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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
44,700 | js_typed_array_with | bluesky950520[P]quickjs/quickjs.c | static JSValue js_typed_array_with(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue arr, val;
JSObject *p;
int64_t idx;
uint32_t len, oldlen, newlen;
p = get_typed_array(ctx, this_val);
if (!p)
return JS_EXCEPTION;
oldlen = p->u.array.count;
if (JS_ToInt64Sat(ctx, &idx, argv[0]))
return JS_EXCEPTION;
val = JS_ToPrimitive(ctx, argv[1], HINT_NUMBER);
if (JS_IsException(val))
return JS_EXCEPTION;
newlen = p->u.array.count;
if (idx < 0)
idx = newlen + idx;
if (idx < 0 || idx >= newlen) {
JS_FreeValue(ctx, val);
return JS_ThrowRangeError(ctx, "invalid array index");
}
len = min_uint32(oldlen, newlen);
arr = js_typed_array_constructor_ta(ctx, JS_UNDEFINED, this_val,
p->class_id, len);
if (JS_IsException(arr)) {
JS_FreeValue(ctx, val);
return JS_EXCEPTION;
}
if (idx < len && JS_SetPropertyInt64(ctx, arr, idx, val) < 0) {
JS_FreeValue(ctx, arr);
return JS_EXCEPTION;
}
return arr;
} | O1 | c | js_typed_array_with:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r13
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq %rsi, 0x8(%rsp)
cmpl $-0x1, %r15d
jne 0x80698
movq 0x8(%rsp), %rbp
movzwl 0x6(%rbp), %eax
addl $-0x15, %eax
cmpw $0xc, %ax
jb 0x806ab
leaq 0x21d72(%rip), %rsi # 0xa2411
xorl %ebp, %ebp
movq %r14, %rdi
xorl %eax, %eax
callq 0x22567
movl $0x6, %ebx
testq %rbp, %rbp
je 0x80795
movl 0x40(%rbp), %eax
movl %eax, 0x1c(%rsp)
movq (%r13), %rdx
movq 0x8(%r13), %rcx
movq %rdx, 0x8(%rsp)
cmpl $-0x9, %ecx
jb 0x806d9
movq 0x8(%rsp), %rax
incl (%rax)
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x277bc
testl %eax, %eax
jne 0x80795
movq 0x10(%r13), %rsi
movq 0x18(%r13), %rdx
movq %rsi, 0x8(%rsp)
cmpl $-0x9, %edx
jb 0x80707
movq 0x8(%rsp), %rax
incl (%rax)
movq %r14, %rdi
movl $0x1, %ecx
callq 0x3dfd7
cmpl $0x6, %edx
je 0x80795
movq %rax, %rsi
movl 0x40(%rbp), %r13d
movq 0x10(%rsp), %rax
testq %rax, %rax
jns 0x80732
addq %r13, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
testq %rax, %rax
js 0x807b2
cmpq %r13, %rax
jge 0x807b2
movq %rax, 0x30(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movl 0x1c(%rsp), %eax
cmpl %r13d, %eax
cmovbl %eax, %r13d
movzwl 0x6(%rbp), %r9d
movl %r13d, (%rsp)
movl $0x3, %edx
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rcx
movq %r15, %r8
callq 0x7eb58
movq %rdx, %r12
cmpl $0x6, %r12d
jne 0x807d1
movq 0x18(%r14), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x1d8c6
xorl %r15d, %r15d
xorl %eax, %eax
orq %rax, %r15
movq %r15, %rax
movq %rbx, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%r14), %rdi
callq 0x1d8c6
leaq 0x1e5a0(%rip), %rsi # 0x9ed62
xorl %r15d, %r15d
movq %r14, %rdi
xorl %eax, %eax
callq 0x20add
jmp 0x80798
movq %rax, %r15
movl %r13d, %eax
movq 0x30(%rsp), %rcx
cmpq %rax, %rcx
jge 0x807fd
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq 0x20(%rsp), %r8
movq 0x28(%rsp), %r9
callq 0x25356
testl %eax, %eax
js 0x80815
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
movq %r15, %rax
andq %rcx, %rax
movl %r15d, %r15d
movq %r12, %rbx
jmp 0x8079a
movq 0x18(%r14), %rdi
movq %r15, %rsi
movq %r12, %rdx
jmp 0x80790
| js_typed_array_with:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r13, r8
mov r15, rdx
mov r12, rsi
mov r14, rdi
mov [rsp+68h+var_60], rsi
cmp r15d, 0FFFFFFFFh
jnz short loc_80698
mov rbp, [rsp+68h+var_60]
movzx eax, word ptr [rbp+6]
add eax, 0FFFFFFEBh
cmp ax, 0Ch
jb short loc_806AB
loc_80698:
lea rsi, aNotATypedarray; "not a TypedArray"
xor ebp, ebp
mov rdi, r14
xor eax, eax
call JS_ThrowTypeError
loc_806AB:
mov ebx, 6
test rbp, rbp
jz loc_80795
mov eax, [rbp+40h]
mov [rsp+68h+var_4C], eax
mov rdx, [r13+0]
mov rcx, [r13+8]
mov [rsp+68h+var_60], rdx
cmp ecx, 0FFFFFFF7h
jb short loc_806D9
mov rax, [rsp+68h+var_60]
inc dword ptr [rax]
loc_806D9:
lea rsi, [rsp+68h+var_58]
mov rdi, r14
call JS_ToInt64SatFree
test eax, eax
jnz loc_80795
mov rsi, [r13+10h]
mov rdx, [r13+18h]
mov [rsp+68h+var_60], rsi
cmp edx, 0FFFFFFF7h
jb short loc_80707
mov rax, [rsp+68h+var_60]
inc dword ptr [rax]
loc_80707:
mov rdi, r14
mov ecx, 1
call JS_ToPrimitiveFree
cmp edx, 6
jz short loc_80795
mov rsi, rax
mov r13d, [rbp+40h]
mov rax, [rsp+68h+var_58]
test rax, rax
jns short loc_80732
add rax, r13
mov [rsp+68h+var_58], rax
loc_80732:
mov rax, [rsp+68h+var_58]
test rax, rax
js short loc_807B2
cmp rax, r13
jge short loc_807B2
mov [rsp+68h+var_38], rax
mov [rsp+68h+var_48], rsi
mov [rsp+68h+var_40], rdx
mov eax, [rsp+68h+var_4C]
cmp eax, r13d
cmovb r13d, eax
movzx r9d, word ptr [rbp+6]
mov [rsp+68h+var_68], r13d
mov edx, 3
mov rdi, r14
xor esi, esi
mov rcx, r12
mov r8, r15
call js_typed_array_constructor_ta
mov r12, rdx
cmp r12d, 6
jnz short loc_807D1
mov rdi, [r14+18h]
mov rsi, [rsp+68h+var_48]
mov rdx, [rsp+68h+var_40]
loc_80790:
call JS_FreeValueRT
loc_80795:
xor r15d, r15d
loc_80798:
xor eax, eax
loc_8079A:
or r15, rax
mov rax, r15
mov rdx, rbx
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_807B2:
mov rdi, [r14+18h]
call JS_FreeValueRT
lea rsi, aInvalidArrayIn; "invalid array index"
xor r15d, r15d
mov rdi, r14
xor eax, eax
call JS_ThrowRangeError
jmp short loc_80798
loc_807D1:
mov r15, rax
mov eax, r13d
mov rcx, [rsp+68h+var_38]
cmp rcx, rax
jge short loc_807FD
mov rdi, r14
mov rsi, r15
mov rdx, r12
mov r8, [rsp+68h+var_48]
mov r9, [rsp+68h+var_40]
call JS_SetPropertyInt64
test eax, eax
js short loc_80815
loc_807FD:
mov rcx, 0FFFFFFFF00000000h
mov rax, r15
and rax, rcx
mov r15d, r15d
mov rbx, r12
jmp short loc_8079A
loc_80815:
mov rdi, [r14+18h]
mov rsi, r15
mov rdx, r12
jmp loc_80790
| unsigned long long js_typed_array_with(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
long long v17; // rbp
_DWORD *v18; // rdx
long long v19; // rcx
double v20; // xmm4_8
double v21; // xmm5_8
unsigned long long v22; // rsi
long long v23; // rdx
_DWORD *v24; // rax
long long v25; // rdx
double v26; // xmm4_8
double v27; // xmm5_8
signed long long v28; // r13
unsigned long long v29; // rax
unsigned long long v30; // rdx
double v31; // xmm4_8
double v32; // xmm5_8
unsigned long long v33; // r12
long long v34; // rdi
_DWORD *v35; // rsi
long long v36; // rdx
unsigned long long v37; // r15
unsigned long long v38; // rax
long long v40; // rdx
long long v41; // rcx
long long v42; // r8
long long v43; // r9
__m128 v44; // xmm4
__m128 v45; // xmm5
char v46; // [rsp+0h] [rbp-68h]
_DWORD *v47; // [rsp+10h] [rbp-58h] BYREF
unsigned int v48; // [rsp+1Ch] [rbp-4Ch]
_DWORD *v49; // [rsp+20h] [rbp-48h]
long long v50; // [rsp+28h] [rbp-40h]
_DWORD *v51; // [rsp+30h] [rbp-38h]
if ( (_DWORD)a3 != -1 || (v17 = a2, (unsigned __int16)(*(_WORD *)(a2 + 6) - 21) >= 0xCu) )
{
v17 = 0LL;
JS_ThrowTypeError(a1, (long long)"not a TypedArray", a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v46);
}
if ( v17 )
{
v48 = *(_DWORD *)(v17 + 64);
v18 = *(_DWORD **)a5;
v19 = *(_QWORD *)(a5 + 8);
if ( (unsigned int)v19 >= 0xFFFFFFF7 )
++**(_DWORD **)a5;
if ( !(unsigned int)JS_ToInt64SatFree(a1, (unsigned long long *)&v47, (long long)v18, v19) )
{
v22 = *(_QWORD *)(a5 + 16);
v23 = *(_QWORD *)(a5 + 24);
if ( (unsigned int)v23 >= 0xFFFFFFF7 )
++**(_DWORD **)(a5 + 16);
v24 = (_DWORD *)JS_ToPrimitiveFree(a1, v22, v23, 1, a7, a8, a9, a10, v20, v21, a13, a14);
if ( (_DWORD)v25 != 6 )
{
v28 = *(unsigned int *)(v17 + 64);
if ( (long long)v47 < 0 )
v47 = (_DWORD *)((char *)v47 + v28);
if ( (long long)v47 < 0 || (long long)v47 >= v28 )
{
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v24, v25);
v37 = 0LL;
JS_ThrowRangeError(
a1,
(long long)"invalid array index",
v40,
v41,
v42,
v43,
a7,
a8,
a9,
a10,
v44,
v45,
a13,
a14,
v46);
goto LABEL_21;
}
v51 = v47;
v49 = v24;
v50 = v25;
if ( v48 < (unsigned int)v28 )
LODWORD(v28) = v48;
v29 = js_typed_array_constructor_ta(
a1,
0LL,
3LL,
a2,
a3,
*(unsigned __int16 *)(v17 + 6),
a7,
a8,
a9,
a10,
v26,
v27,
a13,
a14,
v28);
v33 = v30;
if ( (_DWORD)v30 == 6 )
{
v34 = *(_QWORD *)(a1 + 24);
v35 = v49;
v36 = v50;
}
else
{
v37 = v29;
if ( (long long)v51 >= (unsigned int)v28
|| (int)JS_SetPropertyInt64(
a1,
v29,
v30,
v51,
v49,
v50,
*(double *)a7.m128_u64,
a8,
a9,
a10,
v31,
v32,
a13,
a14) >= 0 )
{
v38 = v37 & 0xFFFFFFFF00000000LL;
v37 = (unsigned int)v37;
return v38 | v37;
}
v34 = *(_QWORD *)(a1 + 24);
v35 = (_DWORD *)v37;
v36 = v33;
}
JS_FreeValueRT(v34, v35, v36);
}
}
}
v37 = 0LL;
LABEL_21:
v38 = 0LL;
return v38 | v37;
}
| js_typed_array_with:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R13,R8
MOV R15,RDX
MOV R12,RSI
MOV R14,RDI
MOV qword ptr [RSP + 0x8],RSI
CMP R15D,-0x1
JNZ 0x00180698
MOV RBP,qword ptr [RSP + 0x8]
MOVZX EAX,word ptr [RBP + 0x6]
ADD EAX,-0x15
CMP AX,0xc
JC 0x001806ab
LAB_00180698:
LEA RSI,[0x1a2411]
XOR EBP,EBP
MOV RDI,R14
XOR EAX,EAX
CALL 0x00122567
LAB_001806ab:
MOV EBX,0x6
TEST RBP,RBP
JZ 0x00180795
MOV EAX,dword ptr [RBP + 0x40]
MOV dword ptr [RSP + 0x1c],EAX
MOV RDX,qword ptr [R13]
MOV RCX,qword ptr [R13 + 0x8]
MOV qword ptr [RSP + 0x8],RDX
CMP ECX,-0x9
JC 0x001806d9
MOV RAX,qword ptr [RSP + 0x8]
INC dword ptr [RAX]
LAB_001806d9:
LEA RSI,[RSP + 0x10]
MOV RDI,R14
CALL 0x001277bc
TEST EAX,EAX
JNZ 0x00180795
MOV RSI,qword ptr [R13 + 0x10]
MOV RDX,qword ptr [R13 + 0x18]
MOV qword ptr [RSP + 0x8],RSI
CMP EDX,-0x9
JC 0x00180707
MOV RAX,qword ptr [RSP + 0x8]
INC dword ptr [RAX]
LAB_00180707:
MOV RDI,R14
MOV ECX,0x1
CALL 0x0013dfd7
CMP EDX,0x6
JZ 0x00180795
MOV RSI,RAX
MOV R13D,dword ptr [RBP + 0x40]
MOV RAX,qword ptr [RSP + 0x10]
TEST RAX,RAX
JNS 0x00180732
ADD RAX,R13
MOV qword ptr [RSP + 0x10],RAX
LAB_00180732:
MOV RAX,qword ptr [RSP + 0x10]
TEST RAX,RAX
JS 0x001807b2
CMP RAX,R13
JGE 0x001807b2
MOV qword ptr [RSP + 0x30],RAX
MOV qword ptr [RSP + 0x20],RSI
MOV qword ptr [RSP + 0x28],RDX
MOV EAX,dword ptr [RSP + 0x1c]
CMP EAX,R13D
CMOVC R13D,EAX
MOVZX R9D,word ptr [RBP + 0x6]
MOV dword ptr [RSP],R13D
MOV EDX,0x3
MOV RDI,R14
XOR ESI,ESI
MOV RCX,R12
MOV R8,R15
CALL 0x0017eb58
MOV R12,RDX
CMP R12D,0x6
JNZ 0x001807d1
MOV RDI,qword ptr [R14 + 0x18]
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
LAB_00180790:
CALL 0x0011d8c6
LAB_00180795:
XOR R15D,R15D
LAB_00180798:
XOR EAX,EAX
LAB_0018079a:
OR R15,RAX
MOV RAX,R15
MOV RDX,RBX
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001807b2:
MOV RDI,qword ptr [R14 + 0x18]
CALL 0x0011d8c6
LEA RSI,[0x19ed62]
XOR R15D,R15D
MOV RDI,R14
XOR EAX,EAX
CALL 0x00120add
JMP 0x00180798
LAB_001807d1:
MOV R15,RAX
MOV EAX,R13D
MOV RCX,qword ptr [RSP + 0x30]
CMP RCX,RAX
JGE 0x001807fd
MOV RDI,R14
MOV RSI,R15
MOV RDX,R12
MOV R8,qword ptr [RSP + 0x20]
MOV R9,qword ptr [RSP + 0x28]
CALL 0x00125356
TEST EAX,EAX
JS 0x00180815
LAB_001807fd:
MOV RCX,-0x100000000
MOV RAX,R15
AND RAX,RCX
MOV R15D,R15D
MOV RBX,R12
JMP 0x0018079a
LAB_00180815:
MOV RDI,qword ptr [R14 + 0x18]
MOV RSI,R15
MOV RDX,R12
JMP 0x00180790
|
int1 [16]
js_typed_array_with(long param_1,long param_2,int8 param_3,int8 param_4,
int8 *param_5)
{
int *piVar1;
int iVar2;
ulong uVar3;
int8 uVar4;
long lVar5;
uint uVar6;
ulong uVar7;
int1 auVar8 [16];
long local_58;
uint local_4c;
int1 local_48 [16];
long local_38;
if (((int)param_3 != -1) || (lVar5 = param_2, 0xb < (ushort)(*(short *)(param_2 + 6) - 0x15U))) {
lVar5 = 0;
JS_ThrowTypeError(param_1,"not a TypedArray");
}
if (lVar5 != 0) {
local_4c = *(uint *)(lVar5 + 0x40);
if (0xfffffff6 < (uint)param_5[1]) {
*(int *)*param_5 = *(int *)*param_5 + 1;
}
iVar2 = JS_ToInt64SatFree(param_1,&local_58);
if (iVar2 == 0) {
piVar1 = (int *)param_5[2];
uVar4 = param_5[3];
if (0xfffffff6 < (uint)uVar4) {
*piVar1 = *piVar1 + 1;
}
local_48 = JS_ToPrimitiveFree(param_1,piVar1,uVar4,1);
if (local_48._8_4_ != 6) {
uVar6 = *(uint *)(lVar5 + 0x40);
if (local_58 < 0) {
local_58 = local_58 + (ulong)uVar6;
}
if ((local_58 < 0) || ((long)(ulong)uVar6 <= local_58)) {
JS_FreeValueRT(*(int8 *)(param_1 + 0x18));
JS_ThrowRangeError(param_1,"invalid array index");
}
else {
local_38 = local_58;
if (local_4c < uVar6) {
uVar6 = local_4c;
}
auVar8 = js_typed_array_constructor_ta
(param_1,0,3,param_2,param_3,*(int2 *)(lVar5 + 6),uVar6);
uVar4 = auVar8._8_8_;
uVar7 = auVar8._0_8_;
if (auVar8._8_4_ != 6) {
if (local_38 < (long)(ulong)uVar6) {
iVar2 = JS_SetPropertyInt64(param_1,uVar7,uVar4,local_38,local_48._0_8_,local_48._8_8_
);
if (iVar2 < 0) {
uVar4 = *(int8 *)(param_1 + 0x18);
goto LAB_00180790;
}
}
uVar3 = uVar7 & 0xffffffff00000000;
uVar7 = uVar7 & 0xffffffff;
goto LAB_0018079a;
}
uVar4 = *(int8 *)(param_1 + 0x18);
auVar8 = local_48;
LAB_00180790:
JS_FreeValueRT(uVar4,auVar8._0_8_,auVar8._8_8_);
}
}
}
}
uVar7 = 0;
uVar3 = 0;
uVar4 = 6;
LAB_0018079a:
auVar8._8_8_ = uVar4;
auVar8._0_8_ = uVar7 | uVar3;
return auVar8;
}
| |
44,701 | remove_io_thread | eloqsql/mysys/mf_iocache.c | void remove_io_thread(IO_CACHE *cache)
{
IO_CACHE_SHARE *cshare= cache->share;
uint total;
DBUG_ENTER("remove_io_thread");
/* If the writer goes, it needs to flush the write cache. */
if (cache == cshare->source_cache)
flush_io_cache(cache);
mysql_mutex_lock(&cshare->mutex);
DBUG_PRINT("io_cache_share", ("%s: %p",
(cache == cshare->source_cache) ?
"writer" : "reader", cache));
/* Remove from share. */
total= --cshare->total_threads;
DBUG_PRINT("io_cache_share", ("remaining threads: %u", total));
/* Detach from share. */
cache->share= NULL;
/* If the writer goes, let the readers know. */
if (cache == cshare->source_cache)
{
DBUG_PRINT("io_cache_share", ("writer leaves"));
cshare->source_cache= NULL;
}
/* If all threads are waiting for me to join the lock, wake them. */
if (!--cshare->running_threads)
{
DBUG_PRINT("io_cache_share", ("the last running thread leaves, wake all"));
mysql_cond_signal(&cshare->cond_writer);
mysql_cond_broadcast(&cshare->cond);
}
mysql_mutex_unlock(&cshare->mutex);
if (!total)
{
DBUG_PRINT("io_cache_share", ("last thread removed, destroy share"));
mysql_cond_destroy (&cshare->cond_writer);
mysql_cond_destroy (&cshare->cond);
mysql_mutex_destroy(&cshare->mutex);
}
DBUG_VOID_RETURN;
} | O0 | c | remove_io_thread:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0xc0(%rcx), %rax
jne 0xebbba
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xeb0c0
movq -0x10(%rbp), %rdi
leaq 0x796be(%rip), %rsi # 0x165283
movl $0x392, %edx # imm = 0x392
callq 0xebca0
jmp 0xebbd1
movq -0x10(%rbp), %rcx
movl 0xdc(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0xdc(%rcx)
movl %eax, -0x14(%rbp)
jmp 0xebbe9
movq -0x8(%rbp), %rax
movq $0x0, 0x98(%rax)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0xc0(%rcx), %rax
jne 0xebc1c
jmp 0xebc0b
jmp 0xebc0d
movq -0x10(%rbp), %rax
movq $0x0, 0xc0(%rax)
movq -0x10(%rbp), %rcx
movl 0xd8(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0xd8(%rcx)
cmpl $0x0, %eax
jne 0xebc55
jmp 0xebc36
jmp 0xebc38
movq -0x10(%rbp), %rdi
addq $0x80, %rdi
callq 0xebd10
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
callq 0xebd70
movq -0x10(%rbp), %rdi
callq 0xebdd0
cmpl $0x0, -0x14(%rbp)
jne 0xebc8e
jmp 0xebc66
jmp 0xebc68
movq -0x10(%rbp), %rdi
addq $0x80, %rdi
callq 0xebe30
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
callq 0xebe30
movq -0x10(%rbp), %rdi
callq 0xebea0
jmp 0xebc90
jmp 0xebc92
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| remove_io_thread:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov rax, [rax+98h]
mov [rbp+var_10], rax
mov rax, [rbp+var_8]
mov rcx, [rbp+var_10]
cmp rax, [rcx+0C0h]
jnz short loc_EBBBA
mov rdi, [rbp+var_8]
mov esi, 1
call my_b_flush_io_cache
loc_EBBBA:
mov rdi, [rbp+var_10]
lea rsi, aWorkspaceLlm4b_38; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 392h
call inline_mysql_mutex_lock_24
jmp short $+2
loc_EBBD1:
mov rcx, [rbp+var_10]
mov eax, [rcx+0DCh]
add eax, 0FFFFFFFFh
mov [rcx+0DCh], eax
mov [rbp+var_14], eax
jmp short $+2
loc_EBBE9:
mov rax, [rbp+var_8]
mov qword ptr [rax+98h], 0
mov rax, [rbp+var_8]
mov rcx, [rbp+var_10]
cmp rax, [rcx+0C0h]
jnz short loc_EBC1C
jmp short $+2
loc_EBC0B:
jmp short $+2
loc_EBC0D:
mov rax, [rbp+var_10]
mov qword ptr [rax+0C0h], 0
loc_EBC1C:
mov rcx, [rbp+var_10]
mov eax, [rcx+0D8h]
add eax, 0FFFFFFFFh
mov [rcx+0D8h], eax
cmp eax, 0
jnz short loc_EBC55
jmp short $+2
loc_EBC36:
jmp short $+2
loc_EBC38:
mov rdi, [rbp+var_10]
add rdi, 80h
call inline_mysql_cond_signal_1
mov rdi, [rbp+var_10]
add rdi, 48h ; 'H'
call inline_mysql_cond_broadcast_3
loc_EBC55:
mov rdi, [rbp+var_10]
call inline_mysql_mutex_unlock_25
cmp [rbp+var_14], 0
jnz short loc_EBC8E
jmp short $+2
loc_EBC66:
jmp short $+2
loc_EBC68:
mov rdi, [rbp+var_10]
add rdi, 80h
call inline_mysql_cond_destroy_3
mov rdi, [rbp+var_10]
add rdi, 48h ; 'H'
call inline_mysql_cond_destroy_3
mov rdi, [rbp+var_10]
call inline_mysql_mutex_destroy_8
loc_EBC8E:
jmp short $+2
loc_EBC90:
jmp short $+2
loc_EBC92:
add rsp, 20h
pop rbp
retn
| long long remove_io_thread(long long a1)
{
int v1; // eax
int v2; // eax
long long result; // rax
int v4; // [rsp+Ch] [rbp-14h]
long long v5; // [rsp+10h] [rbp-10h]
v5 = *(_QWORD *)(a1 + 152);
if ( a1 == *(_QWORD *)(v5 + 192) )
my_b_flush_io_cache(a1, 1);
inline_mysql_mutex_lock_24(v5, "/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c", 914LL);
v1 = *(_DWORD *)(v5 + 220) - 1;
*(_DWORD *)(v5 + 220) = v1;
v4 = v1;
*(_QWORD *)(a1 + 152) = 0LL;
if ( a1 == *(_QWORD *)(v5 + 192) )
*(_QWORD *)(v5 + 192) = 0LL;
v2 = *(_DWORD *)(v5 + 216) - 1;
*(_DWORD *)(v5 + 216) = v2;
if ( !v2 )
{
inline_mysql_cond_signal_1(v5 + 128);
inline_mysql_cond_broadcast_3(v5 + 72);
}
result = inline_mysql_mutex_unlock_25(v5);
if ( !v4 )
{
inline_mysql_cond_destroy_3(v5 + 128);
inline_mysql_cond_destroy_3(v5 + 72);
return inline_mysql_mutex_destroy_8(v5);
}
return result;
}
| remove_io_thread:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x98]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0xc0]
JNZ 0x001ebbba
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,0x1
CALL 0x001eb0c0
LAB_001ebbba:
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x265283]
MOV EDX,0x392
CALL 0x001ebca0
JMP 0x001ebbd1
LAB_001ebbd1:
MOV RCX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RCX + 0xdc]
ADD EAX,-0x1
MOV dword ptr [RCX + 0xdc],EAX
MOV dword ptr [RBP + -0x14],EAX
JMP 0x001ebbe9
LAB_001ebbe9:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x98],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0xc0]
JNZ 0x001ebc1c
JMP 0x001ebc0b
LAB_001ebc0b:
JMP 0x001ebc0d
LAB_001ebc0d:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0xc0],0x0
LAB_001ebc1c:
MOV RCX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RCX + 0xd8]
ADD EAX,-0x1
MOV dword ptr [RCX + 0xd8],EAX
CMP EAX,0x0
JNZ 0x001ebc55
JMP 0x001ebc36
LAB_001ebc36:
JMP 0x001ebc38
LAB_001ebc38:
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x80
CALL 0x001ebd10
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x48
CALL 0x001ebd70
LAB_001ebc55:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001ebdd0
CMP dword ptr [RBP + -0x14],0x0
JNZ 0x001ebc8e
JMP 0x001ebc66
LAB_001ebc66:
JMP 0x001ebc68
LAB_001ebc68:
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x80
CALL 0x001ebe30
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x48
CALL 0x001ebe30
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001ebea0
LAB_001ebc8e:
JMP 0x001ebc90
LAB_001ebc90:
JMP 0x001ebc92
LAB_001ebc92:
ADD RSP,0x20
POP RBP
RET
|
void remove_io_thread(long param_1)
{
long lVar1;
int iVar2;
int iVar3;
lVar1 = *(long *)(param_1 + 0x98);
if (param_1 == *(long *)(lVar1 + 0xc0)) {
my_b_flush_io_cache(param_1,1);
}
inline_mysql_mutex_lock(lVar1,"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",0x392)
;
iVar2 = *(int *)(lVar1 + 0xdc) + -1;
*(int *)(lVar1 + 0xdc) = iVar2;
*(int8 *)(param_1 + 0x98) = 0;
if (param_1 == *(long *)(lVar1 + 0xc0)) {
*(int8 *)(lVar1 + 0xc0) = 0;
}
iVar3 = *(int *)(lVar1 + 0xd8) + -1;
*(int *)(lVar1 + 0xd8) = iVar3;
if (iVar3 == 0) {
inline_mysql_cond_signal(lVar1 + 0x80);
inline_mysql_cond_broadcast(lVar1 + 0x48);
}
inline_mysql_mutex_unlock(lVar1);
if (iVar2 == 0) {
inline_mysql_cond_destroy(lVar1 + 0x80);
inline_mysql_cond_destroy(lVar1 + 0x48);
inline_mysql_mutex_destroy(lVar1);
}
return;
}
| |
44,702 | ggml_view_4d | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c | struct ggml_tensor * ggml_view_4d(
struct ggml_context * ctx,
struct ggml_tensor * a,
int64_t ne0,
int64_t ne1,
int64_t ne2,
int64_t ne3,
size_t nb1,
size_t nb2,
size_t nb3,
size_t offset) {
const int64_t ne[4] = { ne0, ne1, ne2, ne3 };
struct ggml_tensor * result = ggml_view_impl(ctx, a, 4, ne, offset);
result->nb[1] = nb1;
result->nb[2] = nb2;
result->nb[3] = nb3;
return result;
} | O0 | c | ggml_view_4d:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rcx
movq 0x28(%rbp), %r8
movl $0x4, %edx
callq 0x4fd70
movq %rax, -0x58(%rbp)
movq 0x10(%rbp), %rcx
movq -0x58(%rbp), %rax
movq %rcx, 0x38(%rax)
movq 0x18(%rbp), %rcx
movq -0x58(%rbp), %rax
movq %rcx, 0x40(%rax)
movq 0x20(%rbp), %rcx
movq -0x58(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
| ggml_view_4d:
push rbp
mov rbp, rsp
sub rsp, 60h
mov rax, [rbp+arg_18]
mov rax, [rbp+arg_10]
mov rax, [rbp+arg_8]
mov rax, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov rax, [rbp+var_18]
mov [rbp+var_50], rax
mov rax, [rbp+var_20]
mov [rbp+var_48], rax
mov rax, [rbp+var_28]
mov [rbp+var_40], rax
mov rax, [rbp+var_30]
mov [rbp+var_38], rax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
lea rcx, [rbp+var_50]
mov r8, [rbp+arg_18]
mov edx, 4
call ggml_view_impl
mov [rbp+var_58], rax
mov rcx, [rbp+arg_0]
mov rax, [rbp+var_58]
mov [rax+38h], rcx
mov rcx, [rbp+arg_8]
mov rax, [rbp+var_58]
mov [rax+40h], rcx
mov rcx, [rbp+arg_10]
mov rax, [rbp+var_58]
mov [rax+48h], rcx
mov rax, [rbp+var_58]
add rsp, 60h
pop rbp
retn
| _QWORD * ggml_view_4d(
long long a1,
unsigned int *a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
double a11,
double a12,
__m128 a13,
__m128 a14,
long long a15,
long long a16,
long long a17,
long long a18)
{
_QWORD *result; // rax
long long v19[10]; // [rsp+10h] [rbp-50h] BYREF
v19[9] = a1;
v19[8] = (long long)a2;
v19[7] = a3;
v19[6] = a4;
v19[5] = a5;
v19[4] = a6;
v19[0] = a3;
v19[1] = a4;
v19[2] = a5;
v19[3] = a6;
result = (_QWORD *)ggml_view_impl(a1, a2, 4, v19, a18, a7, a8, a9, a10, a11, a12, a13, a14);
result[7] = a15;
result[8] = a16;
result[9] = a17;
return result;
}
| ggml_view_4d:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV RAX,qword ptr [RBP + 0x28]
MOV RAX,qword ptr [RBP + 0x20]
MOV RAX,qword ptr [RBP + 0x18]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
LEA RCX,[RBP + -0x50]
MOV R8,qword ptr [RBP + 0x28]
MOV EDX,0x4
CALL 0x0014fd70
MOV qword ptr [RBP + -0x58],RAX
MOV RCX,qword ptr [RBP + 0x10]
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RAX + 0x38],RCX
MOV RCX,qword ptr [RBP + 0x18]
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RAX + 0x40],RCX
MOV RCX,qword ptr [RBP + 0x20]
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RAX + 0x48],RCX
MOV RAX,qword ptr [RBP + -0x58]
ADD RSP,0x60
POP RBP
RET
|
long ggml_view_4d(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
int8 param_9,int8 param_10)
{
long lVar1;
int8 local_58;
int8 local_50;
int8 local_48;
int8 local_40;
int8 local_38;
int8 local_30;
int8 local_28;
int8 local_20;
int8 local_18;
int8 local_10;
local_58 = param_3;
local_50 = param_4;
local_48 = param_5;
local_40 = param_6;
local_38 = param_6;
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
lVar1 = ggml_view_impl(param_1,param_2,4,&local_58,param_10);
*(int8 *)(lVar1 + 0x38) = param_7;
*(int8 *)(lVar1 + 0x40) = param_8;
*(int8 *)(lVar1 + 0x48) = param_9;
return lVar1;
}
| |
44,703 | ggml_view_4d | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c | struct ggml_tensor * ggml_view_4d(
struct ggml_context * ctx,
struct ggml_tensor * a,
int64_t ne0,
int64_t ne1,
int64_t ne2,
int64_t ne3,
size_t nb1,
size_t nb2,
size_t nb3,
size_t offset) {
const int64_t ne[4] = { ne0, ne1, ne2, ne3 };
struct ggml_tensor * result = ggml_view_impl(ctx, a, 4, ne, offset);
result->nb[1] = nb1;
result->nb[2] = nb2;
result->nb[3] = nb3;
return result;
} | O1 | c | ggml_view_4d:
pushq %rbx
subq $0x20, %rsp
movq 0x40(%rsp), %rbx
movq 0x48(%rsp), %rax
movq %rsp, %r10
movq %rdx, (%r10)
movq %rcx, 0x8(%r10)
movq %r8, 0x10(%r10)
movq %r9, 0x18(%r10)
movl $0x4, %edx
movq %r10, %rcx
movq %rax, %r8
callq 0x1dab9
movaps 0x30(%rsp), %xmm0
movups %xmm0, 0x38(%rax)
movq %rbx, 0x48(%rax)
addq $0x20, %rsp
popq %rbx
retq
| ggml_view_4d:
push rbx
sub rsp, 20h
mov rbx, [rsp+28h+arg_10]
mov rax, [rsp+28h+arg_18]
mov r10, rsp
mov [r10], rdx
mov [r10+8], rcx
mov [r10+10h], r8
mov [r10+18h], r9
mov edx, 4
mov rcx, r10
mov r8, rax
call ggml_view_impl
movaps xmm0, [rsp+28h+arg_0]
movups xmmword ptr [rax+38h], xmm0
mov [rax+48h], rbx
add rsp, 20h
pop rbx
retn
| long long ggml_view_4d(
long long a1,
unsigned int *a2,
long long a3,
long long a4,
long long a5,
long long a6,
double a7,
__int128 a8,
long long a9,
long long a10)
{
long long result; // rax
long long v11[5]; // [rsp+0h] [rbp-28h] BYREF
v11[0] = a3;
v11[1] = a4;
v11[2] = a5;
v11[3] = a6;
result = ggml_view_impl(a1, a2, 4, v11, a10, a7);
*(_OWORD *)(result + 56) = a8;
*(_QWORD *)(result + 72) = a9;
return result;
}
| ggml_view_4d:
PUSH RBX
SUB RSP,0x20
MOV RBX,qword ptr [RSP + 0x40]
MOV RAX,qword ptr [RSP + 0x48]
MOV R10,RSP
MOV qword ptr [R10],RDX
MOV qword ptr [R10 + 0x8],RCX
MOV qword ptr [R10 + 0x10],R8
MOV qword ptr [R10 + 0x18],R9
MOV EDX,0x4
MOV RCX,R10
MOV R8,RAX
CALL 0x0011dab9
MOVAPS XMM0,xmmword ptr [RSP + 0x30]
MOVUPS xmmword ptr [RAX + 0x38],XMM0
MOV qword ptr [RAX + 0x48],RBX
ADD RSP,0x20
POP RBX
RET
|
void ggml_view_4d(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
int8 param_9,int8 param_10)
{
long lVar1;
int8 local_28;
int8 local_20;
int8 local_18;
int8 local_10;
local_28 = param_3;
local_20 = param_4;
local_18 = param_5;
local_10 = param_6;
lVar1 = ggml_view_impl(param_1,param_2,4,&local_28,param_10);
*(int8 *)(lVar1 + 0x38) = param_7;
*(int8 *)(lVar1 + 0x40) = param_8;
*(int8 *)(lVar1 + 0x48) = param_9;
return;
}
| |
44,704 | ggml_view_4d | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c | struct ggml_tensor * ggml_view_4d(
struct ggml_context * ctx,
struct ggml_tensor * a,
int64_t ne0,
int64_t ne1,
int64_t ne2,
int64_t ne3,
size_t nb1,
size_t nb2,
size_t nb3,
size_t offset) {
const int64_t ne[4] = { ne0, ne1, ne2, ne3 };
struct ggml_tensor * result = ggml_view_impl(ctx, a, 4, ne, offset);
result->nb[1] = nb1;
result->nb[2] = nb2;
result->nb[3] = nb3;
return result;
} | O3 | c | ggml_view_4d:
pushq %rbx
subq $0x20, %rsp
movq 0x40(%rsp), %rbx
movq 0x48(%rsp), %rax
movq %rsp, %r10
movq %rdx, (%r10)
movq %rcx, 0x8(%r10)
movq %r8, 0x10(%r10)
movq %r9, 0x18(%r10)
movl $0x4, %edx
movq %r10, %rcx
movq %rax, %r8
callq 0x1c7ce
movaps 0x30(%rsp), %xmm0
movups %xmm0, 0x38(%rax)
movq %rbx, 0x48(%rax)
addq $0x20, %rsp
popq %rbx
retq
| ggml_view_4d:
push rbx
sub rsp, 20h
mov rbx, [rsp+28h+arg_10]
mov rax, [rsp+28h+arg_18]
mov r10, rsp
mov [r10], rdx
mov [r10+8], rcx
mov [r10+10h], r8
mov [r10+18h], r9
mov edx, 4
mov rcx, r10
mov r8, rax
call ggml_view_impl
movaps xmm0, [rsp+28h+arg_0]
movups xmmword ptr [rax+38h], xmm0
mov [rax+48h], rbx
add rsp, 20h
pop rbx
retn
| long long ggml_view_4d(
long long a1,
unsigned int *a2,
long long a3,
long long a4,
long long a5,
long long a6,
double a7,
__int128 a8,
long long a9,
long long a10)
{
long long result; // rax
long long v11[5]; // [rsp+0h] [rbp-28h] BYREF
v11[0] = a3;
v11[1] = a4;
v11[2] = a5;
v11[3] = a6;
result = ggml_view_impl(a1, a2, 4u, v11, a10, a7);
*(_OWORD *)(result + 56) = a8;
*(_QWORD *)(result + 72) = a9;
return result;
}
| ggml_view_4d:
PUSH RBX
SUB RSP,0x20
MOV RBX,qword ptr [RSP + 0x40]
MOV RAX,qword ptr [RSP + 0x48]
MOV R10,RSP
MOV qword ptr [R10],RDX
MOV qword ptr [R10 + 0x8],RCX
MOV qword ptr [R10 + 0x10],R8
MOV qword ptr [R10 + 0x18],R9
MOV EDX,0x4
MOV RCX,R10
MOV R8,RAX
CALL 0x0011c7ce
MOVAPS XMM0,xmmword ptr [RSP + 0x30]
MOVUPS xmmword ptr [RAX + 0x38],XMM0
MOV qword ptr [RAX + 0x48],RBX
ADD RSP,0x20
POP RBX
RET
|
void ggml_view_4d(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
int8 param_9,int8 param_10)
{
long lVar1;
int8 local_28;
int8 local_20;
int8 local_18;
int8 local_10;
local_28 = param_3;
local_20 = param_4;
local_18 = param_5;
local_10 = param_6;
lVar1 = ggml_view_impl(param_1,param_2,4,&local_28,param_10);
*(int8 *)(lVar1 + 0x38) = param_7;
*(int8 *)(lVar1 + 0x40) = param_8;
*(int8 *)(lVar1 + 0x48) = param_9;
return;
}
| |
44,705 | 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>::size() const | monkey531[P]llama/common/json.hpp | size_type size() const noexcept
{
switch (m_data.m_type)
{
case value_t::null:
{
// null values are empty
return 0;
}
case value_t::array:
{
// delegate call to array_t::size()
return m_data.m_value.array->size();
}
case value_t::object:
{
// delegate call to object_t::size()
return m_data.m_value.object->size();
}
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:
{
// all other types have size 1
return 1;
}
}
} | O1 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::size() const:
movzbl (%rdi), %eax
testl %eax, %eax
je 0x5cdd6
cmpl $0x1, %eax
je 0x5cdb3
cmpl $0x2, %eax
jne 0x5cdd1
movq 0x8(%rdi), %rcx
movq 0x8(%rcx), %rax
subq (%rcx), %rax
sarq $0x4, %rax
retq
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x4, %rcx
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
retq
movl $0x1, %eax
retq
nop
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4sizeEv:
movzx eax, byte ptr [rdi]
test eax, eax
jz short locret_5CDD6
cmp eax, 1
jz short loc_5CDB3
cmp eax, 2
jnz short loc_5CDD1
mov rcx, [rdi+8]
mov rax, [rcx+8]
sub rax, [rcx]
sar rax, 4
retn
loc_5CDB3:
mov rax, [rdi+8]
mov rcx, [rax+8]
sub rcx, [rax]
sar rcx, 4
mov rax, 0AAAAAAAAAAAAAAABh
imul rax, rcx
retn
loc_5CDD1:
mov eax, 1
locret_5CDD6:
retn
| long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::size(
unsigned __int8 *a1)
{
long long result; // rax
result = *a1;
if ( *a1 )
{
if ( (_DWORD)result == 1 )
{
return 0xAAAAAAAAAAAAAAABLL * ((long long)(*(_QWORD *)(*((_QWORD *)a1 + 1) + 8LL) - **((_QWORD **)a1 + 1)) >> 4);
}
else if ( (_DWORD)result == 2 )
{
return (long long)(*(_QWORD *)(*((_QWORD *)a1 + 1) + 8LL) - **((_QWORD **)a1 + 1)) >> 4;
}
else
{
return 1LL;
}
}
return result;
}
| size:
MOVZX EAX,byte ptr [RDI]
TEST EAX,EAX
JZ 0x0015cdd6
CMP EAX,0x1
JZ 0x0015cdb3
CMP EAX,0x2
JNZ 0x0015cdd1
MOV RCX,qword ptr [RDI + 0x8]
MOV RAX,qword ptr [RCX + 0x8]
SUB RAX,qword ptr [RCX]
SAR RAX,0x4
RET
LAB_0015cdb3:
MOV RAX,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RAX + 0x8]
SUB RCX,qword ptr [RAX]
SAR RCX,0x4
MOV RAX,-0x5555555555555555
IMUL RAX,RCX
RET
LAB_0015cdd1:
MOV EAX,0x1
LAB_0015cdd6:
RET
|
/* 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>::size() const */
ulong __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::size(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this)
{
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
bVar1;
ulong uVar2;
bVar1 = *this;
uVar2 = (ulong)(byte)bVar1;
if (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>
)0x0) {
if (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>
)0x1) {
return ((*(long **)(this + 8))[1] - **(long **)(this + 8) >> 4) * -0x5555555555555555;
}
if (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>
)0x2) {
return (*(long **)(this + 8))[1] - **(long **)(this + 8) >> 4;
}
uVar2 = 1;
}
return uVar2;
}
| |
44,706 | ps_fetch_datetime | eloqsql/libmariadb/libmariadb/ma_stmt_codec.c | static
void ps_fetch_datetime(MYSQL_BIND *r_param, const MYSQL_FIELD * field,
unsigned char **row)
{
MYSQL_TIME *t= (MYSQL_TIME *)r_param->buffer;
unsigned int len= net_field_length(row);
switch (r_param->buffer_type) {
case MYSQL_TYPE_DATETIME:
case MYSQL_TYPE_TIMESTAMP:
convert_to_datetime(t, row, len, field->type);
break;
case MYSQL_TYPE_DATE:
convert_to_datetime(t, row, len, field->type);
break;
case MYSQL_TYPE_TIME:
convert_to_datetime(t, row, len, field->type);
t->year= t->day= t->month= 0;
break;
case MYSQL_TYPE_YEAR:
{
MYSQL_TIME tm;
convert_to_datetime(&tm, row, len, field->type);
shortstore(r_param->buffer, tm.year);
break;
}
default:
{
char dtbuffer[60];
MYSQL_TIME tm;
size_t length;
convert_to_datetime(&tm, row, len, field->type);
switch(field->type) {
case MYSQL_TYPE_DATE:
length= sprintf(dtbuffer, "%04u-%02u-%02u", tm.year, tm.month, tm.day);
break;
case MYSQL_TYPE_TIME:
length= sprintf(dtbuffer, "%s%02u:%02u:%02u", (tm.neg ? "-" : ""), tm.hour, tm.minute, tm.second);
if (field->decimals && field->decimals <= 6)
{
char ms[8];
sprintf(ms, ".%06lu", tm.second_part);
if (field->decimals < 6)
ms[field->decimals + 1]= 0;
length+= strlen(ms);
strcat(dtbuffer, ms);
}
break;
case MYSQL_TYPE_DATETIME:
case MYSQL_TYPE_TIMESTAMP:
length= sprintf(dtbuffer, "%04u-%02u-%02u %02u:%02u:%02u", tm.year, tm.month, tm.day, tm.hour, tm.minute, tm.second);
if (field->decimals && field->decimals <= 6)
{
char ms[8];
sprintf(ms, ".%06lu", tm.second_part);
if (field->decimals < 6)
ms[field->decimals + 1]= 0;
length+= strlen(ms);
strcat(dtbuffer, ms);
}
break;
default:
dtbuffer[0]= 0;
length= 0;
break;
}
convert_froma_string(r_param, dtbuffer, length);
break;
}
}
(*row) += len;
} | O3 | c | ps_fetch_datetime:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq 0x10(%rdi), %r13
movq %rdx, %rdi
callq 0x72f15
movq %rax, %r14
movl 0x60(%r15), %eax
addl $-0x7, %eax
cmpl $0x6, %eax
ja 0x81720
leaq 0x952f9(%rip), %rcx # 0x1169f8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x70(%r12), %ecx
movq %r13, %rdi
movq %rbx, %rsi
movl %r14d, %edx
callq 0x822f5
jmp 0x8191f
movl 0x70(%r12), %r13d
leaq -0xa0(%rbp), %rdi
movq %rbx, %rsi
movl %r14d, %edx
movl %r13d, %ecx
callq 0x822f5
addl $-0x7, %r13d
cmpl $0x5, %r13d
ja 0x81909
leaq 0x952c5(%rip), %rax # 0x116a14
movslq (%rax,%r13,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl -0xa0(%rbp), %r8d
movl -0x9c(%rbp), %r9d
movl -0x98(%rbp), %eax
movq %rax, -0xa8(%rbp)
movl -0x94(%rbp), %r11d
movl -0x90(%rbp), %r13d
movl -0x8c(%rbp), %r10d
leaq 0x8decd(%rip), %rcx # 0x10f65c
leaq -0x70(%rbp), %rdi
movl $0x3c, %edx
movl $0x1, %esi
xorl %eax, %eax
pushq %r10
pushq %r13
pushq %r11
pushq -0xa8(%rbp)
callq 0x5fea0
addq $0x20, %rsp
jmp 0x8185d
movl 0x70(%r12), %ecx
movq %r13, %rdi
movq %rbx, %rsi
movl %r14d, %edx
callq 0x822f5
movl $0x0, 0x8(%r13)
movq $0x0, (%r13)
jmp 0x8191f
movl 0x70(%r12), %ecx
leaq -0x70(%rbp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movl %r14d, %edx
callq 0x822f5
movl (%r12), %eax
movq 0x10(%r15), %rcx
movb %al, (%rcx)
movq 0x10(%r15), %rcx
movb %ah, 0x1(%rcx)
jmp 0x8191f
cmpb $0x0, -0x80(%rbp)
leaq 0x928e8(%rip), %rax # 0x114101
leaq 0x94b9b(%rip), %r8 # 0x1163bb
cmoveq %rax, %r8
movl -0x94(%rbp), %r9d
movl -0x90(%rbp), %r10d
movl -0x8c(%rbp), %r11d
leaq 0x8de04(%rip), %rcx # 0x10f644
leaq -0x70(%rbp), %rdi
movl $0x3c, %edx
movl $0x1, %esi
xorl %eax, %eax
pushq %r11
pushq %r10
callq 0x5fea0
addq $0x10, %rsp
movslq %eax, %r13
movl 0x68(%r12), %eax
decl %eax
cmpl $0x5, %eax
ja 0x81910
movq -0x88(%rbp), %r8
leaq 0x8ddd7(%rip), %rcx # 0x10f655
leaq -0x78(%rbp), %rdi
movl $0x8, %edx
movl $0x1, %esi
xorl %eax, %eax
callq 0x5fea0
movl 0x68(%r12), %eax
cmpq $0x5, %rax
ja 0x818a7
leaq -0x78(%rbp), %rcx
movb $0x0, 0x1(%rax,%rcx)
leaq -0x78(%rbp), %r12
movq %r12, %rdi
callq 0x5f480
addq %rax, %r13
leaq -0x70(%rbp), %rdi
movl $0x3c, %edx
movq %r12, %rsi
callq 0x5f900
jmp 0x81910
movl -0xa0(%rbp), %r8d
movl -0x9c(%rbp), %r9d
movl -0x98(%rbp), %r10d
subq $0x8, %rsp
leaq 0x8dd4c(%rip), %rcx # 0x10f635
leaq -0x70(%rbp), %rdi
movl $0x3c, %edx
movl $0x1, %esi
xorl %eax, %eax
pushq %r10
callq 0x5fea0
addq $0x10, %rsp
movslq %eax, %r13
jmp 0x81910
movb $0x0, -0x70(%rbp)
xorl %r13d, %r13d
leaq -0x70(%rbp), %rsi
movq %r15, %rdi
movq %r13, %rdx
callq 0x81e25
movl %r14d, %eax
addq %rax, (%rbx)
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x81946
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x5f320
| ps_fetch_datetime:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 88h
mov rbx, rdx
mov r12, rsi
mov r15, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov r13, [rdi+10h]
mov rdi, rdx
call net_field_length
mov r14, rax
mov eax, [r15+60h]
add eax, 0FFFFFFF9h; switch 7 cases
cmp eax, 6
ja short def_81706; jumptable 0000000000081706 default case, cases 8,9
lea rcx, jpt_81706
movsxd rax, ds:(jpt_81706 - 1169F8h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_81708:
mov ecx, [r12+70h]; jumptable 0000000000081706 cases 7,10,12
mov rdi, r13
mov rsi, rbx
mov edx, r14d
call convert_to_datetime
jmp loc_8191F
def_81706:
mov r13d, [r12+70h]; jumptable 0000000000081706 default case, cases 8,9
lea rdi, [rbp+var_A0]
mov rsi, rbx
mov edx, r14d
mov ecx, r13d
call convert_to_datetime
add r13d, 0FFFFFFF9h; switch 6 cases
cmp r13d, 5
ja def_81756; jumptable 0000000000081756 default case, cases 8,9
lea rax, jpt_81756
movsxd rcx, ds:(jpt_81756 - 116A14h)[rax+r13*4]
add rcx, rax
jmp rcx; switch jump
loc_81758:
mov r8d, [rbp+var_A0]; jumptable 0000000000081756 cases 7,12
mov r9d, [rbp+var_9C]
mov eax, [rbp+var_98]
mov [rbp+var_A8], rax
mov r11d, [rbp+var_94]
mov r13d, [rbp+var_90]
mov r10d, [rbp+var_8C]
lea rcx, a04u02u02u02u02; "%04u-%02u-%02u %02u:%02u:%02u"
lea rdi, [rbp+var_70]
mov edx, 3Ch ; '<'
mov esi, 1
xor eax, eax
push r10
push r13
push r11
push [rbp+var_A8]
call ___sprintf_chk
add rsp, 20h
jmp loc_8185D
loc_817B9:
mov ecx, [r12+70h]; jumptable 0000000000081706 case 11
mov rdi, r13
mov rsi, rbx
mov edx, r14d
call convert_to_datetime
mov dword ptr [r13+8], 0
mov qword ptr [r13+0], 0
jmp loc_8191F
loc_817E1:
mov ecx, [r12+70h]; jumptable 0000000000081706 case 13
lea r12, [rbp+var_70]
mov rdi, r12
mov rsi, rbx
mov edx, r14d
call convert_to_datetime
mov eax, [r12]
mov rcx, [r15+10h]
mov [rcx], al
mov rcx, [r15+10h]
mov [rcx+1], ah
jmp loc_8191F
loc_8180E:
cmp [rbp+var_80], 0; jumptable 0000000000081756 case 11
lea rax, byte_114101
lea r8, asc_1163B8+3; "-"
cmovz r8, rax
mov r9d, [rbp+var_94]
mov r10d, [rbp+var_90]
mov r11d, [rbp+var_8C]
lea rcx, aS02u02u02u; "%s%02u:%02u:%02u"
lea rdi, [rbp+var_70]
mov edx, 3Ch ; '<'
mov esi, 1
xor eax, eax
push r11
push r10
call ___sprintf_chk
add rsp, 10h
loc_8185D:
movsxd r13, eax
mov eax, [r12+68h]
dec eax
cmp eax, 5
ja loc_81910
mov r8, [rbp+var_88]
lea rcx, a06lu; ".%06lu"
lea rdi, [rbp+var_78]
mov edx, 8
mov esi, 1
xor eax, eax
call ___sprintf_chk
mov eax, [r12+68h]
cmp rax, 5
ja short loc_818A7
lea rcx, [rbp+var_78]
mov byte ptr [rax+rcx+1], 0
loc_818A7:
lea r12, [rbp+var_78]
mov rdi, r12
call _strlen
add r13, rax
lea rdi, [rbp+var_70]
mov edx, 3Ch ; '<'
mov rsi, r12
call ___strcat_chk
jmp short loc_81910
loc_818C9:
mov r8d, [rbp+var_A0]; jumptable 0000000000081756 case 10
mov r9d, [rbp+var_9C]
mov r10d, [rbp+var_98]
sub rsp, 8
lea rcx, a04u02u02u; "%04u-%02u-%02u"
lea rdi, [rbp+var_70]
mov edx, 3Ch ; '<'
mov esi, 1
xor eax, eax
push r10
call ___sprintf_chk
add rsp, 10h
movsxd r13, eax
jmp short loc_81910
def_81756:
mov [rbp+var_70], 0; jumptable 0000000000081756 default case, cases 8,9
xor r13d, r13d
loc_81910:
lea rsi, [rbp+var_70]
mov rdi, r15
mov rdx, r13
call convert_froma_string
loc_8191F:
mov eax, r14d
add [rbx], rax
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_81946
add rsp, 88h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_81946:
call ___stack_chk_fail
| unsigned long long ps_fetch_datetime(long long a1, long long a2, unsigned __int8 **a3)
{
long long v4; // r13
unsigned int v5; // r14d
unsigned int v6; // r13d
int v7; // eax
char v8; // ah
const char *v9; // r8
long long v10; // r13
unsigned long long v11; // rax
int v13; // [rsp+10h] [rbp-A0h] BYREF
int v14; // [rsp+14h] [rbp-9Ch]
int v15; // [rsp+18h] [rbp-98h]
int v16; // [rsp+1Ch] [rbp-94h]
int v17; // [rsp+20h] [rbp-90h]
int v18; // [rsp+24h] [rbp-8Ch]
long long v19; // [rsp+28h] [rbp-88h]
char v20; // [rsp+30h] [rbp-80h]
_BYTE v21[8]; // [rsp+38h] [rbp-78h] BYREF
_BYTE v22[64]; // [rsp+40h] [rbp-70h] BYREF
unsigned long long v23; // [rsp+80h] [rbp-30h]
v23 = __readfsqword(0x28u);
v4 = *(_QWORD *)(a1 + 16);
v5 = net_field_length(a3);
switch ( *(_DWORD *)(a1 + 96) )
{
case 7:
case 0xA:
case 0xC:
convert_to_datetime(v4, a3, v5, *(unsigned int *)(a2 + 112));
break;
case 0xB:
convert_to_datetime(v4, a3, v5, *(unsigned int *)(a2 + 112));
*(_DWORD *)(v4 + 8) = 0;
*(_QWORD *)v4 = 0LL;
break;
case 0xD:
convert_to_datetime(v22, a3, v5, *(unsigned int *)(a2 + 112));
v8 = v22[1];
**(_BYTE **)(a1 + 16) = v22[0];
*(_BYTE *)(*(_QWORD *)(a1 + 16) + 1LL) = v8;
break;
default:
v6 = *(_DWORD *)(a2 + 112);
convert_to_datetime(&v13, a3, v5, v6);
switch ( v6 )
{
case 7u:
case 0xCu:
v7 = __sprintf_chk(v22, 1LL, 60LL, "%04u-%02u-%02u %02u:%02u:%02u", v13, v14, v15, v16, v17, v18);
goto LABEL_10;
case 0xAu:
v10 = (int)__sprintf_chk(v22, 1LL, 60LL, "%04u-%02u-%02u", v13, v14, v15);
break;
case 0xBu:
v9 = "-";
if ( !v20 )
v9 = &byte_114101;
v7 = __sprintf_chk(v22, 1LL, 60LL, "%s%02u:%02u:%02u", v9, v16, v17, v18);
LABEL_10:
v10 = v7;
if ( (unsigned int)(*(_DWORD *)(a2 + 104) - 1) <= 5 )
{
__sprintf_chk(v21, 1LL, 8LL, ".%06lu", v19);
v11 = *(unsigned int *)(a2 + 104);
if ( v11 <= 5 )
v21[v11 + 1] = 0;
v10 += strlen(v21);
__strcat_chk(v22, v21, 60LL);
}
break;
default:
v22[0] = 0;
v10 = 0LL;
break;
}
convert_froma_string(a1, v22, v10);
break;
}
*a3 += v5;
return __readfsqword(0x28u);
}
| ps_fetch_datetime:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x88
MOV RBX,RDX
MOV R12,RSI
MOV R15,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV R13,qword ptr [RDI + 0x10]
MOV RDI,RDX
CALL 0x00172f15
MOV R14,RAX
MOV EAX,dword ptr [R15 + 0x60]
ADD EAX,-0x7
CMP EAX,0x6
JA 0x00181720
LEA RCX,[0x2169f8]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_7:
MOV ECX,dword ptr [R12 + 0x70]
MOV RDI,R13
MOV RSI,RBX
MOV EDX,R14D
CALL 0x001822f5
JMP 0x0018191f
caseD_8:
MOV R13D,dword ptr [R12 + 0x70]
LEA RDI,[RBP + -0xa0]
MOV RSI,RBX
MOV EDX,R14D
MOV ECX,R13D
CALL 0x001822f5
ADD R13D,-0x7
CMP R13D,0x5
JA 0x00181909
LEA RAX,[0x216a14]
MOVSXD RCX,dword ptr [RAX + R13*0x4]
ADD RCX,RAX
switchD:
JMP RCX
caseD_7:
MOV R8D,dword ptr [RBP + -0xa0]
MOV R9D,dword ptr [RBP + -0x9c]
MOV EAX,dword ptr [RBP + -0x98]
MOV qword ptr [RBP + -0xa8],RAX
MOV R11D,dword ptr [RBP + -0x94]
MOV R13D,dword ptr [RBP + -0x90]
MOV R10D,dword ptr [RBP + -0x8c]
LEA RCX,[0x20f65c]
LEA RDI,[RBP + -0x70]
MOV EDX,0x3c
MOV ESI,0x1
XOR EAX,EAX
PUSH R10
PUSH R13
PUSH R11
PUSH qword ptr [RBP + -0xa8]
CALL 0x0015fea0
ADD RSP,0x20
JMP 0x0018185d
caseD_b:
MOV ECX,dword ptr [R12 + 0x70]
MOV RDI,R13
MOV RSI,RBX
MOV EDX,R14D
CALL 0x001822f5
MOV dword ptr [R13 + 0x8],0x0
MOV qword ptr [R13],0x0
JMP 0x0018191f
caseD_d:
MOV ECX,dword ptr [R12 + 0x70]
LEA R12,[RBP + -0x70]
MOV RDI,R12
MOV RSI,RBX
MOV EDX,R14D
CALL 0x001822f5
MOV EAX,dword ptr [R12]
MOV RCX,qword ptr [R15 + 0x10]
MOV byte ptr [RCX],AL
MOV RCX,qword ptr [R15 + 0x10]
MOV byte ptr [RCX + 0x1],AH
JMP 0x0018191f
caseD_b:
CMP byte ptr [RBP + -0x80],0x0
LEA RAX,[0x214101]
LEA R8,[0x2163bb]
CMOVZ R8,RAX
MOV R9D,dword ptr [RBP + -0x94]
MOV R10D,dword ptr [RBP + -0x90]
MOV R11D,dword ptr [RBP + -0x8c]
LEA RCX,[0x20f644]
LEA RDI,[RBP + -0x70]
MOV EDX,0x3c
MOV ESI,0x1
XOR EAX,EAX
PUSH R11
PUSH R10
CALL 0x0015fea0
ADD RSP,0x10
LAB_0018185d:
MOVSXD R13,EAX
MOV EAX,dword ptr [R12 + 0x68]
DEC EAX
CMP EAX,0x5
JA 0x00181910
MOV R8,qword ptr [RBP + -0x88]
LEA RCX,[0x20f655]
LEA RDI,[RBP + -0x78]
MOV EDX,0x8
MOV ESI,0x1
XOR EAX,EAX
CALL 0x0015fea0
MOV EAX,dword ptr [R12 + 0x68]
CMP RAX,0x5
JA 0x001818a7
LEA RCX,[RBP + -0x78]
MOV byte ptr [RAX + RCX*0x1 + 0x1],0x0
LAB_001818a7:
LEA R12,[RBP + -0x78]
MOV RDI,R12
CALL 0x0015f480
ADD R13,RAX
LEA RDI,[RBP + -0x70]
MOV EDX,0x3c
MOV RSI,R12
CALL 0x0015f900
JMP 0x00181910
caseD_a:
MOV R8D,dword ptr [RBP + -0xa0]
MOV R9D,dword ptr [RBP + -0x9c]
MOV R10D,dword ptr [RBP + -0x98]
SUB RSP,0x8
LEA RCX,[0x20f635]
LEA RDI,[RBP + -0x70]
MOV EDX,0x3c
MOV ESI,0x1
XOR EAX,EAX
PUSH R10
CALL 0x0015fea0
ADD RSP,0x10
MOVSXD R13,EAX
JMP 0x00181910
caseD_8:
MOV byte ptr [RBP + -0x70],0x0
XOR R13D,R13D
LAB_00181910:
LEA RSI,[RBP + -0x70]
MOV RDI,R15
MOV RDX,R13
CALL 0x00181e25
LAB_0018191f:
MOV EAX,R14D
ADD qword ptr [RBX],RAX
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00181946
ADD RSP,0x88
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00181946:
CALL 0x0015f320
|
void ps_fetch_datetime(long param_1,long param_2,long *param_3)
{
int4 uVar1;
int8 *puVar2;
uint uVar3;
int iVar4;
size_t sVar5;
int *puVar6;
long lVar7;
long in_FS_OFFSET;
int4 local_a8;
int4 local_a4;
int4 local_a0;
int4 local_9c;
int4 local_98;
int4 local_94;
int8 local_90;
char local_88;
char local_80;
int1 auStack_7f [7];
uint local_78 [16];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
puVar2 = *(int8 **)(param_1 + 0x10);
uVar3 = net_field_length(param_3);
switch(*(int4 *)(param_1 + 0x60)) {
case 7:
case 10:
case 0xc:
convert_to_datetime(puVar2,param_3,uVar3,*(int4 *)(param_2 + 0x70));
break;
default:
uVar1 = *(int4 *)(param_2 + 0x70);
convert_to_datetime(&local_a8,param_3,uVar3,uVar1);
switch(uVar1) {
case 7:
case 0xc:
iVar4 = __sprintf_chk(local_78,1,0x3c,"%04u-%02u-%02u %02u:%02u:%02u",local_a8,local_a4,
local_a0,local_9c,local_98,local_94);
goto LAB_0018185d;
default:
local_78[0] = local_78[0] & 0xffffff00;
lVar7 = 0;
break;
case 10:
iVar4 = __sprintf_chk(local_78,1,0x3c,"%04u-%02u-%02u",local_a8,local_a4,local_a0);
lVar7 = (long)iVar4;
break;
case 0xb:
puVar6 = &DAT_002163bb;
if (local_88 == '\0') {
puVar6 = &DAT_00214101;
}
iVar4 = __sprintf_chk(local_78,1,0x3c,"%s%02u:%02u:%02u",puVar6,local_9c,local_98,local_94);
LAB_0018185d:
lVar7 = (long)iVar4;
if (*(int *)(param_2 + 0x68) - 1U < 6) {
__sprintf_chk(&local_80,1,8,".%06lu",local_90);
if ((ulong)*(uint *)(param_2 + 0x68) < 6) {
auStack_7f[*(uint *)(param_2 + 0x68)] = 0;
}
sVar5 = strlen(&local_80);
lVar7 = lVar7 + sVar5;
__strcat_chk(local_78,&local_80,0x3c);
}
}
convert_froma_string(param_1,local_78,lVar7);
break;
case 0xb:
convert_to_datetime(puVar2,param_3,uVar3,*(int4 *)(param_2 + 0x70));
*(int4 *)(puVar2 + 1) = 0;
*puVar2 = 0;
break;
case 0xd:
convert_to_datetime(local_78,param_3,uVar3,*(int4 *)(param_2 + 0x70));
**(int1 **)(param_1 + 0x10) = (char)local_78[0];
*(char *)(*(long *)(param_1 + 0x10) + 1) = (char)(local_78[0] >> 8);
}
*param_3 = *param_3 + (ulong)uVar3;
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
44,707 | testing::internal::BriefUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int) | giladroyz[P]FindPeaks/build_O3/_deps/googletest-src/googletest/src/gtest.cc | void BriefUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
int /*iteration*/) {
ColoredPrintf(GTestColor::kGreen, "[==========] ");
printf("%s from %s ran.",
FormatTestCount(unit_test.test_to_run_count()).c_str(),
FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());
if (GTEST_FLAG_GET(print_time)) {
printf(" (%s ms total)",
internal::StreamableToString(unit_test.elapsed_time()).c_str());
}
printf("\n");
ColoredPrintf(GTestColor::kGreen, "[ PASSED ] ");
printf("%s.\n", FormatTestCount(unit_test.successful_test_count()).c_str());
const int skipped_test_count = unit_test.skipped_test_count();
if (skipped_test_count > 0) {
ColoredPrintf(GTestColor::kGreen, "[ SKIPPED ] ");
printf("%s.\n", FormatTestCount(skipped_test_count).c_str());
}
int num_disabled = unit_test.reportable_disabled_test_count();
if (num_disabled && !GTEST_FLAG_GET(also_run_disabled_tests)) {
if (unit_test.Passed()) {
printf("\n"); // Add a spacer if no FAILURE banner is displayed.
}
ColoredPrintf(GTestColor::kYellow, " YOU HAVE %d DISABLED %s\n\n",
num_disabled, num_disabled == 1 ? "TEST" : "TESTS");
}
// Ensure that Google Test output is printed before, e.g., heapchecker output.
fflush(stdout);
} | O3 | cpp | testing::internal::BriefUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
leaq 0x1fc29(%rip), %rsi # 0x432c7
xorl %ebp, %ebp
movl $0x2, %edi
xorl %eax, %eax
callq 0x22129
movq 0x40(%rbx), %rdi
callq 0x1c862
leaq 0x1ebf2(%rip), %rdx # 0x422ae
leaq 0x1eff7(%rip), %rcx # 0x426ba
leaq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0x228b2
movq 0x40(%rbx), %rcx
movq 0xb8(%rcx), %rax
movq 0xc0(%rcx), %rcx
cmpq %rcx, %rax
je 0x236fa
xorl %ebp, %ebp
movq (%rax), %rdx
movzbl 0x70(%rdx), %edx
addl %edx, %ebp
addq $0x8, %rax
cmpq %rcx, %rax
jne 0x236e8
movq 0x8(%rsp), %r14
leaq 0x20be6(%rip), %rdx # 0x442ec
leaq 0x20bea(%rip), %rcx # 0x442f7
leaq 0x28(%rsp), %rdi
movl %ebp, %esi
callq 0x228b2
leaq 0x38(%rsp), %r15
movq -0x10(%r15), %rdx
leaq 0x1fcd5(%rip), %rdi # 0x433fe
movq %r14, %rsi
xorl %eax, %eax
callq 0x8080
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x23749
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x84e0
leaq 0x18(%rsp), %r15
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x23764
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84e0
cmpb $0x1, 0x35f86(%rip) # 0x596f1
jne 0x237b3
movq 0x40(%rbx), %rax
movq 0x2a0(%rax), %rax
leaq 0x28(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3471e
movq (%r14), %rsi
leaq 0x1fc77(%rip), %rdi # 0x4340e
xorl %eax, %eax
callq 0x8080
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x237b3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84e0
movl $0xa, %edi
callq 0x8790
leaq 0x1fc59(%rip), %rsi # 0x4341d
movl $0x2, %edi
xorl %eax, %eax
callq 0x22129
movq 0x40(%rbx), %rdi
callq 0x1c45c
leaq 0x1eace(%rip), %rdx # 0x422ae
leaq 0x1eed3(%rip), %rcx # 0x426ba
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %eax, %esi
callq 0x228b2
movq (%r14), %rsi
leaq 0x1fa8d(%rip), %rdi # 0x4328d
xorl %eax, %eax
callq 0x8080
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x2381c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84e0
movq 0x40(%rbx), %rdi
callq 0x1c4e2
testl %eax, %eax
jle 0x23881
movl %eax, %ebp
leaq 0x1fb0c(%rip), %rsi # 0x4333e
movl $0x2, %edi
xorl %eax, %eax
callq 0x22129
leaq 0x1ea69(%rip), %rdx # 0x422ae
leaq 0x1ee6e(%rip), %rcx # 0x426ba
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %ebp, %esi
callq 0x228b2
movq (%r14), %rsi
leaq 0x1fa28(%rip), %rdi # 0x4328d
xorl %eax, %eax
callq 0x8080
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x23881
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84e0
movq 0x40(%rbx), %r14
movq %r14, %rdi
callq 0x1c622
testl %eax, %eax
je 0x238dc
cmpb $0x0, 0x35deb(%rip) # 0x59683
jne 0x238dc
movl %eax, %ebx
movq %r14, %rdi
callq 0x34788
testb %al, %al
je 0x238b2
movl $0xa, %edi
callq 0x8790
cmpl $0x1, %ebx
leaq 0x1faec(%rip), %rax # 0x433a8
leaq 0x1faea(%rip), %rcx # 0x433ad
cmoveq %rax, %rcx
leaq 0x1fb5d(%rip), %rsi # 0x4342b
movl $0x3, %edi
movl %ebx, %edx
xorl %eax, %eax
callq 0x22129
movq 0x3569d(%rip), %rax # 0x58f80
movq (%rax), %rdi
callq 0x8600
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x23914
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84e0
movq %rbx, %rdi
callq 0x8990
| _ZN7testing8internal26BriefUnitTestResultPrinter18OnTestIterationEndERKNS_8UnitTestEi:
push rbp
push r15
push r14
push rbx
sub rsp, 48h
mov rbx, rsi
lea rsi, asc_432C7; "[==========] "
xor ebp, ebp
mov edi, 2
xor eax, eax
call _ZN7testing8internalL13ColoredPrintfENS0_12_GLOBAL__N_110GTestColorEPKcz; testing::internal::ColoredPrintf(testing::internal::`anonymous namespace'::GTestColor,char const*,...)
mov rdi, [rbx+40h]; this
call _ZNK7testing8internal12UnitTestImpl17test_to_run_countEv; testing::internal::UnitTestImpl::test_to_run_count(void)
lea rdx, aDeathtestPasse+36h; int
lea rcx, aAlsoRunDisable+12h; int
lea rdi, [rsp+68h+var_60]; int
mov esi, eax; int
call _ZN7testingL19FormatCountableNounB5cxx11EiPKcS1_; testing::FormatCountableNoun(int,char const*,char const*)
mov rcx, [rbx+40h]
mov rax, [rcx+0B8h]
mov rcx, [rcx+0C0h]
cmp rax, rcx
jz short loc_236FA
xor ebp, ebp
loc_236E8:
mov rdx, [rax]
movzx edx, byte ptr [rdx+70h]
add ebp, edx
add rax, 8
cmp rax, rcx
jnz short loc_236E8
loc_236FA:
mov r14, qword ptr [rsp+68h+var_60]
lea rdx, aTestSuite; "test suite"
lea rcx, aTestSuites; "test suites"
lea rdi, [rsp+68h+var_40]; int
mov esi, ebp; int
call _ZN7testingL19FormatCountableNounB5cxx11EiPKcS1_; testing::FormatCountableNoun(int,char const*,char const*)
lea r15, [rsp+68h+var_30]
mov rdx, [r15-10h]
lea rdi, aSFromSRan; "%s from %s ran."
mov rsi, r14
xor eax, eax
call _printf
mov rdi, [r15-10h]; void *
cmp rdi, r15
jz short loc_23749
mov rsi, [rsp+68h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_23749:
lea r15, [rsp+68h+var_50]
mov rdi, [r15-10h]; void *
cmp rdi, r15
jz short loc_23764
mov rsi, [rsp+68h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_23764:
cmp cs:_ZN7testing22FLAGS_gtest_print_timeE, 1; testing::FLAGS_gtest_print_time
jnz short loc_237B3
mov rax, [rbx+40h]
mov rax, [rax+2A0h]
lea rsi, [rsp+68h+var_40]
mov [rsi], rax
lea r14, [rsp+68h+var_60]
mov rdi, r14
call _ZN7testing8internal18StreamableToStringIlEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKT_; testing::internal::StreamableToString<long>(long const&)
mov rsi, [r14]
lea rdi, aSMsTotal; " (%s ms total)"
xor eax, eax
call _printf
mov rdi, [r14]; void *
cmp rdi, r15
jz short loc_237B3
mov rsi, [rsp+68h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_237B3:
mov edi, 0Ah
call _putchar
lea rsi, aPassed; "[ PASSED ] "
mov edi, 2
xor eax, eax
call _ZN7testing8internalL13ColoredPrintfENS0_12_GLOBAL__N_110GTestColorEPKcz; testing::internal::ColoredPrintf(testing::internal::`anonymous namespace'::GTestColor,char const*,...)
mov rdi, [rbx+40h]; this
call _ZNK7testing8internal12UnitTestImpl21successful_test_countEv; testing::internal::UnitTestImpl::successful_test_count(void)
lea rdx, aDeathtestPasse+36h; int
lea rcx, aAlsoRunDisable+12h; int
lea r14, [rsp+68h+var_60]
mov rdi, r14; int
mov esi, eax; int
call _ZN7testingL19FormatCountableNounB5cxx11EiPKcS1_; testing::FormatCountableNoun(int,char const*,char const*)
mov rsi, [r14]
lea rdi, aNoteThisIsTest+1Fh; "%s.\n"
xor eax, eax
call _printf
mov rdi, [r14]; void *
cmp rdi, r15
jz short loc_2381C
mov rsi, [rsp+68h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2381C:
mov rdi, [rbx+40h]; this
call _ZNK7testing8internal12UnitTestImpl18skipped_test_countEv; testing::internal::UnitTestImpl::skipped_test_count(void)
test eax, eax
jle short loc_23881
mov ebp, eax
lea rsi, aSkipped_0; "[ SKIPPED ] "
mov edi, 2
xor eax, eax
call _ZN7testing8internalL13ColoredPrintfENS0_12_GLOBAL__N_110GTestColorEPKcz; testing::internal::ColoredPrintf(testing::internal::`anonymous namespace'::GTestColor,char const*,...)
lea rdx, aDeathtestPasse+36h; int
lea rcx, aAlsoRunDisable+12h; int
lea r14, [rsp+68h+var_60]
mov rdi, r14; int
mov esi, ebp; int
call _ZN7testingL19FormatCountableNounB5cxx11EiPKcS1_; testing::FormatCountableNoun(int,char const*,char const*)
mov rsi, [r14]
lea rdi, aNoteThisIsTest+1Fh; "%s.\n"
xor eax, eax
call _printf
mov rdi, [r14]; void *
cmp rdi, r15
jz short loc_23881
mov rsi, [rsp+68h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_23881:
mov r14, [rbx+40h]
mov rdi, r14; this
call _ZNK7testing8internal12UnitTestImpl30reportable_disabled_test_countEv; testing::internal::UnitTestImpl::reportable_disabled_test_count(void)
test eax, eax
jz short loc_238DC
cmp cs:_ZN7testing35FLAGS_gtest_also_run_disabled_testsE, 0; testing::FLAGS_gtest_also_run_disabled_tests
jnz short loc_238DC
mov ebx, eax
mov rdi, r14; this
call _ZNK7testing8internal12UnitTestImpl6PassedEv; testing::internal::UnitTestImpl::Passed(void)
test al, al
jz short loc_238B2
mov edi, 0Ah
call _putchar
loc_238B2:
cmp ebx, 1
lea rax, aTest_0; "TEST"
lea rcx, aTests; "TESTS"
cmovz rcx, rax
lea rsi, aYouHaveDDisabl; " YOU HAVE %d DISABLED %s\n\n"
mov edi, 3
mov edx, ebx
xor eax, eax
call _ZN7testing8internalL13ColoredPrintfENS0_12_GLOBAL__N_110GTestColorEPKcz; testing::internal::ColoredPrintf(testing::internal::`anonymous namespace'::GTestColor,char const*,...)
loc_238DC:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
add rsp, 48h
pop rbx
pop r14
pop r15
pop rbp
retn
mov rbx, rax
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_23914
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_23914:
mov rdi, rbx
call __Unwind_Resume
| long long testing::internal::BriefUnitTestResultPrinter::OnTestIterationEnd(
testing::internal::BriefUnitTestResultPrinter *this,
testing::internal::UnitTestImpl **a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
int v14; // ebp
int v15; // eax
testing::internal::UnitTestImpl *v16; // rcx
long long v17; // rax
long long v18; // rcx
const char *v19; // r14
long long v20; // rdx
long long v21; // rcx
long long v22; // r8
long long v23; // r9
__m128 v24; // xmm4
__m128 v25; // xmm5
int v26; // eax
int v27; // eax
long long v28; // rdx
long long v29; // rcx
long long v30; // r8
long long v31; // r9
__m128 v32; // xmm4
__m128 v33; // xmm5
int v34; // ebp
testing::internal::UnitTestImpl *v35; // r14
unsigned int v36; // eax
unsigned int v37; // ebx
long long v38; // r8
long long v39; // r9
__m128 v40; // xmm4
__m128 v41; // xmm5
const char *v42; // rcx
char v44; // [rsp+0h] [rbp-68h]
char v45; // [rsp+0h] [rbp-68h]
char v46; // [rsp+0h] [rbp-68h]
int v47[2]; // [rsp+8h] [rbp-60h] BYREF
_QWORD v48[2]; // [rsp+18h] [rbp-50h] BYREF
char *v49; // [rsp+28h] [rbp-40h] BYREF
long long v50; // [rsp+38h] [rbp-30h] BYREF
v14 = 0;
testing::internal::ColoredPrintf(
2,
(long long)"[==========] ",
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v44);
v15 = testing::internal::UnitTestImpl::test_to_run_count(a2[8]);
testing::FormatCountableNoun[abi:cxx11]((long long)v47, v15, "test", "tests");
v16 = a2[8];
v17 = *((_QWORD *)v16 + 23);
v18 = *((_QWORD *)v16 + 24);
if ( v17 != v18 )
{
v14 = 0;
do
{
v14 += *(unsigned __int8 *)(*(_QWORD *)v17 + 112LL);
v17 += 8LL;
}
while ( v17 != v18 );
}
v19 = *(const char **)v47;
testing::FormatCountableNoun[abi:cxx11]((long long)&v49, v14, "test suite", "test suites");
printf("%s from %s ran.", v19, v49);
if ( v49 != (char *)&v50 )
operator delete(v49, v50 + 1);
if ( *(_QWORD **)v47 != v48 )
operator delete(*(void **)v47, v48[0] + 1LL);
if ( testing::FLAGS_gtest_print_time == 1 )
{
v49 = (char *)*((_QWORD *)a2[8] + 84);
testing::internal::StreamableToString<long>(v47);
printf(" (%s ms total)", *(const char **)v47);
if ( *(_QWORD **)v47 != v48 )
operator delete(*(void **)v47, v48[0] + 1LL);
}
putchar(10LL);
testing::internal::ColoredPrintf(
2,
(long long)"[ PASSED ] ",
v20,
v21,
v22,
v23,
a7,
a8,
a9,
a10,
v24,
v25,
a13,
a14,
v45);
v26 = testing::internal::UnitTestImpl::successful_test_count(a2[8]);
testing::FormatCountableNoun[abi:cxx11]((long long)v47, v26, "test", "tests");
printf("%s.\n", *(const char **)v47);
if ( *(_QWORD **)v47 != v48 )
operator delete(*(void **)v47, v48[0] + 1LL);
v27 = testing::internal::UnitTestImpl::skipped_test_count(a2[8]);
if ( v27 > 0 )
{
v34 = v27;
testing::internal::ColoredPrintf(
2,
(long long)"[ SKIPPED ] ",
v28,
v29,
v30,
v31,
a7,
a8,
a9,
a10,
v32,
v33,
a13,
a14,
v46);
testing::FormatCountableNoun[abi:cxx11]((long long)v47, v34, "test", "tests");
printf("%s.\n", *(const char **)v47);
if ( *(_QWORD **)v47 != v48 )
operator delete(*(void **)v47, v48[0] + 1LL);
}
v35 = a2[8];
v36 = testing::internal::UnitTestImpl::reportable_disabled_test_count(v35);
if ( v36 && !testing::FLAGS_gtest_also_run_disabled_tests )
{
v37 = v36;
if ( (unsigned __int8)testing::internal::UnitTestImpl::Passed(v35) )
putchar(10LL);
v42 = "TESTS";
if ( v37 == 1 )
v42 = "TEST";
testing::internal::ColoredPrintf(
3,
(long long)" YOU HAVE %d DISABLED %s\n\n",
v37,
(long long)v42,
v38,
v39,
a7,
a8,
a9,
a10,
v40,
v41,
a13,
a14,
v46);
}
return fflush(stdout);
}
| OnTestIterationEnd:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x48
MOV RBX,RSI
LEA RSI,[0x1432c7]
XOR EBP,EBP
MOV EDI,0x2
XOR EAX,EAX
CALL 0x00122129
MOV RDI,qword ptr [RBX + 0x40]
CALL 0x0011c862
LEA RDX,[0x1422ae]
LEA RCX,[0x1426ba]
LEA RDI,[RSP + 0x8]
MOV ESI,EAX
CALL 0x001228b2
MOV RCX,qword ptr [RBX + 0x40]
MOV RAX,qword ptr [RCX + 0xb8]
MOV RCX,qword ptr [RCX + 0xc0]
CMP RAX,RCX
JZ 0x001236fa
XOR EBP,EBP
LAB_001236e8:
MOV RDX,qword ptr [RAX]
MOVZX EDX,byte ptr [RDX + 0x70]
ADD EBP,EDX
ADD RAX,0x8
CMP RAX,RCX
JNZ 0x001236e8
LAB_001236fa:
MOV R14,qword ptr [RSP + 0x8]
LAB_001236ff:
LEA RDX,[0x1442ec]
LEA RCX,[0x1442f7]
LEA RDI,[RSP + 0x28]
MOV ESI,EBP
CALL 0x001228b2
LAB_00123719:
LEA R15,[RSP + 0x38]
MOV RDX,qword ptr [R15 + -0x10]
LEA RDI,[0x1433fe]
MOV RSI,R14
XOR EAX,EAX
CALL 0x00108080
MOV RDI,qword ptr [R15 + -0x10]
CMP RDI,R15
JZ 0x00123749
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x001084e0
LAB_00123749:
LEA R15,[RSP + 0x18]
MOV RDI,qword ptr [R15 + -0x10]
CMP RDI,R15
JZ 0x00123764
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001084e0
LAB_00123764:
CMP byte ptr [0x001596f1],0x1
JNZ 0x001237b3
MOV RAX,qword ptr [RBX + 0x40]
MOV RAX,qword ptr [RAX + 0x2a0]
LEA RSI,[RSP + 0x28]
MOV qword ptr [RSI],RAX
LEA R14,[RSP + 0x8]
MOV RDI,R14
CALL 0x0013471e
MOV RSI,qword ptr [R14]
LEA RDI,[0x14340e]
XOR EAX,EAX
CALL 0x00108080
MOV RDI,qword ptr [R14]
CMP RDI,R15
JZ 0x001237b3
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001084e0
LAB_001237b3:
MOV EDI,0xa
CALL 0x00108790
LEA RSI,[0x14341d]
MOV EDI,0x2
XOR EAX,EAX
CALL 0x00122129
MOV RDI,qword ptr [RBX + 0x40]
CALL 0x0011c45c
LEA RDX,[0x1422ae]
LEA RCX,[0x1426ba]
LEA R14,[RSP + 0x8]
MOV RDI,R14
MOV ESI,EAX
CALL 0x001228b2
MOV RSI,qword ptr [R14]
LEA RDI,[0x14328d]
XOR EAX,EAX
CALL 0x00108080
MOV RDI,qword ptr [R14]
CMP RDI,R15
JZ 0x0012381c
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001084e0
LAB_0012381c:
MOV RDI,qword ptr [RBX + 0x40]
CALL 0x0011c4e2
TEST EAX,EAX
JLE 0x00123881
MOV EBP,EAX
LEA RSI,[0x14333e]
MOV EDI,0x2
XOR EAX,EAX
CALL 0x00122129
LEA RDX,[0x1422ae]
LEA RCX,[0x1426ba]
LEA R14,[RSP + 0x8]
MOV RDI,R14
MOV ESI,EBP
CALL 0x001228b2
MOV RSI,qword ptr [R14]
LEA RDI,[0x14328d]
XOR EAX,EAX
CALL 0x00108080
MOV RDI,qword ptr [R14]
CMP RDI,R15
JZ 0x00123881
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001084e0
LAB_00123881:
MOV R14,qword ptr [RBX + 0x40]
MOV RDI,R14
CALL 0x0011c622
TEST EAX,EAX
JZ 0x001238dc
CMP byte ptr [0x00159683],0x0
JNZ 0x001238dc
MOV EBX,EAX
MOV RDI,R14
CALL 0x00134788
TEST AL,AL
JZ 0x001238b2
MOV EDI,0xa
CALL 0x00108790
LAB_001238b2:
CMP EBX,0x1
LEA RAX,[0x1433a8]
LEA RCX,[0x1433ad]
CMOVZ RCX,RAX
LEA RSI,[0x14342b]
MOV EDI,0x3
MOV EDX,EBX
XOR EAX,EAX
CALL 0x00122129
LAB_001238dc:
MOV RAX,qword ptr [0x00158f80]
MOV RDI,qword ptr [RAX]
CALL 0x00108600
ADD RSP,0x48
POP RBX
POP R14
POP R15
POP RBP
RET
|
/* testing::internal::BriefUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int)
*/
void testing::internal::BriefUnitTestResultPrinter::OnTestIterationEnd
(UnitTest *param_1,int param_2)
{
long *plVar1;
UnitTestImpl *this;
long *plVar2;
char cVar3;
uint uVar4;
int iVar5;
long *plVar6;
char *pcVar7;
uint uVar8;
int4 in_register_00000034;
long lVar9;
long *local_60 [2];
long local_50 [2];
long *local_40 [2];
long local_30 [2];
lVar9 = CONCAT44(in_register_00000034,param_2);
uVar8 = 0;
ColoredPrintf(2,"[==========] ");
uVar4 = UnitTestImpl::test_to_run_count(*(UnitTestImpl **)(lVar9 + 0x40));
FormatCountableNoun_abi_cxx11_((int)local_60,(char *)(ulong)uVar4,"test");
plVar2 = local_60[0];
plVar6 = *(long **)(*(long *)(lVar9 + 0x40) + 0xb8);
plVar1 = *(long **)(*(long *)(lVar9 + 0x40) + 0xc0);
if (plVar6 != plVar1) {
uVar8 = 0;
do {
uVar8 = uVar8 + *(byte *)(*plVar6 + 0x70);
plVar6 = plVar6 + 1;
} while (plVar6 != plVar1);
}
/* try { // try from 001236ff to 00123718 has its CatchHandler @ 001238f6 */
FormatCountableNoun_abi_cxx11_((int)local_40,(char *)(ulong)uVar8,"test suite");
printf("%s from %s ran.",plVar2,local_40[0]);
if (local_40[0] != local_30) {
operator_delete(local_40[0],local_30[0] + 1);
}
if (local_60[0] != local_50) {
operator_delete(local_60[0],local_50[0] + 1);
}
if (FLAGS_gtest_print_time == '\x01') {
local_40[0] = *(long **)(*(long *)(lVar9 + 0x40) + 0x2a0);
StreamableToString<long>((long *)local_60);
printf(" (%s ms total)",local_60[0]);
if (local_60[0] != local_50) {
operator_delete(local_60[0],local_50[0] + 1);
}
}
putchar(10);
ColoredPrintf(2,"[ PASSED ] ");
uVar4 = UnitTestImpl::successful_test_count(*(UnitTestImpl **)(lVar9 + 0x40));
FormatCountableNoun_abi_cxx11_((int)local_60,(char *)(ulong)uVar4,"test");
printf("%s.\n",local_60[0]);
if (local_60[0] != local_50) {
operator_delete(local_60[0],local_50[0] + 1);
}
uVar4 = UnitTestImpl::skipped_test_count(*(UnitTestImpl **)(lVar9 + 0x40));
if (0 < (int)uVar4) {
ColoredPrintf(2,"[ SKIPPED ] ");
FormatCountableNoun_abi_cxx11_((int)local_60,(char *)(ulong)uVar4,"test");
printf("%s.\n",local_60[0]);
if (local_60[0] != local_50) {
operator_delete(local_60[0],local_50[0] + 1);
}
}
this = *(UnitTestImpl **)(lVar9 + 0x40);
iVar5 = UnitTestImpl::reportable_disabled_test_count(this);
if ((iVar5 != 0) && (FLAGS_gtest_also_run_disabled_tests == '\0')) {
cVar3 = UnitTestImpl::Passed(this);
if (cVar3 != '\0') {
putchar(10);
}
pcVar7 = "TESTS";
if (iVar5 == 1) {
pcVar7 = "TEST";
}
ColoredPrintf(3," YOU HAVE %d DISABLED %s\n\n",iVar5,pcVar7);
}
fflush(*(FILE **)PTR_stdout_00158f80);
return;
}
| |
44,708 | my_fill_utf8mb3_mb | eloqsql/strings/ctype-utf8.c | static void
my_fill_utf8mb3_mb(CHARSET_INFO *cs, char *str, size_t length, int fill)
{
char *end= str + length;
char buf[10];
char buflen= my_ci_native_to_mb(cs, (my_wc_t) fill, (uchar*) buf,
(uchar*) buf + sizeof(buf));
DBUG_ASSERT(buflen > 0);
for ( ; str + buflen <= end ; )
{
memcpy(str, buf, buflen);
str+= buflen;
}
for ( ; str < end; )
*str++= ' ';
} | O0 | c | my_fill_utf8mb3_mb:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movl %ecx, -0x34(%rbp)
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq 0xb8(%rax), %rax
movq 0xd8(%rax), %rax
movq -0x20(%rbp), %rdi
movslq -0x34(%rbp), %rsi
leaq -0x12(%rbp), %rdx
leaq -0x12(%rbp), %rcx
addq $0xa, %rcx
callq *%rax
movb %al, -0x41(%rbp)
jmp 0xc476d
jmp 0xc476f
movq -0x28(%rbp), %rax
movsbl -0x41(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
cmpq -0x40(%rbp), %rax
ja 0xc47a9
movq -0x28(%rbp), %rdi
leaq -0x12(%rbp), %rsi
movsbq -0x41(%rbp), %rdx
callq 0x282b0
movsbl -0x41(%rbp), %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0xc476f
jmp 0xc47ab
movq -0x28(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0xc47c9
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb $0x20, (%rax)
jmp 0xc47ab
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xc47e1
addq $0x50, %rsp
popq %rbp
retq
callq 0x283b0
nopw %cs:(%rax,%rax)
| my_fill_utf8mb3_mb:
push rbp
mov rbp, rsp
sub rsp, 50h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_20], rdi
mov [rbp+var_28], rsi
mov [rbp+var_30], rdx
mov [rbp+var_34], ecx
mov rax, [rbp+var_28]
add rax, [rbp+var_30]
mov [rbp+var_40], rax
mov rax, [rbp+var_20]
mov rax, [rax+0B8h]
mov rax, [rax+0D8h]
mov rdi, [rbp+var_20]
movsxd rsi, [rbp+var_34]
lea rdx, [rbp+var_12]
lea rcx, [rbp+var_12]
add rcx, 0Ah
call rax
mov [rbp+var_41], al
jmp short $+2
loc_C476D:
jmp short $+2
loc_C476F:
mov rax, [rbp+var_28]
movsx ecx, [rbp+var_41]
movsxd rcx, ecx
add rax, rcx
cmp rax, [rbp+var_40]
ja short loc_C47A9
mov rdi, [rbp+var_28]
lea rsi, [rbp+var_12]
movsx rdx, [rbp+var_41]
call _memcpy
movsx ecx, [rbp+var_41]
mov rax, [rbp+var_28]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_28], rax
jmp short loc_C476F
loc_C47A9:
jmp short $+2
loc_C47AB:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_40]
jnb short loc_C47C9
mov rax, [rbp+var_28]
mov rcx, rax
add rcx, 1
mov [rbp+var_28], rcx
mov byte ptr [rax], 20h ; ' '
jmp short loc_C47AB
loc_C47C9:
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_C47E1
add rsp, 50h
pop rbp
retn
loc_C47E1:
call ___stack_chk_fail
| unsigned long long my_fill_utf8mb3_mb(long long a1, _BYTE *a2, long long a3, int a4)
{
_BYTE *v4; // rax
char i; // [rsp+Fh] [rbp-41h]
unsigned long long v7; // [rsp+10h] [rbp-40h]
_BYTE *v8; // [rsp+28h] [rbp-28h]
_BYTE v9[10]; // [rsp+3Eh] [rbp-12h] BYREF
unsigned long long v10; // [rsp+48h] [rbp-8h] BYREF
v10 = __readfsqword(0x28u);
v8 = a2;
v7 = (unsigned long long)&a2[a3];
for ( i = (*(long long ( **)(long long, _QWORD, _BYTE *, unsigned long long *))(*(_QWORD *)(a1 + 184) + 216LL))(
a1,
a4,
v9,
&v10); (unsigned long long)&v8[i] <= v7; v8 += i )
memcpy(v8, v9, i);
while ( (unsigned long long)v8 < v7 )
{
v4 = v8++;
*v4 = 32;
}
return __readfsqword(0x28u);
}
| my_fill_utf8mb3_mb:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x20],RDI
MOV qword ptr [RBP + -0x28],RSI
MOV qword ptr [RBP + -0x30],RDX
MOV dword ptr [RBP + -0x34],ECX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RAX + 0xd8]
MOV RDI,qword ptr [RBP + -0x20]
MOVSXD RSI,dword ptr [RBP + -0x34]
LEA RDX,[RBP + -0x12]
LEA RCX,[RBP + -0x12]
ADD RCX,0xa
CALL RAX
MOV byte ptr [RBP + -0x41],AL
JMP 0x001c476d
LAB_001c476d:
JMP 0x001c476f
LAB_001c476f:
MOV RAX,qword ptr [RBP + -0x28]
MOVSX ECX,byte ptr [RBP + -0x41]
MOVSXD RCX,ECX
ADD RAX,RCX
CMP RAX,qword ptr [RBP + -0x40]
JA 0x001c47a9
MOV RDI,qword ptr [RBP + -0x28]
LEA RSI,[RBP + -0x12]
MOVSX RDX,byte ptr [RBP + -0x41]
CALL 0x001282b0
MOVSX ECX,byte ptr [RBP + -0x41]
MOV RAX,qword ptr [RBP + -0x28]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
JMP 0x001c476f
LAB_001c47a9:
JMP 0x001c47ab
LAB_001c47ab:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x40]
JNC 0x001c47c9
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x28],RCX
MOV byte ptr [RAX],0x20
JMP 0x001c47ab
LAB_001c47c9:
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001c47e1
ADD RSP,0x50
POP RBP
RET
LAB_001c47e1:
CALL 0x001283b0
|
void my_fill_utf8mb3_mb(long param_1,int1 *param_2,long param_3,int param_4)
{
char cVar1;
long in_FS_OFFSET;
int1 *local_30;
int1 local_1a [10];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
cVar1 = (**(code **)(*(long *)(param_1 + 0xb8) + 0xd8))(param_1,(long)param_4,local_1a,&local_10);
for (local_30 = param_2; local_30 + (int)cVar1 <= param_2 + param_3;
local_30 = local_30 + (int)cVar1) {
memcpy(local_30,local_1a,(long)cVar1);
}
while (local_30 < param_2 + param_3) {
*local_30 = 0x20;
local_30 = local_30 + 1;
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return;
}
| |
44,709 | my_coll_lexem_next | eloqsql/strings/ctype-uca.c | static my_coll_lexem_num my_coll_lexem_next(MY_COLL_LEXEM *lexem)
{
const char *beg;
my_coll_lexem_num rc;
for (beg= lexem->beg ; beg < lexem->end ; beg++)
{
switch (*beg)
{
case ' ':
case '\t':
case '\r':
case '\n':
continue;
case '[': /* Bracket expression, e.g. "[optimize [a-z]]" */
{
size_t nbrackets; /* Indicates nested recursion level */
for (beg++, nbrackets= 1 ; beg < lexem->end; beg++)
{
if (*beg == '[') /* Enter nested bracket expression */
nbrackets++;
else if (*beg == ']')
{
if (--nbrackets == 0)
{
rc= MY_COLL_LEXEM_OPTION;
beg++;
goto ex;
}
}
}
rc= MY_COLL_LEXEM_ERROR;
goto ex;
}
case '&':
beg++;
rc= MY_COLL_LEXEM_RESET;
goto ex;
case '=':
beg++;
lexem->diff= 0;
rc= MY_COLL_LEXEM_SHIFT;
goto ex;
case '/':
beg++;
rc= MY_COLL_LEXEM_EXTEND;
goto ex;
case '|':
beg++;
rc= MY_COLL_LEXEM_CONTEXT;
goto ex;
case '<': /* Shift: '<' or '<<' or '<<<' or '<<<<' */
{
/* Scan up to 3 additional '<' characters */
for (beg++, lexem->diff= 1;
(beg < lexem->end) && (*beg == '<') && (lexem->diff <= 3);
beg++, lexem->diff++);
rc= MY_COLL_LEXEM_SHIFT;
goto ex;
}
default:
break;
}
/* Escaped character, e.g. \u1234 */
if ((*beg == '\\') && (beg + 2 < lexem->end) &&
(beg[1] == 'u') && my_isxdigit(&my_charset_utf8mb3_general_ci, beg[2]))
{
int ch;
beg+= 2;
lexem->code= 0;
while ((beg < lexem->end) && ((ch= ch2x(beg[0])) >= 0))
{
lexem->code= (lexem->code << 4) + ch;
beg++;
}
rc= MY_COLL_LEXEM_CHAR;
goto ex;
}
/*
Unescaped single byte character:
allow printable ASCII range except SPACE and
special characters parsed above []<&/|=
*/
if (*beg >= 0x21 && *beg <= 0x7E)
{
lexem->code= *beg++;
rc= MY_COLL_LEXEM_CHAR;
goto ex;
}
if (((uchar) *beg) > 0x7F) /* Unescaped multibyte character */
{
CHARSET_INFO *cs= &my_charset_utf8mb3_general_ci;
my_wc_t wc;
int nbytes= my_ci_mb_wc(cs, &wc, (uchar *) beg, (uchar *) lexem->end);
if (nbytes > 0)
{
rc= MY_COLL_LEXEM_CHAR;
beg+= nbytes;
lexem->code= (int) wc;
goto ex;
}
}
rc= MY_COLL_LEXEM_ERROR;
goto ex;
}
rc= MY_COLL_LEXEM_EOF;
ex:
lexem->prev= lexem->beg;
lexem->beg= beg;
lexem->term= rc;
return rc;
} | O3 | c | my_coll_lexem_next:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movq 0x10(%rdi), %rcx
xorl %r15d, %r15d
cmpq %rcx, %r14
jae 0x40ca1
movzbl (%r14), %edx
cmpl $0xc, %edx
jle 0x40aa9
cmpl $0x1f, %edx
jle 0x40ab6
cmpl $0x25, %edx
jg 0x40acf
cmpl $0x20, %edx
je 0x40abf
jmp 0x40c5b
leal -0x9(%rdx), %eax
cmpl $0x2, %eax
jb 0x40abf
jmp 0x40c5b
cmpl $0xd, %edx
jne 0x40c5b
incq %r14
cmpq %rcx, %r14
jne 0x40a8c
movq %rcx, %rax
jmp 0x40ca4
cmpl $0x3c, %edx
jle 0x40b2c
cmpl $0x5b, %edx
jg 0x40b8d
cmpl $0x3d, %edx
je 0x40ba9
cmpl $0x5b, %edx
jne 0x40c5b
incq %r14
movl $0x6, %r15d
cmpq %rcx, %r14
jae 0x40ca1
movl $0x1, %eax
movzbl (%r14), %edx
cmpl $0x5d, %edx
je 0x40b19
cmpl $0x5b, %edx
jne 0x40b22
incq %rax
jmp 0x40b22
decq %rax
je 0x40cbe
incq %r14
cmpq %rcx, %r14
jb 0x40b06
jmp 0x40ac7
cmpl $0x26, %edx
je 0x40c50
cmpl $0x2f, %edx
je 0x40c45
cmpl $0x3c, %edx
jne 0x40c5b
incq %r14
movl $0x1, 0x20(%rbx)
movl $0x1, %r15d
cmpq %rcx, %r14
jae 0x40ca1
movl $0x2, %eax
cmpb $0x3c, (%r14)
jne 0x40ca1
leal -0x1(%rax), %edx
cmpl $0x4, %edx
jae 0x40ca1
incq %r14
movl %eax, 0x20(%rbx)
incl %eax
cmpq %rcx, %r14
jb 0x40b65
jmp 0x40ac7
cmpl $0x5c, %edx
je 0x40bbe
cmpl $0x7c, %edx
jne 0x40c5b
incq %r14
movl $0x9, %r15d
jmp 0x40ca1
incq %r14
movl $0x0, 0x20(%rbx)
movl $0x1, %r15d
jmp 0x40ca1
leaq 0x2(%r14), %rax
cmpq %rcx, %rax
jae 0x40c95
cmpb $0x75, 0x1(%r14)
jne 0x40c95
leaq 0x321ce3(%rip), %rsi # 0x3628c0
movq 0x40(%rsi), %rsi
movzbl (%rax), %edi
cmpb $0x0, 0x1(%rsi,%rdi)
jns 0x40c95
movl $0x0, 0x24(%rbx)
xorl %edx, %edx
movsbl (%rax), %esi
leal -0x30(%rsi), %edi
cmpl $0xa, %edi
jb 0x40c2d
leal -0x61(%rsi), %edi
cmpl $0x5, %edi
ja 0x40c10
addl $-0x57, %esi
jmp 0x40c2b
movl $0x5, %r15d
cmpb $0x37, %sil
jl 0x40ca4
leal -0x41(%rsi), %edi
cmpl $0x5, %edi
ja 0x40ca4
addl $-0x37, %esi
movl %esi, %edi
shll $0x4, %edx
addl %edi, %edx
movl %edx, 0x24(%rbx)
incq %rax
movl $0x5, %r15d
cmpq %rcx, %rax
jb 0x40bf8
jmp 0x40ca4
incq %r14
movl $0x8, %r15d
jmp 0x40ca1
incq %r14
movl $0x4, %r15d
jmp 0x40ca1
leal -0x7f(%rdx), %eax
cmpb $-0x5e, %al
jae 0x40c95
movl $0x6, %r15d
testb %dl, %dl
jns 0x40ca1
leaq 0x321c4d(%rip), %rdi # 0x3628c0
movq 0xb8(%rdi), %rax
leaq -0x20(%rbp), %rsi
movq %r14, %rdx
callq *0x28(%rax)
testl %eax, %eax
jle 0x40ca1
movl %eax, %eax
addq %rax, %r14
movl -0x20(%rbp), %eax
movl %eax, 0x24(%rbx)
jmp 0x40c9b
incq %r14
movl %edx, 0x24(%rbx)
movl $0x5, %r15d
movq %r14, %rax
movq 0x8(%rbx), %rcx
movq %rcx, 0x18(%rbx)
movq %rax, 0x8(%rbx)
movl %r15d, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
incq %r14
movl $0x7, %r15d
jmp 0x40ca1
| my_coll_lexem_next:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rdi
mov r14, [rdi+8]
mov rcx, [rdi+10h]
xor r15d, r15d
cmp r14, rcx
jnb loc_40CA1
loc_40A8C:
movzx edx, byte ptr [r14]
cmp edx, 0Ch
jle short loc_40AA9
cmp edx, 1Fh
jle short loc_40AB6
cmp edx, 25h ; '%'
jg short loc_40ACF
cmp edx, 20h ; ' '
jz short loc_40ABF
jmp loc_40C5B
loc_40AA9:
lea eax, [rdx-9]
cmp eax, 2
jb short loc_40ABF
jmp loc_40C5B
loc_40AB6:
cmp edx, 0Dh
jnz loc_40C5B
loc_40ABF:
inc r14
cmp r14, rcx
jnz short loc_40A8C
loc_40AC7:
mov rax, rcx
jmp loc_40CA4
loc_40ACF:
cmp edx, 3Ch ; '<'
jle short loc_40B2C
cmp edx, 5Bh ; '['
jg loc_40B8D
cmp edx, 3Dh ; '='
jz loc_40BA9
cmp edx, 5Bh ; '['
jnz loc_40C5B
inc r14
mov r15d, 6
cmp r14, rcx
jnb loc_40CA1
mov eax, 1
loc_40B06:
movzx edx, byte ptr [r14]
cmp edx, 5Dh ; ']'
jz short loc_40B19
cmp edx, 5Bh ; '['
jnz short loc_40B22
inc rax
jmp short loc_40B22
loc_40B19:
dec rax
jz loc_40CBE
loc_40B22:
inc r14
cmp r14, rcx
jb short loc_40B06
jmp short loc_40AC7
loc_40B2C:
cmp edx, 26h ; '&'
jz loc_40C50
cmp edx, 2Fh ; '/'
jz loc_40C45
cmp edx, 3Ch ; '<'
jnz loc_40C5B
inc r14
mov dword ptr [rbx+20h], 1
mov r15d, 1
cmp r14, rcx
jnb loc_40CA1
mov eax, 2
loc_40B65:
cmp byte ptr [r14], 3Ch ; '<'
jnz loc_40CA1
lea edx, [rax-1]
cmp edx, 4
jnb loc_40CA1
inc r14
mov [rbx+20h], eax
inc eax
cmp r14, rcx
jb short loc_40B65
jmp loc_40AC7
loc_40B8D:
cmp edx, 5Ch ; '\'
jz short loc_40BBE
cmp edx, 7Ch ; '|'
jnz loc_40C5B
inc r14
mov r15d, 9
jmp loc_40CA1
loc_40BA9:
inc r14
mov dword ptr [rbx+20h], 0
mov r15d, 1
jmp loc_40CA1
loc_40BBE:
lea rax, [r14+2]
cmp rax, rcx
jnb loc_40C95
cmp byte ptr [r14+1], 75h ; 'u'
jnz loc_40C95
lea rsi, my_charset_utf8mb3_general_ci
mov rsi, [rsi+40h]
movzx edi, byte ptr [rax]
cmp byte ptr [rsi+rdi+1], 0
jns loc_40C95
mov dword ptr [rbx+24h], 0
xor edx, edx
loc_40BF8:
movsx esi, byte ptr [rax]
lea edi, [rsi-30h]
cmp edi, 0Ah
jb short loc_40C2D
lea edi, [rsi-61h]
cmp edi, 5
ja short loc_40C10
add esi, 0FFFFFFA9h
jmp short loc_40C2B
loc_40C10:
mov r15d, 5
cmp sil, 37h ; '7'
jl loc_40CA4
lea edi, [rsi-41h]
cmp edi, 5
ja short loc_40CA4
add esi, 0FFFFFFC9h
loc_40C2B:
mov edi, esi
loc_40C2D:
shl edx, 4
add edx, edi
mov [rbx+24h], edx
inc rax
mov r15d, 5
cmp rax, rcx
jb short loc_40BF8
jmp short loc_40CA4
loc_40C45:
inc r14
mov r15d, 8
jmp short loc_40CA1
loc_40C50:
inc r14
mov r15d, 4
jmp short loc_40CA1
loc_40C5B:
lea eax, [rdx-7Fh]
cmp al, 0A2h
jnb short loc_40C95
mov r15d, 6
test dl, dl
jns short loc_40CA1
lea rdi, my_charset_utf8mb3_general_ci
mov rax, [rdi+0B8h]
lea rsi, [rbp+var_20]
mov rdx, r14
call qword ptr [rax+28h]
test eax, eax
jle short loc_40CA1
mov eax, eax
add r14, rax
mov eax, [rbp+var_20]
mov [rbx+24h], eax
jmp short loc_40C9B
loc_40C95:
inc r14
mov [rbx+24h], edx
loc_40C9B:
mov r15d, 5
loc_40CA1:
mov rax, r14
loc_40CA4:
mov rcx, [rbx+8]
mov [rbx+18h], rcx
mov [rbx+8], rax
mov [rbx], r15d
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_40CBE:
inc r14
mov r15d, 7
jmp short loc_40CA1
| unsigned __int8 * my_coll_lexem_next(long long a1)
{
long long v1; // rax
unsigned __int8 *v3; // r14
unsigned long long v4; // rcx
int v5; // r15d
unsigned int v6; // edx
unsigned __int8 *result; // rax
long long v8; // rax
int v9; // edx
int v10; // eax
int v11; // edx
int v12; // esi
int v13; // edi
int v14; // esi
int v15; // eax
_QWORD v16[4]; // [rsp+0h] [rbp-20h] BYREF
v16[0] = v1;
v3 = *(unsigned __int8 **)(a1 + 8);
v4 = *(_QWORD *)(a1 + 16);
v5 = 0;
if ( (unsigned long long)v3 >= v4 )
goto LABEL_58;
do
{
v6 = *v3;
if ( v6 <= 0xC )
{
if ( v6 - 9 >= 2 )
goto LABEL_52;
}
else
{
if ( *v3 > 0x1Fu )
{
if ( *v3 <= 0x25u )
{
if ( v6 != 32 )
goto LABEL_52;
goto LABEL_10;
}
if ( *v3 <= 0x3Cu )
{
switch ( v6 )
{
case '&':
++v3;
v5 = 4;
goto LABEL_58;
case '/':
++v3;
v5 = 8;
goto LABEL_58;
case '<':
++v3;
*(_DWORD *)(a1 + 32) = 1;
v5 = 1;
if ( (unsigned long long)v3 >= v4 )
goto LABEL_58;
v10 = 2;
while ( *v3 == 60 && (unsigned int)(v10 - 1) < 4 )
{
++v3;
*(_DWORD *)(a1 + 32) = v10++;
if ( (unsigned long long)v3 >= v4 )
goto LABEL_11;
}
goto LABEL_58;
}
}
else if ( *v3 > 0x5Bu )
{
if ( v6 == 92 )
{
result = v3 + 2;
if ( (unsigned long long)(v3 + 2) < v4
&& v3[1] == 117
&& *(char *)(*(_QWORD *)&my_charset_utf8mb3_general_ci[16] + *result + 1LL) < 0 )
{
*(_DWORD *)(a1 + 36) = 0;
v11 = 0;
while ( 1 )
{
v12 = (char)*result;
v13 = v12 - 48;
if ( (unsigned int)(v12 - 48) >= 0xA )
{
if ( (unsigned int)(v12 - 97) > 5 )
{
v5 = 5;
if ( (char)v12 < 55 || (unsigned int)(v12 - 65) > 5 )
goto LABEL_59;
v14 = v12 - 55;
}
else
{
v14 = v12 - 87;
}
v13 = v14;
}
v11 = v13 + 16 * v11;
*(_DWORD *)(a1 + 36) = v11;
++result;
v5 = 5;
if ( (unsigned long long)result >= v4 )
goto LABEL_59;
}
}
goto LABEL_56;
}
if ( v6 == 124 )
{
++v3;
v5 = 9;
goto LABEL_58;
}
}
else
{
if ( v6 == 61 )
{
++v3;
*(_DWORD *)(a1 + 32) = 0;
v5 = 1;
goto LABEL_58;
}
if ( v6 == 91 )
{
++v3;
v5 = 6;
if ( (unsigned long long)v3 >= v4 )
goto LABEL_58;
v8 = 1LL;
while ( 1 )
{
v9 = *v3;
if ( v9 == 93 )
{
if ( !--v8 )
{
++v3;
v5 = 7;
goto LABEL_58;
}
}
else if ( v9 == 91 )
{
++v8;
}
if ( (unsigned long long)++v3 >= v4 )
goto LABEL_11;
}
}
}
LABEL_52:
if ( (unsigned __int8)(v6 - 127) < 0xA2u )
{
v5 = 6;
if ( (v6 & 0x80u) != 0 )
{
v15 = (*(long long ( **)(unsigned int *, _QWORD *, unsigned __int8 *))(*(_QWORD *)&my_charset_utf8mb3_general_ci[46]
+ 40LL))(
my_charset_utf8mb3_general_ci,
v16,
v3);
if ( v15 > 0 )
{
v3 += (unsigned int)v15;
*(_DWORD *)(a1 + 36) = v16[0];
LABEL_57:
v5 = 5;
}
}
LABEL_58:
result = v3;
goto LABEL_59;
}
LABEL_56:
++v3;
*(_DWORD *)(a1 + 36) = v6;
goto LABEL_57;
}
if ( v6 != 13 )
goto LABEL_52;
}
LABEL_10:
++v3;
}
while ( v3 != (unsigned __int8 *)v4 );
LABEL_11:
result = (unsigned __int8 *)v4;
LABEL_59:
*(_QWORD *)(a1 + 24) = *(_QWORD *)(a1 + 8);
*(_QWORD *)(a1 + 8) = result;
*(_DWORD *)a1 = v5;
return result;
}
| my_coll_lexem_next:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV R14,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RDI + 0x10]
XOR R15D,R15D
CMP R14,RCX
JNC 0x00140ca1
LAB_00140a8c:
MOVZX EDX,byte ptr [R14]
CMP EDX,0xc
JLE 0x00140aa9
CMP EDX,0x1f
JLE 0x00140ab6
CMP EDX,0x25
JG 0x00140acf
CMP EDX,0x20
JZ 0x00140abf
JMP 0x00140c5b
LAB_00140aa9:
LEA EAX,[RDX + -0x9]
CMP EAX,0x2
JC 0x00140abf
JMP 0x00140c5b
LAB_00140ab6:
CMP EDX,0xd
JNZ 0x00140c5b
LAB_00140abf:
INC R14
CMP R14,RCX
JNZ 0x00140a8c
LAB_00140ac7:
MOV RAX,RCX
JMP 0x00140ca4
LAB_00140acf:
CMP EDX,0x3c
JLE 0x00140b2c
CMP EDX,0x5b
JG 0x00140b8d
CMP EDX,0x3d
JZ 0x00140ba9
CMP EDX,0x5b
JNZ 0x00140c5b
INC R14
MOV R15D,0x6
CMP R14,RCX
JNC 0x00140ca1
MOV EAX,0x1
LAB_00140b06:
MOVZX EDX,byte ptr [R14]
CMP EDX,0x5d
JZ 0x00140b19
CMP EDX,0x5b
JNZ 0x00140b22
INC RAX
JMP 0x00140b22
LAB_00140b19:
DEC RAX
JZ 0x00140cbe
LAB_00140b22:
INC R14
CMP R14,RCX
JC 0x00140b06
JMP 0x00140ac7
LAB_00140b2c:
CMP EDX,0x26
JZ 0x00140c50
CMP EDX,0x2f
JZ 0x00140c45
CMP EDX,0x3c
JNZ 0x00140c5b
INC R14
MOV dword ptr [RBX + 0x20],0x1
MOV R15D,0x1
CMP R14,RCX
JNC 0x00140ca1
MOV EAX,0x2
LAB_00140b65:
CMP byte ptr [R14],0x3c
JNZ 0x00140ca1
LEA EDX,[RAX + -0x1]
CMP EDX,0x4
JNC 0x00140ca1
INC R14
MOV dword ptr [RBX + 0x20],EAX
INC EAX
CMP R14,RCX
JC 0x00140b65
JMP 0x00140ac7
LAB_00140b8d:
CMP EDX,0x5c
JZ 0x00140bbe
CMP EDX,0x7c
JNZ 0x00140c5b
INC R14
MOV R15D,0x9
JMP 0x00140ca1
LAB_00140ba9:
INC R14
MOV dword ptr [RBX + 0x20],0x0
MOV R15D,0x1
JMP 0x00140ca1
LAB_00140bbe:
LEA RAX,[R14 + 0x2]
CMP RAX,RCX
JNC 0x00140c95
CMP byte ptr [R14 + 0x1],0x75
JNZ 0x00140c95
LEA RSI,[0x4628c0]
MOV RSI,qword ptr [RSI + 0x40]
MOVZX EDI,byte ptr [RAX]
CMP byte ptr [RSI + RDI*0x1 + 0x1],0x0
JNS 0x00140c95
MOV dword ptr [RBX + 0x24],0x0
XOR EDX,EDX
LAB_00140bf8:
MOVSX ESI,byte ptr [RAX]
LEA EDI,[RSI + -0x30]
CMP EDI,0xa
JC 0x00140c2d
LEA EDI,[RSI + -0x61]
CMP EDI,0x5
JA 0x00140c10
ADD ESI,-0x57
JMP 0x00140c2b
LAB_00140c10:
MOV R15D,0x5
CMP SIL,0x37
JL 0x00140ca4
LEA EDI,[RSI + -0x41]
CMP EDI,0x5
JA 0x00140ca4
ADD ESI,-0x37
LAB_00140c2b:
MOV EDI,ESI
LAB_00140c2d:
SHL EDX,0x4
ADD EDX,EDI
MOV dword ptr [RBX + 0x24],EDX
INC RAX
MOV R15D,0x5
CMP RAX,RCX
JC 0x00140bf8
JMP 0x00140ca4
LAB_00140c45:
INC R14
MOV R15D,0x8
JMP 0x00140ca1
LAB_00140c50:
INC R14
MOV R15D,0x4
JMP 0x00140ca1
LAB_00140c5b:
LEA EAX,[RDX + -0x7f]
CMP AL,0xa2
JNC 0x00140c95
MOV R15D,0x6
TEST DL,DL
JNS 0x00140ca1
LEA RDI,[0x4628c0]
MOV RAX,qword ptr [RDI + 0xb8]
LEA RSI,[RBP + -0x20]
MOV RDX,R14
CALL qword ptr [RAX + 0x28]
TEST EAX,EAX
JLE 0x00140ca1
MOV EAX,EAX
ADD R14,RAX
MOV EAX,dword ptr [RBP + -0x20]
MOV dword ptr [RBX + 0x24],EAX
JMP 0x00140c9b
LAB_00140c95:
INC R14
MOV dword ptr [RBX + 0x24],EDX
LAB_00140c9b:
MOV R15D,0x5
LAB_00140ca1:
MOV RAX,R14
LAB_00140ca4:
MOV RCX,qword ptr [RBX + 0x8]
MOV qword ptr [RBX + 0x18],RCX
MOV qword ptr [RBX + 0x8],RAX
MOV dword ptr [RBX],R15D
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00140cbe:
INC R14
MOV R15D,0x7
JMP 0x00140ca1
|
void my_coll_lexem_next(int4 *param_1)
{
byte bVar1;
byte *pbVar2;
int4 in_EAX;
uint uVar3;
long lVar4;
int iVar5;
int iVar6;
byte *pbVar7;
byte *pbVar8;
int4 uVar9;
int4 local_28 [2];
pbVar7 = *(byte **)(param_1 + 2);
pbVar2 = *(byte **)(param_1 + 4);
uVar9 = 0;
pbVar8 = pbVar7;
if (pbVar7 < pbVar2) {
do {
bVar1 = *pbVar7;
uVar3 = (uint)bVar1;
if (0xc < bVar1) {
if (bVar1 < 0x20) {
if (uVar3 == 0xd) goto LAB_00140abf;
LAB_00140c5b:
if (0xa1 < (byte)(bVar1 + 0x81)) goto LAB_00140c95;
uVar9 = 6;
pbVar8 = pbVar7;
if ((-1 < (char)bVar1) ||
(local_28[0] = in_EAX,
uVar3 = (**(code **)(my_charset_utf8mb3_general_ci._184_8_ + 0x28))
(my_charset_utf8mb3_general_ci,local_28,pbVar7), (int)uVar3 < 1))
break;
pbVar8 = pbVar7 + uVar3;
param_1[9] = local_28[0];
}
else {
if (bVar1 < 0x26) {
if (uVar3 == 0x20) goto LAB_00140abf;
goto LAB_00140c5b;
}
if (bVar1 < 0x3d) {
if (uVar3 == 0x26) {
uVar9 = 4;
pbVar8 = pbVar7 + 1;
}
else if (uVar3 == 0x2f) {
uVar9 = 8;
pbVar8 = pbVar7 + 1;
}
else {
if (uVar3 != 0x3c) goto LAB_00140c5b;
pbVar7 = pbVar7 + 1;
param_1[8] = 1;
uVar9 = 1;
pbVar8 = pbVar7;
if (pbVar7 < pbVar2) {
iVar5 = 2;
goto LAB_00140b65;
}
}
break;
}
if (bVar1 < 0x5c) {
if (uVar3 == 0x3d) {
param_1[8] = 0;
uVar9 = 1;
pbVar8 = pbVar7 + 1;
}
else {
if (uVar3 != 0x5b) goto LAB_00140c5b;
pbVar7 = pbVar7 + 1;
uVar9 = 6;
pbVar8 = pbVar7;
if (pbVar7 < pbVar2) {
lVar4 = 1;
goto LAB_00140b06;
}
}
break;
}
if (uVar3 != 0x5c) {
if (uVar3 != 0x7c) goto LAB_00140c5b;
uVar9 = 9;
pbVar8 = pbVar7 + 1;
break;
}
pbVar8 = pbVar7 + 2;
if (((pbVar8 < pbVar2) && (pbVar7[1] == 0x75)) &&
(*(char *)(my_charset_utf8mb3_general_ci._64_8_ + 1 + (ulong)*pbVar8) < '\0')) {
param_1[9] = 0;
iVar5 = 0;
goto LAB_00140bf8;
}
LAB_00140c95:
pbVar8 = pbVar7 + 1;
param_1[9] = uVar3;
}
uVar9 = 5;
break;
}
if (1 < bVar1 - 9) goto LAB_00140c5b;
LAB_00140abf:
pbVar7 = pbVar7 + 1;
pbVar8 = pbVar2;
} while (pbVar7 != pbVar2);
}
goto LAB_00140ca4;
while( true ) {
pbVar7 = pbVar7 + 1;
param_1[8] = iVar5;
iVar5 = iVar5 + 1;
pbVar8 = pbVar2;
if (pbVar2 <= pbVar7) break;
LAB_00140b65:
pbVar8 = pbVar7;
if ((*pbVar7 != 0x3c) || (3 < iVar5 - 1U)) break;
}
goto LAB_00140ca4;
LAB_00140b06:
do {
if (*pbVar7 == 0x5d) {
lVar4 = lVar4 + -1;
if (lVar4 == 0) {
uVar9 = 7;
pbVar8 = pbVar7 + 1;
break;
}
}
else if (*pbVar7 == 0x5b) {
lVar4 = lVar4 + 1;
}
pbVar7 = pbVar7 + 1;
pbVar8 = pbVar2;
} while (pbVar7 < pbVar2);
goto LAB_00140ca4;
LAB_00140bf8:
do {
iVar6 = (int)(char)*pbVar8;
uVar3 = iVar6 - 0x30;
if (9 < uVar3) {
if (iVar6 - 0x61U < 6) {
uVar3 = iVar6 - 0x57;
}
else {
uVar9 = 5;
if (((char)*pbVar8 < '7') || (5 < iVar6 - 0x41U)) break;
uVar3 = iVar6 - 0x37;
}
}
iVar5 = iVar5 * 0x10 + uVar3;
param_1[9] = iVar5;
pbVar8 = pbVar8 + 1;
uVar9 = 5;
} while (pbVar8 < pbVar2);
LAB_00140ca4:
*(int8 *)(param_1 + 6) = *(int8 *)(param_1 + 2);
*(byte **)(param_1 + 2) = pbVar8;
*param_1 = uVar9;
return;
}
| |
44,710 | init_server_psi_keys() | eloqsql/sql/mysqld.cc | void init_server_psi_keys(void)
{
const char* category= "sql";
int count;
count= array_elements(all_server_mutexes);
mysql_mutex_register(category, all_server_mutexes, count);
count= array_elements(all_server_rwlocks);
mysql_rwlock_register(category, all_server_rwlocks, count);
count= array_elements(all_server_conds);
mysql_cond_register(category, all_server_conds, count);
count= array_elements(all_server_threads);
mysql_thread_register(category, all_server_threads, count);
count= array_elements(all_server_files);
mysql_file_register(category, all_server_files, count);
count= array_elements(all_server_stages);
mysql_stage_register(category, all_server_stages, count);
count= array_elements(all_server_sockets);
mysql_socket_register(category, all_server_sockets, count);
count= array_elements(all_server_memory);
mysql_memory_register(category, all_server_memory, count);
#ifdef HAVE_PSI_STATEMENT_INTERFACE
init_sql_statement_info();
count= array_elements(sql_statement_info);
mysql_statement_register(category, sql_statement_info, count);
init_sp_psi_keys();
category= "com";
init_com_statement_info();
/*
Register [0 .. COM_QUERY - 1] as "statement/com/..."
*/
count= (int) COM_QUERY;
mysql_statement_register(category, com_statement_info, count);
/*
Register [COM_QUERY + 1 .. COM_END] as "statement/com/..."
*/
count= (int) COM_END - (int) COM_QUERY;
mysql_statement_register(category, & com_statement_info[(int) COM_QUERY + 1], count);
category= "abstract";
/*
Register [COM_QUERY] as "statement/abstract/com_query"
*/
mysql_statement_register(category, & com_statement_info[(int) COM_QUERY], 1);
/*
When a new packet is received,
it is instrumented as "statement/abstract/new_packet".
Based on the packet type found, it later mutates to the
proper narrow type, for example
"statement/abstract/query" or "statement/com/ping".
In cases of "statement/abstract/query", SQL queries are given to
the parser, which mutates the statement type to an even more
narrow classification, for example "statement/sql/select".
*/
stmt_info_new_packet.m_key= 0;
stmt_info_new_packet.m_name= "new_packet";
stmt_info_new_packet.m_flags= PSI_FLAG_MUTABLE;
mysql_statement_register(category, &stmt_info_new_packet, 1);
/*
Statements processed from the relay log are initially instrumented as
"statement/abstract/relay_log". The parser will mutate the statement type to
a more specific classification, for example "statement/sql/insert".
*/
stmt_info_rpl.m_key= 0;
stmt_info_rpl.m_name= "relay_log";
stmt_info_rpl.m_flags= PSI_FLAG_MUTABLE;
mysql_statement_register(category, &stmt_info_rpl, 1);
#endif
} | O0 | cpp | init_server_psi_keys():
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xbe8d7d(%rip), %rax # 0x147b59c
movq %rax, -0x8(%rbp)
movl $0x45, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x12b3c58(%rip), %rsi # 0x1b46490
callq 0x899a90
movl $0xc, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x12b42be(%rip), %rsi # 0x1b46b10
callq 0x899ac0
movl $0x2d, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x12b43c4(%rip), %rsi # 0x1b46c30
callq 0x899af0
movl $0x8, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x12b47ea(%rip), %rsi # 0x1b47070
callq 0x899b20
movl $0x24, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x12b4890(%rip), %rsi # 0x1b47130
callq 0x899b50
movl $0x85, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x12b37a6(%rip), %rsi # 0x1b46060
callq 0x899b90
movl $0x3, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x12b4bbc(%rip), %rsi # 0x1b47490
callq 0x899bd0
movl $0x50, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x12b4bf2(%rip), %rsi # 0x1b474e0
callq 0x899c10
callq 0x891320
movl $0xa2, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x14b8c13(%rip), %rsi # 0x1d4b520
callq 0x899c50
callq 0x9000d0
leaq 0xb9007c(%rip), %rax # 0x142299a
movq %rax, -0x8(%rbp)
callq 0x891420
movl $0x3, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x14b9b14(%rip), %rsi # 0x1d4c450
callq 0x899c50
movl $0xfc, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x14b9afa(%rip), %rsi # 0x1d4c450
addq $0x60, %rsi
callq 0x899c50
leaq 0xb7f411(%rip), %rax # 0x1411d77
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x14b9adb(%rip), %rsi # 0x1d4c450
addq $0x48, %rsi
movl $0x1, %edx
callq 0x899c50
movl $0x0, 0x14b8773(%rip) # 0x1d4b100
leaq 0xb7f3ec(%rip), %rax # 0x1411d80
movq %rax, 0x14b876d(%rip) # 0x1d4b108
movl $0x2, 0x14b876b(%rip) # 0x1d4b110
movq -0x8(%rbp), %rdi
leaq 0x14b8750(%rip), %rsi # 0x1d4b100
movl $0x1, %edx
callq 0x899c50
movl $0x0, 0x14b50a4(%rip) # 0x1d47a68
leaq 0xba6e3a(%rip), %rax # 0x1439805
movq %rax, 0x14b509e(%rip) # 0x1d47a70
movl $0x2, 0x14b509c(%rip) # 0x1d47a78
movq -0x8(%rbp), %rdi
leaq 0x14b5081(%rip), %rsi # 0x1d47a68
movl $0x1, %edx
callq 0x899c50
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| _Z20init_server_psi_keysv:
push rbp
mov rbp, rsp
sub rsp, 10h
lea rax, aSql+2; "sql"
mov [rbp+var_8], rax
mov [rbp+var_C], 45h ; 'E'
mov rdi, [rbp+var_8]
mov edx, [rbp+var_C]
lea rsi, _ZL18all_server_mutexes; all_server_mutexes
call _ZL27inline_mysql_mutex_registerPKcP17PSI_mutex_info_v1i; inline_mysql_mutex_register(char const*,PSI_mutex_info_v1 *,int)
mov [rbp+var_C], 0Ch
mov rdi, [rbp+var_8]
mov edx, [rbp+var_C]
lea rsi, _ZL18all_server_rwlocks; all_server_rwlocks
call _ZL28inline_mysql_rwlock_registerPKcP18PSI_rwlock_info_v1i; inline_mysql_rwlock_register(char const*,PSI_rwlock_info_v1 *,int)
mov [rbp+var_C], 2Dh ; '-'
mov rdi, [rbp+var_8]
mov edx, [rbp+var_C]
lea rsi, _ZL16all_server_conds; all_server_conds
call _ZL26inline_mysql_cond_registerPKcP16PSI_cond_info_v1i; inline_mysql_cond_register(char const*,PSI_cond_info_v1 *,int)
mov [rbp+var_C], 8
mov rdi, [rbp+var_8]
mov edx, [rbp+var_C]
lea rsi, _ZL18all_server_threads; all_server_threads
call _ZL28inline_mysql_thread_registerPKcP18PSI_thread_info_v1i; inline_mysql_thread_register(char const*,PSI_thread_info_v1 *,int)
mov [rbp+var_C], 24h ; '$'
mov rdi, [rbp+var_8]
mov edx, [rbp+var_C]
lea rsi, _ZL16all_server_files; all_server_files
call _ZL26inline_mysql_file_registerPKcP16PSI_file_info_v1i; inline_mysql_file_register(char const*,PSI_file_info_v1 *,int)
mov [rbp+var_C], 85h
mov rdi, [rbp+var_8]
mov edx, [rbp+var_C]
lea rsi, all_server_stages
call _ZL27inline_mysql_stage_registerPKcPP17PSI_stage_info_v1i; inline_mysql_stage_register(char const*,PSI_stage_info_v1 **,int)
mov [rbp+var_C], 3
mov rdi, [rbp+var_8]
mov edx, [rbp+var_C]
lea rsi, _ZL18all_server_sockets; all_server_sockets
call _ZL28inline_mysql_socket_registerPKcP18PSI_socket_info_v1i; inline_mysql_socket_register(char const*,PSI_socket_info_v1 *,int)
mov [rbp+var_C], 50h ; 'P'
mov rdi, [rbp+var_8]
mov edx, [rbp+var_C]
lea rsi, _ZL17all_server_memory; all_server_memory
call _ZL28inline_mysql_memory_registerPKcP18PSI_memory_info_v1i; inline_mysql_memory_register(char const*,PSI_memory_info_v1 *,int)
call _Z23init_sql_statement_infov; init_sql_statement_info(void)
mov [rbp+var_C], 0A2h
mov rdi, [rbp+var_8]
mov edx, [rbp+var_C]
lea rsi, sql_statement_info
call _ZL31inline_mysql_statement_registerPKcP21PSI_statement_info_v1i; inline_mysql_statement_register(char const*,PSI_statement_info_v1 *,int)
call _Z16init_sp_psi_keysv; init_sp_psi_keys(void)
lea rax, aHttpsVismaCom+0Eh; "com"
mov [rbp+var_8], rax
call _Z23init_com_statement_infov; init_com_statement_info(void)
mov [rbp+var_C], 3
mov rdi, [rbp+var_8]
mov edx, [rbp+var_C]
lea rsi, com_statement_info
call _ZL31inline_mysql_statement_registerPKcP21PSI_statement_info_v1i; inline_mysql_statement_register(char const*,PSI_statement_info_v1 *,int)
mov [rbp+var_C], 0FCh
mov rdi, [rbp+var_8]
mov edx, [rbp+var_C]
lea rsi, com_statement_info
add rsi, 60h ; '`'
call _ZL31inline_mysql_statement_registerPKcP21PSI_statement_info_v1i; inline_mysql_statement_register(char const*,PSI_statement_info_v1 *,int)
lea rax, aAbstract; "abstract"
mov [rbp+var_8], rax
mov rdi, [rbp+var_8]
lea rsi, com_statement_info
add rsi, 48h ; 'H'
mov edx, 1
call _ZL31inline_mysql_statement_registerPKcP21PSI_statement_info_v1i; inline_mysql_statement_register(char const*,PSI_statement_info_v1 *,int)
mov cs:stmt_info_new_packet, 0
lea rax, aNewPacket; "new_packet"
mov cs:qword_1D4B108, rax
mov cs:dword_1D4B110, 2
mov rdi, [rbp+var_8]
lea rsi, stmt_info_new_packet
mov edx, 1
call _ZL31inline_mysql_statement_registerPKcP21PSI_statement_info_v1i; inline_mysql_statement_register(char const*,PSI_statement_info_v1 *,int)
mov cs:stmt_info_rpl, 0
lea rax, aSyncRelayLog+5; "relay_log"
mov cs:qword_1D47A70, rax
mov cs:dword_1D47A78, 2
mov rdi, [rbp+var_8]
lea rsi, stmt_info_rpl
mov edx, 1
call _ZL31inline_mysql_statement_registerPKcP21PSI_statement_info_v1i; inline_mysql_statement_register(char const*,PSI_statement_info_v1 *,int)
add rsp, 10h
pop rbp
retn
| long long init_server_psi_keys(void)
{
inline_mysql_mutex_register("sql", &all_server_mutexes, 69LL);
inline_mysql_rwlock_register("sql", &all_server_rwlocks, 12LL);
inline_mysql_cond_register("sql", &all_server_conds, 45LL);
inline_mysql_thread_register("sql", &all_server_threads, 8LL);
inline_mysql_file_register("sql", &all_server_files, 36LL);
inline_mysql_stage_register("sql", &all_server_stages, 133LL);
inline_mysql_socket_register("sql", &all_server_sockets, 3LL);
inline_mysql_memory_register("sql", &all_server_memory, 80LL);
init_sql_statement_info();
inline_mysql_statement_register("sql", &sql_statement_info, 162LL);
init_sp_psi_keys();
init_com_statement_info();
inline_mysql_statement_register("com", &com_statement_info, 3LL);
inline_mysql_statement_register("com", (char *)&com_statement_info + 96, 252LL);
inline_mysql_statement_register("abstract", (char *)&com_statement_info + 72, 1LL);
stmt_info_new_packet = 0;
qword_1D4B108 = (long long)"new_packet";
dword_1D4B110 = 2;
inline_mysql_statement_register("abstract", &stmt_info_new_packet, 1LL);
stmt_info_rpl = 0;
qword_1D47A70 = (long long)"relay_log";
dword_1D47A78 = 2;
return inline_mysql_statement_register("abstract", &stmt_info_rpl, 1LL);
}
| __cxx_global_var_init.1:
PUSH RBP
MOV RBP,RSP
LEA RDI,[0x1e5ad64]
MOV ESI,0x1
CALL 0x008fd530
POP RBP
RET
|
void __cxx_global_var_init_1(void)
{
date_conv_mode_t::date_conv_mode_t((date_conv_mode_t *)&TIME_FUZZY_DATES,1);
return;
}
| |
44,711 | LefDefParser::lefiPin::propNum(int) const | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiMacro.cpp | double
lefiPin::propNum(int index) const
{
char msg[160];
if (index < 0 || index >= numProperties_) {
sprintf(msg, "ERROR (LEFPARS-1352): The index number %d given for the macro property is invalid.\nValid index is from 0 to %d", index, numProperties_);
lefiError(0, 1352, msg);
return 0;
}
return propNums_[index];
} | O3 | cpp | LefDefParser::lefiPin::propNum(int) const:
movl %esi, %edx
testl %esi, %esi
setns %al
movl 0x28c(%rdi), %ecx
cmpl %esi, %ecx
setg %sil
testb %sil, %al
je 0x36f5b
movq 0x2a8(%rdi), %rax
movl %edx, %ecx
movsd (%rax,%rcx,8), %xmm0
retq
pushq %rbx
subq $0xa0, %rsp
leaq 0x29e07(%rip), %rsi # 0x60d71
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2050
xorl %edi, %edi
movl $0x548, %esi # imm = 0x548
movq %rbx, %rdx
callq 0x33d78
xorps %xmm0, %xmm0
addq $0xa0, %rsp
popq %rbx
retq
| _ZNK12LefDefParser7lefiPin7propNumEi:
mov edx, esi
test esi, esi
setns al
mov ecx, [rdi+28Ch]
cmp ecx, esi
setnle sil
test al, sil
jz short loc_36F5B
mov rax, [rdi+2A8h]
mov ecx, edx
movsd xmm0, qword ptr [rax+rcx*8]
retn
loc_36F5B:
push rbx
sub rsp, 0A0h
lea rsi, aErrorLefpars13_24; "ERROR (LEFPARS-1352): The index number "...
mov rbx, rsp
mov rdi, rbx
xor eax, eax
call _sprintf
xor edi, edi; this
mov esi, 548h; int
mov rdx, rbx; int
call _ZN12LefDefParser9lefiErrorEiiPKc; LefDefParser::lefiError(int,int,char const*)
xorps xmm0, xmm0
add rsp, 0A0h
pop rbx
retn
| double LefDefParser::lefiPin::propNum(LefDefParser::lefiPin *this, signed int a2)
{
int v2; // ecx
const char *v4; // rcx
_BYTE v5[168]; // [rsp-A8h] [rbp-A8h] BYREF
v2 = *((_DWORD *)this + 163);
if ( v2 > a2 && a2 >= 0 )
return *(double *)(*((_QWORD *)this + 85) + 8LL * (unsigned int)a2);
sprintf(
v5,
"ERROR (LEFPARS-1352): The index number %d given for the macro property is invalid.\nValid index is from 0 to %d",
a2,
v2);
LefDefParser::lefiError(0LL, 1352, (long long)v5, v4);
return 0.0;
}
| propNum:
MOV EDX,ESI
TEST ESI,ESI
SETNS AL
MOV ECX,dword ptr [RDI + 0x28c]
CMP ECX,ESI
SETG SIL
TEST AL,SIL
JZ 0x00136f5b
MOV RAX,qword ptr [RDI + 0x2a8]
MOV ECX,EDX
MOVSD XMM0,qword ptr [RAX + RCX*0x8]
RET
LAB_00136f5b:
PUSH RBX
SUB RSP,0xa0
LEA RSI,[0x160d71]
MOV RBX,RSP
MOV RDI,RBX
XOR EAX,EAX
CALL 0x00102050
XOR EDI,EDI
MOV ESI,0x548
MOV RDX,RBX
CALL 0x00133d78
XORPS XMM0,XMM0
ADD RSP,0xa0
POP RBX
RET
|
/* LefDefParser::lefiPin::propNum(int) const */
int8 __thiscall LefDefParser::lefiPin::propNum(lefiPin *this,int param_1)
{
char acStack_a8 [160];
if (-1 < param_1 && param_1 < *(int *)(this + 0x28c)) {
return *(int8 *)(*(long *)(this + 0x2a8) + (ulong)(uint)param_1 * 8);
}
sprintf(acStack_a8,
"ERROR (LEFPARS-1352): The index number %d given for the macro property is invalid.\nValid index is from 0 to %d"
);
lefiError(0,0x548,acStack_a8);
return 0;
}
| |
44,712 | pvio_socket_write | eloqsql/libmariadb/plugins/pvio/pvio_socket.c | ssize_t pvio_socket_write(MARIADB_PVIO *pvio, const uchar *buffer, size_t length)
{
ssize_t r;
struct st_pvio_socket *csock;
int timeout;
int send_flags= MSG_DONTWAIT;
#ifdef MSG_NOSIGNAL
send_flags|= MSG_NOSIGNAL;
#endif
if (!pvio || !pvio->data)
return -1;
csock= (struct st_pvio_socket *)pvio->data;
timeout = pvio->timeout[PVIO_WRITE_TIMEOUT];
while ((r = ma_send(csock->socket, (void *)buffer, length,send_flags)) == -1)
{
int err = socket_errno;
if ((err != SOCKET_EAGAIN
#ifdef HAVE_SOCKET_EWOULDBLOCK
&& err != SOCKET_EWOULDBLOCK
#endif
)|| timeout == 0)
return r;
if (pvio_socket_wait_io_or_timeout(pvio, FALSE, timeout) < 1)
return -1;
}
return r;
} | O3 | c | pvio_socket_write:
movq $-0x1, %rax
testq %rdi, %rdi
je 0x2ec65
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x2ec57
movq %rdx, %r14
movq %rsi, %r15
movl 0x2c(%r12), %r13d
movl (%rbx), %edi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2f7cf
cmpq $-0x1, %rax
jne 0x2ec57
callq 0x13060
cmpl $0xb, (%rax)
jne 0x2ec50
testl %r13d, %r13d
je 0x2ec50
movq %r12, %rdi
xorl %esi, %esi
movl %r13d, %edx
callq 0x2ec88
testl %eax, %eax
jg 0x2ec1d
movq $-0x1, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| pvio_socket_write:
mov rax, 0FFFFFFFFFFFFFFFFh
test rdi, rdi
jz short locret_2EC65
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r12, rdi
mov rbx, [rdi]
test rbx, rbx
jz short loc_2EC57
mov r14, rdx
mov r15, rsi
mov r13d, [r12+2Ch]
loc_2EC1D:
mov edi, [rbx]
mov rsi, r15
mov rdx, r14
call ma_send
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_2EC57
call ___errno_location
cmp dword ptr [rax], 0Bh
jnz short loc_2EC50
test r13d, r13d
jz short loc_2EC50
mov rdi, r12
xor esi, esi
mov edx, r13d
call pvio_socket_wait_io_or_timeout
test eax, eax
jg short loc_2EC1D
loc_2EC50:
mov rax, 0FFFFFFFFFFFFFFFFh
loc_2EC57:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
locret_2EC65:
retn
| long long pvio_socket_write(unsigned int **a1, long long a2, long long a3)
{
long long result; // rax
unsigned int *v5; // rbx
unsigned int v7; // r13d
long long v8; // rdi
result = -1LL;
if ( a1 )
{
v5 = *a1;
if ( *a1 )
{
v7 = *((_DWORD *)a1 + 11);
while ( 1 )
{
v8 = *v5;
result = ma_send(v8, a2, a3);
if ( result != -1 )
break;
if ( *(_DWORD *)__errno_location(v8) != 11 || !v7 || (int)pvio_socket_wait_io_or_timeout(a1, 0LL, v7) <= 0 )
return -1LL;
}
}
}
return result;
}
| pvio_socket_write:
MOV RAX,-0x1
TEST RDI,RDI
JZ 0x0012ec65
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R12,RDI
MOV RBX,qword ptr [RDI]
TEST RBX,RBX
JZ 0x0012ec57
MOV R14,RDX
MOV R15,RSI
MOV R13D,dword ptr [R12 + 0x2c]
LAB_0012ec1d:
MOV EDI,dword ptr [RBX]
MOV RSI,R15
MOV RDX,R14
CALL 0x0012f7cf
CMP RAX,-0x1
JNZ 0x0012ec57
CALL 0x00113060
CMP dword ptr [RAX],0xb
JNZ 0x0012ec50
TEST R13D,R13D
JZ 0x0012ec50
MOV RDI,R12
XOR ESI,ESI
MOV EDX,R13D
CALL 0x0012ec88
TEST EAX,EAX
JG 0x0012ec1d
LAB_0012ec50:
MOV RAX,-0x1
LAB_0012ec57:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
LAB_0012ec65:
RET
|
long pvio_socket_write(int8 *param_1,int8 param_2,int8 param_3)
{
int iVar1;
int4 *puVar2;
int iVar3;
long lVar4;
int *piVar5;
if ((param_1 != (int8 *)0x0) &&
(puVar2 = (int4 *)*param_1, puVar2 != (int4 *)0x0)) {
iVar1 = *(int *)((long)param_1 + 0x2c);
do {
lVar4 = ma_send(*puVar2,param_2,param_3);
if (lVar4 != -1) {
return lVar4;
}
piVar5 = __errno_location();
} while (((*piVar5 == 0xb) && (iVar1 != 0)) &&
(iVar3 = pvio_socket_wait_io_or_timeout(param_1,0,iVar1), 0 < iVar3));
}
return -1;
}
| |
44,713 | js_string_slice | bluesky950520[P]quickjs/quickjs.c | static JSValue js_string_slice(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue str, ret;
int len, start, end;
JSString *p;
str = JS_ToStringCheckObject(ctx, this_val);
if (JS_IsException(str))
return str;
p = JS_VALUE_GET_STRING(str);
len = p->len;
if (JS_ToInt32Clamp(ctx, &start, argv[0], 0, len, len)) {
JS_FreeValue(ctx, str);
return JS_EXCEPTION;
}
end = len;
if (!JS_IsUndefined(argv[1])) {
if (JS_ToInt32Clamp(ctx, &end, argv[1], 0, len, len)) {
JS_FreeValue(ctx, str);
return JS_EXCEPTION;
}
}
ret = js_sub_string(ctx, p, start, max_int(end, start));
JS_FreeValue(ctx, str);
return ret;
} | O1 | c | js_string_slice:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbp
movq %rdi, %r14
callq 0x419eb
movq %rdx, %rbx
movq %rax, 0x18(%rsp)
cmpl $0x6, %ebx
jne 0x7b4cf
movq %rax, %r15
jmp 0x7b575
movq 0x18(%rsp), %r13
movl $0x7fffffff, %r12d # imm = 0x7FFFFFFF
andl 0x4(%r13), %r12d
movq (%rbp), %rdx
movq 0x8(%rbp), %rcx
movl %r12d, (%rsp)
leaq 0x14(%rsp), %rsi
xorl %r15d, %r15d
movq %r14, %rdi
xorl %r8d, %r8d
movl %r12d, %r9d
callq 0x26b42
testl %eax, %eax
je 0x7b50c
movl $0x6, %r12d
jmp 0x7b561
movq %r13, 0x20(%rsp)
movl %r12d, 0x10(%rsp)
movq 0x18(%rbp), %rcx
cmpl $0x3, %ecx
je 0x7b541
movq 0x10(%rbp), %rdx
movl %r12d, (%rsp)
leaq 0x10(%rsp), %rsi
xorl %r15d, %r15d
movq %r14, %rdi
xorl %r8d, %r8d
movl %r12d, %r9d
callq 0x26b42
testl %eax, %eax
jne 0x7b504
movl 0x14(%rsp), %edx
movl 0x10(%rsp), %ecx
cmpl %edx, %ecx
cmovlel %edx, %ecx
movq %r14, %rdi
movq 0x20(%rsp), %rsi
callq 0x33bbb
movq %rax, %r15
movq %rdx, %r12
movq 0x18(%rsp), %rsi
movq 0x18(%r14), %rdi
movq %rbx, %rdx
callq 0x1ccb2
movq %r12, %rbx
movq %r15, %rax
movq %rbx, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| js_string_slice:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rbp, r8
mov r14, rdi
call JS_ToStringCheckObject
mov rbx, rdx
mov [rsp+58h+var_40], rax
cmp ebx, 6
jnz short loc_7B4CF
mov r15, rax
jmp loc_7B575
loc_7B4CF:
mov r13, [rsp+58h+var_40]
mov r12d, 7FFFFFFFh
and r12d, [r13+4]
mov rdx, [rbp+0]
mov rcx, [rbp+8]
mov [rsp+58h+var_58], r12d
lea rsi, [rsp+58h+var_44]
xor r15d, r15d
mov rdi, r14
xor r8d, r8d
mov r9d, r12d
call JS_ToInt32Clamp
test eax, eax
jz short loc_7B50C
loc_7B504:
mov r12d, 6
jmp short loc_7B561
loc_7B50C:
mov [rsp+58h+var_38], r13
mov [rsp+58h+var_48], r12d
mov rcx, [rbp+18h]
cmp ecx, 3
jz short loc_7B541
mov rdx, [rbp+10h]
mov [rsp+58h+var_58], r12d
lea rsi, [rsp+58h+var_48]
xor r15d, r15d
mov rdi, r14
xor r8d, r8d
mov r9d, r12d
call JS_ToInt32Clamp
test eax, eax
jnz short loc_7B504
loc_7B541:
mov edx, [rsp+58h+var_44]
mov ecx, [rsp+58h+var_48]
cmp ecx, edx
cmovle ecx, edx
mov rdi, r14
mov rsi, [rsp+58h+var_38]
call js_sub_string
mov r15, rax
mov r12, rdx
loc_7B561:
mov rsi, [rsp+58h+var_40]
mov rdi, [r14+18h]
mov rdx, rbx
call JS_FreeValueRT
mov rbx, r12
loc_7B575:
mov rax, r15
mov rdx, rbx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| _DWORD * js_string_slice(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
_DWORD *v15; // rax
long long v16; // rdx
long long v17; // rbx
long long v18; // r15
_DWORD *v19; // r13
int v20; // r12d
long long v21; // rcx
int v22; // ecx
int v24; // [rsp+10h] [rbp-48h] BYREF
int v25; // [rsp+14h] [rbp-44h] BYREF
_DWORD *v26; // [rsp+18h] [rbp-40h]
_DWORD *v27; // [rsp+20h] [rbp-38h]
v15 = (_DWORD *)JS_ToStringCheckObject(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
v17 = v16;
v26 = v15;
if ( (_DWORD)v16 == 6 )
return v15;
v19 = v26;
v20 = v26[1] & 0x7FFFFFFF;
v18 = 0LL;
if ( !(unsigned int)JS_ToInt32Clamp(a1, &v25, *(_DWORD **)a5, *(_QWORD *)(a5 + 8), 0, v20, v20) )
{
v27 = v19;
v24 = v20;
v21 = *(_QWORD *)(a5 + 24);
if ( (_DWORD)v21 == 3
|| (v18 = 0LL, !(unsigned int)JS_ToInt32Clamp(a1, &v24, *(_DWORD **)(a5 + 16), v21, 0, v20, v20)) )
{
v22 = v24;
if ( v24 <= v25 )
v22 = v25;
v18 = js_sub_string(a1, (long long)v27, v25, v22);
}
}
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v26, v17);
return (_DWORD *)v18;
}
| js_string_slice:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RBP,R8
MOV R14,RDI
CALL 0x001419eb
MOV RBX,RDX
MOV qword ptr [RSP + 0x18],RAX
CMP EBX,0x6
JNZ 0x0017b4cf
MOV R15,RAX
JMP 0x0017b575
LAB_0017b4cf:
MOV R13,qword ptr [RSP + 0x18]
MOV R12D,0x7fffffff
AND R12D,dword ptr [R13 + 0x4]
MOV RDX,qword ptr [RBP]
MOV RCX,qword ptr [RBP + 0x8]
MOV dword ptr [RSP],R12D
LEA RSI,[RSP + 0x14]
XOR R15D,R15D
MOV RDI,R14
XOR R8D,R8D
MOV R9D,R12D
CALL 0x00126b42
TEST EAX,EAX
JZ 0x0017b50c
LAB_0017b504:
MOV R12D,0x6
JMP 0x0017b561
LAB_0017b50c:
MOV qword ptr [RSP + 0x20],R13
MOV dword ptr [RSP + 0x10],R12D
MOV RCX,qword ptr [RBP + 0x18]
CMP ECX,0x3
JZ 0x0017b541
MOV RDX,qword ptr [RBP + 0x10]
MOV dword ptr [RSP],R12D
LEA RSI,[RSP + 0x10]
XOR R15D,R15D
MOV RDI,R14
XOR R8D,R8D
MOV R9D,R12D
CALL 0x00126b42
TEST EAX,EAX
JNZ 0x0017b504
LAB_0017b541:
MOV EDX,dword ptr [RSP + 0x14]
MOV ECX,dword ptr [RSP + 0x10]
CMP ECX,EDX
CMOVLE ECX,EDX
MOV RDI,R14
MOV RSI,qword ptr [RSP + 0x20]
CALL 0x00133bbb
MOV R15,RAX
MOV R12,RDX
LAB_0017b561:
MOV RSI,qword ptr [RSP + 0x18]
MOV RDI,qword ptr [R14 + 0x18]
MOV RDX,RBX
CALL 0x0011ccb2
MOV RBX,R12
LAB_0017b575:
MOV RAX,R15
MOV RDX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int1 [16] js_string_slice(long param_1)
{
int iVar1;
long lVar2;
int8 uVar3;
int8 *in_R8;
uint uVar4;
int1 auVar5 [16];
uint local_48;
uint local_44;
long local_40;
long local_38;
auVar5 = JS_ToStringCheckObject();
uVar3 = auVar5._8_8_;
lVar2 = auVar5._0_8_;
if (auVar5._8_4_ != 6) {
uVar4 = *(uint *)(lVar2 + 4) & 0x7fffffff;
local_40 = lVar2;
iVar1 = JS_ToInt32Clamp(param_1,&local_44,*in_R8,in_R8[1],0,uVar4,uVar4);
if ((iVar1 == 0) &&
((local_48 = uVar4, local_38 = lVar2, (int)in_R8[3] == 3 ||
(iVar1 = JS_ToInt32Clamp(param_1,&local_48,in_R8[2],in_R8[3],0,uVar4,uVar4), iVar1 == 0))))
{
uVar4 = local_48;
if ((int)local_48 <= (int)local_44) {
uVar4 = local_44;
}
auVar5 = js_sub_string(param_1,local_38,local_44,uVar4);
}
else {
auVar5 = ZEXT816(6) << 0x40;
}
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),local_40,uVar3);
}
return auVar5;
}
| |
44,714 | mi_enable_indexes | eloqsql/storage/myisam/mi_open.c | int mi_enable_indexes(MI_INFO *info)
{
int error= 0;
MYISAM_SHARE *share= info->s;
if (share->state.state.data_file_length ||
(share->state.state.key_file_length != share->base.keystart))
{
mi_print_error(info->s, HA_ERR_CRASHED);
error= HA_ERR_CRASHED;
}
else
mi_set_all_keys_active(share->state.key_map, share->base.keys);
return error;
} | O3 | c | mi_enable_indexes:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rax
cmpq $0x0, 0x40(%rax)
jne 0x80715
movq 0x38(%rax), %rcx
cmpq 0x108(%rax), %rcx
jne 0x80715
movl 0x180(%rax), %ecx
movq $-0x1, %rdx
shlq %cl, %rdx
movq $-0x1, %rsi
cmpl $0x40, %ecx
notq %rdx
cmovaeq %rsi, %rdx
movq %rdx, 0xc0(%rax)
xorl %ebx, %ebx
jmp 0x8072b
movq 0x268(%rax), %rsi
movl $0x7e, %ebx
movl $0x7e, %edi
callq 0x7ad3a
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| mi_enable_indexes:
push rbp
mov rbp, rsp
push rbx
push rax
mov rax, [rdi]
cmp qword ptr [rax+40h], 0
jnz short loc_80715
mov rcx, [rax+38h]
cmp rcx, [rax+108h]
jnz short loc_80715
mov ecx, [rax+180h]
mov rdx, 0FFFFFFFFFFFFFFFFh
shl rdx, cl
mov rsi, 0FFFFFFFFFFFFFFFFh
cmp ecx, 40h ; '@'
not rdx
cmovnb rdx, rsi
mov [rax+0C0h], rdx
xor ebx, ebx
jmp short loc_8072B
loc_80715:
mov rsi, [rax+268h]
mov ebx, 7Eh ; '~'
mov edi, 7Eh ; '~'
call mi_report_error
loc_8072B:
mov eax, ebx
add rsp, 8
pop rbx
pop rbp
retn
| long long mi_enable_indexes(long long *a1)
{
long long v1; // rax
unsigned int v2; // ecx
long long v3; // rdx
unsigned int v4; // ebx
v1 = *a1;
if ( *(_QWORD *)(*a1 + 64) || *(_QWORD *)(v1 + 56) != *(_QWORD *)(v1 + 264) )
{
v4 = 126;
mi_report_error(126, *(_QWORD *)(v1 + 616));
}
else
{
v2 = *(_DWORD *)(v1 + 384);
v3 = ~(-1LL << v2);
if ( v2 >= 0x40 )
v3 = -1LL;
*(_QWORD *)(v1 + 192) = v3;
return 0;
}
return v4;
}
| mi_enable_indexes:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RAX,qword ptr [RDI]
CMP qword ptr [RAX + 0x40],0x0
JNZ 0x00180715
MOV RCX,qword ptr [RAX + 0x38]
CMP RCX,qword ptr [RAX + 0x108]
JNZ 0x00180715
MOV ECX,dword ptr [RAX + 0x180]
MOV RDX,-0x1
SHL RDX,CL
MOV RSI,-0x1
CMP ECX,0x40
NOT RDX
CMOVNC RDX,RSI
MOV qword ptr [RAX + 0xc0],RDX
XOR EBX,EBX
JMP 0x0018072b
LAB_00180715:
MOV RSI,qword ptr [RAX + 0x268]
MOV EBX,0x7e
MOV EDI,0x7e
CALL 0x0017ad3a
LAB_0018072b:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP RBP
RET
|
int8 mi_enable_indexes(long *param_1)
{
long lVar1;
ulong uVar2;
int8 uVar3;
lVar1 = *param_1;
if ((*(long *)(lVar1 + 0x40) == 0) && (*(long *)(lVar1 + 0x38) == *(long *)(lVar1 + 0x108))) {
uVar2 = ~(-1L << ((byte)*(uint *)(lVar1 + 0x180) & 0x3f));
if (0x3f < *(uint *)(lVar1 + 0x180)) {
uVar2 = 0xffffffffffffffff;
}
*(ulong *)(lVar1 + 0xc0) = uVar2;
uVar3 = 0;
}
else {
uVar3 = 0x7e;
mi_report_error(0x7e,*(int8 *)(lVar1 + 0x268));
}
return uVar3;
}
| |
44,715 | js_string_fromCharCode | bluesky950520[P]quickjs/quickjs.c | static JSValue js_string_fromCharCode(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
int i;
StringBuffer b_s, *b = &b_s;
// shortcut for single argument common case
if (argc == 1 && JS_VALUE_GET_TAG(argv[0]) == JS_TAG_INT) {
uint16_t c16 = JS_VALUE_GET_INT(argv[0]);
return js_new_string_char(ctx, c16);
}
string_buffer_init(ctx, b, argc);
for(i = 0; i < argc; i++) {
int32_t c;
if (JS_ToInt32(ctx, &c, argv[i]) || string_buffer_putc16(b, c & 0xffff)) {
string_buffer_free(b);
return JS_EXCEPTION;
}
}
return string_buffer_end(b);
} | O0 | c | js_string_fromCharCode:
subq $0x78, %rsp
movq %rsi, 0x58(%rsp)
movq %rdx, 0x60(%rsp)
movq %rdi, 0x50(%rsp)
movl %ecx, 0x4c(%rsp)
movq %r8, 0x40(%rsp)
leaq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpl $0x1, 0x4c(%rsp)
jne 0xd26e5
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, %eax
jne 0xd26e5
movq 0x40(%rsp), %rax
movl (%rax), %eax
movw %ax, 0xe(%rsp)
movq 0x50(%rsp), %rdi
movzwl 0xe(%rsp), %esi
callq 0x60450
movq %rax, 0x68(%rsp)
movq %rdx, 0x70(%rsp)
jmp 0xd278f
movq 0x50(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0x4c(%rsp), %edx
callq 0x50640
movl $0x0, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
cmpl 0x4c(%rsp), %eax
jge 0xd277b
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rax
movslq 0x3c(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
leaq 0x8(%rsp), %rsi
callq 0x38f20
cmpl $0x0, %eax
jne 0xd274f
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %esi
andl $0xffff, %esi # imm = 0xFFFF
callq 0x7e690
cmpl $0x0, %eax
je 0xd276c
movq 0x10(%rsp), %rdi
callq 0x524b0
movl $0x0, 0x68(%rsp)
movq $0x6, 0x70(%rsp)
jmp 0xd278f
jmp 0xd276e
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0xd2700
movq 0x10(%rsp), %rdi
callq 0x4db00
movq %rax, 0x68(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x68(%rsp), %rax
movq 0x70(%rsp), %rdx
addq $0x78, %rsp
retq
nop
| js_string_fromCharCode:
sub rsp, 78h
mov [rsp+78h+var_20], rsi
mov [rsp+78h+var_18], rdx
mov [rsp+78h+var_28], rdi
mov [rsp+78h+var_2C], ecx
mov [rsp+78h+var_38], r8
lea rax, [rsp+78h+var_60]
mov [rsp+78h+var_68], rax
cmp [rsp+78h+var_2C], 1
jnz short loc_D26E5
mov rax, [rsp+78h+var_38]
mov rax, [rax+8]
cmp eax, 0
jnz short loc_D26E5
mov rax, [rsp+78h+var_38]
mov eax, [rax]
mov [rsp+78h+var_6A], ax
mov rdi, [rsp+78h+var_28]
movzx esi, [rsp+78h+var_6A]
call js_new_string_char
mov [rsp+78h+var_10], rax
mov [rsp+78h+var_8], rdx
jmp loc_D278F
loc_D26E5:
mov rdi, [rsp+78h+var_28]
mov rsi, [rsp+78h+var_68]
mov edx, [rsp+78h+var_2C]
call string_buffer_init
mov [rsp+78h+var_3C], 0
loc_D2700:
mov eax, [rsp+78h+var_3C]
cmp eax, [rsp+78h+var_2C]
jge short loc_D277B
mov rdi, [rsp+78h+var_28]
mov rax, [rsp+78h+var_38]
movsxd rcx, [rsp+78h+var_3C]
shl rcx, 4
add rax, rcx
mov rdx, [rax]
mov rcx, [rax+8]
lea rsi, [rsp+78h+var_70]
call JS_ToInt32
cmp eax, 0
jnz short loc_D274F
mov rdi, [rsp+78h+var_68]
mov esi, [rsp+78h+var_70]
and esi, 0FFFFh
call string_buffer_putc16
cmp eax, 0
jz short loc_D276C
loc_D274F:
mov rdi, [rsp+78h+var_68]
call string_buffer_free
mov dword ptr [rsp+78h+var_10], 0
mov [rsp+78h+var_8], 6
jmp short loc_D278F
loc_D276C:
jmp short $+2
loc_D276E:
mov eax, [rsp+78h+var_3C]
add eax, 1
mov [rsp+78h+var_3C], eax
jmp short loc_D2700
loc_D277B:
mov rdi, [rsp+78h+var_68]
call string_buffer_end
mov [rsp+78h+var_10], rax
mov [rsp+78h+var_8], rdx
loc_D278F:
mov rax, [rsp+78h+var_10]
mov rdx, [rsp+78h+var_8]
add rsp, 78h
retn
| long long js_string_fromCharCode(long long a1, long long a2, long long a3, signed int a4, long long a5)
{
long long v5; // rdx
long long v6; // rdx
int v8; // [rsp+8h] [rbp-70h] BYREF
long long *v9; // [rsp+10h] [rbp-68h]
char v10; // [rsp+18h] [rbp-60h] BYREF
signed int i; // [rsp+3Ch] [rbp-3Ch]
long long v12; // [rsp+40h] [rbp-38h]
signed int v13; // [rsp+4Ch] [rbp-2Ch]
long long v14; // [rsp+50h] [rbp-28h]
long long v15; // [rsp+58h] [rbp-20h]
long long v16; // [rsp+60h] [rbp-18h]
long long v17; // [rsp+68h] [rbp-10h]
long long v18; // [rsp+70h] [rbp-8h]
v15 = a2;
v16 = a3;
v14 = a1;
v13 = a4;
v12 = a5;
v9 = (long long *)&v10;
if ( a4 != 1 || (unsigned int)*(_QWORD *)(v12 + 8) )
{
string_buffer_init(v14, (long long)v9, v13);
for ( i = 0; i < v13; ++i )
{
if ( (unsigned int)JS_ToInt32(v14, (long long)&v8, *(_DWORD **)(16LL * i + v12), *(_QWORD *)(16LL * i + v12 + 8))
|| (unsigned int)string_buffer_putc16((long long)v9, (unsigned __int16)v8) )
{
string_buffer_free(v9);
LODWORD(v17) = 0;
v18 = 6LL;
return v17;
}
}
v17 = string_buffer_end((long long)v9);
v18 = v6;
}
else
{
v17 = js_new_string_char(v14, *(_DWORD *)v12);
v18 = v5;
}
return v17;
}
| js_string_fromCharCode:
SUB RSP,0x78
MOV qword ptr [RSP + 0x58],RSI
MOV qword ptr [RSP + 0x60],RDX
MOV qword ptr [RSP + 0x50],RDI
MOV dword ptr [RSP + 0x4c],ECX
MOV qword ptr [RSP + 0x40],R8
LEA RAX,[RSP + 0x18]
MOV qword ptr [RSP + 0x10],RAX
CMP dword ptr [RSP + 0x4c],0x1
JNZ 0x001d26e5
MOV RAX,qword ptr [RSP + 0x40]
MOV RAX,qword ptr [RAX + 0x8]
CMP EAX,0x0
JNZ 0x001d26e5
MOV RAX,qword ptr [RSP + 0x40]
MOV EAX,dword ptr [RAX]
MOV word ptr [RSP + 0xe],AX
MOV RDI,qword ptr [RSP + 0x50]
MOVZX ESI,word ptr [RSP + 0xe]
CALL 0x00160450
MOV qword ptr [RSP + 0x68],RAX
MOV qword ptr [RSP + 0x70],RDX
JMP 0x001d278f
LAB_001d26e5:
MOV RDI,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RSP + 0x10]
MOV EDX,dword ptr [RSP + 0x4c]
CALL 0x00150640
MOV dword ptr [RSP + 0x3c],0x0
LAB_001d2700:
MOV EAX,dword ptr [RSP + 0x3c]
CMP EAX,dword ptr [RSP + 0x4c]
JGE 0x001d277b
MOV RDI,qword ptr [RSP + 0x50]
MOV RAX,qword ptr [RSP + 0x40]
MOVSXD RCX,dword ptr [RSP + 0x3c]
SHL RCX,0x4
ADD RAX,RCX
MOV RDX,qword ptr [RAX]
MOV RCX,qword ptr [RAX + 0x8]
LEA RSI,[RSP + 0x8]
CALL 0x00138f20
CMP EAX,0x0
JNZ 0x001d274f
MOV RDI,qword ptr [RSP + 0x10]
MOV ESI,dword ptr [RSP + 0x8]
AND ESI,0xffff
CALL 0x0017e690
CMP EAX,0x0
JZ 0x001d276c
LAB_001d274f:
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x001524b0
MOV dword ptr [RSP + 0x68],0x0
MOV qword ptr [RSP + 0x70],0x6
JMP 0x001d278f
LAB_001d276c:
JMP 0x001d276e
LAB_001d276e:
MOV EAX,dword ptr [RSP + 0x3c]
ADD EAX,0x1
MOV dword ptr [RSP + 0x3c],EAX
JMP 0x001d2700
LAB_001d277b:
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x0014db00
MOV qword ptr [RSP + 0x68],RAX
MOV qword ptr [RSP + 0x70],RDX
LAB_001d278f:
MOV RAX,qword ptr [RSP + 0x68]
MOV RDX,qword ptr [RSP + 0x70]
ADD RSP,0x78
RET
|
int1 [16]
js_string_fromCharCode
(int8 param_1,int8 param_2,int8 param_3,int param_4,int4 *param_5)
{
int iVar1;
int1 auVar2 [16];
uint local_70;
int2 local_6a;
int1 *local_68;
int1 local_60 [36];
int local_3c;
int4 *local_38;
int local_2c;
int8 local_28;
int8 local_20;
int8 local_18;
int4 local_10;
int4 uStack_c;
int8 local_8;
local_68 = local_60;
local_38 = param_5;
local_2c = param_4;
local_28 = param_1;
local_20 = param_2;
local_18 = param_3;
if ((param_4 == 1) && ((int)*(int8 *)(param_5 + 2) == 0)) {
local_6a = (int2)*param_5;
auVar2 = js_new_string_char(param_1,local_6a);
local_8 = auVar2._8_8_;
local_10 = auVar2._0_4_;
uStack_c = auVar2._4_4_;
}
else {
string_buffer_init(param_1,local_68,param_4);
for (local_3c = 0; local_3c < local_2c; local_3c = local_3c + 1) {
iVar1 = JS_ToInt32(local_28,&local_70,*(int8 *)(local_38 + (long)local_3c * 4),
*(int8 *)((long)(local_38 + (long)local_3c * 4) + 8));
if (iVar1 != 0) {
LAB_001d274f:
string_buffer_free(local_68);
local_10 = 0;
local_8 = 6;
goto LAB_001d278f;
}
iVar1 = string_buffer_putc16(local_68,local_70 & 0xffff);
if (iVar1 != 0) goto LAB_001d274f;
}
auVar2 = string_buffer_end(local_68);
local_8 = auVar2._8_8_;
local_10 = auVar2._0_4_;
uStack_c = auVar2._4_4_;
}
LAB_001d278f:
auVar2._4_4_ = uStack_c;
auVar2._0_4_ = local_10;
auVar2._8_8_ = local_8;
return auVar2;
}
| |
44,716 | js_array_toReversed | bluesky950520[P]quickjs/quickjs.c | static JSValue js_array_toReversed(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue arr, obj, ret, *arrp, *pval;
JSObject *p;
int64_t i, len;
uint32_t count32;
ret = JS_EXCEPTION;
arr = JS_UNDEFINED;
obj = JS_ToObject(ctx, this_val);
if (js_get_length64(ctx, &len, obj))
goto exception;
if (len > UINT32_MAX) {
JS_ThrowRangeError(ctx, "invalid array length");
goto exception;
}
arr = JS_NewArray(ctx);
if (JS_IsException(arr))
goto exception;
if (len > 0) {
p = JS_VALUE_GET_OBJ(arr);
if (expand_fast_array(ctx, p, len) < 0)
goto exception;
p->u.array.count = len;
i = len - 1;
pval = p->u.array.u.values;
if (js_get_fast_array(ctx, obj, &arrp, &count32) && count32 == len) {
for (; i >= 0; i--, pval++)
*pval = js_dup(arrp[i]);
} else {
// Query order is observable; test262 expects descending order.
for (; i >= 0; i--, pval++) {
if (-1 == JS_TryGetPropertyInt64(ctx, obj, i, pval)) {
// Exception; initialize remaining elements.
for (; i >= 0; i--, pval++)
*pval = JS_UNDEFINED;
goto exception;
}
}
}
if (JS_SetProperty(ctx, arr, JS_ATOM_length, js_int64(len)) < 0)
goto exception;
}
ret = arr;
arr = JS_UNDEFINED;
exception:
JS_FreeValue(ctx, arr);
JS_FreeValue(ctx, obj);
return ret;
} | O0 | c | js_array_toReversed:
subq $0x128, %rsp # imm = 0x128
movq %rsi, 0x108(%rsp)
movq %rdx, 0x110(%rsp)
movq %rdi, 0x100(%rsp)
movl %ecx, 0xfc(%rsp)
movq %r8, 0xf0(%rsp)
movl $0x0, 0x90(%rsp)
movq $0x6, 0x98(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x118(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x120(%rsp)
movl $0x0, 0x80(%rsp)
movq $0x3, 0x88(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0xe0(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0x100(%rsp), %rdi
movq 0x108(%rsp), %rsi
movq 0x110(%rsp), %rdx
callq 0x37770
movq %rax, 0x70(%rsp)
movq %rdx, 0x78(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0xd0(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0xd8(%rsp)
movq 0x100(%rsp), %rdi
movq 0xd0(%rsp), %rdx
movq 0xd8(%rsp), %rcx
leaq 0xa8(%rsp), %rsi
callq 0x2df60
cmpl $0x0, %eax
je 0xcb41c
jmp 0xcb785
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpq %rax, 0xa8(%rsp)
jle 0xcb450
movq 0x100(%rsp), %rdi
leaq 0x42dc8(%rip), %rsi # 0x10e202
movb $0x0, %al
callq 0x29670
movq %rax, 0x60(%rsp)
movq %rdx, 0x68(%rsp)
jmp 0xcb785
movq 0x100(%rsp), %rdi
callq 0x2a520
movq %rax, 0x50(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0xe0(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe0(%rsp), %rdi
movq 0xe8(%rsp), %rsi
callq 0x23cc0
cmpl $0x0, %eax
je 0xcb4a0
jmp 0xcb785
cmpq $0x0, 0xa8(%rsp)
jle 0xcb73a
movq 0xe0(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq 0x100(%rsp), %rdi
movq 0xb8(%rsp), %rsi
movq 0xa8(%rsp), %rax
movl %eax, %edx
callq 0x61050
cmpl $0x0, %eax
jge 0xcb4e8
jmp 0xcb785
movq 0xa8(%rsp), %rax
movl %eax, %ecx
movq 0xb8(%rsp), %rax
movl %ecx, 0x40(%rax)
movq 0xa8(%rsp), %rax
subq $0x1, %rax
movq %rax, 0xb0(%rsp)
movq 0xb8(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0xc0(%rsp)
movq 0x100(%rsp), %rdi
movq 0xd0(%rsp), %rsi
movq 0xd8(%rsp), %rdx
leaq 0xc8(%rsp), %rcx
leaq 0xa4(%rsp), %r8
callq 0x70740
cmpl $0x0, %eax
je 0xcb606
movl 0xa4(%rsp), %eax
cmpq 0xa8(%rsp), %rax
jne 0xcb606
jmp 0xcb572
cmpq $0x0, 0xb0(%rsp)
jl 0xcb601
movq 0xc0(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0xc8(%rsp), %rax
movq 0xb0(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x216d0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x40(%rsp), %rcx
movq %rcx, (%rax)
movq 0x48(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0xb0(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0xb0(%rsp)
movq 0xc0(%rsp), %rax
addq $0x10, %rax
movq %rax, 0xc0(%rsp)
jmp 0xcb572
jmp 0xcb6e6
jmp 0xcb608
cmpq $0x0, 0xb0(%rsp)
jl 0xcb6e4
movq 0x100(%rsp), %rdi
movq 0xb0(%rsp), %rcx
movq 0xc0(%rsp), %r8
movq 0xd0(%rsp), %rsi
movq 0xd8(%rsp), %rdx
callq 0x87ba0
movl %eax, %ecx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0xcb6b5
jmp 0xcb651
cmpq $0x0, 0xb0(%rsp)
jl 0xcb6b0
movq 0xc0(%rsp), %rax
movl $0x0, 0x30(%rsp)
movq $0x3, 0x38(%rsp)
movq 0x30(%rsp), %rcx
movq %rcx, (%rax)
movq 0x38(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0xb0(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0xb0(%rsp)
movq 0xc0(%rsp), %rax
addq $0x10, %rax
movq %rax, 0xc0(%rsp)
jmp 0xcb651
jmp 0xcb785
jmp 0xcb6b7
movq 0xb0(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0xb0(%rsp)
movq 0xc0(%rsp), %rax
addq $0x10, %rax
movq %rax, 0xc0(%rsp)
jmp 0xcb608
jmp 0xcb6e6
movq 0x100(%rsp), %rax
movq %rax, (%rsp)
movq 0xa8(%rsp), %rdi
callq 0x37480
movq (%rsp), %rdi
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq 0xe0(%rsp), %rsi
movq 0xe8(%rsp), %rdx
movq 0x20(%rsp), %r8
movq 0x28(%rsp), %r9
movl $0x32, %ecx
callq 0x31f00
cmpl $0x0, %eax
jge 0xcb738
jmp 0xcb785
jmp 0xcb73a
movq 0xe0(%rsp), %rax
movq %rax, 0x118(%rsp)
movq 0xe8(%rsp), %rax
movq %rax, 0x120(%rsp)
movl $0x0, 0x10(%rsp)
movq $0x3, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0xe0(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0x100(%rsp), %rdi
movq 0xe0(%rsp), %rsi
movq 0xe8(%rsp), %rdx
callq 0x23c90
movq 0x100(%rsp), %rdi
movq 0xd0(%rsp), %rsi
movq 0xd8(%rsp), %rdx
callq 0x23c90
movq 0x118(%rsp), %rax
movq 0x120(%rsp), %rdx
addq $0x128, %rsp # imm = 0x128
retq
nopw (%rax,%rax)
| js_array_toReversed:
sub rsp, 128h
mov [rsp+128h+var_20], rsi
mov [rsp+128h+var_18], rdx
mov [rsp+128h+var_28], rdi
mov [rsp+128h+var_2C], ecx
mov [rsp+128h+var_38], r8
mov dword ptr [rsp+128h+var_98], 0
mov [rsp+128h+var_90], 6
mov rax, [rsp+128h+var_98]
mov [rsp+128h+var_10], rax
mov rax, [rsp+128h+var_90]
mov [rsp+128h+var_8], rax
mov dword ptr [rsp+128h+var_A8], 0
mov [rsp+128h+var_A0], 3
mov rax, [rsp+128h+var_A8]
mov [rsp+128h+var_48], rax
mov rax, [rsp+128h+var_A0]
mov [rsp+128h+var_40], rax
mov rdi, [rsp+128h+var_28]
mov rsi, [rsp+128h+var_20]
mov rdx, [rsp+128h+var_18]
call JS_ToObject
mov [rsp+128h+var_B8], rax
mov [rsp+128h+var_B0], rdx
mov rax, [rsp+128h+var_B8]
mov [rsp+128h+var_58], rax
mov rax, [rsp+128h+var_B0]
mov [rsp+128h+var_50], rax
mov rdi, [rsp+128h+var_28]
mov rdx, [rsp+128h+var_58]
mov rcx, [rsp+128h+var_50]
lea rsi, [rsp+128h+var_80]
call js_get_length64
cmp eax, 0
jz short loc_CB41C
jmp loc_CB785
loc_CB41C:
mov eax, 0FFFFFFFFh
cmp [rsp+128h+var_80], rax
jle short loc_CB450
mov rdi, [rsp+128h+var_28]
lea rsi, aInvalidArrayLe; "invalid array length"
mov al, 0
call JS_ThrowRangeError
mov [rsp+128h+var_C8], rax
mov [rsp+128h+var_C0], rdx
jmp loc_CB785
loc_CB450:
mov rdi, [rsp+128h+var_28]
call JS_NewArray
mov [rsp+128h+var_D8], rax
mov [rsp+128h+var_D0], rdx
mov rax, [rsp+128h+var_D8]
mov [rsp+128h+var_48], rax
mov rax, [rsp+128h+var_D0]
mov [rsp+128h+var_40], rax
mov rdi, [rsp+128h+var_48]
mov rsi, [rsp+128h+var_40]
call JS_IsException_1
cmp eax, 0
jz short loc_CB4A0
jmp loc_CB785
loc_CB4A0:
cmp [rsp+128h+var_80], 0
jle loc_CB73A
mov rax, [rsp+128h+var_48]
mov [rsp+128h+var_70], rax
mov rdi, [rsp+128h+var_28]
mov rsi, [rsp+128h+var_70]
mov rax, [rsp+128h+var_80]
mov edx, eax
call expand_fast_array
cmp eax, 0
jge short loc_CB4E8
jmp loc_CB785
loc_CB4E8:
mov rax, [rsp+128h+var_80]
mov ecx, eax
mov rax, [rsp+128h+var_70]
mov [rax+40h], ecx
mov rax, [rsp+128h+var_80]
sub rax, 1
mov [rsp+128h+var_78], rax
mov rax, [rsp+128h+var_70]
mov rax, [rax+38h]
mov [rsp+128h+var_68], rax
mov rdi, [rsp+128h+var_28]
mov rsi, [rsp+128h+var_58]
mov rdx, [rsp+128h+var_50]
lea rcx, [rsp+128h+var_60]
lea r8, [rsp+128h+var_84]
call js_get_fast_array
cmp eax, 0
jz loc_CB606
mov eax, [rsp+128h+var_84]
cmp rax, [rsp+128h+var_80]
jnz loc_CB606
jmp short $+2
loc_CB572:
cmp [rsp+128h+var_78], 0
jl loc_CB601
mov rax, [rsp+128h+var_68]
mov [rsp+128h+var_120], rax
mov rax, [rsp+128h+var_60]
mov rcx, [rsp+128h+var_78]
shl rcx, 4
add rax, rcx
mov rdi, [rax]
mov rsi, [rax+8]
call js_dup
mov rcx, rax
mov rax, [rsp+128h+var_120]
mov [rsp+128h+var_E8], rcx
mov [rsp+128h+var_E0], rdx
mov rcx, [rsp+128h+var_E8]
mov [rax], rcx
mov rcx, [rsp+128h+var_E0]
mov [rax+8], rcx
mov rax, [rsp+128h+var_78]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rsp+128h+var_78], rax
mov rax, [rsp+128h+var_68]
add rax, 10h
mov [rsp+128h+var_68], rax
jmp loc_CB572
loc_CB601:
jmp loc_CB6E6
loc_CB606:
jmp short $+2
loc_CB608:
cmp [rsp+128h+var_78], 0
jl loc_CB6E4
mov rdi, [rsp+128h+var_28]
mov rcx, [rsp+128h+var_78]
mov r8, [rsp+128h+var_68]
mov rsi, [rsp+128h+var_58]
mov rdx, [rsp+128h+var_50]
call JS_TryGetPropertyInt64
mov ecx, eax
mov eax, 0FFFFFFFFh
cmp eax, ecx
jnz short loc_CB6B5
jmp short $+2
loc_CB651:
cmp [rsp+128h+var_78], 0
jl short loc_CB6B0
mov rax, [rsp+128h+var_68]
mov dword ptr [rsp+128h+var_F8], 0
mov [rsp+128h+var_F0], 3
mov rcx, [rsp+128h+var_F8]
mov [rax], rcx
mov rcx, [rsp+128h+var_F0]
mov [rax+8], rcx
mov rax, [rsp+128h+var_78]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rsp+128h+var_78], rax
mov rax, [rsp+128h+var_68]
add rax, 10h
mov [rsp+128h+var_68], rax
jmp short loc_CB651
loc_CB6B0:
jmp loc_CB785
loc_CB6B5:
jmp short $+2
loc_CB6B7:
mov rax, [rsp+128h+var_78]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rsp+128h+var_78], rax
mov rax, [rsp+128h+var_68]
add rax, 10h
mov [rsp+128h+var_68], rax
jmp loc_CB608
loc_CB6E4:
jmp short $+2
loc_CB6E6:
mov rax, [rsp+128h+var_28]
mov [rsp+128h+var_128], rax
mov rdi, [rsp+128h+var_80]
call js_int64
mov rdi, [rsp+128h+var_128]
mov [rsp+128h+var_108], rax
mov [rsp+128h+var_100], rdx
mov rsi, [rsp+128h+var_48]
mov rdx, [rsp+128h+var_40]
mov r8, [rsp+128h+var_108]
mov r9, [rsp+128h+var_100]
mov ecx, 32h ; '2'
call JS_SetProperty
cmp eax, 0
jge short loc_CB738
jmp short loc_CB785
loc_CB738:
jmp short $+2
loc_CB73A:
mov rax, [rsp+128h+var_48]
mov [rsp+128h+var_10], rax
mov rax, [rsp+128h+var_40]
mov [rsp+128h+var_8], rax
mov dword ptr [rsp+128h+var_118], 0
mov [rsp+128h+var_110], 3
mov rax, [rsp+128h+var_118]
mov [rsp+128h+var_48], rax
mov rax, [rsp+128h+var_110]
mov [rsp+128h+var_40], rax
loc_CB785:
mov rdi, [rsp+128h+var_28]
mov rsi, [rsp+128h+var_48]
mov rdx, [rsp+128h+var_40]
call JS_FreeValue
mov rdi, [rsp+128h+var_28]
mov rsi, [rsp+128h+var_58]
mov rdx, [rsp+128h+var_50]
call JS_FreeValue
mov rax, [rsp+128h+var_10]
mov rdx, [rsp+128h+var_8]
add rsp, 128h
retn
| long long js_array_toReversed(
long long a1,
_DWORD *a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
long long v14; // rdx
long long v15; // rdx
long long v16; // rcx
long long v17; // r8
long long v18; // r9
__m128 v19; // xmm4
__m128 v20; // xmm5
long long v21; // rdx
long long v22; // rdx
long long *v23; // rax
int v24; // edx
char v26; // [rsp+0h] [rbp-128h]
int v27; // [rsp+0h] [rbp-128h]
long long *v28; // [rsp+8h] [rbp-120h]
long long v29; // [rsp+10h] [rbp-118h]
int v30; // [rsp+20h] [rbp-108h]
long long v31; // [rsp+30h] [rbp-F8h]
long long v32; // [rsp+80h] [rbp-A8h]
long long v33; // [rsp+90h] [rbp-98h]
int v34; // [rsp+A4h] [rbp-84h] BYREF
long long v35; // [rsp+A8h] [rbp-80h] BYREF
signed long long v36; // [rsp+B0h] [rbp-78h]
long long v37; // [rsp+B8h] [rbp-70h]
long long *v38; // [rsp+C0h] [rbp-68h]
long long v39; // [rsp+C8h] [rbp-60h] BYREF
_DWORD *v40; // [rsp+D0h] [rbp-58h]
long long v41; // [rsp+D8h] [rbp-50h]
long long v42; // [rsp+E0h] [rbp-48h]
long long v43; // [rsp+E8h] [rbp-40h]
long long v44; // [rsp+F0h] [rbp-38h]
int v45; // [rsp+FCh] [rbp-2Ch]
long long v46; // [rsp+100h] [rbp-28h]
_DWORD *v47; // [rsp+108h] [rbp-20h]
long long v48; // [rsp+110h] [rbp-18h]
long long v49; // [rsp+118h] [rbp-10h]
long long v50; // [rsp+120h] [rbp-8h]
v47 = a2;
v48 = a3;
v46 = a1;
v45 = a4;
v44 = a5;
LODWORD(v33) = 0;
v49 = v33;
v50 = 6LL;
LODWORD(v32) = 0;
v42 = v32;
v43 = 3LL;
v40 = JS_ToObject(a1, a2, a3, a7, a8, a9, a10, a11, a12, a13, a14, a4, a5, a6);
v41 = v14;
if ( !(unsigned int)js_get_length64(a1, &v35, (int)v40, v14) )
{
if ( v35 <= 0xFFFFFFFFLL )
{
v42 = JS_NewArray(v46);
v43 = v21;
if ( !JS_IsException_1(v42, v21) )
{
if ( v35 <= 0 )
goto LABEL_19;
v37 = v42;
if ( (int)expand_fast_array(v46, v42, v35) >= 0 )
{
*(_DWORD *)(v37 + 64) = v35;
v36 = v35 - 1;
v38 = *(long long **)(v37 + 56);
if ( (unsigned int)js_get_fast_array(v46, (long long)v40, v41, &v39, &v34) && v34 == v35 )
{
while ( v36 >= 0 )
{
v28 = v38;
*v28 = (long long)js_dup(*(_DWORD **)(16 * v36 + v39), *(_QWORD *)(16 * v36 + v39 + 8));
v28[1] = v22;
--v36;
v38 += 2;
}
}
else
{
while ( v36 >= 0 )
{
if ( (unsigned int)JS_TryGetPropertyInt64(v46, (long long)v40, v41, v36, v38) == -1 )
{
while ( v36 >= 0 )
{
v23 = v38;
LODWORD(v31) = 0;
*v38 = v31;
v23[1] = 3LL;
--v36;
v38 += 2;
}
goto LABEL_20;
}
--v36;
v38 += 2;
}
}
v27 = v46;
v30 = js_int64(v35);
if ( (int)JS_SetProperty(v27, v42, v43, 50, v30, v24) >= 0 )
{
LABEL_19:
v49 = v42;
v50 = v43;
LODWORD(v29) = 0;
v42 = v29;
v43 = 3LL;
}
}
}
}
else
{
JS_ThrowRangeError(
v46,
(long long)"invalid array length",
v15,
v16,
v17,
v18,
a7,
a8,
a9,
a10,
v19,
v20,
a13,
a14,
v26);
}
}
LABEL_20:
JS_FreeValue(v46, v42, v43);
JS_FreeValue(v46, (long long)v40, v41);
return v49;
}
| js_array_toReversed:
SUB RSP,0x128
MOV qword ptr [RSP + 0x108],RSI
MOV qword ptr [RSP + 0x110],RDX
MOV qword ptr [RSP + 0x100],RDI
MOV dword ptr [RSP + 0xfc],ECX
MOV qword ptr [RSP + 0xf0],R8
MOV dword ptr [RSP + 0x90],0x0
MOV qword ptr [RSP + 0x98],0x6
MOV RAX,qword ptr [RSP + 0x90]
MOV qword ptr [RSP + 0x118],RAX
MOV RAX,qword ptr [RSP + 0x98]
MOV qword ptr [RSP + 0x120],RAX
MOV dword ptr [RSP + 0x80],0x0
MOV qword ptr [RSP + 0x88],0x3
MOV RAX,qword ptr [RSP + 0x80]
MOV qword ptr [RSP + 0xe0],RAX
MOV RAX,qword ptr [RSP + 0x88]
MOV qword ptr [RSP + 0xe8],RAX
MOV RDI,qword ptr [RSP + 0x100]
MOV RSI,qword ptr [RSP + 0x108]
MOV RDX,qword ptr [RSP + 0x110]
CALL 0x00137770
MOV qword ptr [RSP + 0x70],RAX
MOV qword ptr [RSP + 0x78],RDX
MOV RAX,qword ptr [RSP + 0x70]
MOV qword ptr [RSP + 0xd0],RAX
MOV RAX,qword ptr [RSP + 0x78]
MOV qword ptr [RSP + 0xd8],RAX
MOV RDI,qword ptr [RSP + 0x100]
MOV RDX,qword ptr [RSP + 0xd0]
MOV RCX,qword ptr [RSP + 0xd8]
LEA RSI,[RSP + 0xa8]
CALL 0x0012df60
CMP EAX,0x0
JZ 0x001cb41c
JMP 0x001cb785
LAB_001cb41c:
MOV EAX,0xffffffff
CMP qword ptr [RSP + 0xa8],RAX
JLE 0x001cb450
MOV RDI,qword ptr [RSP + 0x100]
LEA RSI,[0x20e202]
MOV AL,0x0
CALL 0x00129670
MOV qword ptr [RSP + 0x60],RAX
MOV qword ptr [RSP + 0x68],RDX
JMP 0x001cb785
LAB_001cb450:
MOV RDI,qword ptr [RSP + 0x100]
CALL 0x0012a520
MOV qword ptr [RSP + 0x50],RAX
MOV qword ptr [RSP + 0x58],RDX
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0xe0],RAX
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0xe8],RAX
MOV RDI,qword ptr [RSP + 0xe0]
MOV RSI,qword ptr [RSP + 0xe8]
CALL 0x00123cc0
CMP EAX,0x0
JZ 0x001cb4a0
JMP 0x001cb785
LAB_001cb4a0:
CMP qword ptr [RSP + 0xa8],0x0
JLE 0x001cb73a
MOV RAX,qword ptr [RSP + 0xe0]
MOV qword ptr [RSP + 0xb8],RAX
MOV RDI,qword ptr [RSP + 0x100]
MOV RSI,qword ptr [RSP + 0xb8]
MOV RAX,qword ptr [RSP + 0xa8]
MOV EDX,EAX
CALL 0x00161050
CMP EAX,0x0
JGE 0x001cb4e8
JMP 0x001cb785
LAB_001cb4e8:
MOV RAX,qword ptr [RSP + 0xa8]
MOV ECX,EAX
MOV RAX,qword ptr [RSP + 0xb8]
MOV dword ptr [RAX + 0x40],ECX
MOV RAX,qword ptr [RSP + 0xa8]
SUB RAX,0x1
MOV qword ptr [RSP + 0xb0],RAX
MOV RAX,qword ptr [RSP + 0xb8]
MOV RAX,qword ptr [RAX + 0x38]
MOV qword ptr [RSP + 0xc0],RAX
MOV RDI,qword ptr [RSP + 0x100]
MOV RSI,qword ptr [RSP + 0xd0]
MOV RDX,qword ptr [RSP + 0xd8]
LEA RCX,[RSP + 0xc8]
LEA R8,[RSP + 0xa4]
CALL 0x00170740
CMP EAX,0x0
JZ 0x001cb606
MOV EAX,dword ptr [RSP + 0xa4]
CMP RAX,qword ptr [RSP + 0xa8]
JNZ 0x001cb606
JMP 0x001cb572
LAB_001cb572:
CMP qword ptr [RSP + 0xb0],0x0
JL 0x001cb601
MOV RAX,qword ptr [RSP + 0xc0]
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [RSP + 0xc8]
MOV RCX,qword ptr [RSP + 0xb0]
SHL RCX,0x4
ADD RAX,RCX
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RAX + 0x8]
CALL 0x001216d0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x40],RCX
MOV qword ptr [RSP + 0x48],RDX
MOV RCX,qword ptr [RSP + 0x40]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RSP + 0x48]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RSP + 0xb0]
ADD RAX,-0x1
MOV qword ptr [RSP + 0xb0],RAX
MOV RAX,qword ptr [RSP + 0xc0]
ADD RAX,0x10
MOV qword ptr [RSP + 0xc0],RAX
JMP 0x001cb572
LAB_001cb601:
JMP 0x001cb6e6
LAB_001cb606:
JMP 0x001cb608
LAB_001cb608:
CMP qword ptr [RSP + 0xb0],0x0
JL 0x001cb6e4
MOV RDI,qword ptr [RSP + 0x100]
MOV RCX,qword ptr [RSP + 0xb0]
MOV R8,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0xd0]
MOV RDX,qword ptr [RSP + 0xd8]
CALL 0x00187ba0
MOV ECX,EAX
MOV EAX,0xffffffff
CMP EAX,ECX
JNZ 0x001cb6b5
JMP 0x001cb651
LAB_001cb651:
CMP qword ptr [RSP + 0xb0],0x0
JL 0x001cb6b0
MOV RAX,qword ptr [RSP + 0xc0]
MOV dword ptr [RSP + 0x30],0x0
MOV qword ptr [RSP + 0x38],0x3
MOV RCX,qword ptr [RSP + 0x30]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RSP + 0x38]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RSP + 0xb0]
ADD RAX,-0x1
MOV qword ptr [RSP + 0xb0],RAX
MOV RAX,qword ptr [RSP + 0xc0]
ADD RAX,0x10
MOV qword ptr [RSP + 0xc0],RAX
JMP 0x001cb651
LAB_001cb6b0:
JMP 0x001cb785
LAB_001cb6b5:
JMP 0x001cb6b7
LAB_001cb6b7:
MOV RAX,qword ptr [RSP + 0xb0]
ADD RAX,-0x1
MOV qword ptr [RSP + 0xb0],RAX
MOV RAX,qword ptr [RSP + 0xc0]
ADD RAX,0x10
MOV qword ptr [RSP + 0xc0],RAX
JMP 0x001cb608
LAB_001cb6e4:
JMP 0x001cb6e6
LAB_001cb6e6:
MOV RAX,qword ptr [RSP + 0x100]
MOV qword ptr [RSP],RAX
MOV RDI,qword ptr [RSP + 0xa8]
CALL 0x00137480
MOV RDI,qword ptr [RSP]
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x28],RDX
MOV RSI,qword ptr [RSP + 0xe0]
MOV RDX,qword ptr [RSP + 0xe8]
MOV R8,qword ptr [RSP + 0x20]
MOV R9,qword ptr [RSP + 0x28]
MOV ECX,0x32
CALL 0x00131f00
CMP EAX,0x0
JGE 0x001cb738
JMP 0x001cb785
LAB_001cb738:
JMP 0x001cb73a
LAB_001cb73a:
MOV RAX,qword ptr [RSP + 0xe0]
MOV qword ptr [RSP + 0x118],RAX
MOV RAX,qword ptr [RSP + 0xe8]
MOV qword ptr [RSP + 0x120],RAX
MOV dword ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x18],0x3
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0xe0],RAX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0xe8],RAX
LAB_001cb785:
MOV RDI,qword ptr [RSP + 0x100]
MOV RSI,qword ptr [RSP + 0xe0]
MOV RDX,qword ptr [RSP + 0xe8]
CALL 0x00123c90
MOV RDI,qword ptr [RSP + 0x100]
MOV RSI,qword ptr [RSP + 0xd0]
MOV RDX,qword ptr [RSP + 0xd8]
CALL 0x00123c90
MOV RAX,qword ptr [RSP + 0x118]
MOV RDX,qword ptr [RSP + 0x120]
ADD RSP,0x128
RET
|
int1 [16]
js_array_toReversed(int8 param_1,int8 param_2,int8 param_3,int4 param_4,
int8 param_5)
{
int1 (*pauVar1) [16];
int8 uVar2;
int iVar3;
int8 *puVar4;
int1 auVar5 [16];
uint uStack_114;
uint uStack_f4;
uint uStack_a4;
uint uStack_94;
uint local_84;
ulong local_80;
long local_78;
long local_70;
int1 (*local_68) [16];
long local_60;
int1 local_58 [16];
int1 local_48 [16];
int8 local_38;
int4 local_2c;
int8 local_28;
int8 local_20;
int8 local_18;
int1 local_10 [16];
local_10._0_8_ = (ulong)uStack_94 << 0x20;
local_10._8_8_ = 6;
local_48._0_8_ = (ulong)uStack_a4 << 0x20;
local_48._8_8_ = 3;
local_38 = param_5;
local_2c = param_4;
local_28 = param_1;
local_20 = param_2;
local_18 = param_3;
local_58 = JS_ToObject(param_1,param_2,param_3);
iVar3 = js_get_length64(local_28,&local_80,local_58._0_8_,local_58._8_8_);
if (iVar3 == 0) {
if ((long)local_80 < 0x100000000) {
local_48 = JS_NewArray(local_28);
iVar3 = JS_IsException(local_48._0_8_,local_48._8_8_);
if (iVar3 == 0) {
if (0 < (long)local_80) {
local_70 = local_48._0_8_;
iVar3 = expand_fast_array(local_28,local_48._0_8_,local_80 & 0xffffffff);
if (iVar3 < 0) goto LAB_001cb785;
*(int *)(local_70 + 0x40) = (int)local_80;
local_78 = local_80 - 1;
local_68 = *(int1 (**) [16])(local_70 + 0x38);
iVar3 = js_get_fast_array(local_28,local_58._0_8_,local_58._8_8_,&local_60,&local_84);
if ((iVar3 == 0) || (local_84 != local_80)) {
while( true ) {
if (local_78 < 0) break;
iVar3 = JS_TryGetPropertyInt64
(local_28,local_58._0_8_,local_58._8_8_,local_78,local_68);
if (iVar3 == -1) goto LAB_001cb651;
local_78 = local_78 + -1;
local_68 = local_68 + 1;
}
}
else {
for (; pauVar1 = local_68, -1 < local_78; local_78 = local_78 + -1) {
puVar4 = (int8 *)(local_60 + local_78 * 0x10);
auVar5 = js_dup(*puVar4,puVar4[1]);
*pauVar1 = auVar5;
local_68 = local_68 + 1;
}
}
uVar2 = local_28;
auVar5 = js_int64(local_80);
iVar3 = JS_SetProperty(uVar2,local_48._0_8_,local_48._8_8_,0x32,auVar5._0_8_,auVar5._8_8_)
;
if (iVar3 < 0) goto LAB_001cb785;
}
auVar5._8_8_ = 3;
auVar5._0_8_ = (ulong)uStack_114 << 0x20;
local_10 = local_48;
local_48 = auVar5;
}
}
else {
JS_ThrowRangeError(local_28,"invalid array length");
}
}
goto LAB_001cb785;
LAB_001cb651:
for (; -1 < local_78; local_78 = local_78 + -1) {
*(ulong *)*local_68 = (ulong)uStack_f4 << 0x20;
*(int8 *)(*local_68 + 8) = 3;
local_68 = local_68 + 1;
}
LAB_001cb785:
JS_FreeValue(local_28,local_48._0_8_,local_48._8_8_);
JS_FreeValue(local_28,local_58._0_8_,local_58._8_8_);
return local_10;
}
| |
44,717 | js_array_toReversed | bluesky950520[P]quickjs/quickjs.c | static JSValue js_array_toReversed(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue arr, obj, ret, *arrp, *pval;
JSObject *p;
int64_t i, len;
uint32_t count32;
ret = JS_EXCEPTION;
arr = JS_UNDEFINED;
obj = JS_ToObject(ctx, this_val);
if (js_get_length64(ctx, &len, obj))
goto exception;
if (len > UINT32_MAX) {
JS_ThrowRangeError(ctx, "invalid array length");
goto exception;
}
arr = JS_NewArray(ctx);
if (JS_IsException(arr))
goto exception;
if (len > 0) {
p = JS_VALUE_GET_OBJ(arr);
if (expand_fast_array(ctx, p, len) < 0)
goto exception;
p->u.array.count = len;
i = len - 1;
pval = p->u.array.u.values;
if (js_get_fast_array(ctx, obj, &arrp, &count32) && count32 == len) {
for (; i >= 0; i--, pval++)
*pval = js_dup(arrp[i]);
} else {
// Query order is observable; test262 expects descending order.
for (; i >= 0; i--, pval++) {
if (-1 == JS_TryGetPropertyInt64(ctx, obj, i, pval)) {
// Exception; initialize remaining elements.
for (; i >= 0; i--, pval++)
*pval = JS_UNDEFINED;
goto exception;
}
}
}
if (JS_SetProperty(ctx, arr, JS_ATOM_length, js_int64(len)) < 0)
goto exception;
}
ret = arr;
arr = JS_UNDEFINED;
exception:
JS_FreeValue(ctx, arr);
JS_FreeValue(ctx, obj);
return ret;
} | O1 | c | js_array_toReversed:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movl $0x0, 0x30(%rsp)
callq 0x26ddd
movq %rax, %r14
movq %rdx, %r15
leaq 0x60(%rsp), %rsi
movq %rbx, %rdi
movq %rax, %rdx
movq %r15, %rcx
callq 0x22adc
movl $0x3, %r13d
testl %eax, %eax
je 0x7658e
xorl %r12d, %r12d
jmp 0x765b6
movq 0x60(%rsp), %rcx
movabsq $0x100000000, %rax # imm = 0x100000000
cmpq %rax, %rcx
jl 0x765f0
leaq 0x28bf5(%rip), %rsi # 0x9f19e
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x20add
movl $0x6, %ebp
movq 0x30(%rsp), %rsi
movq 0x18(%rbx), %rdi
movq %r13, %rdx
callq 0x1d8c6
movq 0x18(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1d8c6
movq %r12, %rax
movq %rbp, %rdx
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rcx, 0x28(%rsp)
movq 0x38(%rbx), %rsi
incl (%rsi)
movq %rbx, %rdi
movl $0x2, %edx
callq 0xf516
movq %rdx, %rbp
movq %rax, 0x30(%rsp)
cmpl $0x6, %ebp
jne 0x7661d
xorl %r12d, %r12d
movq %rbp, %r13
jmp 0x765b6
movq %rax, %r12
movq 0x28(%rsp), %rax
testq %rax, %rax
jle 0x76779
movq 0x30(%rsp), %rsi
movq %rbx, %rdi
movq %rsi, 0x38(%rsp)
movq %rax, %rdx
callq 0x3dbb8
testl %eax, %eax
js 0x76615
movq 0x38(%rsp), %rax
movq 0x28(%rsp), %rcx
movl %ecx, 0x40(%rax)
movq 0x38(%rax), %r8
movq %r14, 0x40(%rsp)
cmpl $-0x1, %r15d
jne 0x76679
movq 0x40(%rsp), %rcx
cmpw $0x2, 0x6(%rcx)
jne 0x76679
testb $0x8, 0x5(%rcx)
jne 0x767c1
xorl %eax, %eax
xorl %edx, %edx
testb %dl, %dl
je 0x766cd
movq 0x28(%rsp), %rdx
cmpq %rax, %rdx
jne 0x766d2
movq %rdx, %rax
shlq $0x4, %rax
addq %rcx, %rax
addq $-0x8, %rax
movq %rdx, %rcx
movq -0x8(%rax), %rdx
movq (%rax), %rsi
movq %rdx, 0x40(%rsp)
cmpl $-0x9, %esi
jb 0x766b4
movq 0x40(%rsp), %rdi
incl (%rdi)
movq %rdx, (%r8)
movq %rsi, 0x8(%r8)
addq $0x10, %r8
decq %rcx
addq $-0x10, %rax
testq %rcx, %rcx
jg 0x7669c
jmp 0x76712
movq 0x28(%rsp), %rdx
movq %rdx, 0x50(%rsp)
leaq -0x1(%rdx), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rcx, 0x58(%rsp)
movq %r8, 0x38(%rsp)
callq 0x4d6d1
cmpl $-0x1, %eax
je 0x76786
movq 0x38(%rsp), %r8
addq $0x10, %r8
movq 0x58(%rsp), %rax
movq %rax, %rdx
testq %rax, %rax
jg 0x766d2
movq 0x28(%rsp), %rcx
movq %rcx, %rax
shrq $0x1f, %rax
cvtsi2sd %rcx, %xmm0
movl %ecx, %ecx
movq %xmm0, %r8
cmoveq %rcx, %r8
movl $0x7, %r9d
cmoveq %rax, %r9
movq 0x30(%rsp), %rsi
movq %rsi, 0x40(%rsp)
movq %rbp, 0x48(%rsp)
movups 0x40(%rsp), %xmm0
movups %xmm0, (%rsp)
movq $0x0, 0x18(%rsp)
movl $0x4000, 0x10(%rsp) # imm = 0x4000
movq %rbx, %rdi
movq %rbp, %rdx
movl $0x32, %ecx
callq 0x24388
testl %eax, %eax
js 0x76615
movl $0x0, 0x30(%rsp)
jmp 0x765bb
movq 0x38(%rsp), %rcx
movq 0x50(%rsp), %rdx
movq %rdx, %rax
decq %rax
js 0x76615
xorl %r12d, %r12d
movq %rcx, %rax
movl $0x0, (%rax)
movq $0x3, 0x8(%rax)
addq $0x10, %rax
decq %rdx
testq %rdx, %rdx
jg 0x767a2
jmp 0x76618
movl 0x40(%rcx), %eax
movq 0x38(%rcx), %rcx
movb $0x1, %dl
jmp 0x7667d
| js_array_toReversed:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov rbx, rdi
mov dword ptr [rsp+98h+var_68], 0
call JS_ToObject
mov r14, rax
mov r15, rdx
lea rsi, [rsp+98h+var_38]
mov rdi, rbx
mov rdx, rax
mov rcx, r15
call js_get_length64
mov r13d, 3
test eax, eax
jz short loc_7658E
xor r12d, r12d
jmp short loc_765B6
loc_7658E:
mov rcx, [rsp+98h+var_38]
mov rax, 100000000h
cmp rcx, rax
jl short loc_765F0
lea rsi, aInvalidArrayLe; "invalid array length"
xor r12d, r12d
mov rdi, rbx
xor eax, eax
call JS_ThrowRangeError
loc_765B6:
mov ebp, 6
loc_765BB:
mov rsi, [rsp+98h+var_68]
mov rdi, [rbx+18h]
mov rdx, r13
call JS_FreeValueRT
mov rdi, [rbx+18h]
mov rsi, r14
mov rdx, r15
call JS_FreeValueRT
mov rax, r12
mov rdx, rbp
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_765F0:
mov [rsp+98h+var_70], rcx
mov rsi, [rbx+38h]
inc dword ptr [rsi]
mov rdi, rbx
mov edx, 2
call JS_NewObjectFromShape
mov rbp, rdx
mov [rsp+98h+var_68], rax
cmp ebp, 6
jnz short loc_7661D
loc_76615:
xor r12d, r12d
loc_76618:
mov r13, rbp
jmp short loc_765B6
loc_7661D:
mov r12, rax
mov rax, [rsp+98h+var_70]
test rax, rax
jle loc_76779
mov rsi, [rsp+98h+var_68]
mov rdi, rbx
mov [rsp+98h+var_60], rsi
mov rdx, rax
call expand_fast_array
test eax, eax
js short loc_76615
mov rax, [rsp+98h+var_60]
mov rcx, [rsp+98h+var_70]
mov [rax+40h], ecx
mov r8, [rax+38h]
mov qword ptr [rsp+98h+var_58], r14
cmp r15d, 0FFFFFFFFh
jnz short loc_76679
mov rcx, qword ptr [rsp+98h+var_58]
cmp word ptr [rcx+6], 2
jnz short loc_76679
test byte ptr [rcx+5], 8
jnz loc_767C1
loc_76679:
xor eax, eax
xor edx, edx
loc_7667D:
test dl, dl
jz short loc_766CD
mov rdx, [rsp+98h+var_70]
cmp rdx, rax
jnz short loc_766D2
mov rax, rdx
shl rax, 4
add rax, rcx
add rax, 0FFFFFFFFFFFFFFF8h
mov rcx, rdx
loc_7669C:
mov rdx, [rax-8]
mov rsi, [rax]
mov qword ptr [rsp+98h+var_58], rdx
cmp esi, 0FFFFFFF7h
jb short loc_766B4
mov rdi, qword ptr [rsp+98h+var_58]
inc dword ptr [rdi]
loc_766B4:
mov [r8], rdx
mov [r8+8], rsi
add r8, 10h
dec rcx
add rax, 0FFFFFFFFFFFFFFF0h
test rcx, rcx
jg short loc_7669C
jmp short loc_76712
loc_766CD:
mov rdx, [rsp+98h+var_70]
loc_766D2:
mov [rsp+98h+var_48], rdx
lea rcx, [rdx-1]
mov rdi, rbx
mov rsi, r14
mov rdx, r15
mov [rsp+98h+var_40], rcx
mov [rsp+98h+var_60], r8
call JS_TryGetPropertyInt64
cmp eax, 0FFFFFFFFh
jz loc_76786
mov r8, [rsp+98h+var_60]
add r8, 10h
mov rax, [rsp+98h+var_40]
mov rdx, rax
test rax, rax
jg short loc_766D2
loc_76712:
mov rcx, [rsp+98h+var_70]
mov rax, rcx
shr rax, 1Fh
cvtsi2sd xmm0, rcx
mov ecx, ecx
movq r8, xmm0
cmovz r8, rcx
mov r9d, 7
cmovz r9, rax
mov rsi, [rsp+98h+var_68]
mov qword ptr [rsp+98h+var_58], rsi
mov qword ptr [rsp+98h+var_58+8], rbp
movups xmm0, [rsp+98h+var_58]
movups [rsp+98h+var_98], xmm0
mov [rsp+98h+var_80], 0
mov [rsp+98h+var_88], 4000h
mov rdi, rbx
mov rdx, rbp
mov ecx, 32h ; '2'
call JS_SetPropertyInternal2
test eax, eax
js loc_76615
loc_76779:
mov dword ptr [rsp+98h+var_68], 0
jmp loc_765BB
loc_76786:
mov rcx, [rsp+98h+var_60]
mov rdx, [rsp+98h+var_48]
mov rax, rdx
dec rax
js loc_76615
xor r12d, r12d
mov rax, rcx
loc_767A2:
mov dword ptr [rax], 0
mov qword ptr [rax+8], 3
add rax, 10h
dec rdx
test rdx, rdx
jg short loc_767A2
jmp loc_76618
loc_767C1:
mov eax, [rcx+40h]
mov rcx, [rcx+38h]
mov dl, 1
jmp loc_7667D
| long long js_array_toReversed(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
_DWORD *v14; // r14
long long v15; // rdx
long long v16; // r15
long long v17; // rdx
long long v18; // r8
long long v19; // r9
__m128 v20; // xmm4
__m128 v21; // xmm5
long long v22; // r13
long long v23; // r12
_DWORD *v25; // rsi
long long v26; // rax
unsigned long long v27; // rdx
unsigned long long v28; // rbp
double v29; // xmm4_8
double v30; // xmm5_8
_DWORD *v31; // rcx
_QWORD *v32; // r8
long long v33; // rax
char v34; // dl
unsigned long long v35; // rdx
long long *v36; // rax
long long i; // rcx
long long v38; // rdx
long long v39; // rsi
double v40; // r8
long long v41; // r9
long long v42; // rdx
_QWORD *v43; // rax
char v44; // [rsp+0h] [rbp-98h]
unsigned long long v45; // [rsp+28h] [rbp-70h]
long long v46; // [rsp+30h] [rbp-68h]
_QWORD *v47; // [rsp+38h] [rbp-60h]
__m128 v48; // [rsp+40h] [rbp-58h]
long long v49; // [rsp+50h] [rbp-48h]
long long v50; // [rsp+58h] [rbp-40h]
long long v51[7]; // [rsp+60h] [rbp-38h] BYREF
LODWORD(v46) = 0;
v14 = JS_ToObject(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
v16 = v15;
v22 = 3LL;
if ( !(unsigned int)js_get_length64(a1, v51, (int)v14, v15) )
{
if ( v51[0] >= 0x100000000LL )
{
v23 = 0LL;
JS_ThrowRangeError(
a1,
(long long)"invalid array length",
v17,
v51[0],
v18,
v19,
a7,
a8,
a9,
a10,
v20,
v21,
a13,
a14,
v44);
goto LABEL_5;
}
v45 = v51[0];
v25 = *(_DWORD **)(a1 + 56);
++*v25;
v26 = JS_NewObjectFromShape(a1, v25, 2u);
v28 = v27;
v46 = v26;
if ( (_DWORD)v27 == 6 )
goto LABEL_7;
v23 = v26;
if ( (long long)v45 > 0 )
{
if ( (int)expand_fast_array(a1, v26, v45) >= 0 )
{
v31 = (_DWORD *)v45;
*(_DWORD *)(v46 + 64) = v45;
v32 = *(_QWORD **)(v46 + 56);
if ( (_DWORD)v16 == -1 && (v31 = v14, *((_WORD *)v14 + 3) == 2) && (*((_BYTE *)v14 + 5) & 8) != 0 )
{
v33 = (unsigned int)v14[16];
v31 = (_DWORD *)*((_QWORD *)v14 + 7);
v34 = 1;
}
else
{
v33 = 0LL;
v34 = 0;
}
if ( v34 )
{
v35 = v45;
if ( v45 != v33 )
goto LABEL_23;
v36 = (long long *)&v31[4 * v45 - 2];
for ( i = v45; i > 0; --i )
{
v38 = *(v36 - 1);
v39 = *v36;
if ( (unsigned int)*v36 >= 0xFFFFFFF7 )
++*(_DWORD *)*(v36 - 1);
*v32 = v38;
v32[1] = v39;
v32 += 2;
v36 -= 2;
}
LABEL_25:
v40 = (double)(int)v45;
if ( !(v45 >> 31) )
*(_QWORD *)&v40 = (unsigned int)v45;
v41 = 7LL;
if ( !(v45 >> 31) )
v41 = v45 >> 31;
v48.m128_u64[0] = v46;
v48.m128_u64[1] = v28;
if ( (int)JS_SetPropertyInternal2(
a1,
v46,
v28,
0x32u,
*(_DWORD **)&v40,
v41,
v48,
a8,
a9,
a10,
v29,
v30,
a13,
a14,
v46,
v28,
0x4000u,
0LL) >= 0 )
goto LABEL_30;
}
else
{
v35 = v45;
LABEL_23:
while ( 1 )
{
v49 = v35;
v50 = v35 - 1;
v47 = v32;
if ( (unsigned int)JS_TryGetPropertyInt64(a1, (long long)v14, v16, v35 - 1, (long long)v32) == -1 )
break;
v32 = v47 + 2;
v35 = v50;
if ( v50 <= 0 )
goto LABEL_25;
}
v42 = v49;
if ( v49 - 1 >= 0 )
{
v23 = 0LL;
v43 = v47;
do
{
*(_DWORD *)v43 = 0;
v43[1] = 3LL;
v43 += 2;
--v42;
}
while ( v42 > 0 );
goto LABEL_8;
}
}
}
LABEL_7:
v23 = 0LL;
LABEL_8:
v22 = v28;
goto LABEL_5;
}
LABEL_30:
LODWORD(v46) = 0;
goto LABEL_5;
}
v23 = 0LL;
LABEL_5:
JS_FreeValueRT(*(_QWORD *)(a1 + 24), (_DWORD *)v46, v22);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v14, v16);
return v23;
}
| js_array_toReversed:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV RBX,RDI
MOV dword ptr [RSP + 0x30],0x0
CALL 0x00126ddd
MOV R14,RAX
MOV R15,RDX
LEA RSI,[RSP + 0x60]
MOV RDI,RBX
MOV RDX,RAX
MOV RCX,R15
CALL 0x00122adc
MOV R13D,0x3
TEST EAX,EAX
JZ 0x0017658e
XOR R12D,R12D
JMP 0x001765b6
LAB_0017658e:
MOV RCX,qword ptr [RSP + 0x60]
MOV RAX,0x100000000
CMP RCX,RAX
JL 0x001765f0
LEA RSI,[0x19f19e]
XOR R12D,R12D
MOV RDI,RBX
XOR EAX,EAX
CALL 0x00120add
LAB_001765b6:
MOV EBP,0x6
LAB_001765bb:
MOV RSI,qword ptr [RSP + 0x30]
MOV RDI,qword ptr [RBX + 0x18]
MOV RDX,R13
CALL 0x0011d8c6
MOV RDI,qword ptr [RBX + 0x18]
MOV RSI,R14
MOV RDX,R15
CALL 0x0011d8c6
MOV RAX,R12
MOV RDX,RBP
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001765f0:
MOV qword ptr [RSP + 0x28],RCX
MOV RSI,qword ptr [RBX + 0x38]
INC dword ptr [RSI]
MOV RDI,RBX
MOV EDX,0x2
CALL 0x0010f516
MOV RBP,RDX
MOV qword ptr [RSP + 0x30],RAX
CMP EBP,0x6
JNZ 0x0017661d
LAB_00176615:
XOR R12D,R12D
LAB_00176618:
MOV R13,RBP
JMP 0x001765b6
LAB_0017661d:
MOV R12,RAX
MOV RAX,qword ptr [RSP + 0x28]
TEST RAX,RAX
JLE 0x00176779
MOV RSI,qword ptr [RSP + 0x30]
MOV RDI,RBX
MOV qword ptr [RSP + 0x38],RSI
MOV RDX,RAX
CALL 0x0013dbb8
TEST EAX,EAX
JS 0x00176615
MOV RAX,qword ptr [RSP + 0x38]
MOV RCX,qword ptr [RSP + 0x28]
MOV dword ptr [RAX + 0x40],ECX
MOV R8,qword ptr [RAX + 0x38]
MOV qword ptr [RSP + 0x40],R14
CMP R15D,-0x1
JNZ 0x00176679
MOV RCX,qword ptr [RSP + 0x40]
CMP word ptr [RCX + 0x6],0x2
JNZ 0x00176679
TEST byte ptr [RCX + 0x5],0x8
JNZ 0x001767c1
LAB_00176679:
XOR EAX,EAX
XOR EDX,EDX
LAB_0017667d:
TEST DL,DL
JZ 0x001766cd
MOV RDX,qword ptr [RSP + 0x28]
CMP RDX,RAX
JNZ 0x001766d2
MOV RAX,RDX
SHL RAX,0x4
ADD RAX,RCX
ADD RAX,-0x8
MOV RCX,RDX
LAB_0017669c:
MOV RDX,qword ptr [RAX + -0x8]
MOV RSI,qword ptr [RAX]
MOV qword ptr [RSP + 0x40],RDX
CMP ESI,-0x9
JC 0x001766b4
MOV RDI,qword ptr [RSP + 0x40]
INC dword ptr [RDI]
LAB_001766b4:
MOV qword ptr [R8],RDX
MOV qword ptr [R8 + 0x8],RSI
ADD R8,0x10
DEC RCX
ADD RAX,-0x10
TEST RCX,RCX
JG 0x0017669c
JMP 0x00176712
LAB_001766cd:
MOV RDX,qword ptr [RSP + 0x28]
LAB_001766d2:
MOV qword ptr [RSP + 0x50],RDX
LEA RCX,[RDX + -0x1]
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R15
MOV qword ptr [RSP + 0x58],RCX
MOV qword ptr [RSP + 0x38],R8
CALL 0x0014d6d1
CMP EAX,-0x1
JZ 0x00176786
MOV R8,qword ptr [RSP + 0x38]
ADD R8,0x10
MOV RAX,qword ptr [RSP + 0x58]
MOV RDX,RAX
TEST RAX,RAX
JG 0x001766d2
LAB_00176712:
MOV RCX,qword ptr [RSP + 0x28]
MOV RAX,RCX
SHR RAX,0x1f
CVTSI2SD XMM0,RCX
MOV ECX,ECX
MOVQ R8,XMM0
CMOVZ R8,RCX
MOV R9D,0x7
CMOVZ R9,RAX
MOV RSI,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x40],RSI
MOV qword ptr [RSP + 0x48],RBP
MOVUPS XMM0,xmmword ptr [RSP + 0x40]
MOVUPS xmmword ptr [RSP],XMM0
MOV qword ptr [RSP + 0x18],0x0
MOV dword ptr [RSP + 0x10],0x4000
MOV RDI,RBX
MOV RDX,RBP
MOV ECX,0x32
CALL 0x00124388
TEST EAX,EAX
JS 0x00176615
LAB_00176779:
MOV dword ptr [RSP + 0x30],0x0
JMP 0x001765bb
LAB_00176786:
MOV RCX,qword ptr [RSP + 0x38]
MOV RDX,qword ptr [RSP + 0x50]
MOV RAX,RDX
DEC RAX
JS 0x00176615
XOR R12D,R12D
MOV RAX,RCX
LAB_001767a2:
MOV dword ptr [RAX],0x0
MOV qword ptr [RAX + 0x8],0x3
ADD RAX,0x10
DEC RDX
TEST RDX,RDX
JG 0x001767a2
JMP 0x00176618
LAB_001767c1:
MOV EAX,dword ptr [RCX + 0x40]
MOV RCX,qword ptr [RCX + 0x38]
MOV DL,0x1
JMP 0x0017667d
|
int1 [16] js_array_toReversed(long param_1)
{
int *piVar1;
bool bVar2;
int1 auVar3 [16];
int iVar4;
ulong uVar5;
ulong uVar7;
int8 *puVar8;
int8 *puVar9;
ulong uVar10;
int8 uVar11;
ulong uVar12;
double dVar13;
int8 uVar14;
int1 auVar15 [16];
int1 auVar16 [16];
ulong local_68;
int4 local_58;
ulong local_38;
ulong uVar6;
local_68 = local_68 & 0xffffffff00000000;
auVar15 = JS_ToObject();
uVar11 = auVar15._8_8_;
uVar5 = auVar15._0_8_;
iVar4 = js_get_length64(param_1,&local_38,uVar5,uVar11);
auVar3._8_8_ = 3;
auVar3._0_8_ = local_68;
auVar16._8_8_ = 3;
auVar16._0_8_ = local_68;
if (iVar4 == 0) {
if ((long)local_38 < 0x100000000) {
piVar1 = *(int **)(param_1 + 0x38);
*piVar1 = *piVar1 + 1;
auVar16 = JS_NewObjectFromShape(param_1,piVar1,2);
uVar6 = auVar16._0_8_;
auVar3 = auVar16;
if (auVar16._8_4_ != 6) {
if ((long)local_38 < 1) {
LAB_00176779:
local_68 = uVar6 & 0xffffffff00000000;
auVar3._8_8_ = 3;
auVar3._0_8_ = local_68;
goto LAB_001765bb;
}
iVar4 = expand_fast_array(param_1,uVar6,local_38);
if (-1 < iVar4) {
*(int *)(uVar6 + 0x40) = (int)local_38;
puVar9 = *(int8 **)(uVar6 + 0x38);
uVar10 = local_38;
if (((auVar15._8_4_ == -1) && (uVar10 = uVar5, *(short *)(uVar5 + 6) == 2)) &&
((*(byte *)(uVar5 + 5) & 8) != 0)) {
uVar7 = (ulong)*(uint *)(uVar5 + 0x40);
uVar10 = *(ulong *)(uVar5 + 0x38);
bVar2 = true;
}
else {
uVar7 = 0;
bVar2 = false;
}
uVar12 = local_38;
if ((bVar2) && (local_38 == uVar7)) {
puVar8 = (int8 *)(local_38 * 0x10 + uVar10 + -8);
uVar10 = local_38;
do {
piVar1 = (int *)puVar8[-1];
uVar14 = *puVar8;
if (0xfffffff6 < (uint)uVar14) {
*piVar1 = *piVar1 + 1;
}
*puVar9 = piVar1;
puVar9[1] = uVar14;
puVar9 = puVar9 + 2;
uVar10 = uVar10 - 1;
puVar8 = puVar8 + -2;
} while (0 < (long)uVar10);
}
else {
do {
uVar10 = uVar12 - 1;
iVar4 = JS_TryGetPropertyInt64(param_1,uVar5,uVar11);
if (iVar4 == -1) {
if (-1 < (long)(uVar12 - 1)) {
do {
*(int4 *)puVar9 = 0;
puVar9[1] = 3;
puVar9 = puVar9 + 2;
uVar12 = uVar12 - 1;
} while (0 < (long)uVar12);
}
goto LAB_001765b6;
}
puVar9 = puVar9 + 2;
uVar12 = uVar10;
} while (0 < (long)uVar10);
}
bVar2 = local_38 >> 0x1f == 0;
dVar13 = (double)(long)local_38;
if (bVar2) {
dVar13 = (double)(local_38 & 0xffffffff);
}
uVar14 = 7;
if (bVar2) {
uVar14 = 0;
}
local_58 = auVar16._0_4_;
iVar4 = JS_SetPropertyInternal2
(param_1,uVar6,auVar16._8_8_,0x32,dVar13,uVar14,local_58,auVar16._8_4_,
0x4000,0);
if (-1 < iVar4) goto LAB_00176779;
}
}
}
else {
JS_ThrowRangeError(param_1,"invalid array length");
auVar3 = auVar16;
}
}
LAB_001765b6:
auVar16 = ZEXT816(6) << 0x40;
LAB_001765bb:
local_68 = auVar3._0_8_;
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),local_68,auVar3._8_8_);
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),uVar5,uVar11);
return auVar16;
}
| |
44,718 | my_wc_mb_8bit | eloqsql/strings/ctype-simple.c | int my_wc_mb_8bit(CHARSET_INFO *cs,my_wc_t wc,
uchar *str,
uchar *end)
{
MY_UNI_IDX *idx;
if (str >= end)
return MY_CS_TOOSMALL;
for (idx=cs->tab_from_uni; idx->tab ; idx++)
{
if (idx->from <= wc && idx->to >= wc)
{
str[0]= idx->tab[wc - idx->from];
return (!str[0] && wc) ? MY_CS_ILUNI : 1;
}
}
return MY_CS_ILUNI;
} | O3 | c | my_wc_mb_8bit:
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0x38d09
pushq %rbp
movq %rsp, %rbp
movq 0x70(%rdi), %rcx
movq 0x8(%rcx), %rdi
xorl %eax, %eax
testq %rdi, %rdi
je 0x38d08
addq $0x2, %rcx
movzwl -0x2(%rcx), %r9d
movq %rsi, %r8
subq %r9, %r8
jb 0x38ce3
movzwl (%rcx), %r9d
cmpq %rsi, %r9
jae 0x38cf2
movq 0x16(%rcx), %rdi
addq $0x10, %rcx
testq %rdi, %rdi
jne 0x38ccd
jmp 0x38d08
movb (%rdi,%r8), %al
movb %al, (%rdx)
testb %al, %al
setne %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
movzbl %cl, %eax
popq %rbp
retq
| my_wc_mb_8bit:
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short locret_38D09
push rbp
mov rbp, rsp
mov rcx, [rdi+70h]
mov rdi, [rcx+8]
xor eax, eax
test rdi, rdi
jz short loc_38D08
add rcx, 2
loc_38CCD:
movzx r9d, word ptr [rcx-2]
mov r8, rsi
sub r8, r9
jb short loc_38CE3
movzx r9d, word ptr [rcx]
cmp r9, rsi
jnb short loc_38CF2
loc_38CE3:
mov rdi, [rcx+16h]
add rcx, 10h
test rdi, rdi
jnz short loc_38CCD
jmp short loc_38D08
loc_38CF2:
mov al, [rdi+r8]
mov [rdx], al
test al, al
setnz al
test rsi, rsi
setz cl
or cl, al
movzx eax, cl
loc_38D08:
pop rbp
locret_38D09:
retn
| long long my_wc_mb_8bit(long long a1, unsigned long long a2, _BYTE *a3, unsigned long long a4)
{
long long result; // rax
long long v5; // rcx
long long v6; // rdi
unsigned __int16 *i; // rcx
unsigned long long v8; // r9
char v9; // al
result = 4294967195LL;
if ( (unsigned long long)a3 < a4 )
{
v5 = *(_QWORD *)(a1 + 112);
v6 = *(_QWORD *)(v5 + 8);
result = 0LL;
if ( v6 )
{
for ( i = (unsigned __int16 *)(v5 + 2); ; i += 8 )
{
v8 = *(i - 1);
if ( a2 >= v8 && *i >= a2 )
break;
v6 = *(_QWORD *)(i + 11);
if ( !v6 )
return result;
}
v9 = *(_BYTE *)(v6 + a2 - v8);
*a3 = v9;
return (v9 != 0) | (unsigned __int8)(a2 == 0);
}
}
return result;
}
| my_wc_mb_8bit:
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x00138d09
PUSH RBP
MOV RBP,RSP
MOV RCX,qword ptr [RDI + 0x70]
MOV RDI,qword ptr [RCX + 0x8]
XOR EAX,EAX
TEST RDI,RDI
JZ 0x00138d08
ADD RCX,0x2
LAB_00138ccd:
MOVZX R9D,word ptr [RCX + -0x2]
MOV R8,RSI
SUB R8,R9
JC 0x00138ce3
MOVZX R9D,word ptr [RCX]
CMP R9,RSI
JNC 0x00138cf2
LAB_00138ce3:
MOV RDI,qword ptr [RCX + 0x16]
ADD RCX,0x10
TEST RDI,RDI
JNZ 0x00138ccd
JMP 0x00138d08
LAB_00138cf2:
MOV AL,byte ptr [RDI + R8*0x1]
MOV byte ptr [RDX],AL
TEST AL,AL
SETNZ AL
TEST RSI,RSI
SETZ CL
OR CL,AL
MOVZX EAX,CL
LAB_00138d08:
POP RBP
LAB_00138d09:
RET
|
ulong my_wc_mb_8bit(long param_1,ulong param_2,char *param_3,char *param_4)
{
char cVar1;
ulong uVar2;
ushort *puVar3;
long lVar4;
uVar2 = 0xffffff9b;
if (param_3 < param_4) {
lVar4 = *(long *)(*(long *)(param_1 + 0x70) + 8);
uVar2 = 0;
if (lVar4 != 0) {
puVar3 = (ushort *)(*(long *)(param_1 + 0x70) + 2);
do {
if ((puVar3[-1] <= param_2) && (param_2 <= *puVar3)) {
cVar1 = *(char *)(lVar4 + (param_2 - puVar3[-1]));
*param_3 = cVar1;
return (ulong)(param_2 == 0 || cVar1 != '\0');
}
lVar4 = *(long *)(puVar3 + 0xb);
puVar3 = puVar3 + 8;
} while (lVar4 != 0);
}
}
return uVar2;
}
| |
44,719 | my_fprintf | eloqsql/strings/my_vsnprintf.c | int my_fprintf(FILE *stream, const char* format, ...)
{
int result;
va_list args;
va_start(args, format);
result= my_vfprintf(stream, format, args);
va_end(args);
return result;
} | O3 | c | my_fprintf:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
leaq -0xd0(%rbp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x5a4d8
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
leaq -0x20(%rbp), %rdx
movq %r10, 0x10(%rdx)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax # imm = 0x3000000010
movq %rax, (%rdx)
callq 0x5a39c
addq $0xd0, %rsp
popq %rbp
retq
nop
| my_fprintf:
push rbp
mov rbp, rsp
sub rsp, 0D0h
lea r10, [rbp+var_D0]
mov [r10+10h], rdx
mov [r10+18h], rcx
mov [r10+20h], r8
mov [r10+28h], r9
test al, al
jz short loc_5A4D8
movaps [rbp+var_A0], xmm0
movaps [rbp+var_90], xmm1
movaps [rbp+var_80], xmm2
movaps [rbp+var_70], xmm3
movaps [rbp+var_60], xmm4
movaps [rbp+var_50], xmm5
movaps [rbp+var_40], xmm6
movaps [rbp+var_30], xmm7
loc_5A4D8:
lea rdx, [rbp+var_20]
mov [rdx+10h], r10
lea rax, [rbp+arg_0]
mov [rdx+8], rax
mov rax, 3000000010h
mov [rdx], rax
call my_vfprintf
add rsp, 0D0h
pop rbp
retn
| long long my_fprintf(
long long a1,
unsigned __int8 *a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
char v16; // [rsp+0h] [rbp-D0h] BYREF
long long v17; // [rsp+10h] [rbp-C0h]
long long v18; // [rsp+18h] [rbp-B8h]
long long v19; // [rsp+20h] [rbp-B0h]
long long v20; // [rsp+28h] [rbp-A8h]
__m128 v21; // [rsp+30h] [rbp-A0h]
__m128 v22; // [rsp+40h] [rbp-90h]
__m128 v23; // [rsp+50h] [rbp-80h]
__m128 v24; // [rsp+60h] [rbp-70h]
__m128 v25; // [rsp+70h] [rbp-60h]
__m128 v26; // [rsp+80h] [rbp-50h]
__m128 v27; // [rsp+90h] [rbp-40h]
__m128 v28; // [rsp+A0h] [rbp-30h]
_QWORD v29[4]; // [rsp+B0h] [rbp-20h] BYREF
v21 = a7;
v22 = a8;
v23 = a9;
v24 = a10;
v25 = a11;
v26 = a12;
v27 = a13;
v28 = a14;
v17 = a3;
v18 = a4;
v19 = a5;
v20 = a6;
v29[2] = &v16;
v29[1] = &a15;
v29[0] = 0x3000000010LL;
return my_vfprintf(a1, a2, (unsigned int *)v29);
}
| my_fprintf:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xd0
LEA R10,[RBP + -0xd0]
MOV qword ptr [R10 + 0x10],RDX
MOV qword ptr [R10 + 0x18],RCX
MOV qword ptr [R10 + 0x20],R8
MOV qword ptr [R10 + 0x28],R9
TEST AL,AL
JZ 0x0015a4d8
MOVAPS xmmword ptr [RBP + -0xa0],XMM0
MOVAPS xmmword ptr [RBP + -0x90],XMM1
MOVAPS xmmword ptr [RBP + -0x80],XMM2
MOVAPS xmmword ptr [RBP + -0x70],XMM3
MOVAPS xmmword ptr [RBP + -0x60],XMM4
MOVAPS xmmword ptr [RBP + -0x50],XMM5
MOVAPS xmmword ptr [RBP + -0x40],XMM6
MOVAPS xmmword ptr [RBP + -0x30],XMM7
LAB_0015a4d8:
LEA RDX,[RBP + -0x20]
MOV qword ptr [RDX + 0x10],R10
LEA RAX,[RBP + 0x10]
MOV qword ptr [RDX + 0x8],RAX
MOV RAX,0x3000000010
MOV qword ptr [RDX],RAX
CALL 0x0015a39c
ADD RSP,0xd0
POP RBP
RET
|
void my_fprintf(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
int8 param_9,int8 param_10,int8 param_11,int8 param_12,
int8 param_13,int8 param_14)
{
char in_AL;
int1 local_d8 [16];
int8 local_c8;
int8 local_c0;
int8 local_b8;
int8 local_b0;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
int8 local_58;
int8 local_48;
int8 local_38;
int8 local_28;
int1 *local_20;
int1 *local_18;
local_18 = local_d8;
if (in_AL != '\0') {
local_a8 = param_1;
local_98 = param_2;
local_88 = param_3;
local_78 = param_4;
local_68 = param_5;
local_58 = param_6;
local_48 = param_7;
local_38 = param_8;
}
local_20 = &stack0x00000008;
local_28 = 0x3000000010;
local_c8 = param_11;
local_c0 = param_12;
local_b8 = param_13;
local_b0 = param_14;
my_vfprintf();
return;
}
| |
44,720 | mysql_close_cont | eloqsql/libmariadb/libmariadb/mariadb_async.c | int STDCALL
mysql_close_cont(MYSQL *sock, int ready_status)
{
int res;
res= mysql_close_slow_part_cont(sock, ready_status);
if (res)
return res;
mysql_close(sock);
return 0;
} | O0 | c | mysql_close_cont:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x5d6a0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x5d88c
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5d89c
movq -0x10(%rbp), %rdi
callq 0x418c0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| mysql_close_cont:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov rdi, [rbp+var_10]
mov esi, [rbp+var_14]
call mysql_close_slow_part_cont
mov [rbp+var_18], eax
cmp [rbp+var_18], 0
jz short loc_5D88C
mov eax, [rbp+var_18]
mov [rbp+var_4], eax
jmp short loc_5D89C
loc_5D88C:
mov rdi, [rbp+var_10]
call mysql_close
mov [rbp+var_4], 0
loc_5D89C:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
| long long mysql_close_cont(long long a1, unsigned int a2)
{
unsigned int v3; // [rsp+8h] [rbp-18h]
v3 = mysql_close_slow_part_cont(a1, a2);
if ( v3 )
{
return v3;
}
else
{
mysql_close(a1);
return 0;
}
}
| mysql_close_cont:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x14]
CALL 0x0015d6a0
MOV dword ptr [RBP + -0x18],EAX
CMP dword ptr [RBP + -0x18],0x0
JZ 0x0015d88c
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0015d89c
LAB_0015d88c:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001418c0
MOV dword ptr [RBP + -0x4],0x0
LAB_0015d89c:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int mysql_close_cont(int8 param_1,int4 param_2)
{
int4 local_c;
local_c = mysql_close_slow_part_cont(param_1,param_2);
if (local_c == 0) {
mysql_close(param_1);
local_c = 0;
}
return local_c;
}
| |
44,721 | process_int_arg | eloqsql/strings/my_vsnprintf.c | static char *process_int_arg(char *to, const char *end, size_t length,
longlong par, char arg_type, uint print_type)
{
size_t res_length, to_length;
char *store_start= to, *store_end;
char buff[32];
if ((to_length= (size_t) (end-to)) < 16 || length)
store_start= buff;
if (arg_type == 'd' || arg_type == 'i')
store_end= longlong10_to_str(par, store_start, -10);
else if (arg_type == 'u')
store_end= longlong10_to_str(par, store_start, 10);
else if (arg_type == 'p')
{
store_start[0]= '0';
store_start[1]= 'x';
store_end= ll2str(par, store_start + 2, 16, 0);
}
else if (arg_type == 'o')
{
store_end= ll2str(par, store_start, 8, 0);
}
else
{
DBUG_ASSERT(arg_type == 'X' || arg_type =='x');
store_end= ll2str(par, store_start, 16, (arg_type == 'X'));
}
if ((res_length= (size_t) (store_end - store_start)) > to_length)
return to; /* num doesn't fit in output */
/* If %#d syntax was used, we have to pre-zero/pre-space the string */
if (store_start == buff)
{
length= MY_MIN(length, to_length);
if (res_length < length)
{
size_t diff= (length- res_length);
bfill(to, diff, (print_type & PREZERO_ARG) ? '0' : ' ');
if (arg_type == 'p' && print_type & PREZERO_ARG)
{
if (diff > 1)
to[1]= 'x';
else
store_start[0]= 'x';
store_start[1]= '0';
}
to+= diff;
}
bmove(to, store_start, res_length);
}
to+= res_length;
return to;
} | O3 | c | process_int_arg:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r13
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
subq %rdi, %r13
cmpq $0x10, %r13
setb %al
movq %rdx, -0x68(%rbp)
testq %rdx, %rdx
setne %dl
orb %al, %dl
leaq -0x50(%rbp), %rax
movq %rdi, %r15
cmovneq %rax, %r15
cmpl $0x6e, %r8d
movl %r8d, -0x58(%rbp)
movb %dl, -0x51(%rbp)
movq %r9, -0x60(%rbp)
jle 0x91e66
cmpl $0x6f, %r8d
je 0x91e87
cmpl $0x70, %r8d
je 0x91e97
movq %rax, %r12
cmpl $0x75, %r8d
jne 0x91ebb
movq %rcx, %rdi
movq %r15, %rsi
movl $0xa, %edx
jmp 0x91e80
movq %rax, %r12
cmpl $0x64, %r8d
je 0x91e75
cmpl $0x69, %r8d
jne 0x91ebb
movq %rcx, %rdi
movq %r15, %rsi
movl $0xfffffff6, %edx # imm = 0xFFFFFFF6
callq 0x90a52
jmp 0x91ed6
movq %rax, %r12
movq %rcx, %rdi
movq %r15, %rsi
movl $0x8, %edx
jmp 0x91eb7
movb $0x30, (%r15)
testb %dl, %dl
movq %rbx, %rsi
movq %rax, %r12
cmovneq %rax, %rsi
movb $0x78, 0x1(%rsi)
addq $0x2, %rsi
movq %rcx, %rdi
movl $0x10, %edx
xorl %ecx, %ecx
jmp 0x91ed1
xorl %eax, %eax
cmpb $0x58, %r8b
sete %al
movq %rcx, %rdi
movq %r15, %rsi
movl $0x10, %edx
movl %eax, %ecx
callq 0x9097c
movq %rax, %r14
subq %r15, %r14
cmpq %r13, %r14
ja 0x91f52
cmpq %r12, %r15
jne 0x91f4f
movq -0x68(%rbp), %r12
cmpq %r12, %r13
cmovbq %r13, %r12
subq %r14, %r12
jbe 0x91f41
movq -0x60(%rbp), %rax
andl $0x4, %eax
sete %r13b
leal 0x20(,%rax,4), %esi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x281d0
cmpb $0x70, -0x58(%rbp)
setne %al
orb %r13b, %al
jne 0x91f3e
leaq 0x1(%rbx), %rax
cmpq $0x2, %r12
cmovbq %r15, %rax
movb $0x78, (%rax)
cmpb $0x0, -0x51(%rbp)
leaq -0x50(%rbp), %rax
cmoveq %rbx, %rax
movb $0x30, 0x1(%rax)
addq %r12, %rbx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x28660
addq %r14, %rbx
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x91f73
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x28400
| process_int_arg:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov r13, rsi
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
sub r13, rdi
cmp r13, 10h
setb al
mov [rbp+var_68], rdx
test rdx, rdx
setnz dl
or dl, al
lea rax, [rbp+var_50]
mov r15, rdi
cmovnz r15, rax
cmp r8d, 6Eh ; 'n'
mov [rbp+var_58], r8d
mov [rbp+var_51], dl
mov [rbp+var_60], r9
jle short loc_91E66
cmp r8d, 6Fh ; 'o'
jz short loc_91E87
cmp r8d, 70h ; 'p'
jz short loc_91E97
mov r12, rax
cmp r8d, 75h ; 'u'
jnz short loc_91EBB
mov rdi, rcx
mov rsi, r15
mov edx, 0Ah
jmp short loc_91E80
loc_91E66:
mov r12, rax
cmp r8d, 64h ; 'd'
jz short loc_91E75
cmp r8d, 69h ; 'i'
jnz short loc_91EBB
loc_91E75:
mov rdi, rcx
mov rsi, r15
mov edx, 0FFFFFFF6h
loc_91E80:
call int10_to_str
jmp short loc_91ED6
loc_91E87:
mov r12, rax
mov rdi, rcx
mov rsi, r15
mov edx, 8
jmp short loc_91EB7
loc_91E97:
mov byte ptr [r15], 30h ; '0'
test dl, dl
mov rsi, rbx
mov r12, rax
cmovnz rsi, rax
mov byte ptr [rsi+1], 78h ; 'x'
add rsi, 2
mov rdi, rcx
mov edx, 10h
loc_91EB7:
xor ecx, ecx
jmp short loc_91ED1
loc_91EBB:
xor eax, eax
cmp r8b, 58h ; 'X'
setz al
mov rdi, rcx
mov rsi, r15
mov edx, 10h
mov ecx, eax
loc_91ED1:
call int2str
loc_91ED6:
mov r14, rax
sub r14, r15
cmp r14, r13
ja short loc_91F52
cmp r15, r12
jnz short loc_91F4F
mov r12, [rbp+var_68]
cmp r13, r12
cmovb r12, r13
sub r12, r14
jbe short loc_91F41
mov rax, [rbp+var_60]
and eax, 4
setz r13b
lea esi, ds:20h[rax*4]
mov rdi, rbx
mov rdx, r12
call _memset
cmp byte ptr [rbp+var_58], 70h ; 'p'
setnz al
or al, r13b
jnz short loc_91F3E
lea rax, [rbx+1]
cmp r12, 2
cmovb rax, r15
mov byte ptr [rax], 78h ; 'x'
cmp [rbp+var_51], 0
lea rax, [rbp+var_50]
cmovz rax, rbx
mov byte ptr [rax+1], 30h ; '0'
loc_91F3E:
add rbx, r12
loc_91F41:
mov rdi, rbx
mov rsi, r15
mov rdx, r14
call _memmove
loc_91F4F:
add rbx, r14
loc_91F52:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_91F73
mov rax, rbx
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_91F73:
call ___stack_chk_fail
| _BYTE * process_int_arg(_BYTE *a1, long long a2, unsigned long long a3, unsigned long long a4, int a5, char a6)
{
_BYTE *v6; // rbx
unsigned long long v7; // r13
bool v8; // dl
_BYTE *v9; // r15
unsigned long long v10; // rdi
_BYTE *v11; // rsi
int v12; // edx
_BYTE *v13; // rax
unsigned long long v14; // rdi
_BYTE *v15; // rsi
unsigned int v16; // edx
_BYTE *v17; // rsi
BOOL v18; // ecx
unsigned long long v19; // r14
unsigned long long v20; // r12
bool v21; // cc
unsigned long long v22; // r12
_BYTE *v23; // rax
_BYTE *v24; // rax
char v28; // [rsp+18h] [rbp-58h]
bool v29; // [rsp+1Fh] [rbp-51h]
_BYTE v30[32]; // [rsp+20h] [rbp-50h] BYREF
unsigned long long v31; // [rsp+40h] [rbp-30h]
v6 = a1;
v31 = __readfsqword(0x28u);
v7 = a2 - (_QWORD)a1;
v8 = (unsigned long long)(a2 - (_QWORD)a1) < 0x10 || a3 != 0;
v9 = a1;
if ( v8 )
v9 = v30;
v28 = a5;
v29 = v8;
if ( a5 <= 110 )
{
if ( a5 == 100 || a5 == 105 )
{
v10 = a4;
v11 = v9;
v12 = -10;
goto LABEL_11;
}
goto LABEL_17;
}
switch ( a5 )
{
case 'o':
v14 = a4;
v15 = v9;
v16 = 8;
break;
case 'p':
*v9 = 48;
v17 = a1;
if ( v8 )
v17 = v30;
v17[1] = 120;
v15 = v17 + 2;
v14 = a4;
v16 = 16;
break;
case 'u':
v10 = a4;
v11 = v9;
v12 = 10;
LABEL_11:
v13 = int10_to_str(v10, v11, v12);
goto LABEL_19;
default:
LABEL_17:
v14 = a4;
v15 = v9;
v16 = 16;
v18 = (_BYTE)a5 == 88;
goto LABEL_18;
}
v18 = 0;
LABEL_18:
v13 = int2str(v14, v15, v16, v18);
LABEL_19:
v19 = v13 - v9;
if ( v13 - v9 <= v7 )
{
if ( v9 == v30 )
{
v20 = a3;
if ( v7 < a3 )
v20 = v7;
v21 = v20 <= v19;
v22 = v20 - v19;
if ( !v21 )
{
memset(v6, 4 * (a6 & 4u) + 32, v22);
if ( (a6 & 4) != 0 && v28 == 112 )
{
v23 = v6 + 1;
if ( v22 < 2 )
v23 = v9;
*v23 = 120;
v24 = v30;
if ( !v29 )
v24 = v6;
v24[1] = 48;
}
v6 += v22;
}
memmove(v6, v9, v19);
}
v6 += v19;
}
return v6;
}
| process_int_arg:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R13,RSI
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
SUB R13,RDI
CMP R13,0x10
SETC AL
MOV qword ptr [RBP + -0x68],RDX
TEST RDX,RDX
SETNZ DL
OR DL,AL
LEA RAX,[RBP + -0x50]
MOV R15,RDI
CMOVNZ R15,RAX
CMP R8D,0x6e
MOV dword ptr [RBP + -0x58],R8D
MOV byte ptr [RBP + -0x51],DL
MOV qword ptr [RBP + -0x60],R9
JLE 0x00191e66
CMP R8D,0x6f
JZ 0x00191e87
CMP R8D,0x70
JZ 0x00191e97
MOV R12,RAX
CMP R8D,0x75
JNZ 0x00191ebb
MOV RDI,RCX
MOV RSI,R15
MOV EDX,0xa
JMP 0x00191e80
LAB_00191e66:
MOV R12,RAX
CMP R8D,0x64
JZ 0x00191e75
CMP R8D,0x69
JNZ 0x00191ebb
LAB_00191e75:
MOV RDI,RCX
MOV RSI,R15
MOV EDX,0xfffffff6
LAB_00191e80:
CALL 0x00190a52
JMP 0x00191ed6
LAB_00191e87:
MOV R12,RAX
MOV RDI,RCX
MOV RSI,R15
MOV EDX,0x8
JMP 0x00191eb7
LAB_00191e97:
MOV byte ptr [R15],0x30
TEST DL,DL
MOV RSI,RBX
MOV R12,RAX
CMOVNZ RSI,RAX
MOV byte ptr [RSI + 0x1],0x78
ADD RSI,0x2
MOV RDI,RCX
MOV EDX,0x10
LAB_00191eb7:
XOR ECX,ECX
JMP 0x00191ed1
LAB_00191ebb:
XOR EAX,EAX
CMP R8B,0x58
SETZ AL
MOV RDI,RCX
MOV RSI,R15
MOV EDX,0x10
MOV ECX,EAX
LAB_00191ed1:
CALL 0x0019097c
LAB_00191ed6:
MOV R14,RAX
SUB R14,R15
CMP R14,R13
JA 0x00191f52
CMP R15,R12
JNZ 0x00191f4f
MOV R12,qword ptr [RBP + -0x68]
CMP R13,R12
CMOVC R12,R13
SUB R12,R14
JBE 0x00191f41
MOV RAX,qword ptr [RBP + -0x60]
AND EAX,0x4
SETZ R13B
LEA ESI,[0x20 + RAX*0x4]
MOV RDI,RBX
MOV RDX,R12
CALL 0x001281d0
CMP byte ptr [RBP + -0x58],0x70
SETNZ AL
OR AL,R13B
JNZ 0x00191f3e
LEA RAX,[RBX + 0x1]
CMP R12,0x2
CMOVC RAX,R15
MOV byte ptr [RAX],0x78
CMP byte ptr [RBP + -0x51],0x0
LEA RAX,[RBP + -0x50]
CMOVZ RAX,RBX
MOV byte ptr [RAX + 0x1],0x30
LAB_00191f3e:
ADD RBX,R12
LAB_00191f41:
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
CALL 0x00128660
LAB_00191f4f:
ADD RBX,R14
LAB_00191f52:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00191f73
MOV RAX,RBX
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00191f73:
CALL 0x00128400
|
int1 *
process_int_arg(int1 *param_1,long param_2,ulong param_3,int8 param_4,int param_5,
uint param_6)
{
long lVar1;
int1 *puVar2;
int8 uVar3;
ulong uVar4;
ulong __n;
int1 *__src;
long in_FS_OFFSET;
bool bVar5;
bool bVar6;
bool bVar7;
int1 local_58 [32];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
uVar4 = param_2 - (long)param_1;
bVar5 = uVar4 < 0x10;
bVar6 = param_3 != 0;
__src = param_1;
if (bVar6 || bVar5) {
__src = local_58;
}
puVar2 = __src;
if (param_5 < 0x6f) {
if ((param_5 == 100) || (param_5 == 0x69)) {
uVar3 = 0xfffffff6;
LAB_00191e80:
lVar1 = int10_to_str(param_4,__src,uVar3);
goto LAB_00191ed6;
}
LAB_00191ebb:
bVar7 = (char)param_5 == 'X';
uVar3 = 0x10;
}
else {
if (param_5 == 0x6f) {
uVar3 = 8;
}
else {
if (param_5 != 0x70) {
if (param_5 != 0x75) goto LAB_00191ebb;
uVar3 = 10;
goto LAB_00191e80;
}
*__src = 0x30;
puVar2 = param_1;
if (bVar6 || bVar5) {
puVar2 = local_58;
}
puVar2[1] = 0x78;
uVar3 = 0x10;
puVar2 = puVar2 + 2;
}
bVar7 = false;
}
lVar1 = int2str(param_4,puVar2,uVar3,bVar7);
LAB_00191ed6:
__n = lVar1 - (long)__src;
if (__n <= uVar4) {
if (__src == local_58) {
if (uVar4 < param_3) {
param_3 = uVar4;
}
uVar4 = param_3 - __n;
if (__n <= param_3 && uVar4 != 0) {
memset(param_1,(param_6 & 4) * 4 + 0x20,uVar4);
if ((char)param_5 == 'p' && (param_6 & 4) != 0) {
puVar2 = param_1 + 1;
if (uVar4 < 2) {
puVar2 = __src;
}
*puVar2 = 0x78;
puVar2 = local_58;
if (!bVar6 && !bVar5) {
puVar2 = param_1;
}
puVar2[1] = 0x30;
}
param_1 = param_1 + uVar4;
}
memmove(param_1,__src,__n);
}
param_1 = param_1 + __n;
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
44,722 | bitmap_subtract | eloqsql/mysys/my_bitmap.c | void bitmap_subtract(MY_BITMAP *map, const MY_BITMAP *map2)
{
my_bitmap_map *to= map->bitmap, *from= map2->bitmap, *end;
DBUG_ASSERT(map->bitmap);
DBUG_ASSERT(map2->bitmap);
DBUG_ASSERT(map->n_bits==map2->n_bits);
end= map->last_word_ptr;
while (to <= end)
*to++ &= ~(*from++);
} | O3 | c | bitmap_subtract:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
cmpq %rcx, %rax
ja 0xa061e
pushq %rbp
movq %rsp, %rbp
movq (%rsi), %rdx
movl (%rdx), %esi
notl %esi
andl %esi, (%rax)
addq $0x4, %rdx
addq $0x4, %rax
cmpq %rcx, %rax
jbe 0xa060a
popq %rbp
retq
| bitmap_subtract:
mov rax, [rdi]
mov rcx, [rdi+8]
cmp rax, rcx
ja short locret_A061E
push rbp
mov rbp, rsp
mov rdx, [rsi]
loc_A060A:
mov esi, [rdx]
not esi
and [rax], esi
add rdx, 4
add rax, 4
cmp rax, rcx
jbe short loc_A060A
pop rbp
locret_A061E:
retn
| _DWORD * bitmap_subtract(long long a1, _DWORD **a2)
{
_DWORD *result; // rax
unsigned long long v3; // rcx
_DWORD *v4; // rdx
result = *(_DWORD **)a1;
v3 = *(_QWORD *)(a1 + 8);
if ( *(_QWORD *)a1 <= v3 )
{
v4 = *a2;
do
*result++ &= ~*v4++;
while ( (unsigned long long)result <= v3 );
}
return result;
}
| bitmap_subtract:
MOV RAX,qword ptr [RDI]
MOV RCX,qword ptr [RDI + 0x8]
CMP RAX,RCX
JA 0x001a061e
PUSH RBP
MOV RBP,RSP
MOV RDX,qword ptr [RSI]
LAB_001a060a:
MOV ESI,dword ptr [RDX]
NOT ESI
AND dword ptr [RAX],ESI
ADD RDX,0x4
ADD RAX,0x4
CMP RAX,RCX
JBE 0x001a060a
POP RBP
LAB_001a061e:
RET
|
void bitmap_subtract(int8 *param_1,int8 *param_2)
{
uint *puVar1;
uint *puVar2;
uint *puVar3;
puVar2 = (uint *)*param_1;
puVar1 = (uint *)param_1[1];
if (puVar2 <= puVar1) {
puVar3 = (uint *)*param_2;
do {
*puVar2 = *puVar2 & ~*puVar3;
puVar3 = puVar3 + 1;
puVar2 = puVar2 + 1;
} while (puVar2 <= puVar1);
}
return;
}
| |
44,723 | Brightness::monitorLoop() | mihussein[P]Hlemon/src/brightness.cpp | void Brightness::monitorLoop() {
while (true) {
int timeout_ms = 500; // Reduced timeout
int ret = poll(fds, 1, timeout_ms);
if (ret > 0 && (fds[0].revents & POLLIN)) {
struct udev_device *dev = udev_monitor_receive_device(mon);
if (dev) {
updateLemonbar(lemonOutput());
udev_device_unref(dev);
}
}
}
stopMonitoring();
} | O0 | cpp | Brightness::monitorLoop():
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movl $0x1f4, -0xc(%rbp) # imm = 0x1F4
addq $0x10, %rdi
movl -0xc(%rbp), %edx
movl $0x1, %esi
callq 0x56c0
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jle 0xbc26
movq -0x50(%rbp), %rax
movswl 0x16(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xbc26
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5140
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xbc24
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xb230
movq -0x58(%rbp), %rdi
callq 0xb1d0
jmp 0xbbf9
leaq -0x38(%rbp), %rdi
callq 0x58a8
movq -0x18(%rbp), %rdi
callq 0x5820
jmp 0xbc24
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x58a8
jmp 0xbc2b
jmp 0xbc26
jmp 0xbb94
movq -0x40(%rbp), %rdi
callq 0x57e0
nopw %cs:(%rax,%rax)
| _ZN10Brightness11monitorLoopEv:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_50], rax
loc_BB94:
mov rdi, [rbp+var_50]
mov [rbp+var_C], 1F4h
add rdi, 10h
mov edx, [rbp+var_C]
mov esi, 1
call _poll
mov [rbp+var_10], eax
cmp [rbp+var_10], 0
jle short loc_BC26
mov rax, [rbp+var_50]
movsx eax, word ptr [rax+16h]
and eax, 1
cmp eax, 0
jz short loc_BC26
mov rax, [rbp+var_50]
mov rdi, [rax+8]
call _udev_monitor_receive_device
mov [rbp+var_18], rax
cmp [rbp+var_18], 0
jz short loc_BC24
lea rdi, [rbp+var_38]
mov [rbp+var_58], rdi
call _Z11lemonOutputB5cxx11v; lemonOutput(void)
mov rdi, [rbp+var_58]
call _Z14updateLemonbarRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; updateLemonbar(std::string const&)
jmp short $+2
loc_BBF9:
lea rdi, [rbp+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov rdi, [rbp+var_18]
call _udev_device_unref
jmp short loc_BC24
mov rcx, rax
mov eax, edx
mov [rbp+var_40], rcx
mov [rbp+var_44], eax
lea rdi, [rbp+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_BC2B
loc_BC24:
jmp short $+2
loc_BC26:
jmp loc_BB94
loc_BC2B:
mov rdi, [rbp+var_40]
call __Unwind_Resume
| void __noreturn Brightness::monitorLoop(Brightness *this)
{
_BYTE v1[32]; // [rsp+28h] [rbp-38h] BYREF
long long v2; // [rsp+48h] [rbp-18h]
int v3; // [rsp+50h] [rbp-10h]
int v4; // [rsp+54h] [rbp-Ch]
Brightness *v5; // [rsp+58h] [rbp-8h]
v5 = this;
while ( 1 )
{
do
{
v4 = 500;
v3 = poll((char *)this + 16, 1LL, 500LL);
}
while ( v3 <= 0 );
if ( (*((_WORD *)this + 11) & 1) != 0 )
{
v2 = udev_monitor_receive_device(*((_QWORD *)this + 1));
if ( v2 )
{
lemonOutput[abi:cxx11]((long long)v1);
updateLemonbar((long long)v1);
std::string::~string(v1);
udev_device_unref(v2);
}
}
}
}
| monitorLoop:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x50],RAX
LAB_0010bb94:
MOV RDI,qword ptr [RBP + -0x50]
MOV dword ptr [RBP + -0xc],0x1f4
ADD RDI,0x10
MOV EDX,dword ptr [RBP + -0xc]
MOV ESI,0x1
CALL 0x001056c0
MOV dword ptr [RBP + -0x10],EAX
CMP dword ptr [RBP + -0x10],0x0
JLE 0x0010bc26
MOV RAX,qword ptr [RBP + -0x50]
MOVSX EAX,word ptr [RAX + 0x16]
AND EAX,0x1
CMP EAX,0x0
JZ 0x0010bc26
MOV RAX,qword ptr [RBP + -0x50]
MOV RDI,qword ptr [RAX + 0x8]
CALL 0x00105140
MOV qword ptr [RBP + -0x18],RAX
CMP qword ptr [RBP + -0x18],0x0
JZ 0x0010bc24
LEA RDI,[RBP + -0x38]
MOV qword ptr [RBP + -0x58],RDI
CALL 0x0010b230
MOV RDI,qword ptr [RBP + -0x58]
LAB_0010bbf2:
CALL 0x0010b1d0
LAB_0010bbf7:
JMP 0x0010bbf9
LAB_0010bbf9:
LEA RDI,[RBP + -0x38]
CALL 0x001058a8
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00105820
JMP 0x0010bc24
LAB_0010bc24:
JMP 0x0010bc26
LAB_0010bc26:
JMP 0x0010bb94
|
/* Brightness::monitorLoop() */
void __thiscall Brightness::monitorLoop(Brightness *this)
{
string local_40 [32];
long local_20;
int local_18;
int4 local_14;
Brightness *local_10;
local_10 = this;
do {
do {
local_14 = 500;
local_18 = poll((pollfd *)(this + 0x10),1,500);
} while (local_18 < 1);
if (((*(ushort *)(this + 0x16) & 1) != 0) &&
(local_20 = udev_monitor_receive_device(*(int8 *)(this + 8)), local_20 != 0)) {
lemonOutput_abi_cxx11_();
/* try { // try from 0010bbf2 to 0010bbf6 has its CatchHandler @ 0010bc0d */
updateLemonbar(local_40);
std::__cxx11::string::~string(local_40);
udev_device_unref(local_20);
}
} while( true );
}
| |
44,724 | Brightness::monitorLoop() | mihussein[P]Hlemon/src/brightness.cpp | void Brightness::monitorLoop() {
while (true) {
int timeout_ms = 500; // Reduced timeout
int ret = poll(fds, 1, timeout_ms);
if (ret > 0 && (fds[0].revents & POLLIN)) {
struct udev_device *dev = udev_monitor_receive_device(mon);
if (dev) {
updateLemonbar(lemonOutput());
udev_device_unref(dev);
}
}
}
stopMonitoring();
} | O3 | cpp | Brightness::monitorLoop():
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
leaq 0x10(%rsp), %r13
movq %rsp, %r15
movl $0x1, %esi
movq %r14, %rdi
movl $0x1f4, %edx # imm = 0x1F4
callq 0x4540
testl %eax, %eax
jle 0x74da
testb $0x1, 0x16(%rbx)
je 0x74da
movq 0x8(%rbx), %rdi
callq 0x4130
testq %rax, %rax
je 0x74da
movq %rax, %r12
movq %r15, %rdi
callq 0x6506
movq %r15, %rdi
callq 0x64d7
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x752d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4380
movq %r12, %rdi
callq 0x4690
jmp 0x74da
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x7550
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4380
movq %rbx, %rdi
callq 0x4660
| _ZN10Brightness11monitorLoopEv:
push r15; void *
push r14; int
push r13; __int64
push r12; int
push rbx; void *
sub rsp, 20h
mov rbx, rdi
lea r14, [rdi+10h]
lea r13, [rsp+48h+var_38]
mov r15, rsp
loc_74DA:
mov esi, 1
mov rdi, r14
mov edx, 1F4h
call _poll
test eax, eax
jle short loc_74DA
test byte ptr [rbx+16h], 1
jz short loc_74DA
mov rdi, [rbx+8]
call _udev_monitor_receive_device
test rax, rax
jz short loc_74DA
mov r12, rax
mov rdi, r15; int
call _Z11lemonOutputB5cxx11v; lemonOutput(void)
mov rdi, r15
call _Z14updateLemonbarRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; updateLemonbar(std::string const&)
mov rdi, [rsp+48h+var_48]; void *
cmp rdi, r13
jz short loc_752D
mov rsi, [rsp+48h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_752D:
mov rdi, r12
call _udev_device_unref
jmp short loc_74DA
mov rbx, rax
mov rdi, [rsp+0]; void *
cmp rdi, r13
jz short loc_7550
mov rsi, [rsp+arg_8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7550:
mov rdi, rbx
call __Unwind_Resume
| void __noreturn Brightness::monitorLoop(Brightness *this)
{
long long v1; // rax
long long v2; // r12
void *v3[2]; // [rsp+0h] [rbp-48h] BYREF
long long v4; // [rsp+10h] [rbp-38h] BYREF
while ( 1 )
{
while ( 1 )
{
while ( (int)poll((char *)this + 16, 1LL, 500LL) <= 0 )
;
if ( (*((_BYTE *)this + 22) & 1) != 0 )
{
v1 = udev_monitor_receive_device(*((_QWORD *)this + 1));
if ( v1 )
break;
}
}
v2 = v1;
lemonOutput[abi:cxx11]((long long)v3);
updateLemonbar((const char **)v3);
if ( v3[0] != &v4 )
operator delete(v3[0], v4 + 1);
udev_device_unref(v2);
}
}
| monitorLoop:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x20
MOV RBX,RDI
LEA R14,[RDI + 0x10]
LEA R13,[RSP + 0x10]
MOV R15,RSP
LAB_001074da:
MOV ESI,0x1
MOV RDI,R14
MOV EDX,0x1f4
CALL 0x00104540
TEST EAX,EAX
JLE 0x001074da
TEST byte ptr [RBX + 0x16],0x1
JZ 0x001074da
MOV RDI,qword ptr [RBX + 0x8]
CALL 0x00104130
TEST RAX,RAX
JZ 0x001074da
MOV R12,RAX
MOV RDI,R15
CALL 0x00106506
LAB_0010750f:
MOV RDI,R15
CALL 0x001064d7
LAB_00107517:
MOV RDI,qword ptr [RSP]
CMP RDI,R13
JZ 0x0010752d
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x00104380
LAB_0010752d:
MOV RDI,R12
CALL 0x00104690
JMP 0x001074da
|
/* Brightness::monitorLoop() */
void __thiscall Brightness::monitorLoop(Brightness *this)
{
int iVar1;
long lVar2;
long *local_48 [2];
long local_38 [2];
do {
do {
do {
iVar1 = poll((pollfd *)(this + 0x10),1,500);
} while (iVar1 < 1);
} while (((byte)this[0x16] & 1) == 0);
lVar2 = udev_monitor_receive_device(*(int8 *)(this + 8));
if (lVar2 != 0) {
lemonOutput_abi_cxx11_();
/* try { // try from 0010750f to 00107516 has its CatchHandler @ 00107537 */
updateLemonbar((string *)local_48);
if (local_48[0] != local_38) {
operator_delete(local_48[0],local_38[0] + 1);
}
udev_device_unref(lVar2);
}
} while( true );
}
| |
44,725 | nlohmann::json_abi_v3_11_3::detail::dtoa_impl::find_largest_pow10(unsigned int, unsigned int&) | hkr04[P]cpp-mcp/common/json.hpp | inline int find_largest_pow10(const std::uint32_t n, std::uint32_t& pow10)
{
// LCOV_EXCL_START
if (n >= 1000000000)
{
pow10 = 1000000000;
return 10;
}
// LCOV_EXCL_STOP
if (n >= 100000000)
{
pow10 = 100000000;
return 9;
}
if (n >= 10000000)
{
pow10 = 10000000;
return 8;
}
if (n >= 1000000)
{
pow10 = 1000000;
return 7;
}
if (n >= 100000)
{
pow10 = 100000;
return 6;
}
if (n >= 10000)
{
pow10 = 10000;
return 5;
}
if (n >= 1000)
{
pow10 = 1000;
return 4;
}
if (n >= 100)
{
pow10 = 100;
return 3;
}
if (n >= 10)
{
pow10 = 10;
return 2;
}
pow10 = 1;
return 1;
} | O0 | cpp | nlohmann::json_abi_v3_11_3::detail::dtoa_impl::find_largest_pow10(unsigned int, unsigned int&):
movl %edi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
cmpl $0x3b9aca00, -0x8(%rsp) # imm = 0x3B9ACA00
jb 0x1b47b
movq -0x10(%rsp), %rax
movl $0x3b9aca00, (%rax) # imm = 0x3B9ACA00
movl $0xa, -0x4(%rsp)
jmp 0x1b58c
cmpl $0x5f5e100, -0x8(%rsp) # imm = 0x5F5E100
jb 0x1b49d
movq -0x10(%rsp), %rax
movl $0x5f5e100, (%rax) # imm = 0x5F5E100
movl $0x9, -0x4(%rsp)
jmp 0x1b58c
cmpl $0x989680, -0x8(%rsp) # imm = 0x989680
jb 0x1b4bf
movq -0x10(%rsp), %rax
movl $0x989680, (%rax) # imm = 0x989680
movl $0x8, -0x4(%rsp)
jmp 0x1b58c
cmpl $0xf4240, -0x8(%rsp) # imm = 0xF4240
jb 0x1b4e1
movq -0x10(%rsp), %rax
movl $0xf4240, (%rax) # imm = 0xF4240
movl $0x7, -0x4(%rsp)
jmp 0x1b58c
cmpl $0x186a0, -0x8(%rsp) # imm = 0x186A0
jb 0x1b503
movq -0x10(%rsp), %rax
movl $0x186a0, (%rax) # imm = 0x186A0
movl $0x6, -0x4(%rsp)
jmp 0x1b58c
cmpl $0x2710, -0x8(%rsp) # imm = 0x2710
jb 0x1b522
movq -0x10(%rsp), %rax
movl $0x2710, (%rax) # imm = 0x2710
movl $0x5, -0x4(%rsp)
jmp 0x1b58c
cmpl $0x3e8, -0x8(%rsp) # imm = 0x3E8
jb 0x1b541
movq -0x10(%rsp), %rax
movl $0x3e8, (%rax) # imm = 0x3E8
movl $0x4, -0x4(%rsp)
jmp 0x1b58c
cmpl $0x64, -0x8(%rsp)
jb 0x1b55d
movq -0x10(%rsp), %rax
movl $0x64, (%rax)
movl $0x3, -0x4(%rsp)
jmp 0x1b58c
cmpl $0xa, -0x8(%rsp)
jb 0x1b579
movq -0x10(%rsp), %rax
movl $0xa, (%rax)
movl $0x2, -0x4(%rsp)
jmp 0x1b58c
movq -0x10(%rsp), %rax
movl $0x1, (%rax)
movl $0x1, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl18find_largest_pow10EjRj:
mov [rsp+var_8], edi
mov [rsp+var_10], rsi
cmp [rsp+var_8], 3B9ACA00h
jb short loc_1B47B
mov rax, [rsp+var_10]
mov dword ptr [rax], 3B9ACA00h
mov [rsp+var_4], 0Ah
jmp loc_1B58C
loc_1B47B:
cmp [rsp+var_8], 5F5E100h
jb short loc_1B49D
mov rax, [rsp+var_10]
mov dword ptr [rax], 5F5E100h
mov [rsp+var_4], 9
jmp loc_1B58C
loc_1B49D:
cmp [rsp+var_8], 989680h
jb short loc_1B4BF
mov rax, [rsp+var_10]
mov dword ptr [rax], 989680h
mov [rsp+var_4], 8
jmp loc_1B58C
loc_1B4BF:
cmp [rsp+var_8], 0F4240h
jb short loc_1B4E1
mov rax, [rsp+var_10]
mov dword ptr [rax], 0F4240h
mov [rsp+var_4], 7
jmp loc_1B58C
loc_1B4E1:
cmp [rsp+var_8], 186A0h
jb short loc_1B503
mov rax, [rsp+var_10]
mov dword ptr [rax], 186A0h
mov [rsp+var_4], 6
jmp loc_1B58C
loc_1B503:
cmp [rsp+var_8], 2710h
jb short loc_1B522
mov rax, [rsp+var_10]
mov dword ptr [rax], 2710h
mov [rsp+var_4], 5
jmp short loc_1B58C
loc_1B522:
cmp [rsp+var_8], 3E8h
jb short loc_1B541
mov rax, [rsp+var_10]
mov dword ptr [rax], 3E8h
mov [rsp+var_4], 4
jmp short loc_1B58C
loc_1B541:
cmp [rsp+var_8], 64h ; 'd'
jb short loc_1B55D
mov rax, [rsp+var_10]
mov dword ptr [rax], 64h ; 'd'
mov [rsp+var_4], 3
jmp short loc_1B58C
loc_1B55D:
cmp [rsp+var_8], 0Ah
jb short loc_1B579
mov rax, [rsp+var_10]
mov dword ptr [rax], 0Ah
mov [rsp+var_4], 2
jmp short loc_1B58C
loc_1B579:
mov rax, [rsp+var_10]
mov dword ptr [rax], 1
mov [rsp+var_4], 1
loc_1B58C:
mov eax, [rsp+var_4]
retn
| long long nlohmann::json_abi_v3_11_3::detail::dtoa_impl::find_largest_pow10(
nlohmann::json_abi_v3_11_3::detail::dtoa_impl *this,
_DWORD *a2,
unsigned int *a3)
{
if ( (unsigned int)this < 0x3B9ACA00 )
{
if ( (unsigned int)this < 0x5F5E100 )
{
if ( (unsigned int)this < 0x989680 )
{
if ( (unsigned int)this < 0xF4240 )
{
if ( (unsigned int)this < 0x186A0 )
{
if ( (unsigned int)this < 0x2710 )
{
if ( (unsigned int)this < 0x3E8 )
{
if ( (unsigned int)this < 0x64 )
{
if ( (unsigned int)this < 0xA )
{
*a2 = 1;
return 1;
}
else
{
*a2 = 10;
return 2;
}
}
else
{
*a2 = 100;
return 3;
}
}
else
{
*a2 = 1000;
return 4;
}
}
else
{
*a2 = 10000;
return 5;
}
}
else
{
*a2 = 100000;
return 6;
}
}
else
{
*a2 = 1000000;
return 7;
}
}
else
{
*a2 = 10000000;
return 8;
}
}
else
{
*a2 = 100000000;
return 9;
}
}
else
{
*a2 = 1000000000;
return 10;
}
}
| find_largest_pow10:
MOV dword ptr [RSP + -0x8],EDI
MOV qword ptr [RSP + -0x10],RSI
CMP dword ptr [RSP + -0x8],0x3b9aca00
JC 0x0011b47b
MOV RAX,qword ptr [RSP + -0x10]
MOV dword ptr [RAX],0x3b9aca00
MOV dword ptr [RSP + -0x4],0xa
JMP 0x0011b58c
LAB_0011b47b:
CMP dword ptr [RSP + -0x8],0x5f5e100
JC 0x0011b49d
MOV RAX,qword ptr [RSP + -0x10]
MOV dword ptr [RAX],0x5f5e100
MOV dword ptr [RSP + -0x4],0x9
JMP 0x0011b58c
LAB_0011b49d:
CMP dword ptr [RSP + -0x8],0x989680
JC 0x0011b4bf
MOV RAX,qword ptr [RSP + -0x10]
MOV dword ptr [RAX],0x989680
MOV dword ptr [RSP + -0x4],0x8
JMP 0x0011b58c
LAB_0011b4bf:
CMP dword ptr [RSP + -0x8],0xf4240
JC 0x0011b4e1
MOV RAX,qword ptr [RSP + -0x10]
MOV dword ptr [RAX],0xf4240
MOV dword ptr [RSP + -0x4],0x7
JMP 0x0011b58c
LAB_0011b4e1:
CMP dword ptr [RSP + -0x8],0x186a0
JC 0x0011b503
MOV RAX,qword ptr [RSP + -0x10]
MOV dword ptr [RAX],0x186a0
MOV dword ptr [RSP + -0x4],0x6
JMP 0x0011b58c
LAB_0011b503:
CMP dword ptr [RSP + -0x8],0x2710
JC 0x0011b522
MOV RAX,qword ptr [RSP + -0x10]
MOV dword ptr [RAX],0x2710
MOV dword ptr [RSP + -0x4],0x5
JMP 0x0011b58c
LAB_0011b522:
CMP dword ptr [RSP + -0x8],0x3e8
JC 0x0011b541
MOV RAX,qword ptr [RSP + -0x10]
MOV dword ptr [RAX],0x3e8
MOV dword ptr [RSP + -0x4],0x4
JMP 0x0011b58c
LAB_0011b541:
CMP dword ptr [RSP + -0x8],0x64
JC 0x0011b55d
MOV RAX,qword ptr [RSP + -0x10]
MOV dword ptr [RAX],0x64
MOV dword ptr [RSP + -0x4],0x3
JMP 0x0011b58c
LAB_0011b55d:
CMP dword ptr [RSP + -0x8],0xa
JC 0x0011b579
MOV RAX,qword ptr [RSP + -0x10]
MOV dword ptr [RAX],0xa
MOV dword ptr [RSP + -0x4],0x2
JMP 0x0011b58c
LAB_0011b579:
MOV RAX,qword ptr [RSP + -0x10]
MOV dword ptr [RAX],0x1
MOV dword ptr [RSP + -0x4],0x1
LAB_0011b58c:
MOV EAX,dword ptr [RSP + -0x4]
RET
|
/* nlohmann::json_abi_v3_11_3::detail::dtoa_impl::find_largest_pow10(unsigned int, unsigned int&) */
int4
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::find_largest_pow10(uint param_1,uint *param_2)
{
int4 local_4;
if (param_1 < 1000000000) {
if (param_1 < 100000000) {
if (param_1 < 10000000) {
if (param_1 < 1000000) {
if (param_1 < 100000) {
if (param_1 < 10000) {
if (param_1 < 1000) {
if (param_1 < 100) {
if (param_1 < 10) {
*param_2 = 1;
local_4 = 1;
}
else {
*param_2 = 10;
local_4 = 2;
}
}
else {
*param_2 = 100;
local_4 = 3;
}
}
else {
*param_2 = 1000;
local_4 = 4;
}
}
else {
*param_2 = 10000;
local_4 = 5;
}
}
else {
*param_2 = 100000;
local_4 = 6;
}
}
else {
*param_2 = 1000000;
local_4 = 7;
}
}
else {
*param_2 = 10000000;
local_4 = 8;
}
}
else {
*param_2 = 100000000;
local_4 = 9;
}
}
else {
*param_2 = 1000000000;
local_4 = 10;
}
return local_4;
}
| |
44,726 | OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<double>::Clear() | NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/stencilTable.cpp | void
LimitStencilTableReal<REAL>::Clear() {
StencilTableReal<REAL>::Clear();
_duWeights.clear();
_dvWeights.clear();
_duuWeights.clear();
_duvWeights.clear();
_dvvWeights.clear();
} | O0 | cpp | OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<double>::Clear():
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0xccc90
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
callq 0xce3f0
movq -0x10(%rbp), %rdi
addq $0x88, %rdi
callq 0xce3f0
movq -0x10(%rbp), %rdi
addq $0xa0, %rdi
callq 0xce3f0
movq -0x10(%rbp), %rdi
addq $0xb8, %rdi
callq 0xce3f0
movq -0x10(%rbp), %rdi
addq $0xd0, %rdi
callq 0xce3f0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| _ZN10OpenSubdiv6v3_6_03Far21LimitStencilTableRealIdE5ClearEv:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]
mov [rbp+var_10], rdi
call __ZN10OpenSubdiv6v3_6_03Far16StencilTableRealIdE5ClearEv; OpenSubdiv::v3_6_0::Far::StencilTableReal<double>::Clear(void)
mov rdi, [rbp+var_10]
add rdi, 70h ; 'p'
call __ZNSt6vectorIdSaIdEE5clearEv; std::vector<double>::clear(void)
mov rdi, [rbp+var_10]
add rdi, 88h
call __ZNSt6vectorIdSaIdEE5clearEv; std::vector<double>::clear(void)
mov rdi, [rbp+var_10]
add rdi, 0A0h
call __ZNSt6vectorIdSaIdEE5clearEv; std::vector<double>::clear(void)
mov rdi, [rbp+var_10]
add rdi, 0B8h
call __ZNSt6vectorIdSaIdEE5clearEv; std::vector<double>::clear(void)
mov rdi, [rbp+var_10]
add rdi, 0D0h
call __ZNSt6vectorIdSaIdEE5clearEv; std::vector<double>::clear(void)
add rsp, 10h
pop rbp
retn
| long long OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<double>::Clear(long long a1)
{
OpenSubdiv::v3_6_0::Far::StencilTableReal<double>::Clear(a1);
std::vector<double>::clear(a1 + 112);
std::vector<double>::clear(a1 + 136);
std::vector<double>::clear(a1 + 160);
std::vector<double>::clear(a1 + 184);
return std::vector<double>::clear(a1 + 208);
}
| |||
44,727 | OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<double>::Clear() | NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/stencilTable.cpp | void
LimitStencilTableReal<REAL>::Clear() {
StencilTableReal<REAL>::Clear();
_duWeights.clear();
_dvWeights.clear();
_duuWeights.clear();
_duvWeights.clear();
_dvvWeights.clear();
} | O1 | cpp | OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<double>::Clear():
pushq %rbx
movq %rdi, %rbx
callq 0x3b370
movq 0x70(%rbx), %rax
cmpq %rax, 0x78(%rbx)
je 0x723cb
movq %rax, 0x78(%rbx)
movq 0x88(%rbx), %rax
cmpq %rax, 0x90(%rbx)
je 0x723e2
movq %rax, 0x90(%rbx)
movq 0xa0(%rbx), %rax
cmpq %rax, 0xa8(%rbx)
je 0x723f9
movq %rax, 0xa8(%rbx)
movq 0xb8(%rbx), %rax
cmpq %rax, 0xc0(%rbx)
je 0x72410
movq %rax, 0xc0(%rbx)
movq 0xd0(%rbx), %rax
cmpq %rax, 0xd8(%rbx)
je 0x72427
movq %rax, 0xd8(%rbx)
popq %rbx
retq
nop
| _ZN10OpenSubdiv6v3_6_03Far21LimitStencilTableRealIfE5ClearEv:
push rbx
mov rbx, rdi
call __ZN10OpenSubdiv6v3_6_03Far16StencilTableRealIfE5ClearEv; OpenSubdiv::v3_6_0::Far::StencilTableReal<float>::Clear(void)
mov rax, [rbx+70h]
cmp [rbx+78h], rax
jz short loc_723CB
mov [rbx+78h], rax
loc_723CB:
mov rax, [rbx+88h]
cmp [rbx+90h], rax
jz short loc_723E2
mov [rbx+90h], rax
loc_723E2:
mov rax, [rbx+0A0h]
cmp [rbx+0A8h], rax
jz short loc_723F9
mov [rbx+0A8h], rax
loc_723F9:
mov rax, [rbx+0B8h]
cmp [rbx+0C0h], rax
jz short loc_72410
mov [rbx+0C0h], rax
loc_72410:
mov rax, [rbx+0D0h]
cmp [rbx+0D8h], rax
jz short loc_72427
mov [rbx+0D8h], rax
loc_72427:
pop rbx
retn
| long long OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<float>::Clear(_QWORD *a1)
{
long long v1; // rax
long long v2; // rax
long long v3; // rax
long long v4; // rax
long long result; // rax
OpenSubdiv::v3_6_0::Far::StencilTableReal<float>::Clear((long long)a1);
v1 = a1[14];
if ( a1[15] != v1 )
a1[15] = v1;
v2 = a1[17];
if ( a1[18] != v2 )
a1[18] = v2;
v3 = a1[20];
if ( a1[21] != v3 )
a1[21] = v3;
v4 = a1[23];
if ( a1[24] != v4 )
a1[24] = v4;
result = a1[26];
if ( a1[27] != result )
a1[27] = result;
return result;
}
| Clear:
PUSH RBX
MOV RBX,RDI
CALL 0x0013b370
MOV RAX,qword ptr [RBX + 0x70]
CMP qword ptr [RBX + 0x78],RAX
JZ 0x001723cb
MOV qword ptr [RBX + 0x78],RAX
LAB_001723cb:
MOV RAX,qword ptr [RBX + 0x88]
CMP qword ptr [RBX + 0x90],RAX
JZ 0x001723e2
MOV qword ptr [RBX + 0x90],RAX
LAB_001723e2:
MOV RAX,qword ptr [RBX + 0xa0]
CMP qword ptr [RBX + 0xa8],RAX
JZ 0x001723f9
MOV qword ptr [RBX + 0xa8],RAX
LAB_001723f9:
MOV RAX,qword ptr [RBX + 0xb8]
CMP qword ptr [RBX + 0xc0],RAX
JZ 0x00172410
MOV qword ptr [RBX + 0xc0],RAX
LAB_00172410:
MOV RAX,qword ptr [RBX + 0xd0]
CMP qword ptr [RBX + 0xd8],RAX
JZ 0x00172427
MOV qword ptr [RBX + 0xd8],RAX
LAB_00172427:
POP RBX
RET
|
/* OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<float>::Clear() */
void __thiscall
OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<float>::Clear(LimitStencilTableReal<float> *this)
{
StencilTableReal<float>::Clear((StencilTableReal<float> *)this);
if (*(long *)(this + 0x78) != *(long *)(this + 0x70)) {
*(long *)(this + 0x78) = *(long *)(this + 0x70);
}
if (*(long *)(this + 0x90) != *(long *)(this + 0x88)) {
*(long *)(this + 0x90) = *(long *)(this + 0x88);
}
if (*(long *)(this + 0xa8) != *(long *)(this + 0xa0)) {
*(long *)(this + 0xa8) = *(long *)(this + 0xa0);
}
if (*(long *)(this + 0xc0) != *(long *)(this + 0xb8)) {
*(long *)(this + 0xc0) = *(long *)(this + 0xb8);
}
if (*(long *)(this + 0xd8) != *(long *)(this + 0xd0)) {
*(long *)(this + 0xd8) = *(long *)(this + 0xd0);
}
return;
}
| |
44,728 | OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<double>::Clear() | NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/stencilTable.cpp | void
LimitStencilTableReal<REAL>::Clear() {
StencilTableReal<REAL>::Clear();
_duWeights.clear();
_dvWeights.clear();
_duuWeights.clear();
_duvWeights.clear();
_dvvWeights.clear();
} | O2 | cpp | OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<double>::Clear():
pushq %rbx
movq %rdi, %rbx
callq 0x525e0
movq 0x70(%rbx), %rax
cmpq %rax, 0x78(%rbx)
je 0x83e6f
movq %rax, 0x78(%rbx)
movq 0x88(%rbx), %rax
cmpq %rax, 0x90(%rbx)
je 0x83e86
movq %rax, 0x90(%rbx)
movq 0xa0(%rbx), %rax
cmpq %rax, 0xa8(%rbx)
je 0x83e9d
movq %rax, 0xa8(%rbx)
movq 0xb8(%rbx), %rax
cmpq %rax, 0xc0(%rbx)
je 0x83eb4
movq %rax, 0xc0(%rbx)
movq 0xd0(%rbx), %rax
cmpq %rax, 0xd8(%rbx)
je 0x83ecb
movq %rax, 0xd8(%rbx)
popq %rbx
retq
nop
| _ZN10OpenSubdiv6v3_6_03Far21LimitStencilTableRealIdE5ClearEv:
push rbx
mov rbx, rdi
call __ZN10OpenSubdiv6v3_6_03Far16StencilTableRealIdE5ClearEv; OpenSubdiv::v3_6_0::Far::StencilTableReal<double>::Clear(void)
mov rax, [rbx+70h]
cmp [rbx+78h], rax
jz short loc_83E6F
mov [rbx+78h], rax
loc_83E6F:
mov rax, [rbx+88h]
cmp [rbx+90h], rax
jz short loc_83E86
mov [rbx+90h], rax
loc_83E86:
mov rax, [rbx+0A0h]
cmp [rbx+0A8h], rax
jz short loc_83E9D
mov [rbx+0A8h], rax
loc_83E9D:
mov rax, [rbx+0B8h]
cmp [rbx+0C0h], rax
jz short loc_83EB4
mov [rbx+0C0h], rax
loc_83EB4:
mov rax, [rbx+0D0h]
cmp [rbx+0D8h], rax
jz short loc_83ECB
mov [rbx+0D8h], rax
loc_83ECB:
pop rbx
retn
| long long OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<double>::Clear(_QWORD *a1)
{
long long v1; // rax
long long v2; // rax
long long v3; // rax
long long v4; // rax
long long result; // rax
OpenSubdiv::v3_6_0::Far::StencilTableReal<double>::Clear((long long)a1);
v1 = a1[14];
if ( a1[15] != v1 )
a1[15] = v1;
v2 = a1[17];
if ( a1[18] != v2 )
a1[18] = v2;
v3 = a1[20];
if ( a1[21] != v3 )
a1[21] = v3;
v4 = a1[23];
if ( a1[24] != v4 )
a1[24] = v4;
result = a1[26];
if ( a1[27] != result )
a1[27] = result;
return result;
}
| Clear:
PUSH RBX
MOV RBX,RDI
CALL 0x001525e0
MOV RAX,qword ptr [RBX + 0x70]
CMP qword ptr [RBX + 0x78],RAX
JZ 0x00183e6f
MOV qword ptr [RBX + 0x78],RAX
LAB_00183e6f:
MOV RAX,qword ptr [RBX + 0x88]
CMP qword ptr [RBX + 0x90],RAX
JZ 0x00183e86
MOV qword ptr [RBX + 0x90],RAX
LAB_00183e86:
MOV RAX,qword ptr [RBX + 0xa0]
CMP qword ptr [RBX + 0xa8],RAX
JZ 0x00183e9d
MOV qword ptr [RBX + 0xa8],RAX
LAB_00183e9d:
MOV RAX,qword ptr [RBX + 0xb8]
CMP qword ptr [RBX + 0xc0],RAX
JZ 0x00183eb4
MOV qword ptr [RBX + 0xc0],RAX
LAB_00183eb4:
MOV RAX,qword ptr [RBX + 0xd0]
CMP qword ptr [RBX + 0xd8],RAX
JZ 0x00183ecb
MOV qword ptr [RBX + 0xd8],RAX
LAB_00183ecb:
POP RBX
RET
|
/* OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<double>::Clear() */
void __thiscall
OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<double>::Clear(LimitStencilTableReal<double> *this)
{
StencilTableReal<double>::Clear((StencilTableReal<double> *)this);
if (*(long *)(this + 0x78) != *(long *)(this + 0x70)) {
*(long *)(this + 0x78) = *(long *)(this + 0x70);
}
if (*(long *)(this + 0x90) != *(long *)(this + 0x88)) {
*(long *)(this + 0x90) = *(long *)(this + 0x88);
}
if (*(long *)(this + 0xa8) != *(long *)(this + 0xa0)) {
*(long *)(this + 0xa8) = *(long *)(this + 0xa0);
}
if (*(long *)(this + 0xc0) != *(long *)(this + 0xb8)) {
*(long *)(this + 0xc0) = *(long *)(this + 0xb8);
}
if (*(long *)(this + 0xd8) != *(long *)(this + 0xd0)) {
*(long *)(this + 0xd8) = *(long *)(this + 0xd0);
}
return;
}
| |
44,729 | OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<double>::Clear() | NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/stencilTable.cpp | void
LimitStencilTableReal<REAL>::Clear() {
StencilTableReal<REAL>::Clear();
_duWeights.clear();
_dvWeights.clear();
_duuWeights.clear();
_duvWeights.clear();
_dvvWeights.clear();
} | O3 | cpp | OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<double>::Clear():
pushq %rbx
movq %rdi, %rbx
callq 0x3b330
movq 0x70(%rbx), %rax
cmpq %rax, 0x78(%rbx)
je 0x739ab
movq %rax, 0x78(%rbx)
movq 0x88(%rbx), %rax
cmpq %rax, 0x90(%rbx)
je 0x739c2
movq %rax, 0x90(%rbx)
movq 0xa0(%rbx), %rax
cmpq %rax, 0xa8(%rbx)
je 0x739d9
movq %rax, 0xa8(%rbx)
movq 0xb8(%rbx), %rax
cmpq %rax, 0xc0(%rbx)
je 0x739f0
movq %rax, 0xc0(%rbx)
movq 0xd0(%rbx), %rax
cmpq %rax, 0xd8(%rbx)
je 0x73a07
movq %rax, 0xd8(%rbx)
popq %rbx
retq
nop
| _ZN10OpenSubdiv6v3_6_03Far21LimitStencilTableRealIfE5ClearEv:
push rbx
mov rbx, rdi
call __ZN10OpenSubdiv6v3_6_03Far16StencilTableRealIfE5ClearEv; OpenSubdiv::v3_6_0::Far::StencilTableReal<float>::Clear(void)
mov rax, [rbx+70h]
cmp [rbx+78h], rax
jz short loc_739AB
mov [rbx+78h], rax
loc_739AB:
mov rax, [rbx+88h]
cmp [rbx+90h], rax
jz short loc_739C2
mov [rbx+90h], rax
loc_739C2:
mov rax, [rbx+0A0h]
cmp [rbx+0A8h], rax
jz short loc_739D9
mov [rbx+0A8h], rax
loc_739D9:
mov rax, [rbx+0B8h]
cmp [rbx+0C0h], rax
jz short loc_739F0
mov [rbx+0C0h], rax
loc_739F0:
mov rax, [rbx+0D0h]
cmp [rbx+0D8h], rax
jz short loc_73A07
mov [rbx+0D8h], rax
loc_73A07:
pop rbx
retn
| long long OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<float>::Clear(_QWORD *a1)
{
long long v1; // rax
long long v2; // rax
long long v3; // rax
long long v4; // rax
long long result; // rax
OpenSubdiv::v3_6_0::Far::StencilTableReal<float>::Clear((long long)a1);
v1 = a1[14];
if ( a1[15] != v1 )
a1[15] = v1;
v2 = a1[17];
if ( a1[18] != v2 )
a1[18] = v2;
v3 = a1[20];
if ( a1[21] != v3 )
a1[21] = v3;
v4 = a1[23];
if ( a1[24] != v4 )
a1[24] = v4;
result = a1[26];
if ( a1[27] != result )
a1[27] = result;
return result;
}
| Clear:
PUSH RBX
MOV RBX,RDI
CALL 0x0013b330
MOV RAX,qword ptr [RBX + 0x70]
CMP qword ptr [RBX + 0x78],RAX
JZ 0x001739ab
MOV qword ptr [RBX + 0x78],RAX
LAB_001739ab:
MOV RAX,qword ptr [RBX + 0x88]
CMP qword ptr [RBX + 0x90],RAX
JZ 0x001739c2
MOV qword ptr [RBX + 0x90],RAX
LAB_001739c2:
MOV RAX,qword ptr [RBX + 0xa0]
CMP qword ptr [RBX + 0xa8],RAX
JZ 0x001739d9
MOV qword ptr [RBX + 0xa8],RAX
LAB_001739d9:
MOV RAX,qword ptr [RBX + 0xb8]
CMP qword ptr [RBX + 0xc0],RAX
JZ 0x001739f0
MOV qword ptr [RBX + 0xc0],RAX
LAB_001739f0:
MOV RAX,qword ptr [RBX + 0xd0]
CMP qword ptr [RBX + 0xd8],RAX
JZ 0x00173a07
MOV qword ptr [RBX + 0xd8],RAX
LAB_00173a07:
POP RBX
RET
|
/* OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<float>::Clear() */
void __thiscall
OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<float>::Clear(LimitStencilTableReal<float> *this)
{
StencilTableReal<float>::Clear((StencilTableReal<float> *)this);
if (*(long *)(this + 0x78) != *(long *)(this + 0x70)) {
*(long *)(this + 0x78) = *(long *)(this + 0x70);
}
if (*(long *)(this + 0x90) != *(long *)(this + 0x88)) {
*(long *)(this + 0x90) = *(long *)(this + 0x88);
}
if (*(long *)(this + 0xa8) != *(long *)(this + 0xa0)) {
*(long *)(this + 0xa8) = *(long *)(this + 0xa0);
}
if (*(long *)(this + 0xc0) != *(long *)(this + 0xb8)) {
*(long *)(this + 0xc0) = *(long *)(this + 0xb8);
}
if (*(long *)(this + 0xd8) != *(long *)(this + 0xd0)) {
*(long *)(this + 0xd8) = *(long *)(this + 0xd0);
}
return;
}
| |
44,730 | mysql_mbcharlen_utf8mb3 | eloqsql/libmariadb/libmariadb/ma_charset.c | static unsigned int mysql_mbcharlen_utf8mb3(unsigned int utf8)
{
if (utf8 < 0x80) {
return 1; /* single byte character */
}
if (utf8 < 0xC2) {
return 0; /* invalid multibyte header */
}
if (utf8 < 0xE0) {
return 2; /* double byte character */
}
if (utf8 < 0xF0) {
return 3; /* triple byte character */
}
return 0;
} | O0 | c | mysql_mbcharlen_utf8mb3:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x80, -0x8(%rbp)
jae 0x44489
movl $0x1, -0x4(%rbp)
jmp 0x444c6
cmpl $0xc2, -0x8(%rbp)
jae 0x4449b
movl $0x0, -0x4(%rbp)
jmp 0x444c6
cmpl $0xe0, -0x8(%rbp)
jae 0x444ad
movl $0x2, -0x4(%rbp)
jmp 0x444c6
cmpl $0xf0, -0x8(%rbp)
jae 0x444bf
movl $0x3, -0x4(%rbp)
jmp 0x444c6
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
| mysql_mbcharlen_utf8mb3:
push rbp
mov rbp, rsp
mov [rbp+var_8], edi
cmp [rbp+var_8], 80h
jnb short loc_44489
mov [rbp+var_4], 1
jmp short loc_444C6
loc_44489:
cmp [rbp+var_8], 0C2h
jnb short loc_4449B
mov [rbp+var_4], 0
jmp short loc_444C6
loc_4449B:
cmp [rbp+var_8], 0E0h
jnb short loc_444AD
mov [rbp+var_4], 2
jmp short loc_444C6
loc_444AD:
cmp [rbp+var_8], 0F0h
jnb short loc_444BF
mov [rbp+var_4], 3
jmp short loc_444C6
loc_444BF:
mov [rbp+var_4], 0
loc_444C6:
mov eax, [rbp+var_4]
pop rbp
retn
| long long mysql_mbcharlen_utf8mb3(unsigned int a1)
{
if ( a1 >= 0x80 )
{
if ( a1 >= 0xC2 )
{
if ( a1 >= 0xE0 )
{
if ( a1 >= 0xF0 )
return 0;
else
return 3;
}
else
{
return 2;
}
}
else
{
return 0;
}
}
else
{
return 1;
}
}
| mysql_mbcharlen_utf8mb3:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x8],EDI
CMP dword ptr [RBP + -0x8],0x80
JNC 0x00144489
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001444c6
LAB_00144489:
CMP dword ptr [RBP + -0x8],0xc2
JNC 0x0014449b
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001444c6
LAB_0014449b:
CMP dword ptr [RBP + -0x8],0xe0
JNC 0x001444ad
MOV dword ptr [RBP + -0x4],0x2
JMP 0x001444c6
LAB_001444ad:
CMP dword ptr [RBP + -0x8],0xf0
JNC 0x001444bf
MOV dword ptr [RBP + -0x4],0x3
JMP 0x001444c6
LAB_001444bf:
MOV dword ptr [RBP + -0x4],0x0
LAB_001444c6:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 mysql_mbcharlen_utf8mb3(uint param_1)
{
int4 local_c;
if (param_1 < 0x80) {
local_c = 1;
}
else if (param_1 < 0xc2) {
local_c = 0;
}
else if (param_1 < 0xe0) {
local_c = 2;
}
else if (param_1 < 0xf0) {
local_c = 3;
}
else {
local_c = 0;
}
return local_c;
}
| |
44,731 | mysql_mbcharlen_utf8mb3 | eloqsql/libmariadb/libmariadb/ma_charset.c | static unsigned int mysql_mbcharlen_utf8mb3(unsigned int utf8)
{
if (utf8 < 0x80) {
return 1; /* single byte character */
}
if (utf8 < 0xC2) {
return 0; /* invalid multibyte header */
}
if (utf8 < 0xE0) {
return 2; /* double byte character */
}
if (utf8 < 0xF0) {
return 3; /* triple byte character */
}
return 0;
} | O3 | c | mysql_mbcharlen_utf8mb3:
pushq %rbp
movq %rsp, %rbp
movl $0x1, %eax
cmpl $0x80, %edi
jb 0x30720
xorl %eax, %eax
cmpl $0xc2, %edi
jb 0x30720
movl $0x2, %eax
cmpl $0xe0, %edi
jb 0x30720
xorl %eax, %eax
cmpl $0xf0, %edi
setb %al
leal (%rax,%rax,2), %eax
popq %rbp
retq
| mysql_mbcharlen_utf8mb3:
push rbp
mov rbp, rsp
mov eax, 1
cmp edi, 80h
jb short loc_30720
xor eax, eax
cmp edi, 0C2h
jb short loc_30720
mov eax, 2
cmp edi, 0E0h
jb short loc_30720
xor eax, eax
cmp edi, 0F0h
setb al
lea eax, [rax+rax*2]
loc_30720:
pop rbp
retn
| long long mysql_mbcharlen_utf8mb3(unsigned int a1)
{
long long result; // rax
result = 1LL;
if ( a1 >= 0x80 )
{
result = 0LL;
if ( a1 >= 0xC2 )
{
result = 2LL;
if ( a1 >= 0xE0 )
return 3 * (unsigned int)(a1 < 0xF0);
}
}
return result;
}
| mysql_mbcharlen_utf8mb3:
PUSH RBP
MOV RBP,RSP
MOV EAX,0x1
CMP EDI,0x80
JC 0x00130720
XOR EAX,EAX
CMP EDI,0xc2
JC 0x00130720
MOV EAX,0x2
CMP EDI,0xe0
JC 0x00130720
XOR EAX,EAX
CMP EDI,0xf0
SETC AL
LEA EAX,[RAX + RAX*0x2]
LAB_00130720:
POP RBP
RET
|
char mysql_mbcharlen_utf8mb3(uint param_1)
{
char cVar1;
cVar1 = '\x01';
if (((0x7f < param_1) && (cVar1 = '\0', 0xc1 < param_1)) && (cVar1 = '\x02', 0xdf < param_1)) {
cVar1 = (param_1 < 0xf0) * '\x03';
}
return cVar1;
}
| |
44,732 | 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>::push_back(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&&) | monkey531[P]llama/common/./json.hpp | void push_back(basic_json&& val)
{
// push_back only works for null objects or arrays
if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
{
JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this));
}
// transform null object into an array
if (is_null())
{
m_data.m_type = value_t::array;
m_data.m_value = value_t::array;
assert_invariant();
}
// add element to array (move semantics)
const auto old_capacity = m_data.m_value.array->capacity();
m_data.m_value.array->push_back(std::move(val));
set_parent(m_data.m_value.array->back(), old_capacity);
// if val is moved from, basic_json move constructor marks it null, so we do not call the destructor
} | O3 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::push_back(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rdi), %eax
testl %eax, %eax
jne 0x7a1ea
movb $0x2, (%r14)
movl $0x18, %edi
callq 0x18690
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x8(%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x3d970
jmp 0x7a1ef
cmpl $0x2, %eax
jne 0x7a203
movq 0x8(%r14), %rdi
movq %rbx, %rsi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x3f08e
movl $0x20, %edi
callq 0x18360
movq %rax, %rbx
movq %r14, %rdi
callq 0x3e096
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x42a53(%rip), %rsi # 0xbcc7a
leaq 0x10(%rsp), %rdi
callq 0x3e00d
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x134, %esi # imm = 0x134
movq %r14, %rcx
callq 0x49cf4
xorl %ebp, %ebp
leaq 0x74066(%rip), %rsi # 0xee2b8
leaq -0x2dea9(%rip), %rdx # 0x4c3b0
movq %rbx, %rdi
callq 0x18b30
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7a27f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x186a0
testb %bpl, %bpl
jne 0x7a289
jmp 0x7a291
movq %rax, %r14
movq %rbx, %rdi
callq 0x18500
movq %r14, %rdi
callq 0x18b90
nop
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9push_backEOSD_:
push rbp; char
push r14; int
push rbx; __int64
sub rsp, 30h
mov rbx, rsi
mov r14, rdi
movzx eax, byte ptr [rdi]
test eax, eax
jnz short loc_7A1EA
mov byte ptr [r14], 2
mov edi, 18h; unsigned __int64
call __Znwm; operator new(ulong)
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
mov qword ptr [rax+10h], 0
mov [r14+8], rax
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
jmp short loc_7A1EF
loc_7A1EA:
cmp eax, 2
jnz short loc_7A203
loc_7A1EF:
mov rdi, [r14+8]
mov rsi, rbx
add rsp, 30h
pop rbx
pop r14
pop rbp
jmp _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &&)
loc_7A203:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+48h+var_40]
mov [rdx], rax
lea rsi, aCannotUsePushB; "cannot use push_back() with "
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA29_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[29],char const*>(char const(&)[29],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 134h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+48h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_7A27F
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7A27F:
test bpl, bpl
jnz short loc_7A289
jmp short loc_7A291
mov r14, rax
loc_7A289:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_7A291:
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::push_back(
long long a1,
long long a2)
{
long long v2; // rax
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
const char *v5; // [rsp+8h] [rbp-40h] BYREF
_QWORD v6[2]; // [rsp+10h] [rbp-38h] BYREF
if ( *(_BYTE *)a1 )
{
if ( *(_BYTE *)a1 != 2 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
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>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[29],char const*>(
(long long)v6,
(long long)"cannot use push_back() with ",
&v5);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
308,
v6);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
}
else
{
*(_BYTE *)a1 = 2;
v2 = operator new(0x18uLL);
*(_OWORD *)v2 = 0LL;
*(_QWORD *)(v2 + 16) = 0LL;
*(_QWORD *)(a1 + 8) = v2;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)a1);
}
return std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
*(_QWORD *)(a1 + 8),
a2);
}
| push_back:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV RBX,RSI
MOV R14,RDI
MOVZX EAX,byte ptr [RDI]
TEST EAX,EAX
JNZ 0x0017a1ea
MOV byte ptr [R14],0x2
MOV EDI,0x18
CALL 0x00118690
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOV qword ptr [RAX + 0x10],0x0
MOV qword ptr [R14 + 0x8],RAX
MOV RDI,R14
MOV ESI,0x1
CALL 0x0013d970
JMP 0x0017a1ef
LAB_0017a1ea:
CMP EAX,0x2
JNZ 0x0017a203
LAB_0017a1ef:
MOV RDI,qword ptr [R14 + 0x8]
MOV RSI,RBX
ADD RSP,0x30
POP RBX
POP R14
POP RBP
JMP 0x0013f08e
LAB_0017a203:
MOV EDI,0x20
CALL 0x00118360
MOV RBX,RAX
MOV RDI,R14
CALL 0x0013e096
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_0017a220:
LEA RSI,[0x1bcc7a]
LEA RDI,[RSP + 0x10]
CALL 0x0013e00d
MOV BPL,0x1
LAB_0017a234:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x134
MOV RCX,R14
CALL 0x00149cf4
XOR EBP,EBP
LEA RSI,[0x1ee2b8]
LEA RDX,[0x14c3b0]
MOV RDI,RBX
CALL 0x00118b30
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >,
void>::push_back(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>&&) */
void __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::push_back(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this,basic_json *param_1)
{
int8 *puVar1;
int8 uVar2;
char *local_40;
detail local_38 [32];
if (*this == (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x0) {
*this = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2;
puVar1 = (int8 *)operator_new(0x18);
*puVar1 = 0;
puVar1[1] = 0;
puVar1[2] = 0;
*(int8 **)(this + 8) = puVar1;
assert_invariant(SUB81(this,0));
}
else if (*this != (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2) {
uVar2 = __cxa_allocate_exception(0x20);
local_40 = (char *)type_name(this);
/* try { // try from 0017a220 to 0017a230 has its CatchHandler @ 0017a286 */
detail::concat<std::__cxx11::string,char_const(&)[29],char_const*>
(local_38,"cannot use push_back() with ",&local_40);
/* try { // try from 0017a234 to 0017a260 has its CatchHandler @ 0017a261 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar2,0x134,local_38,this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar2,&detail::type_error::typeinfo,detail::exception::~exception);
}
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(*(vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(this + 8),param_1);
return;
}
| |
44,733 | JS_SetConstructorBit | bluesky950520[P]quickjs/quickjs.c | BOOL JS_SetConstructorBit(JSContext *ctx, JSValue func_obj, BOOL val)
{
JSObject *p;
if (JS_VALUE_GET_TAG(func_obj) != JS_TAG_OBJECT)
return FALSE;
p = JS_VALUE_GET_OBJ(func_obj);
p->is_constructor = val;
return TRUE;
} | O2 | c | JS_SetConstructorBit:
xorl %eax, %eax
cmpl $-0x1, %edx
jne 0x24d23
movb 0x5(%rsi), %al
shlb $0x4, %cl
andb $0x10, %cl
andb $-0x11, %al
orb %cl, %al
movb %al, 0x5(%rsi)
pushq $0x1
popq %rax
retq
| JS_SetConstructorBit:
xor eax, eax
cmp edx, 0FFFFFFFFh
jnz short locret_24D23
mov al, [rsi+5]
shl cl, 4
and cl, 10h
and al, 0EFh
or al, cl
mov [rsi+5], al
push 1
pop rax
locret_24D23:
retn
| long long JS_SetConstructorBit(long long a1, long long a2, int a3, char a4)
{
long long result; // rax
result = 0LL;
if ( a3 == -1 )
{
*(_BYTE *)(a2 + 5) = (16 * a4) & 0x10 | *(_BYTE *)(a2 + 5) & 0xEF;
return 1LL;
}
return result;
}
| JS_SetConstructorBit:
XOR EAX,EAX
CMP EDX,-0x1
JNZ 0x00124d23
MOV AL,byte ptr [RSI + 0x5]
SHL CL,0x4
AND CL,0x10
AND AL,0xef
OR AL,CL
MOV byte ptr [RSI + 0x5],AL
PUSH 0x1
POP RAX
LAB_00124d23:
RET
|
bool JS_SetConstructorBit(int8 param_1,long param_2,int param_3,byte param_4)
{
if (param_3 == -1) {
*(byte *)(param_2 + 5) = *(byte *)(param_2 + 5) & 0xef | (param_4 & 1) << 4;
}
return param_3 == -1;
}
| |
44,734 | bitmap_set_prefix | eloqsql/mysys/my_bitmap.c | void bitmap_set_prefix(MY_BITMAP *map, uint prefix_size)
{
uint prefix_bytes, prefix_bits, d;
uchar *m= (uchar *)map->bitmap;
DBUG_ASSERT(map->bitmap);
DBUG_ASSERT(prefix_size <= map->n_bits || prefix_size == (uint) ~0);
set_if_smaller(prefix_size, map->n_bits);
if ((prefix_bytes= prefix_size / 8))
memset(m, 0xff, prefix_bytes);
m+= prefix_bytes;
if ((prefix_bits= prefix_size & 7))
{
*(m++)= (1 << prefix_bits)-1;
// As the prefix bits are set, lets count this byte too as a prefix byte.
prefix_bytes ++;
}
if ((d= no_bytes_in_map(map)-prefix_bytes))
memset(m, 0, d);
} | O0 | c | bitmap_set_prefix:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xf04fc
jmp 0xf04fe
jmp 0xf0500
jmp 0xf0502
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jbe 0xf0518
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0xc(%rbp)
jmp 0xf051a
movl -0xc(%rbp), %eax
shrl $0x3, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, %eax
je 0xf053b
movq -0x20(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, %edx
movl $0xff, %esi
callq 0x2a2a0
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
andl $0x7, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0xf0582
movl -0x14(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
subl $0x1, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
addl $0x7, %eax
shrl $0x3, %eax
subl -0x10(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
je 0xf05aa
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x2a2a0
addq $0x20, %rsp
popq %rbp
retq
| bitmap_set_prefix:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_20], rax
jmp short $+2
loc_F04FC:
jmp short $+2
loc_F04FE:
jmp short $+2
loc_F0500:
jmp short $+2
loc_F0502:
mov eax, [rbp+var_C]
mov rcx, [rbp+var_8]
cmp eax, [rcx+1Ch]
jbe short loc_F0518
mov rax, [rbp+var_8]
mov eax, [rax+1Ch]
mov [rbp+var_C], eax
loc_F0518:
jmp short $+2
loc_F051A:
mov eax, [rbp+var_C]
shr eax, 3
mov [rbp+var_10], eax
cmp eax, 0
jz short loc_F053B
mov rdi, [rbp+var_20]
mov eax, [rbp+var_10]
mov edx, eax
mov esi, 0FFh
call _memset
loc_F053B:
mov ecx, [rbp+var_10]
mov rax, [rbp+var_20]
mov ecx, ecx
add rax, rcx
mov [rbp+var_20], rax
mov eax, [rbp+var_C]
and eax, 7
mov [rbp+var_14], eax
cmp eax, 0
jz short loc_F0582
mov ecx, [rbp+var_14]
mov eax, 1
shl eax, cl
sub eax, 1
mov cl, al
mov rax, [rbp+var_20]
mov rdx, rax
add rdx, 1
mov [rbp+var_20], rdx
mov [rax], cl
mov eax, [rbp+var_10]
add eax, 1
mov [rbp+var_10], eax
loc_F0582:
mov rax, [rbp+var_8]
mov eax, [rax+1Ch]
add eax, 7
shr eax, 3
sub eax, [rbp+var_10]
mov [rbp+var_18], eax
cmp eax, 0
jz short loc_F05AA
mov rdi, [rbp+var_20]
mov eax, [rbp+var_18]
mov edx, eax
xor esi, esi
call _memset
loc_F05AA:
add rsp, 20h
pop rbp
retn
| long long bitmap_set_prefix(long long *a1, unsigned int a2)
{
_BYTE *v2; // rax
long long result; // rax
long long v4; // [rsp+0h] [rbp-20h]
_BYTE *v5; // [rsp+0h] [rbp-20h]
unsigned int v6; // [rsp+10h] [rbp-10h]
unsigned int v7; // [rsp+14h] [rbp-Ch]
v7 = a2;
v4 = *a1;
if ( a2 > *((_DWORD *)a1 + 7) )
v7 = *((_DWORD *)a1 + 7);
v6 = v7 >> 3;
if ( v7 >> 3 )
memset(v4, 255LL, v6);
v5 = (_BYTE *)(v6 + v4);
if ( (v7 & 7) != 0 )
{
v2 = v5++;
*v2 = (1 << (v7 & 7)) - 1;
++v6;
}
result = ((unsigned int)(*((_DWORD *)a1 + 7) + 7) >> 3) - v6;
if ( (_DWORD)result )
return memset(v5, 0LL, (unsigned int)result);
return result;
}
| bitmap_set_prefix:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001f04fc
LAB_001f04fc:
JMP 0x001f04fe
LAB_001f04fe:
JMP 0x001f0500
LAB_001f0500:
JMP 0x001f0502
LAB_001f0502:
MOV EAX,dword ptr [RBP + -0xc]
MOV RCX,qword ptr [RBP + -0x8]
CMP EAX,dword ptr [RCX + 0x1c]
JBE 0x001f0518
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x1c]
MOV dword ptr [RBP + -0xc],EAX
LAB_001f0518:
JMP 0x001f051a
LAB_001f051a:
MOV EAX,dword ptr [RBP + -0xc]
SHR EAX,0x3
MOV dword ptr [RBP + -0x10],EAX
CMP EAX,0x0
JZ 0x001f053b
MOV RDI,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RBP + -0x10]
MOV EDX,EAX
MOV ESI,0xff
CALL 0x0012a2a0
LAB_001f053b:
MOV ECX,dword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV EAX,dword ptr [RBP + -0xc]
AND EAX,0x7
MOV dword ptr [RBP + -0x14],EAX
CMP EAX,0x0
JZ 0x001f0582
MOV ECX,dword ptr [RBP + -0x14]
MOV EAX,0x1
SHL EAX,CL
SUB EAX,0x1
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x20],RDX
MOV byte ptr [RAX],CL
MOV EAX,dword ptr [RBP + -0x10]
ADD EAX,0x1
MOV dword ptr [RBP + -0x10],EAX
LAB_001f0582:
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x1c]
ADD EAX,0x7
SHR EAX,0x3
SUB EAX,dword ptr [RBP + -0x10]
MOV dword ptr [RBP + -0x18],EAX
CMP EAX,0x0
JZ 0x001f05aa
MOV RDI,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RBP + -0x18]
MOV EDX,EAX
XOR ESI,ESI
CALL 0x0012a2a0
LAB_001f05aa:
ADD RSP,0x20
POP RBP
RET
|
void bitmap_set_prefix(int8 *param_1,uint param_2)
{
void *__s;
char *pcVar1;
char *local_28;
uint local_18;
uint local_14;
__s = (void *)*param_1;
local_14 = param_2;
if (*(uint *)((long)param_1 + 0x1c) < param_2) {
local_14 = *(uint *)((long)param_1 + 0x1c);
}
local_18 = local_14 >> 3;
if (local_18 != 0) {
memset(__s,0xff,(ulong)local_18);
}
pcVar1 = (char *)((long)__s + (ulong)local_18);
local_28 = pcVar1;
if ((local_14 & 7) != 0) {
local_28 = pcVar1 + 1;
*pcVar1 = (char)(1 << (sbyte)(local_14 & 7)) + -1;
local_18 = local_18 + 1;
}
local_18 = (*(int *)((long)param_1 + 0x1c) + 7U >> 3) - local_18;
if (local_18 != 0) {
memset(local_28,0,(ulong)local_18);
}
return;
}
| |
44,735 | common_params_get_system_info[abi:cxx11](common_params const&) | llama.cpp/common/common.cpp | std::string common_params_get_system_info(const common_params & params) {
std::ostringstream os;
os << "system_info: n_threads = " << params.cpuparams.n_threads;
if (params.cpuparams_batch.n_threads != -1) {
os << " (n_threads_batch = " << params.cpuparams_batch.n_threads << ")";
}
#if defined(_WIN32) && (_WIN32_WINNT >= 0x0601) && !defined(__MINGW64__) // windows 7 and later
// TODO: windows + arm64 + mingw64
DWORD logicalProcessorCount = GetActiveProcessorCount(ALL_PROCESSOR_GROUPS);
os << " / " << logicalProcessorCount << " | " << llama_print_system_info();
#else
os << " / " << std::thread::hardware_concurrency() << " | " << llama_print_system_info();
#endif
return os.str();
} | O3 | cpp | common_params_get_system_info[abi:cxx11](common_params const&):
pushq %r15
pushq %r14
pushq %rbx
subq $0x180, %rsp # imm = 0x180
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x21010
leaq 0x2d9e9(%rip), %rsi # 0x1231a2
movl $0x19, %edx
movq %r15, %rdi
callq 0x21070
movl 0x274(%r14), %esi
leaq 0x8(%rsp), %rdi
callq 0x20510
cmpl $-0x1, 0x488(%r14)
je 0xf581c
leaq 0x2d9d4(%rip), %rsi # 0x1231bc
leaq 0x8(%rsp), %rdi
movl $0x14, %edx
callq 0x21070
movl 0x488(%r14), %esi
leaq 0x8(%rsp), %rdi
callq 0x20510
leaq 0x2557c(%rip), %rsi # 0x11ad8b
movl $0x1, %edx
movq %rax, %rdi
callq 0x21070
leaq 0x2d9ae(%rip), %rsi # 0x1231d1
leaq 0x8(%rsp), %rdi
movl $0x3, %edx
callq 0x21070
callq 0x20df0
movl %eax, %esi
leaq 0x8(%rsp), %rdi
callq 0x20880
movq %rax, %r14
leaq 0x2ef73(%rip), %rsi # 0x1247c0
movl $0x3, %edx
movq %rax, %rdi
callq 0x21070
callq 0x20060
movq %rax, %r15
testq %rax, %rax
je 0xf587f
movq %r15, %rdi
callq 0x20690
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x21070
jmp 0xf5899
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x212c0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x20670
movq 0x6b6ab(%rip), %rsi # 0x160f58
leaq 0x8(%rsp), %rdi
callq 0x20c80
leaq 0x78(%rsp), %rdi
callq 0x20c50
movq %rbx, %rax
addq $0x180, %rsp # imm = 0x180
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x6b67d(%rip), %rsi # 0x160f58
leaq 0x8(%rsp), %rdi
callq 0x20c80
leaq 0x78(%rsp), %rdi
callq 0x20c50
movq %rbx, %rdi
callq 0x20b00
| _Z29common_params_get_system_infoB5cxx11RK13common_params:
push r15
push r14
push rbx
sub rsp, 180h
mov r14, rsi
mov rbx, rdi
lea r15, [rsp+198h+var_190]
mov rdi, r15
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::ostringstream::basic_ostringstream(void)
lea rsi, aSystemInfoNThr; "system_info: n_threads = "
mov edx, 19h
mov rdi, r15
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov esi, [r14+274h]
lea rdi, [rsp+198h+var_190]
call __ZNSolsEi; std::ostream::operator<<(int)
cmp dword ptr [r14+488h], 0FFFFFFFFh
jz short loc_F581C
lea rsi, aNThreadsBatch; " (n_threads_batch = "
lea rdi, [rsp+198h+var_190]
mov edx, 14h
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov esi, [r14+488h]
lea rdi, [rsp+198h+var_190]
call __ZNSolsEi; std::ostream::operator<<(int)
lea rsi, aCompreplyCompg_2+3Ah; ")"
mov edx, 1
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
loc_F581C:
lea rsi, asc_1231D1; " / "
lea rdi, [rsp+198h+var_190]; this
mov edx, 3
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
call __ZNSt6thread20hardware_concurrencyEv; std::thread::hardware_concurrency(void)
mov esi, eax
lea rdi, [rsp+198h+var_190]
call __ZNSo9_M_insertImEERSoT_; std::ostream::_M_insert<ulong>(ulong)
mov r14, rax
lea rsi, asc_1247BF+1; " | "
mov edx, 3
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
call _llama_print_system_info
mov r15, rax
test rax, rax
jz short loc_F587F
mov rdi, r15
call _strlen
mov rdi, r14
mov rsi, r15
mov rdx, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
jmp short loc_F5899
loc_F587F:
mov rax, [r14]
mov rax, [rax-18h]
mov rdi, r14
add rdi, rax
mov esi, [r14+rax+20h]
or esi, 1
call __ZNSt9basic_iosIcSt11char_traitsIcEE5clearESt12_Ios_Iostate; std::ios::clear(std::_Ios_Iostate)
loc_F5899:
lea rsi, [rsp+198h+var_188]
mov rdi, rbx
call __ZNKSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
mov rsi, cs:_ZTTNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+198h+var_190]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED2Ev; std::ostringstream::~ostringstream()
lea rdi, [rsp+198h+var_120]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
mov rax, rbx
add rsp, 180h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
mov rsi, cs:_ZTTNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+arg_0]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED2Ev; std::ostringstream::~ostringstream()
lea rdi, [rsp+arg_70]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
mov rdi, rbx
call __Unwind_Resume
| long long common_params_get_system_info[abi:cxx11](long long a1, long long a2)
{
long long v2; // rax
unsigned int v3; // eax
_QWORD *v4; // r14
long long v5; // rax
long long v6; // r15
long long v7; // rax
_BYTE v9[8]; // [rsp+8h] [rbp-190h] BYREF
_BYTE v10[104]; // [rsp+10h] [rbp-188h] BYREF
_BYTE v11[288]; // [rsp+78h] [rbp-120h] BYREF
std::ostringstream::basic_ostringstream(v9);
std::__ostream_insert<char,std::char_traits<char>>(v9, "system_info: n_threads = ", 25LL);
std::ostream::operator<<(v9, *(unsigned int *)(a2 + 628));
if ( *(_DWORD *)(a2 + 1160) != -1 )
{
std::__ostream_insert<char,std::char_traits<char>>(v9, " (n_threads_batch = ", 20LL);
v2 = std::ostream::operator<<(v9, *(unsigned int *)(a2 + 1160));
std::__ostream_insert<char,std::char_traits<char>>(v2, ")", 1LL);
}
std::__ostream_insert<char,std::char_traits<char>>(v9, " / ", 3LL);
v3 = std::thread::hardware_concurrency((std::thread *)v9);
v4 = (_QWORD *)std::ostream::_M_insert<unsigned long>(v9, v3);
std::__ostream_insert<char,std::char_traits<char>>(v4, " | ", 3LL);
v5 = llama_print_system_info();
v6 = v5;
if ( v5 )
{
v7 = strlen(v5);
std::__ostream_insert<char,std::char_traits<char>>(v4, v6, v7);
}
else
{
std::ios::clear((char *)v4 + *(_QWORD *)(*v4 - 24LL), *(_DWORD *)((char *)v4 + *(_QWORD *)(*v4 - 24LL) + 32) | 1u);
}
std::stringbuf::str(a1, v10);
std::ostringstream::~ostringstream(v9, &`VTT for'std::ostringstream);
std::ios_base::~ios_base((std::ios_base *)v11);
return a1;
}
| common_params_get_system_info[abi:cxx11]:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x180
MOV R14,RSI
MOV RBX,RDI
LEA R15,[RSP + 0x8]
MOV RDI,R15
CALL 0x00121010
LAB_001f57b2:
LEA RSI,[0x2231a2]
MOV EDX,0x19
MOV RDI,R15
CALL 0x00121070
MOV ESI,dword ptr [R14 + 0x274]
LEA RDI,[RSP + 0x8]
CALL 0x00120510
CMP dword ptr [R14 + 0x488],-0x1
JZ 0x001f581c
LEA RSI,[0x2231bc]
LEA RDI,[RSP + 0x8]
MOV EDX,0x14
CALL 0x00121070
MOV ESI,dword ptr [R14 + 0x488]
LEA RDI,[RSP + 0x8]
CALL 0x00120510
LEA RSI,[0x21ad8b]
MOV EDX,0x1
MOV RDI,RAX
CALL 0x00121070
LAB_001f581c:
LEA RSI,[0x2231d1]
LEA RDI,[RSP + 0x8]
MOV EDX,0x3
CALL 0x00121070
CALL 0x00120df0
MOV ESI,EAX
LEA RDI,[RSP + 0x8]
CALL 0x00120880
MOV R14,RAX
LEA RSI,[0x2247c0]
MOV EDX,0x3
MOV RDI,RAX
CALL 0x00121070
CALL 0x00120060
MOV R15,RAX
TEST RAX,RAX
JZ 0x001f587f
MOV RDI,R15
CALL 0x00120690
MOV RDI,R14
MOV RSI,R15
MOV RDX,RAX
CALL 0x00121070
JMP 0x001f5899
LAB_001f587f:
MOV RAX,qword ptr [R14]
MOV RAX,qword ptr [RAX + -0x18]
MOV RDI,R14
ADD RDI,RAX
MOV ESI,dword ptr [R14 + RAX*0x1 + 0x20]
OR ESI,0x1
CALL 0x001212c0
LAB_001f5899:
LEA RSI,[RSP + 0x10]
MOV RDI,RBX
CALL 0x00120670
LAB_001f58a6:
MOV RSI,qword ptr [0x00260f58]
LEA RDI,[RSP + 0x8]
CALL 0x00120c80
LEA RDI,[RSP + 0x78]
CALL 0x00120c50
MOV RAX,RBX
ADD RSP,0x180
POP RBX
POP R14
POP R15
RET
|
/* common_params_get_system_info[abi:cxx11](common_params const&) */
common_params * common_params_get_system_info_abi_cxx11_(common_params *param_1)
{
ostream *poVar1;
char *__s;
size_t sVar2;
long in_RSI;
ostringstream local_190 [112];
ios_base local_120 [264];
std::__cxx11::ostringstream::ostringstream(local_190);
/* try { // try from 001f57b2 to 001f58a5 has its CatchHandler @ 001f58d1 */
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)local_190,"system_info: n_threads = ",0x19);
std::ostream::operator<<((ostream *)local_190,*(int *)(in_RSI + 0x274));
if (*(int *)(in_RSI + 0x488) != -1) {
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)local_190," (n_threads_batch = ",0x14);
poVar1 = (ostream *)std::ostream::operator<<((ostream *)local_190,*(int *)(in_RSI + 0x488));
std::__ostream_insert<char,std::char_traits<char>>(poVar1,")",1);
}
std::__ostream_insert<char,std::char_traits<char>>((ostream *)local_190," / ",3);
std::thread::hardware_concurrency();
poVar1 = std::ostream::_M_insert<unsigned_long>((ulong)local_190);
std::__ostream_insert<char,std::char_traits<char>>(poVar1," | ",3);
__s = (char *)llama_print_system_info();
if (__s == (char *)0x0) {
std::ios::clear(poVar1 + *(long *)(*(long *)poVar1 + -0x18),
*(uint *)(poVar1 + *(long *)(*(long *)poVar1 + -0x18) + 0x20) | 1);
}
else {
sVar2 = strlen(__s);
std::__ostream_insert<char,std::char_traits<char>>(poVar1,__s,sVar2);
}
std::__cxx11::stringbuf::str();
std::__cxx11::ostringstream::~ostringstream(local_190);
std::ios_base::~ios_base(local_120);
return param_1;
}
| |
44,736 | my_set_error | eloqsql/libmariadb/libmariadb/mariadb_lib.c | void my_set_error(MYSQL *mysql,
unsigned int error_nr,
const char *sqlstate,
const char *format,
...)
{
va_list ap;
const char *errmsg;
if (!format)
{
if (error_nr >= CR_MIN_ERROR && error_nr <= CR_MYSQL_LAST_ERROR)
errmsg= ER(error_nr);
else if (error_nr >= CER_MIN_ERROR && error_nr <= CR_MARIADB_LAST_ERROR)
errmsg= CER(error_nr);
else
errmsg= ER(CR_UNKNOWN_ERROR);
}
mysql->net.last_errno= error_nr;
ma_strmake(mysql->net.sqlstate, sqlstate, SQLSTATE_LENGTH);
va_start(ap, format);
vsnprintf(mysql->net.last_error, MYSQL_ERRMSG_SIZE - 1,
format ? format : errmsg, ap);
va_end(ap);
return;
} | O0 | c | my_set_error:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
testb %al, %al
je 0x3080e
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %r9, -0xd8(%rbp)
movq %r8, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x308a2
cmpl $0x7d0, -0xc(%rbp) # imm = 0x7D0
jb 0x30861
cmpl $0x80d, -0xc(%rbp) # imm = 0x80D
ja 0x30861
movl -0xc(%rbp), %eax
subl $0x7d0, %eax # imm = 0x7D0
movl %eax, %eax
movl %eax, %ecx
leaq 0x50659(%rip), %rax # 0x80eb0
movq (%rax,%rcx,8), %rax
movq %rax, -0x48(%rbp)
jmp 0x308a0
cmpl $0x1388, -0xc(%rbp) # imm = 0x1388
jb 0x30890
cmpl $0x1397, -0xc(%rbp) # imm = 0x1397
ja 0x30890
movl -0xc(%rbp), %eax
subl $0x1388, %eax # imm = 0x1388
movl %eax, %eax
movl %eax, %ecx
leaq 0x5082a(%rip), %rax # 0x810b0
movq (%rax,%rcx,8), %rax
movq %rax, -0x48(%rbp)
jmp 0x3089e
leaq 0x50619(%rip), %rax # 0x80eb0
movq (%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0x308a0
jmp 0x308a2
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x90(%rax)
movq -0x8(%rbp), %rdi
addq $0x297, %rdi # imm = 0x297
movq -0x18(%rbp), %rsi
movl $0x5, %edx
callq 0x4c650
leaq -0x40(%rbp), %rax
leaq -0x100(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x20, (%rax)
movq -0x8(%rbp), %rax
addq $0x97, %rax
movq %rax, -0x108(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x30911
movq -0x20(%rbp), %rax
movq %rax, -0x110(%rbp)
jmp 0x3091c
movq -0x48(%rbp), %rax
movq %rax, -0x110(%rbp)
movq -0x108(%rbp), %rdi
movq -0x110(%rbp), %rdx
movl $0x1ff, %esi # imm = 0x1FF
leaq -0x40(%rbp), %rcx
callq 0x142b0
addq $0x110, %rsp # imm = 0x110
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_set_error:
push rbp
mov rbp, rsp
sub rsp, 110h
test al, al
jz short loc_3080E
movaps [rbp+var_D0], xmm0
movaps [rbp+var_C0], xmm1
movaps [rbp+var_B0], xmm2
movaps [rbp+var_A0], xmm3
movaps [rbp+var_90], xmm4
movaps [rbp+var_80], xmm5
movaps [rbp+var_70], xmm6
movaps [rbp+var_60], xmm7
loc_3080E:
mov [rbp+var_D8], r9
mov [rbp+var_E0], r8
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
cmp [rbp+var_20], 0
jnz short loc_308A2
cmp [rbp+var_C], 7D0h
jb short loc_30861
cmp [rbp+var_C], 80Dh
ja short loc_30861
mov eax, [rbp+var_C]
sub eax, 7D0h
mov eax, eax
mov ecx, eax
lea rax, client_errors
mov rax, [rax+rcx*8]
mov [rbp+var_48], rax
jmp short loc_308A0
loc_30861:
cmp [rbp+var_C], 1388h
jb short loc_30890
cmp [rbp+var_C], 1397h
ja short loc_30890
mov eax, [rbp+var_C]
sub eax, 1388h
mov eax, eax
mov ecx, eax
lea rax, mariadb_client_errors
mov rax, [rax+rcx*8]
mov [rbp+var_48], rax
jmp short loc_3089E
loc_30890:
lea rax, client_errors
mov rax, [rax]
mov [rbp+var_48], rax
loc_3089E:
jmp short $+2
loc_308A0:
jmp short $+2
loc_308A2:
mov ecx, [rbp+var_C]
mov rax, [rbp+var_8]
mov [rax+90h], ecx
mov rdi, [rbp+var_8]
add rdi, 297h
mov rsi, [rbp+var_18]
mov edx, 5
call ma_strmake
lea rax, [rbp+var_40]
lea rcx, [rbp+var_100]
mov [rax+10h], rcx
lea rcx, [rbp+arg_0]
mov [rax+8], rcx
mov dword ptr [rax+4], 30h ; '0'
mov dword ptr [rax], 20h ; ' '
mov rax, [rbp+var_8]
add rax, 97h
mov [rbp+var_108], rax
cmp [rbp+var_20], 0
jz short loc_30911
mov rax, [rbp+var_20]
mov [rbp+var_110], rax
jmp short loc_3091C
loc_30911:
mov rax, [rbp+var_48]
mov [rbp+var_110], rax
loc_3091C:
mov rdi, [rbp+var_108]
mov rdx, [rbp+var_110]
mov esi, 1FFh
lea rcx, [rbp+var_40]
call _vsnprintf
add rsp, 110h
pop rbp
retn
| long long my_set_error(long long a1, unsigned int a2, long long a3, long long a4, ...)
{
long long v5; // [rsp+8h] [rbp-108h]
char *v6; // [rsp+C8h] [rbp-48h]
va_list va; // [rsp+D0h] [rbp-40h] BYREF
long long v8; // [rsp+F0h] [rbp-20h]
long long v9; // [rsp+F8h] [rbp-18h]
unsigned int v10; // [rsp+104h] [rbp-Ch]
long long v11; // [rsp+108h] [rbp-8h]
v11 = a1;
v10 = a2;
v9 = a3;
v8 = a4;
if ( !a4 )
{
if ( v10 < 0x7D0 || v10 > 0x80D )
{
if ( v10 < 0x1388 || v10 > 0x1397 )
v6 = client_errors[0];
else
v6 = mariadb_client_errors[v10 - 5000];
}
else
{
v6 = client_errors[v10 - 2000];
}
}
*(_DWORD *)(v11 + 144) = v10;
ma_strmake(v11 + 663, v9, 5LL);
va_start(va, a4);
v5 = v11 + 151;
if ( v8 )
return vsnprintf(v5, 511LL, v8, va);
else
return vsnprintf(v5, 511LL, v6, va);
}
| my_set_error:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x110
TEST AL,AL
JZ 0x0013080e
MOVAPS xmmword ptr [RBP + -0xd0],XMM0
MOVAPS xmmword ptr [RBP + -0xc0],XMM1
MOVAPS xmmword ptr [RBP + -0xb0],XMM2
MOVAPS xmmword ptr [RBP + -0xa0],XMM3
MOVAPS xmmword ptr [RBP + -0x90],XMM4
MOVAPS xmmword ptr [RBP + -0x80],XMM5
MOVAPS xmmword ptr [RBP + -0x70],XMM6
MOVAPS xmmword ptr [RBP + -0x60],XMM7
LAB_0013080e:
MOV qword ptr [RBP + -0xd8],R9
MOV qword ptr [RBP + -0xe0],R8
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
CMP qword ptr [RBP + -0x20],0x0
JNZ 0x001308a2
CMP dword ptr [RBP + -0xc],0x7d0
JC 0x00130861
CMP dword ptr [RBP + -0xc],0x80d
JA 0x00130861
MOV EAX,dword ptr [RBP + -0xc]
SUB EAX,0x7d0
MOV EAX,EAX
MOV ECX,EAX
LEA RAX,[0x180eb0]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x48],RAX
JMP 0x001308a0
LAB_00130861:
CMP dword ptr [RBP + -0xc],0x1388
JC 0x00130890
CMP dword ptr [RBP + -0xc],0x1397
JA 0x00130890
MOV EAX,dword ptr [RBP + -0xc]
SUB EAX,0x1388
MOV EAX,EAX
MOV ECX,EAX
LEA RAX,[0x1810b0]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x48],RAX
JMP 0x0013089e
LAB_00130890:
LEA RAX,[0x180eb0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x48],RAX
LAB_0013089e:
JMP 0x001308a0
LAB_001308a0:
JMP 0x001308a2
LAB_001308a2:
MOV ECX,dword ptr [RBP + -0xc]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x90],ECX
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x297
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,0x5
CALL 0x0014c650
LEA RAX,[RBP + -0x40]
LEA RCX,[RBP + -0x100]
MOV qword ptr [RAX + 0x10],RCX
LEA RCX,[RBP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RAX + 0x4],0x30
MOV dword ptr [RAX],0x20
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x97
MOV qword ptr [RBP + -0x108],RAX
CMP qword ptr [RBP + -0x20],0x0
JZ 0x00130911
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x110],RAX
JMP 0x0013091c
LAB_00130911:
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x110],RAX
LAB_0013091c:
MOV RDI,qword ptr [RBP + -0x108]
MOV RDX,qword ptr [RBP + -0x110]
MOV ESI,0x1ff
LEA RCX,[RBP + -0x40]
CALL 0x001142b0
ADD RSP,0x110
POP RBP
RET
|
void my_set_error(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
long param_9,uint param_10,int8 param_11,char *param_12,int8 param_13,
int8 param_14)
{
char in_AL;
char *local_118;
int1 local_108 [32];
int8 local_e8;
int8 local_e0;
int8 local_d8;
int8 local_c8;
int8 local_b8;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
char *local_50;
int4 local_48;
int4 local_44;
int1 *local_40;
int1 *local_38;
char *local_28;
int8 local_20;
uint local_14;
long local_10;
if (in_AL != '\0') {
local_d8 = param_1;
local_c8 = param_2;
local_b8 = param_3;
local_a8 = param_4;
local_98 = param_5;
local_88 = param_6;
local_78 = param_7;
local_68 = param_8;
}
if (param_12 == (char *)0x0) {
if ((param_10 < 2000) || (0x80d < param_10)) {
if ((param_10 < 5000) || (0x1397 < param_10)) {
local_50 = client_errors;
}
else {
local_50 = *(char **)(mariadb_client_errors + (ulong)(param_10 - 5000) * 8);
}
}
else {
local_50 = (&client_errors)[param_10 - 2000];
}
}
*(uint *)(param_9 + 0x90) = param_10;
local_e8 = param_13;
local_e0 = param_14;
local_28 = param_12;
local_20 = param_11;
local_14 = param_10;
local_10 = param_9;
ma_strmake(param_9 + 0x297,param_11,5);
local_38 = local_108;
local_40 = &stack0x00000008;
local_44 = 0x30;
local_48 = 0x20;
if (local_28 == (char *)0x0) {
local_118 = local_50;
}
else {
local_118 = local_28;
}
vsnprintf((char *)(local_10 + 0x97),0x1ff,local_118,&local_48);
return;
}
| |
44,737 | minja::Value::to_int() const | monkey531[P]llama/common/minja.hpp | int64_t to_int() const {
if (is_null()) return 0;
if (is_boolean()) return get<bool>() ? 1 : 0;
if (is_number()) return static_cast<int64_t>(get<double>());
if (is_string()) {
try {
return std::stol(get<std::string>());
} catch (const std::exception &) {
return 0;
}
}
return 0;
} | O3 | cpp | minja::Value::to_int() const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rsi
cmpq $0x0, 0x20(%rdi)
movb 0x40(%rdi), %al
jne 0xb0c3c
cmpq $0x0, 0x10(%rsi)
jne 0xb0c3c
testb %al, %al
jne 0xb0c3c
cmpq $0x0, 0x30(%rsi)
jne 0xb0c3c
xorl %ebx, %ebx
jmp 0xb0cde
cmpb $0x4, %al
jne 0xb0c50
movq %rsi, %rdi
callq 0x87072
movzbl %al, %ebx
jmp 0xb0cde
leal -0x5(%rax), %ecx
cmpb $0x2, %cl
ja 0xb0c67
movq %rsi, %rdi
callq 0x861e8
cvttsd2si %xmm0, %rbx
jmp 0xb0cde
cmpb $0x3, %al
jne 0xb0c35
leaq 0x8(%rsp), %rdi
callq 0x87182
movq 0x8(%rsp), %r15
callq 0x1b060
movq %rax, %r14
movl (%rax), %ebp
movl $0x0, (%rax)
leaq 0x28(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
movl $0xa, %edx
callq 0x1bc30
cmpq %r15, (%r12)
je 0xb0cee
movq %rax, %rbx
movl (%r14), %eax
testl %eax, %eax
je 0xb0cc0
cmpl $0x22, %eax
jne 0xb0cc3
leaq 0x422ae(%rip), %rdi # 0xf2f69
callq 0x1bc80
movl %ebp, (%r14)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb0cde
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b8b0
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x42274(%rip), %rdi # 0xf2f69
callq 0x1b540
movq %rdx, %r15
movq %rax, %rbx
jmp 0xb0d2c
movq %rdx, %r15
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0xb0d11
movl %ebp, (%r14)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb0d2c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b8b0
movq %rbx, %rdi
cmpl $0x1, %r15d
jne 0xb0d44
callq 0x1b380
callq 0x1be30
jmp 0xb0c35
callq 0x1bf70
nop
| _ZNK5minja5Value6to_intEv:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 30h
mov rsi, rdi
cmp qword ptr [rdi+20h], 0
mov al, [rdi+40h]
jnz short loc_B0C3C
cmp qword ptr [rsi+10h], 0
jnz short loc_B0C3C
test al, al
jnz short loc_B0C3C
cmp qword ptr [rsi+30h], 0
jnz short loc_B0C3C
loc_B0C35:
xor ebx, ebx
jmp loc_B0CDE
loc_B0C3C:
cmp al, 4
jnz short loc_B0C50
mov rdi, rsi
call _ZNK5minja5Value3getIbEET_v; minja::Value::get<bool>(void)
movzx ebx, al
jmp loc_B0CDE
loc_B0C50:
lea ecx, [rax-5]
cmp cl, 2
ja short loc_B0C67
mov rdi, rsi
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
cvttsd2si rbx, xmm0
jmp short loc_B0CDE
loc_B0C67:
cmp al, 3
jnz short loc_B0C35
lea rdi, [rsp+58h+var_50]
call _ZNK5minja5Value3getINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEET_v; minja::Value::get<std::string>(void)
mov r15, [rsp+58h+var_50]
call ___errno_location
mov r14, rax
mov ebp, [rax]
mov dword ptr [rax], 0
lea r12, [rsp+58h+var_30]
mov rdi, r15
mov rsi, r12
mov edx, 0Ah
call _strtol
cmp [r12], r15
jz short loc_B0CEE
mov rbx, rax
mov eax, [r14]
test eax, eax
jz short loc_B0CC0
cmp eax, 22h ; '"'
jnz short loc_B0CC3
lea rdi, aStol; "stol"
call __ZSt20__throw_out_of_rangePKc; std::__throw_out_of_range(char const*)
loc_B0CC0:
mov [r14], ebp
loc_B0CC3:
lea rax, [rsp+58h+var_40]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_B0CDE
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_B0CDE:
mov rax, rbx
add rsp, 30h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_B0CEE:
lea rdi, aStol; "stol"
call __ZSt24__throw_invalid_argumentPKc; std::__throw_invalid_argument(char const*)
mov r15, rdx
mov rbx, rax
jmp short loc_B0D2C
mov r15, rdx
mov rbx, rax
cmp dword ptr [r14], 0
jnz short loc_B0D11
mov [r14], ebp
loc_B0D11:
lea rax, [rsp+58h+var_40]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_B0D2C
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_B0D2C:
mov rdi, rbx; void *
cmp r15d, 1
jnz short loc_B0D44
call ___cxa_begin_catch
call ___cxa_end_catch
jmp loc_B0C35
loc_B0D44:
call __Unwind_Resume
| long long minja::Value::to_int(minja::Value *this, double a2)
{
char v2; // al
long long v3; // rbx
long long *v4; // r15
int *v5; // r14
int v6; // ebp
long long v7; // rax
void *v9; // rdi
int v10; // edx
long long *v11; // [rsp+8h] [rbp-50h] BYREF
long long v12; // [rsp+18h] [rbp-40h] BYREF
long long *v13; // [rsp+28h] [rbp-30h] BYREF
v2 = *((_BYTE *)this + 64);
if ( !*((_QWORD *)this + 4) && !*((_QWORD *)this + 2) && !v2 && !*((_QWORD *)this + 6) )
return 0LL;
if ( v2 == 4 )
return (unsigned __int8)minja::Value::get<bool>(this);
if ( (unsigned __int8)(v2 - 5) <= 2u )
return (unsigned int)(int)minja::Value::get<double>(this);
if ( v2 != 3 )
return 0LL;
minja::Value::get<std::string>((long long)&v11, this);
v4 = v11;
v5 = (int *)__errno_location(a2);
v6 = *v5;
*v5 = 0;
v7 = strtol(v4, &v13, 10LL);
if ( v13 == v4 )
{
v9 = (void *)std::__throw_invalid_argument("stol");
if ( v10 != 1 )
_Unwind_Resume(v9);
__cxa_begin_catch(v9);
__cxa_end_catch();
return 0LL;
}
v3 = v7;
if ( *v5 )
{
if ( *v5 == 34 )
std::__throw_out_of_range("stol");
}
else
{
*v5 = v6;
}
if ( v11 != &v12 )
operator delete(v11, v12 + 1);
return v3;
}
| to_int:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x30
MOV RSI,RDI
CMP qword ptr [RDI + 0x20],0x0
MOV AL,byte ptr [RDI + 0x40]
JNZ 0x001b0c3c
CMP qword ptr [RSI + 0x10],0x0
JNZ 0x001b0c3c
TEST AL,AL
JNZ 0x001b0c3c
CMP qword ptr [RSI + 0x30],0x0
JNZ 0x001b0c3c
LAB_001b0c35:
XOR EBX,EBX
JMP 0x001b0cde
LAB_001b0c3c:
CMP AL,0x4
JNZ 0x001b0c50
MOV RDI,RSI
CALL 0x00187072
MOVZX EBX,AL
JMP 0x001b0cde
LAB_001b0c50:
LEA ECX,[RAX + -0x5]
CMP CL,0x2
JA 0x001b0c67
MOV RDI,RSI
CALL 0x001861e8
CVTTSD2SI RBX,XMM0
JMP 0x001b0cde
LAB_001b0c67:
CMP AL,0x3
JNZ 0x001b0c35
LAB_001b0c6b:
LEA RDI,[RSP + 0x8]
CALL 0x00187182
MOV R15,qword ptr [RSP + 0x8]
CALL 0x0011b060
MOV R14,RAX
MOV EBP,dword ptr [RAX]
MOV dword ptr [RAX],0x0
LEA R12,[RSP + 0x28]
MOV RDI,R15
MOV RSI,R12
MOV EDX,0xa
CALL 0x0011bc30
CMP qword ptr [R12],R15
JZ 0x001b0cee
MOV RBX,RAX
MOV EAX,dword ptr [R14]
TEST EAX,EAX
JZ 0x001b0cc0
CMP EAX,0x22
JNZ 0x001b0cc3
LAB_001b0cb4:
LEA RDI,[0x1f2f69]
CALL 0x0011bc80
LAB_001b0cc0:
MOV dword ptr [R14],EBP
LAB_001b0cc3:
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001b0cde
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011b8b0
LAB_001b0cde:
MOV RAX,RBX
ADD RSP,0x30
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001b0cee:
LEA RDI,[0x1f2f69]
CALL 0x0011b540
LAB_001b0cfa:
MOV R15,RDX
MOV RBX,RAX
JMP 0x001b0d2c
LAB_001b0d2c:
MOV RDI,RBX
CMP R15D,0x1
JNZ 0x001b0d44
CALL 0x0011b380
CALL 0x0011be30
JMP 0x001b0c35
LAB_001b0d44:
CALL 0x0011bf70
|
/* minja::Value::to_int() const */
ulong __thiscall minja::Value::to_int(Value *this)
{
Value VVar1;
int iVar2;
bool bVar3;
int *piVar4;
ulong uVar5;
double dVar6;
int1 auVar7 [12];
long *local_50;
long local_40 [2];
long *local_30;
VVar1 = this[0x40];
if ((((*(long *)(this + 0x20) == 0) && (*(long *)(this + 0x10) == 0)) && (VVar1 == (Value)0x0)) &&
(*(long *)(this + 0x30) == 0)) {
return 0;
}
if (VVar1 == (Value)0x4) {
bVar3 = get<bool>(this);
return (ulong)bVar3;
}
if ((byte)((char)VVar1 - 5U) < 3) {
dVar6 = get<double>(this);
return (long)dVar6;
}
if (VVar1 != (Value)0x3) {
return 0;
}
/* try { // try from 001b0c6b to 001b0c74 has its CatchHandler @ 001b0cfa */
get<std::__cxx11::string>();
piVar4 = __errno_location();
iVar2 = *piVar4;
*piVar4 = 0;
uVar5 = strtol((char *)local_50,(char **)&local_30,10);
if (local_30 == local_50) {
auVar7 = std::__throw_invalid_argument("stol");
/* catch(type#1 @ 00230930, ) { ... } // from try @ 001b0c6b with catch @
001b0cfa */
if (auVar7._8_4_ == 1) {
__cxa_begin_catch();
__cxa_end_catch();
return 0;
}
/* WARNING: Subroutine does not return */
_Unwind_Resume(auVar7._0_8_);
}
if (*piVar4 != 0) {
if (*piVar4 != 0x22) goto LAB_001b0cc3;
/* try { // try from 001b0cb4 to 001b0cf9 has its CatchHandler @ 001b0d02 */
std::__throw_out_of_range("stol");
}
*piVar4 = iVar2;
LAB_001b0cc3:
if (local_50 != local_40) {
operator_delete(local_50,local_40[0] + 1);
return uVar5;
}
return uVar5;
}
| |
44,738 | fmt::v10::detail::fractional_part_rounding_thresholds(int) | AlayaLite/build_O0/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h | constexpr auto fractional_part_rounding_thresholds(int index) -> uint32_t {
// For checking rounding thresholds.
// The kth entry is chosen to be the smallest integer such that the
// upper 32-bits of 10^(k+1) times it is strictly bigger than 5 * 10^k.
// It is equal to ceil(2^31 + 2^32/10^(k + 1)).
// These are stored in a string literal because we cannot have static arrays
// in constexpr functions and non-static ones are poorly optimized.
return U"\x9999999a\x828f5c29\x80418938\x80068db9\x8000a7c6\x800010c7"
U"\x800001ae\x8000002b"[index];
} | O0 | c | fmt::v10::detail::fractional_part_rounding_thresholds(int):
movl %edi, -0x4(%rsp)
movslq -0x4(%rsp), %rcx
leaq 0x66ce4(%rip), %rax # 0x11ad54
movl (%rax,%rcx,4), %eax
retq
nopw %cs:(%rax,%rax)
nop
| _ZN3fmt3v106detail35fractional_part_rounding_thresholdsEi:
mov [rsp+var_4], edi
movsxd rcx, [rsp+var_4]
lea rax, unk_11AD54
mov eax, [rax+rcx*4]
retn
| long long fmt::v10::detail::fractional_part_rounding_thresholds(fmt::v10::detail *this)
{
return dword_11AD54[(int)this];
}
| fractional_part_rounding_thresholds:
MOV dword ptr [RSP + -0x4],EDI
MOVSXD RCX,dword ptr [RSP + -0x4]
LEA RAX,[0x21ad54]
MOV EAX,dword ptr [RAX + RCX*0x4]
RET
|
/* fmt::v10::detail::fractional_part_rounding_thresholds(int) */
int4 fmt::v10::detail::fractional_part_rounding_thresholds(int param_1)
{
return *(int4 *)(&DAT_0021ad54 + (long)param_1 * 4);
}
| |
44,739 | my_hash_update | eloqsql/mysys/hash.c | my_bool my_hash_update(HASH *hash, uchar *record, uchar *old_key,
size_t old_key_length)
{
uint new_index, new_pos_index, org_index, records, idx;
size_t length, empty, blength;
my_hash_value_type hash_nr;
HASH_LINK org_link,*data,*previous,*pos;
uchar *new_key;
DBUG_ENTER("my_hash_update");
new_key= (uchar*) my_hash_key(hash, record, &length, 1);
hash_nr= hash->hash_function(hash->charset, new_key, length);
if (HASH_UNIQUE & hash->flags)
{
HASH_SEARCH_STATE state;
uchar *found;
if ((found= my_hash_first_from_hash_value(hash, hash_nr, new_key, length,
&state)))
{
do
{
if (found != record)
DBUG_RETURN(1); /* Duplicate entry */
}
while ((found= my_hash_next(hash, new_key, length, &state)));
}
}
data=dynamic_element(&hash->array,0,HASH_LINK*);
blength=hash->blength; records=hash->records;
/* Search after record with key */
idx= my_hash_mask(hash->hash_function(hash->charset, old_key,
(old_key_length ? old_key_length :
hash->key_length)),
blength, records);
org_index= idx;
new_index= my_hash_mask(hash_nr, blength, records);
previous=0;
for (;;)
{
if ((pos= data+idx)->data == record)
break;
previous=pos;
if ((idx=pos->next) == NO_RECORD)
DBUG_RETURN(1); /* Not found in links */
}
if (org_index == new_index)
{
data[idx].hash_nr= hash_nr; /* Hash number may have changed */
DBUG_RETURN(0); /* Record is in right position */
}
org_link= *pos;
empty=idx;
/* Relink record from current chain */
if (!previous)
{
if (pos->next != NO_RECORD)
{
empty=pos->next;
*pos= data[pos->next];
}
}
else
previous->next=pos->next; /* unlink pos */
/* Move data to correct position */
if (new_index == empty)
{
/*
At this point record is unlinked from the old chain, thus it holds
random position. By the chance this position is equal to position
for the first element in the new chain. That means updated record
is the only record in the new chain.
*/
if (empty != idx)
{
/*
Record was moved while unlinking it from the old chain.
Copy data to a new position.
*/
data[empty]= org_link;
}
data[empty].next= NO_RECORD;
data[empty].hash_nr= hash_nr;
DBUG_RETURN(0);
}
pos=data+new_index;
new_pos_index= my_hash_rec_mask(pos, blength, records);
if (new_index != new_pos_index)
{ /* Other record in wrong position */
data[empty]= *pos;
movelink(data,new_index,new_pos_index, (uint) empty);
org_link.next=NO_RECORD;
data[new_index]= org_link;
data[new_index].hash_nr= hash_nr;
}
else
{ /* Link in chain at right position */
org_link.next=data[new_index].next;
data[empty]=org_link;
data[empty].hash_nr= hash_nr;
data[new_index].next= (uint) empty;
}
DBUG_RETURN(0);
} | O0 | c | my_hash_update:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x48(%rbp), %rdx
movl $0x1, %ecx
callq 0x6cfd0
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x68(%rcx), %rdi
movq -0x90(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq *%rax
movl %eax, -0x5c(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x6d55a
movq -0x10(%rbp), %rdi
movl -0x5c(%rbp), %esi
movq -0x90(%rbp), %rdx
movq -0x48(%rbp), %rcx
leaq -0x94(%rbp), %r8
callq 0x6c7b0
movq %rax, -0xa0(%rbp)
cmpq $0x0, %rax
je 0x6d558
jmp 0x6d514
movq -0xa0(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x6d52c
jmp 0x6d523
movb $0x1, -0x1(%rbp)
jmp 0x6d872
jmp 0x6d52e
movq -0x10(%rbp), %rdi
movq -0x90(%rbp), %rsi
movq -0x48(%rbp), %rdx
leaq -0x94(%rbp), %rcx
callq 0x6c9d0
movq %rax, -0xa0(%rbp)
cmpq $0x0, %rax
jne 0x6d514
jmp 0x6d558
jmp 0x6d55a
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0xb0(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xa8(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x6d5ba
movq -0x28(%rbp), %rax
movq %rax, -0xc0(%rbp)
jmp 0x6d5c9
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xc0(%rbp)
movq -0xb8(%rbp), %rax
movq -0xa8(%rbp), %rsi
movq -0xb0(%rbp), %rdi
movq -0xc0(%rbp), %rdx
callq *%rax
movl %eax, %edi
movq -0x58(%rbp), %rsi
movl -0x38(%rbp), %eax
movl %eax, %edx
callq 0x6c8b0
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x5c(%rbp), %edi
movq -0x58(%rbp), %rsi
movl -0x38(%rbp), %eax
movl %eax, %edx
callq 0x6c8b0
movl %eax, -0x2c(%rbp)
movq $0x0, -0x80(%rbp)
movq -0x78(%rbp), %rax
movl -0x3c(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x88(%rbp)
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x6d63d
jmp 0x6d666
movq -0x88(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x88(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
cmpl $-0x1, %eax
jne 0x6d664
jmp 0x6d65b
movb $0x1, -0x1(%rbp)
jmp 0x6d872
jmp 0x6d61c
movl -0x34(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jne 0x6d68b
movl -0x5c(%rbp), %ecx
movq -0x78(%rbp), %rax
movl -0x3c(%rbp), %edx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x4(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x6d872
movq -0x88(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x70(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x68(%rbp)
movl -0x3c(%rbp), %eax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x80(%rbp)
jne 0x6d6f3
movq -0x88(%rbp), %rax
cmpl $-0x1, (%rax)
je 0x6d6f1
movq -0x88(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x50(%rbp)
movq -0x88(%rbp), %rax
movq -0x78(%rbp), %rcx
movq -0x88(%rbp), %rdx
movl (%rdx), %edx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
jmp 0x6d702
movq -0x88(%rbp), %rax
movl (%rax), %ecx
movq -0x80(%rbp), %rax
movl %ecx, (%rax)
movl -0x2c(%rbp), %eax
cmpq -0x50(%rbp), %rax
jne 0x6d768
movq -0x50(%rbp), %rax
movl -0x3c(%rbp), %ecx
cmpq %rcx, %rax
je 0x6d735
movq -0x78(%rbp), %rax
movq -0x50(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x70(%rbp), %rcx
movq %rcx, (%rax)
movq -0x68(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x78(%rbp), %rax
movq -0x50(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl $0xffffffff, (%rax) # imm = 0xFFFFFFFF
movl -0x5c(%rbp), %ecx
movq -0x78(%rbp), %rax
movq -0x50(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x4(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x6d872
movq -0x78(%rbp), %rax
movl -0x2c(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rdi
movq -0x58(%rbp), %rsi
movl -0x38(%rbp), %eax
movl %eax, %edx
callq 0x6c9a0
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x30(%rbp), %eax
je 0x6d810
movq -0x78(%rbp), %rax
movq -0x50(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x88(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x78(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl -0x30(%rbp), %edx
movq -0x50(%rbp), %rax
movl %eax, %ecx
callq 0x6d040
movl $0xffffffff, -0x70(%rbp) # imm = 0xFFFFFFFF
movq -0x78(%rbp), %rax
movl -0x2c(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x70(%rbp), %rcx
movq %rcx, (%rax)
movq -0x68(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x5c(%rbp), %ecx
movq -0x78(%rbp), %rax
movl -0x2c(%rbp), %edx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x4(%rax)
jmp 0x6d86c
movq -0x78(%rbp), %rax
movl -0x2c(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, -0x70(%rbp)
movq -0x78(%rbp), %rax
movq -0x50(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x70(%rbp), %rcx
movq %rcx, (%rax)
movq -0x68(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x5c(%rbp), %ecx
movq -0x78(%rbp), %rax
movq -0x50(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x4(%rax)
movq -0x50(%rbp), %rax
movl %eax, %ecx
movq -0x78(%rbp), %rax
movl -0x2c(%rbp), %edx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
jmp 0x6d86e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0xc0, %rsp
popq %rbp
retq
nop
| my_hash_update:
push rbp
mov rbp, rsp
sub rsp, 0C0h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
lea rdx, [rbp+var_48]
mov ecx, 1
call my_hash_key
mov [rbp+var_90], rax
mov rax, [rbp+var_10]
mov rax, [rax+58h]
mov rcx, [rbp+var_10]
mov rdi, [rcx+68h]
mov rsi, [rbp+var_90]
mov rdx, [rbp+var_48]
call rax
mov [rbp+var_5C], eax
mov rax, [rbp+var_10]
mov eax, [rax+20h]
and eax, 1
cmp eax, 0
jz short loc_6D55A
mov rdi, [rbp+var_10]
mov esi, [rbp+var_5C]
mov rdx, [rbp+var_90]
mov rcx, [rbp+var_48]
lea r8, [rbp+var_94]
call my_hash_first_from_hash_value
mov [rbp+var_A0], rax
cmp rax, 0
jz short loc_6D558
jmp short $+2
loc_6D514:
mov rax, [rbp+var_A0]
cmp rax, [rbp+var_18]
jz short loc_6D52C
jmp short $+2
loc_6D523:
mov [rbp+var_1], 1
jmp loc_6D872
loc_6D52C:
jmp short $+2
loc_6D52E:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_90]
mov rdx, [rbp+var_48]
lea rcx, [rbp+var_94]
call my_hash_next
mov [rbp+var_A0], rax
cmp rax, 0
jnz short loc_6D514
jmp short $+2
loc_6D558:
jmp short $+2
loc_6D55A:
mov rax, [rbp+var_10]
mov rax, [rax+28h]
mov [rbp+var_78], rax
mov rax, [rbp+var_10]
mov rax, [rax+10h]
mov [rbp+var_58], rax
mov rax, [rbp+var_10]
mov rax, [rax+18h]
mov [rbp+var_38], eax
mov rax, [rbp+var_10]
mov rax, [rax+58h]
mov [rbp+var_B8], rax
mov rax, [rbp+var_10]
mov rax, [rax+68h]
mov [rbp+var_B0], rax
mov rax, [rbp+var_20]
mov [rbp+var_A8], rax
cmp [rbp+var_28], 0
jz short loc_6D5BA
mov rax, [rbp+var_28]
mov [rbp+var_C0], rax
jmp short loc_6D5C9
loc_6D5BA:
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rbp+var_C0], rax
loc_6D5C9:
mov rax, [rbp+var_B8]
mov rsi, [rbp+var_A8]
mov rdi, [rbp+var_B0]
mov rdx, [rbp+var_C0]
call rax
mov edi, eax
mov rsi, [rbp+var_58]
mov eax, [rbp+var_38]
mov edx, eax
call my_hash_mask
mov [rbp+var_3C], eax
mov eax, [rbp+var_3C]
mov [rbp+var_34], eax
mov edi, [rbp+var_5C]
mov rsi, [rbp+var_58]
mov eax, [rbp+var_38]
mov edx, eax
call my_hash_mask
mov [rbp+var_2C], eax
mov [rbp+var_80], 0
loc_6D61C:
mov rax, [rbp+var_78]
mov ecx, [rbp+var_3C]
shl rcx, 4
add rax, rcx
mov [rbp+var_88], rax
mov rax, [rax+8]
cmp rax, [rbp+var_18]
jnz short loc_6D63D
jmp short loc_6D666
loc_6D63D:
mov rax, [rbp+var_88]
mov [rbp+var_80], rax
mov rax, [rbp+var_88]
mov eax, [rax]
mov [rbp+var_3C], eax
cmp eax, 0FFFFFFFFh
jnz short loc_6D664
jmp short $+2
loc_6D65B:
mov [rbp+var_1], 1
jmp loc_6D872
loc_6D664:
jmp short loc_6D61C
loc_6D666:
mov eax, [rbp+var_34]
cmp eax, [rbp+var_2C]
jnz short loc_6D68B
mov ecx, [rbp+var_5C]
mov rax, [rbp+var_78]
mov edx, [rbp+var_3C]
shl rdx, 4
add rax, rdx
mov [rax+4], ecx
mov [rbp+var_1], 0
jmp loc_6D872
loc_6D68B:
mov rax, [rbp+var_88]
mov rcx, [rax]
mov [rbp+var_70], rcx
mov rax, [rax+8]
mov [rbp+var_68], rax
mov eax, [rbp+var_3C]
mov [rbp+var_50], rax
cmp [rbp+var_80], 0
jnz short loc_6D6F3
mov rax, [rbp+var_88]
cmp dword ptr [rax], 0FFFFFFFFh
jz short loc_6D6F1
mov rax, [rbp+var_88]
mov eax, [rax]
mov [rbp+var_50], rax
mov rax, [rbp+var_88]
mov rcx, [rbp+var_78]
mov rdx, [rbp+var_88]
mov edx, [rdx]
shl rdx, 4
add rcx, rdx
mov rdx, [rcx]
mov [rax], rdx
mov rcx, [rcx+8]
mov [rax+8], rcx
loc_6D6F1:
jmp short loc_6D702
loc_6D6F3:
mov rax, [rbp+var_88]
mov ecx, [rax]
mov rax, [rbp+var_80]
mov [rax], ecx
loc_6D702:
mov eax, [rbp+var_2C]
cmp rax, [rbp+var_50]
jnz short loc_6D768
mov rax, [rbp+var_50]
mov ecx, [rbp+var_3C]
cmp rax, rcx
jz short loc_6D735
mov rax, [rbp+var_78]
mov rcx, [rbp+var_50]
shl rcx, 4
add rax, rcx
mov rcx, [rbp+var_70]
mov [rax], rcx
mov rcx, [rbp+var_68]
mov [rax+8], rcx
loc_6D735:
mov rax, [rbp+var_78]
mov rcx, [rbp+var_50]
shl rcx, 4
add rax, rcx
mov dword ptr [rax], 0FFFFFFFFh
mov ecx, [rbp+var_5C]
mov rax, [rbp+var_78]
mov rdx, [rbp+var_50]
shl rdx, 4
add rax, rdx
mov [rax+4], ecx
mov [rbp+var_1], 0
jmp loc_6D872
loc_6D768:
mov rax, [rbp+var_78]
mov ecx, [rbp+var_2C]
shl rcx, 4
add rax, rcx
mov [rbp+var_88], rax
mov rdi, [rbp+var_88]
mov rsi, [rbp+var_58]
mov eax, [rbp+var_38]
mov edx, eax
call my_hash_rec_mask
mov [rbp+var_30], eax
mov eax, [rbp+var_2C]
cmp eax, [rbp+var_30]
jz short loc_6D810
mov rax, [rbp+var_78]
mov rcx, [rbp+var_50]
shl rcx, 4
add rax, rcx
mov rcx, [rbp+var_88]
mov rdx, [rcx]
mov [rax], rdx
mov rcx, [rcx+8]
mov [rax+8], rcx
mov rdi, [rbp+var_78]
mov esi, [rbp+var_2C]
mov edx, [rbp+var_30]
mov rax, [rbp+var_50]
mov ecx, eax
call movelink
mov dword ptr [rbp+var_70], 0FFFFFFFFh
mov rax, [rbp+var_78]
mov ecx, [rbp+var_2C]
shl rcx, 4
add rax, rcx
mov rcx, [rbp+var_70]
mov [rax], rcx
mov rcx, [rbp+var_68]
mov [rax+8], rcx
mov ecx, [rbp+var_5C]
mov rax, [rbp+var_78]
mov edx, [rbp+var_2C]
shl rdx, 4
add rax, rdx
mov [rax+4], ecx
jmp short loc_6D86C
loc_6D810:
mov rax, [rbp+var_78]
mov ecx, [rbp+var_2C]
shl rcx, 4
add rax, rcx
mov eax, [rax]
mov dword ptr [rbp+var_70], eax
mov rax, [rbp+var_78]
mov rcx, [rbp+var_50]
shl rcx, 4
add rax, rcx
mov rcx, [rbp+var_70]
mov [rax], rcx
mov rcx, [rbp+var_68]
mov [rax+8], rcx
mov ecx, [rbp+var_5C]
mov rax, [rbp+var_78]
mov rdx, [rbp+var_50]
shl rdx, 4
add rax, rdx
mov [rax+4], ecx
mov rax, [rbp+var_50]
mov ecx, eax
mov rax, [rbp+var_78]
mov edx, [rbp+var_2C]
shl rdx, 4
add rax, rdx
mov [rax], ecx
loc_6D86C:
jmp short $+2
loc_6D86E:
mov [rbp+var_1], 0
loc_6D872:
mov al, [rbp+var_1]
add rsp, 0C0h
pop rbp
retn
| char my_hash_update(_QWORD *a1, long long a2, long long a3, long long a4)
{
unsigned int v4; // eax
unsigned int *v5; // rax
_QWORD *v6; // rcx
_QWORD *v7; // rax
_QWORD *v8; // rax
unsigned int *v9; // rcx
_QWORD *v10; // rax
_QWORD *v11; // rax
long long ( *v13)(long long, long long, long long); // [rsp+8h] [rbp-B8h]
long long v14; // [rsp+10h] [rbp-B0h]
long long v15; // [rsp+20h] [rbp-A0h]
unsigned int v16; // [rsp+2Ch] [rbp-94h] BYREF
long long v17; // [rsp+30h] [rbp-90h]
unsigned int *v18; // [rsp+38h] [rbp-88h]
_DWORD *v19; // [rsp+40h] [rbp-80h]
long long v20; // [rsp+48h] [rbp-78h]
long long v21; // [rsp+50h] [rbp-70h]
long long v22; // [rsp+58h] [rbp-68h]
unsigned int v23; // [rsp+64h] [rbp-5Ch]
unsigned long long v24; // [rsp+68h] [rbp-58h]
long long v25; // [rsp+70h] [rbp-50h]
long long v26; // [rsp+78h] [rbp-48h] BYREF
unsigned int v27; // [rsp+84h] [rbp-3Ch]
unsigned int v28; // [rsp+88h] [rbp-38h]
unsigned int v29; // [rsp+8Ch] [rbp-34h]
unsigned int v30; // [rsp+90h] [rbp-30h]
unsigned int v31; // [rsp+94h] [rbp-2Ch]
long long v32; // [rsp+98h] [rbp-28h]
long long v33; // [rsp+A0h] [rbp-20h]
long long v34; // [rsp+A8h] [rbp-18h]
_QWORD *v35; // [rsp+B0h] [rbp-10h]
v35 = a1;
v34 = a2;
v33 = a3;
v32 = a4;
v17 = my_hash_key((long long)a1, a2, &v26, 1);
v23 = ((long long ( *)(_QWORD, long long, long long))v35[11])(v35[13], v17, v26);
if ( (v35[4] & 1) != 0 && (v15 = my_hash_first_from_hash_value(v35, v23, v17, v26, &v16)) != 0 )
{
while ( v15 == v34 )
{
v15 = my_hash_next((long long)v35, v17, v26, &v16);
if ( !v15 )
goto LABEL_6;
}
return 1;
}
else
{
LABEL_6:
v20 = v35[5];
v24 = v35[2];
v28 = v35[3];
v13 = (long long ( *)(long long, long long, long long))v35[11];
v14 = v35[13];
if ( v32 )
v4 = v13(v14, v33, v32);
else
v4 = v13(v14, v33, v35[1]);
v27 = my_hash_mask(v4, v24, v28);
v29 = v27;
v31 = my_hash_mask(v23, v24, v28);
v19 = 0LL;
while ( 1 )
{
v18 = (unsigned int *)(16LL * v27 + v20);
if ( *((_QWORD *)v18 + 1) == v34 )
break;
v19 = v18;
v27 = *v18;
if ( v27 == -1 )
return 1;
}
if ( v29 == v31 )
{
*(_DWORD *)(16LL * v27 + v20 + 4) = v23;
return 0;
}
else
{
v21 = *(_QWORD *)v18;
v22 = *((_QWORD *)v18 + 1);
v25 = v27;
if ( v19 )
{
*v19 = *v18;
}
else if ( *v18 != -1 )
{
v25 = *v18;
v5 = v18;
v6 = (_QWORD *)(16LL * *v18 + v20);
*(_QWORD *)v18 = *v6;
*((_QWORD *)v5 + 1) = v6[1];
}
if ( v31 == v25 )
{
if ( v25 != v27 )
{
v7 = (_QWORD *)(16 * v25 + v20);
*v7 = v21;
v7[1] = v22;
}
*(_DWORD *)(16 * v25 + v20) = -1;
*(_DWORD *)(16 * v25 + v20 + 4) = v23;
return 0;
}
else
{
v18 = (unsigned int *)(16LL * v31 + v20);
v30 = my_hash_rec_mask((long long)v18, v24, v28);
if ( v31 == v30 )
{
LODWORD(v21) = *(_DWORD *)(16LL * v31 + v20);
v11 = (_QWORD *)(16 * v25 + v20);
*v11 = v21;
v11[1] = v22;
*(_DWORD *)(16 * v25 + v20 + 4) = v23;
*(_DWORD *)(16LL * v31 + v20) = v25;
}
else
{
v8 = (_QWORD *)(16 * v25 + v20);
v9 = v18;
*v8 = *(_QWORD *)v18;
v8[1] = *((_QWORD *)v9 + 1);
movelink(v20, v31, v30, v25);
LODWORD(v21) = -1;
v10 = (_QWORD *)(16LL * v31 + v20);
*v10 = v21;
v10[1] = v22;
*(_DWORD *)(16LL * v31 + v20 + 4) = v23;
}
return 0;
}
}
}
}
| my_hash_update:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xc0
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 RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
LEA RDX,[RBP + -0x48]
MOV ECX,0x1
CALL 0x0016cfd0
MOV qword ptr [RBP + -0x90],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x58]
MOV RCX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RCX + 0x68]
MOV RSI,qword ptr [RBP + -0x90]
MOV RDX,qword ptr [RBP + -0x48]
CALL RAX
MOV dword ptr [RBP + -0x5c],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x20]
AND EAX,0x1
CMP EAX,0x0
JZ 0x0016d55a
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x5c]
MOV RDX,qword ptr [RBP + -0x90]
MOV RCX,qword ptr [RBP + -0x48]
LEA R8,[RBP + -0x94]
CALL 0x0016c7b0
MOV qword ptr [RBP + -0xa0],RAX
CMP RAX,0x0
JZ 0x0016d558
JMP 0x0016d514
LAB_0016d514:
MOV RAX,qword ptr [RBP + -0xa0]
CMP RAX,qword ptr [RBP + -0x18]
JZ 0x0016d52c
JMP 0x0016d523
LAB_0016d523:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0016d872
LAB_0016d52c:
JMP 0x0016d52e
LAB_0016d52e:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x90]
MOV RDX,qword ptr [RBP + -0x48]
LEA RCX,[RBP + -0x94]
CALL 0x0016c9d0
MOV qword ptr [RBP + -0xa0],RAX
CMP RAX,0x0
JNZ 0x0016d514
JMP 0x0016d558
LAB_0016d558:
JMP 0x0016d55a
LAB_0016d55a:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x18]
MOV dword ptr [RBP + -0x38],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x58]
MOV qword ptr [RBP + -0xb8],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x68]
MOV qword ptr [RBP + -0xb0],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0xa8],RAX
CMP qword ptr [RBP + -0x28],0x0
JZ 0x0016d5ba
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0xc0],RAX
JMP 0x0016d5c9
LAB_0016d5ba:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0xc0],RAX
LAB_0016d5c9:
MOV RAX,qword ptr [RBP + -0xb8]
MOV RSI,qword ptr [RBP + -0xa8]
MOV RDI,qword ptr [RBP + -0xb0]
MOV RDX,qword ptr [RBP + -0xc0]
CALL RAX
MOV EDI,EAX
MOV RSI,qword ptr [RBP + -0x58]
MOV EAX,dword ptr [RBP + -0x38]
MOV EDX,EAX
CALL 0x0016c8b0
MOV dword ptr [RBP + -0x3c],EAX
MOV EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x34],EAX
MOV EDI,dword ptr [RBP + -0x5c]
MOV RSI,qword ptr [RBP + -0x58]
MOV EAX,dword ptr [RBP + -0x38]
MOV EDX,EAX
CALL 0x0016c8b0
MOV dword ptr [RBP + -0x2c],EAX
MOV qword ptr [RBP + -0x80],0x0
LAB_0016d61c:
MOV RAX,qword ptr [RBP + -0x78]
MOV ECX,dword ptr [RBP + -0x3c]
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RBP + -0x88],RAX
MOV RAX,qword ptr [RAX + 0x8]
CMP RAX,qword ptr [RBP + -0x18]
JNZ 0x0016d63d
JMP 0x0016d666
LAB_0016d63d:
MOV RAX,qword ptr [RBP + -0x88]
MOV qword ptr [RBP + -0x80],RAX
MOV RAX,qword ptr [RBP + -0x88]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x3c],EAX
CMP EAX,-0x1
JNZ 0x0016d664
JMP 0x0016d65b
LAB_0016d65b:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0016d872
LAB_0016d664:
JMP 0x0016d61c
LAB_0016d666:
MOV EAX,dword ptr [RBP + -0x34]
CMP EAX,dword ptr [RBP + -0x2c]
JNZ 0x0016d68b
MOV ECX,dword ptr [RBP + -0x5c]
MOV RAX,qword ptr [RBP + -0x78]
MOV EDX,dword ptr [RBP + -0x3c]
SHL RDX,0x4
ADD RAX,RDX
MOV dword ptr [RAX + 0x4],ECX
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0016d872
LAB_0016d68b:
MOV RAX,qword ptr [RBP + -0x88]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RBP + -0x70],RCX
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x68],RAX
MOV EAX,dword ptr [RBP + -0x3c]
MOV qword ptr [RBP + -0x50],RAX
CMP qword ptr [RBP + -0x80],0x0
JNZ 0x0016d6f3
MOV RAX,qword ptr [RBP + -0x88]
CMP dword ptr [RAX],-0x1
JZ 0x0016d6f1
MOV RAX,qword ptr [RBP + -0x88]
MOV EAX,dword ptr [RAX]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x88]
MOV RCX,qword ptr [RBP + -0x78]
MOV RDX,qword ptr [RBP + -0x88]
MOV EDX,dword ptr [RDX]
SHL RDX,0x4
ADD RCX,RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX],RDX
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
LAB_0016d6f1:
JMP 0x0016d702
LAB_0016d6f3:
MOV RAX,qword ptr [RBP + -0x88]
MOV ECX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x80]
MOV dword ptr [RAX],ECX
LAB_0016d702:
MOV EAX,dword ptr [RBP + -0x2c]
CMP RAX,qword ptr [RBP + -0x50]
JNZ 0x0016d768
MOV RAX,qword ptr [RBP + -0x50]
MOV ECX,dword ptr [RBP + -0x3c]
CMP RAX,RCX
JZ 0x0016d735
MOV RAX,qword ptr [RBP + -0x78]
MOV RCX,qword ptr [RBP + -0x50]
SHL RCX,0x4
ADD RAX,RCX
MOV RCX,qword ptr [RBP + -0x70]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x68]
MOV qword ptr [RAX + 0x8],RCX
LAB_0016d735:
MOV RAX,qword ptr [RBP + -0x78]
MOV RCX,qword ptr [RBP + -0x50]
SHL RCX,0x4
ADD RAX,RCX
MOV dword ptr [RAX],0xffffffff
MOV ECX,dword ptr [RBP + -0x5c]
MOV RAX,qword ptr [RBP + -0x78]
MOV RDX,qword ptr [RBP + -0x50]
SHL RDX,0x4
ADD RAX,RDX
MOV dword ptr [RAX + 0x4],ECX
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0016d872
LAB_0016d768:
MOV RAX,qword ptr [RBP + -0x78]
MOV ECX,dword ptr [RBP + -0x2c]
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RBP + -0x88],RAX
MOV RDI,qword ptr [RBP + -0x88]
MOV RSI,qword ptr [RBP + -0x58]
MOV EAX,dword ptr [RBP + -0x38]
MOV EDX,EAX
CALL 0x0016c9a0
MOV dword ptr [RBP + -0x30],EAX
MOV EAX,dword ptr [RBP + -0x2c]
CMP EAX,dword ptr [RBP + -0x30]
JZ 0x0016d810
MOV RAX,qword ptr [RBP + -0x78]
MOV RCX,qword ptr [RBP + -0x50]
SHL RCX,0x4
ADD RAX,RCX
MOV RCX,qword ptr [RBP + -0x88]
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX],RDX
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV RDI,qword ptr [RBP + -0x78]
MOV ESI,dword ptr [RBP + -0x2c]
MOV EDX,dword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x50]
MOV ECX,EAX
CALL 0x0016d040
MOV dword ptr [RBP + -0x70],0xffffffff
MOV RAX,qword ptr [RBP + -0x78]
MOV ECX,dword ptr [RBP + -0x2c]
SHL RCX,0x4
ADD RAX,RCX
MOV RCX,qword ptr [RBP + -0x70]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x68]
MOV qword ptr [RAX + 0x8],RCX
MOV ECX,dword ptr [RBP + -0x5c]
MOV RAX,qword ptr [RBP + -0x78]
MOV EDX,dword ptr [RBP + -0x2c]
SHL RDX,0x4
ADD RAX,RDX
MOV dword ptr [RAX + 0x4],ECX
JMP 0x0016d86c
LAB_0016d810:
MOV RAX,qword ptr [RBP + -0x78]
MOV ECX,dword ptr [RBP + -0x2c]
SHL RCX,0x4
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x70],EAX
MOV RAX,qword ptr [RBP + -0x78]
MOV RCX,qword ptr [RBP + -0x50]
SHL RCX,0x4
ADD RAX,RCX
MOV RCX,qword ptr [RBP + -0x70]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x68]
MOV qword ptr [RAX + 0x8],RCX
MOV ECX,dword ptr [RBP + -0x5c]
MOV RAX,qword ptr [RBP + -0x78]
MOV RDX,qword ptr [RBP + -0x50]
SHL RDX,0x4
ADD RAX,RDX
MOV dword ptr [RAX + 0x4],ECX
MOV RAX,qword ptr [RBP + -0x50]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x78]
MOV EDX,dword ptr [RBP + -0x2c]
SHL RDX,0x4
ADD RAX,RDX
MOV dword ptr [RAX],ECX
LAB_0016d86c:
JMP 0x0016d86e
LAB_0016d86e:
MOV byte ptr [RBP + -0x1],0x0
LAB_0016d872:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0xc0
POP RBP
RET
|
int1 my_hash_update(long param_1,long param_2,int8 param_3,long param_4)
{
int4 uVar1;
long lVar2;
uint *puVar3;
int8 *puVar4;
long local_c8;
int1 local_9c [4];
int8 local_98;
int8 *local_90;
uint *local_88;
long local_80;
int8 local_78;
int8 local_70;
int4 local_64;
int8 local_60;
ulong local_58;
int8 local_50;
uint local_44;
int4 local_40;
uint local_3c;
uint local_38;
uint local_34;
long local_30;
int8 local_28;
long local_20;
long local_18;
local_30 = param_4;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
local_98 = my_hash_key(param_1,param_2,&local_50,1);
local_64 = (**(code **)(local_18 + 0x58))(*(int8 *)(local_18 + 0x68),local_98,local_50);
if ((*(uint *)(local_18 + 0x20) & 1) != 0) {
lVar2 = my_hash_first_from_hash_value(local_18,local_64,local_98,local_50,local_9c);
while (lVar2 != 0) {
if (lVar2 != local_20) {
return 1;
}
lVar2 = my_hash_next(local_18,local_98,local_50,local_9c);
}
}
local_80 = *(long *)(local_18 + 0x28);
local_60 = *(int8 *)(local_18 + 0x10);
local_40 = (int4)*(int8 *)(local_18 + 0x18);
if (local_30 == 0) {
local_c8 = *(long *)(local_18 + 8);
}
else {
local_c8 = local_30;
}
uVar1 = (**(code **)(local_18 + 0x58))(*(int8 *)(local_18 + 0x68),local_28,local_c8);
local_44 = my_hash_mask(uVar1,local_60,local_40);
local_3c = local_44;
local_34 = my_hash_mask(local_64,local_60,local_40);
local_88 = (uint *)0x0;
while (puVar3 = (uint *)(local_80 + (ulong)local_44 * 0x10), *(long *)(puVar3 + 2) != local_20) {
local_44 = *puVar3;
local_88 = puVar3;
if (local_44 == 0xffffffff) {
return 1;
}
}
if (local_3c == local_34) {
*(int4 *)(local_80 + (ulong)local_44 * 0x10 + 4) = local_64;
return 0;
}
local_78 = *(int8 *)puVar3;
local_70 = *(int8 *)(puVar3 + 2);
local_58 = (ulong)local_44;
if (local_88 == (uint *)0x0) {
if (*puVar3 != 0xffffffff) {
local_58 = (ulong)*puVar3;
puVar4 = (int8 *)(local_80 + (ulong)*puVar3 * 0x10);
*(int8 *)puVar3 = *puVar4;
*(int8 *)(puVar3 + 2) = puVar4[1];
}
}
else {
*local_88 = *puVar3;
}
if (local_34 == local_58) {
if (local_58 != local_44) {
puVar4 = (int8 *)(local_80 + local_58 * 0x10);
*puVar4 = local_78;
puVar4[1] = local_70;
}
*(int4 *)(local_80 + local_58 * 0x10) = 0xffffffff;
*(int4 *)(local_80 + local_58 * 0x10 + 4) = local_64;
return 0;
}
local_90 = (int8 *)(local_80 + (ulong)local_34 * 0x10);
local_38 = my_hash_rec_mask(local_90,local_60,local_40);
if (local_34 == local_38) {
local_78 = CONCAT44(local_78._4_4_,*(int4 *)(local_80 + (ulong)local_34 * 0x10));
puVar4 = (int8 *)(local_80 + local_58 * 0x10);
*puVar4 = local_78;
puVar4[1] = local_70;
*(int4 *)(local_80 + local_58 * 0x10 + 4) = local_64;
*(int *)(local_80 + (ulong)local_34 * 0x10) = (int)local_58;
}
else {
puVar4 = (int8 *)(local_80 + local_58 * 0x10);
*puVar4 = *local_90;
puVar4[1] = local_90[1];
movelink(local_80,local_34,local_38,local_58 & 0xffffffff);
local_78 = CONCAT44(local_78._4_4_,0xffffffff);
puVar4 = (int8 *)(local_80 + (ulong)local_34 * 0x10);
*puVar4 = local_78;
puVar4[1] = local_70;
*(int4 *)(local_80 + (ulong)local_34 * 0x10 + 4) = local_64;
}
return 0;
}
| |
44,740 | ggml_vec_scale_f32 | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c | inline static void ggml_vec_scale_f32(const int n, float * y, const float v) {
#if defined(GGML_USE_ACCELERATE)
vDSP_vsmul(y, 1, &v, y, 1, n);
#elif defined(GGML_SIMD)
const int np = (n & ~(GGML_F32_STEP - 1));
GGML_F32_VEC vx = GGML_F32_VEC_SET1(v);
GGML_F32_VEC ay[GGML_F32_ARR];
for (int i = 0; i < np; i += GGML_F32_STEP) {
for (int j = 0; j < GGML_F32_ARR; j++) {
ay[j] = GGML_F32_VEC_LOAD(y + i + j*GGML_F32_EPR);
ay[j] = GGML_F32_VEC_MUL(ay[j], vx);
GGML_F32_VEC_STORE(y + i + j*GGML_F32_EPR, ay[j]);
}
}
// leftovers
for (int i = np; i < n; ++i) {
y[i] *= v;
}
#else
// scalar
for (int i = 0; i < n; ++i) {
y[i] *= v;
}
#endif
} | O0 | c | ggml_vec_scale_f32:
pushq %rbp
movq %rsp, %rbp
andq $-0x40, %rsp
subq $0x340, %rsp # imm = 0x340
movl %edi, 0x1b4(%rsp)
movq %rsi, 0x1a8(%rsp)
vmovss %xmm0, 0x1a4(%rsp)
movl 0x1b4(%rsp), %eax
andl $-0x40, %eax
movl %eax, 0x1a0(%rsp)
vmovss 0x1a4(%rsp), %xmm0
vmovss %xmm0, 0x2bc(%rsp)
vbroadcastss 0x2bc(%rsp), %zmm0
vmovaps %zmm0, 0x240(%rsp)
vmovaps 0x240(%rsp), %zmm0
vmovaps %zmm0, 0x140(%rsp)
movl $0x0, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
cmpl 0x1a0(%rsp), %eax
jge 0x28a25
movl $0x0, 0x38(%rsp)
cmpl $0x4, 0x38(%rsp)
jge 0x28a13
movq 0x1a8(%rsp), %rax
movslq 0x3c(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movl 0x38(%rsp), %ecx
shll $0x4, %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x1b8(%rsp)
movq 0x1b8(%rsp), %rax
vmovups (%rax), %zmm0
movslq 0x38(%rsp), %rcx
leaq 0x40(%rsp), %rax
shlq $0x6, %rcx
addq %rcx, %rax
vmovaps %zmm0, (%rax)
movslq 0x38(%rsp), %rcx
leaq 0x40(%rsp), %rax
shlq $0x6, %rcx
addq %rcx, %rax
vmovaps (%rax), %zmm1
vmovaps 0x140(%rsp), %zmm0
vmovaps %zmm1, 0x200(%rsp)
vmovaps %zmm0, 0x1c0(%rsp)
vmovaps 0x200(%rsp), %zmm0
vmulps 0x1c0(%rsp), %zmm0, %zmm0
movslq 0x38(%rsp), %rcx
leaq 0x40(%rsp), %rax
shlq $0x6, %rcx
addq %rcx, %rax
vmovaps %zmm0, (%rax)
movq 0x1a8(%rsp), %rax
movslq 0x3c(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movl 0x38(%rsp), %ecx
shll $0x4, %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq 0x38(%rsp), %rdx
leaq 0x40(%rsp), %rcx
shlq $0x6, %rdx
addq %rdx, %rcx
vmovaps (%rcx), %zmm0
movq %rax, 0x328(%rsp)
vmovaps %zmm0, 0x2c0(%rsp)
vmovaps 0x2c0(%rsp), %zmm0
movq 0x328(%rsp), %rax
vmovups %zmm0, (%rax)
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x288ee
jmp 0x28a15
movl 0x3c(%rsp), %eax
addl $0x40, %eax
movl %eax, 0x3c(%rsp)
jmp 0x288d5
movl 0x1a0(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
cmpl 0x1b4(%rsp), %eax
jge 0x28a6a
vmovss 0x1a4(%rsp), %xmm0
movq 0x1a8(%rsp), %rax
movslq 0x34(%rsp), %rcx
vmulss (%rax,%rcx,4), %xmm0, %xmm0
vmovss %xmm0, (%rax,%rcx,4)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x28a30
movq %rbp, %rsp
popq %rbp
vzeroupper
retq
nopw %cs:(%rax,%rax)
| ggml_vec_scale_f32:
push rbp
mov rbp, rsp
and rsp, 0FFFFFFFFFFFFFFC0h
sub rsp, 340h
mov [rsp+340h+var_18C], edi
mov [rsp+340h+var_198], rsi
vmovss [rsp+340h+var_19C], xmm0
mov eax, [rsp+340h+var_18C]
and eax, 0FFFFFFC0h
mov [rsp+340h+var_1A0], eax
vmovss xmm0, [rsp+340h+var_19C]
vmovss [rsp+340h+var_84], xmm0
vbroadcastss zmm0, [rsp+340h+var_84]
vmovaps zmmword ptr [rsp+340h+var_100], zmm0
vmovaps zmm0, zmmword ptr [rsp+340h+var_100]
vmovaps zmmword ptr [rsp+340h+var_200], zmm0
mov [rsp+340h+var_304], 0
loc_288D5:
mov eax, [rsp+340h+var_304]
cmp eax, [rsp+340h+var_1A0]
jge loc_28A25
mov [rsp+340h+var_308], 0
loc_288EE:
cmp [rsp+340h+var_308], 4
jge loc_28A13
mov rax, [rsp+340h+var_198]
movsxd rcx, [rsp+340h+var_304]
shl rcx, 2
add rax, rcx
mov ecx, [rsp+340h+var_308]
shl ecx, 4
movsxd rcx, ecx
shl rcx, 2
add rax, rcx
mov [rsp+340h+var_188], rax
mov rax, [rsp+340h+var_188]
vmovups zmm0, zmmword ptr [rax]
movsxd rcx, [rsp+340h+var_308]
lea rax, [rsp+340h+var_300]
shl rcx, 6
add rax, rcx
vmovaps zmmword ptr [rax], zmm0
movsxd rcx, [rsp+340h+var_308]
lea rax, [rsp+340h+var_300]
shl rcx, 6
add rax, rcx
vmovaps zmm1, zmmword ptr [rax]
vmovaps zmm0, zmmword ptr [rsp+340h+var_200]
vmovaps zmmword ptr [rsp+340h+var_140], zmm1
vmovaps zmmword ptr [rsp+340h+var_180], zmm0
vmovaps zmm0, zmmword ptr [rsp+340h+var_140]
vmulps zmm0, zmm0, zmmword ptr [rsp+340h+var_180]
movsxd rcx, [rsp+340h+var_308]
lea rax, [rsp+340h+var_300]
shl rcx, 6
add rax, rcx
vmovaps zmmword ptr [rax], zmm0
mov rax, [rsp+340h+var_198]
movsxd rcx, [rsp+340h+var_304]
shl rcx, 2
add rax, rcx
mov ecx, [rsp+340h+var_308]
shl ecx, 4
movsxd rcx, ecx
shl rcx, 2
add rax, rcx
movsxd rdx, [rsp+340h+var_308]
lea rcx, [rsp+340h+var_300]
shl rdx, 6
add rcx, rdx
vmovaps zmm0, zmmword ptr [rcx]
mov [rsp+340h+var_18], rax
vmovaps zmmword ptr [rsp+340h+var_80], zmm0
vmovaps zmm0, zmmword ptr [rsp+340h+var_80]
mov rax, [rsp+340h+var_18]
vmovups zmmword ptr [rax], zmm0
mov eax, [rsp+340h+var_308]
add eax, 1
mov [rsp+340h+var_308], eax
jmp loc_288EE
loc_28A13:
jmp short $+2
loc_28A15:
mov eax, [rsp+340h+var_304]
add eax, 40h ; '@'
mov [rsp+340h+var_304], eax
jmp loc_288D5
loc_28A25:
mov eax, [rsp+340h+var_1A0]
mov [rsp+340h+var_30C], eax
loc_28A30:
mov eax, [rsp+340h+var_30C]
cmp eax, [rsp+340h+var_18C]
jge short loc_28A6A
vmovss xmm0, [rsp+340h+var_19C]
mov rax, [rsp+340h+var_198]
movsxd rcx, [rsp+340h+var_30C]
vmulss xmm0, xmm0, dword ptr [rax+rcx*4]
vmovss dword ptr [rax+rcx*4], xmm0
mov eax, [rsp+340h+var_30C]
add eax, 1
mov [rsp+340h+var_30C], eax
jmp short loc_28A30
loc_28A6A:
mov rsp, rbp
pop rbp
vzeroupper
retn
| long long ggml_vec_scale_f32(signed int a1, long long a2, __m128 _XMM0)
{
long long result; // rax
signed int k; // [rsp+34h] [rbp-30Ch]
int j; // [rsp+38h] [rbp-308h]
signed int i; // [rsp+3Ch] [rbp-304h]
_BYTE v25[256]; // [rsp+40h] [rbp-300h] BYREF
signed int v27; // [rsp+1A0h] [rbp-1A0h]
long long v29; // [rsp+1A8h] [rbp-198h]
signed int v30; // [rsp+1B4h] [rbp-18Ch]
long long v31; // [rsp+1B8h] [rbp-188h]
long long v37; // [rsp+328h] [rbp-18h]
v30 = a1;
v29 = a2;
__asm { vmovss [rsp+340h+var_19C], xmm0 }
v27 = a1 & 0xFFFFFFC0;
__asm
{
vmovss xmm0, [rsp+340h+var_19C]
vmovss [rsp+340h+var_84], xmm0
vbroadcastss zmm0, [rsp+340h+var_84]
vmovaps zmmword ptr [rsp+340h+var_100], zmm0
vmovaps zmm0, zmmword ptr [rsp+340h+var_100]
vmovaps zmmword ptr [rsp+340h+var_200], zmm0
}
for ( i = 0; i < v27; i += 64 )
{
for ( j = 0; j < 4; ++j )
{
v31 = 64LL * j + 4LL * i + v29;
_RAX = v31;
__asm { vmovups zmm0, zmmword ptr [rax] }
_RAX = &v25[64 * (long long)j];
__asm
{
vmovaps zmmword ptr [rax], zmm0
vmovaps zmm1, zmmword ptr [rax]
vmovaps zmm0, zmmword ptr [rsp+340h+var_200]
vmovaps zmmword ptr [rsp+340h+var_140], zmm1
vmovaps zmmword ptr [rsp+340h+var_180], zmm0
vmovaps zmm0, zmmword ptr [rsp+340h+var_140]
vmulps zmm0, zmm0, zmmword ptr [rsp+340h+var_180]
vmovaps zmmword ptr [rax], zmm0
}
_RCX = _RAX;
__asm { vmovaps zmm0, zmmword ptr [rcx] }
v37 = 64LL * j + 4LL * i + v29;
__asm
{
vmovaps zmmword ptr [rsp+340h+var_80], zmm0
vmovaps zmm0, zmmword ptr [rsp+340h+var_80]
}
_RAX = v37;
__asm { vmovups zmmword ptr [rax], zmm0 }
}
}
for ( k = v27; ; ++k )
{
result = (unsigned int)k;
if ( k >= v30 )
break;
__asm { vmovss xmm0, [rsp+340h+var_19C] }
_RAX = v29;
_RCX = k;
__asm
{
vmulss xmm0, xmm0, dword ptr [rax+rcx*4]
vmovss dword ptr [rax+rcx*4], xmm0
}
}
__asm { vzeroupper }
return result;
}
| ggml_vec_scale_f32:
PUSH RBP
MOV RBP,RSP
AND RSP,-0x40
SUB RSP,0x340
MOV dword ptr [RSP + 0x1b4],EDI
MOV qword ptr [RSP + 0x1a8],RSI
VMOVSS dword ptr [RSP + 0x1a4],XMM0
MOV EAX,dword ptr [RSP + 0x1b4]
AND EAX,0xffffffc0
MOV dword ptr [RSP + 0x1a0],EAX
VMOVSS XMM0,dword ptr [RSP + 0x1a4]
VMOVSS dword ptr [RSP + 0x2bc],XMM0
VBROADCASTSS ZMM0,dword ptr [RSP + 0x2bc]
VMOVAPS zmmword ptr [RSP + 0x240] ,ZMM0
VMOVAPS ZMM0,zmmword ptr [RSP + 0x240]
VMOVAPS zmmword ptr [RSP + 0x140] ,ZMM0
MOV dword ptr [RSP + 0x3c],0x0
LAB_001288d5:
MOV EAX,dword ptr [RSP + 0x3c]
CMP EAX,dword ptr [RSP + 0x1a0]
JGE 0x00128a25
MOV dword ptr [RSP + 0x38],0x0
LAB_001288ee:
CMP dword ptr [RSP + 0x38],0x4
JGE 0x00128a13
MOV RAX,qword ptr [RSP + 0x1a8]
MOVSXD RCX,dword ptr [RSP + 0x3c]
SHL RCX,0x2
ADD RAX,RCX
MOV ECX,dword ptr [RSP + 0x38]
SHL ECX,0x4
MOVSXD RCX,ECX
SHL RCX,0x2
ADD RAX,RCX
MOV qword ptr [RSP + 0x1b8],RAX
MOV RAX,qword ptr [RSP + 0x1b8]
VMOVUPS ZMM0,zmmword ptr [RAX]
MOVSXD RCX,dword ptr [RSP + 0x38]
LEA RAX,[RSP + 0x40]
SHL RCX,0x6
ADD RAX,RCX
VMOVAPS zmmword ptr [RAX] ,ZMM0
MOVSXD RCX,dword ptr [RSP + 0x38]
LEA RAX,[RSP + 0x40]
SHL RCX,0x6
ADD RAX,RCX
VMOVAPS ZMM1,zmmword ptr [RAX]
VMOVAPS ZMM0,zmmword ptr [RSP + 0x140]
VMOVAPS zmmword ptr [RSP + 0x200] ,ZMM1
VMOVAPS zmmword ptr [RSP + 0x1c0] ,ZMM0
VMOVAPS ZMM0,zmmword ptr [RSP + 0x200]
VMULPS ZMM0,ZMM0,zmmword ptr [RSP + 0x1c0]
MOVSXD RCX,dword ptr [RSP + 0x38]
LEA RAX,[RSP + 0x40]
SHL RCX,0x6
ADD RAX,RCX
VMOVAPS zmmword ptr [RAX] ,ZMM0
MOV RAX,qword ptr [RSP + 0x1a8]
MOVSXD RCX,dword ptr [RSP + 0x3c]
SHL RCX,0x2
ADD RAX,RCX
MOV ECX,dword ptr [RSP + 0x38]
SHL ECX,0x4
MOVSXD RCX,ECX
SHL RCX,0x2
ADD RAX,RCX
MOVSXD RDX,dword ptr [RSP + 0x38]
LEA RCX,[RSP + 0x40]
SHL RDX,0x6
ADD RCX,RDX
VMOVAPS ZMM0,zmmword ptr [RCX]
MOV qword ptr [RSP + 0x328],RAX
VMOVAPS zmmword ptr [RSP + 0x2c0] ,ZMM0
VMOVAPS ZMM0,zmmword ptr [RSP + 0x2c0]
MOV RAX,qword ptr [RSP + 0x328]
VMOVUPS zmmword ptr [RAX],ZMM0
MOV EAX,dword ptr [RSP + 0x38]
ADD EAX,0x1
MOV dword ptr [RSP + 0x38],EAX
JMP 0x001288ee
LAB_00128a13:
JMP 0x00128a15
LAB_00128a15:
MOV EAX,dword ptr [RSP + 0x3c]
ADD EAX,0x40
MOV dword ptr [RSP + 0x3c],EAX
JMP 0x001288d5
LAB_00128a25:
MOV EAX,dword ptr [RSP + 0x1a0]
MOV dword ptr [RSP + 0x34],EAX
LAB_00128a30:
MOV EAX,dword ptr [RSP + 0x34]
CMP EAX,dword ptr [RSP + 0x1b4]
JGE 0x00128a6a
VMOVSS XMM0,dword ptr [RSP + 0x1a4]
MOV RAX,qword ptr [RSP + 0x1a8]
MOVSXD RCX,dword ptr [RSP + 0x34]
VMULSS XMM0,XMM0,dword ptr [RAX + RCX*0x4]
VMOVSS dword ptr [RAX + RCX*0x4],XMM0
MOV EAX,dword ptr [RSP + 0x34]
ADD EAX,0x1
MOV dword ptr [RSP + 0x34],EAX
JMP 0x00128a30
LAB_00128a6a:
MOV RSP,RBP
POP RBP
VZEROUPPER
RET
|
void ggml_vec_scale_f32(float param_1,uint param_2,long param_3)
{
int8 uVar1;
int8 uVar2;
int8 uVar3;
int8 uVar4;
int8 uVar5;
int8 uVar6;
int8 uVar7;
int1 auVar8 [64];
long lVar9;
int1 auVar10 [64];
uint local_34c;
int local_348;
int local_344;
int8 local_340 [32];
int8 local_240;
int8 uStack_238;
int8 uStack_230;
int8 uStack_228;
int8 uStack_220;
int8 uStack_218;
int8 uStack_210;
int8 uStack_208;
uint local_1e0;
float local_1dc;
long local_1d8;
uint local_1cc;
int8 *local_1c8;
int8 local_1c0;
int8 uStack_1b8;
int8 uStack_1b0;
int8 uStack_1a8;
int8 uStack_1a0;
int8 uStack_198;
int8 uStack_190;
int8 uStack_188;
int8 local_180;
int8 uStack_178;
int8 uStack_170;
int8 uStack_168;
int8 uStack_160;
int8 uStack_158;
int8 uStack_150;
int8 uStack_148;
int1 local_140 [64];
float local_c4;
int8 local_c0;
int8 uStack_b8;
int8 uStack_b0;
int8 uStack_a8;
int8 uStack_a0;
int8 uStack_98;
int8 uStack_90;
int8 uStack_88;
int8 *local_58;
local_1cc = param_2;
local_1d8 = param_3;
local_1dc = param_1;
local_1e0 = param_2 & 0xffffffc0;
local_c4 = param_1;
local_140 = vbroadcastss_avx512f(ZEXT416((uint)param_1));
local_240 = local_140._0_8_;
uStack_238 = local_140._8_8_;
uStack_230 = local_140._16_8_;
uStack_228 = local_140._24_8_;
uStack_220 = local_140._32_8_;
uStack_218 = local_140._40_8_;
uStack_210 = local_140._48_8_;
uStack_208 = local_140._56_8_;
for (local_344 = 0; local_344 < (int)local_1e0; local_344 = local_344 + 0x40) {
for (local_348 = 0; local_348 < 4; local_348 = local_348 + 1) {
local_1c8 = (int8 *)(local_1d8 + (long)local_344 * 4 + (long)(local_348 << 4) * 4);
uVar1 = local_1c8[1];
uVar2 = local_1c8[2];
uVar3 = local_1c8[3];
uVar4 = local_1c8[4];
uVar5 = local_1c8[5];
uVar6 = local_1c8[6];
uVar7 = local_1c8[7];
lVar9 = (long)local_348;
local_340[lVar9 * 8] = *local_1c8;
local_340[lVar9 * 8 + 1] = uVar1;
local_340[lVar9 * 8 + 2] = uVar2;
local_340[lVar9 * 8 + 3] = uVar3;
local_340[lVar9 * 8 + 4] = uVar4;
local_340[lVar9 * 8 + 5] = uVar5;
local_340[lVar9 * 8 + 6] = uVar6;
local_340[lVar9 * 8 + 7] = uVar7;
lVar9 = (long)local_348;
local_180 = local_340[lVar9 * 8];
uStack_178 = local_340[lVar9 * 8 + 1];
uStack_170 = local_340[lVar9 * 8 + 2];
uStack_168 = local_340[lVar9 * 8 + 3];
uStack_160 = local_340[lVar9 * 8 + 4];
uStack_158 = local_340[lVar9 * 8 + 5];
uStack_150 = local_340[lVar9 * 8 + 6];
uStack_148 = local_340[lVar9 * 8 + 7];
local_1c0 = local_240;
uStack_1b8 = uStack_238;
uStack_1b0 = uStack_230;
uStack_1a8 = uStack_228;
uStack_1a0 = uStack_220;
uStack_198 = uStack_218;
uStack_190 = uStack_210;
uStack_188 = uStack_208;
auVar8._8_8_ = local_340[lVar9 * 8 + 1];
auVar8._0_8_ = local_340[lVar9 * 8];
auVar8._16_8_ = local_340[lVar9 * 8 + 2];
auVar8._24_8_ = local_340[lVar9 * 8 + 3];
auVar8._32_8_ = local_340[lVar9 * 8 + 4];
auVar8._40_8_ = local_340[lVar9 * 8 + 5];
auVar8._48_8_ = local_340[lVar9 * 8 + 6];
auVar8._56_8_ = local_340[lVar9 * 8 + 7];
auVar10._8_8_ = uStack_238;
auVar10._0_8_ = local_240;
auVar10._16_8_ = uStack_230;
auVar10._24_8_ = uStack_228;
auVar10._32_8_ = uStack_220;
auVar10._40_8_ = uStack_218;
auVar10._48_8_ = uStack_210;
auVar10._56_8_ = uStack_208;
auVar10 = vmulps_avx512f(auVar8,auVar10);
*(int1 (*) [64])(local_340 + (long)local_348 * 8) = auVar10;
local_58 = (int8 *)(local_1d8 + (long)local_344 * 4 + (long)(local_348 << 4) * 4);
lVar9 = (long)local_348;
uStack_b8 = local_340[lVar9 * 8 + 1];
uStack_b0 = local_340[lVar9 * 8 + 2];
uStack_a8 = local_340[lVar9 * 8 + 3];
uStack_a0 = local_340[lVar9 * 8 + 4];
uStack_98 = local_340[lVar9 * 8 + 5];
uStack_90 = local_340[lVar9 * 8 + 6];
uStack_88 = local_340[lVar9 * 8 + 7];
local_c0 = local_340[lVar9 * 8];
*local_58 = local_340[lVar9 * 8];
local_58[1] = uStack_b8;
local_58[2] = uStack_b0;
local_58[3] = uStack_a8;
local_58[4] = uStack_a0;
local_58[5] = uStack_98;
local_58[6] = uStack_90;
local_58[7] = uStack_88;
}
}
for (local_34c = local_1e0; (int)local_34c < (int)local_1cc; local_34c = local_34c + 1) {
*(float *)(local_1d8 + (long)(int)local_34c * 4) =
local_1dc * *(float *)(local_1d8 + (long)(int)local_34c * 4);
}
return;
}
| |
44,741 | ggml_vec_scale_f32 | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c | inline static void ggml_vec_scale_f32(const int n, float * y, const float v) {
#if defined(GGML_USE_ACCELERATE)
vDSP_vsmul(y, 1, &v, y, 1, n);
#elif defined(GGML_SIMD)
const int np = (n & ~(GGML_F32_STEP - 1));
GGML_F32_VEC vx = GGML_F32_VEC_SET1(v);
GGML_F32_VEC ay[GGML_F32_ARR];
for (int i = 0; i < np; i += GGML_F32_STEP) {
for (int j = 0; j < GGML_F32_ARR; j++) {
ay[j] = GGML_F32_VEC_LOAD(y + i + j*GGML_F32_EPR);
ay[j] = GGML_F32_VEC_MUL(ay[j], vx);
GGML_F32_VEC_STORE(y + i + j*GGML_F32_EPR, ay[j]);
}
}
// leftovers
for (int i = np; i < n; ++i) {
y[i] *= v;
}
#else
// scalar
for (int i = 0; i < n; ++i) {
y[i] *= v;
}
#endif
} | O2 | c | ggml_vec_scale_f32:
movl %edi, %eax
andl $-0x40, %eax
vbroadcastss %xmm0, %zmm1
cltq
xorl %ecx, %ecx
movq %rsi, %rdx
cmpq %rax, %rcx
jge 0x23c24
xorl %r8d, %r8d
cmpq $0x100, %r8 # imm = 0x100
je 0x23c17
vmulps (%rdx,%r8), %zmm1, %zmm2
vmovups %zmm2, (%rdx,%r8)
addq $0x40, %r8
jmp 0x23bfa
addq $0x40, %rcx
addq $0x100, %rdx # imm = 0x100
jmp 0x23bf2
movslq %edi, %rcx
cmpq %rcx, %rax
jge 0x23c3b
vmulss (%rsi,%rax,4), %xmm0, %xmm1
vmovss %xmm1, (%rsi,%rax,4)
incq %rax
jmp 0x23c27
vzeroupper
retq
| ggml_vec_scale_f32:
mov eax, edi
and eax, 0FFFFFFC0h
vbroadcastss zmm1, xmm0
cdqe
xor ecx, ecx
mov rdx, rsi
loc_23BF2:
cmp rcx, rax
jge short loc_23C24
xor r8d, r8d
loc_23BFA:
cmp r8, 100h
jz short loc_23C17
vmulps zmm2, zmm1, zmmword ptr [rdx+r8]
vmovups zmmword ptr [rdx+r8], zmm2
add r8, 40h ; '@'
jmp short loc_23BFA
loc_23C17:
add rcx, 40h ; '@'
add rdx, 100h
jmp short loc_23BF2
loc_23C24:
movsxd rcx, edi
loc_23C27:
cmp rax, rcx
jge short loc_23C3B
vmulss xmm1, xmm0, dword ptr [rsi+rax*4]
vmovss dword ptr [rsi+rax*4], xmm1
inc rax
jmp short loc_23C27
loc_23C3B:
vzeroupper
retn
| long long ggml_vec_scale_f32(int a1, long long _RSI, __m128 _XMM0)
{
long long result; // rax
long long v5; // rcx
__asm { vbroadcastss zmm1, xmm0 }
result = (int)(a1 & 0xFFFFFFC0);
v5 = 0LL;
_RDX = _RSI;
while ( v5 < result )
{
for ( _R8 = 0LL; _R8 != 256; _R8 += 64LL )
{
__asm
{
vmulps zmm2, zmm1, zmmword ptr [rdx+r8]
vmovups zmmword ptr [rdx+r8], zmm2
}
}
v5 += 64LL;
_RDX += 256LL;
}
while ( result < a1 )
{
__asm
{
vmulss xmm1, xmm0, dword ptr [rsi+rax*4]
vmovss dword ptr [rsi+rax*4], xmm1
}
++result;
}
__asm { vzeroupper }
return result;
}
| ggml_vec_scale_f32:
MOV EAX,EDI
AND EAX,0xffffffc0
VBROADCASTSS ZMM1,XMM0
CDQE
XOR ECX,ECX
MOV RDX,RSI
LAB_00123bf2:
CMP RCX,RAX
JGE 0x00123c24
XOR R8D,R8D
LAB_00123bfa:
CMP R8,0x100
JZ 0x00123c17
VMULPS ZMM2,ZMM1,zmmword ptr [RDX + R8*0x1]
VMOVUPS zmmword ptr [RDX + R8*0x1],ZMM2
ADD R8,0x40
JMP 0x00123bfa
LAB_00123c17:
ADD RCX,0x40
ADD RDX,0x100
JMP 0x00123bf2
LAB_00123c24:
MOVSXD RCX,EDI
LAB_00123c27:
CMP RAX,RCX
JGE 0x00123c3b
VMULSS XMM1,XMM0,dword ptr [RSI + RAX*0x4]
VMOVSS dword ptr [RSI + RAX*0x4],XMM1
INC RAX
JMP 0x00123c27
LAB_00123c3b:
VZEROUPPER
RET
|
void ggml_vec_scale_f32(float param_1,uint param_2,long param_3)
{
int1 auVar1 [16];
long lVar2;
long lVar3;
long lVar4;
long lVar5;
int1 auVar6 [64];
int1 auVar7 [64];
int1 in_register_00001204 [12];
auVar1._4_12_ = in_register_00001204;
auVar1._0_4_ = param_1;
auVar6 = vbroadcastss_avx512f(auVar1);
lVar2 = (long)(int)(param_2 & 0xffffffc0);
lVar4 = param_3;
for (lVar3 = 0; lVar3 < lVar2; lVar3 = lVar3 + 0x40) {
for (lVar5 = 0; lVar5 != 0x100; lVar5 = lVar5 + 0x40) {
auVar7 = vmulps_avx512f(auVar6,*(int1 (*) [64])(lVar4 + lVar5));
*(int1 (*) [64])(lVar4 + lVar5) = auVar7;
}
lVar4 = lVar4 + 0x100;
}
for (; lVar2 < (int)param_2; lVar2 = lVar2 + 1) {
*(float *)(param_3 + lVar2 * 4) = param_1 * *(float *)(param_3 + lVar2 * 4);
}
return;
}
| |
44,742 | ma_bitmap_unlock | eloqsql/storage/maria/ma_bitmap.c | void _ma_bitmap_unlock(MARIA_SHARE *share)
{
MARIA_FILE_BITMAP *bitmap= &share->bitmap;
uint send_signal;
DBUG_ENTER("_ma_bitmap_unlock");
if (!share->now_transactional)
DBUG_VOID_RETURN;
DBUG_ASSERT(bitmap->flush_all_requested > 0 && bitmap->non_flushable == 1);
mysql_mutex_lock(&bitmap->bitmap_lock);
bitmap->non_flushable= 0;
_ma_bitmap_unpin_all(share);
send_signal= bitmap->waiting_for_non_flushable;
if (!--bitmap->flush_all_requested)
send_signal|= bitmap->waiting_for_flush_all_requested;
mysql_mutex_unlock(&bitmap->bitmap_lock);
if (send_signal)
mysql_cond_broadcast(&bitmap->bitmap_cond);
DBUG_VOID_RETURN;
} | O0 | c | ma_bitmap_unlock:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xa10, %rax # imm = 0xA10
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, 0x7e7(%rax)
jne 0x3bbbe
jmp 0x3bbb9
jmp 0x3bc45
jmp 0x3bbc0
jmp 0x3bbc2
movq -0x10(%rbp), %rdi
addq $0x88, %rdi
leaq 0x1421e9(%rip), %rsi # 0x17ddbd
movl $0x279, %edx # imm = 0x279
callq 0x3b500
movq -0x10(%rbp), %rax
movl $0x0, 0x38(%rax)
movq -0x8(%rbp), %rdi
callq 0x3bc50
movq -0x10(%rbp), %rax
movl 0x3c(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movl 0x30(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x30(%rcx)
cmpl $0x0, %eax
jne 0x3bc1b
movq -0x10(%rbp), %rax
movl 0x34(%rax), %eax
orl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
addq $0x88, %rdi
callq 0x3b7b0
cmpl $0x0, -0x14(%rbp)
je 0x3bc41
movq -0x10(%rbp), %rdi
addq $0xd0, %rdi
callq 0x3ba60
jmp 0x3bc43
jmp 0x3bc45
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| _ma_bitmap_unlock:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
add rax, 0A10h
mov [rbp+var_10], rax
mov rax, [rbp+var_8]
cmp byte ptr [rax+7E7h], 0
jnz short loc_3BBBE
jmp short $+2
loc_3BBB9:
jmp loc_3BC45
loc_3BBBE:
jmp short $+2
loc_3BBC0:
jmp short $+2
loc_3BBC2:
mov rdi, [rbp+var_10]
add rdi, 88h
lea rsi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 279h
call inline_mysql_mutex_lock_1
mov rax, [rbp+var_10]
mov dword ptr [rax+38h], 0
mov rdi, [rbp+var_8]
call _ma_bitmap_unpin_all
mov rax, [rbp+var_10]
mov eax, [rax+3Ch]
mov [rbp+var_14], eax
mov rcx, [rbp+var_10]
mov eax, [rcx+30h]
add eax, 0FFFFFFFFh
mov [rcx+30h], eax
cmp eax, 0
jnz short loc_3BC1B
mov rax, [rbp+var_10]
mov eax, [rax+34h]
or eax, [rbp+var_14]
mov [rbp+var_14], eax
loc_3BC1B:
mov rdi, [rbp+var_10]
add rdi, 88h
call inline_mysql_mutex_unlock_1
cmp [rbp+var_14], 0
jz short loc_3BC41
mov rdi, [rbp+var_10]
add rdi, 0D0h
call inline_mysql_cond_broadcast
loc_3BC41:
jmp short $+2
loc_3BC43:
jmp short $+2
loc_3BC45:
add rsp, 20h
pop rbp
retn
| long long ma_bitmap_unlock(long long a1)
{
long long result; // rax
int v2; // eax
int v3; // [rsp+Ch] [rbp-14h]
result = a1;
if ( *(_BYTE *)(a1 + 2023) )
{
inline_mysql_mutex_lock_1(
a1 + 2712,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_bitmap.c",
0x279u);
*(_DWORD *)(a1 + 2632) = 0;
ma_bitmap_unpin_all(a1);
v3 = *(_DWORD *)(a1 + 2636);
v2 = *(_DWORD *)(a1 + 2624) - 1;
*(_DWORD *)(a1 + 2624) = v2;
if ( !v2 )
v3 |= *(_DWORD *)(a1 + 2628);
result = inline_mysql_mutex_unlock_1(a1 + 2712);
if ( v3 )
return inline_mysql_cond_broadcast(a1 + 2784);
}
return result;
}
| _ma_bitmap_unlock:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0xa10
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x8]
CMP byte ptr [RAX + 0x7e7],0x0
JNZ 0x0013bbbe
JMP 0x0013bbb9
LAB_0013bbb9:
JMP 0x0013bc45
LAB_0013bbbe:
JMP 0x0013bbc0
LAB_0013bbc0:
JMP 0x0013bbc2
LAB_0013bbc2:
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x88
LEA RSI,[0x27ddbd]
MOV EDX,0x279
CALL 0x0013b500
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x38],0x0
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0013bc50
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x3c]
MOV dword ptr [RBP + -0x14],EAX
MOV RCX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RCX + 0x30]
ADD EAX,-0x1
MOV dword ptr [RCX + 0x30],EAX
CMP EAX,0x0
JNZ 0x0013bc1b
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x34]
OR EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x14],EAX
LAB_0013bc1b:
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x88
CALL 0x0013b7b0
CMP dword ptr [RBP + -0x14],0x0
JZ 0x0013bc41
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0xd0
CALL 0x0013ba60
LAB_0013bc41:
JMP 0x0013bc43
LAB_0013bc43:
JMP 0x0013bc45
LAB_0013bc45:
ADD RSP,0x20
POP RBP
RET
|
void _ma_bitmap_unlock(long param_1)
{
int iVar1;
uint local_1c;
if (*(char *)(param_1 + 0x7e7) != '\0') {
inline_mysql_mutex_lock
(param_1 + 0xa98,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_bitmap.c",
0x279);
*(int4 *)(param_1 + 0xa48) = 0;
_ma_bitmap_unpin_all(param_1);
local_1c = *(uint *)(param_1 + 0xa4c);
iVar1 = *(int *)(param_1 + 0xa40) + -1;
*(int *)(param_1 + 0xa40) = iVar1;
if (iVar1 == 0) {
local_1c = *(uint *)(param_1 + 0xa44) | local_1c;
}
inline_mysql_mutex_unlock(param_1 + 0xa98);
if (local_1c != 0) {
inline_mysql_cond_broadcast(param_1 + 0xae0);
}
}
return;
}
| |
44,743 | testing::internal::PrintTo(char16_t const*, std::ostream*) | giladroyz[P]FindPeaks/build_O1/_deps/googletest-src/googletest/src/gtest-printers.cc | void PrintTo(const char16_t* s, ostream* os) { PrintCStringTo(s, os); } | O1 | cpp | testing::internal::PrintTo(char16_t const*, std::ostream*):
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0x17def
movq %rdi, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x83b0
leaq 0x2c908(%rip), %rsi # 0x446c4
movl $0xd, %edx
movq %rax, %rdi
callq 0x85b0
movq $-0x1, %rsi
cmpw $0x0, 0x2(%r14,%rsi,2)
leaq 0x1(%rsi), %rsi
jne 0x17dd0
movq %r14, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x18206
leaq 0x2c7d8(%rip), %rsi # 0x445ce
movl $0x4, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x85b0
| _ZN7testing8internal7PrintToEPKDsPSo:
push r14
push rbx
push rax
mov rbx, rsi
test rdi, rdi
jz short loc_17DEF
mov r14, rdi
mov rdi, rbx
mov rsi, r14
call __ZNSo9_M_insertIPKvEERSoT_; std::ostream::_M_insert<void const*>(void const*)
lea rsi, aPointingTo; " pointing to "
mov edx, 0Dh
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rsi, 0FFFFFFFFFFFFFFFFh
loc_17DD0:
cmp word ptr [r14+rsi*2+2], 0
lea rsi, [rsi+1]
jnz short loc_17DD0
mov rdi, r14
mov rdx, rbx
add rsp, 8
pop rbx
pop r14
jmp _ZN7testing8internalL20PrintCharsAsStringToIDsEENS0_10CharFormatEPKT_mPSo; testing::internal::PrintCharsAsStringTo<char16_t>(char16_t const*,ulong,std::ostream *)
loc_17DEF:
lea rsi, aNull_0; "NULL"
mov edx, 4
mov rdi, rbx
add rsp, 8
pop rbx
pop r14
jmp __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
| long long testing::internal::PrintTo(long long a1, long long a2, long long a3)
{
long long v4; // rax
long long v5; // rsi
if ( !a1 )
return std::__ostream_insert<char,std::char_traits<char>>(a2, "NULL", 4LL);
v4 = std::ostream::_M_insert<void const*>(a2, a1, a3);
std::__ostream_insert<char,std::char_traits<char>>(v4, " pointing to ", 13LL);
v5 = -1LL;
while ( *(_WORD *)(a1 + 2 * v5++ + 2) != 0 )
;
return testing::internal::PrintCharsAsStringTo<char16_t>(a1, v5, a2);
}
| PrintTo:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RSI
TEST RDI,RDI
JZ 0x00117def
MOV R14,RDI
MOV RDI,RBX
MOV RSI,R14
CALL 0x001083b0
LEA RSI,[0x1446c4]
MOV EDX,0xd
MOV RDI,RAX
CALL 0x001085b0
MOV RSI,-0x1
LAB_00117dd0:
CMP word ptr [R14 + RSI*0x2 + 0x2],0x0
LEA RSI,[RSI + 0x1]
JNZ 0x00117dd0
MOV RDI,R14
MOV RDX,RBX
ADD RSP,0x8
POP RBX
POP R14
JMP 0x00118206
LAB_00117def:
LEA RSI,[0x1445ce]
MOV EDX,0x4
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R14
JMP 0x001085b0
|
/* testing::internal::PrintTo(char16_t const*, std::ostream*) */
void testing::internal::PrintTo(wchar16 *param_1,ostream *param_2)
{
long lVar1;
ostream *poVar2;
ulong uVar3;
if (param_1 != (wchar16 *)0x0) {
poVar2 = std::ostream::_M_insert<void_const*>(param_2);
std::__ostream_insert<char,std::char_traits<char>>(poVar2," pointing to ",0xd);
uVar3 = 0xffffffffffffffff;
do {
lVar1 = uVar3 + 1;
uVar3 = uVar3 + 1;
} while (param_1[lVar1] != L'\0');
PrintCharsAsStringTo<char16_t>(param_1,uVar3,param_2);
return;
}
std::__ostream_insert<char,std::char_traits<char>>(param_2,"NULL",4);
return;
}
| |
44,744 | ma_read_rnd_mempack_record | eloqsql/storage/maria/ma_packrec.c | static int _ma_read_rnd_mempack_record(MARIA_HA *info,
uchar *buf,
register MARIA_RECORD_POS filepos,
my_bool skip_deleted_blocks
__attribute__((unused)))
{
MARIA_BLOCK_INFO block_info;
MARIA_SHARE *share= info->s;
uchar *pos,*start;
DBUG_ENTER("_ma_read_rnd_mempack_record");
if (filepos >= share->state.state.data_file_length)
{
my_errno=HA_ERR_END_OF_FILE;
goto err;
}
if (!(pos= (uchar*) _ma_mempack_get_block_info(info, &info->bit_buff,
&block_info,
&info->rec_buff,
&info->rec_buff_size,
(uchar*)
(start= share->file_map +
filepos))))
goto err;
#ifndef DBUG_OFF
if (block_info.rec_len > info->s->max_pack_length)
{
_ma_set_fatal_error(info, HA_ERR_WRONG_IN_RECORD);
goto err;
}
#endif
info->packed_length=block_info.rec_len;
info->cur_row.lastpos= filepos;
info->cur_row.nextpos= filepos+(uint) (pos-start)+block_info.rec_len;
info->update|= HA_STATE_AKTIV | HA_STATE_KEY_CHANGED;
DBUG_RETURN (_ma_pack_rec_unpack(info, &info->bit_buff, buf,
pos, block_info.rec_len));
err:
DBUG_RETURN(my_errno);
} | O3 | c | ma_read_rnd_mempack_record:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq (%rdi), %rdi
cmpq %rdx, 0x40(%rdi)
jbe 0x43561
movq %rdx, %r15
movq %rsi, %rbx
leaq 0x290(%r14), %r12
leaq 0x3a0(%r14), %rcx
leaq 0x460(%r14), %r8
movq 0x5f0(%rdi), %r13
addq %rdx, %r13
leaq -0x88(%rbp), %rdx
movq %r12, %rsi
movq %r13, %r9
callq 0x44e71
testq %rax, %rax
je 0x4356c
movq -0x70(%rbp), %r8
movq %r8, 0x450(%r14)
movq %r15, 0x98(%r14)
movl %eax, %ecx
subl %r13d, %ecx
addq %r8, %r15
addq %rcx, %r15
movq %r15, 0xa0(%r14)
orb $-0x7e, 0x624(%r14)
movq %fs:0x28, %rcx
cmpq -0x30(%rbp), %rcx
jne 0x43591
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %rax, %rcx
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x42fd1
callq 0xa8ec2
movl $0x89, (%rax)
callq 0xa8ec2
movl (%rax), %eax
movq %fs:0x28, %rcx
cmpq -0x30(%rbp), %rcx
jne 0x43591
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2a240
| _ma_read_rnd_mempack_record:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov r14, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov rdi, [rdi]
cmp [rdi+40h], rdx
jbe loc_43561
mov r15, rdx
mov rbx, rsi
lea r12, [r14+290h]
lea rcx, [r14+3A0h]
lea r8, [r14+460h]
mov r13, [rdi+5F0h]
add r13, rdx
lea rdx, [rbp+var_88]
mov rsi, r12
mov r9, r13
call _ma_mempack_get_block_info
test rax, rax
jz short loc_4356C
mov r8, [rbp+var_70]
mov [r14+450h], r8
mov [r14+98h], r15
mov ecx, eax
sub ecx, r13d
add r15, r8
add r15, rcx
mov [r14+0A0h], r15
or byte ptr [r14+624h], 82h
mov rcx, fs:28h
cmp rcx, [rbp+var_30]
jnz short loc_43591
mov rdi, r14
mov rsi, r12
mov rdx, rbx
mov rcx, rax
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _ma_pack_rec_unpack
loc_43561:
call _my_thread_var
mov dword ptr [rax], 89h
loc_4356C:
call _my_thread_var
mov eax, [rax]
mov rcx, fs:28h
cmp rcx, [rbp+var_30]
jnz short loc_43591
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_43591:
call ___stack_chk_fail
| long long ma_read_rnd_mempack_record(long long *a1, long long a2, unsigned long long a3)
{
long long v4; // rdi
unsigned long long v6; // r13
long long block_info; // rax
int v8; // r9d
long long v9; // r8
_BYTE v11[24]; // [rsp+8h] [rbp-88h] BYREF
long long v12; // [rsp+20h] [rbp-70h]
unsigned long long v13; // [rsp+60h] [rbp-30h]
v13 = __readfsqword(0x28u);
v4 = *a1;
if ( *(_QWORD *)(v4 + 64) <= a3 )
{
*(_DWORD *)my_thread_var(v4) = 137;
}
else
{
v6 = a3 + *(_QWORD *)(v4 + 1520);
block_info = ma_mempack_get_block_info(v4, a1 + 82, v11, a1 + 116, a1 + 140, v6);
if ( block_info )
{
v9 = v12;
a1[138] = v12;
a1[19] = a3;
a1[20] = (unsigned int)(block_info - v6) + v9 + a3;
*((_BYTE *)a1 + 1572) |= 0x82u;
return ma_pack_rec_unpack(a1, (long long)(a1 + 82), a2, block_info, v9, v8);
}
}
return *(unsigned int *)my_thread_var(v4);
}
| _ma_read_rnd_mempack_record:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R14,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RDI]
CMP qword ptr [RDI + 0x40],RDX
JBE 0x00143561
MOV R15,RDX
MOV RBX,RSI
LEA R12,[R14 + 0x290]
LEA RCX,[R14 + 0x3a0]
LEA R8,[R14 + 0x460]
MOV R13,qword ptr [RDI + 0x5f0]
ADD R13,RDX
LEA RDX,[RBP + -0x88]
MOV RSI,R12
MOV R9,R13
CALL 0x00144e71
TEST RAX,RAX
JZ 0x0014356c
MOV R8,qword ptr [RBP + -0x70]
MOV qword ptr [R14 + 0x450],R8
MOV qword ptr [R14 + 0x98],R15
MOV ECX,EAX
SUB ECX,R13D
ADD R15,R8
ADD R15,RCX
MOV qword ptr [R14 + 0xa0],R15
OR byte ptr [R14 + 0x624],0x82
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x30]
JNZ 0x00143591
MOV RDI,R14
MOV RSI,R12
MOV RDX,RBX
MOV RCX,RAX
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00142fd1
LAB_00143561:
CALL 0x001a8ec2
MOV dword ptr [RAX],0x89
LAB_0014356c:
CALL 0x001a8ec2
MOV EAX,dword ptr [RAX]
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x30]
JNZ 0x00143591
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00143591:
CALL 0x0012a240
|
ulong _ma_read_rnd_mempack_record(long *param_1,int8 param_2,ulong param_3)
{
long lVar1;
ulong uVar2;
int4 *puVar3;
uint *puVar4;
long lVar5;
long in_FS_OFFSET;
int1 local_90 [24];
long local_78;
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
lVar1 = *param_1;
if (param_3 < *(ulong *)(lVar1 + 0x40)) {
lVar5 = *(long *)(lVar1 + 0x5f0) + param_3;
lVar1 = _ma_mempack_get_block_info
(lVar1,param_1 + 0x52,local_90,param_1 + 0x74,param_1 + 0x8c,lVar5);
if (lVar1 != 0) {
param_1[0x8a] = local_78;
param_1[0x13] = param_3;
param_1[0x14] = param_3 + local_78 + (ulong)(uint)((int)lVar1 - (int)lVar5);
*(byte *)((long)param_1 + 0x624) = *(byte *)((long)param_1 + 0x624) | 0x82;
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
uVar2 = _ma_pack_rec_unpack(param_1,param_1 + 0x52,param_2,lVar1);
return uVar2;
}
goto LAB_00143591;
}
}
else {
puVar3 = (int4 *)_my_thread_var();
*puVar3 = 0x89;
}
puVar4 = (uint *)_my_thread_var();
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return (ulong)*puVar4;
}
LAB_00143591:
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
44,745 | maria_rtree_find_first | eloqsql/storage/maria/ma_rt_index.c | int maria_rtree_find_first(MARIA_HA *info, MARIA_KEY *key, uint32 search_flag)
{
my_off_t root;
uint nod_cmp_flag;
MARIA_KEYDEF *keyinfo= key->keyinfo;
/*
At the moment index can only properly handle the
MBR_INTERSECT, so we use it for all sorts of queries.
TODO: better searsh for CONTAINS/WITHIN.
*/
search_flag= nod_cmp_flag= MBR_INTERSECT;
if ((root= info->s->state.key_root[keyinfo->key_nr]) == HA_OFFSET_ERROR)
{
my_errno= HA_ERR_END_OF_FILE;
return -1;
}
/*
Save searched key, include data pointer.
The data pointer is required if the search_flag contains MBR_DATA.
(minimum bounding rectangle)
*/
memcpy(info->first_mbr_key, key->data, key->data_length + key->ref_length);
info->last_rkey_length= key->data_length;
info->maria_rtree_recursion_depth= -1;
info->keyread_buff_used= 1;
/*
TODO better search for CONTAINS/WITHIN.
nod_cmp_flag= ((search_flag & (MBR_EQUAL | MBR_WITHIN)) ?
MBR_WITHIN : MBR_INTERSECT);
*/
return maria_rtree_find_req(info, keyinfo, search_flag, nod_cmp_flag, root,
0);
} | O3 | c | maria_rtree_find_first:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x8(%rsi), %rbx
movq (%rdi), %rax
movq 0x118(%rax), %rax
movzbl 0xa5(%rbx), %ecx
movq (%rax,%rcx,8), %r12
cmpq $-0x1, %r12
je 0x6bd56
movq %rsi, %r15
movq %rdi, %r14
movq 0x398(%rdi), %rdi
movq (%rsi), %rsi
movl 0x14(%r15), %edx
addl 0x10(%r15), %edx
callq 0x29080
movl 0x10(%r15), %eax
movl %eax, 0x630(%r14)
movl $0xffffffff, 0x6f0(%r14) # imm = 0xFFFFFFFF
movb $0x1, 0x685(%r14)
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x6bd6f
callq 0xa29fe
movl $0x89, (%rax)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| maria_rtree_find_first:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov rbx, [rsi+8]
mov rax, [rdi]
mov rax, [rax+118h]
movzx ecx, byte ptr [rbx+0A5h]
mov r12, [rax+rcx*8]
cmp r12, 0FFFFFFFFFFFFFFFFh
jz short loc_6BD56
mov r15, rsi
mov r14, rdi
mov rdi, [rdi+398h]
mov rsi, [rsi]
mov edx, [r15+14h]
add edx, [r15+10h]
call _memcpy
mov eax, [r15+10h]
mov [r14+630h], eax
mov dword ptr [r14+6F0h], 0FFFFFFFFh
mov byte ptr [r14+685h], 1
mov rdi, r14
mov rsi, rbx
mov rdx, r12
xor ecx, ecx
pop rbx
pop r12
pop r14
pop r15
pop rbp
jmp short maria_rtree_find_req
loc_6BD56:
call _my_thread_var
mov dword ptr [rax], 89h
mov eax, 0FFFFFFFFh
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long maria_rtree_find_first(long long a1, const char *a2)
{
long long v2; // rbx
long long v3; // r12
v2 = *((_QWORD *)a2 + 1);
v3 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)a1 + 280LL) + 8LL * *(unsigned __int8 *)(v2 + 165));
if ( v3 == -1 )
{
*(_DWORD *)my_thread_var(a1, a2) = 137;
return 0xFFFFFFFFLL;
}
else
{
memcpy(*(_QWORD *)(a1 + 920), *(_QWORD *)a2, (unsigned int)(*((_DWORD *)a2 + 4) + *((_DWORD *)a2 + 5)));
*(_DWORD *)(a1 + 1584) = *((_DWORD *)a2 + 4);
*(_DWORD *)(a1 + 1776) = -1;
*(_BYTE *)(a1 + 1669) = 1;
return maria_rtree_find_req(a1, v2, v3, 0LL);
}
}
| maria_rtree_find_first:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RBX,qword ptr [RSI + 0x8]
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x118]
MOVZX ECX,byte ptr [RBX + 0xa5]
MOV R12,qword ptr [RAX + RCX*0x8]
CMP R12,-0x1
JZ 0x0016bd56
MOV R15,RSI
MOV R14,RDI
MOV RDI,qword ptr [RDI + 0x398]
MOV RSI,qword ptr [RSI]
MOV EDX,dword ptr [R15 + 0x14]
ADD EDX,dword ptr [R15 + 0x10]
CALL 0x00129080
MOV EAX,dword ptr [R15 + 0x10]
MOV dword ptr [R14 + 0x630],EAX
MOV dword ptr [R14 + 0x6f0],0xffffffff
MOV byte ptr [R14 + 0x685],0x1
MOV RDI,R14
MOV RSI,RBX
MOV RDX,R12
XOR ECX,ECX
POP RBX
POP R12
POP R14
POP R15
POP RBP
JMP 0x0016bd6f
LAB_0016bd56:
CALL 0x001a29fe
MOV dword ptr [RAX],0x89
MOV EAX,0xffffffff
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
int8 maria_rtree_find_first(long *param_1,int8 *param_2)
{
long lVar1;
long lVar2;
int8 uVar3;
int4 *puVar4;
lVar1 = param_2[1];
lVar2 = *(long *)(*(long *)(*param_1 + 0x118) + (ulong)*(byte *)(lVar1 + 0xa5) * 8);
if (lVar2 != -1) {
memcpy((void *)param_1[0x73],(void *)*param_2,
(ulong)(uint)(*(int *)((long)param_2 + 0x14) + *(int *)(param_2 + 2)));
*(int4 *)(param_1 + 0xc6) = *(int4 *)(param_2 + 2);
*(int4 *)(param_1 + 0xde) = 0xffffffff;
*(int1 *)((long)param_1 + 0x685) = 1;
uVar3 = maria_rtree_find_req(param_1,lVar1,lVar2,0);
return uVar3;
}
puVar4 = (int4 *)_my_thread_var();
*puVar4 = 0x89;
return 0xffffffff;
}
| |
44,746 | js_typed_array_get_byteOffset | bluesky950520[P]quickjs/quickjs.c | static JSValue js_typed_array_get_byteOffset(JSContext *ctx, JSValue this_val)
{
JSObject *p;
JSTypedArray *ta;
p = get_typed_array(ctx, this_val);
if (!p)
return JS_EXCEPTION;
if (typed_array_is_oob(p))
return js_int32(0);
ta = p->u.typed_array;
return js_uint32(ta->offset);
} | O2 | c | js_typed_array_get_byteOffset:
pushq %rbx
callq 0x31c8f
testq %rax, %rax
je 0x6b66c
movq %rax, %rbx
movq %rax, %rdi
callq 0x31cba
testl %eax, %eax
je 0x6b675
xorl %eax, %eax
xorl %ecx, %ecx
xorl %edx, %edx
jmp 0x6b6a8
pushq $0x6
popq %rdx
xorl %eax, %eax
xorl %ecx, %ecx
jmp 0x6b6a8
movq 0x30(%rbx), %rax
movslq 0x20(%rax), %rax
xorl %ecx, %ecx
movl %eax, %edx
cvtsi2sd %rdx, %xmm0
testq %rax, %rax
movq %xmm0, %rsi
cmovnsq %rax, %rsi
pushq $0x7
popq %rdx
cmovnsq %rcx, %rdx
movabsq $0x7fffffff00000000, %rcx # imm = 0x7FFFFFFF00000000
andq %rsi, %rcx
movl %esi, %eax
orq %rcx, %rax
popq %rbx
retq
| js_typed_array_get_byteOffset:
push rbx
call get_typed_array
test rax, rax
jz short loc_6B66C
mov rbx, rax
mov rdi, rax
call typed_array_is_oob
test eax, eax
jz short loc_6B675
xor eax, eax
xor ecx, ecx
xor edx, edx
jmp short loc_6B6A8
loc_6B66C:
push 6
pop rdx
xor eax, eax
xor ecx, ecx
jmp short loc_6B6A8
loc_6B675:
mov rax, [rbx+30h]
movsxd rax, dword ptr [rax+20h]
xor ecx, ecx
mov edx, eax
cvtsi2sd xmm0, rdx
test rax, rax
movq rsi, xmm0
cmovns rsi, rax
push 7
pop rdx
cmovns rdx, rcx
mov rcx, 7FFFFFFF00000000h
and rcx, rsi
mov eax, esi
loc_6B6A8:
or rax, rcx
pop rbx
retn
| long long js_typed_array_get_byteOffset(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
long long typed_array; // rax
long long v15; // rbx
long long v16; // rax
long long v17; // rcx
double v18; // rsi
typed_array = get_typed_array(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
if ( typed_array )
{
v15 = typed_array;
if ( typed_array_is_oob(typed_array) )
{
v16 = 0LL;
v17 = 0LL;
}
else
{
v18 = (double)*(int *)(*(_QWORD *)(v15 + 48) + 32LL);
if ( *(int *)(*(_QWORD *)(v15 + 48) + 32LL) >= 0LL )
*(_QWORD *)&v18 = *(int *)(*(_QWORD *)(v15 + 48) + 32LL);
v17 = *(_QWORD *)&v18 & 0x7FFFFFFF00000000LL;
v16 = LODWORD(v18);
}
}
else
{
v16 = 0LL;
v17 = 0LL;
}
return v17 | v16;
}
| js_typed_array_get_byteOffset:
PUSH RBX
CALL 0x00131c8f
TEST RAX,RAX
JZ 0x0016b66c
MOV RBX,RAX
MOV RDI,RAX
CALL 0x00131cba
TEST EAX,EAX
JZ 0x0016b675
XOR EAX,EAX
XOR ECX,ECX
XOR EDX,EDX
JMP 0x0016b6a8
LAB_0016b66c:
PUSH 0x6
POP RDX
XOR EAX,EAX
XOR ECX,ECX
JMP 0x0016b6a8
LAB_0016b675:
MOV RAX,qword ptr [RBX + 0x30]
MOVSXD RAX,dword ptr [RAX + 0x20]
XOR ECX,ECX
MOV EDX,EAX
CVTSI2SD XMM0,RDX
TEST RAX,RAX
MOVQ RSI,XMM0
CMOVNS RSI,RAX
PUSH 0x7
POP RDX
CMOVNS RDX,RCX
MOV RCX,0x7fffffff00000000
AND RCX,RSI
MOV EAX,ESI
LAB_0016b6a8:
OR RAX,RCX
POP RBX
RET
|
int1 [16] js_typed_array_get_byteOffset(void)
{
uint uVar1;
int iVar2;
long lVar3;
ulong uVar4;
double dVar5;
ulong uVar6;
int8 uVar7;
double dVar8;
int1 auVar9 [16];
lVar3 = get_typed_array();
if (lVar3 == 0) {
uVar7 = 6;
uVar4 = 0;
uVar6 = 0;
}
else {
iVar2 = typed_array_is_oob(lVar3);
if (iVar2 == 0) {
uVar1 = *(uint *)(*(long *)(lVar3 + 0x30) + 0x20);
dVar5 = (double)(long)(int)uVar1;
dVar8 = (double)uVar1;
if (-1 < (long)dVar5) {
dVar8 = dVar5;
}
uVar7 = 7;
if (-1 < (long)dVar5) {
uVar7 = 0;
}
uVar6 = (ulong)dVar8 & 0x7fffffff00000000;
uVar4 = (ulong)dVar8 & 0xffffffff;
}
else {
uVar4 = 0;
uVar6 = 0;
uVar7 = 0;
}
}
auVar9._0_8_ = uVar4 | uVar6;
auVar9._8_8_ = uVar7;
return auVar9;
}
| |
44,747 | glfwInputKey | untodesu[P]riteg/build_O2/_deps/glfw-src/src/input.c | void _glfwInputKey(_GLFWwindow* window, int key, int scancode, int action, int mods)
{
if (key >= 0 && key <= GLFW_KEY_LAST)
{
GLFWbool repeated = GLFW_FALSE;
if (action == GLFW_RELEASE && window->keys[key] == GLFW_RELEASE)
return;
if (action == GLFW_PRESS && window->keys[key] == GLFW_PRESS)
repeated = GLFW_TRUE;
if (action == GLFW_RELEASE && window->stickyKeys)
window->keys[key] = _GLFW_STICK;
else
window->keys[key] = (char) action;
if (repeated)
action = GLFW_REPEAT;
}
if (!window->lockKeyMods)
mods &= ~(GLFW_MOD_CAPS_LOCK | GLFW_MOD_NUM_LOCK);
if (window->callbacks.key)
window->callbacks.key((GLFWwindow*) window, key, scancode, action, mods);
} | O2 | c | glfwInputKey:
cmpl $0x15c, %esi # imm = 0x15C
ja 0x15af7
movl %esi, %eax
cmpl $0x1, %ecx
je 0x15ad9
testl %ecx, %ecx
jne 0x15af0
cmpb $0x0, 0x80(%rdi,%rax)
je 0x15b17
cmpl $0x0, 0x68(%rdi)
je 0x15b18
movb $0x3, 0x80(%rdi,%rax)
jmp 0x15af7
cmpb $0x1, 0x80(%rdi,%rax)
movb $0x1, 0x80(%rdi,%rax)
jne 0x15af7
pushq $0x2
popq %rcx
jmp 0x15af7
movb %cl, 0x80(%rdi,%rax)
movq 0x320(%rdi), %r9
testq %r9, %r9
je 0x15b17
movl %r8d, %eax
andl $-0x31, %eax
cmpl $0x0, 0x70(%rdi)
cmovnel %r8d, %eax
movl %eax, %r8d
jmpq *%r9
retq
movb $0x0, 0x80(%rdi,%rax)
jmp 0x15af7
| _glfwInputKey:
cmp esi, 15Ch
ja short loc_15AF7
mov eax, esi
cmp ecx, 1
jz short loc_15AD9
test ecx, ecx
jnz short loc_15AF0
cmp byte ptr [rdi+rax+80h], 0
jz short locret_15B17
cmp dword ptr [rdi+68h], 0
jz short loc_15B18
mov byte ptr [rdi+rax+80h], 3
jmp short loc_15AF7
loc_15AD9:
cmp byte ptr [rdi+rax+80h], 1
mov byte ptr [rdi+rax+80h], 1
jnz short loc_15AF7
push 2
pop rcx
jmp short loc_15AF7
loc_15AF0:
mov [rdi+rax+80h], cl
loc_15AF7:
mov r9, [rdi+320h]
test r9, r9
jz short locret_15B17
mov eax, r8d
and eax, 0FFFFFFCFh
cmp dword ptr [rdi+70h], 0
cmovnz eax, r8d
mov r8d, eax
jmp r9
locret_15B17:
retn
loc_15B18:
mov byte ptr [rdi+rax+80h], 0
jmp short loc_15AF7
| void glfwInputKey(long long a1, long long a2, long long a3, long long a4, unsigned int a5)
{
bool v5; // zf
void ( *v6)(long long, long long, long long, long long, _QWORD); // r9
unsigned int v7; // eax
if ( (unsigned int)a2 <= 0x15C )
{
if ( (_DWORD)a4 == 1 )
{
v5 = *(_BYTE *)(a1 + (unsigned int)a2 + 128) == 1;
*(_BYTE *)(a1 + (unsigned int)a2 + 128) = 1;
if ( v5 )
a4 = 2LL;
}
else if ( (_DWORD)a4 )
{
*(_BYTE *)(a1 + (unsigned int)a2 + 128) = a4;
}
else
{
if ( !*(_BYTE *)(a1 + (unsigned int)a2 + 128) )
return;
if ( *(_DWORD *)(a1 + 104) )
*(_BYTE *)(a1 + (unsigned int)a2 + 128) = 3;
else
*(_BYTE *)(a1 + (unsigned int)a2 + 128) = 0;
}
}
v6 = *(void ( **)(long long, long long, long long, long long, _QWORD))(a1 + 800);
if ( v6 )
{
v7 = a5 & 0xFFFFFFCF;
if ( *(_DWORD *)(a1 + 112) )
v7 = a5;
v6(a1, a2, a3, a4, v7);
}
}
| _glfwInputKey:
CMP ESI,0x15c
JA 0x00115af7
MOV EAX,ESI
CMP ECX,0x1
JZ 0x00115ad9
TEST ECX,ECX
JNZ 0x00115af0
CMP byte ptr [RDI + RAX*0x1 + 0x80],0x0
JZ 0x00115b17
CMP dword ptr [RDI + 0x68],0x0
JZ 0x00115b18
MOV byte ptr [RDI + RAX*0x1 + 0x80],0x3
JMP 0x00115af7
LAB_00115ad9:
CMP byte ptr [RDI + RAX*0x1 + 0x80],0x1
MOV byte ptr [RDI + RAX*0x1 + 0x80],0x1
JNZ 0x00115af7
PUSH 0x2
POP RCX
JMP 0x00115af7
LAB_00115af0:
MOV byte ptr [RDI + RAX*0x1 + 0x80],CL
LAB_00115af7:
MOV R9,qword ptr [RDI + 0x320]
TEST R9,R9
JZ 0x00115b17
MOV EAX,R8D
AND EAX,0xffffffcf
CMP dword ptr [RDI + 0x70],0x0
CMOVNZ EAX,R8D
MOV R8D,EAX
JMP R9
LAB_00115b17:
RET
LAB_00115b18:
MOV byte ptr [RDI + RAX*0x1 + 0x80],0x0
JMP 0x00115af7
|
void _glfwInputKey(long param_1,uint param_2,int8 param_3,int param_4)
{
ulong uVar1;
if (param_2 < 0x15d) {
uVar1 = (ulong)param_2;
if (param_4 == 1) {
*(int1 *)(param_1 + 0x80 + uVar1) = 1;
}
else if (param_4 == 0) {
if (*(char *)(param_1 + 0x80 + uVar1) == '\0') {
return;
}
if (*(int *)(param_1 + 0x68) == 0) {
*(int1 *)(param_1 + 0x80 + uVar1) = 0;
}
else {
*(int1 *)(param_1 + 0x80 + uVar1) = 3;
}
}
else {
*(char *)(param_1 + 0x80 + uVar1) = (char)param_4;
}
}
if (*(code **)(param_1 + 800) == (code *)0x0) {
return;
}
/* WARNING: Could not recover jumptable at 0x00115b14. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(param_1 + 800))();
return;
}
| |
44,748 | ggml_conv_1d_dw | ngxson[P]ggml-easy/ggml/src/ggml.c | struct ggml_tensor * ggml_conv_1d_dw(
struct ggml_context * ctx,
struct ggml_tensor * a,
struct ggml_tensor * b,
int s0,
int p0,
int d0) {
struct ggml_tensor * new_a = ggml_reshape_4d(ctx, a, a->ne[0], 1, a->ne[1], a->ne[2]);
struct ggml_tensor * new_b = ggml_reshape_4d(ctx, b, b->ne[0], 1, b->ne[1], b->ne[2]);
struct ggml_tensor * im2col = ggml_im2col(ctx, new_a, new_b, s0, 0, p0, 0, d0, 0, false, GGML_TYPE_F16);
struct ggml_tensor * result = ggml_mul_mat(ctx, im2col, a);
result = ggml_reshape_3d(ctx, result, b->ne[0], b->ne[1], 1);
return result;
} | O1 | c | ggml_conv_1d_dw:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movl %r8d, %ebp
movl %ecx, %r13d
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rsi), %rdx
movq 0x18(%rsi), %r8
movq 0x20(%rsi), %r9
movl $0x1, %ecx
callq 0x17230
movq %rax, %r12
movq 0x10(%r14), %rdx
movq 0x18(%r14), %r8
movq 0x20(%r14), %r9
movl $0x1, %ecx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x17230
subq $0x8, %rsp
xorl %r10d, %r10d
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
movl %r13d, %ecx
xorl %r8d, %r8d
movl %ebp, %r9d
pushq $0x1
pushq %r10
pushq %r10
pushq 0x20(%rsp)
pushq %r10
callq 0x17b80
addq $0x30, %rsp
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x16960
movq 0x10(%r14), %rdx
movq 0x18(%r14), %rcx
movl $0x1, %r8d
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x17050
| ggml_conv_1d_dw:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov [rsp+38h+var_38], r9
mov ebp, r8d
mov r13d, ecx
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov rdx, [rsi+10h]
mov r8, [rsi+18h]
mov r9, [rsi+20h]
mov ecx, 1
call _ggml_reshape_4d
mov r12, rax
mov rdx, [r14+10h]
mov r8, [r14+18h]
mov r9, [r14+20h]
mov ecx, 1
mov rdi, rbx
mov rsi, r14
call _ggml_reshape_4d
sub rsp, 8
xor r10d, r10d
mov rdi, rbx
mov rsi, r12
mov rdx, rax
mov ecx, r13d
xor r8d, r8d
mov r9d, ebp
push 1
push r10
push r10
push [rsp+58h+var_38]
push r10
call _ggml_im2col
add rsp, 30h
mov rdi, rbx
mov rsi, rax
mov rdx, r15
call _ggml_mul_mat
mov rdx, [r14+10h]
mov rcx, [r14+18h]
mov r8d, 1
mov rdi, rbx
mov rsi, rax
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _ggml_reshape_3d
| long long ggml_conv_1d_dw(long long a1, long long *a2, long long *a3, int a4, int a5, int a6)
{
_QWORD *v9; // r12
_QWORD *v10; // rax
_QWORD *v11; // rax
long long v12; // rcx
int v13; // r8d
int v14; // r9d
long long v15; // rax
v9 = (_QWORD *)ggml_reshape_4d(a1, (long long)a2, a2[2], 1LL, a2[3], a2[4]);
v10 = (_QWORD *)ggml_reshape_4d(a1, (long long)a3, a3[2], 1LL, a3[3], a3[4]);
v11 = (_QWORD *)ggml_im2col(a1, v9, v10, a4, 0, a5, 0, a6, 0, 0, 1u);
v15 = ggml_mul_mat(a1, v11, (long long)a2, v12, v13, v14);
return ggml_reshape_3d(a1, v15, a3[2], a3[3], 1LL);
}
| ggml_conv_1d_dw:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV qword ptr [RSP],R9
MOV EBP,R8D
MOV R13D,ECX
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV RDX,qword ptr [RSI + 0x10]
MOV R8,qword ptr [RSI + 0x18]
MOV R9,qword ptr [RSI + 0x20]
MOV ECX,0x1
CALL 0x00117230
MOV R12,RAX
MOV RDX,qword ptr [R14 + 0x10]
MOV R8,qword ptr [R14 + 0x18]
MOV R9,qword ptr [R14 + 0x20]
MOV ECX,0x1
MOV RDI,RBX
MOV RSI,R14
CALL 0x00117230
SUB RSP,0x8
XOR R10D,R10D
MOV RDI,RBX
MOV RSI,R12
MOV RDX,RAX
MOV ECX,R13D
XOR R8D,R8D
MOV R9D,EBP
PUSH 0x1
PUSH R10
PUSH R10
PUSH qword ptr [RSP + 0x20]
PUSH R10
CALL 0x00117b80
ADD RSP,0x30
MOV RDI,RBX
MOV RSI,RAX
MOV RDX,R15
CALL 0x00116960
MOV RDX,qword ptr [R14 + 0x10]
MOV RCX,qword ptr [R14 + 0x18]
MOV R8D,0x1
MOV RDI,RBX
MOV RSI,RAX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00117050
|
void ggml_conv_1d_dw(int8 param_1,long param_2,long param_3,int4 param_4,
int4 param_5,int8 param_6)
{
int8 uVar1;
int8 uVar2;
uVar1 = ggml_reshape_4d(param_1,param_2,*(int8 *)(param_2 + 0x10),1,
*(int8 *)(param_2 + 0x18),*(int8 *)(param_2 + 0x20),param_6);
uVar2 = ggml_reshape_4d(param_1,param_3,*(int8 *)(param_3 + 0x10),1,
*(int8 *)(param_3 + 0x18),*(int8 *)(param_3 + 0x20));
uVar1 = ggml_im2col(param_1,uVar1,uVar2,param_4,0,param_5,0,param_6,0,0,1);
uVar1 = ggml_mul_mat(param_1,uVar1,param_2);
ggml_reshape_3d(param_1,uVar1,*(int8 *)(param_3 + 0x10),*(int8 *)(param_3 + 0x18),1);
return;
}
| |
44,749 | ggml_conv_1d_dw | ngxson[P]ggml-easy/ggml/src/ggml.c | struct ggml_tensor * ggml_conv_1d_dw(
struct ggml_context * ctx,
struct ggml_tensor * a,
struct ggml_tensor * b,
int s0,
int p0,
int d0) {
struct ggml_tensor * new_a = ggml_reshape_4d(ctx, a, a->ne[0], 1, a->ne[1], a->ne[2]);
struct ggml_tensor * new_b = ggml_reshape_4d(ctx, b, b->ne[0], 1, b->ne[1], b->ne[2]);
struct ggml_tensor * im2col = ggml_im2col(ctx, new_a, new_b, s0, 0, p0, 0, d0, 0, false, GGML_TYPE_F16);
struct ggml_tensor * result = ggml_mul_mat(ctx, im2col, a);
result = ggml_reshape_3d(ctx, result, b->ne[0], b->ne[1], 1);
return result;
} | O2 | c | ggml_conv_1d_dw:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, %r15d
movl %r8d, 0x34(%rsp)
movl %ecx, 0x30(%rsp)
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq 0x10(%rsi), %rdx
movq 0x18(%rsi), %r8
movq 0x20(%rsi), %r9
pushq $0x1
popq %r13
movq %r13, %rcx
callq 0x1d900
movq %rax, %rbp
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %r8
movq 0x20(%rbx), %r9
movq %r14, %rdi
movq %rbx, %rsi
movq %r13, %rcx
callq 0x1d900
andl $0x0, 0x18(%rsp)
andl $0x0, 0x10(%rsp)
andl $0x0, (%rsp)
movl %r15d, 0x8(%rsp)
movl $0x1, 0x20(%rsp)
movq %r14, %rdi
movq %rbp, %rsi
movq %rax, %rdx
movl 0x30(%rsp), %ecx
xorl %r8d, %r8d
movl 0x34(%rsp), %r9d
callq 0x1e610
movq %r14, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x1cd00
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rcx
movq %r14, %rdi
movq %rax, %rsi
movq %r13, %r8
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1d6b0
| ggml_conv_1d_dw:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r15d, r9d
mov [rsp+68h+var_34], r8d
mov [rsp+68h+var_38], ecx
mov rbx, rdx
mov r12, rsi
mov r14, rdi
mov rdx, [rsi+10h]
mov r8, [rsi+18h]
mov r9, [rsi+20h]
push 1
pop r13
mov rcx, r13
call _ggml_reshape_4d
mov rbp, rax
mov rdx, [rbx+10h]
mov r8, [rbx+18h]
mov r9, [rbx+20h]
mov rdi, r14
mov rsi, rbx
mov rcx, r13
call _ggml_reshape_4d
and [rsp+68h+var_50], 0
and [rsp+68h+var_58], 0
and [rsp+68h+var_68], 0
mov [rsp+68h+var_60], r15d
mov [rsp+68h+var_48], 1
mov rdi, r14
mov rsi, rbp
mov rdx, rax
mov ecx, [rsp+68h+var_38]
xor r8d, r8d
mov r9d, [rsp+68h+var_34]
call _ggml_im2col
mov rdi, r14
mov rsi, rax
mov rdx, r12
call _ggml_mul_mat
mov rdx, [rbx+10h]
mov rcx, [rbx+18h]
mov rdi, r14
mov rsi, rax
mov r8, r13
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _ggml_reshape_3d
| long long ggml_conv_1d_dw(
long long a1,
long long *a2,
long long *a3,
int a4,
unsigned int a5,
int a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
double a11,
double a12,
__m128 a13,
__m128 a14)
{
_QWORD *v16; // rbp
double v17; // xmm4_8
double v18; // xmm5_8
_QWORD *v19; // rax
__m128 v20; // xmm4
__m128 v21; // xmm5
_QWORD *v22; // rax
double v23; // xmm4_8
double v24; // xmm5_8
long long v25; // rax
double v26; // xmm4_8
double v27; // xmm5_8
v16 = (_QWORD *)ggml_reshape_4d(a1, (long long)a2, a2[2], 1LL, a2[3], a2[4], a7, a8, a9, a10, a11, a12, a13, a14);
v19 = (_QWORD *)ggml_reshape_4d(a1, (long long)a3, a3[2], 1LL, a3[3], a3[4], a7, a8, a9, a10, v17, v18, a13, a14);
v22 = (_QWORD *)ggml_im2col(a1, v16, v19, a4, 0LL, a5, a7, a8, a9, a10, v20, v21, a13, a14, 0, a6, 0, 0, 1u);
v25 = ggml_mul_mat(a1, v22, (long long)a2, a7, a8, a9, a10, v23, v24, a13, a14);
return ggml_reshape_3d(a1, v25, a3[2], a3[3], 1LL, a7, a8, a9, a10, v26, v27, a13, a14);
}
| ggml_conv_1d_dw:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R15D,R9D
MOV dword ptr [RSP + 0x34],R8D
MOV dword ptr [RSP + 0x30],ECX
MOV RBX,RDX
MOV R12,RSI
MOV R14,RDI
MOV RDX,qword ptr [RSI + 0x10]
MOV R8,qword ptr [RSI + 0x18]
MOV R9,qword ptr [RSI + 0x20]
PUSH 0x1
POP R13
MOV RCX,R13
CALL 0x0011d900
MOV RBP,RAX
MOV RDX,qword ptr [RBX + 0x10]
MOV R8,qword ptr [RBX + 0x18]
MOV R9,qword ptr [RBX + 0x20]
MOV RDI,R14
MOV RSI,RBX
MOV RCX,R13
CALL 0x0011d900
AND dword ptr [RSP + 0x18],0x0
AND dword ptr [RSP + 0x10],0x0
AND dword ptr [RSP],0x0
MOV dword ptr [RSP + 0x8],R15D
MOV dword ptr [RSP + 0x20],0x1
MOV RDI,R14
MOV RSI,RBP
MOV RDX,RAX
MOV ECX,dword ptr [RSP + 0x30]
XOR R8D,R8D
MOV R9D,dword ptr [RSP + 0x34]
CALL 0x0011e610
MOV RDI,R14
MOV RSI,RAX
MOV RDX,R12
CALL 0x0011cd00
MOV RDX,qword ptr [RBX + 0x10]
MOV RCX,qword ptr [RBX + 0x18]
MOV RDI,R14
MOV RSI,RAX
MOV R8,R13
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0011d6b0
|
void ggml_conv_1d_dw(int8 param_1,long param_2,long param_3,int4 param_4,
int4 param_5,int4 param_6)
{
int8 uVar1;
int8 uVar2;
uVar1 = ggml_reshape_4d(param_1,param_2,*(int8 *)(param_2 + 0x10),1,
*(int8 *)(param_2 + 0x18),*(int8 *)(param_2 + 0x20));
uVar2 = ggml_reshape_4d(param_1,param_3,*(int8 *)(param_3 + 0x10),1,
*(int8 *)(param_3 + 0x18),*(int8 *)(param_3 + 0x20));
uVar1 = ggml_im2col(param_1,uVar1,uVar2,param_4,0,param_5,0,param_6,0,0,1);
uVar1 = ggml_mul_mat(param_1,uVar1,param_2);
ggml_reshape_3d(param_1,uVar1,*(int8 *)(param_3 + 0x10),*(int8 *)(param_3 + 0x18),1);
return;
}
| |
44,750 | handleAbsEvent | untodesu[P]riteg/build_O2/_deps/glfw-src/src/linux_joystick.c | static void handleAbsEvent(_GLFWjoystick* js, int code, int value)
{
const int index = js->linjs.absMap[code];
if (code >= ABS_HAT0X && code <= ABS_HAT3Y)
{
static const char stateMap[3][3] =
{
{ GLFW_HAT_CENTERED, GLFW_HAT_UP, GLFW_HAT_DOWN },
{ GLFW_HAT_LEFT, GLFW_HAT_LEFT_UP, GLFW_HAT_LEFT_DOWN },
{ GLFW_HAT_RIGHT, GLFW_HAT_RIGHT_UP, GLFW_HAT_RIGHT_DOWN },
};
const int hat = (code - ABS_HAT0X) / 2;
const int axis = (code - ABS_HAT0X) % 2;
int* state = js->linjs.hats[hat];
// NOTE: Looking at several input drivers, it seems all hat events use
// -1 for left / up, 0 for centered and 1 for right / down
if (value == 0)
state[axis] = 0;
else if (value < 0)
state[axis] = 1;
else if (value > 0)
state[axis] = 2;
_glfwInputJoystickHat(js, index, stateMap[state[0]][state[1]]);
}
else
{
const struct input_absinfo* info = &js->linjs.absInfo[code];
float normalized = value;
const int range = info->maximum - info->minimum;
if (range)
{
// Normalize to 0.0 -> 1.0
normalized = (normalized - info->minimum) / range;
// Normalize to -1.0 -> 1.0
normalized = normalized * 2.0f - 1.0f;
}
_glfwInputJoystickAxis(js, index, normalized);
}
} | O2 | c | handleAbsEvent:
movl %esi, %eax
movslq %esi, %rcx
movl 0x187c(%rdi,%rcx,4), %esi
movl %ecx, %r8d
andl $-0x8, %r8d
cmpl $0x10, %r8d
jne 0x24257
leal -0x10(%rax), %ecx
shrl %ecx
andl $0x1, %eax
leaq (%rdi,%rcx,8), %rcx
addq $0x1f7c, %rcx # imm = 0x1F7C
movl %eax, %eax
testl %edx, %edx
je 0x24296
js 0x2429c
movl $0x2, (%rcx,%rax,4)
jmp 0x242a3
cvtsi2ss %edx, %xmm0
imulq $0x18, %rcx, %rax
movl 0x1980(%rdi,%rax), %ecx
movl 0x1984(%rdi,%rax), %eax
subl %ecx, %eax
je 0x15c5a
cvtsi2ss %ecx, %xmm1
subss %xmm1, %xmm0
cvtsi2ss %eax, %xmm1
divss %xmm1, %xmm0
addss %xmm0, %xmm0
addss 0x4d977(%rip), %xmm0 # 0x71c08
jmp 0x15c5a
andl $0x0, (%rcx,%rax,4)
jmp 0x242a3
movl $0x1, (%rcx,%rax,4)
movslq (%rcx), %rax
movslq 0x4(%rcx), %rcx
leaq (%rax,%rax,2), %rax
leaq 0x52cb8(%rip), %rdx # 0x76f6d
addq %rax, %rdx
movsbl (%rcx,%rdx), %edx
jmp 0x15c72
| handleAbsEvent:
mov eax, esi
movsxd rcx, esi
mov esi, [rdi+rcx*4+187Ch]
mov r8d, ecx
and r8d, 0FFFFFFF8h
cmp r8d, 10h
jnz short loc_24257
lea ecx, [rax-10h]
shr ecx, 1
and eax, 1
lea rcx, [rdi+rcx*8]
add rcx, 1F7Ch
mov eax, eax
test edx, edx
jz short loc_24296
js short loc_2429C
mov dword ptr [rcx+rax*4], 2
jmp short loc_242A3
loc_24257:
cvtsi2ss xmm0, edx
imul rax, rcx, 18h
mov ecx, [rdi+rax+1980h]
mov eax, [rdi+rax+1984h]
sub eax, ecx
jz _glfwInputJoystickAxis
cvtsi2ss xmm1, ecx
subss xmm0, xmm1
cvtsi2ss xmm1, eax
divss xmm0, xmm1
addss xmm0, xmm0
addss xmm0, cs:dword_71C08
jmp _glfwInputJoystickAxis
loc_24296:
and dword ptr [rcx+rax*4], 0
jmp short loc_242A3
loc_2429C:
mov dword ptr [rcx+rax*4], 1
loc_242A3:
movsxd rax, dword ptr [rcx]
movsxd rcx, dword ptr [rcx+4]
lea rax, [rax+rax*2]
lea rdx, handleAbsEvent_stateMap
add rdx, rax
movsx edx, byte ptr [rcx+rdx]
jmp _glfwInputJoystickHat
| long long handleAbsEvent(long long a1, int a2, int a3)
{
long long v4; // rcx
int v5; // esi
int *v6; // rcx
long long v7; // rax
float v8; // xmm0_4
long long v9; // rax
int v10; // ecx
int v11; // eax
v4 = a2;
v5 = *(_DWORD *)(a1 + 4LL * a2 + 6268);
if ( (v4 & 0xFFFFFFF8) == 0x10 )
{
v6 = (int *)(a1 + 8LL * ((unsigned int)(a2 - 16) >> 1) + 8060);
v7 = a2 & 1;
if ( a3 )
{
if ( a3 < 0 )
v6[v7] = 1;
else
v6[v7] = 2;
}
else
{
v6[v7] = 0;
}
return glfwInputJoystickHat(a1, v5, handleAbsEvent_stateMap[3 * *v6 + v6[1]]);
}
else
{
v8 = (float)a3;
v9 = 24 * v4;
v10 = *(_DWORD *)(a1 + 24 * v4 + 6528);
v11 = *(_DWORD *)(a1 + v9 + 6532) - v10;
if ( v11 )
return glfwInputJoystickAxis(
a1,
v5,
(float)((float)((float)(v8 - (float)v10) / (float)v11) + (float)((float)(v8 - (float)v10) / (float)v11))
+ -1.0);
else
return glfwInputJoystickAxis(a1, v5, v8);
}
}
| handleAbsEvent:
MOV EAX,ESI
MOVSXD RCX,ESI
MOV ESI,dword ptr [RDI + RCX*0x4 + 0x187c]
MOV R8D,ECX
AND R8D,0xfffffff8
CMP R8D,0x10
JNZ 0x00124257
LEA ECX,[RAX + -0x10]
SHR ECX,0x1
AND EAX,0x1
LEA RCX,[RDI + RCX*0x8]
ADD RCX,0x1f7c
MOV EAX,EAX
TEST EDX,EDX
JZ 0x00124296
JS 0x0012429c
MOV dword ptr [RCX + RAX*0x4],0x2
JMP 0x001242a3
LAB_00124257:
CVTSI2SS XMM0,EDX
IMUL RAX,RCX,0x18
MOV ECX,dword ptr [RDI + RAX*0x1 + 0x1980]
MOV EAX,dword ptr [RDI + RAX*0x1 + 0x1984]
SUB EAX,ECX
JZ 0x00115c5a
CVTSI2SS XMM1,ECX
SUBSS XMM0,XMM1
CVTSI2SS XMM1,EAX
DIVSS XMM0,XMM1
ADDSS XMM0,XMM0
ADDSS XMM0,dword ptr [0x00171c08]
JMP 0x00115c5a
LAB_00124296:
AND dword ptr [RCX + RAX*0x4],0x0
JMP 0x001242a3
LAB_0012429c:
MOV dword ptr [RCX + RAX*0x4],0x1
LAB_001242a3:
MOVSXD RAX,dword ptr [RCX]
MOVSXD RCX,dword ptr [RCX + 0x4]
LEA RAX,[RAX + RAX*0x2]
LEA RDX,[0x176f6d]
ADD RDX,RAX
MOVSX EDX,byte ptr [RCX + RDX*0x1]
JMP 0x00115c72
|
void handleAbsEvent(long param_1,uint param_2,int param_3)
{
int iVar1;
int iVar2;
uint uVar3;
int iVar4;
long lVar5;
int *piVar6;
float fVar7;
iVar1 = *(int *)(param_1 + 0x187c + (long)(int)param_2 * 4);
if ((param_2 & 0xfffffff8) == 0x10) {
uVar3 = param_2 & 1;
lVar5 = param_1 + (ulong)(param_2 - 0x10 >> 1) * 8;
piVar6 = (int *)(lVar5 + 0x1f7c);
if (param_3 == 0) {
piVar6[uVar3] = 0;
}
else if (param_3 < 0) {
piVar6[uVar3] = 1;
}
else {
piVar6[uVar3] = 2;
}
_glfwInputJoystickHat
(param_1,iVar1,
(int)(char)handleAbsEvent_stateMap
[(long)*(int *)(lVar5 + 0x1f80) + (long)*piVar6 * 3]);
return;
}
lVar5 = (long)(int)param_2 * 0x18;
iVar2 = *(int *)(param_1 + 0x1980 + lVar5);
iVar4 = *(int *)(param_1 + 0x1984 + lVar5) - iVar2;
if (iVar4 != 0) {
fVar7 = ((float)param_3 - (float)iVar2) / (float)iVar4;
_glfwInputJoystickAxis(fVar7 + fVar7 + DAT_00171c08);
return;
}
*(float *)(*(long *)(param_1 + 8) + (long)iVar1 * 4) = (float)param_3;
return;
}
| |
44,751 | ma_update_dynamic_record | eloqsql/storage/maria/ma_dynrec.c | my_bool _ma_update_dynamic_record(MARIA_HA *info, MARIA_RECORD_POS pos,
const uchar *oldrec __attribute__ ((unused)),
const uchar *record)
{
uint length= _ma_rec_pack(info, info->rec_buff + MARIA_REC_BUFF_OFFSET,
record);
if (!length)
return 1;
return (update_dynamic_record(info, pos,
info->rec_buff + MARIA_REC_BUFF_OFFSET,
length));
} | O0 | c | ma_update_dynamic_record:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x3a0(%rax), %rsi
addq $0x18, %rsi
movq -0x28(%rbp), %rdx
callq 0x4cf50
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x4d6f3
movb $0x1, -0x1(%rbp)
jmp 0x4d717
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x3a0(%rax), %rdx
addq $0x18, %rdx
movl -0x2c(%rbp), %eax
movl %eax, %ecx
callq 0x4d720
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
| _ma_update_dynamic_record:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rdi, [rbp+var_10]
mov rax, [rbp+var_10]
mov rsi, [rax+3A0h]
add rsi, 18h
mov rdx, [rbp+var_28]
call _ma_rec_pack
mov [rbp+var_2C], eax
cmp [rbp+var_2C], 0
jnz short loc_4D6F3
mov [rbp+var_1], 1
jmp short loc_4D717
loc_4D6F3:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rax, [rbp+var_10]
mov rdx, [rax+3A0h]
add rdx, 18h
mov eax, [rbp+var_2C]
mov ecx, eax
call update_dynamic_record
mov [rbp+var_1], al
loc_4D717:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
| char ma_update_dynamic_record(long long a1, long long a2, long long a3, _BYTE *a4)
{
unsigned int v5; // [rsp+4h] [rbp-2Ch]
v5 = ma_rec_pack((_DWORD *)a1, (_BYTE *)(*(_QWORD *)(a1 + 928) + 24LL), a4);
if ( v5 )
return update_dynamic_record(a1, a2, *(_QWORD *)(a1 + 928) + 24LL, v5);
else
return 1;
}
| _ma_update_dynamic_record:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x3a0]
ADD RSI,0x18
MOV RDX,qword ptr [RBP + -0x28]
CALL 0x0014cf50
MOV dword ptr [RBP + -0x2c],EAX
CMP dword ptr [RBP + -0x2c],0x0
JNZ 0x0014d6f3
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0014d717
LAB_0014d6f3:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x3a0]
ADD RDX,0x18
MOV EAX,dword ptr [RBP + -0x2c]
MOV ECX,EAX
CALL 0x0014d720
MOV byte ptr [RBP + -0x1],AL
LAB_0014d717:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int1
_ma_update_dynamic_record(long param_1,int8 param_2,int8 param_3,int8 param_4)
{
int iVar1;
int1 local_9;
iVar1 = _ma_rec_pack(param_1,*(long *)(param_1 + 0x3a0) + 0x18,param_4);
if (iVar1 == 0) {
local_9 = 1;
}
else {
local_9 = update_dynamic_record(param_1,param_2,*(long *)(param_1 + 0x3a0) + 0x18,iVar1);
}
return local_9;
}
| |
44,752 | add_export_entry2 | bluesky950520[P]quickjs/quickjs.c | static JSExportEntry *add_export_entry2(JSContext *ctx,
JSParseState *s, JSModuleDef *m,
JSAtom local_name, JSAtom export_name,
JSExportTypeEnum export_type)
{
JSExportEntry *me;
if (find_export_entry(ctx, m, export_name)) {
char buf1[ATOM_GET_STR_BUF_SIZE];
if (s) {
js_parse_error(s, "duplicate exported name '%s'",
JS_AtomGetStr(ctx, buf1, sizeof(buf1), export_name));
} else {
JS_ThrowSyntaxErrorAtom(ctx, "duplicate exported name '%s'", export_name);
}
return NULL;
}
if (js_resize_array(ctx, (void **)&m->export_entries,
sizeof(JSExportEntry),
&m->export_entries_size,
m->export_entries_count + 1))
return NULL;
me = &m->export_entries[m->export_entries_count++];
memset(me, 0, sizeof(*me));
me->local_name = JS_DupAtom(ctx, local_name);
me->export_name = JS_DupAtom(ctx, export_name);
me->export_type = export_type;
return me;
} | O2 | c | add_export_entry2:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, %ebp
movl %r8d, %ebx
movl %ecx, %r15d
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movq %rdx, %rdi
movl %r8d, %esi
callq 0x2910e
testq %rax, %rax
je 0x28ff4
testq %r13, %r13
je 0x29079
movq %rsp, %rsi
movq %r14, %rdi
movl %ebx, %edx
callq 0x2f335
leaq 0x5d6a2(%rip), %rsi # 0x86684
movq %r13, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x28457
jmp 0x2908a
leaq 0x28(%r12), %rsi
leaq 0x34(%r12), %rcx
movl 0x30(%r12), %r8d
incl %r8d
pushq $0x20
popq %rdx
movq %r14, %rdi
callq 0x3b0ef
testl %eax, %eax
jne 0x2908a
movq 0x28(%r12), %rcx
movslq 0x30(%r12), %rdx
leal 0x1(%rdx), %eax
movl %eax, 0x30(%r12)
shlq $0x5, %rdx
leaq (%rcx,%rdx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rcx,%rdx)
movups %xmm0, (%rcx,%rdx)
cmpl $0xe0, %r15d
jl 0x29055
movq 0x18(%r14), %rcx
movq 0x68(%rcx), %rcx
movl %r15d, %edx
movq (%rcx,%rdx,8), %rcx
incl (%rcx)
movl %r15d, 0x14(%rax)
cmpl $0xe0, %ebx
jl 0x29071
movq 0x18(%r14), %rcx
movq 0x68(%rcx), %rcx
movl %ebx, %edx
movq (%rcx,%rdx,8), %rcx
incl (%rcx)
movl %ebx, 0x18(%rax)
movl %ebp, 0x10(%rax)
jmp 0x2908c
leaq 0x5d604(%rip), %rdx # 0x86684
movq %r14, %rdi
movl %ebx, %esi
callq 0x394c3
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| add_export_entry2:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov ebp, r9d
mov ebx, r8d
mov r15d, ecx
mov r12, rdx
mov r13, rsi
mov r14, rdi
mov rdi, rdx
mov esi, r8d
call find_export_entry
test rax, rax
jz short loc_28FF4
test r13, r13
jz loc_29079
mov rsi, rsp
mov rdi, r14
mov edx, ebx
call JS_AtomGetStr
lea rsi, aDuplicateExpor; "duplicate exported name '%s'"
mov rdi, r13
mov rdx, rax
xor eax, eax
call js_parse_error
jmp loc_2908A
loc_28FF4:
lea rsi, [r12+28h]
lea rcx, [r12+34h]
mov r8d, [r12+30h]
inc r8d
push 20h ; ' '
pop rdx
mov rdi, r14
call js_resize_array
test eax, eax
jnz short loc_2908A
mov rcx, [r12+28h]
movsxd rdx, dword ptr [r12+30h]
lea eax, [rdx+1]
mov [r12+30h], eax
shl rdx, 5
lea rax, [rcx+rdx]
xorps xmm0, xmm0
movups xmmword ptr [rcx+rdx+10h], xmm0
movups xmmword ptr [rcx+rdx], xmm0
cmp r15d, 0E0h
jl short loc_29055
mov rcx, [r14+18h]
mov rcx, [rcx+68h]
mov edx, r15d
mov rcx, [rcx+rdx*8]
inc dword ptr [rcx]
loc_29055:
mov [rax+14h], r15d
cmp ebx, 0E0h
jl short loc_29071
mov rcx, [r14+18h]
mov rcx, [rcx+68h]
mov edx, ebx
mov rcx, [rcx+rdx*8]
inc dword ptr [rcx]
loc_29071:
mov [rax+18h], ebx
mov [rax+10h], ebp
jmp short loc_2908C
loc_29079:
lea rdx, aDuplicateExpor; "duplicate exported name '%s'"
mov rdi, r14
mov esi, ebx
call __JS_ThrowSyntaxErrorAtom
loc_2908A:
xor eax, eax
loc_2908C:
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long add_export_entry2(
long long a1,
long long *a2,
long long a3,
int a4,
unsigned int a5,
int a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
double a11,
double a12,
__m128 a13,
__m128 a14)
{
const char *v18; // rcx
long long Str; // rax
long long v20; // rcx
long long v21; // r8
long long v22; // r9
__m128 v23; // xmm4
__m128 v24; // xmm5
long long v25; // rcx
long long v26; // rdx
long long result; // rax
_DWORD *v28; // rcx
_DWORD *v29; // rcx
char v30[120]; // [rsp+0h] [rbp-78h] BYREF
if ( find_export_entry(a3, a5) )
{
if ( a2 )
{
Str = JS_AtomGetStr(a1, v30, a5);
js_parse_error(
a2,
(long long)"duplicate exported name '%s'",
Str,
v20,
v21,
v22,
a7,
a8,
a9,
a10,
v23,
v24,
a13,
a14,
v30[0]);
}
else
{
_JS_ThrowSyntaxErrorAtom(a1, a5, "duplicate exported name '%s'", v18);
}
return 0LL;
}
if ( (unsigned int)js_resize_array(a1, a3 + 40, 32LL, a3 + 52, (unsigned int)(*(_DWORD *)(a3 + 48) + 1)) )
return 0LL;
v25 = *(_QWORD *)(a3 + 40);
v26 = *(int *)(a3 + 48);
*(_DWORD *)(a3 + 48) = v26 + 1;
result = v25 + 32 * v26;
*(_OWORD *)(result + 16) = 0LL;
*(_OWORD *)result = 0LL;
if ( a4 >= 224 )
{
v28 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(a1 + 24) + 104LL) + 8LL * (unsigned int)a4);
++*v28;
}
*(_DWORD *)(result + 20) = a4;
if ( (int)a5 >= 224 )
{
v29 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(a1 + 24) + 104LL) + 8LL * a5);
++*v29;
}
*(_DWORD *)(result + 24) = a5;
*(_DWORD *)(result + 16) = a6;
return result;
}
| add_export_entry2:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV EBP,R9D
MOV EBX,R8D
MOV R15D,ECX
MOV R12,RDX
MOV R13,RSI
MOV R14,RDI
MOV RDI,RDX
MOV ESI,R8D
CALL 0x0012910e
TEST RAX,RAX
JZ 0x00128ff4
TEST R13,R13
JZ 0x00129079
MOV RSI,RSP
MOV RDI,R14
MOV EDX,EBX
CALL 0x0012f335
LEA RSI,[0x186684]
MOV RDI,R13
MOV RDX,RAX
XOR EAX,EAX
CALL 0x00128457
JMP 0x0012908a
LAB_00128ff4:
LEA RSI,[R12 + 0x28]
LEA RCX,[R12 + 0x34]
MOV R8D,dword ptr [R12 + 0x30]
INC R8D
PUSH 0x20
POP RDX
MOV RDI,R14
CALL 0x0013b0ef
TEST EAX,EAX
JNZ 0x0012908a
MOV RCX,qword ptr [R12 + 0x28]
MOVSXD RDX,dword ptr [R12 + 0x30]
LEA EAX,[RDX + 0x1]
MOV dword ptr [R12 + 0x30],EAX
SHL RDX,0x5
LEA RAX,[RCX + RDX*0x1]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RCX + RDX*0x1 + 0x10],XMM0
MOVUPS xmmword ptr [RCX + RDX*0x1],XMM0
CMP R15D,0xe0
JL 0x00129055
MOV RCX,qword ptr [R14 + 0x18]
MOV RCX,qword ptr [RCX + 0x68]
MOV EDX,R15D
MOV RCX,qword ptr [RCX + RDX*0x8]
INC dword ptr [RCX]
LAB_00129055:
MOV dword ptr [RAX + 0x14],R15D
CMP EBX,0xe0
JL 0x00129071
MOV RCX,qword ptr [R14 + 0x18]
MOV RCX,qword ptr [RCX + 0x68]
MOV EDX,EBX
MOV RCX,qword ptr [RCX + RDX*0x8]
INC dword ptr [RCX]
LAB_00129071:
MOV dword ptr [RAX + 0x18],EBX
MOV dword ptr [RAX + 0x10],EBP
JMP 0x0012908c
LAB_00129079:
LEA RDX,[0x186684]
MOV RDI,R14
MOV ESI,EBX
CALL 0x001394c3
LAB_0012908a:
XOR EAX,EAX
LAB_0012908c:
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long add_export_entry2(long param_1,long param_2,long param_3,uint param_4,uint param_5,
int4 param_6)
{
int8 *puVar1;
long lVar2;
int *piVar3;
int iVar4;
long lVar5;
int8 uVar6;
long lVar7;
ulong uVar8;
int1 auStack_78 [72];
uVar8 = (ulong)param_5;
lVar5 = find_export_entry(param_3,param_5);
if (lVar5 == 0) {
iVar4 = js_resize_array(param_1,param_3 + 0x28,0x20,param_3 + 0x34,*(int *)(param_3 + 0x30) + 1)
;
if (iVar4 == 0) {
lVar2 = *(long *)(param_3 + 0x28);
iVar4 = *(int *)(param_3 + 0x30);
*(int *)(param_3 + 0x30) = iVar4 + 1;
lVar7 = (long)iVar4 * 0x20;
lVar5 = lVar2 + lVar7;
puVar1 = (int8 *)(lVar2 + 0x10 + lVar7);
*puVar1 = 0;
puVar1[1] = 0;
*(int8 *)(lVar2 + lVar7) = 0;
((int8 *)(lVar2 + lVar7))[1] = 0;
if (0xdf < (int)param_4) {
piVar3 = *(int **)(*(long *)(*(long *)(param_1 + 0x18) + 0x68) + (ulong)param_4 * 8);
*piVar3 = *piVar3 + 1;
}
*(uint *)(lVar5 + 0x14) = param_4;
if (0xdf < (int)param_5) {
piVar3 = *(int **)(*(long *)(*(long *)(param_1 + 0x18) + 0x68) + uVar8 * 8);
*piVar3 = *piVar3 + 1;
}
*(uint *)(lVar5 + 0x18) = param_5;
*(int4 *)(lVar5 + 0x10) = param_6;
return lVar5;
}
}
else if (param_2 == 0) {
__JS_ThrowSyntaxErrorAtom(param_1,uVar8,"duplicate exported name \'%s\'");
}
else {
uVar6 = JS_AtomGetStr(param_1,auStack_78,uVar8);
js_parse_error(param_2,"duplicate exported name \'%s\'",uVar6);
}
return 0;
}
| |
44,753 | my_uca_copy_page | eloqsql/strings/ctype-uca.c | static my_bool
my_uca_copy_page(MY_CHARSET_LOADER *loader,
const MY_UCA_WEIGHT_LEVEL *src,
MY_UCA_WEIGHT_LEVEL *dst,
size_t page)
{
uint chc, size= 256 * dst->lengths[page] * sizeof(uint16);
if (!(dst->weights[page]= (uint16 *) (loader->once_alloc)(size)))
return TRUE;
DBUG_ASSERT(src->lengths[page] <= dst->lengths[page]);
memset(dst->weights[page], 0, size);
for (chc=0 ; chc < 256; chc++)
{
memcpy(dst->weights[page] + chc * dst->lengths[page],
src->weights[page] + chc * src->lengths[page],
src->lengths[page] * sizeof(uint16));
}
return FALSE;
} | O0 | c | my_uca_copy_page:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
shll $0x8, %eax
cltq
shlq %rax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rax
movl -0x30(%rbp), %ecx
movl %ecx, %edi
callq *%rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x28(%rbp), %rdx
movq %rax, (%rcx,%rdx,8)
cmpq $0x0, %rax
jne 0x5bdd4
movb $0x1, -0x1(%rbp)
jmp 0x5be90
jmp 0x5bdd6
jmp 0x5bdd8
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl -0x30(%rbp), %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x24180
movl $0x0, -0x2c(%rbp)
cmpl $0x100, -0x2c(%rbp) # imm = 0x100
jae 0x5be8c
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x28(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
imull %ecx, %eax
movl %eax, %eax
shlq %rax
addq %rax, %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movl -0x2c(%rbp), %eax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x28(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
imull %ecx, %eax
movl %eax, %eax
shlq %rax
addq %rax, %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %edx
shlq %rdx
callq 0x24200
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5bdfb
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| my_uca_copy_page:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_20]
mov rax, [rax+8]
mov rcx, [rbp+var_28]
movzx eax, byte ptr [rax+rcx]
shl eax, 8
cdqe
shl rax, 1
mov [rbp+var_30], eax
mov rax, [rbp+var_10]
mov rax, [rax+80h]
mov ecx, [rbp+var_30]
mov edi, ecx
call rax
mov rcx, [rbp+var_20]
mov rcx, [rcx+10h]
mov rdx, [rbp+var_28]
mov [rcx+rdx*8], rax
cmp rax, 0
jnz short loc_5BDD4
mov [rbp+var_1], 1
jmp loc_5BE90
loc_5BDD4:
jmp short $+2
loc_5BDD6:
jmp short $+2
loc_5BDD8:
mov rax, [rbp+var_20]
mov rax, [rax+10h]
mov rcx, [rbp+var_28]
mov rdi, [rax+rcx*8]
mov eax, [rbp+var_30]
mov edx, eax
xor esi, esi
call _memset
mov [rbp+var_2C], 0
loc_5BDFB:
cmp [rbp+var_2C], 100h
jnb loc_5BE8C
mov rax, [rbp+var_20]
mov rax, [rax+10h]
mov rcx, [rbp+var_28]
mov rdi, [rax+rcx*8]
mov eax, [rbp+var_2C]
mov rcx, [rbp+var_20]
mov rcx, [rcx+8]
mov rdx, [rbp+var_28]
movzx ecx, byte ptr [rcx+rdx]
imul eax, ecx
mov eax, eax
shl rax, 1
add rdi, rax
mov rax, [rbp+var_18]
mov rax, [rax+10h]
mov rcx, [rbp+var_28]
mov rsi, [rax+rcx*8]
mov eax, [rbp+var_2C]
mov rcx, [rbp+var_18]
mov rcx, [rcx+8]
mov rdx, [rbp+var_28]
movzx ecx, byte ptr [rcx+rdx]
imul eax, ecx
mov eax, eax
shl rax, 1
add rsi, rax
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov rcx, [rbp+var_28]
movzx eax, byte ptr [rax+rcx]
mov edx, eax
shl rdx, 1
call _memcpy
mov eax, [rbp+var_2C]
add eax, 1
mov [rbp+var_2C], eax
jmp loc_5BDFB
loc_5BE8C:
mov [rbp+var_1], 0
loc_5BE90:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
| char my_uca_copy_page(long long a1, long long a2, long long a3, long long a4)
{
long long v4; // rax
unsigned int v6; // [rsp+0h] [rbp-30h]
unsigned int i; // [rsp+4h] [rbp-2Ch]
v6 = *(unsigned __int8 *)(*(_QWORD *)(a3 + 8) + a4) << 9;
v4 = (*(long long ( **)(_QWORD))(a1 + 128))(v6);
*(_QWORD *)(*(_QWORD *)(a3 + 16) + 8 * a4) = v4;
if ( !v4 )
return 1;
memset(*(_QWORD *)(*(_QWORD *)(a3 + 16) + 8 * a4), 0LL, v6);
for ( i = 0; i < 0x100; ++i )
memcpy(
2LL * *(unsigned __int8 *)(*(_QWORD *)(a3 + 8) + a4) * i + *(_QWORD *)(*(_QWORD *)(a3 + 16) + 8 * a4),
2LL * *(unsigned __int8 *)(*(_QWORD *)(a2 + 8) + a4) * i + *(_QWORD *)(*(_QWORD *)(a2 + 16) + 8 * a4),
2LL * *(unsigned __int8 *)(*(_QWORD *)(a2 + 8) + a4));
return 0;
}
| my_uca_copy_page:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x28]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
SHL EAX,0x8
CDQE
SHL RAX,0x1
MOV dword ptr [RBP + -0x30],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x80]
MOV ECX,dword ptr [RBP + -0x30]
MOV EDI,ECX
CALL RAX
MOV RCX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RCX + 0x10]
MOV RDX,qword ptr [RBP + -0x28]
MOV qword ptr [RCX + RDX*0x8],RAX
CMP RAX,0x0
JNZ 0x0015bdd4
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0015be90
LAB_0015bdd4:
JMP 0x0015bdd6
LAB_0015bdd6:
JMP 0x0015bdd8
LAB_0015bdd8:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RBP + -0x28]
MOV RDI,qword ptr [RAX + RCX*0x8]
MOV EAX,dword ptr [RBP + -0x30]
MOV EDX,EAX
XOR ESI,ESI
CALL 0x00124180
MOV dword ptr [RBP + -0x2c],0x0
LAB_0015bdfb:
CMP dword ptr [RBP + -0x2c],0x100
JNC 0x0015be8c
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RBP + -0x28]
MOV RDI,qword ptr [RAX + RCX*0x8]
MOV EAX,dword ptr [RBP + -0x2c]
MOV RCX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RCX + 0x8]
MOV RDX,qword ptr [RBP + -0x28]
MOVZX ECX,byte ptr [RCX + RDX*0x1]
IMUL EAX,ECX
MOV EAX,EAX
SHL RAX,0x1
ADD RDI,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RAX + RCX*0x8]
MOV EAX,dword ptr [RBP + -0x2c]
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX + 0x8]
MOV RDX,qword ptr [RBP + -0x28]
MOVZX ECX,byte ptr [RCX + RDX*0x1]
IMUL EAX,ECX
MOV EAX,EAX
SHL RAX,0x1
ADD RSI,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x28]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV EDX,EAX
SHL RDX,0x1
CALL 0x00124200
MOV EAX,dword ptr [RBP + -0x2c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x0015bdfb
LAB_0015be8c:
MOV byte ptr [RBP + -0x1],0x0
LAB_0015be90:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int1 my_uca_copy_page(long param_1,long param_2,long param_3,long param_4)
{
size_t __n;
long lVar1;
int4 local_34;
int1 local_9;
__n = (long)(int)((uint)*(byte *)(*(long *)(param_3 + 8) + param_4) << 8) << 1;
lVar1 = (**(code **)(param_1 + 0x80))(__n);
*(long *)(*(long *)(param_3 + 0x10) + param_4 * 8) = lVar1;
if (lVar1 == 0) {
local_9 = 1;
}
else {
memset(*(void **)(*(long *)(param_3 + 0x10) + param_4 * 8),0,__n);
for (local_34 = 0; local_34 < 0x100; local_34 = local_34 + 1) {
memcpy((void *)(*(long *)(*(long *)(param_3 + 0x10) + param_4 * 8) +
(ulong)(local_34 * *(byte *)(*(long *)(param_3 + 8) + param_4)) * 2),
(void *)(*(long *)(*(long *)(param_2 + 0x10) + param_4 * 8) +
(ulong)(local_34 * *(byte *)(*(long *)(param_2 + 8) + param_4)) * 2),
(ulong)*(byte *)(*(long *)(param_2 + 8) + param_4) << 1);
}
local_9 = 0;
}
return local_9;
}
| |
44,754 | common_chat_params_init_functionary_v3_1_llama_3_1(minja::chat_template const&, common_chat_inputs const&) | monkey531[P]llama/common/chat.cpp | static common_chat_params common_chat_params_init_functionary_v3_1_llama_3_1(const common_chat_template & tmpl, const struct common_chat_inputs & inputs) {
// https://github.com/MeetKai/functionary/blob/main/tests/prompt_test_v3-llama3.1.txt
common_chat_params data;
json tools = inputs.tools.is_null() ? inputs.tools : json::array();
std::string python_code_argument_name;
auto has_raw_python = false;
data.grammar_lazy = inputs.tool_choice != "required";
data.grammar = build_grammar([&](const common_grammar_builder & builder) {
std::vector<std::string> tool_rules;
foreach_function(inputs.tools, [&](const json & tool) {
const auto & function = tool["function"];
const auto & parameters = function["parameters"];
std::string name = function["name"];
if (name == "python" || name == "ipython") {
if (!parameters.contains("type")) {
throw std::runtime_error("Missing type in python tool");
}
has_raw_python = true;
auto type = parameters.at("type");
if (type == "object") {
auto properties = parameters.at("properties");
for (auto it = properties.begin(); it != properties.end(); ++it) {
if (it.value().at("type") == "string") {
if (!python_code_argument_name.empty()) {
throw std::runtime_error("Multiple string arguments found in python tool");
}
python_code_argument_name = it.key();
}
}
if (python_code_argument_name.empty()) {
throw std::runtime_error("No string argument found in python tool");
}
} else if (type != "string") {
throw std::runtime_error("Invalid type in python tool: " + type.dump());
}
}
tool_rules.push_back(builder.add_rule(name + "-call", "\"<function=" + name + ">\" " + builder.add_schema(name + "-args", parameters) + " \"</function>\" space"));
});
if (has_raw_python) {
tool_rules.push_back(builder.add_rule("python-call", "\"<|python_tag|>\" .*"));
data.grammar_triggers.push_back({"<|python_tag|>", /* .at_start = */ false});
}
auto tool_call = builder.add_rule("tool_call", string_join(tool_rules, " | ")) + " space";
builder.add_rule("root", inputs.parallel_tool_calls ? "(" + tool_call + ")+" : tool_call);
data.grammar_triggers.push_back({"<function=", /* .at_start = */ false});
}, grammar_options);
data.prompt = tmpl.apply(inputs.messages, inputs.tools.empty() ? json() : inputs.tools, inputs.add_generation_prompt);
// TODO: if (has_raw_python)
data.format = COMMON_CHAT_FORMAT_FUNCTIONARY_V3_1_LLAMA_3_1;
return data;
} | O3 | cpp | common_chat_params_init_functionary_v3_1_llama_3_1(minja::chat_template const&, common_chat_inputs const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x0, (%rdi)
xorl %eax, %eax
movb %al, 0x8(%rdi)
movq %rax, 0x10(%rdi)
leaq 0x28(%rdi), %rcx
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movb %al, 0x28(%rdi)
movb %al, 0x38(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x60(%rdi)
movups %xmm0, 0x70(%rdi)
movq %rax, 0x80(%rdi)
leaq 0x10(%rdx), %r12
cmpb %al, 0x10(%rdx)
je 0x84832
leaq 0x58(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0x2, %r8d
callq 0x2e5b0
jmp 0x8483f
leaq 0x58(%rsp), %rdi
movq %r12, %rsi
callq 0x2dfb0
leaq 0x88(%rsp), %rbp
movq %rbp, -0x10(%rbp)
xorl %r13d, %r13d
movq %r13, -0x8(%rbp)
movb %r13b, (%rbp)
movb %r13b, 0x17(%rsp)
leaq 0x20(%r14), %rdi
leaq 0x27f09(%rip), %rsi # 0xac76f
callq 0x6bdcd
movb %al, 0x38(%rbx)
movq %r13, 0x20(%rsp)
movl $0x20, %edi
callq 0x186d0
movq %r14, (%rax)
leaq 0x17(%rsp), %rcx
movq %rcx, 0x8(%rax)
leaq 0x78(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq %rbx, 0x18(%rax)
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x9fa9(%rip), %rax # 0x8e84e
movq %rax, 0x18(%rsi)
leaq 0xa692(%rip), %rax # 0x8ef42
movq %rax, 0x10(%rsi)
leaq 0x2ed51(%rip), %rdx # 0xb360c
leaq 0x38(%rsp), %rdi
callq 0x997ac
leaq 0x18(%rbx), %rdi
leaq 0x38(%rsp), %r13
movq %r13, %rsi
callq 0x18850
movq (%r13), %rdi
leaq 0x48(%rsp), %r13
cmpq %r13, %rdi
je 0x848f1
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x186e0
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x8490a
leaq 0x18(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movzbl (%r12), %eax
testl %eax, %eax
je 0x84939
cmpl $0x2, %eax
je 0x8491d
cmpl $0x1, %eax
jne 0x8492a
movq 0x18(%r14), %rax
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
je 0x84939
leaq 0x18(%rsp), %rdi
movq %r12, %rsi
callq 0x2dfb0
jmp 0x84947
movb $0x0, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movzbl 0x68(%r14), %r8d
leaq 0x68(%rsp), %r9
movb $0x0, (%r9)
movq $0x0, 0x8(%r9)
movl $0x1, (%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rcx
movq %r15, %rsi
movq %r14, %rdx
callq 0x684ec
leaq 0x98(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x2f304
movb 0x8(%rbx), %al
leaq 0x98(%rsp), %rdi
movb (%rdi), %cl
movb %cl, 0x8(%rbx)
movb %al, (%rdi)
movq 0x10(%rbx), %rax
movq 0x8(%rdi), %rcx
movq %rcx, 0x10(%rbx)
movq %rax, 0x8(%rdi)
callq 0x4d7e0
movq 0x38(%rsp), %rdi
cmpq %r13, %rdi
je 0x849c9
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x186e0
leaq 0x68(%rsp), %rdi
callq 0x4d7e0
leaq 0x18(%rsp), %rdi
callq 0x4d7e0
movl $0x8, (%rbx)
movq 0x78(%rsp), %rdi
cmpq %rbp, %rdi
je 0x849fd
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x186e0
leaq 0x58(%rsp), %rdi
callq 0x4d7e0
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x84a78
jmp 0x84a70
movq %rax, %r14
movq 0x38(%rsp), %rdi
cmpq %r13, %rdi
je 0x84a3c
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x186e0
jmp 0x84a3c
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0x4d7e0
leaq 0x18(%rsp), %rdi
callq 0x4d7e0
jmp 0x84a7b
movq %rax, %r14
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x84a7b
leaq 0x18(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x84a7b
movq %rax, %rdi
callq 0x1f25d
movq %rax, %r14
movq 0x78(%rsp), %rdi
cmpq %rbp, %rdi
je 0x84a95
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x186e0
leaq 0x58(%rsp), %rdi
callq 0x4d7e0
movq %rbx, %rdi
callq 0x2dd20
movq %r14, %rdi
callq 0x18c10
movq %rax, %r14
jmp 0x84a9f
| _ZL50common_chat_params_init_functionary_v3_1_llama_3_1RKN5minja13chat_templateERK18common_chat_inputs:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0A8h
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov dword ptr [rdi], 0
xor eax, eax
mov [rdi+8], al
mov [rdi+10h], rax
lea rcx, [rdi+28h]
mov [rdi+18h], rcx
mov [rdi+20h], rax
mov [rdi+28h], al
mov [rdi+38h], al
xorps xmm0, xmm0
movups xmmword ptr [rdi+40h], xmm0
movups xmmword ptr [rdi+50h], xmm0
movups xmmword ptr [rdi+60h], xmm0
movups xmmword ptr [rdi+70h], xmm0
mov [rdi+80h], rax
lea r12, [rdx+10h]
cmp [rdx+10h], al
jz short loc_84832
lea rdi, [rsp+0D8h+var_80]
xor esi, esi
xor edx, edx
xor ecx, ecx
mov r8d, 2
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ESt16initializer_listINS0_6detail8json_refISD_EEEbNSF_7value_tE; 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(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<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>>>,bool,nlohmann::json_abi_v3_11_3::detail::value_t)
jmp short loc_8483F
loc_84832:
lea rdi, [rsp+0D8h+var_80]
mov rsi, r12
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&)
loc_8483F:
lea rbp, [rsp+0D8h+var_50]
mov [rbp-10h], rbp
xor r13d, r13d
mov [rbp-8], r13
mov [rbp+0], r13b
mov [rsp+0D8h+var_C1], r13b
lea rdi, [r14+20h]
lea rsi, aRequired; "required"
call _ZN8nlohmann16json_abi_v3_11_3neIPKcTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerESA_IhSaIhEEvEES5_
mov [rbx+38h], al
mov [rsp+0D8h+var_B8], r13
mov edi, 20h ; ' '; unsigned __int64
call __Znwm; operator new(ulong)
mov [rax], r14
lea rcx, [rsp+0D8h+var_C1]
mov [rax+8], rcx
lea rcx, [rsp+0D8h+var_60]
mov [rax+10h], rcx
mov [rax+18h], rbx
lea rsi, [rsp+0D8h+var_C0]
mov [rsi], rax
lea rax, _ZNSt17_Function_handlerIFvRK22common_grammar_builderEZL50common_chat_params_init_functionary_v3_1_llama_3_1RKN5minja13chat_templateERK18common_chat_inputsE3$_0E9_M_invokeERKSt9_Any_dataS2_; std::_Function_handler<void ()(common_grammar_builder const&),common_chat_params_init_functionary_v3_1_llama_3_1(minja::chat_template const&,common_chat_inputs const&)::$_0>::_M_invoke(std::_Any_data const&,common_grammar_builder const&)
mov [rsi+18h], rax
lea rax, _ZNSt17_Function_handlerIFvRK22common_grammar_builderEZL50common_chat_params_init_functionary_v3_1_llama_3_1RKN5minja13chat_templateERK18common_chat_inputsE3$_0E10_M_managerERSt9_Any_dataRKSD_St18_Manager_operation; std::_Function_handler<void ()(common_grammar_builder const&),common_chat_params_init_functionary_v3_1_llama_3_1(minja::chat_template const&,common_chat_inputs const&)::$_0>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov [rsi+10h], rax
lea rdx, _ZL15grammar_options; grammar_options
lea rdi, [rsp+0D8h+var_A0]
call _Z13build_grammarB5cxx11RKSt8functionIFvRK22common_grammar_builderEERK22common_grammar_options; build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)
lea rdi, [rbx+18h]
lea r13, [rsp+0D8h+var_A0]
mov rsi, r13
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, [r13+0]; void *
lea r13, [rsp+0D8h+var_90]
cmp rdi, r13
jz short loc_848F1
mov rsi, [rsp+0D8h+var_90]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_848F1:
mov rax, [rsp+0D8h+var_B0]
test rax, rax
jz short loc_8490A
lea rdi, [rsp+0D8h+var_C0]
mov rsi, rdi
mov edx, 3
call rax
loc_8490A:
movzx eax, byte ptr [r12]
test eax, eax
jz short loc_84939
cmp eax, 2
jz short loc_8491D
cmp eax, 1
jnz short loc_8492A
loc_8491D:
mov rax, [r14+18h]
mov rcx, [rax]
cmp rcx, [rax+8]
jz short loc_84939
loc_8492A:
lea rdi, [rsp+0D8h+var_C0]
mov rsi, r12
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ERKSD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
jmp short loc_84947
loc_84939:
mov [rsp+0D8h+var_C0], 0
mov [rsp+0D8h+var_B8], 0
loc_84947:
movzx r8d, byte ptr [r14+68h]
lea r9, [rsp+0D8h+var_70]
mov byte ptr [r9], 0
mov qword ptr [r9+8], 0
mov [rsp+0D8h+var_D8], 1
lea rdi, [rsp+0D8h+var_A0]
lea rcx, [rsp+0D8h+var_C0]
mov rsi, r15
mov rdx, r14
call _ZNK5minja13chat_template5applyERKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES5_IhSaIhEEvEESH_bSH_b; minja::chat_template::apply(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,bool,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,bool)
lea rdi, [rsp+0D8h+var_40]
lea rsi, [rsp+0D8h+var_A0]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SG_EE5valueEiE4typeELi0EEEOT_
mov al, [rbx+8]
lea rdi, [rsp+0D8h+var_40]
mov cl, [rdi]
mov [rbx+8], cl
mov [rdi], al
mov rax, [rbx+10h]
mov rcx, [rdi+8]
mov [rbx+10h], rcx
mov [rdi+8], rax
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [rsp+0D8h+var_A0]; void *
cmp rdi, r13
jz short loc_849C9
mov rsi, [rsp+0D8h+var_90]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_849C9:
lea rdi, [rsp+0D8h+var_70]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
lea rdi, [rsp+0D8h+var_C0]
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 dword ptr [rbx], 8
mov rdi, [rsp+0D8h+var_60]; void *
cmp rdi, rbp
jz short loc_849FD
mov rsi, [rsp+0D8h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_849FD:
lea rdi, [rsp+0D8h+var_80]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
add rsp, 0A8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_84A78
jmp short loc_84A70
mov r14, rax
mov rdi, [rsp+0D8h+var_A0]; void *
cmp rdi, r13
jz short loc_84A3C
mov rsi, [rsp+0D8h+var_90]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_84A3C
mov r14, rax
loc_84A3C:
lea rdi, [rsp+0D8h+var_70]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
lea rdi, [rsp+0D8h+var_C0]
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_84A7B
mov r14, rax
mov rax, [rsp+0D8h+var_B0]
test rax, rax
jz short loc_84A7B
lea rdi, [rsp+0D8h+var_C0]
mov rsi, rdi
mov edx, 3
call rax
jmp short loc_84A7B
loc_84A70:
mov rdi, rax
call __clang_call_terminate
loc_84A78:
mov r14, rax
loc_84A7B:
mov rdi, [rsp+0D8h+var_60]; void *
cmp rdi, rbp
jz short loc_84A95
mov rsi, [rsp+0D8h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_84A95:
lea rdi, [rsp+0D8h+var_80]
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_84A9F:
mov rdi, rbx; this
call _ZN18common_chat_paramsD2Ev; common_chat_params::~common_chat_params()
mov rdi, r14
call __Unwind_Resume
mov r14, rax
jmp short loc_84A9F
| void common_chat_params_init_functionary_v3_1_llama_3_1(
const minja::chat_template *a1,
const common_chat_inputs *a2,
long long a3)
{
_BYTE *v4; // r12
long long v5; // rax
int v6; // eax
int v7; // r8d
char v8; // al
long long v9; // rax
char v10; // [rsp+17h] [rbp-C1h] BYREF
void **v11; // [rsp+18h] [rbp-C0h] BYREF
long long v12; // [rsp+20h] [rbp-B8h]
long long ( *v13)(); // [rsp+28h] [rbp-B0h]
long long ( *v14)(); // [rsp+30h] [rbp-A8h]
void *v15[2]; // [rsp+38h] [rbp-A0h] BYREF
_QWORD v16[2]; // [rsp+48h] [rbp-90h] BYREF
void **v17[2]; // [rsp+58h] [rbp-80h] BYREF
void **v18[2]; // [rsp+68h] [rbp-70h] BYREF
void *v19[2]; // [rsp+78h] [rbp-60h] BYREF
_QWORD v20[2]; // [rsp+88h] [rbp-50h] BYREF
_OWORD v21[4]; // [rsp+98h] [rbp-40h] BYREF
*(_DWORD *)a1 = 0;
*((_BYTE *)a1 + 8) = 0;
*((_QWORD *)a1 + 2) = 0LL;
*((_QWORD *)a1 + 3) = (char *)a1 + 40;
*((_QWORD *)a1 + 4) = 0LL;
*((_BYTE *)a1 + 40) = 0;
*((_BYTE *)a1 + 56) = 0;
*((_OWORD *)a1 + 4) = 0LL;
*((_OWORD *)a1 + 5) = 0LL;
*((_OWORD *)a1 + 6) = 0LL;
*((_OWORD *)a1 + 7) = 0LL;
*((_QWORD *)a1 + 16) = 0LL;
v4 = (_BYTE *)(a3 + 16);
if ( *(_BYTE *)(a3 + 16) )
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(
v17,
0LL,
0LL,
0LL,
2LL);
else
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(
(long long)v17,
a3 + 16);
v19[0] = v20;
v19[1] = 0LL;
LOBYTE(v20[0]) = 0;
v10 = 0;
*((_BYTE *)a1 + 56) = ZN8nlohmann16json_abi_v3_11_3neIPKcTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerESA_IhSaIhEEvEES5_(
a3 + 32,
(long long)"required");
v12 = 0LL;
v5 = operator new(0x20uLL);
*(_QWORD *)v5 = a3;
*(_QWORD *)(v5 + 8) = &v10;
*(_QWORD *)(v5 + 16) = v19;
*(_QWORD *)(v5 + 24) = a1;
v11 = (void **)v5;
v14 = std::_Function_handler<void ()(common_grammar_builder const&),common_chat_params_init_functionary_v3_1_llama_3_1(minja::chat_template const&,common_chat_inputs const&)::$_0>::_M_invoke;
v13 = std::_Function_handler<void ()(common_grammar_builder const&),common_chat_params_init_functionary_v3_1_llama_3_1(minja::chat_template const&,common_chat_inputs const&)::$_0>::_M_manager;
build_grammar[abi:cxx11](v15, &v11, &grammar_options);
std::string::operator=((char *)a1 + 24, v15);
if ( v15[0] != v16 )
operator delete(v15[0], v16[0] + 1LL);
if ( v13 )
((void ( *)(void ***, void ***, long long))v13)(&v11, &v11, 3LL);
v6 = (unsigned __int8)*v4;
if ( !*v4 || (v6 == 2 || v6 == 1) && **(_QWORD **)(a3 + 24) == *(_QWORD *)(*(_QWORD *)(a3 + 24) + 8LL) )
{
LOBYTE(v11) = 0;
v12 = 0LL;
}
else
{
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(
(long long)&v11,
(long long)v4);
}
v7 = *(unsigned __int8 *)(a3 + 104);
LOBYTE(v18[0]) = 0;
v18[1] = 0LL;
minja::chat_template::apply((long long)v15, a2, a3, (unsigned __int8 *)&v11, v7, v18, 1);
ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SG_EE5valueEiE4typeELi0EEEOT_(v21);
v8 = *((_BYTE *)a1 + 8);
*((_BYTE *)a1 + 8) = v21[0];
LOBYTE(v21[0]) = v8;
v9 = *((_QWORD *)a1 + 2);
*((_QWORD *)a1 + 2) = *((_QWORD *)&v21[0] + 1);
*((_QWORD *)&v21[0] + 1) = v9;
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((void ***)v21);
if ( v15[0] != v16 )
operator delete(v15[0], v16[0] + 1LL);
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(v18);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(&v11);
*(_DWORD *)a1 = 8;
if ( v19[0] != v20 )
operator delete(v19[0], v20[0] + 1LL);
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(v17);
}
| common_chat_params_init_functionary_v3_1_llama_3_1:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xa8
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV dword ptr [RDI],0x0
XOR EAX,EAX
MOV byte ptr [RDI + 0x8],AL
MOV qword ptr [RDI + 0x10],RAX
LEA RCX,[RDI + 0x28]
MOV qword ptr [RDI + 0x18],RCX
MOV qword ptr [RDI + 0x20],RAX
MOV byte ptr [RDI + 0x28],AL
MOV byte ptr [RDI + 0x38],AL
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x40],XMM0
MOVUPS xmmword ptr [RDI + 0x50],XMM0
MOVUPS xmmword ptr [RDI + 0x60],XMM0
MOVUPS xmmword ptr [RDI + 0x70],XMM0
MOV qword ptr [RDI + 0x80],RAX
LEA R12,[RDX + 0x10]
CMP byte ptr [RDX + 0x10],AL
JZ 0x00184832
LAB_0018481a:
LEA RDI,[RSP + 0x58]
XOR ESI,ESI
XOR EDX,EDX
XOR ECX,ECX
MOV R8D,0x2
CALL 0x0012e5b0
JMP 0x0018483f
LAB_00184832:
LEA RDI,[RSP + 0x58]
MOV RSI,R12
CALL 0x0012dfb0
LAB_0018483f:
LEA RBP,[RSP + 0x88]
MOV qword ptr [RBP + -0x10],RBP
XOR R13D,R13D
MOV qword ptr [RBP + -0x8],R13
MOV byte ptr [RBP],R13B
MOV byte ptr [RSP + 0x17],R13B
LEA RDI,[R14 + 0x20]
LEA RSI,[0x1ac76f]
CALL 0x0016bdcd
MOV byte ptr [RBX + 0x38],AL
MOV qword ptr [RSP + 0x20],R13
LAB_00184873:
MOV EDI,0x20
CALL 0x001186d0
MOV qword ptr [RAX],R14
LEA RCX,[RSP + 0x17]
MOV qword ptr [RAX + 0x8],RCX
LEA RCX,[RSP + 0x78]
MOV qword ptr [RAX + 0x10],RCX
MOV qword ptr [RAX + 0x18],RBX
LEA RSI,[RSP + 0x18]
MOV qword ptr [RSI],RAX
LEA RAX,[0x18e84e]
MOV qword ptr [RSI + 0x18],RAX
LEA RAX,[0x18ef42]
MOV qword ptr [RSI + 0x10],RAX
LAB_001848b4:
LEA RDX,[0x1b360c]
LEA RDI,[RSP + 0x38]
CALL 0x001997ac
LEA RDI,[RBX + 0x18]
LEA R13,[RSP + 0x38]
MOV RSI,R13
CALL 0x00118850
MOV RDI,qword ptr [R13]
LEA R13,[RSP + 0x48]
CMP RDI,R13
JZ 0x001848f1
MOV RSI,qword ptr [RSP + 0x48]
INC RSI
CALL 0x001186e0
LAB_001848f1:
MOV RAX,qword ptr [RSP + 0x28]
TEST RAX,RAX
JZ 0x0018490a
LAB_001848fb:
LEA RDI,[RSP + 0x18]
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_0018490a:
MOVZX EAX,byte ptr [R12]
TEST EAX,EAX
JZ 0x00184939
CMP EAX,0x2
JZ 0x0018491d
CMP EAX,0x1
JNZ 0x0018492a
LAB_0018491d:
MOV RAX,qword ptr [R14 + 0x18]
MOV RCX,qword ptr [RAX]
CMP RCX,qword ptr [RAX + 0x8]
JZ 0x00184939
LAB_0018492a:
LEA RDI,[RSP + 0x18]
MOV RSI,R12
CALL 0x0012dfb0
JMP 0x00184947
LAB_00184939:
MOV byte ptr [RSP + 0x18],0x0
MOV qword ptr [RSP + 0x20],0x0
LAB_00184947:
MOVZX R8D,byte ptr [R14 + 0x68]
LEA R9,[RSP + 0x68]
MOV byte ptr [R9],0x0
MOV qword ptr [R9 + 0x8],0x0
LAB_0018495d:
MOV dword ptr [RSP],0x1
LEA RDI,[RSP + 0x38]
LEA RCX,[RSP + 0x18]
MOV RSI,R15
MOV RDX,R14
CALL 0x001684ec
LAB_00184979:
LEA RDI,[RSP + 0x98]
LEA RSI,[RSP + 0x38]
CALL 0x0012f304
MOV AL,byte ptr [RBX + 0x8]
LEA RDI,[RSP + 0x98]
MOV CL,byte ptr [RDI]
MOV byte ptr [RBX + 0x8],CL
MOV byte ptr [RDI],AL
MOV RAX,qword ptr [RBX + 0x10]
MOV RCX,qword ptr [RDI + 0x8]
MOV qword ptr [RBX + 0x10],RCX
MOV qword ptr [RDI + 0x8],RAX
CALL 0x0014d7e0
MOV RDI,qword ptr [RSP + 0x38]
CMP RDI,R13
JZ 0x001849c9
MOV RSI,qword ptr [RSP + 0x48]
INC RSI
CALL 0x001186e0
LAB_001849c9:
LEA RDI,[RSP + 0x68]
CALL 0x0014d7e0
LEA RDI,[RSP + 0x18]
CALL 0x0014d7e0
MOV dword ptr [RBX],0x8
MOV RDI,qword ptr [RSP + 0x78]
CMP RDI,RBP
JZ 0x001849fd
MOV RSI,qword ptr [RSP + 0x88]
INC RSI
CALL 0x001186e0
LAB_001849fd:
LEA RDI,[RSP + 0x58]
CALL 0x0014d7e0
ADD RSP,0xa8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* common_chat_params_init_functionary_v3_1_llama_3_1(minja::chat_template const&,
common_chat_inputs const&) */
void common_chat_params_init_functionary_v3_1_llama_3_1
(chat_template *param_1,common_chat_inputs *param_2)
{
basic_json *pbVar1;
basic_json bVar2;
int8 uVar3;
chat_template cVar4;
long in_RDX;
int1 local_c1;
long *local_c0;
int8 local_b8;
code *local_b0;
code *local_a8;
long *local_a0 [2];
long local_90 [2];
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
local_80 [16];
data local_70 [8];
int8 local_68;
int1 *local_60;
int8 local_58;
int1 local_50;
int7 uStack_4f;
chat_template local_40 [8];
int8 local_38;
*(int4 *)param_1 = 0;
param_1[8] = (chat_template)0x0;
*(int8 *)(param_1 + 0x10) = 0;
*(chat_template **)(param_1 + 0x18) = param_1 + 0x28;
*(int8 *)(param_1 + 0x20) = 0;
param_1[0x28] = (chat_template)0x0;
param_1[0x38] = (chat_template)0x0;
*(int8 *)(param_1 + 0x40) = 0;
*(int8 *)(param_1 + 0x48) = 0;
*(int8 *)(param_1 + 0x50) = 0;
*(int8 *)(param_1 + 0x58) = 0;
*(int8 *)(param_1 + 0x60) = 0;
*(int8 *)(param_1 + 0x68) = 0;
*(int8 *)(param_1 + 0x70) = 0;
*(int8 *)(param_1 + 0x78) = 0;
*(int8 *)(param_1 + 0x80) = 0;
pbVar1 = (basic_json *)(in_RDX + 0x10);
if (*(char *)(in_RDX + 0x10) == '\0') {
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json(local_80,pbVar1);
}
else {
/* try { // try from 0018481a to 0018483e has its CatchHandler @ 00184aaf */
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json(local_80,0,0,0,2);
}
local_58 = 0;
local_50 = 0;
local_c1 = 0;
local_60 = &local_50;
cVar4 = (chat_template)
_ZN8nlohmann16json_abi_v3_11_3neIPKcTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerESA_IhSaIhEEvEES5_
(in_RDX + 0x20,"required");
param_1[0x38] = cVar4;
local_b8 = 0;
/* try { // try from 00184873 to 0018487c has its CatchHandler @ 00184a78 */
local_c0 = (long *)operator_new(0x20);
*local_c0 = in_RDX;
local_c0[1] = (long)&local_c1;
local_c0[2] = (long)&local_60;
local_c0[3] = (long)param_1;
local_a8 = std::
_Function_handler<void(common_grammar_builder_const&),common_chat_params_init_functionary_v3_1_llama_3_1(minja::chat_template_const&,common_chat_inputs_const&)::$_0>
::_M_invoke;
local_b0 = std::
_Function_handler<void(common_grammar_builder_const&),common_chat_params_init_functionary_v3_1_llama_3_1(minja::chat_template_const&,common_chat_inputs_const&)::$_0>
::_M_manager;
/* try { // try from 001848b4 to 001848c4 has its CatchHandler @ 00184a52 */
build_grammar_abi_cxx11_((function *)local_a0,(common_grammar_options *)&local_c0);
std::__cxx11::string::operator=((string *)(param_1 + 0x18),(string *)local_a0);
if (local_a0[0] != local_90) {
operator_delete(local_a0[0],local_90[0] + 1);
}
if (local_b0 != (code *)0x0) {
/* try { // try from 001848fb to 00184909 has its CatchHandler @ 00184a1b */
(*local_b0)(&local_c0,&local_c0,3);
}
bVar2 = *pbVar1;
if ((bVar2 == (basic_json)0x0) ||
(((bVar2 == (basic_json)0x2 || (bVar2 == (basic_json)0x1)) &&
(**(long **)(in_RDX + 0x18) == (*(long **)(in_RDX + 0x18))[1])))) {
local_c0 = (long *)((ulong)local_c0 & 0xffffffffffffff00);
local_b8 = 0;
}
else {
/* try { // try from 0018492a to 00184936 has its CatchHandler @ 00184a19 */
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json((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_c0,pbVar1);
}
local_70[0] = (data)0x0;
local_68 = 0;
/* try { // try from 0018495d to 00184978 has its CatchHandler @ 00184a39 */
minja::chat_template::apply
((basic_json *)local_a0,(basic_json *)param_2,SUB81(in_RDX,0),(basic_json *)&local_c0,
*(bool *)(in_RDX + 0x68));
/* try { // try from 00184979 to 0018498a has its CatchHandler @ 00184a1d */
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SG_EE5valueEiE4typeELi0EEEOT_
(local_40,local_a0);
cVar4 = param_1[8];
param_1[8] = local_40[0];
uVar3 = *(int8 *)(param_1 + 0x10);
*(int8 *)(param_1 + 0x10) = local_38;
local_40[0] = cVar4;
local_38 = uVar3;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)local_40);
if (local_a0[0] != local_90) {
operator_delete(local_a0[0],local_90[0] + 1);
}
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_70);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)&local_c0);
*(int4 *)param_1 = 8;
if (local_60 != &local_50) {
operator_delete(local_60,CONCAT71(uStack_4f,local_50) + 1);
}
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)local_80);
return;
}
| |
44,755 | nglog::SeverityToColor(nglog::LogSeverity) | ng-log[P]ng-log/src/logging.cc | static GLogColor SeverityToColor(LogSeverity severity) {
switch (severity) {
case NGLOG_INFO:
return COLOR_DEFAULT;
case NGLOG_WARNING:
return COLOR_YELLOW;
case NGLOG_ERROR:
case NGLOG_FATAL:
return COLOR_RED;
}
// should never get here.
NGLOG_UNREACHABLE;
} | O0 | cpp | nglog::SeverityToColor(nglog::LogSeverity):
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
testl %eax, %eax
je 0x1d7fe
jmp 0x1d7e7
movl -0xc(%rbp), %eax
subl $0x1, %eax
je 0x1d807
jmp 0x1d7f1
movl -0xc(%rbp), %eax
addl $-0x2, %eax
subl $0x2, %eax
jb 0x1d810
jmp 0x1d819
movl $0x0, -0x4(%rbp)
jmp 0x1d838
movl $0x3, -0x4(%rbp)
jmp 0x1d838
movl $0x1, -0x4(%rbp)
jmp 0x1d838
leaq 0x364f5(%rip), %rdi # 0x53d15
leaq 0x35fb3(%rip), %rsi # 0x537da
movl $0xeb, %edx
leaq 0x364e8(%rip), %rcx # 0x53d1b
callq 0x9480
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZN5nglogL15SeverityToColorENS_11LogSeverityE:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], edi
mov eax, [rbp+var_8]
mov [rbp+var_C], eax
test eax, eax
jz short loc_1D7FE
jmp short $+2
loc_1D7E7:
mov eax, [rbp+var_C]
sub eax, 1
jz short loc_1D807
jmp short $+2
loc_1D7F1:
mov eax, [rbp+var_C]
add eax, 0FFFFFFFEh
sub eax, 2
jb short loc_1D810
jmp short loc_1D819
loc_1D7FE:
mov [rbp+var_4], 0
jmp short loc_1D838
loc_1D807:
mov [rbp+var_4], 3
jmp short loc_1D838
loc_1D810:
mov [rbp+var_4], 1
jmp short loc_1D838
loc_1D819:
lea rdi, aFalse; "false"
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
mov edx, 0EBh
lea rcx, aGlogcolorNglog; "GLogColor nglog::SeverityToColor(LogSev"...
call ___assert_fail
loc_1D838:
mov eax, [rbp+var_4]
add rsp, 10h
pop rbp
retn
| long long nglog::SeverityToColor(int a1)
{
if ( a1 )
{
if ( a1 == 1 )
{
return 3;
}
else
{
if ( (unsigned int)(a1 - 2) >= 2 )
__assert_fail(
"false",
"/workspace/llm4binary/github/2025_star3/ng-log[P]ng-log/src/logging.cc",
235LL,
"GLogColor nglog::SeverityToColor(LogSeverity)");
return 1;
}
}
else
{
return 0;
}
}
| SeverityToColor:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV dword ptr [RBP + -0x8],EDI
MOV EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0xc],EAX
TEST EAX,EAX
JZ 0x0011d7fe
JMP 0x0011d7e7
LAB_0011d7e7:
MOV EAX,dword ptr [RBP + -0xc]
SUB EAX,0x1
JZ 0x0011d807
JMP 0x0011d7f1
LAB_0011d7f1:
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,-0x2
SUB EAX,0x2
JC 0x0011d810
JMP 0x0011d819
LAB_0011d7fe:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0011d838
LAB_0011d807:
MOV dword ptr [RBP + -0x4],0x3
JMP 0x0011d838
LAB_0011d810:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0011d838
LAB_0011d819:
LEA RDI,[0x153d15]
LEA RSI,[0x1537da]
MOV EDX,0xeb
LEA RCX,[0x153d1b]
CALL 0x00109480
LAB_0011d838:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x10
POP RBP
RET
|
/* nglog::SeverityToColor(nglog::LogSeverity) */
int4 nglog::SeverityToColor(int param_1)
{
int4 local_c;
if (param_1 == 0) {
local_c = 0;
}
else if (param_1 == 1) {
local_c = 3;
}
else {
if (1 < param_1 - 2U) {
/* WARNING: Subroutine does not return */
__assert_fail("false","/workspace/llm4binary/github/2025_star3/ng-log[P]ng-log/src/logging.cc"
,0xeb,"GLogColor nglog::SeverityToColor(LogSeverity)");
}
local_c = 1;
}
return local_c;
}
| |
44,756 | CLI::App::_valid_subcommand(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) const | MikePodsytnik[P]TCRtrie/build_O1/_deps/cli11-src/include/CLI/impl/App_inl.hpp | CLI11_NODISCARD CLI11_INLINE bool App::_valid_subcommand(const std::string ¤t, bool ignore_used) const {
// Don't match if max has been reached - but still check parents
if(require_subcommand_max_ != 0 && parsed_subcommands_.size() >= require_subcommand_max_) {
return parent_ != nullptr && parent_->_valid_subcommand(current, ignore_used);
}
auto *com = _find_subcommand(current, true, ignore_used);
if(com != nullptr) {
return true;
}
// Check parent if exists, else return false
return parent_ != nullptr && parent_->_valid_subcommand(current, ignore_used);
} | O1 | cpp | CLI::App::_valid_subcommand(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) const:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movzbl %dl, %ebp
movq 0x2b0(%r14), %rax
testq %rax, %rax
je 0x212c8
movq 0x1b0(%r14), %rcx
subq 0x1a8(%r14), %rcx
sarq $0x3, %rcx
cmpq %rax, %rcx
jae 0x212df
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
movl %ebp, %ecx
callq 0x217ac
testq %rax, %rax
jne 0x212ef
movq 0x2c8(%r14), %r14
testq %r14, %r14
jne 0x212a5
xorl %eax, %eax
jmp 0x212f1
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
| _ZNK3CLI3App17_valid_subcommandERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEb:
push rbp
push r14
push rbx
mov rbx, rsi
mov r14, rdi
movzx ebp, dl
loc_212A5:
mov rax, [r14+2B0h]
test rax, rax
jz short loc_212C8
mov rcx, [r14+1B0h]
sub rcx, [r14+1A8h]
sar rcx, 3
cmp rcx, rax
jnb short loc_212DF
loc_212C8:
mov rdi, r14
mov rsi, rbx
mov edx, 1
mov ecx, ebp
call _ZNK3CLI3App16_find_subcommandERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbb; CLI::App::_find_subcommand(std::string const&,bool,bool)
test rax, rax
jnz short loc_212EF
loc_212DF:
mov r14, [r14+2C8h]
test r14, r14
jnz short loc_212A5
xor eax, eax
jmp short loc_212F1
loc_212EF:
mov al, 1
loc_212F1:
pop rbx
pop r14
pop rbp
retn
| char CLI::App::_valid_subcommand(_QWORD *a1, long long a2, unsigned __int8 a3)
{
unsigned int v4; // ebp
unsigned long long v5; // rax
v4 = a3;
while ( 1 )
{
v5 = a1[86];
if ( !v5 || (long long)(a1[54] - a1[53]) >> 3 < v5 )
{
if ( CLI::App::_find_subcommand(a1, a2, 1LL, v4) )
break;
}
a1 = (_QWORD *)a1[89];
if ( !a1 )
return 0;
}
return 1;
}
| _valid_subcommand:
PUSH RBP
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R14,RDI
MOVZX EBP,DL
LAB_001212a5:
MOV RAX,qword ptr [R14 + 0x2b0]
TEST RAX,RAX
JZ 0x001212c8
MOV RCX,qword ptr [R14 + 0x1b0]
SUB RCX,qword ptr [R14 + 0x1a8]
SAR RCX,0x3
CMP RCX,RAX
JNC 0x001212df
LAB_001212c8:
MOV RDI,R14
MOV RSI,RBX
MOV EDX,0x1
MOV ECX,EBP
CALL 0x001217ac
TEST RAX,RAX
JNZ 0x001212ef
LAB_001212df:
MOV R14,qword ptr [R14 + 0x2c8]
TEST R14,R14
JNZ 0x001212a5
XOR EAX,EAX
JMP 0x001212f1
LAB_001212ef:
MOV AL,0x1
LAB_001212f1:
POP RBX
POP R14
POP RBP
RET
|
/* CLI::App::_valid_subcommand(std::__cxx11::string const&, bool) const */
int8 __thiscall CLI::App::_valid_subcommand(App *this,string *param_1,bool param_2)
{
long lVar1;
while (((*(ulong *)(this + 0x2b0) != 0 &&
(*(ulong *)(this + 0x2b0) <=
(ulong)(*(long *)(this + 0x1b0) - *(long *)(this + 0x1a8) >> 3))) ||
(lVar1 = _find_subcommand(this,param_1,true,param_2), lVar1 == 0))) {
this = *(App **)(this + 0x2c8);
if (this == (App *)0x0) {
return 0;
}
}
return 1;
}
| |
44,757 | 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 0x66b67
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 0x66b9f
movl -0x214(%rbp), %edi
callq 0x66a70
movq %rax, -0x228(%rbp)
cmpq $0x0, %rax
jne 0x66bd9
leaq -0x210(%rbp), %rdi
movl -0x214(%rbp), %ecx
movl $0x200, %esi # imm = 0x200
leaq 0x4bfda(%rip), %rdx # 0xb2baa
movb $0x0, %al
callq 0xad530
jmp 0x66c2d
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 0x363884(%rip), %rdi # 0x3ca4a0
movl $0x200, %edx # imm = 0x200
callq 0xaaf10
leaq -0x240(%rbp), %rax
leaq 0x1b022c(%rip), %rax # 0x216e60
movq (%rax), %rax
movl -0x214(%rbp), %edi
leaq -0x210(%rbp), %rsi
movq -0x220(%rbp), %rdx
callq *%rax
jmp 0x66c4f
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x66c6a
addq $0x2f0, %rsp # imm = 0x2F0
popq %rbp
retq
callq 0x26370
nop
| my_error:
push rbp
mov rbp, rsp
sub rsp, 2F0h
test al, al
jz short loc_66B67
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_66B67:
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_66B9F:
mov edi, [rbp+var_214]
call my_get_err_msg
mov [rbp+var_228], rax
cmp rax, 0
jnz short loc_66BD9
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_66C2D
loc_66BD9:
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_66C2D:
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_66C4F:
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_66C6A
add rsp, 2F0h
pop rbp
retn
loc_66C6A:
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);
}
((void ( *)(long long, long long, __int16))error_handler_hook[0])(v8, (long long)v9, v7);
return __readfsqword(0x28u);
}
| my_error:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x2f0
TEST AL,AL
JZ 0x00166b67
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_00166b67:
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 0x00166b9f
LAB_00166b9f:
MOV EDI,dword ptr [RBP + -0x214]
CALL 0x00166a70
MOV qword ptr [RBP + -0x228],RAX
CMP RAX,0x0
JNZ 0x00166bd9
LEA RDI,[RBP + -0x210]
MOV ECX,dword ptr [RBP + -0x214]
MOV ESI,0x200
LEA RDX,[0x1b2baa]
MOV AL,0x0
CALL 0x001ad530
JMP 0x00166c2d
LAB_00166bd9:
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,[0x4ca4a0]
MOV EDX,0x200
CALL 0x001aaf10
LEA RAX,[RBP + -0x240]
LAB_00166c2d:
LEA RAX,[0x316e60]
MOV RAX,qword ptr [RAX]
MOV EDI,dword ptr [RBP + -0x214]
LEA RSI,[RBP + -0x210]
MOV RDX,qword ptr [RBP + -0x220]
CALL RAX
JMP 0x00166c4f
LAB_00166c4f:
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00166c6a
ADD RSP,0x2f0
POP RBP
RET
LAB_00166c6a:
CALL 0x00126370
|
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();
}
| |
44,758 | minja::Parser::parseNumber(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&) | monkey531[P]llama/common/minja.hpp | json parseNumber(CharIterator& it, const CharIterator& end) {
auto before = it;
consumeSpaces();
auto start = it;
bool hasDecimal = false;
bool hasExponent = false;
if (it != end && (*it == '-' || *it == '+')) ++it;
while (it != end) {
if (std::isdigit(*it)) {
++it;
} else if (*it == '.') {
if (hasDecimal) throw std::runtime_error("Multiple decimal points");
hasDecimal = true;
++it;
} else if (it != start && (*it == 'e' || *it == 'E')) {
if (hasExponent) throw std::runtime_error("Multiple exponents");
hasExponent = true;
++it;
} else {
break;
}
}
if (start == it) {
it = before;
return json(); // No valid characters found
}
std::string str(start, it);
try {
return json::parse(str);
} catch (json::parse_error& e) {
throw std::runtime_error("Failed to parse number: '" + str + "' (" + std::string(e.what()) + ")");
return json();
}
} | O3 | cpp | minja::Parser::parseNumber(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdx), %r9
movq 0x18(%rsi), %rbp
movq 0x20(%rsi), %r13
movq %r9, %rsi
cmpq %rbp, %r13
je 0x8be66
movq %rbx, 0x8(%rsp)
movq %r9, %rbx
movsbl (%r13), %edi
callq 0x1a0c0
testl %eax, %eax
je 0x8be5b
incq %r13
movq %r13, 0x20(%r12)
cmpq %rbp, %r13
jne 0x8be40
movq (%r14), %rsi
movq %rbx, %r9
movq 0x8(%rsp), %rbx
movq (%r15), %rax
cmpq %rsi, %rax
je 0x8bf50
movzbl (%rsi), %ecx
cmpl $0x2d, %ecx
je 0x8be82
movq %rsi, %rdx
cmpl $0x2b, %ecx
jne 0x8be8c
leaq 0x1(%rsi), %rdx
movq %rdx, (%r14)
movq (%r15), %rax
cmpq %rax, %rdx
je 0x8bed9
xorl %eax, %eax
xorl %ecx, %ecx
movsbl (%rdx), %edi
leal -0x30(%rdi), %r8d
cmpl $0xa, %r8d
jb 0x8bece
movzbl %dil, %edi
cmpl $0x2e, %edi
jne 0x8beb6
testb $0x1, %al
movb $0x1, %al
je 0x8bece
jmp 0x8bf8d
cmpq %rsi, %rdx
je 0x8bed9
orl $0x20, %edi
cmpl $0x65, %edi
jne 0x8bed9
testb $0x1, %cl
movb $0x1, %cl
jne 0x8bfab
incq %rdx
movq %rdx, (%r14)
cmpq (%r15), %rdx
jne 0x8be95
cmpq %rsi, %rdx
je 0x8bf50
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x10(%rsp), %rdi
callq 0x70c0e
xorps %xmm0, %xmm0
leaq 0x90(%rsp), %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x8c804
movq 0xa0(%rsp), %rax
testq %rax, %rax
je 0x8bf37
leaq 0x90(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x8bf78
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1a8e0
jmp 0x8bf78
movq %r9, (%r14)
movb $0x0, (%rbx)
movq $0x0, 0x8(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x58f20
movq %rbx, %rdi
movl $0x1, %esi
callq 0x58f20
movq %rbx, %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x1a450
movq %rax, %rbx
leaq 0x642c6(%rip), %rsi # 0xf0267
movq %rax, %rdi
callq 0x1a330
jmp 0x8bfc7
movl $0x10, %edi
callq 0x1a450
movq %rax, %rbx
leaq 0x642c0(%rip), %rsi # 0xf027f
movq %rax, %rdi
callq 0x1a330
movq 0xa0022(%rip), %rsi # 0x12bff0
movq 0x9ff8b(%rip), %rdx # 0x12bf60
movq %rbx, %rdi
callq 0x1af10
jmp 0x8c252
movq %rdx, %rbx
movq %rax, %r14
movq 0xa0(%rsp), %rax
testq %rax, %rax
je 0x8c007
leaq 0x90(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
cmpl $0x1, %ebx
jne 0x8c237
movq %r14, %rdi
callq 0x1a390
movq %rax, %r14
movl $0x10, %edi
callq 0x1a450
movq %rax, %rbx
leaq 0x64263(%rip), %rsi # 0xf0292
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x54c9d
leaq 0x64267(%rip), %rsi # 0xf02ac
leaq 0x50(%rsp), %rdi
callq 0x1b0e0
leaq 0x40(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x8c072
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x8c07f
movq %rdx, 0x30(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x40(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x38(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
leaq 0xb8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %rax, %rsi
callq 0x532ca
leaq 0xd8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0xb8(%rsp), %rdx
callq 0x79476
leaq 0x687bd(%rip), %rsi # 0xf4893
leaq 0xd8(%rsp), %rdi
callq 0x1b0e0
leaq 0x80(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x8c108
movups (%rcx), %xmm0
movups %xmm0, (%r13)
jmp 0x8c118
movq %rdx, 0x70(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x80(%rsp)
movq 0x8(%rax), %rdx
leaq 0x70(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x1ae20
xorl %ebp, %ebp
movq 0x9fea8(%rip), %rsi # 0x12bff0
movq 0x9fe11(%rip), %rdx # 0x12bf60
movq %rbx, %rdi
callq 0x1af10
movq %rax, %r14
movq 0x70(%rsp), %rdi
cmpq %r13, %rdi
je 0x8c17c
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x1a8e0
jmp 0x8c17c
movq %rax, %r14
movb $0x1, %bpl
leaq 0xe8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8c1a5
movq 0xe8(%rsp), %rsi
incq %rsi
callq 0x1a8e0
jmp 0x8c1a5
movq %rax, %r14
movb $0x1, %bpl
leaq 0xc8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8c1ce
movq 0xc8(%rsp), %rsi
incq %rsi
callq 0x1a8e0
jmp 0x8c1ce
movq %rax, %r14
movb $0x1, %bpl
movq 0x30(%rsp), %rdi
cmpq %r12, %rdi
je 0x8c1e5
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1a8e0
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8c200
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x1a8e0
testb %bpl, %bpl
jne 0x8c22a
jmp 0x8c232
movq %rax, %r14
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8c22a
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x1a8e0
jmp 0x8c22a
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a690
callq 0x1ae50
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x8c26c
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1a8e0
jmp 0x8c26c
jmp 0x8c252
movq %rax, %rdi
callq 0x22203
movq %rax, %r14
jmp 0x8c26c
jmp 0x8c261
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a690
movq %r14, %rdi
callq 0x1af90
| _ZN5minja6Parser11parseNumberERN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEERKSB_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0F8h
mov r15, rcx
mov r14, rdx
mov r12, rsi
mov rbx, rdi
mov r9, [rdx]
mov rbp, [rsi+18h]
mov r13, [rsi+20h]
mov rsi, r9
cmp r13, rbp
jz short loc_8BE66
mov [rsp+128h+var_120], rbx
mov rbx, r9
loc_8BE40:
movsx edi, byte ptr [r13+0]
call _isspace
test eax, eax
jz short loc_8BE5B
inc r13
mov [r12+20h], r13
cmp r13, rbp
jnz short loc_8BE40
loc_8BE5B:
mov rsi, [r14]
mov r9, rbx
mov rbx, [rsp+128h+var_120]
loc_8BE66:
mov rax, [r15]
cmp rax, rsi
jz loc_8BF50
movzx ecx, byte ptr [rsi]
cmp ecx, 2Dh ; '-'
jz short loc_8BE82
mov rdx, rsi
cmp ecx, 2Bh ; '+'
jnz short loc_8BE8C
loc_8BE82:
lea rdx, [rsi+1]
mov [r14], rdx
mov rax, [r15]
loc_8BE8C:
cmp rdx, rax
jz short loc_8BED9
xor eax, eax
xor ecx, ecx
loc_8BE95:
movsx edi, byte ptr [rdx]
lea r8d, [rdi-30h]
cmp r8d, 0Ah
jb short loc_8BECE
movzx edi, dil
cmp edi, 2Eh ; '.'
jnz short loc_8BEB6
test al, 1
mov al, 1
jz short loc_8BECE
jmp loc_8BF8D
loc_8BEB6:
cmp rdx, rsi
jz short loc_8BED9
or edi, 20h
cmp edi, 65h ; 'e'
jnz short loc_8BED9
test cl, 1
mov cl, 1
jnz loc_8BFAB
loc_8BECE:
inc rdx
mov [r14], rdx
cmp rdx, [r15]
jnz short loc_8BE95
loc_8BED9:
cmp rdx, rsi
jz short loc_8BF50
lea r15, [rsp+128h+var_108]
mov [r15-10h], r15
lea rdi, [rsp+128h+var_118]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIN9__gnu_cxx17__normal_iteratorIPKcS4_EEEEvT_SB_St20forward_iterator_tag; std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::forward_iterator_tag)
xorps xmm0, xmm0
lea rdx, [rsp+128h+var_98]
movaps xmmword ptr [rdx+10h], xmm0
movaps xmmword ptr [rdx], xmm0
lea rsi, [rsp+128h+var_118]
mov rdi, rbx
mov ecx, 1
xor r8d, r8d
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5parseIRS9_EESD_OT_St8functionIFbiNS0_6detail13parse_event_tERSD_EEbb; 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>::parse<std::string&>(std::string&,std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&)>,bool,bool)
mov rax, [rsp+128h+var_88]
test rax, rax
jz short loc_8BF37
lea rdi, [rsp+128h+var_98]
mov rsi, rdi
mov edx, 3
call rax
loc_8BF37:
mov rdi, [rsp+128h+var_118]; void *
cmp rdi, r15
jz short loc_8BF78
mov rsi, [rsp+128h+var_108]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_8BF78
loc_8BF50:
mov [r14], r9
mov byte ptr [rbx], 0
mov qword ptr [rbx+8], 0
mov rdi, rbx
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
loc_8BF78:
mov rax, rbx
add rsp, 0F8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_8BF8D:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aMultipleDecima; "Multiple decimal points"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short loc_8BFC7
loc_8BFAB:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aMultipleExpone; "Multiple exponents"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
loc_8BFC7:
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
jmp loc_8C252
mov rbx, rdx
mov r14, rax
mov rax, [rsp+128h+var_88]
test rax, rax
jz short loc_8C007
lea rdi, [rsp+128h+var_98]
mov rsi, rdi
mov edx, 3
call rax
loc_8C007:
cmp ebx, 1
jnz loc_8C237
mov rdi, r14; void *
call ___cxa_begin_catch
mov r14, rax
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aFailedToParseN; "Failed to parse number: '"
lea rdi, [rsp+128h+var_D8]
lea rdx, [rsp+128h+var_118]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
lea rsi, asc_F02AC; "' ("
lea rdi, [rsp+128h+var_D8]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea r12, [rsp+128h+var_E8]
mov [r12-10h], r12
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jnz short loc_8C072
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r12], xmm0
jmp short loc_8C07F
loc_8C072:
mov [rsp+128h+var_F8], rdx
mov rdx, [rcx]
mov [rsp+128h+var_E8], rdx
loc_8C07F:
mov rdx, [rax+8]
mov [rsp+128h+var_F0], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
mov rax, [r14]
mov rdi, r14
call qword ptr [rax+10h]
lea rdi, [rsp+128h+var_70]
lea rdx, [rsp+128h+var_121]
mov rsi, rax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rdi, [rsp+128h+var_50]
lea rsi, [rsp+128h+var_F8]
lea rdx, [rsp+128h+var_70]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_S9_; std::operator+<char>(std::string&&,std::string&)
lea rsi, a09401910201912+51h; ")"
lea rdi, [rsp+128h+var_50]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea r13, [rsp+128h+var_A8]
mov [r13-10h], r13
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jnz short loc_8C108
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r13+0], xmm0
jmp short loc_8C118
loc_8C108:
mov [rsp+128h+var_B8], rdx
mov rdx, [rcx]
mov [rsp+128h+var_A8], rdx
loc_8C118:
mov rdx, [rax+8]
lea rsi, [rsp+128h+var_B8]
mov [rsi+8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
mov bpl, 1
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
mov rdi, [rsp+128h+var_B8]; void *
cmp rdi, r13
jz short loc_8C17C
mov rsi, [rsp+128h+var_A8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_8C17C
mov r14, rax
mov bpl, 1
loc_8C17C:
lea rax, [rsp+128h+var_40]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_8C1A5
mov rsi, [rsp+128h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_8C1A5
mov r14, rax
mov bpl, 1
loc_8C1A5:
lea rax, [rsp+128h+var_60]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_8C1CE
mov rsi, [rsp+128h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_8C1CE
mov r14, rax
mov bpl, 1
loc_8C1CE:
mov rdi, [rsp+128h+var_F8]; void *
cmp rdi, r12
jz short loc_8C1E5
mov rsi, [rsp+128h+var_E8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_8C1E5:
lea rax, [rsp+128h+var_C8]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_8C200
mov rsi, [rsp+128h+var_C8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_8C200:
test bpl, bpl
jnz short loc_8C22A
jmp short loc_8C232
mov r14, rax
lea rax, [rsp+128h+var_C8]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_8C22A
mov rsi, [rsp+128h+var_C8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_8C22A
mov r14, rax
loc_8C22A:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_8C232:
call ___cxa_end_catch
loc_8C237:
mov rdi, [rsp+128h+var_118]; void *
cmp rdi, r15
jz short loc_8C26C
mov rsi, [rsp+128h+var_108]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_8C26C
jmp short $+2
loc_8C252:
mov rdi, rax
call __clang_call_terminate
mov r14, rax
jmp short loc_8C26C
jmp short $+2
loc_8C261:
mov r14, rax
mov rdi, rbx; void *
call ___cxa_free_exception
loc_8C26C:
mov rdi, r14
call __Unwind_Resume
| long long minja::Parser::parseNumber(long long a1, long long a2, char **a3, char **a4)
{
long long v7; // rbx
char *v8; // r9
char *v9; // rbp
char *v10; // r13
char *v11; // rsi
char *v12; // rbx
char *v13; // rax
int v14; // ecx
char *v15; // rdx
char v16; // al
char v17; // cl
int v18; // edi
bool v19; // zf
std::runtime_error *exception; // rbx
void *v22[2]; // [rsp+10h] [rbp-118h] BYREF
_QWORD v23[2]; // [rsp+20h] [rbp-108h] BYREF
__int128 v24; // [rsp+90h] [rbp-98h] BYREF
__int128 v25; // [rsp+A0h] [rbp-88h]
v7 = a1;
v8 = *a3;
v9 = *(char **)(a2 + 24);
v10 = *(char **)(a2 + 32);
v11 = *a3;
if ( v10 != v9 )
{
v12 = *a3;
do
{
if ( !(unsigned int)isspace((unsigned int)*v10) )
break;
*(_QWORD *)(a2 + 32) = ++v10;
}
while ( v10 != v9 );
v11 = *a3;
v8 = v12;
v7 = a1;
}
v13 = *a4;
if ( *a4 == v11 )
goto LABEL_25;
v14 = (unsigned __int8)*v11;
if ( v14 == 45 || (v15 = v11, v14 == 43) )
{
v15 = v11 + 1;
*a3 = v11 + 1;
v13 = *a4;
}
if ( v15 != v13 )
{
v16 = 0;
v17 = 0;
do
{
v18 = *v15;
if ( (unsigned int)(v18 - 48) >= 0xA )
{
if ( (unsigned __int8)v18 == 46 )
{
v19 = (v16 & 1) == 0;
v16 = 1;
if ( !v19 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Multiple decimal points");
goto LABEL_28;
}
}
else
{
if ( v15 == v11 || ((unsigned __int8)v18 | 0x20) != 0x65 )
break;
v19 = (v17 & 1) == 0;
v17 = 1;
if ( !v19 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Multiple exponents");
LABEL_28:
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
}
}
*a3 = ++v15;
}
while ( v15 != *a4 );
}
if ( v15 == v11 )
{
LABEL_25:
*a3 = v8;
*(_BYTE *)v7 = 0;
*(_QWORD *)(v7 + 8) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)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>::assert_invariant((char *)v7);
}
else
{
v22[0] = v23;
std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>((long long)v22, v11, (long long)v15);
v25 = 0LL;
v24 = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::parse<std::string&>(
v7,
v22,
&v24,
1LL,
0LL);
if ( (_QWORD)v25 )
((void ( *)(__int128 *, __int128 *, long long))v25)(&v24, &v24, 3LL);
if ( v22[0] != v23 )
operator delete(v22[0], v23[0] + 1LL);
}
return v7;
}
| parseNumber:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xf8
MOV R15,RCX
MOV R14,RDX
MOV R12,RSI
MOV RBX,RDI
MOV R9,qword ptr [RDX]
MOV RBP,qword ptr [RSI + 0x18]
MOV R13,qword ptr [RSI + 0x20]
MOV RSI,R9
CMP R13,RBP
JZ 0x0018be66
MOV qword ptr [RSP + 0x8],RBX
MOV RBX,R9
LAB_0018be40:
MOVSX EDI,byte ptr [R13]
CALL 0x0011a0c0
TEST EAX,EAX
JZ 0x0018be5b
INC R13
MOV qword ptr [R12 + 0x20],R13
CMP R13,RBP
JNZ 0x0018be40
LAB_0018be5b:
MOV RSI,qword ptr [R14]
MOV R9,RBX
MOV RBX,qword ptr [RSP + 0x8]
LAB_0018be66:
MOV RAX,qword ptr [R15]
CMP RAX,RSI
JZ 0x0018bf50
MOVZX ECX,byte ptr [RSI]
CMP ECX,0x2d
JZ 0x0018be82
MOV RDX,RSI
CMP ECX,0x2b
JNZ 0x0018be8c
LAB_0018be82:
LEA RDX,[RSI + 0x1]
MOV qword ptr [R14],RDX
MOV RAX,qword ptr [R15]
LAB_0018be8c:
CMP RDX,RAX
JZ 0x0018bed9
XOR EAX,EAX
XOR ECX,ECX
LAB_0018be95:
MOVSX EDI,byte ptr [RDX]
LEA R8D,[RDI + -0x30]
CMP R8D,0xa
JC 0x0018bece
MOVZX EDI,DIL
CMP EDI,0x2e
JNZ 0x0018beb6
TEST AL,0x1
MOV AL,0x1
JZ 0x0018bece
JMP 0x0018bf8d
LAB_0018beb6:
CMP RDX,RSI
JZ 0x0018bed9
OR EDI,0x20
CMP EDI,0x65
JNZ 0x0018bed9
TEST CL,0x1
MOV CL,0x1
JNZ 0x0018bfab
LAB_0018bece:
INC RDX
MOV qword ptr [R14],RDX
CMP RDX,qword ptr [R15]
JNZ 0x0018be95
LAB_0018bed9:
CMP RDX,RSI
JZ 0x0018bf50
LEA R15,[RSP + 0x20]
MOV qword ptr [R15 + -0x10],R15
LAB_0018bee7:
LEA RDI,[RSP + 0x10]
CALL 0x00170c0e
XORPS XMM0,XMM0
LEA RDX,[RSP + 0x90]
MOVAPS xmmword ptr [RDX + 0x10],XMM0
MOVAPS xmmword ptr [RDX],XMM0
LAB_0018bf03:
LEA RSI,[RSP + 0x10]
MOV RDI,RBX
MOV ECX,0x1
XOR R8D,R8D
CALL 0x0018c804
MOV RAX,qword ptr [RSP + 0xa0]
TEST RAX,RAX
JZ 0x0018bf37
LAB_0018bf25:
LEA RDI,[RSP + 0x90]
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_0018bf37:
MOV RDI,qword ptr [RSP + 0x10]
CMP RDI,R15
JZ 0x0018bf78
MOV RSI,qword ptr [RSP + 0x20]
INC RSI
CALL 0x0011a8e0
JMP 0x0018bf78
LAB_0018bf50:
MOV qword ptr [R14],R9
MOV byte ptr [RBX],0x0
MOV qword ptr [RBX + 0x8],0x0
MOV RDI,RBX
MOV ESI,0x1
CALL 0x00158f20
MOV RDI,RBX
MOV ESI,0x1
CALL 0x00158f20
LAB_0018bf78:
MOV RAX,RBX
ADD RSP,0xf8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0018bf8d:
MOV EDI,0x10
CALL 0x0011a450
MOV RBX,RAX
LAB_0018bf9a:
LEA RSI,[0x1f0267]
MOV RDI,RAX
CALL 0x0011a330
LAB_0018bfa9:
JMP 0x0018bfc7
LAB_0018bfab:
MOV EDI,0x10
CALL 0x0011a450
MOV RBX,RAX
LAB_0018bfb8:
LEA RSI,[0x1f027f]
MOV RDI,RAX
CALL 0x0011a330
LAB_0018bfc7:
MOV RSI,qword ptr [0x0022bff0]
MOV RDX,qword ptr [0x0022bf60]
MOV RDI,RBX
CALL 0x0011af10
|
/* minja::Parser::parseNumber(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::string >&,
__gnu_cxx::__normal_iterator<char const*, std::__cxx11::string > const&) */
__normal_iterator *
minja::Parser::parseNumber(__normal_iterator *param_1,__normal_iterator *param_2)
{
byte bVar1;
byte *pbVar2;
char *pcVar3;
bool bVar4;
bool bVar5;
bool bVar6;
int iVar7;
byte *pbVar8;
runtime_error *this;
bool bVar9;
int8 *in_RCX;
long *in_RDX;
byte *pbVar10;
byte *pbVar11;
char *pcVar12;
long *local_118 [2];
long local_108 [14];
int8 local_98;
int8 uStack_90;
code *local_88;
int8 uStack_80;
pbVar2 = (byte *)*in_RDX;
pcVar3 = *(char **)(param_2 + 0x18);
pcVar12 = *(char **)(param_2 + 0x20);
pbVar11 = pbVar2;
if (pcVar12 != pcVar3) {
do {
iVar7 = isspace((int)*pcVar12);
if (iVar7 == 0) break;
pcVar12 = pcVar12 + 1;
*(char **)(param_2 + 0x20) = pcVar12;
} while (pcVar12 != pcVar3);
pbVar11 = (byte *)*in_RDX;
}
pbVar8 = (byte *)*in_RCX;
if (pbVar8 != pbVar11) {
if ((*pbVar11 == 0x2d) || (pbVar10 = pbVar11, *pbVar11 == 0x2b)) {
pbVar10 = pbVar11 + 1;
*in_RDX = (long)pbVar10;
pbVar8 = (byte *)*in_RCX;
}
if (pbVar10 != pbVar8) {
bVar6 = false;
bVar9 = false;
do {
bVar1 = *pbVar10;
bVar4 = bVar6;
bVar5 = bVar9;
if (9 < (int)(char)bVar1 - 0x30U) {
if (bVar1 == 0x2e) {
bVar4 = true;
if (bVar6) {
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0018bf9a to 0018bfa8 has its CatchHandler @ 0018c261 */
std::runtime_error::runtime_error(this,"Multiple decimal points");
LAB_0018bfc7:
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_0022bff0,PTR__runtime_error_0022bf60);
}
}
else {
if ((pbVar10 == pbVar11) || ((bVar1 | 0x20) != 0x65)) break;
bVar5 = true;
if (bVar9) {
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0018bfb8 to 0018bfc6 has its CatchHandler @ 0018c25f */
std::runtime_error::runtime_error(this,"Multiple exponents");
goto LAB_0018bfc7;
}
}
}
bVar9 = bVar5;
bVar6 = bVar4;
pbVar10 = pbVar10 + 1;
*in_RDX = (long)pbVar10;
} while (pbVar10 != (byte *)*in_RCX);
}
if (pbVar10 != pbVar11) {
/* try { // try from 0018bee7 to 0018bef0 has its CatchHandler @ 0018c25a */
local_118[0] = local_108;
std::__cxx11::string::
_M_construct<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>(local_118);
local_88 = (code *)0x0;
uStack_80 = 0;
local_98 = 0;
uStack_90 = 0;
/* try { // try from 0018bf03 to 0018bf17 has its CatchHandler @ 0018bfe2 */
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>
::parse<std::__cxx11::string&>
((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)param_1,local_118,&local_98,1,0);
if (local_88 != (code *)0x0) {
/* try { // try from 0018bf25 to 0018bf36 has its CatchHandler @ 0018bfdd */
(*local_88)(&local_98,&local_98,3);
}
if (local_118[0] == local_108) {
return param_1;
}
operator_delete(local_118[0],local_108[0] + 1);
return param_1;
}
}
*in_RDX = (long)pbVar2;
*param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(param_1,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(param_1,0));
return param_1;
}
| |
44,759 | js_global_isFinite | bluesky950520[P]quickjs/quickjs.c | static JSValue js_global_isFinite(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
BOOL res;
double d;
if (unlikely(JS_ToFloat64(ctx, &d, argv[0])))
return JS_EXCEPTION;
res = isfinite(d);
return js_bool(res);
} | O0 | c | js_global_isFinite:
subq $0x48, %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 0x10(%rsp), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
movq %rsp, %rsi
callq 0x372c0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xcf05f
movl $0x0, 0x38(%rsp)
movq $0x6, 0x40(%rsp)
jmp 0xcf0a2
movsd (%rsp), %xmm0
movq %xmm0, %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
andq %rcx, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
subq %rcx, %rax
setl %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %edi
callq 0x55f90
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rdx
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
| js_global_isFinite:
sub rsp, 48h
mov [rsp+48h+var_20], rsi
mov [rsp+48h+var_18], rdx
mov [rsp+48h+var_28], rdi
mov [rsp+48h+var_2C], ecx
mov [rsp+48h+var_38], r8
mov rdi, [rsp+48h+var_28]
mov rax, [rsp+48h+var_38]
mov rdx, [rax]
mov rcx, [rax+8]
mov rsi, rsp
call JS_ToFloat64
cmp eax, 0
setnz al
xor al, 0FFh
xor al, 0FFh
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_CF05F
mov dword ptr [rsp+48h+var_10], 0
mov [rsp+48h+var_8], 6
jmp short loc_CF0A2
loc_CF05F:
movsd xmm0, [rsp+48h+var_48]
movq rax, xmm0
mov rcx, 7FFFFFFFFFFFFFFFh
and rax, rcx
mov rcx, 7FF0000000000000h
sub rax, rcx
setl al
and al, 1
movzx eax, al
mov [rsp+48h+var_3C], eax
mov edi, [rsp+48h+var_3C]
call js_bool
mov [rsp+48h+var_10], rax
mov [rsp+48h+var_8], rdx
loc_CF0A2:
mov rax, [rsp+48h+var_10]
mov rdx, [rsp+48h+var_8]
add rsp, 48h
retn
| long long js_global_isFinite(long long a1, long long a2, long long a3, int a4, long long a5)
{
long long v5; // rdx
long long v7; // [rsp+0h] [rbp-48h] BYREF
BOOL v8; // [rsp+Ch] [rbp-3Ch]
long long v9; // [rsp+10h] [rbp-38h]
int v10; // [rsp+1Ch] [rbp-2Ch]
long long v11; // [rsp+20h] [rbp-28h]
long long v12; // [rsp+28h] [rbp-20h]
long long v13; // [rsp+30h] [rbp-18h]
long long v14; // [rsp+38h] [rbp-10h]
long long v15; // [rsp+40h] [rbp-8h]
v12 = a2;
v13 = a3;
v11 = a1;
v10 = a4;
v9 = a5;
if ( (unsigned int)JS_ToFloat64(a1, (long long)&v7, *(_DWORD **)a5, *(_QWORD *)(a5 + 8)) )
{
LODWORD(v14) = 0;
v15 = 6LL;
}
else
{
v8 = (v7 & 0x7FFFFFFFFFFFFFFFuLL) < 0x7FF0000000000000LL;
v14 = js_bool(v8);
v15 = v5;
}
return v14;
}
| js_global_isFinite:
SUB RSP,0x48
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 RAX,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RAX]
MOV RCX,qword ptr [RAX + 0x8]
MOV RSI,RSP
CALL 0x001372c0
CMP EAX,0x0
SETNZ AL
XOR AL,0xff
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x001cf05f
MOV dword ptr [RSP + 0x38],0x0
MOV qword ptr [RSP + 0x40],0x6
JMP 0x001cf0a2
LAB_001cf05f:
MOVSD XMM0,qword ptr [RSP]
MOVQ RAX,XMM0
MOV RCX,0x7fffffffffffffff
AND RAX,RCX
MOV RCX,0x7ff0000000000000
SUB RAX,RCX
SETL AL
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RSP + 0xc],EAX
MOV EDI,dword ptr [RSP + 0xc]
CALL 0x00155f90
MOV qword ptr [RSP + 0x38],RAX
MOV qword ptr [RSP + 0x40],RDX
LAB_001cf0a2:
MOV RAX,qword ptr [RSP + 0x38]
MOV RDX,qword ptr [RSP + 0x40]
ADD RSP,0x48
RET
|
int1 [16]
js_global_isFinite(int8 param_1,int8 param_2,int8 param_3,int4 param_4,
int8 *param_5)
{
int iVar1;
int1 auVar2 [16];
ulong local_48;
uint local_3c;
int8 *local_38;
int4 local_2c;
int8 local_28;
int8 local_20;
int8 local_18;
int4 local_10;
int4 uStack_c;
int8 local_8;
local_38 = param_5;
local_2c = param_4;
local_28 = param_1;
local_20 = param_2;
local_18 = param_3;
iVar1 = JS_ToFloat64(param_1,&local_48,*param_5,param_5[1]);
if (iVar1 == 0) {
local_3c = (uint)((local_48 & 0x7fffffffffffffff) < 0x7ff0000000000000);
auVar2 = js_bool(local_3c);
local_8 = auVar2._8_8_;
local_10 = auVar2._0_4_;
uStack_c = auVar2._4_4_;
}
else {
local_10 = 0;
local_8 = 6;
}
auVar2._4_4_ = uStack_c;
auVar2._0_4_ = local_10;
auVar2._8_8_ = local_8;
return auVar2;
}
| |
44,760 | js_global_isFinite | bluesky950520[P]quickjs/quickjs.c | static JSValue js_global_isFinite(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
BOOL res;
double d;
if (unlikely(JS_ToFloat64(ctx, &d, argv[0])))
return JS_EXCEPTION;
res = isfinite(d);
return js_bool(res);
} | O1 | c | js_global_isFinite:
pushq %rax
movq (%r8), %rdx
movq 0x8(%r8), %rcx
movq %rsp, %rsi
callq 0x26a6d
testl %eax, %eax
jne 0x1267b
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
andq (%rsp), %rcx
movabsq $0x7ff0000000000000, %rdx # imm = 0x7FF0000000000000
xorl %eax, %eax
cmpq %rdx, %rcx
setl %al
pushq $0x1
popq %rdx
popq %rcx
retq
pushq $0x6
popq %rdx
xorl %eax, %eax
jmp 0x12679
| js_global_isFinite:
push rax
mov rdx, [r8]
mov rcx, [r8+8]
mov rsi, rsp
call JS_ToFloat64
test eax, eax
jnz short loc_1267B
mov rcx, 7FFFFFFFFFFFFFFFh
and rcx, [rsp+8+var_8]
mov rdx, 7FF0000000000000h
xor eax, eax
cmp rcx, rdx
setl al
push 1
pop rdx
loc_12679:
pop rcx
retn
loc_1267B:
push 6
pop rdx
xor eax, eax
jmp short loc_12679
| _BOOL8 js_global_isFinite(long long a1, long long a2, long long a3, long long a4, _QWORD *a5)
{
long long v5; // rax
long long v7; // [rsp+0h] [rbp-8h] BYREF
v7 = v5;
return !(unsigned int)JS_ToFloat64(a1, &v7, *a5, a5[1]) && (v7 & 0x7FFFFFFFFFFFFFFFuLL) < 0x7FF0000000000000LL;
}
| js_global_isFinite:
PUSH RAX
MOV RDX,qword ptr [R8]
MOV RCX,qword ptr [R8 + 0x8]
MOV RSI,RSP
CALL 0x00126a6d
TEST EAX,EAX
JNZ 0x0011267b
MOV RCX,0x7fffffffffffffff
AND RCX,qword ptr [RSP]
MOV RDX,0x7ff0000000000000
XOR EAX,EAX
CMP RCX,RDX
SETL AL
PUSH 0x1
POP RDX
LAB_00112679:
POP RCX
RET
LAB_0011267b:
PUSH 0x6
POP RDX
XOR EAX,EAX
JMP 0x00112679
|
bool js_global_isFinite(int8 param_1)
{
int iVar1;
ulong in_RAX;
int8 *in_R8;
ulong local_8;
local_8 = in_RAX;
iVar1 = JS_ToFloat64(param_1,&local_8,*in_R8,in_R8[1]);
return iVar1 == 0 && (local_8 & 0x7fffffffffffffff) < 0x7ff0000000000000;
}
| |
44,761 | blst_sk_mul_n_check | corpus-core[P]colibri-stateless/build_O3/_deps/blst-src/src/exports.c | int blst_sk_mul_n_check(pow256 ret, const pow256 a, const pow256 b)
{
vec256 t[2];
const union {
long one;
char little;
} is_endian = { 1 };
bool_t is_zero;
if (((size_t)a|(size_t)b)%sizeof(limb_t) != 0 || !is_endian.little) {
limbs_from_le_bytes(t[0], a, sizeof(pow256));
limbs_from_le_bytes(t[1], b, sizeof(pow256));
a = (const byte *)t[0];
b = (const byte *)t[1];
}
mul_mont_sparse_256(t[0], BLS12_381_rRR, (const limb_t *)a, BLS12_381_r, r0);
mul_mont_sparse_256(t[0], t[0], (const limb_t *)b, BLS12_381_r, r0);
le_bytes_from_limbs(ret, t[0], sizeof(pow256));
is_zero = vec_is_zero(t[0], sizeof(vec256));
vec_zero(t, sizeof(t));
return (int)(is_zero^1);
} | O3 | c | blst_sk_mul_n_check:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %rdx
movq %rdi, %rbx
movl %r14d, %eax
orl %edx, %eax
testb $0x7, %al
je 0x65434
movl $0x1f, %eax
xorl %ecx, %ecx
shlq $0x8, %rcx
movzbl (%rdx,%rax), %esi
orq %rsi, %rcx
movq %rax, %rsi
andq $-0x8, %rsi
movq %rcx, -0x70(%rbp,%rsi)
addq $-0x1, %rax
jb 0x653e7
leaq -0x50(%rbp), %rax
movl $0x1f, %ecx
xorl %esi, %esi
leaq -0x70(%rbp), %rdx
shlq $0x8, %rsi
movzbl (%r14,%rcx), %edi
orq %rdi, %rsi
movq %rcx, %rdi
andq $-0x8, %rdi
movq %rsi, -0x50(%rbp,%rdi)
addq $-0x1, %rcx
jb 0x65413
movq %rax, %r14
leaq 0x27b15(%rip), %rsi # 0x8cf50
leaq 0x275fe(%rip), %r15 # 0x8ca40
leaq -0x70(%rbp), %r12
movabsq $-0x100000001, %r13 # imm = 0xFFFFFFFEFFFFFFFF
movq %r12, %rdi
movq %r15, %rcx
movq %r13, %r8
callq 0x76040
movq %r12, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %r13, %r8
callq 0x76040
cmpq %rbx, %r12
je 0x6549c
xorl %eax, %eax
movq -0x70(%rbp,%rax,8), %rdx
xorl %ecx, %ecx
movb %dl, (%rbx,%rcx)
incq %rcx
shrq $0x8, %rdx
cmpq $0x8, %rcx
jne 0x65480
incq %rax
addq %rcx, %rbx
cmpq $0x4, %rax
jne 0x65479
leaq -0x70(%rbp), %rdi
movl $0x20, %esi
callq 0x70940
xorl %ecx, %ecx
movq $0x0, -0x70(%rbp,%rcx,8)
incq %rcx
cmpq $0x8, %rcx
jne 0x654ac
leaq -0x70(%rbp), %rcx
xorl $0x1, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| blst_sk_mul_n_check:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov r14, rdx
mov rdx, rsi
mov rbx, rdi
mov eax, r14d
or eax, edx
test al, 7
jz short loc_65434
mov eax, 1Fh
xor ecx, ecx
loc_653E7:
shl rcx, 8
movzx esi, byte ptr [rdx+rax]
or rcx, rsi
mov rsi, rax
and rsi, 0FFFFFFFFFFFFFFF8h
mov [rbp+rsi+var_70], rcx
add rax, 0FFFFFFFFFFFFFFFFh
jb short loc_653E7
lea rax, [rbp+var_50]
mov ecx, 1Fh
xor esi, esi
lea rdx, [rbp+var_70]
loc_65413:
shl rsi, 8
movzx edi, byte ptr [r14+rcx]
or rsi, rdi
mov rdi, rcx
and rdi, 0FFFFFFFFFFFFFFF8h
mov [rbp+rdi+var_50], rsi
add rcx, 0FFFFFFFFFFFFFFFFh
jb short loc_65413
mov r14, rax
loc_65434:
lea rsi, BLS12_381_rRR
lea r15, BLS12_381_r
lea r12, [rbp+var_70]
mov r13, 0FFFFFFFEFFFFFFFFh
mov rdi, r12
mov rcx, r15
mov r8, r13
call mul_mont_sparse_256
mov rdi, r12
mov rsi, r12
mov rdx, r14
mov rcx, r15
mov r8, r13
call mul_mont_sparse_256
cmp r12, rbx
jz short loc_6549C
xor eax, eax
loc_65479:
mov rdx, [rbp+rax*8+var_70]
xor ecx, ecx
loc_65480:
mov [rbx+rcx], dl
inc rcx
shr rdx, 8
cmp rcx, 8
jnz short loc_65480
inc rax
add rbx, rcx
cmp rax, 4
jnz short loc_65479
loc_6549C:
lea rdi, [rbp+var_70]
mov esi, 20h ; ' '
call vec_is_zero_16x
xor ecx, ecx
loc_654AC:
mov [rbp+rcx*8+var_70], 0
inc rcx
cmp rcx, 8
jnz short loc_654AC
lea rcx, [rbp+var_70]
xor eax, 1
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long blst_sk_mul_n_check(_QWORD *a1, _QWORD *a2, _QWORD *a3)
{
_QWORD *v4; // rdx
_QWORD *v5; // rbx
long long v6; // rax
unsigned long long v7; // rcx
bool v8; // cf
long long v9; // rcx
unsigned long long v10; // rsi
long long i; // rax
unsigned long long v12; // rdx
long long j; // rcx
int is_zero_16x; // eax
long long k; // rcx
_QWORD v17[4]; // [rsp+0h] [rbp-70h] BYREF
_QWORD v18[10]; // [rsp+20h] [rbp-50h] BYREF
v4 = a2;
v5 = a1;
if ( (((unsigned __int8)a2 | (unsigned __int8)a3) & 7) != 0 )
{
v6 = 31LL;
v7 = 0LL;
do
{
v7 = *((unsigned __int8 *)a2 + v6) | (v7 << 8);
*(_QWORD *)((char *)v17 + (v6 & 0xFFFFFFFFFFFFFFF8LL)) = v7;
v8 = v6-- != 0;
}
while ( v8 );
v9 = 31LL;
v10 = 0LL;
v4 = v17;
do
{
v10 = *((unsigned __int8 *)a3 + v9) | (v10 << 8);
*(_QWORD *)((char *)v18 + (v9 & 0xFFFFFFFFFFFFFFF8LL)) = v10;
v8 = v9-- != 0;
}
while ( v8 );
a3 = v18;
}
mul_mont_sparse_256(v17, &BLS12_381_rRR, v4, &BLS12_381_r, 0xFFFFFFFEFFFFFFFFLL);
mul_mont_sparse_256(v17, v17, a3, &BLS12_381_r, 0xFFFFFFFEFFFFFFFFLL);
if ( v17 != a1 )
{
for ( i = 0LL; i != 4; ++i )
{
v12 = v17[i];
for ( j = 0LL; j != 8; ++j )
{
*((_BYTE *)v5 + j) = v12;
v12 >>= 8;
}
++v5;
}
}
is_zero_16x = vec_is_zero_16x(v17, 32LL);
for ( k = 0LL; k != 8; ++k )
v17[k] = 0LL;
return is_zero_16x ^ 1u;
}
| blst_sk_mul_n_check:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R14,RDX
MOV RDX,RSI
MOV RBX,RDI
MOV EAX,R14D
OR EAX,EDX
TEST AL,0x7
JZ 0x00165434
MOV EAX,0x1f
XOR ECX,ECX
LAB_001653e7:
SHL RCX,0x8
MOVZX ESI,byte ptr [RDX + RAX*0x1]
OR RCX,RSI
MOV RSI,RAX
AND RSI,-0x8
MOV qword ptr [RBP + RSI*0x1 + -0x70],RCX
ADD RAX,-0x1
JC 0x001653e7
LEA RAX,[RBP + -0x50]
MOV ECX,0x1f
XOR ESI,ESI
LEA RDX,[RBP + -0x70]
LAB_00165413:
SHL RSI,0x8
MOVZX EDI,byte ptr [R14 + RCX*0x1]
OR RSI,RDI
MOV RDI,RCX
AND RDI,-0x8
MOV qword ptr [RBP + RDI*0x1 + -0x50],RSI
ADD RCX,-0x1
JC 0x00165413
MOV R14,RAX
LAB_00165434:
LEA RSI,[0x18cf50]
LEA R15,[0x18ca40]
LEA R12,[RBP + -0x70]
MOV R13,-0x100000001
MOV RDI,R12
MOV RCX,R15
MOV R8,R13
CALL 0x00176040
MOV RDI,R12
MOV RSI,R12
MOV RDX,R14
MOV RCX,R15
MOV R8,R13
CALL 0x00176040
CMP R12,RBX
JZ 0x0016549c
XOR EAX,EAX
LAB_00165479:
MOV RDX,qword ptr [RBP + RAX*0x8 + -0x70]
XOR ECX,ECX
LAB_00165480:
MOV byte ptr [RBX + RCX*0x1],DL
INC RCX
SHR RDX,0x8
CMP RCX,0x8
JNZ 0x00165480
INC RAX
ADD RBX,RCX
CMP RAX,0x4
JNZ 0x00165479
LAB_0016549c:
LEA RDI,[RBP + -0x70]
MOV ESI,0x20
CALL 0x00170940
XOR ECX,ECX
LAB_001654ac:
MOV qword ptr [RBP + RCX*0x8 + -0x70],0x0
INC RCX
CMP RCX,0x8
JNZ 0x001654ac
LEA RCX,[RBP + -0x70]
XOR EAX,0x1
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
uint blst_sk_mul_n_check(ulong *param_1,ulong *param_2,ulong *param_3)
{
uint uVar1;
ulong uVar2;
long lVar3;
ulong uVar4;
long lVar5;
ulong *puVar6;
bool bVar7;
ulong local_78 [9];
puVar6 = param_3;
if ((((uint)param_3 | (uint)param_2) & 7) != 0) {
uVar2 = 0x1f;
uVar4 = 0;
do {
uVar4 = uVar4 << 8 | (ulong)*(byte *)((long)param_2 + uVar2);
*(ulong *)((long)local_78 + (uVar2 & 0xfffffffffffffff8)) = uVar4;
bVar7 = uVar2 != 0;
uVar2 = uVar2 - 1;
} while (bVar7);
puVar6 = local_78 + 4;
uVar2 = 0x1f;
uVar4 = 0;
param_2 = local_78;
do {
uVar4 = uVar4 << 8 | (ulong)*(byte *)((long)param_3 + uVar2);
*(ulong *)((long)local_78 + (uVar2 & 0xfffffffffffffff8) + 0x20) = uVar4;
bVar7 = uVar2 != 0;
uVar2 = uVar2 - 1;
} while (bVar7);
}
mul_mont_sparse_256(local_78,BLS12_381_rRR,param_2,BLS12_381_r,0xfffffffeffffffff);
mul_mont_sparse_256(local_78,local_78,puVar6,BLS12_381_r,0xfffffffeffffffff);
if (local_78 != param_1) {
lVar3 = 0;
do {
uVar2 = local_78[lVar3];
lVar5 = 0;
do {
*(char *)((long)param_1 + lVar5) = (char)uVar2;
lVar5 = lVar5 + 1;
uVar2 = uVar2 >> 8;
} while (lVar5 != 8);
lVar3 = lVar3 + 1;
param_1 = param_1 + 1;
} while (lVar3 != 4);
}
uVar1 = vec_is_zero_16x(local_78,0x20);
lVar3 = 0;
do {
local_78[lVar3] = 0;
lVar3 = lVar3 + 1;
} while (lVar3 != 8);
return uVar1 ^ 1;
}
| |
44,762 | js_boolean_constructor | bluesky950520[P]quickjs/quickjs.c | static JSValue js_boolean_constructor(JSContext *ctx, JSValue new_target,
int argc, JSValue *argv)
{
JSValue val, obj;
val = js_bool(JS_ToBool(ctx, argv[0]));
if (!JS_IsUndefined(new_target)) {
obj = js_create_from_ctor(ctx, new_target, JS_CLASS_BOOLEAN);
if (!JS_IsException(obj))
JS_SetObjectData(ctx, obj, val);
return obj;
} else {
return val;
}
} | O0 | c | js_boolean_constructor:
subq $0x78, %rsp
movq %rsi, 0x58(%rsp)
movq %rdx, 0x60(%rsp)
movq %rdi, 0x50(%rsp)
movl %ecx, 0x4c(%rsp)
movq %r8, 0x40(%rsp)
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x3e820
movl %eax, %edi
callq 0x5d540
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x58(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0x34550
cmpl $0x0, %eax
jne 0x5d658
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x60(%rsp), %rdx
movl $0x6, %ecx
callq 0x5b0f0
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
jne 0x5d642
movq 0x50(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %r8
callq 0x5b300
movq 0x20(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x70(%rsp)
jmp 0x5d66c
movq 0x30(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x68(%rsp), %rax
movq 0x70(%rsp), %rdx
addq $0x78, %rsp
retq
nopl (%rax,%rax)
| js_boolean_constructor:
sub rsp, 78h
mov [rsp+78h+var_20], rsi
mov [rsp+78h+var_18], rdx
mov [rsp+78h+var_28], rdi
mov [rsp+78h+var_2C], ecx
mov [rsp+78h+var_38], r8
mov rdi, [rsp+78h+var_28]
mov rax, [rsp+78h+var_38]
mov rsi, [rax]
mov rdx, [rax+8]
call JS_ToBool
mov edi, eax
call js_bool
mov [rsp+78h+var_68], rax
mov [rsp+78h+var_60], rdx
mov rax, [rsp+78h+var_68]
mov [rsp+78h+var_48], rax
mov rax, [rsp+78h+var_60]
mov [rsp+78h+var_40], rax
mov rdi, [rsp+78h+var_20]
mov rsi, [rsp+78h+var_18]
call JS_IsUndefined_1
cmp eax, 0
jnz short loc_5D658
mov rdi, [rsp+78h+var_28]
mov rsi, [rsp+78h+var_20]
mov rdx, [rsp+78h+var_18]
mov ecx, 6
call js_create_from_ctor
mov [rsp+78h+var_78], rax
mov [rsp+78h+var_70], rdx
mov rax, [rsp+78h+var_78]
mov [rsp+78h+var_58], rax
mov rax, [rsp+78h+var_70]
mov [rsp+78h+var_50], rax
mov rdi, [rsp+78h+var_58]
mov rsi, [rsp+78h+var_50]
call JS_IsException_1
cmp eax, 0
jnz short loc_5D642
mov rdi, [rsp+78h+var_28]
mov rsi, [rsp+78h+var_58]
mov rdx, [rsp+78h+var_50]
mov rcx, [rsp+78h+var_48]
mov r8, [rsp+78h+var_40]
call JS_SetObjectData
loc_5D642:
mov rax, [rsp+78h+var_58]
mov [rsp+78h+var_10], rax
mov rax, [rsp+78h+var_50]
mov [rsp+78h+var_8], rax
jmp short loc_5D66C
loc_5D658:
mov rax, [rsp+78h+var_48]
mov [rsp+78h+var_10], rax
mov rax, [rsp+78h+var_40]
mov [rsp+78h+var_8], rax
loc_5D66C:
mov rax, [rsp+78h+var_10]
mov rdx, [rsp+78h+var_8]
add rsp, 78h
retn
| long long js_boolean_constructor(
long long a1,
long long a2,
long long a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11,
long long a12,
long long a13)
{
int v13; // eax
long long v14; // rdx
int v15; // edx
double v16; // xmm4_8
double v17; // xmm5_8
long long v19; // [rsp+0h] [rbp-78h]
long long v20; // [rsp+10h] [rbp-68h]
int v21; // [rsp+28h] [rbp-50h]
long long v22; // [rsp+38h] [rbp-40h]
v13 = JS_ToBool(a1, *(_DWORD **)a13, *(_QWORD *)(a13 + 8));
v20 = js_bool(v13);
v22 = v14;
if ( JS_IsUndefined_1(a2, a3) )
return v20;
v19 = js_create_from_ctor(a1, a2, a3, 6);
v21 = v15;
if ( !JS_IsException_1(v19, v15) )
JS_SetObjectData(a1, v19, v21, v20, v22, a4, a5, a6, a7, v16, v17, a10, a11);
return v19;
}
| js_boolean_constructor:
SUB RSP,0x78
MOV qword ptr [RSP + 0x58],RSI
MOV qword ptr [RSP + 0x60],RDX
MOV qword ptr [RSP + 0x50],RDI
MOV dword ptr [RSP + 0x4c],ECX
MOV qword ptr [RSP + 0x40],R8
MOV RDI,qword ptr [RSP + 0x50]
MOV RAX,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
CALL 0x0013e820
MOV EDI,EAX
CALL 0x0015d540
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x18],RDX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x38],RAX
MOV RDI,qword ptr [RSP + 0x58]
MOV RSI,qword ptr [RSP + 0x60]
CALL 0x00134550
CMP EAX,0x0
JNZ 0x0015d658
MOV RDI,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RSP + 0x58]
MOV RDX,qword ptr [RSP + 0x60]
MOV ECX,0x6
CALL 0x0015b0f0
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x8],RDX
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x28],RAX
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x28]
CALL 0x00129fb0
CMP EAX,0x0
JNZ 0x0015d642
MOV RDI,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
MOV RCX,qword ptr [RSP + 0x30]
MOV R8,qword ptr [RSP + 0x38]
CALL 0x0015b300
LAB_0015d642:
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x68],RAX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x70],RAX
JMP 0x0015d66c
LAB_0015d658:
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x68],RAX
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x70],RAX
LAB_0015d66c:
MOV RAX,qword ptr [RSP + 0x68]
MOV RDX,qword ptr [RSP + 0x70]
ADD RSP,0x78
RET
|
int1 [16]
js_boolean_constructor
(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 *param_5)
{
int4 uVar1;
int iVar2;
int8 uVar3;
int8 uVar4;
int1 auVar5 [16];
uVar1 = JS_ToBool(param_1,*param_5,param_5[1]);
auVar5 = js_bool(uVar1);
uVar4 = auVar5._8_8_;
uVar3 = auVar5._0_8_;
iVar2 = JS_IsUndefined(param_2,param_3);
if (iVar2 == 0) {
auVar5 = js_create_from_ctor(param_1,param_2,param_3,6);
iVar2 = JS_IsException(auVar5._0_8_,auVar5._8_8_);
if (iVar2 == 0) {
JS_SetObjectData(param_1,auVar5._0_8_,auVar5._8_8_,uVar3,uVar4);
}
}
return auVar5;
}
| |
44,763 | js_boolean_constructor | bluesky950520[P]quickjs/quickjs.c | static JSValue js_boolean_constructor(JSContext *ctx, JSValue new_target,
int argc, JSValue *argv)
{
JSValue val, obj;
val = js_bool(JS_ToBool(ctx, argv[0]));
if (!JS_IsUndefined(new_target)) {
obj = js_create_from_ctor(ctx, new_target, JS_CLASS_BOOLEAN);
if (!JS_IsException(obj))
JS_SetObjectData(ctx, obj, val);
return obj;
} else {
return val;
}
} | O2 | c | js_boolean_constructor:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq (%r8), %rsi
movq 0x8(%r8), %rdx
callq 0x24e1f
xorl %ebx, %ebx
testl %eax, %eax
setne %bl
cmpl $0x3, %r15d
jne 0x3571c
pushq $0x1
popq %r15
jmp 0x35751
pushq $0x6
popq %rcx
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3400a
movq %rax, %r12
movq %rdx, %r15
cmpl $0x6, %r15d
je 0x3574e
pushq $0x1
popq %r8
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x3410c
movq %r12, %rbx
movq %rbx, %rax
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| js_boolean_constructor:
push r15
push r14
push r12
push rbx
push rax
mov r15, rdx
mov r12, rsi
mov r14, rdi
mov rsi, [r8]
mov rdx, [r8+8]
call JS_ToBool
xor ebx, ebx
test eax, eax
setnz bl
cmp r15d, 3
jnz short loc_3571C
push 1
pop r15
jmp short loc_35751
loc_3571C:
push 6
pop rcx
mov rdi, r14
mov rsi, r12
mov rdx, r15
call js_create_from_ctor
mov r12, rax
mov r15, rdx
cmp r15d, 6
jz short loc_3574E
push 1
pop r8
mov rdi, r14
mov rsi, r12
mov rdx, r15
mov rcx, rbx
call JS_SetObjectData
loc_3574E:
mov rbx, r12
loc_35751:
mov rax, rbx
mov rdx, r15
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| _BOOL8 js_boolean_constructor(
long long a1,
long long a2,
long long a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11,
long long a12,
long long *a13)
{
char v13; // al
_BOOL8 v15; // rbx
unsigned long long v16; // rax
int v17; // edx
long long v18; // r9
double v19; // xmm4_8
double v20; // xmm5_8
unsigned long long v21; // r12
char v23; // [rsp-8h] [rbp-28h]
v23 = v13;
v15 = (unsigned int)JS_ToBool(a1, *a13, a13[1]) != 0;
if ( (_DWORD)a3 != 3 )
{
v16 = js_create_from_ctor(a1, a2, a3, 6);
v21 = v16;
if ( v17 != 6 )
JS_SetObjectData(a1, v16, v17, v15, 1LL, a4, a5, a6, a7, v19, v20, a10, a11, v18, v23);
return v21;
}
return v15;
}
| js_boolean_constructor:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RDX
MOV R12,RSI
MOV R14,RDI
MOV RSI,qword ptr [R8]
MOV RDX,qword ptr [R8 + 0x8]
CALL 0x00124e1f
XOR EBX,EBX
TEST EAX,EAX
SETNZ BL
CMP R15D,0x3
JNZ 0x0013571c
PUSH 0x1
POP R15
JMP 0x00135751
LAB_0013571c:
PUSH 0x6
POP RCX
MOV RDI,R14
MOV RSI,R12
MOV RDX,R15
CALL 0x0013400a
MOV R12,RAX
MOV R15,RDX
CMP R15D,0x6
JZ 0x0013574e
PUSH 0x1
POP R8
MOV RDI,R14
MOV RSI,R12
MOV RDX,R15
MOV RCX,RBX
CALL 0x0013410c
LAB_0013574e:
MOV RBX,R12
LAB_00135751:
MOV RAX,RBX
MOV RDX,R15
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
int1 [16]
js_boolean_constructor
(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 *param_5)
{
int iVar1;
ulong uVar2;
int1 auVar3 [16];
iVar1 = JS_ToBool(param_1,*param_5,param_5[1]);
uVar2 = CONCAT71(0,iVar1 != 0);
if ((int)param_3 == 3) {
auVar3._8_8_ = 1;
auVar3._0_8_ = uVar2;
}
else {
auVar3 = js_create_from_ctor(param_1,param_2,param_3,6);
if (auVar3._8_4_ != 6) {
JS_SetObjectData(param_1,auVar3._0_8_,auVar3._8_8_,uVar2,1);
}
}
return auVar3;
}
| |
44,764 | my_sync_dir | eloqsql/mysys/my_sync.c | int my_sync_dir(const char *dir_name __attribute__((unused)),
myf my_flags __attribute__((unused)))
{
#ifdef NEED_EXPLICIT_SYNC_DIR
static const char cur_dir_name[]= {FN_CURLIB, 0};
File dir_fd;
int res= 0;
const char *correct_dir_name;
DBUG_ENTER("my_sync_dir");
DBUG_PRINT("my",("Dir: '%s' my_flags: %lu", dir_name, my_flags));
/* Sometimes the path does not contain an explicit directory */
correct_dir_name= (dir_name[0] == 0) ? cur_dir_name : dir_name;
/*
Syncing a dir may give EINVAL on tmpfs on Linux, which is ok.
EIO on the other hand is very important. Hence MY_IGNORE_BADFD.
*/
if ((dir_fd= my_open(correct_dir_name, O_RDONLY, MYF(my_flags))) >= 0)
{
if (my_sync(dir_fd, MYF(my_flags | MY_IGNORE_BADFD)))
res= 2;
if (my_close(dir_fd, MYF(my_flags)))
res= 3;
}
else
res= 1;
DBUG_RETURN(res);
#else
return 0;
#endif
} | O3 | c | my_sync_dir:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x0, (%rdi)
movq %rsi, %rbx
leaq 0x34610(%rip), %rax # 0x66f2c
cmoveq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x31fa8
testl %eax, %eax
js 0x32963
movl %eax, %r14d
movq %rbx, %rsi
orq $0x20, %rsi
movl %eax, %edi
callq 0x327d4
xorl %r15d, %r15d
testl %eax, %eax
setne %r15b
addl %r15d, %r15d
movl %r14d, %edi
movq %rbx, %rsi
callq 0x3214d
testl %eax, %eax
movl $0x3, %eax
cmovel %r15d, %eax
jmp 0x32968
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| my_sync_dir:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
cmp byte ptr [rdi], 0
mov rbx, rsi
lea rax, my_sync_dir_cur_dir_name
cmovz rdi, rax
xor esi, esi
mov rdx, rbx
call my_open
test eax, eax
js short loc_32963
mov r14d, eax
mov rsi, rbx
or rsi, 20h
mov edi, eax
call my_sync
xor r15d, r15d
test eax, eax
setnz r15b
add r15d, r15d
mov edi, r14d
mov rsi, rbx
call my_close
test eax, eax
mov eax, 3
cmovz eax, r15d
jmp short loc_32968
loc_32963:
mov eax, 1
loc_32968:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long my_sync_dir(_BYTE *a1, long long a2)
{
int v2; // eax
unsigned int v3; // r14d
unsigned int v4; // r15d
bool v5; // zf
long long result; // rax
if ( !*a1 )
a1 = &my_sync_dir_cur_dir_name;
v2 = my_open((long long)a1, 0, a2);
if ( v2 < 0 )
return 1LL;
v3 = v2;
v4 = 2 * ((unsigned int)my_sync((unsigned int)v2, (unsigned int)a2 | 0x20) != 0);
v5 = (unsigned int)my_close(v3, a2) == 0;
result = 3LL;
if ( v5 )
return v4;
return result;
}
| my_sync_dir:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
CMP byte ptr [RDI],0x0
MOV RBX,RSI
LEA RAX,[0x166f2c]
CMOVZ RDI,RAX
XOR ESI,ESI
MOV RDX,RBX
CALL 0x00131fa8
TEST EAX,EAX
JS 0x00132963
MOV R14D,EAX
MOV RSI,RBX
OR RSI,0x20
MOV EDI,EAX
CALL 0x001327d4
XOR R15D,R15D
TEST EAX,EAX
SETNZ R15B
ADD R15D,R15D
MOV EDI,R14D
MOV RSI,RBX
CALL 0x0013214d
TEST EAX,EAX
MOV EAX,0x3
CMOVZ EAX,R15D
JMP 0x00132968
LAB_00132963:
MOV EAX,0x1
LAB_00132968:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
char my_sync_dir(char *param_1,ulong param_2)
{
char cVar1;
int iVar2;
int iVar3;
if (*param_1 == '\0') {
param_1 = ".";
}
iVar2 = my_open(param_1,0,param_2);
if (iVar2 < 0) {
cVar1 = '\x01';
}
else {
iVar3 = my_sync(iVar2,param_2 | 0x20);
iVar2 = my_close(iVar2,param_2);
cVar1 = '\x03';
if (iVar2 == 0) {
cVar1 = (iVar3 != 0) * '\x02';
}
}
return cVar1;
}
| |
44,765 | ma_state_info_write | eloqsql/storage/maria/ma_open.c | uint _ma_state_info_write(MARIA_SHARE *share, uint pWrite)
{
uint res;
if (share->options & HA_OPTION_READ_ONLY_DATA)
return 0;
if (pWrite & MA_STATE_INFO_WRITE_LOCK)
mysql_mutex_lock(&share->intern_lock);
else if (maria_multi_threaded && !share->temporary)
mysql_mutex_assert_owner(&share->intern_lock);
if (share->base.born_transactional && translog_status == TRANSLOG_OK &&
!maria_in_recovery)
{
/*
In a recovery, we want to set is_of_horizon to the LSN of the last
record executed by Recovery, not the current EOF of the log (which
is too new). Recovery does it by itself.
*/
share->state.is_of_horizon= translog_get_horizon();
DBUG_PRINT("info", ("is_of_horizon set to LSN " LSN_FMT "",
LSN_IN_PARTS(share->state.is_of_horizon)));
}
res= _ma_state_info_write_sub(share->kfile.file, &share->state, pWrite);
if (pWrite & MA_STATE_INFO_WRITE_LOCK)
mysql_mutex_unlock(&share->intern_lock);
/* If open_count != 0 we have to write the state again at close */
share->changed= share->state.open_count != 0;
return res;
} | O3 | c | ma_state_info_write:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %r15d, %r15d
testb $0x1, 0x722(%rdi)
jne 0x548f0
movl %esi, %r14d
movq %rdi, %rbx
testb $0x4, %r14b
je 0x5487e
leaq 0x8f0(%rbx), %rdi
cmpq $0x0, 0x930(%rbx)
jne 0x548fe
callq 0x29210
cmpb $0x0, 0x44c(%rbx)
je 0x548ad
leaq 0x3a76c2(%rip), %rax # 0x3fbf50
cmpl $0x1, (%rax)
jne 0x548ad
leaq 0x3a7680(%rip), %rax # 0x3fbf1a
cmpb $0x0, (%rax)
jne 0x548ad
xorl %eax, %eax
callq 0x4720c
movq %rax, 0x180(%rbx)
movl 0x760(%rbx), %edi
movq %rbx, %rsi
movl %r14d, %edx
callq 0x54926
movl %eax, %r15d
testb $0x4, %r14b
je 0x548e2
leaq 0x8f0(%rbx), %r14
movq 0x930(%rbx), %rdi
testq %rdi, %rdi
jne 0x54914
movq %r14, %rdi
callq 0x291e0
cmpl $0x0, 0x16c(%rbx)
setne 0x7de(%rbx)
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x84ffc(%rip), %rsi # 0xd9901
movl $0x5e3, %edx # imm = 0x5E3
callq 0x2eb6f
jmp 0x5487e
leaq 0x3306f5(%rip), %rax # 0x385010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x548da
| _ma_state_info_write:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
xor r15d, r15d
test byte ptr [rdi+722h], 1
jnz loc_548F0
mov r14d, esi
mov rbx, rdi
test r14b, 4
jz short loc_5487E
lea rdi, [rbx+8F0h]
cmp qword ptr [rbx+930h], 0
jnz loc_548FE
call _pthread_mutex_lock
loc_5487E:
cmp byte ptr [rbx+44Ch], 0
jz short loc_548AD
lea rax, translog_status
cmp dword ptr [rax], 1
jnz short loc_548AD
lea rax, maria_in_recovery
cmp byte ptr [rax], 0
jnz short loc_548AD
xor eax, eax
call translog_get_horizon
mov [rbx+180h], rax
loc_548AD:
mov edi, [rbx+760h]
mov rsi, rbx
mov edx, r14d
call _ma_state_info_write_sub
mov r15d, eax
test r14b, 4
jz short loc_548E2
lea r14, [rbx+8F0h]
mov rdi, [rbx+930h]
test rdi, rdi
jnz short loc_54914
loc_548DA:
mov rdi, r14
call _pthread_mutex_unlock
loc_548E2:
cmp dword ptr [rbx+16Ch], 0
setnz byte ptr [rbx+7DEh]
loc_548F0:
mov eax, r15d
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_548FE:
lea rsi, aWorkspaceLlm4b_9; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 5E3h
call psi_mutex_lock
jmp loc_5487E
loc_54914:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_548DA
| long long ma_state_info_write(long long a1, unsigned int a2)
{
unsigned int v2; // r15d
long long v4; // rdi
long long v5; // rdi
v2 = 0;
if ( (*(_BYTE *)(a1 + 1826) & 1) == 0 )
{
if ( (a2 & 4) != 0 )
{
v4 = a1 + 2288;
if ( *(_QWORD *)(a1 + 2352) )
psi_mutex_lock(v4, (long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_open.c", 0x5E3u);
else
pthread_mutex_lock(v4);
}
if ( *(_BYTE *)(a1 + 1100) && translog_status == 1 && !maria_in_recovery )
*(_QWORD *)(a1 + 384) = translog_get_horizon();
v2 = ma_state_info_write_sub(*(unsigned int *)(a1 + 1888), a1, a2);
if ( (a2 & 4) != 0 )
{
v5 = *(_QWORD *)(a1 + 2352);
if ( v5 )
((void ( *)(long long))PSI_server[44])(v5);
pthread_mutex_unlock(a1 + 2288);
}
*(_BYTE *)(a1 + 2014) = *(_DWORD *)(a1 + 364) != 0;
}
return v2;
}
| _ma_state_info_write:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
XOR R15D,R15D
TEST byte ptr [RDI + 0x722],0x1
JNZ 0x001548f0
MOV R14D,ESI
MOV RBX,RDI
TEST R14B,0x4
JZ 0x0015487e
LEA RDI,[RBX + 0x8f0]
CMP qword ptr [RBX + 0x930],0x0
JNZ 0x001548fe
CALL 0x00129210
LAB_0015487e:
CMP byte ptr [RBX + 0x44c],0x0
JZ 0x001548ad
LEA RAX,[0x4fbf50]
CMP dword ptr [RAX],0x1
JNZ 0x001548ad
LEA RAX,[0x4fbf1a]
CMP byte ptr [RAX],0x0
JNZ 0x001548ad
XOR EAX,EAX
CALL 0x0014720c
MOV qword ptr [RBX + 0x180],RAX
LAB_001548ad:
MOV EDI,dword ptr [RBX + 0x760]
MOV RSI,RBX
MOV EDX,R14D
CALL 0x00154926
MOV R15D,EAX
TEST R14B,0x4
JZ 0x001548e2
LEA R14,[RBX + 0x8f0]
MOV RDI,qword ptr [RBX + 0x930]
TEST RDI,RDI
JNZ 0x00154914
LAB_001548da:
MOV RDI,R14
CALL 0x001291e0
LAB_001548e2:
CMP dword ptr [RBX + 0x16c],0x0
SETNZ byte ptr [RBX + 0x7de]
LAB_001548f0:
MOV EAX,R15D
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_001548fe:
LEA RSI,[0x1d9901]
MOV EDX,0x5e3
CALL 0x0012eb6f
JMP 0x0015487e
LAB_00154914:
LEA RAX,[0x485010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x001548da
|
int4 _ma_state_info_write(long param_1,uint param_2)
{
int4 uVar1;
int8 uVar2;
uVar1 = 0;
if ((*(byte *)(param_1 + 0x722) & 1) == 0) {
if ((param_2 & 4) != 0) {
if (*(long *)(param_1 + 0x930) == 0) {
pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x8f0));
}
else {
psi_mutex_lock((pthread_mutex_t *)(param_1 + 0x8f0),
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_open.c",0x5e3);
}
}
if (((*(char *)(param_1 + 0x44c) != '\0') && (translog_status == 1)) &&
(maria_in_recovery == '\0')) {
uVar2 = translog_get_horizon();
*(int8 *)(param_1 + 0x180) = uVar2;
}
uVar1 = _ma_state_info_write_sub(*(int4 *)(param_1 + 0x760),param_1,param_2);
if ((param_2 & 4) != 0) {
if (*(long *)(param_1 + 0x930) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x8f0));
}
*(bool *)(param_1 + 0x7de) = *(int *)(param_1 + 0x16c) != 0;
}
return uVar1;
}
| |
44,766 | func_uni_big5_onechar | eloqsql/strings/ctype-big5.c | static int func_uni_big5_onechar(int code){
if ((code>=0x00A2)&&(code<=0x00F7))
return(tab_uni_big50[code-0x00A2]);
if ((code>=0x02C7)&&(code<=0x0451))
return(tab_uni_big51[code-0x02C7]);
if ((code>=0x2013)&&(code<=0x22BF))
return(tab_uni_big52[code-0x2013]);
if ((code>=0x2460)&&(code<=0x2642))
return(tab_uni_big53[code-0x2460]);
if ((code>=0x3000)&&(code<=0x3129))
return(tab_uni_big54[code-0x3000]);
if ((code>=0x32A3)&&(code<=0x32A3))
return(tab_uni_big55[code-0x32A3]);
if ((code>=0x338E)&&(code<=0x33D5))
return(tab_uni_big56[code-0x338E]);
if ((code>=0x4E00)&&(code<=0x9483))
return(tab_uni_big57[code-0x4E00]);
if ((code>=0x9577)&&(code<=0x9FA4))
return(tab_uni_big58[code-0x9577]);
if ((code>=0xFA0C)&&(code<=0xFA0D))
return(tab_uni_big59[code-0xFA0C]);
if ((code>=0xFE30)&&(code<=0xFFFD))
return(tab_uni_big510[code-0xFE30]);
return(0);
} | O0 | c | func_uni_big5_onechar:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0xa2, -0x8(%rbp)
jl 0x6a3f7
cmpl $0xf7, -0x8(%rbp)
jg 0x6a3f7
movl -0x8(%rbp), %eax
subl $0xa2, %eax
movslq %eax, %rcx
leaq 0x561f5(%rip), %rax # 0xc05e0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x6a5d5
cmpl $0x2c7, -0x8(%rbp) # imm = 0x2C7
jl 0x6a427
cmpl $0x451, -0x8(%rbp) # imm = 0x451
jg 0x6a427
movl -0x8(%rbp), %eax
subl $0x2c7, %eax # imm = 0x2C7
movslq %eax, %rcx
leaq 0x56275(%rip), %rax # 0xc0690
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x6a5d5
cmpl $0x2013, -0x8(%rbp) # imm = 0x2013
jl 0x6a457
cmpl $0x22bf, -0x8(%rbp) # imm = 0x22BF
jg 0x6a457
movl -0x8(%rbp), %eax
subl $0x2013, %eax # imm = 0x2013
movslq %eax, %rcx
leaq 0x56565(%rip), %rax # 0xc09b0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x6a5d5
cmpl $0x2460, -0x8(%rbp) # imm = 0x2460
jl 0x6a487
cmpl $0x2642, -0x8(%rbp) # imm = 0x2642
jg 0x6a487
movl -0x8(%rbp), %eax
subl $0x2460, %eax # imm = 0x2460
movslq %eax, %rcx
leaq 0x56a95(%rip), %rax # 0xc0f10
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x6a5d5
cmpl $0x3000, -0x8(%rbp) # imm = 0x3000
jl 0x6a4b7
cmpl $0x3129, -0x8(%rbp) # imm = 0x3129
jg 0x6a4b7
movl -0x8(%rbp), %eax
subl $0x3000, %eax # imm = 0x3000
movslq %eax, %rcx
leaq 0x56e35(%rip), %rax # 0xc12e0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x6a5d5
cmpl $0x32a3, -0x8(%rbp) # imm = 0x32A3
jl 0x6a4e7
cmpl $0x32a3, -0x8(%rbp) # imm = 0x32A3
jg 0x6a4e7
movl -0x8(%rbp), %eax
subl $0x32a3, %eax # imm = 0x32A3
movslq %eax, %rcx
leaq 0x57059(%rip), %rax # 0xc1534
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x6a5d5
cmpl $0x338e, -0x8(%rbp) # imm = 0x338E
jl 0x6a517
cmpl $0x33d5, -0x8(%rbp) # imm = 0x33D5
jg 0x6a517
movl -0x8(%rbp), %eax
subl $0x338e, %eax # imm = 0x338E
movslq %eax, %rcx
leaq 0x57035(%rip), %rax # 0xc1540
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x6a5d5
cmpl $0x4e00, -0x8(%rbp) # imm = 0x4E00
jl 0x6a547
cmpl $0x9483, -0x8(%rbp) # imm = 0x9483
jg 0x6a547
movl -0x8(%rbp), %eax
subl $0x4e00, %eax # imm = 0x4E00
movslq %eax, %rcx
leaq 0x57095(%rip), %rax # 0xc15d0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x6a5d5
cmpl $0x9577, -0x8(%rbp) # imm = 0x9577
jl 0x6a574
cmpl $0x9fa4, -0x8(%rbp) # imm = 0x9FA4
jg 0x6a574
movl -0x8(%rbp), %eax
subl $0x9577, %eax # imm = 0x9577
movslq %eax, %rcx
leaq 0x5fd75(%rip), %rax # 0xca2e0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x6a5d5
cmpl $0xfa0c, -0x8(%rbp) # imm = 0xFA0C
jl 0x6a5a1
cmpl $0xfa0d, -0x8(%rbp) # imm = 0xFA0D
jg 0x6a5a1
movl -0x8(%rbp), %eax
subl $0xfa0c, %eax # imm = 0xFA0C
movslq %eax, %rcx
leaq 0x611a4(%rip), %rax # 0xcb73c
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x6a5d5
cmpl $0xfe30, -0x8(%rbp) # imm = 0xFE30
jl 0x6a5ce
cmpl $0xfffd, -0x8(%rbp) # imm = 0xFFFD
jg 0x6a5ce
movl -0x8(%rbp), %eax
subl $0xfe30, %eax # imm = 0xFE30
movslq %eax, %rcx
leaq 0x6117b(%rip), %rax # 0xcb740
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x6a5d5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
| func_uni_big5_onechar:
push rbp
mov rbp, rsp
mov [rbp+var_8], edi
cmp [rbp+var_8], 0A2h
jl short loc_6A3F7
cmp [rbp+var_8], 0F7h
jg short loc_6A3F7
mov eax, [rbp+var_8]
sub eax, 0A2h
movsxd rcx, eax
lea rax, tab_uni_big50
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_6A5D5
loc_6A3F7:
cmp [rbp+var_8], 2C7h
jl short loc_6A427
cmp [rbp+var_8], 451h
jg short loc_6A427
mov eax, [rbp+var_8]
sub eax, 2C7h
movsxd rcx, eax
lea rax, tab_uni_big51
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_6A5D5
loc_6A427:
cmp [rbp+var_8], 2013h
jl short loc_6A457
cmp [rbp+var_8], 22BFh
jg short loc_6A457
mov eax, [rbp+var_8]
sub eax, 2013h
movsxd rcx, eax
lea rax, tab_uni_big52
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_6A5D5
loc_6A457:
cmp [rbp+var_8], 2460h
jl short loc_6A487
cmp [rbp+var_8], 2642h
jg short loc_6A487
mov eax, [rbp+var_8]
sub eax, 2460h
movsxd rcx, eax
lea rax, tab_uni_big53
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_6A5D5
loc_6A487:
cmp [rbp+var_8], 3000h
jl short loc_6A4B7
cmp [rbp+var_8], 3129h
jg short loc_6A4B7
mov eax, [rbp+var_8]
sub eax, 3000h
movsxd rcx, eax
lea rax, tab_uni_big54
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_6A5D5
loc_6A4B7:
cmp [rbp+var_8], 32A3h
jl short loc_6A4E7
cmp [rbp+var_8], 32A3h
jg short loc_6A4E7
mov eax, [rbp+var_8]
sub eax, 32A3h
movsxd rcx, eax
lea rax, tab_uni_big55
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_6A5D5
loc_6A4E7:
cmp [rbp+var_8], 338Eh
jl short loc_6A517
cmp [rbp+var_8], 33D5h
jg short loc_6A517
mov eax, [rbp+var_8]
sub eax, 338Eh
movsxd rcx, eax
lea rax, tab_uni_big56
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_6A5D5
loc_6A517:
cmp [rbp+var_8], 4E00h
jl short loc_6A547
cmp [rbp+var_8], 9483h
jg short loc_6A547
mov eax, [rbp+var_8]
sub eax, 4E00h
movsxd rcx, eax
lea rax, tab_uni_big57
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_6A5D5
loc_6A547:
cmp [rbp+var_8], 9577h
jl short loc_6A574
cmp [rbp+var_8], 9FA4h
jg short loc_6A574
mov eax, [rbp+var_8]
sub eax, 9577h
movsxd rcx, eax
lea rax, tab_uni_big58
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_6A5D5
loc_6A574:
cmp [rbp+var_8], 0FA0Ch
jl short loc_6A5A1
cmp [rbp+var_8], 0FA0Dh
jg short loc_6A5A1
mov eax, [rbp+var_8]
sub eax, 0FA0Ch
movsxd rcx, eax
lea rax, tab_uni_big59
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_6A5D5
loc_6A5A1:
cmp [rbp+var_8], 0FE30h
jl short loc_6A5CE
cmp [rbp+var_8], 0FFFDh
jg short loc_6A5CE
mov eax, [rbp+var_8]
sub eax, 0FE30h
movsxd rcx, eax
lea rax, tab_uni_big510
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_6A5D5
loc_6A5CE:
mov [rbp+var_4], 0
loc_6A5D5:
mov eax, [rbp+var_4]
pop rbp
retn
| long long func_uni_big5_onechar(int a1)
{
if ( a1 < 162 || a1 > 247 )
{
if ( a1 < 711 || a1 > 1105 )
{
if ( a1 < 8211 || a1 > 8895 )
{
if ( a1 < 9312 || a1 > 9794 )
{
if ( a1 < 12288 || a1 > 12585 )
{
if ( a1 == 12963 )
{
return tab_uni_big55;
}
else if ( a1 < 13198 || a1 > 13269 )
{
if ( a1 < 19968 || a1 > 38019 )
{
if ( a1 < 38263 || a1 > 40868 )
{
if ( a1 < 64012 || a1 > 64013 )
{
if ( a1 < 65072 || a1 > 65533 )
return 0;
else
return tab_uni_big510[a1 - 65072];
}
else
{
return tab_uni_big59[a1 - 64012];
}
}
else
{
return tab_uni_big58[a1 - 38263];
}
}
else
{
return tab_uni_big57[a1 - 19968];
}
}
else
{
return tab_uni_big56[a1 - 13198];
}
}
else
{
return tab_uni_big54[a1 - 12288];
}
}
else
{
return tab_uni_big53[a1 - 9312];
}
}
else
{
return tab_uni_big52[a1 - 8211];
}
}
else
{
return tab_uni_big51[a1 - 711];
}
}
else
{
return tab_uni_big50[a1 - 162];
}
}
| func_uni_big5_onechar:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x8],EDI
CMP dword ptr [RBP + -0x8],0xa2
JL 0x0016a3f7
CMP dword ptr [RBP + -0x8],0xf7
JG 0x0016a3f7
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0xa2
MOVSXD RCX,EAX
LEA RAX,[0x1c05e0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0016a5d5
LAB_0016a3f7:
CMP dword ptr [RBP + -0x8],0x2c7
JL 0x0016a427
CMP dword ptr [RBP + -0x8],0x451
JG 0x0016a427
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2c7
MOVSXD RCX,EAX
LEA RAX,[0x1c0690]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0016a5d5
LAB_0016a427:
CMP dword ptr [RBP + -0x8],0x2013
JL 0x0016a457
CMP dword ptr [RBP + -0x8],0x22bf
JG 0x0016a457
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2013
MOVSXD RCX,EAX
LEA RAX,[0x1c09b0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0016a5d5
LAB_0016a457:
CMP dword ptr [RBP + -0x8],0x2460
JL 0x0016a487
CMP dword ptr [RBP + -0x8],0x2642
JG 0x0016a487
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2460
MOVSXD RCX,EAX
LEA RAX,[0x1c0f10]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0016a5d5
LAB_0016a487:
CMP dword ptr [RBP + -0x8],0x3000
JL 0x0016a4b7
CMP dword ptr [RBP + -0x8],0x3129
JG 0x0016a4b7
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x3000
MOVSXD RCX,EAX
LEA RAX,[0x1c12e0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0016a5d5
LAB_0016a4b7:
CMP dword ptr [RBP + -0x8],0x32a3
JL 0x0016a4e7
CMP dword ptr [RBP + -0x8],0x32a3
JG 0x0016a4e7
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x32a3
MOVSXD RCX,EAX
LEA RAX,[0x1c1534]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0016a5d5
LAB_0016a4e7:
CMP dword ptr [RBP + -0x8],0x338e
JL 0x0016a517
CMP dword ptr [RBP + -0x8],0x33d5
JG 0x0016a517
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x338e
MOVSXD RCX,EAX
LEA RAX,[0x1c1540]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0016a5d5
LAB_0016a517:
CMP dword ptr [RBP + -0x8],0x4e00
JL 0x0016a547
CMP dword ptr [RBP + -0x8],0x9483
JG 0x0016a547
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x4e00
MOVSXD RCX,EAX
LEA RAX,[0x1c15d0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0016a5d5
LAB_0016a547:
CMP dword ptr [RBP + -0x8],0x9577
JL 0x0016a574
CMP dword ptr [RBP + -0x8],0x9fa4
JG 0x0016a574
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x9577
MOVSXD RCX,EAX
LEA RAX,[0x1ca2e0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0016a5d5
LAB_0016a574:
CMP dword ptr [RBP + -0x8],0xfa0c
JL 0x0016a5a1
CMP dword ptr [RBP + -0x8],0xfa0d
JG 0x0016a5a1
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0xfa0c
MOVSXD RCX,EAX
LEA RAX,[0x1cb73c]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0016a5d5
LAB_0016a5a1:
CMP dword ptr [RBP + -0x8],0xfe30
JL 0x0016a5ce
CMP dword ptr [RBP + -0x8],0xfffd
JG 0x0016a5ce
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0xfe30
MOVSXD RCX,EAX
LEA RAX,[0x1cb740]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0016a5d5
LAB_0016a5ce:
MOV dword ptr [RBP + -0x4],0x0
LAB_0016a5d5:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int2 func_uni_big5_onechar(int param_1)
{
int2 uVar1;
if ((param_1 < 0xa2) || (0xf7 < param_1)) {
if ((param_1 < 0x2c7) || (0x451 < param_1)) {
if ((param_1 < 0x2013) || (0x22bf < param_1)) {
if ((param_1 < 0x2460) || (0x2642 < param_1)) {
if ((param_1 < 0x3000) || (0x3129 < param_1)) {
if ((param_1 < 0x32a3) || (0x32a3 < param_1)) {
if ((param_1 < 0x338e) || (0x33d5 < param_1)) {
if ((param_1 < 0x4e00) || (0x9483 < param_1)) {
if ((param_1 < 0x9577) || (0x9fa4 < param_1)) {
if ((param_1 < 0xfa0c) || (0xfa0d < param_1)) {
if ((param_1 < 0xfe30) || (0xfffd < param_1)) {
uVar1 = 0;
}
else {
uVar1 = *(int2 *)(tab_uni_big510 + (long)(param_1 + -0xfe30) * 2);
}
}
else {
uVar1 = *(int2 *)((long)&tab_uni_big59 + (long)(param_1 + -0xfa0c) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_big58 + (long)(param_1 + -0x9577) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_big57 + (long)(param_1 + -0x4e00) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_big56 + (long)(param_1 + -0x338e) * 2);
}
}
else {
uVar1 = (&tab_uni_big55)[param_1 + -0x32a3];
}
}
else {
uVar1 = *(int2 *)(tab_uni_big54 + (long)(param_1 + -0x3000) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_big53 + (long)(param_1 + -0x2460) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_big52 + (long)(param_1 + -0x2013) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_big51 + (long)(param_1 + -0x2c7) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_big50 + (long)(param_1 + -0xa2) * 2);
}
return uVar1;
}
| |
44,767 | usage() | eloqsql/client/mysqladmin.cc | static void usage(void)
{
print_version();
puts(ORACLE_WELCOME_COPYRIGHT_NOTICE("2000"));
puts("Administration program for the mysqld daemon.");
printf("Usage: %s [OPTIONS] command command....\n", my_progname);
print_defaults("my",load_default_groups);
puts("");
my_print_help(my_long_options);
my_print_variables(my_long_options);
puts("\nWhere command is a one or more of: (Commands may be shortened)\n\
create databasename Create a new database\n\
debug Instruct server to write debug information to log\n\
drop databasename Delete a database and all its tables\n\
extended-status Gives an extended status message from the server\n\
flush-all-statistics Flush all statistics tables\n\
flush-all-status Flush status and statistics\n\
flush-client-statistics Flush client statistics\n\
flush-hosts Flush all cached hosts\n\
flush-index-statistics Flush index statistics\n\
flush-logs Flush all logs\n\
flush-privileges Reload grant tables (same as reload)\n\
flush-binary-log Flush binary log\n\
flush-engine-log Flush engine log(s)\n\
flush-error-log Flush error log\n\
flush-general-log Flush general log\n\
flush-relay-log Flush relay log\n\
flush-slow-log Flush slow query log\n\
flush-ssl Flush SSL certificates\n\
flush-status Clear status variables\n\
flush-table-statistics Clear table statistics\n\
flush-tables Flush all tables\n\
flush-threads Flush the thread cache\n\
flush-user-statistics Flush user statistics\n\
flush-user-resources Flush user resources\n\
kill id,id,... Kill mysql threads");
#if MYSQL_VERSION_ID >= 32200
puts("\
password [new-password] Change old password to new-password in current format\n\
old-password [new-password] Change old password to new-password in old format");
#endif
puts("\
ping Check if mysqld is alive\n\
processlist Show list of active threads in server\n\
reload Reload grant tables\n\
refresh Flush all tables and close and open logfiles\n\
shutdown Take server down\n\
status Gives a short status message from the server\n\
start-slave Start slave\n\
stop-slave Stop slave\n\
variables Prints variables available\n\
version Get version info from server");
} | O0 | cpp | usage():
pushq %rbp
movq %rsp, %rbp
callq 0x37050
leaq 0x94de4(%rip), %rdi # 0xcbe84
callq 0x369d0
leaq 0x956c7(%rip), %rdi # 0xcc773
callq 0x369d0
leaq 0x40e738(%rip), %rax # 0x4457f0
movq (%rax), %rsi
leaq 0x956df(%rip), %rdi # 0xcc7a1
movb $0x0, %al
callq 0x36070
leaq 0x93fd9(%rip), %rdi # 0xcb0a9
leaq 0x1faf49(%rip), %rsi # 0x232020
callq 0x73540
leaq 0x94e44(%rip), %rdi # 0xcbf27
callq 0x369d0
leaq 0x1faf61(%rip), %rdi # 0x232050
callq 0x7ba20
leaq 0x1faf55(%rip), %rdi # 0x232050
callq 0x7c0d0
leaq 0x956c3(%rip), %rdi # 0xcc7ca
callq 0x369d0
leaq 0x95bcb(%rip), %rdi # 0xcccde
callq 0x369d0
leaq 0x95c5f(%rip), %rdi # 0xccd7e
callq 0x369d0
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZL5usagev:
push rbp
mov rbp, rsp
call _ZL13print_versionv; print_version(void)
lea rdi, aCopyrightC2000; "Copyright (c) 2000, 2018, Oracle, Maria"...
call _puts
lea rdi, aAdministration; "Administration program for the mysqld d"...
call _puts
lea rax, my_progname
mov rsi, [rax]
lea rdi, aUsageSOptionsC; "Usage: %s [OPTIONS] command command...."...
mov al, 0
call _printf
lea rdi, aMy; "my"
lea rsi, _ZL19load_default_groups; load_default_groups
call print_defaults
lea rdi, aS+5; ""
call _puts
lea rdi, _ZL15my_long_options; my_long_options
call my_print_help
lea rdi, _ZL15my_long_options; my_long_options
call my_print_variables
lea rdi, aWhereCommandIs; "\nWhere command is a one or more of: (C"...
call _puts
lea rdi, aPasswordNewPas; " password [new-password] Change old pa"...
call _puts
lea rdi, aPingCheckIfMys; " ping\t\t\tCheck if mysqld is alive\n "...
call _puts
pop rbp
retn
| long long usage(void)
{
print_version();
puts("Copyright (c) 2000, 2018, Oracle, MariaDB Corporation Ab and others.\n");
puts("Administration program for the mysqld daemon.");
printf("Usage: %s [OPTIONS] command command....\n", my_progname);
print_defaults("my", load_default_groups);
puts("");
my_print_help(&my_long_options);
my_print_variables(&my_long_options);
puts(
"\n"
"Where command is a one or more of: (Commands may be shortened)\n"
" create databasename\t Create a new database\n"
" debug\t\t\t Instruct server to write debug information to log\n"
" drop databasename\t Delete a database and all its tables\n"
" extended-status Gives an extended status message from the server\n"
" flush-all-statistics Flush all statistics tables\n"
" flush-all-status Flush status and statistics\n"
" flush-client-statistics Flush client statistics\n"
" flush-hosts Flush all cached hosts\n"
" flush-index-statistics Flush index statistics\n"
" flush-logs Flush all logs\n"
" flush-privileges Reload grant tables (same as reload)\n"
" flush-binary-log Flush binary log\n"
" flush-engine-log Flush engine log(s)\n"
" flush-error-log Flush error log\n"
" flush-general-log Flush general log\n"
" flush-relay-log Flush relay log\n"
" flush-slow-log Flush slow query log\n"
" flush-ssl Flush SSL certificates\n"
" flush-status Clear status variables\n"
" flush-table-statistics Clear table statistics\n"
" flush-tables Flush all tables\n"
" flush-threads Flush the thread cache\n"
" flush-user-statistics Flush user statistics\n"
" flush-user-resources Flush user resources\n"
" kill id,id,...\tKill mysql threads");
puts(
" password [new-password] Change old password to new-password in current format\n"
" old-password [new-password] Change old password to new-password in old format");
return puts(
" ping\t\t\tCheck if mysqld is alive\n"
" processlist\t\tShow list of active threads in server\n"
" reload\t\tReload grant tables\n"
" refresh\t\tFlush all tables and close and open logfiles\n"
" shutdown\t\tTake server down\n"
" status\t\tGives a short status message from the server\n"
" start-slave\t\tStart slave\n"
" stop-slave\t\tStop slave\n"
" variables Prints variables available\n"
" version\t\tGet version info from server");
}
| usage:
PUSH RBP
MOV RBP,RSP
CALL 0x00137050
LEA RDI,[0x1cbe84]
CALL 0x001369d0
LEA RDI,[0x1cc773]
CALL 0x001369d0
LEA RAX,[0x5457f0]
MOV RSI,qword ptr [RAX]
LEA RDI,[0x1cc7a1]
MOV AL,0x0
CALL 0x00136070
LEA RDI,[0x1cb0a9]
LEA RSI,[0x332020]
CALL 0x00173540
LEA RDI,[0x1cbf27]
CALL 0x001369d0
LEA RDI,[0x332050]
CALL 0x0017ba20
LEA RDI,[0x332050]
CALL 0x0017c0d0
LEA RDI,[0x1cc7ca]
CALL 0x001369d0
LEA RDI,[0x1cccde]
CALL 0x001369d0
LEA RDI,[0x1ccd7e]
CALL 0x001369d0
POP RBP
RET
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* usage() */
void usage(void)
{
print_version();
puts("Copyright (c) 2000, 2018, Oracle, MariaDB Corporation Ab and others.\n");
puts("Administration program for the mysqld daemon.");
printf("Usage: %s [OPTIONS] command command....\n",my_progname);
print_defaults(&DAT_001cb0a9,load_default_groups);
puts(&DAT_001cbf27);
my_print_help(my_long_options);
my_print_variables(my_long_options);
puts(
"\nWhere command is a one or more of: (Commands may be shortened)\n create databasename\t Create a new database\n debug\t\t\t Instruct server to write debug information to log\n drop databasename\t Delete a database and all its tables\n extended-status Gives an extended status message from the server\n flush-all-statistics Flush all statistics tables\n flush-all-status Flush status and statistics\n flush-client-statistics Flush client statistics\n flush-hosts Flush all cached hosts\n flush-index-statistics Flush index statistics\n flush-logs Flush all logs\n flush-privileges Reload grant tables (same as reload)\n flush-binary-log Flush binary log\n flush-engine-log Flush engine log(s)\n flush-error-log Flush error log\n flush-general-log Flush general log\n flush-relay-log Flush relay log\n flush-slow-log Flush slow query log\n flush-ssl Flush SSL certificates\n flush-status Clear status variables\n flush-table-statistics Clear table statistics\n flush-tables Flush all tables\n flush-threads Flush the thread cache\n flush-user-statistics Flush user statistics\n flush-user-resources Flush user resources\n kill id,id,...\tKill mysql threads"
);
puts(
" password [new-password] Change old password to new-password in current format\n old-password [new-password] Change old password to new-password in old format"
);
puts(
" ping\t\t\tCheck if mysqld is alive\n processlist\t\tShow list of active threads in server\n reload\t\tReload grant tables\n refresh\t\tFlush all tables and close and open logfiles\n shutdown\t\tTake server down\n status\t\tGives a short status message from the server\n start-slave\t\tStart slave\n stop-slave\t\tStop slave\n variables Prints variables available\n version\t\tGet version info from server"
);
return;
}
| |
44,768 | my_readlink | eloqsql/mysys/my_symlink.c | int my_readlink(char *to, const char *filename, myf MyFlags)
{
#ifndef HAVE_READLINK
strmov(to,filename);
return 1;
#else
int result=0;
int length;
DBUG_ENTER("my_readlink");
if ((length=readlink(filename, to, FN_REFLEN-1)) < 0)
{
/* Don't give an error if this wasn't a symlink */
if ((my_errno=errno) == EINVAL)
{
result= 1;
strmov(to,filename);
}
else
{
if (MyFlags & MY_WME)
my_error(EE_CANT_READLINK, MYF(0), filename, errno);
result= -1;
}
}
else
to[length]=0;
DBUG_PRINT("exit" ,("result: %d", result));
DBUG_RETURN(result);
#endif /* HAVE_READLINK */
} | O3 | c | my_readlink:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1ff, %edx # imm = 0x1FF
movq %rsi, %rdi
movq %r14, %rsi
callq 0x24330
testl %eax, %eax
js 0x2fc42
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
movb $0x0, (%r14,%rax)
xorl %r14d, %r14d
jmp 0x2fc8f
callq 0x24050
movq %rax, %r12
movl (%rax), %r13d
callq 0x28ca6
movl %r13d, (%rax)
cmpl $0x16, %r13d
jne 0x2fc6e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x24290
movl $0x1, %r14d
jmp 0x2fc8f
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
testb $0x10, %r15b
je 0x2fc8f
movl (%r12), %ecx
movl $0x18, %edi
xorl %esi, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2e7bf
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_readlink:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15, rdx
mov rbx, rsi
mov r14, rdi
mov edx, 1FFh
mov rdi, rsi
mov rsi, r14
call _readlink
test eax, eax
js short loc_2FC42
and eax, 7FFFFFFFh
mov byte ptr [r14+rax], 0
xor r14d, r14d
jmp short loc_2FC8F
loc_2FC42:
call ___errno_location
mov r12, rax
mov r13d, [rax]
call _my_thread_var
mov [rax], r13d
cmp r13d, 16h
jnz short loc_2FC6E
mov rdi, r14
mov rsi, rbx
call _strcpy
mov r14d, 1
jmp short loc_2FC8F
loc_2FC6E:
mov r14d, 0FFFFFFFFh
test r15b, 10h
jz short loc_2FC8F
mov ecx, [r12]
mov edi, 18h
xor esi, esi
mov rdx, rbx
xor eax, eax
call my_error
loc_2FC8F:
mov eax, r14d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_readlink(long long a1, long long a2, char a3)
{
int v4; // eax
unsigned int v5; // r14d
unsigned int *v6; // r12
unsigned int v7; // r13d
v4 = readlink(a2, a1, 511LL);
if ( v4 < 0 )
{
v6 = (unsigned int *)__errno_location(a2);
v7 = *v6;
*(_DWORD *)my_thread_var() = v7;
if ( v7 == 22 )
{
strcpy(a1, a2);
return 1;
}
else
{
v5 = -1;
if ( (a3 & 0x10) != 0 )
my_error(0x18u, 0, a2, *v6);
}
}
else
{
*(_BYTE *)(a1 + (v4 & 0x7FFFFFFF)) = 0;
return 0;
}
return v5;
}
| my_readlink:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RDX
MOV RBX,RSI
MOV R14,RDI
MOV EDX,0x1ff
MOV RDI,RSI
MOV RSI,R14
CALL 0x00124330
TEST EAX,EAX
JS 0x0012fc42
AND EAX,0x7fffffff
MOV byte ptr [R14 + RAX*0x1],0x0
XOR R14D,R14D
JMP 0x0012fc8f
LAB_0012fc42:
CALL 0x00124050
MOV R12,RAX
MOV R13D,dword ptr [RAX]
CALL 0x00128ca6
MOV dword ptr [RAX],R13D
CMP R13D,0x16
JNZ 0x0012fc6e
MOV RDI,R14
MOV RSI,RBX
CALL 0x00124290
MOV R14D,0x1
JMP 0x0012fc8f
LAB_0012fc6e:
MOV R14D,0xffffffff
TEST R15B,0x10
JZ 0x0012fc8f
MOV ECX,dword ptr [R12]
MOV EDI,0x18
XOR ESI,ESI
MOV RDX,RBX
XOR EAX,EAX
CALL 0x0012e7bf
LAB_0012fc8f:
MOV EAX,R14D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 my_readlink(char *param_1,char *param_2,ulong param_3)
{
int iVar1;
ssize_t sVar2;
int *piVar3;
int *piVar4;
int8 uVar5;
sVar2 = readlink(param_2,param_1,0x1ff);
if ((int)(uint)sVar2 < 0) {
piVar3 = __errno_location();
iVar1 = *piVar3;
piVar4 = (int *)_my_thread_var();
*piVar4 = iVar1;
if (iVar1 == 0x16) {
strcpy(param_1,param_2);
uVar5 = 1;
}
else {
uVar5 = 0xffffffff;
if ((param_3 & 0x10) != 0) {
my_error(0x18,0,param_2,*piVar3);
}
}
}
else {
param_1[(uint)sVar2 & 0x7fffffff] = '\0';
uVar5 = 0;
}
return uVar5;
}
| |
44,769 | mysql_local_infile_init | eloqsql/libmariadb/libmariadb/ma_loaddata.c | static
int mysql_local_infile_init(void **ptr, const char *filename, void *userdata)
{
MYSQL_INFILE_INFO *info;
MYSQL *mysql= (MYSQL *)userdata;
info = (MYSQL_INFILE_INFO *)malloc(sizeof(MYSQL_INFILE_INFO));
if (!info) {
return(1);
}
memset(info, 0, sizeof(MYSQL_INFILE_INFO));
*ptr = info;
info->filename = filename;
info->fp= ma_open(filename, "rb", mysql);
if (!info->fp)
{
/* error handling is done via mysql_local_infile_error function, so we
need to copy error to info */
if (mysql_errno(mysql) && !info->error_no)
{
info->error_no= mysql_errno(mysql);
ma_strmake(info->error_msg, mysql_error(mysql), MYSQL_ERRMSG_SIZE);
}
else
{
info->error_no = errno;
snprintf((char *)info->error_msg, sizeof(info->error_msg),
CER(CR_FILE_NOT_FOUND), filename, info->error_no);
}
return(1);
}
return(0);
} | O3 | c | mysql_local_infile_init:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r13
movl $0x1, %edi
movl $0x218, %esi # imm = 0x218
callq 0x378f0
movl $0x1, %r12d
testq %rax, %rax
je 0x51835
movq %rax, %rbx
movq %rax, (%r13)
movq %r14, 0x210(%rax)
leaq 0x532db(%rip), %rsi # 0xa4a7b
movq %r14, %rdi
movq %r15, %rdx
callq 0x5694c
movq %rax, (%rbx)
xorl %r12d, %r12d
testq %rax, %rax
jne 0x51835
movq %r15, %rdi
callq 0x4b375
testl %eax, %eax
je 0x517c8
cmpl $0x0, 0x8(%rbx)
je 0x51808
callq 0x37a20
movl (%rax), %eax
movl %eax, 0x8(%rbx)
addq $0xc, %rbx
leaq 0x2fbfb3(%rip), %rcx # 0x34d790
movq 0x20(%rcx), %r8
movl %eax, (%rsp)
movl $0x1, %r12d
movl $0x201, %esi # imm = 0x201
movl $0x201, %ecx # imm = 0x201
movq %rbx, %rdi
movl $0x1, %edx
movq %r14, %r9
xorl %eax, %eax
callq 0x37c60
jmp 0x51835
movq %r15, %rdi
callq 0x4b375
movl %eax, 0x8(%rbx)
addq $0xc, %rbx
movq %r15, %rdi
callq 0x4b38a
movl $0x200, %edx # imm = 0x200
movq %rbx, %rdi
movq %rax, %rsi
callq 0x53ecf
movl $0x1, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| mysql_local_infile_init:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15, rdx
mov r14, rsi
mov r13, rdi
mov edi, 1
mov esi, 218h
call _calloc
mov r12d, 1
test rax, rax
jz loc_51835
mov rbx, rax
mov [r13+0], rax
mov [rax+210h], r14
lea rsi, aRb; "rb"
mov rdi, r14
mov rdx, r15
call ma_open
mov [rbx], rax
xor r12d, r12d
test rax, rax
jnz short loc_51835
mov rdi, r15
call mysql_errno
test eax, eax
jz short loc_517C8
cmp dword ptr [rbx+8], 0
jz short loc_51808
loc_517C8:
call ___errno_location
mov eax, [rax]
mov [rbx+8], eax
add rbx, 0Ch
lea rcx, mariadb_client_errors
mov r8, [rcx+20h]
mov [rsp+30h+var_30], eax
mov r12d, 1
mov esi, 201h
mov ecx, 201h
mov rdi, rbx
mov edx, 1
mov r9, r14
xor eax, eax
call ___snprintf_chk
jmp short loc_51835
loc_51808:
mov rdi, r15
call mysql_errno
mov [rbx+8], eax
add rbx, 0Ch
mov rdi, r15
call mysql_error
mov edx, 200h
mov rdi, rbx
mov rsi, rax
call ma_strmake
mov r12d, 1
loc_51835:
mov eax, r12d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long mysql_local_infile_init(long long *a1, long long a2, long long a3)
{
long long v3; // rax
long long v5; // rax
unsigned int v6; // r12d
long long v7; // rbx
long long v8; // rax
int v9; // eax
char *v10; // rax
long long v12; // [rsp+0h] [rbp-30h]
HIDWORD(v12) = HIDWORD(v3);
v5 = calloc(1LL, 536LL);
v6 = 1;
if ( v5 )
{
v7 = v5;
*a1 = v5;
*(_QWORD *)(v5 + 528) = a2;
v8 = ma_open(a2, "rb", a3);
*(_QWORD *)v7 = v8;
v6 = 0;
if ( !v8 )
{
if ( (unsigned int)mysql_errno(a3) && !*(_DWORD *)(v7 + 8) )
{
*(_DWORD *)(v7 + 8) = mysql_errno(a3);
v10 = mysql_error(a3);
ma_strmake(v7 + 12, v10, 512LL);
return 1;
}
else
{
v9 = *(_DWORD *)__errno_location(a3);
*(_DWORD *)(v7 + 8) = v9;
LODWORD(v12) = v9;
v6 = 1;
__snprintf_chk(v7 + 12, 513LL, 1LL, 513LL, mariadb_client_errors[4], a2, v12);
}
}
}
return v6;
}
| mysql_local_infile_init:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RDX
MOV R14,RSI
MOV R13,RDI
MOV EDI,0x1
MOV ESI,0x218
CALL 0x001378f0
MOV R12D,0x1
TEST RAX,RAX
JZ 0x00151835
MOV RBX,RAX
MOV qword ptr [R13],RAX
MOV qword ptr [RAX + 0x210],R14
LEA RSI,[0x1a4a7b]
MOV RDI,R14
MOV RDX,R15
CALL 0x0015694c
MOV qword ptr [RBX],RAX
XOR R12D,R12D
TEST RAX,RAX
JNZ 0x00151835
MOV RDI,R15
CALL 0x0014b375
TEST EAX,EAX
JZ 0x001517c8
CMP dword ptr [RBX + 0x8],0x0
JZ 0x00151808
LAB_001517c8:
CALL 0x00137a20
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBX + 0x8],EAX
ADD RBX,0xc
LEA RCX,[0x44d790]
MOV R8,qword ptr [RCX + 0x20]
MOV dword ptr [RSP],EAX
MOV R12D,0x1
MOV ESI,0x201
MOV ECX,0x201
MOV RDI,RBX
MOV EDX,0x1
MOV R9,R14
XOR EAX,EAX
CALL 0x00137c60
JMP 0x00151835
LAB_00151808:
MOV RDI,R15
CALL 0x0014b375
MOV dword ptr [RBX + 0x8],EAX
ADD RBX,0xc
MOV RDI,R15
CALL 0x0014b38a
MOV EDX,0x200
MOV RDI,RBX
MOV RSI,RAX
CALL 0x00153ecf
MOV R12D,0x1
LAB_00151835:
MOV EAX,R12D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 mysql_local_infile_init(int8 *param_1,long param_2,int8 param_3)
{
int iVar1;
int4 uVar2;
int8 in_RAX;
long *plVar3;
long lVar4;
int *piVar5;
int8 uVar6;
uVar2 = (int4)((ulong)in_RAX >> 0x20);
plVar3 = (long *)calloc(1,0x218);
uVar6 = 1;
if (plVar3 != (long *)0x0) {
*param_1 = plVar3;
plVar3[0x42] = param_2;
lVar4 = ma_open(param_2,&DAT_001a4a7b,param_3);
*plVar3 = lVar4;
uVar6 = 0;
if (lVar4 == 0) {
iVar1 = mysql_errno(param_3);
if ((iVar1 == 0) || ((int)plVar3[1] != 0)) {
piVar5 = __errno_location();
iVar1 = *piVar5;
*(int *)(plVar3 + 1) = iVar1;
uVar6 = 1;
__snprintf_chk((long)plVar3 + 0xc,0x201,1,0x201,mariadb_client_errors._32_8_,param_2,
CONCAT44(uVar2,iVar1));
}
else {
uVar2 = mysql_errno(param_3);
*(int4 *)(plVar3 + 1) = uVar2;
uVar6 = mysql_error(param_3);
ma_strmake((long)plVar3 + 0xc,uVar6,0x200);
uVar6 = 1;
}
}
}
return uVar6;
}
| |
44,770 | js_std_file_read_write | bluesky950520[P]quickjs/quickjs-libc.c | static JSValue js_std_file_read_write(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv, int magic)
{
FILE *f = js_std_file_get(ctx, this_val);
uint64_t pos, len;
size_t size, ret;
uint8_t *buf;
if (!f)
return JS_EXCEPTION;
if (JS_ToIndex(ctx, &pos, argv[1]))
return JS_EXCEPTION;
if (JS_ToIndex(ctx, &len, argv[2]))
return JS_EXCEPTION;
buf = JS_GetArrayBuffer(ctx, &size, argv[0]);
if (!buf)
return JS_EXCEPTION;
if (pos + len > size)
return JS_ThrowRangeError(ctx, "read/write array buffer overflow");
if (magic)
ret = fwrite(buf + pos, 1, len, f);
else
ret = fread(buf + pos, 1, len, f);
return JS_NewInt64(ctx, ret);
} | O0 | c | js_std_file_read_write:
subq $0xf8, %rsp
movq %rsi, 0x58(%rsp)
movq %rdx, 0x60(%rsp)
movq %rdi, 0x50(%rsp)
movl %ecx, 0x4c(%rsp)
movq %r8, 0x40(%rsp)
movl %r9d, 0x3c(%rsp)
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x60(%rsp), %rdx
callq 0x13a80
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x1328b
movl $0x0, 0x68(%rsp)
movq $0x6, 0x70(%rsp)
jmp 0x13502
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rcx
leaq 0x28(%rsp), %rsi
callq 0x39140
cmpl $0x0, %eax
je 0x132c2
movl $0x0, 0x68(%rsp)
movq $0x6, 0x70(%rsp)
jmp 0x13502
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rax
movq 0x20(%rax), %rdx
movq 0x28(%rax), %rcx
leaq 0x20(%rsp), %rsi
callq 0x39140
cmpl $0x0, %eax
je 0x132f9
movl $0x0, 0x68(%rsp)
movq $0x6, 0x70(%rsp)
jmp 0x13502
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
leaq 0x18(%rsp), %rsi
callq 0x58010
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x13337
movl $0x0, 0x68(%rsp)
movq $0x6, 0x70(%rsp)
jmp 0x13502
movq 0x28(%rsp), %rax
addq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
jbe 0x1336a
movq 0x50(%rsp), %rdi
leaq 0xf694b(%rip), %rsi # 0x109c9f
movb $0x0, %al
callq 0x29670
movq %rax, 0x68(%rsp)
movq %rdx, 0x70(%rsp)
jmp 0x13502
cmpl $0x0, 0x3c(%rsp)
je 0x13396
movq 0x8(%rsp), %rdi
addq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
movq 0x30(%rsp), %rcx
movl $0x1, %esi
callq 0xe8c0
movq %rax, 0x10(%rsp)
jmp 0x133b9
movq 0x8(%rsp), %rdi
addq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
movq 0x30(%rsp), %rcx
movl $0x1, %esi
callq 0xe170
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0xa0(%rsp)
movq %rax, 0x98(%rsp)
cmpq $-0x80000000, 0x98(%rsp) # imm = 0x80000000
jl 0x1346d
cmpq $0x7fffffff, 0x98(%rsp) # imm = 0x7FFFFFFF
jg 0x1346d
movq 0xa0(%rsp), %rcx
movl 0x98(%rsp), %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
movl 0xbc(%rsp), %eax
movl %eax, 0xc8(%rsp)
movq $0x0, 0xd0(%rsp)
movq 0xc8(%rsp), %rcx
movq 0xd0(%rsp), %rax
movq %rcx, 0x88(%rsp)
movq %rax, 0x90(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0xb0(%rsp)
jmp 0x134e8
movq 0xa0(%rsp), %rax
cvtsi2sdq 0x98(%rsp), %xmm0
movq %rax, 0xe0(%rsp)
movsd %xmm0, 0xd8(%rsp)
movsd 0xd8(%rsp), %xmm0
callq 0x14820
movq %rax, 0xe8(%rsp)
movq %rdx, 0xf0(%rsp)
movq 0xe8(%rsp), %rcx
movq 0xf0(%rsp), %rax
movq %rcx, 0x78(%rsp)
movq %rax, 0x80(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0xa8(%rsp), %rcx
movq 0xb0(%rsp), %rax
movq %rcx, 0x68(%rsp)
movq %rax, 0x70(%rsp)
movq 0x68(%rsp), %rax
movq 0x70(%rsp), %rdx
addq $0xf8, %rsp
retq
nopw %cs:(%rax,%rax)
| js_std_file_read_write:
sub rsp, 0F8h
mov [rsp+0F8h+var_A0], rsi
mov [rsp+0F8h+var_98], rdx
mov [rsp+0F8h+var_A8], rdi
mov [rsp+0F8h+var_AC], ecx
mov [rsp+0F8h+var_B8], r8
mov [rsp+0F8h+var_BC], r9d
mov rdi, [rsp+0F8h+var_A8]
mov rsi, [rsp+0F8h+var_A0]
mov rdx, [rsp+0F8h+var_98]
call js_std_file_get
mov [rsp+0F8h+var_C8], rax
cmp [rsp+0F8h+var_C8], 0
jnz short loc_1328B
mov dword ptr [rsp+0F8h+var_90], 0
mov [rsp+0F8h+var_88], 6
jmp loc_13502
loc_1328B:
mov rdi, [rsp+0F8h+var_A8]
mov rax, [rsp+0F8h+var_B8]
mov rdx, [rax+10h]
mov rcx, [rax+18h]
lea rsi, [rsp+0F8h+var_D0]
call JS_ToIndex
cmp eax, 0
jz short loc_132C2
mov dword ptr [rsp+0F8h+var_90], 0
mov [rsp+0F8h+var_88], 6
jmp loc_13502
loc_132C2:
mov rdi, [rsp+0F8h+var_A8]
mov rax, [rsp+0F8h+var_B8]
mov rdx, [rax+20h]
mov rcx, [rax+28h]
lea rsi, [rsp+0F8h+var_D8]
call JS_ToIndex
cmp eax, 0
jz short loc_132F9
mov dword ptr [rsp+0F8h+var_90], 0
mov [rsp+0F8h+var_88], 6
jmp loc_13502
loc_132F9:
mov rdi, [rsp+0F8h+var_A8]
mov rax, [rsp+0F8h+var_B8]
mov rdx, [rax]
mov rcx, [rax+8]
lea rsi, [rsp+0F8h+var_E0]
call JS_GetArrayBuffer
mov [rsp+0F8h+var_F0], rax
cmp [rsp+0F8h+var_F0], 0
jnz short loc_13337
mov dword ptr [rsp+0F8h+var_90], 0
mov [rsp+0F8h+var_88], 6
jmp loc_13502
loc_13337:
mov rax, [rsp+0F8h+var_D0]
add rax, [rsp+0F8h+var_D8]
cmp rax, [rsp+0F8h+var_E0]
jbe short loc_1336A
mov rdi, [rsp+0F8h+var_A8]
lea rsi, aReadWriteArray; "read/write array buffer overflow"
mov al, 0
call JS_ThrowRangeError
mov [rsp+0F8h+var_90], rax
mov [rsp+0F8h+var_88], rdx
jmp loc_13502
loc_1336A:
cmp [rsp+0F8h+var_BC], 0
jz short loc_13396
mov rdi, [rsp+0F8h+var_F0]
add rdi, [rsp+0F8h+var_D0]
mov rdx, [rsp+0F8h+var_D8]
mov rcx, [rsp+0F8h+var_C8]
mov esi, 1
call _fwrite
mov [rsp+0F8h+var_E8], rax
jmp short loc_133B9
loc_13396:
mov rdi, [rsp+0F8h+var_F0]
add rdi, [rsp+0F8h+var_D0]
mov rdx, [rsp+0F8h+var_D8]
mov rcx, [rsp+0F8h+var_C8]
mov esi, 1
call _fread
mov [rsp+0F8h+var_E8], rax
loc_133B9:
mov rcx, [rsp+0F8h+var_A8]
mov rax, [rsp+0F8h+var_E8]
mov [rsp+0F8h+var_58], rcx
mov [rsp+0F8h+var_60], rax
cmp [rsp+0F8h+var_60], 0FFFFFFFF80000000h
jl loc_1346D
cmp [rsp+0F8h+var_60], 7FFFFFFFh
jg short loc_1346D
mov rcx, [rsp+0F8h+var_58]
mov eax, dword ptr [rsp+0F8h+var_60]
mov [rsp+0F8h+var_38], rcx
mov [rsp+0F8h+var_3C], eax
mov eax, [rsp+0F8h+var_3C]
mov dword ptr [rsp+0F8h+var_30], eax
mov [rsp+0F8h+var_28], 0
mov rcx, [rsp+0F8h+var_30]
mov rax, [rsp+0F8h+var_28]
mov [rsp+0F8h+var_70], rcx
mov [rsp+0F8h+var_68], rax
mov rax, [rsp+0F8h+var_70]
mov [rsp+0F8h+var_50], rax
mov rax, [rsp+0F8h+var_68]
mov [rsp+0F8h+var_48], rax
jmp short loc_134E8
loc_1346D:
mov rax, [rsp+0F8h+var_58]
cvtsi2sd xmm0, [rsp+0F8h+var_60]
mov [rsp+0F8h+var_18], rax
movsd [rsp+0F8h+var_20], xmm0
movsd xmm0, [rsp+0F8h+var_20]
call __JS_NewFloat64
mov [rsp+0F8h+var_10], rax
mov [rsp+0F8h+var_8], rdx
mov rcx, [rsp+0F8h+var_10]
mov rax, [rsp+0F8h+var_8]
mov [rsp+0F8h+var_80], rcx
mov [rsp+0F8h+var_78], rax
mov rax, [rsp+0F8h+var_80]
mov [rsp+0F8h+var_50], rax
mov rax, [rsp+0F8h+var_78]
mov [rsp+0F8h+var_48], rax
loc_134E8:
mov rcx, [rsp+0F8h+var_50]
mov rax, [rsp+0F8h+var_48]
mov [rsp+0F8h+var_90], rcx
mov [rsp+0F8h+var_88], rax
loc_13502:
mov rax, [rsp+0F8h+var_90]
mov rdx, [rsp+0F8h+var_88]
add rsp, 0F8h
retn
| long long js_std_file_read_write(long long a1, long long a2, long long a3, int a4, _QWORD *a5, int a6)
{
int v6; // edx
int v7; // ecx
int v8; // r8d
int v9; // r9d
long long v10; // rdx
long long v11; // rdx
long long ArrayBuffer; // [rsp+8h] [rbp-F0h]
signed long long v14; // [rsp+10h] [rbp-E8h]
unsigned long long v15; // [rsp+18h] [rbp-E0h] BYREF
long long v16; // [rsp+20h] [rbp-D8h] BYREF
long long v17; // [rsp+28h] [rbp-D0h] BYREF
long long v18; // [rsp+30h] [rbp-C8h]
int v19; // [rsp+3Ch] [rbp-BCh]
_QWORD *v20; // [rsp+40h] [rbp-B8h]
int v21; // [rsp+4Ch] [rbp-ACh]
long long v22; // [rsp+50h] [rbp-A8h]
long long v23; // [rsp+58h] [rbp-A0h]
long long v24; // [rsp+60h] [rbp-98h]
long long v25; // [rsp+68h] [rbp-90h]
long long v26; // [rsp+70h] [rbp-88h]
long long v27; // [rsp+78h] [rbp-80h]
long long v28; // [rsp+80h] [rbp-78h]
long long v29; // [rsp+88h] [rbp-70h]
long long v30; // [rsp+90h] [rbp-68h]
long long v31; // [rsp+98h] [rbp-60h]
long long v32; // [rsp+A0h] [rbp-58h]
long long v33; // [rsp+A8h] [rbp-50h]
long long v34; // [rsp+B0h] [rbp-48h]
int v35; // [rsp+BCh] [rbp-3Ch]
long long v36; // [rsp+C0h] [rbp-38h]
long long v37; // [rsp+C8h] [rbp-30h]
long long v38; // [rsp+D0h] [rbp-28h]
double v39; // [rsp+D8h] [rbp-20h]
long long v40; // [rsp+E0h] [rbp-18h]
long long v41; // [rsp+E8h] [rbp-10h]
long long v42; // [rsp+F0h] [rbp-8h]
v23 = a2;
v24 = a3;
v22 = a1;
v21 = a4;
v20 = a5;
v19 = a6;
v18 = js_std_file_get(a1, a2, a3);
if ( v18 )
{
if ( (unsigned int)JS_ToIndex(v22, &v17, v20[2], v20[3]) )
{
LODWORD(v25) = 0;
v26 = 6LL;
}
else if ( (unsigned int)JS_ToIndex(v22, &v16, v20[4], v20[5]) )
{
LODWORD(v25) = 0;
v26 = 6LL;
}
else
{
ArrayBuffer = JS_GetArrayBuffer(v22, &v15, *v20, v20[1]);
if ( ArrayBuffer )
{
if ( v16 + v17 <= v15 )
{
if ( v19 )
v14 = fwrite(v17 + ArrayBuffer, 1LL, v16, v18);
else
v14 = fread(v17 + ArrayBuffer, 1LL, v16, v18);
v32 = v22;
v31 = v14;
if ( v14 < (long long)0xFFFFFFFF80000000LL || v31 > 0x7FFFFFFF )
{
v40 = v32;
v39 = (double)(int)v31;
v41 = _JS_NewFloat64((double)(int)v31);
v42 = v11;
v27 = v41;
v28 = v11;
v33 = v41;
v34 = v11;
}
else
{
v36 = v32;
v35 = v31;
LODWORD(v37) = v31;
v38 = 0LL;
v29 = v37;
v30 = 0LL;
v33 = v37;
v34 = 0LL;
}
v25 = v33;
v26 = v34;
}
else
{
v25 = JS_ThrowRangeError(v22, (unsigned int)"read/write array buffer overflow", v6, v7, v8, v9);
v26 = v10;
}
}
else
{
LODWORD(v25) = 0;
v26 = 6LL;
}
}
}
else
{
LODWORD(v25) = 0;
v26 = 6LL;
}
return v25;
}
| js_std_file_read_write:
SUB RSP,0xf8
MOV qword ptr [RSP + 0x58],RSI
MOV qword ptr [RSP + 0x60],RDX
MOV qword ptr [RSP + 0x50],RDI
MOV dword ptr [RSP + 0x4c],ECX
MOV qword ptr [RSP + 0x40],R8
MOV dword ptr [RSP + 0x3c],R9D
MOV RDI,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RSP + 0x58]
MOV RDX,qword ptr [RSP + 0x60]
CALL 0x00113a80
MOV qword ptr [RSP + 0x30],RAX
CMP qword ptr [RSP + 0x30],0x0
JNZ 0x0011328b
MOV dword ptr [RSP + 0x68],0x0
MOV qword ptr [RSP + 0x70],0x6
JMP 0x00113502
LAB_0011328b:
MOV RDI,qword ptr [RSP + 0x50]
MOV RAX,qword ptr [RSP + 0x40]
MOV RDX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RAX + 0x18]
LEA RSI,[RSP + 0x28]
CALL 0x00139140
CMP EAX,0x0
JZ 0x001132c2
MOV dword ptr [RSP + 0x68],0x0
MOV qword ptr [RSP + 0x70],0x6
JMP 0x00113502
LAB_001132c2:
MOV RDI,qword ptr [RSP + 0x50]
MOV RAX,qword ptr [RSP + 0x40]
MOV RDX,qword ptr [RAX + 0x20]
MOV RCX,qword ptr [RAX + 0x28]
LEA RSI,[RSP + 0x20]
CALL 0x00139140
CMP EAX,0x0
JZ 0x001132f9
MOV dword ptr [RSP + 0x68],0x0
MOV qword ptr [RSP + 0x70],0x6
JMP 0x00113502
LAB_001132f9:
MOV RDI,qword ptr [RSP + 0x50]
MOV RAX,qword ptr [RSP + 0x40]
MOV RDX,qword ptr [RAX]
MOV RCX,qword ptr [RAX + 0x8]
LEA RSI,[RSP + 0x18]
CALL 0x00158010
MOV qword ptr [RSP + 0x8],RAX
CMP qword ptr [RSP + 0x8],0x0
JNZ 0x00113337
MOV dword ptr [RSP + 0x68],0x0
MOV qword ptr [RSP + 0x70],0x6
JMP 0x00113502
LAB_00113337:
MOV RAX,qword ptr [RSP + 0x28]
ADD RAX,qword ptr [RSP + 0x20]
CMP RAX,qword ptr [RSP + 0x18]
JBE 0x0011336a
MOV RDI,qword ptr [RSP + 0x50]
LEA RSI,[0x209c9f]
MOV AL,0x0
CALL 0x00129670
MOV qword ptr [RSP + 0x68],RAX
MOV qword ptr [RSP + 0x70],RDX
JMP 0x00113502
LAB_0011336a:
CMP dword ptr [RSP + 0x3c],0x0
JZ 0x00113396
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [RSP + 0x30]
MOV ESI,0x1
CALL 0x0010e8c0
MOV qword ptr [RSP + 0x10],RAX
JMP 0x001133b9
LAB_00113396:
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [RSP + 0x30]
MOV ESI,0x1
CALL 0x0010e170
MOV qword ptr [RSP + 0x10],RAX
LAB_001133b9:
MOV RCX,qword ptr [RSP + 0x50]
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0xa0],RCX
MOV qword ptr [RSP + 0x98],RAX
CMP qword ptr [RSP + 0x98],-0x80000000
JL 0x0011346d
CMP qword ptr [RSP + 0x98],0x7fffffff
JG 0x0011346d
MOV RCX,qword ptr [RSP + 0xa0]
MOV EAX,dword ptr [RSP + 0x98]
MOV qword ptr [RSP + 0xc0],RCX
MOV dword ptr [RSP + 0xbc],EAX
MOV EAX,dword ptr [RSP + 0xbc]
MOV dword ptr [RSP + 0xc8],EAX
MOV qword ptr [RSP + 0xd0],0x0
MOV RCX,qword ptr [RSP + 0xc8]
MOV RAX,qword ptr [RSP + 0xd0]
MOV qword ptr [RSP + 0x88],RCX
MOV qword ptr [RSP + 0x90],RAX
MOV RAX,qword ptr [RSP + 0x88]
MOV qword ptr [RSP + 0xa8],RAX
MOV RAX,qword ptr [RSP + 0x90]
MOV qword ptr [RSP + 0xb0],RAX
JMP 0x001134e8
LAB_0011346d:
MOV RAX,qword ptr [RSP + 0xa0]
CVTSI2SD XMM0,qword ptr [RSP + 0x98]
MOV qword ptr [RSP + 0xe0],RAX
MOVSD qword ptr [RSP + 0xd8],XMM0
MOVSD XMM0,qword ptr [RSP + 0xd8]
CALL 0x00114820
MOV qword ptr [RSP + 0xe8],RAX
MOV qword ptr [RSP + 0xf0],RDX
MOV RCX,qword ptr [RSP + 0xe8]
MOV RAX,qword ptr [RSP + 0xf0]
MOV qword ptr [RSP + 0x78],RCX
MOV qword ptr [RSP + 0x80],RAX
MOV RAX,qword ptr [RSP + 0x78]
MOV qword ptr [RSP + 0xa8],RAX
MOV RAX,qword ptr [RSP + 0x80]
MOV qword ptr [RSP + 0xb0],RAX
LAB_001134e8:
MOV RCX,qword ptr [RSP + 0xa8]
MOV RAX,qword ptr [RSP + 0xb0]
MOV qword ptr [RSP + 0x68],RCX
MOV qword ptr [RSP + 0x70],RAX
LAB_00113502:
MOV RAX,qword ptr [RSP + 0x68]
MOV RDX,qword ptr [RSP + 0x70]
ADD RSP,0xf8
RET
|
int1 [16]
js_std_file_read_write
(int8 param_1,int8 param_2,int8 param_3,int4 param_4,
int8 *param_5,int param_6)
{
int iVar1;
int4 extraout_EAX;
long lVar2;
int4 extraout_var;
int8 extraout_RDX;
int1 auVar3 [16];
size_t local_e8;
ulong local_e0;
size_t local_d8;
long local_d0;
FILE *local_c8;
int local_bc;
int8 *local_b8;
int4 local_ac;
int8 local_a8;
int8 local_a0;
int8 local_98;
int4 local_90;
int4 uStack_8c;
int8 local_88;
size_t local_60;
int8 local_58;
int4 local_50;
int4 uStack_4c;
int8 local_48;
int4 uStack_2c;
double local_20;
int8 local_18;
local_bc = param_6;
local_b8 = param_5;
local_ac = param_4;
local_a8 = param_1;
local_a0 = param_2;
local_98 = param_3;
local_c8 = (FILE *)js_std_file_get(param_1,param_2,param_3);
if (local_c8 == (FILE *)0x0) {
local_90 = 0;
local_88 = 6;
}
else {
iVar1 = JS_ToIndex(local_a8,&local_d0,local_b8[2],local_b8[3]);
if (iVar1 == 0) {
iVar1 = JS_ToIndex(local_a8,&local_d8,local_b8[4],local_b8[5]);
if (iVar1 == 0) {
lVar2 = JS_GetArrayBuffer(local_a8,&local_e0,*local_b8,local_b8[1]);
if (lVar2 == 0) {
local_90 = 0;
local_88 = 6;
}
else if (local_e0 < local_d0 + local_d8) {
auVar3 = JS_ThrowRangeError(local_a8,"read/write array buffer overflow");
local_88 = auVar3._8_8_;
local_90 = auVar3._0_4_;
uStack_8c = auVar3._4_4_;
}
else {
if (local_bc == 0) {
local_e8 = fread((void *)(lVar2 + local_d0),1,local_d8,local_c8);
}
else {
local_e8 = fwrite((void *)(lVar2 + local_d0),1,local_d8,local_c8);
}
local_58 = local_a8;
local_60 = local_e8;
if (((long)local_e8 < -0x80000000) || (0x7fffffff < (long)local_e8)) {
local_20 = (double)(long)local_e8;
local_18 = local_a8;
__JS_NewFloat64(local_20);
local_48 = extraout_RDX;
local_50 = extraout_EAX;
uStack_4c = extraout_var;
}
else {
local_60._0_4_ = (int4)local_e8;
local_50 = (int4)local_60;
uStack_4c = uStack_2c;
local_48 = 0;
}
local_90 = local_50;
uStack_8c = uStack_4c;
local_88 = local_48;
}
}
else {
local_90 = 0;
local_88 = 6;
}
}
else {
local_90 = 0;
local_88 = 6;
}
}
auVar3._4_4_ = uStack_8c;
auVar3._0_4_ = local_90;
auVar3._8_8_ = local_88;
return auVar3;
}
| |
44,771 | js_std_file_read_write | bluesky950520[P]quickjs/quickjs-libc.c | static JSValue js_std_file_read_write(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv, int magic)
{
FILE *f = js_std_file_get(ctx, this_val);
uint64_t pos, len;
size_t size, ret;
uint8_t *buf;
if (!f)
return JS_EXCEPTION;
if (JS_ToIndex(ctx, &pos, argv[1]))
return JS_EXCEPTION;
if (JS_ToIndex(ctx, &len, argv[2]))
return JS_EXCEPTION;
buf = JS_GetArrayBuffer(ctx, &size, argv[0]);
if (!buf)
return JS_EXCEPTION;
if (pos + len > size)
return JS_ThrowRangeError(ctx, "read/write array buffer overflow");
if (magic)
ret = fwrite(buf + pos, 1, len, f);
else
ret = fread(buf + pos, 1, len, f);
return JS_NewInt64(ctx, ret);
} | O1 | c | js_std_file_read_write:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %r9d, %ebp
movq %r8, %r12
movq %rdi, %r15
callq 0x16588
movl $0x6, %ebx
testq %rax, %rax
je 0x16272
movq %rax, %r14
movq 0x10(%r12), %rdx
movq 0x18(%r12), %rcx
leaq 0x18(%rsp), %rsi
movq %r15, %rdi
callq 0x27a6f
testl %eax, %eax
jne 0x16272
movq 0x20(%r12), %rdx
movq 0x28(%r12), %rcx
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x27a6f
testl %eax, %eax
je 0x1628c
xorl %eax, %eax
xorl %r12d, %r12d
movl %eax, %eax
orq %r12, %rax
movq %rbx, %rdx
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%r12), %rdx
movq 0x8(%r12), %rcx
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x38f81
testq %rax, %rax
je 0x16272
movabsq $-0x100000000, %r12 # imm = 0xFFFFFFFF00000000
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rdx
leaq (%rdx,%rcx), %rsi
cmpq 0x8(%rsp), %rsi
jbe 0x162dc
leaq 0x858ba(%rip), %rsi # 0x9bb87
movq %r15, %rdi
xorl %eax, %eax
callq 0x20add
movq %rdx, %rbx
jmp 0x1631b
addq %rcx, %rax
movl $0x1, %esi
movq %rax, %rdi
movq %r14, %rcx
testl %ebp, %ebp
je 0x162f5
callq 0xe8d0
jmp 0x162fa
callq 0xe170
movslq %eax, %rcx
xorl %edx, %edx
cmpq %rax, %rcx
cvtsi2sd %rax, %xmm0
movl %ecx, %ecx
movq %xmm0, %rax
cmoveq %rcx, %rax
movl $0x7, %ebx
cmoveq %rdx, %rbx
andq %rax, %r12
jmp 0x16277
| js_std_file_read_write:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 20h
mov ebp, r9d
mov r12, r8
mov r15, rdi
call js_std_file_get
mov ebx, 6
test rax, rax
jz short loc_16272
mov r14, rax
mov rdx, [r12+10h]
mov rcx, [r12+18h]
lea rsi, [rsp+48h+var_30]
mov rdi, r15
call JS_ToIndex
test eax, eax
jnz short loc_16272
mov rdx, [r12+20h]
mov rcx, [r12+28h]
lea rsi, [rsp+48h+var_38]
mov rdi, r15
call JS_ToIndex
test eax, eax
jz short loc_1628C
loc_16272:
xor eax, eax
xor r12d, r12d
loc_16277:
mov eax, eax
or rax, r12
mov rdx, rbx
add rsp, 20h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_1628C:
mov rdx, [r12]
mov rcx, [r12+8]
lea rsi, [rsp+48h+var_40]
mov rdi, r15
call JS_GetArrayBuffer
test rax, rax
jz short loc_16272
mov r12, 0FFFFFFFF00000000h
mov rcx, [rsp+48h+var_30]
mov rdx, [rsp+48h+var_38]
lea rsi, [rdx+rcx]
cmp rsi, [rsp+48h+var_40]
jbe short loc_162DC
lea rsi, aReadWriteArray; "read/write array buffer overflow"
mov rdi, r15
xor eax, eax
call JS_ThrowRangeError
mov rbx, rdx
jmp short loc_1631B
loc_162DC:
add rax, rcx
mov esi, 1
mov rdi, rax
mov rcx, r14
test ebp, ebp
jz short loc_162F5
call _fwrite
jmp short loc_162FA
loc_162F5:
call _fread
loc_162FA:
movsxd rcx, eax
xor edx, edx
cmp rcx, rax
cvtsi2sd xmm0, rax
mov ecx, ecx
movq rax, xmm0
cmovz rax, rcx
mov ebx, 7
cmovz rbx, rdx
loc_1631B:
and r12, rax
jmp loc_16277
| unsigned long long js_std_file_read_write(long long a1, long long a2, long long a3, long long a4, _QWORD *a5, int a6)
{
long long v8; // rax
long long v9; // r14
double v10; // rax
unsigned long long v11; // r12
long long ArrayBuffer; // rax
int v14; // r8d
int v15; // r9d
long long v16; // rdi
long long v17; // rax
bool v18; // zf
double v19; // rcx
unsigned long long v20; // [rsp+8h] [rbp-40h] BYREF
long long v21; // [rsp+10h] [rbp-38h] BYREF
_QWORD v22[6]; // [rsp+18h] [rbp-30h] BYREF
v8 = js_std_file_get(a1);
if ( !v8
|| (v9 = v8, (unsigned int)JS_ToIndex(a1, v22, a5[2], a5[3]))
|| (unsigned int)JS_ToIndex(a1, &v21, a5[4], a5[5])
|| (ArrayBuffer = JS_GetArrayBuffer(a1, &v20, *a5, a5[1])) == 0 )
{
LODWORD(v10) = 0;
v11 = 0LL;
}
else
{
if ( v21 + v22[0] <= v20 )
{
v16 = v22[0] + ArrayBuffer;
if ( a6 )
v17 = fwrite(v16, 1LL, v21, v9);
else
v17 = fread(v16, 1LL, v21, v9);
v18 = (int)v17 == v17;
*(_QWORD *)&v19 = (unsigned int)v17;
v10 = (double)(int)v17;
if ( v18 )
v10 = v19;
}
else
{
v10 = COERCE_DOUBLE(JS_ThrowRangeError(a1, (unsigned int)"read/write array buffer overflow", v21, v22[0], v14, v15));
}
v11 = *(_QWORD *)&v10 & 0xFFFFFFFF00000000LL;
}
return v11 | LODWORD(v10);
}
| |||
44,772 | js_std_file_read_write | bluesky950520[P]quickjs/quickjs-libc.c | static JSValue js_std_file_read_write(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv, int magic)
{
FILE *f = js_std_file_get(ctx, this_val);
uint64_t pos, len;
size_t size, ret;
uint8_t *buf;
if (!f)
return JS_EXCEPTION;
if (JS_ToIndex(ctx, &pos, argv[1]))
return JS_EXCEPTION;
if (JS_ToIndex(ctx, &len, argv[2]))
return JS_EXCEPTION;
buf = JS_GetArrayBuffer(ctx, &size, argv[0]);
if (!buf)
return JS_EXCEPTION;
if (pos + len > size)
return JS_ThrowRangeError(ctx, "read/write array buffer overflow");
if (magic)
ret = fwrite(buf + pos, 1, len, f);
else
ret = fread(buf + pos, 1, len, f);
return JS_NewInt64(ctx, ret);
} | O2 | c | js_std_file_read_write:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %r9d, %ebp
movq %r8, %r12
movq %rdi, %r15
callq 0x113c6
pushq $0x6
popq %rbx
testq %rax, %rax
je 0x110db
movq %rax, %r14
movq 0x10(%r12), %rdx
movq 0x18(%r12), %rcx
leaq 0x18(%rsp), %rsi
movq %r15, %rdi
callq 0x21680
testl %eax, %eax
jne 0x110db
movq 0x20(%r12), %rdx
movq 0x28(%r12), %rcx
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x21680
testl %eax, %eax
je 0x110f5
xorl %eax, %eax
xorl %r12d, %r12d
movl %eax, %eax
orq %r12, %rax
movq %rbx, %rdx
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%r12), %rdx
movq 0x8(%r12), %rcx
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x320b8
testq %rax, %rax
je 0x110db
movabsq $-0x100000000, %r12 # imm = 0xFFFFFFFF00000000
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rdx
leaq (%rdx,%rcx), %rsi
cmpq 0x8(%rsp), %rsi
jbe 0x11145
leaq 0x719fd(%rip), %rsi # 0x82b33
movq %r15, %rdi
xorl %eax, %eax
callq 0x1acb3
movq %rdx, %rbx
jmp 0x11180
addq %rcx, %rax
pushq $0x1
popq %rsi
movq %rax, %rdi
movq %r14, %rcx
testl %ebp, %ebp
je 0x1115c
callq 0xe8f0
jmp 0x11161
callq 0xe180
movslq %eax, %rcx
xorl %edx, %edx
cmpq %rax, %rcx
cvtsi2sd %rax, %xmm0
movl %ecx, %ecx
movq %xmm0, %rax
cmoveq %rcx, %rax
pushq $0x7
popq %rbx
cmoveq %rdx, %rbx
andq %rax, %r12
jmp 0x110e0
| js_std_file_read_write:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 20h
mov ebp, r9d
mov r12, r8
mov r15, rdi
call js_std_file_get
push 6
pop rbx
test rax, rax
jz short loc_110DB
mov r14, rax
mov rdx, [r12+10h]
mov rcx, [r12+18h]
lea rsi, [rsp+48h+var_30]
mov rdi, r15
call JS_ToIndex
test eax, eax
jnz short loc_110DB
mov rdx, [r12+20h]
mov rcx, [r12+28h]
lea rsi, [rsp+48h+var_38]
mov rdi, r15
call JS_ToIndex
test eax, eax
jz short loc_110F5
loc_110DB:
xor eax, eax
xor r12d, r12d
loc_110E0:
mov eax, eax
or rax, r12
mov rdx, rbx
add rsp, 20h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_110F5:
mov rdx, [r12]
mov rcx, [r12+8]
lea rsi, [rsp+48h+var_40]
mov rdi, r15
call JS_GetArrayBuffer
test rax, rax
jz short loc_110DB
mov r12, 0FFFFFFFF00000000h
mov rcx, [rsp+48h+var_30]
mov rdx, [rsp+48h+var_38]
lea rsi, [rdx+rcx]
cmp rsi, [rsp+48h+var_40]
jbe short loc_11145
lea rsi, aReadWriteArray; "read/write array buffer overflow"
mov rdi, r15
xor eax, eax
call JS_ThrowRangeError
mov rbx, rdx
jmp short loc_11180
loc_11145:
add rax, rcx
push 1
pop rsi
mov rdi, rax
mov rcx, r14
test ebp, ebp
jz short loc_1115C
call _fwrite
jmp short loc_11161
loc_1115C:
call _fread
loc_11161:
movsxd rcx, eax
xor edx, edx
cmp rcx, rax
cvtsi2sd xmm0, rax
mov ecx, ecx
movq rax, xmm0
cmovz rax, rcx
push 7
pop rbx
cmovz rbx, rdx
loc_11180:
and r12, rax
jmp loc_110E0
| unsigned long long js_std_file_read_write(long long a1, long long a2, long long a3, long long a4, _QWORD *a5, int a6)
{
long long v8; // rax
long long v9; // r14
double v10; // rax
unsigned long long v11; // r12
long long ArrayBuffer; // rax
int v14; // r8d
int v15; // r9d
long long v16; // rdi
long long v17; // rax
bool v18; // zf
double v19; // rcx
unsigned long long v20; // [rsp+8h] [rbp-40h] BYREF
long long v21; // [rsp+10h] [rbp-38h] BYREF
_QWORD v22[6]; // [rsp+18h] [rbp-30h] BYREF
v8 = js_std_file_get(a1);
if ( !v8
|| (v9 = v8, (unsigned int)JS_ToIndex(a1, v22, a5[2], a5[3]))
|| (unsigned int)JS_ToIndex(a1, &v21, a5[4], a5[5])
|| (ArrayBuffer = JS_GetArrayBuffer(a1, &v20, *a5, a5[1])) == 0 )
{
LODWORD(v10) = 0;
v11 = 0LL;
}
else
{
if ( v21 + v22[0] <= v20 )
{
v16 = v22[0] + ArrayBuffer;
if ( a6 )
v17 = fwrite(v16, 1LL, v21, v9);
else
v17 = fread(v16, 1LL, v21, v9);
v18 = (int)v17 == v17;
*(_QWORD *)&v19 = (unsigned int)v17;
v10 = (double)(int)v17;
if ( v18 )
v10 = v19;
}
else
{
v10 = COERCE_DOUBLE(JS_ThrowRangeError(a1, (unsigned int)"read/write array buffer overflow", v21, v22[0], v14, v15));
}
v11 = *(_QWORD *)&v10 & 0xFFFFFFFF00000000LL;
}
return v11 | LODWORD(v10);
}
| js_std_file_read_write:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x20
MOV EBP,R9D
MOV R12,R8
MOV R15,RDI
CALL 0x001113c6
PUSH 0x6
POP RBX
TEST RAX,RAX
JZ 0x001110db
MOV R14,RAX
MOV RDX,qword ptr [R12 + 0x10]
MOV RCX,qword ptr [R12 + 0x18]
LEA RSI,[RSP + 0x18]
MOV RDI,R15
CALL 0x00121680
TEST EAX,EAX
JNZ 0x001110db
MOV RDX,qword ptr [R12 + 0x20]
MOV RCX,qword ptr [R12 + 0x28]
LEA RSI,[RSP + 0x10]
MOV RDI,R15
CALL 0x00121680
TEST EAX,EAX
JZ 0x001110f5
LAB_001110db:
XOR EAX,EAX
XOR R12D,R12D
LAB_001110e0:
MOV EAX,EAX
OR RAX,R12
MOV RDX,RBX
ADD RSP,0x20
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001110f5:
MOV RDX,qword ptr [R12]
MOV RCX,qword ptr [R12 + 0x8]
LEA RSI,[RSP + 0x8]
MOV RDI,R15
CALL 0x001320b8
TEST RAX,RAX
JZ 0x001110db
MOV R12,-0x100000000
MOV RCX,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x10]
LEA RSI,[RDX + RCX*0x1]
CMP RSI,qword ptr [RSP + 0x8]
JBE 0x00111145
LEA RSI,[0x182b33]
MOV RDI,R15
XOR EAX,EAX
CALL 0x0011acb3
MOV RBX,RDX
JMP 0x00111180
LAB_00111145:
ADD RAX,RCX
PUSH 0x1
POP RSI
MOV RDI,RAX
MOV RCX,R14
TEST EBP,EBP
JZ 0x0011115c
CALL 0x0010e8f0
JMP 0x00111161
LAB_0011115c:
CALL 0x0010e180
LAB_00111161:
MOVSXD RCX,EAX
XOR EDX,EDX
CMP RCX,RAX
CVTSI2SD XMM0,RAX
MOV ECX,ECX
MOVQ RAX,XMM0
CMOVZ RAX,RCX
PUSH 0x7
POP RBX
CMOVZ RBX,RDX
LAB_00111180:
AND R12,RAX
JMP 0x001110e0
|
int1 [16] js_std_file_read_write(int8 param_1)
{
int iVar1;
FILE *__stream;
long lVar2;
double dVar3;
int8 *in_R8;
int in_R9D;
ulong uVar4;
bool bVar5;
int1 auVar6 [16];
int1 auVar7 [16];
ulong local_40;
size_t local_38;
long local_30;
__stream = (FILE *)js_std_file_get();
if (__stream != (FILE *)0x0) {
iVar1 = JS_ToIndex(param_1,&local_30,in_R8[2],in_R8[3]);
if (iVar1 == 0) {
iVar1 = JS_ToIndex(param_1,&local_38,in_R8[4],in_R8[5]);
if (iVar1 == 0) {
lVar2 = JS_GetArrayBuffer(param_1,&local_40,*in_R8,in_R8[1]);
if (lVar2 != 0) {
if (local_40 < local_38 + local_30) {
auVar7 = JS_ThrowRangeError(param_1,"read/write array buffer overflow");
}
else {
if (in_R9D == 0) {
uVar4 = fread((void *)(lVar2 + local_30),1,local_38,__stream);
}
else {
uVar4 = fwrite((void *)(lVar2 + local_30),1,local_38,__stream);
}
bVar5 = (long)(int)uVar4 == uVar4;
dVar3 = (double)(long)uVar4;
if (bVar5) {
dVar3 = (double)(uVar4 & 0xffffffff);
}
auVar7._8_8_ = 7;
auVar7._0_8_ = dVar3;
if (bVar5) {
auVar7._8_8_ = 0;
}
}
uVar4 = auVar7._0_8_ & 0xffffffff00000000;
goto LAB_001110e0;
}
}
}
}
auVar7 = ZEXT816(6) << 0x40;
uVar4 = 0;
LAB_001110e0:
auVar6._0_8_ = auVar7._0_8_ & 0xffffffff | uVar4;
auVar6._8_8_ = auVar7._8_8_;
return auVar6;
}
| |
44,773 | ftb_find_relevance_parse | eloqsql/storage/myisam/ft_boolean_search.c | static int ftb_find_relevance_parse(MYSQL_FTPARSER_PARAM *param,
const char *doc, int len)
{
MY_FTB_FIND_PARAM *ftb_param= param->mysql_ftparam;
FT_INFO *ftb= ftb_param->ftb;
uchar *end= (uchar*) doc + len;
FT_WORD w;
while (ft_simple_get_word(ftb->charset, (uchar**) &doc, end, &w, TRUE))
param->mysql_add_word(param, (char*) w.pos, (int)w.len, 0);
return(0);
} | O0 | c | ftb_find_relevance_parse:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x30(%rbp), %rdx
leaq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rcx
movl $0x1, %r8d
callq 0xa51f0
cmpb $0x0, %al
je 0xa22f8
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x38(%rbp), %rcx
movl %ecx, %edx
xorl %ecx, %ecx
callq *%rax
jmp 0xa22b9
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
| ftb_find_relevance_parse:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov rax, [rbp+var_8]
mov rax, [rax+18h]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_28], rax
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_14]
add rax, rcx
mov [rbp+var_30], rax
loc_A22B9:
mov rax, [rbp+var_28]
mov rdi, [rax+10h]
mov rdx, [rbp+var_30]
lea rsi, [rbp+var_10]
lea rcx, [rbp+var_48]
mov r8d, 1
call ft_simple_get_word
cmp al, 0
jz short loc_A22F8
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_48]
mov rcx, [rbp+var_38]
mov edx, ecx
xor ecx, ecx
call rax
jmp short loc_A22B9
loc_A22F8:
xor eax, eax
add rsp, 50h
pop rbp
retn
| long long ftb_find_relevance_parse(long long a1, long long a2, int a3)
{
long long v4; // [rsp+8h] [rbp-48h] BYREF
long long v5; // [rsp+18h] [rbp-38h]
long long v6; // [rsp+20h] [rbp-30h]
long long v7; // [rsp+28h] [rbp-28h]
long long *v8; // [rsp+30h] [rbp-20h]
int v9; // [rsp+3Ch] [rbp-14h]
long long v10; // [rsp+40h] [rbp-10h] BYREF
long long v11; // [rsp+48h] [rbp-8h]
v11 = a1;
v10 = a2;
v9 = a3;
v8 = *(long long **)(a1 + 24);
v7 = *v8;
v6 = a3 + a2;
while ( (unsigned __int8)ft_simple_get_word(*(_QWORD *)(v7 + 16), &v10, v6, &v4, 1LL) )
(*(void ( **)(long long, long long, _QWORD, _QWORD))(v11 + 8))(v11, v4, (unsigned int)v5, 0LL);
return 0LL;
}
| ftb_find_relevance_parse:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x14]
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
LAB_001a22b9:
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,qword ptr [RAX + 0x10]
MOV RDX,qword ptr [RBP + -0x30]
LEA RSI,[RBP + -0x10]
LEA RCX,[RBP + -0x48]
MOV R8D,0x1
CALL 0x001a51f0
CMP AL,0x0
JZ 0x001a22f8
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RBP + -0x38]
MOV EDX,ECX
XOR ECX,ECX
CALL RAX
JMP 0x001a22b9
LAB_001a22f8:
XOR EAX,EAX
ADD RSP,0x50
POP RBP
RET
|
int8 ftb_find_relevance_parse(long param_1,long param_2,int param_3)
{
char cVar1;
int8 local_50 [2];
ulong local_40;
long local_38;
long local_30;
long *local_28;
int local_1c;
long local_18;
long local_10;
local_28 = *(long **)(param_1 + 0x18);
local_30 = *local_28;
local_38 = param_2 + param_3;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
while( true ) {
cVar1 = ft_simple_get_word(*(int8 *)(local_30 + 0x10),&local_18,local_38,local_50,1);
if (cVar1 == '\0') break;
(**(code **)(local_10 + 8))(local_10,local_50[0],local_40 & 0xffffffff,0);
}
return 0;
}
| |
44,774 | evmone::Result evmone::instr::core::create_eof_impl<(evmone::Opcode)236>(evmone::StackTop, long, evmone::ExecutionState&, unsigned char const*&) | corpus-core[P]colibri-stateless/build_O3/_deps/evmone_external-src/lib/evmone/instructions_calls.cpp | Result create_eof_impl(
StackTop stack, int64_t gas_left, ExecutionState& state, code_iterator& pos) noexcept
{
static_assert(Op == OP_EOFCREATE || Op == OP_TXCREATE);
if (state.in_static_mode())
return {EVMC_STATIC_MODE_VIOLATION, gas_left};
const auto initcode_hash =
(Op == OP_TXCREATE) ? intx::be::store<evmc::bytes32>(stack.pop()) : evmc::bytes32{};
const auto salt = stack.pop();
const auto input_offset_u256 = stack.pop();
const auto input_size_u256 = stack.pop();
const auto endowment = stack.pop();
stack.push(0); // Assume failure.
state.return_data.clear();
if (!check_memory(gas_left, state.memory, input_offset_u256, input_size_u256))
return {EVMC_OUT_OF_GAS, gas_left};
constexpr auto pos_advance = (Op == OP_EOFCREATE ? 2 : 1);
pos += pos_advance;
if (state.msg->depth >= 1024)
return {EVMC_SUCCESS, gas_left}; // "Light" failure.
if (endowment != 0 &&
intx::be::load<uint256>(state.host.get_balance(state.msg->recipient)) < endowment)
return {EVMC_SUCCESS, gas_left}; // "Light" failure.
bytes_view initcontainer;
if constexpr (Op == OP_EOFCREATE)
{
const auto initcontainer_index = pos[-1];
const auto& container = state.original_code;
const auto& eof_header = state.analysis.baseline->eof_header();
initcontainer = eof_header.get_container(container, initcontainer_index);
}
else
{
auto* tx_initcode = state.get_tx_initcode_by_hash(initcode_hash);
// In case initcode was not found, nullptr was returned.
if (tx_initcode == nullptr)
return {EVMC_SUCCESS, gas_left}; // "Light" failure
initcontainer = tx_initcode->code;
if (!tx_initcode->is_valid.has_value())
{
const auto error_subcont =
validate_eof(state.rev, ContainerKind::initcode, initcontainer);
tx_initcode->is_valid = (error_subcont == EOFValidationError::success);
}
if (!*tx_initcode->is_valid)
return {EVMC_SUCCESS, gas_left}; // "Light" failure.
}
const auto input_offset = static_cast<size_t>(input_offset_u256);
const auto input_size = static_cast<size_t>(input_size_u256);
evmc_message msg{.kind = to_call_kind(Op)};
msg.gas = gas_left - gas_left / 64;
if (input_size > 0)
{
// input_data may be garbage if init_code_size == 0.
msg.input_data = &state.memory[input_offset];
msg.input_size = input_size;
}
msg.sender = state.msg->recipient;
msg.depth = state.msg->depth + 1;
msg.create2_salt = intx::be::store<evmc::bytes32>(salt);
msg.value = intx::be::store<evmc::uint256be>(endowment);
// init_code is guaranteed to be non-empty by validation of container sections
msg.code = initcontainer.data();
msg.code_size = initcontainer.size();
const auto result = state.host.call(msg);
gas_left -= msg.gas - result.gas_left;
state.gas_refund += result.gas_refund;
state.return_data.assign(result.output_data, result.output_size);
if (result.status_code == EVMC_SUCCESS)
stack.top() = intx::be::load<uint256>(result.create_address);
return {EVMC_SUCCESS, gas_left};
} | O3 | cpp | evmone::Result evmone::instr::core::create_eof_impl<(evmone::Opcode)236>(evmone::StackTop, long, evmone::ExecutionState&, unsigned char const*&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %rsi, %rbx
movq 0x20(%rdx), %rax
movl $0xb, %ebp
testb $0x1, 0x4(%rax)
jne 0x4899b
movq %rcx, %r13
movq %rdx, %r15
movq %rdi, %r14
movups (%rdi), %xmm2
movups 0x10(%rdi), %xmm4
movq -0x20(%rdi), %r12
movq -0x18(%rdi), %rcx
movq -0x10(%rdi), %rax
movq -0x8(%rdi), %r8
movdqu -0x60(%rdi), %xmm3
movdqu -0x50(%rdi), %xmm5
movdqu -0x40(%rdi), %xmm6
movdqu -0x30(%rdi), %xmm0
xorps %xmm1, %xmm1
movups %xmm1, -0x60(%rdi)
movups %xmm1, -0x50(%rdi)
movq $0x0, 0x50(%rdx)
movq 0x48(%rdx), %rdx
movb $0x0, (%rdx)
movdqa %xmm0, %xmm1
por %xmm6, %xmm1
leaq 0x8(%r15), %rsi
ptest %xmm1, %xmm1
je 0x48706
pextrq $0x1, %xmm0, %rdx
movq %xmm0, %rdi
orq %rdx, %rdi
pextrq $0x1, %xmm6, %rdx
movl $0x3, %ebp
orq %rdi, %rdx
jne 0x4899b
movq %xmm6, %rdx
movq %rdx, %rdi
shrq $0x20, %rdi
jne 0x4899b
orq %rcx, %rax
orq %r8, %rax
movq %r12, %rcx
shrq $0x20, %rcx
orq %rax, %rcx
jne 0x4899b
addq %r12, %rdx
cmpq 0x10(%r15), %rdx
jbe 0x486fd
movq %rbx, %rdi
movaps %xmm2, 0x40(%rsp)
movdqa %xmm3, 0x10(%rsp)
movaps %xmm4, 0x30(%rsp)
movdqa %xmm5, (%rsp)
movq %rsi, %rbx
movdqa %xmm6, 0x20(%rsp)
callq 0x3fbe5
movdqa 0x20(%rsp), %xmm6
movq %rbx, %rsi
movdqa (%rsp), %xmm5
movaps 0x30(%rsp), %xmm4
movdqa 0x10(%rsp), %xmm3
movaps 0x40(%rsp), %xmm2
movq %rax, %rbx
testq %rbx, %rbx
js 0x4899b
movq (%r13), %rax
addq $0x2, %rax
movq %rax, (%r13)
movq 0x20(%r15), %rcx
xorl %ebp, %ebp
cmpl $0x3ff, 0x8(%rcx) # imm = 0x3FF
jg 0x4899b
movdqa %xmm6, 0x20(%rsp)
movq %rsi, 0x68(%rsp)
movaps %xmm4, 0x30(%rsp)
movaps %xmm2, 0x40(%rsp)
movdqa %xmm5, (%rsp)
movdqa %xmm5, %xmm0
movdqa %xmm3, 0x10(%rsp)
por %xmm3, %xmm0
ptest %xmm0, %xmm0
je 0x487f2
movl 0x28(%rcx), %eax
leaq 0x170(%rsp), %rdx
movl %eax, 0x10(%rdx)
movdqu 0x18(%rcx), %xmm0
movdqa %xmm0, (%rdx)
movq 0x30(%r15), %rax
movq 0x38(%r15), %rsi
leaq 0xb8(%rsp), %rdi
callq *0x18(%rax)
movq 0xb8(%rsp), %rax
movq 0xc0(%rsp), %rcx
bswapq %rcx
bswapq %rax
movdqa (%rsp), %xmm0
movq %xmm0, %rdx
pextrq $0x1, %xmm0, %rsi
movq %rcx, %rdi
xorq %rdx, %rdi
movq %rax, %r8
xorq %rsi, %r8
orq %rdi, %r8
movdqa 0x10(%rsp), %xmm0
jne 0x487e2
movq 0xc8(%rsp), %rax
movq 0xd0(%rsp), %rcx
bswapq %rax
bswapq %rcx
movq %xmm0, %rdx
pextrq $0x1, %xmm0, %rsi
cmpq %rdx, %rcx
sbbq %rsi, %rax
jb 0x4899b
movq (%r13), %rax
movzbl -0x1(%rax), %ecx
movq 0x1f8(%r15), %rdi
addq $0x48, %rdi
movq 0x68(%r15), %rsi
movq 0x70(%r15), %rdx
callq 0x40f78
movq %rax, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movdqa 0x20(%rsp), %xmm0
movq %xmm0, %rbp
leaq 0xb8(%rsp), %r13
movl $0xa8, %edx
movq %r13, %rdi
xorl %esi, %esi
callq 0x21120
movl $0x5, (%r13)
leaq 0x3f(%rbx), %rax
testq %rbx, %rbx
cmovnsq %rbx, %rax
sarq $0x6, %rax
movq %rbx, %rcx
subq %rax, %rcx
movq %rcx, 0x10(%r13)
testq %rbp, %rbp
je 0x48878
movq 0x68(%rsp), %rax
addq (%rax), %r12
movq %r12, 0xf8(%rsp)
movq %rbp, 0x100(%rsp)
movq 0x20(%r15), %rax
movl 0x28(%rax), %ecx
leaq 0xb8(%rsp), %rdx
movl %ecx, 0x3c(%rdx)
movups 0x18(%rax), %xmm0
movups %xmm0, 0x2c(%rdx)
movl 0x8(%rax), %eax
incl %eax
movl %eax, 0x8(%rdx)
movdqa 0x3875e(%rip), %xmm0 # 0x81000
movdqa 0x30(%rsp), %xmm1
pshufb %xmm0, %xmm1
movdqu %xmm1, 0x70(%rdx)
movdqa 0x40(%rsp), %xmm1
pshufb %xmm0, %xmm1
movdqu %xmm1, 0x80(%rdx)
movdqa (%rsp), %xmm1
pshufb %xmm0, %xmm1
movdqu %xmm1, 0x50(%rdx)
movdqa 0x10(%rsp), %xmm1
pshufb %xmm0, %xmm1
movdqu %xmm1, 0x60(%rdx)
movq 0x58(%rsp), %rax
movq %rax, 0xa8(%rdx)
movq 0x60(%rsp), %rax
movq %rax, 0xb0(%rdx)
movq 0x30(%r15), %rax
movq 0x38(%r15), %rsi
leaq 0x170(%rsp), %rdi
callq *0x40(%rax)
leaq 0x70(%rsp), %rax
leaq 0x170(%rsp), %rsi
movl $0x9, %ecx
movq %rax, %rdi
rep movsq (%rsi), %es:(%rdi)
subq 0xc8(%rsp), %rbx
addq 0x8(%rax), %rbx
movq 0x10(%rax), %rcx
addq %rcx, (%r15)
leaq 0x48(%r15), %rdi
movq 0x18(%rax), %rcx
movq 0x20(%rax), %r8
movq 0x50(%r15), %rdx
xorl %esi, %esi
callq 0x4934e
cmpl $0x0, 0x70(%rsp)
jne 0x48985
movl 0xa0(%rsp), %eax
movdqu 0xa4(%rsp), %xmm0
pshufb 0x3868f(%rip), %xmm0 # 0x81000
bswapl %eax
movdqu %xmm0, -0x60(%r14)
movq %rax, -0x50(%r14)
movq $0x0, -0x48(%r14)
movq 0x98(%rsp), %rax
testq %rax, %rax
je 0x48999
leaq 0x70(%rsp), %rdi
callq *%rax
xorl %ebp, %ebp
movl %ebp, %eax
movq %rbx, %rdx
addq $0x1b8, %rsp # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x489b8
jmp 0x489b8
jmp 0x489b8
movq %rax, %rdi
callq 0x2e015
| _ZN6evmone5instr4core15create_eof_implILNS_6OpcodeE236EEENS_6ResultENS_8StackTopElRNS_14ExecutionStateERPKh:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 1B8h
mov rbx, rsi
mov rax, [rdx+20h]
mov ebp, 0Bh
test byte ptr [rax+4], 1
jnz loc_4899B
mov r13, rcx
mov r15, rdx
mov r14, rdi
movups xmm2, xmmword ptr [rdi]
movups xmm4, xmmword ptr [rdi+10h]
mov r12, [rdi-20h]
mov rcx, [rdi-18h]
mov rax, [rdi-10h]
mov r8, [rdi-8]
movdqu xmm3, xmmword ptr [rdi-60h]
movdqu xmm5, xmmword ptr [rdi-50h]
movdqu xmm6, xmmword ptr [rdi-40h]
movdqu xmm0, xmmword ptr [rdi-30h]
xorps xmm1, xmm1
movups xmmword ptr [rdi-60h], xmm1
movups xmmword ptr [rdi-50h], xmm1
mov qword ptr [rdx+50h], 0
mov rdx, [rdx+48h]
mov byte ptr [rdx], 0
movdqa xmm1, xmm0
por xmm1, xmm6
lea rsi, [r15+8]; __int64
ptest xmm1, xmm1
jz loc_48706
pextrq rdx, xmm0, 1
movq rdi, xmm0
or rdi, rdx
pextrq rdx, xmm6, 1
mov ebp, 3
or rdx, rdi
jnz loc_4899B
movq rdx, xmm6
mov rdi, rdx
shr rdi, 20h
jnz loc_4899B
or rax, rcx
or rax, r8
mov rcx, r12
shr rcx, 20h
or rcx, rax; unsigned __int64
jnz loc_4899B
add rdx, r12; evmone::Memory *
cmp rdx, [r15+10h]
jbe short loc_486FD
mov rdi, rbx; this
movaps [rsp+1E8h+var_1A8], xmm2
movdqa [rsp+1E8h+var_1D8], xmm3
movaps [rsp+1E8h+var_1B8], xmm4
movdqa [rsp+1E8h+var_1E8], xmm5
mov rbx, rsi
movdqa [rsp+1E8h+var_1C8], xmm6
call _ZN6evmone11grow_memoryElRNS_6MemoryEm; evmone::grow_memory(long,evmone::Memory &,ulong)
movdqa xmm6, [rsp+1E8h+var_1C8]
mov rsi, rbx
movdqa xmm5, [rsp+1E8h+var_1E8]
movaps xmm4, [rsp+1E8h+var_1B8]
movdqa xmm3, [rsp+1E8h+var_1D8]
movaps xmm2, [rsp+1E8h+var_1A8]
mov rbx, rax
loc_486FD:
test rbx, rbx
js loc_4899B
loc_48706:
mov rax, [r13+0]
add rax, 2
mov [r13+0], rax
mov rcx, [r15+20h]
xor ebp, ebp
cmp dword ptr [rcx+8], 3FFh
jg loc_4899B
movdqa [rsp+1E8h+var_1C8], xmm6
mov [rsp+1E8h+var_180], rsi
movaps [rsp+1E8h+var_1B8], xmm4
movaps [rsp+1E8h+var_1A8], xmm2
movdqa [rsp+1E8h+var_1E8], xmm5
movdqa xmm0, xmm5
movdqa [rsp+1E8h+var_1D8], xmm3
por xmm0, xmm3
ptest xmm0, xmm0
jz loc_487F2
mov eax, [rcx+28h]
lea rdx, [rsp+1E8h+var_78]
mov [rdx+10h], eax
movdqu xmm0, xmmword ptr [rcx+18h]
movdqa xmmword ptr [rdx], xmm0
mov rax, [r15+30h]
mov rsi, [r15+38h]
lea rdi, [rsp+1E8h+var_130]
call qword ptr [rax+18h]
mov rax, [rsp+1E8h+var_130]
mov rcx, [rsp+1E8h+var_128]
bswap rcx
bswap rax
movdqa xmm0, [rsp+1E8h+var_1E8]
movq rdx, xmm0
pextrq rsi, xmm0, 1
mov rdi, rcx
xor rdi, rdx
mov r8, rax
xor r8, rsi
or r8, rdi
movdqa xmm0, [rsp+1E8h+var_1D8]
jnz short loc_487E2
mov rax, [rsp+1E8h+var_120]
mov rcx, [rsp+1E8h+var_118]
bswap rax
bswap rcx
movq rdx, xmm0
pextrq rsi, xmm0, 1
loc_487E2:
cmp rcx, rdx
sbb rax, rsi
jb loc_4899B
mov rax, [r13+0]
loc_487F2:
movzx ecx, byte ptr [rax-1]
mov rdi, [r15+1F8h]
add rdi, 48h ; 'H'
mov rsi, [r15+68h]
mov rdx, [r15+70h]
call _ZNK6evmone10EOF1Header13get_containerESt17basic_string_viewIhN4evmc11byte_traitsIhEEEm; evmone::EOF1Header::get_container(std::basic_string_view<uchar,evmc::byte_traits<uchar>>,ulong)
mov [rsp+1E8h+var_188], rax
mov [rsp+1E8h+var_190], rdx
movdqa xmm0, [rsp+1E8h+var_1C8]
movq rbp, xmm0
lea r13, [rsp+1E8h+var_130]
mov edx, 0A8h
mov rdi, r13
xor esi, esi
call _memset
mov dword ptr [r13+0], 5
lea rax, [rbx+3Fh]
test rbx, rbx
cmovns rax, rbx
sar rax, 6
mov rcx, rbx
sub rcx, rax
mov [r13+10h], rcx
test rbp, rbp
jz short loc_48878
mov rax, [rsp+1E8h+var_180]
add r12, [rax]
mov [rsp+1E8h+var_F0], r12
mov [rsp+1E8h+var_E8], rbp
loc_48878:
mov rax, [r15+20h]
mov ecx, [rax+28h]
lea rdx, [rsp+1E8h+var_130]
mov [rdx+3Ch], ecx
movups xmm0, xmmword ptr [rax+18h]
movups xmmword ptr [rdx+2Ch], xmm0
mov eax, [rax+8]
inc eax
mov [rdx+8], eax
movdqa xmm0, cs:xmmword_81000
movdqa xmm1, [rsp+1E8h+var_1B8]
pshufb xmm1, xmm0
movdqu xmmword ptr [rdx+70h], xmm1
movdqa xmm1, [rsp+1E8h+var_1A8]
pshufb xmm1, xmm0
movdqu xmmword ptr [rdx+80h], xmm1
movdqa xmm1, [rsp+1E8h+var_1E8]
pshufb xmm1, xmm0
movdqu xmmword ptr [rdx+50h], xmm1
movdqa xmm1, [rsp+1E8h+var_1D8]
pshufb xmm1, xmm0
movdqu xmmword ptr [rdx+60h], xmm1
mov rax, [rsp+1E8h+var_190]
mov [rdx+0A8h], rax
mov rax, [rsp+1E8h+var_188]
mov [rdx+0B0h], rax
mov rax, [r15+30h]
mov rsi, [r15+38h]
lea rdi, [rsp+1E8h+var_78]
call qword ptr [rax+40h]
lea rax, [rsp+1E8h+var_178]
lea rsi, [rsp+1E8h+var_78]
mov ecx, 9
mov rdi, rax
rep movsq
sub rbx, [rsp+1E8h+var_120]
add rbx, [rax+8]
mov rcx, [rax+10h]
add [r15], rcx
lea rdi, [r15+48h]
mov rcx, [rax+18h]
mov r8, [rax+20h]
mov rdx, [r15+50h]
xor esi, esi
call _ZNSt7__cxx1112basic_stringIhN4evmc11byte_traitsIhEESaIhEE10_M_replaceEmmPKhm; std::basic_string<uchar,evmc::byte_traits<uchar>,std::allocator<uchar>>::_M_replace(ulong,ulong,uchar const*,ulong)
cmp [rsp+1E8h+var_178], 0
jnz short loc_48985
mov eax, [rsp+1E8h+var_148]
movdqu xmm0, [rsp+1E8h+var_144]
pshufb xmm0, cs:xmmword_81000
bswap eax
movdqu xmmword ptr [r14-60h], xmm0
mov [r14-50h], rax
mov qword ptr [r14-48h], 0
loc_48985:
mov rax, [rsp+1E8h+var_150]
test rax, rax
jz short loc_48999
lea rdi, [rsp+1E8h+var_178]
call rax
loc_48999:
xor ebp, ebp
loc_4899B:
mov eax, ebp
mov rdx, rbx
add rsp, 1B8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_489B8
jmp short loc_489B8
jmp short $+2
loc_489B8:
mov rdi, rax
call __clang_call_terminate
| long long evmone::instr::core::create_eof_impl<(evmone::Opcode)236>(
const __m128i *a1,
evmone *a2,
long long a3,
long long *a4,
long long a5,
long long a6)
{
unsigned int v7; // ebp
__m128i v10; // xmm2
__m128i v11; // xmm4
unsigned long long v12; // r12
long long v13; // rcx
long long v14; // rax
long long v15; // r8
__m128i v16; // xmm3
__m128i v17; // xmm5
__m128i v18; // xmm6
__m128i v19; // xmm0
__m128i v20; // xmm1
evmone::Memory *v21; // rsi
char *v22; // rax
long long v23; // rax
long long v24; // rcx
__m128i v25; // xmm0
unsigned long long v26; // rcx
unsigned long long v27; // rax
__m128i v28; // xmm0
long long v29; // rdx
signed long long epi64; // rsi
bool v31; // zf
__m128i v32; // xmm0
long long v33; // rdx
unsigned long long v34; // rbp
long long v35; // rax
__m128i si128; // xmm0
long long v37; // rax
__m128i v39; // [rsp+0h] [rbp-1E8h] BYREF
__m128i v40; // [rsp+10h] [rbp-1D8h] BYREF
__m128i v41; // [rsp+20h] [rbp-1C8h] BYREF
__m128i v42; // [rsp+30h] [rbp-1B8h] BYREF
__m128i v43; // [rsp+40h] [rbp-1A8h] BYREF
long long v44; // [rsp+58h] [rbp-190h]
unsigned long long container; // [rsp+60h] [rbp-188h]
evmone::Memory *v46; // [rsp+68h] [rbp-180h]
_QWORD v47[9]; // [rsp+70h] [rbp-178h] BYREF
unsigned long long v48; // [rsp+B8h] [rbp-130h] BYREF
unsigned long long v49; // [rsp+C0h] [rbp-128h]
unsigned long long v50; // [rsp+C8h] [rbp-120h]
unsigned long long v51; // [rsp+D0h] [rbp-118h]
__int128 v52; // [rsp+E4h] [rbp-104h]
int v53; // [rsp+F4h] [rbp-F4h]
unsigned long long v54; // [rsp+F8h] [rbp-F0h]
unsigned long long v55; // [rsp+100h] [rbp-E8h]
__m128i v56; // [rsp+108h] [rbp-E0h]
__m128i v57; // [rsp+118h] [rbp-D0h]
__m128i v58; // [rsp+128h] [rbp-C0h]
__m128i v59; // [rsp+138h] [rbp-B0h]
long long v60; // [rsp+160h] [rbp-88h]
unsigned long long v61; // [rsp+168h] [rbp-80h]
_OWORD v62[7]; // [rsp+170h] [rbp-78h] BYREF
v7 = 11;
if ( (*(_BYTE *)(*(_QWORD *)(a3 + 32) + 4LL) & 1) == 0 )
{
v10 = *a1;
v11 = a1[1];
v12 = a1[-2].m128i_u64[0];
v13 = a1[-2].m128i_i64[1];
v14 = a1[-1].m128i_i64[0];
v15 = a1[-1].m128i_i64[1];
v16 = _mm_loadu_si128(a1 - 6);
v17 = _mm_loadu_si128(a1 - 5);
v18 = _mm_loadu_si128(a1 - 4);
v19 = _mm_loadu_si128(a1 - 3);
a1[-6] = 0LL;
a1[-5] = 0LL;
*(_QWORD *)(a3 + 80) = 0LL;
**(_BYTE **)(a3 + 72) = 0;
v20 = _mm_or_si128(v19, v18);
v21 = (evmone::Memory *)(a3 + 8);
if ( _mm_testz_si128(v20, v20) )
goto LABEL_9;
v7 = 3;
if ( !(_mm_extract_epi64(v19, 1) | v19.m128i_i64[0] | _mm_extract_epi64(v18, 1))
&& !HIDWORD(v18.m128i_i64[0])
&& !(v15 | v13 | v14 | HIDWORD(v12)) )
{
if ( v12 + v18.m128i_i64[0] > *(_QWORD *)(a3 + 16) )
{
v43 = v10;
v40 = v16;
v42 = v11;
v39 = v17;
v41 = v18;
v22 = evmone::grow_memory(a2, v21, (evmone::Memory *)(v12 + v18.m128i_i64[0]));
v18 = _mm_load_si128(&v41);
v17 = _mm_load_si128(&v39);
v11 = v42;
v16 = _mm_load_si128(&v40);
a2 = (evmone *)v22;
}
if ( (long long)a2 >= 0 )
{
LABEL_9:
v23 = *a4 + 2;
*a4 = v23;
v24 = *(_QWORD *)(a3 + 32);
v7 = 0;
if ( *(int *)(v24 + 8) <= 1023 )
{
v41 = v18;
v46 = v21;
v42 = v11;
v43 = v10;
v39 = v17;
v40 = v16;
v25 = _mm_or_si128(v17, v16);
if ( _mm_testz_si128(v25, v25) )
{
LABEL_15:
container = evmone::EOF1Header::get_container(
(_QWORD *)(*(_QWORD *)(a3 + 504) + 72LL),
*(_QWORD *)(a3 + 104),
*(_QWORD *)(a3 + 112),
*(unsigned __int8 *)(v23 - 1));
v44 = v33;
v34 = _mm_load_si128(&v41).m128i_u64[0];
memset(&v48, 0LL, 168LL);
LODWORD(v48) = 5;
v50 = (unsigned long long)a2 - (long long)a2 / 64;
if ( v34 )
{
v54 = *(_QWORD *)v46 + v12;
v55 = v34;
}
v35 = *(_QWORD *)(a3 + 32);
v53 = *(_DWORD *)(v35 + 40);
v52 = *(_OWORD *)(v35 + 24);
LODWORD(v49) = *(_DWORD *)(v35 + 8) + 1;
si128 = _mm_load_si128((const __m128i *)&xmmword_81000);
v58 = _mm_shuffle_epi8(_mm_load_si128(&v42), si128);
v59 = _mm_shuffle_epi8(_mm_load_si128(&v43), si128);
v56 = _mm_shuffle_epi8(_mm_load_si128(&v39), si128);
v57 = _mm_shuffle_epi8(_mm_load_si128(&v40), si128);
v60 = v44;
v61 = container;
(*(void ( **)(_OWORD *, _QWORD))(*(_QWORD *)(a3 + 48) + 64LL))(v62, *(_QWORD *)(a3 + 56));
qmemcpy(v47, v62, sizeof(v47));
*(_QWORD *)a3 += v47[2];
std::basic_string<unsigned char,evmc::byte_traits<unsigned char>,std::allocator<unsigned char>>::_M_replace(
a3 + 72,
0LL,
*(_QWORD *)(a3 + 80),
v47[3],
v47[4]);
if ( !LODWORD(v47[0]) )
{
v37 = _byteswap_ulong(v47[6]);
a1[-6] = _mm_shuffle_epi8(_mm_loadu_si128((const __m128i *)((char *)&v47[6] + 4)), (__m128i)xmmword_81000);
a1[-5].m128i_i64[0] = v37;
a1[-5].m128i_i64[1] = 0LL;
}
if ( v47[5] )
((void ( *)(_QWORD *))v47[5])(v47);
return 0;
}
LODWORD(v62[1]) = *(_DWORD *)(v24 + 40);
v62[0] = _mm_loadu_si128((const __m128i *)(v24 + 24));
(*(void ( **)(unsigned long long *, _QWORD, _OWORD *, long long, long long, long long, long long, long long, long long, long long, long long, long long, long long, long long, long long, long long))(*(_QWORD *)(a3 + 48) + 24LL))(
&v48,
*(_QWORD *)(a3 + 56),
v62,
v24,
v15,
a6,
v39.m128i_i64[0],
v39.m128i_i64[1],
v40.m128i_i64[0],
v40.m128i_i64[1],
v41.m128i_i64[0],
v41.m128i_i64[1],
v42.m128i_i64[0],
v42.m128i_i64[1],
v43.m128i_i64[0],
v43.m128i_i64[1]);
v26 = _byteswap_uint64(v49);
v27 = _byteswap_uint64(v48);
v28 = _mm_load_si128(&v39);
v29 = v28.m128i_i64[0];
epi64 = _mm_extract_epi64(v28, 1);
v31 = (v28.m128i_i64[0] ^ v26 | epi64 ^ v27) == 0;
v32 = _mm_load_si128(&v40);
if ( v31 )
{
v27 = _byteswap_uint64(v50);
v26 = _byteswap_uint64(v51);
v29 = v32.m128i_i64[0];
epi64 = _mm_extract_epi64(v32, 1);
}
if ( __PAIR128__(v27, v26) >= __PAIR128__(epi64, v29) )
{
v23 = *a4;
goto LABEL_15;
}
}
}
}
}
return v7;
}
| create_eof_impl<(evmone::Opcode)236>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x1b8
MOV RBX,RSI
MOV RAX,qword ptr [RDX + 0x20]
MOV EBP,0xb
TEST byte ptr [RAX + 0x4],0x1
JNZ 0x0014899b
MOV R13,RCX
MOV R15,RDX
MOV R14,RDI
MOVUPS XMM2,xmmword ptr [RDI]
MOVUPS XMM4,xmmword ptr [RDI + 0x10]
MOV R12,qword ptr [RDI + -0x20]
MOV RCX,qword ptr [RDI + -0x18]
MOV RAX,qword ptr [RDI + -0x10]
MOV R8,qword ptr [RDI + -0x8]
MOVDQU XMM3,xmmword ptr [RDI + -0x60]
MOVDQU XMM5,xmmword ptr [RDI + -0x50]
MOVDQU XMM6,xmmword ptr [RDI + -0x40]
MOVDQU XMM0,xmmword ptr [RDI + -0x30]
XORPS XMM1,XMM1
MOVUPS xmmword ptr [RDI + -0x60],XMM1
MOVUPS xmmword ptr [RDI + -0x50],XMM1
MOV qword ptr [RDX + 0x50],0x0
MOV RDX,qword ptr [RDX + 0x48]
MOV byte ptr [RDX],0x0
MOVDQA XMM1,XMM0
POR XMM1,XMM6
LEA RSI,[R15 + 0x8]
PTEST XMM1,XMM1
JZ 0x00148706
PEXTRQ RDX,XMM0,0x1
MOVQ RDI,XMM0
OR RDI,RDX
PEXTRQ RDX,XMM6,0x1
MOV EBP,0x3
OR RDX,RDI
JNZ 0x0014899b
MOVQ RDX,XMM6
MOV RDI,RDX
SHR RDI,0x20
JNZ 0x0014899b
OR RAX,RCX
OR RAX,R8
MOV RCX,R12
SHR RCX,0x20
OR RCX,RAX
JNZ 0x0014899b
ADD RDX,R12
CMP RDX,qword ptr [R15 + 0x10]
JBE 0x001486fd
MOV RDI,RBX
MOVAPS xmmword ptr [RSP + 0x40],XMM2
MOVDQA xmmword ptr [RSP + 0x10],XMM3
MOVAPS xmmword ptr [RSP + 0x30],XMM4
MOVDQA xmmword ptr [RSP],XMM5
MOV RBX,RSI
MOVDQA xmmword ptr [RSP + 0x20],XMM6
CALL 0x0013fbe5
MOVDQA XMM6,xmmword ptr [RSP + 0x20]
MOV RSI,RBX
MOVDQA XMM5,xmmword ptr [RSP]
MOVAPS XMM4,xmmword ptr [RSP + 0x30]
MOVDQA XMM3,xmmword ptr [RSP + 0x10]
MOVAPS XMM2,xmmword ptr [RSP + 0x40]
MOV RBX,RAX
LAB_001486fd:
TEST RBX,RBX
JS 0x0014899b
LAB_00148706:
MOV RAX,qword ptr [R13]
ADD RAX,0x2
MOV qword ptr [R13],RAX
MOV RCX,qword ptr [R15 + 0x20]
XOR EBP,EBP
CMP dword ptr [RCX + 0x8],0x3ff
JG 0x0014899b
MOVDQA xmmword ptr [RSP + 0x20],XMM6
MOV qword ptr [RSP + 0x68],RSI
MOVAPS xmmword ptr [RSP + 0x30],XMM4
MOVAPS xmmword ptr [RSP + 0x40],XMM2
MOVDQA xmmword ptr [RSP],XMM5
MOVDQA XMM0,XMM5
MOVDQA xmmword ptr [RSP + 0x10],XMM3
POR XMM0,XMM3
PTEST XMM0,XMM0
JZ 0x001487f2
MOV EAX,dword ptr [RCX + 0x28]
LEA RDX,[RSP + 0x170]
MOV dword ptr [RDX + 0x10],EAX
MOVDQU XMM0,xmmword ptr [RCX + 0x18]
MOVDQA xmmword ptr [RDX],XMM0
MOV RAX,qword ptr [R15 + 0x30]
MOV RSI,qword ptr [R15 + 0x38]
LAB_00148777:
LEA RDI,[RSP + 0xb8]
CALL qword ptr [RAX + 0x18]
LAB_00148782:
MOV RAX,qword ptr [RSP + 0xb8]
MOV RCX,qword ptr [RSP + 0xc0]
BSWAP RCX
BSWAP RAX
MOVDQA XMM0,xmmword ptr [RSP]
MOVQ RDX,XMM0
PEXTRQ RSI,XMM0,0x1
MOV RDI,RCX
XOR RDI,RDX
MOV R8,RAX
XOR R8,RSI
OR R8,RDI
MOVDQA XMM0,xmmword ptr [RSP + 0x10]
JNZ 0x001487e2
MOV RAX,qword ptr [RSP + 0xc8]
MOV RCX,qword ptr [RSP + 0xd0]
BSWAP RAX
BSWAP RCX
MOVQ RDX,XMM0
PEXTRQ RSI,XMM0,0x1
LAB_001487e2:
CMP RCX,RDX
SBB RAX,RSI
JC 0x0014899b
MOV RAX,qword ptr [R13]
LAB_001487f2:
MOVZX ECX,byte ptr [RAX + -0x1]
MOV RDI,qword ptr [R15 + 0x1f8]
ADD RDI,0x48
MOV RSI,qword ptr [R15 + 0x68]
MOV RDX,qword ptr [R15 + 0x70]
CALL 0x00140f78
MOV qword ptr [RSP + 0x60],RAX
MOV qword ptr [RSP + 0x58],RDX
MOVDQA XMM0,xmmword ptr [RSP + 0x20]
MOVQ RBP,XMM0
LEA R13,[RSP + 0xb8]
MOV EDX,0xa8
MOV RDI,R13
XOR ESI,ESI
CALL 0x00121120
MOV dword ptr [R13],0x5
LEA RAX,[RBX + 0x3f]
TEST RBX,RBX
CMOVNS RAX,RBX
SAR RAX,0x6
MOV RCX,RBX
SUB RCX,RAX
MOV qword ptr [R13 + 0x10],RCX
TEST RBP,RBP
JZ 0x00148878
MOV RAX,qword ptr [RSP + 0x68]
ADD R12,qword ptr [RAX]
MOV qword ptr [RSP + 0xf8],R12
MOV qword ptr [RSP + 0x100],RBP
LAB_00148878:
MOV RAX,qword ptr [R15 + 0x20]
MOV ECX,dword ptr [RAX + 0x28]
LEA RDX,[RSP + 0xb8]
MOV dword ptr [RDX + 0x3c],ECX
MOVUPS XMM0,xmmword ptr [RAX + 0x18]
MOVUPS xmmword ptr [RDX + 0x2c],XMM0
MOV EAX,dword ptr [RAX + 0x8]
INC EAX
MOV dword ptr [RDX + 0x8],EAX
MOVDQA XMM0,xmmword ptr [0x00181000]
MOVDQA XMM1,xmmword ptr [RSP + 0x30]
PSHUFB XMM1,XMM0
MOVDQU xmmword ptr [RDX + 0x70],XMM1
MOVDQA XMM1,xmmword ptr [RSP + 0x40]
PSHUFB XMM1,XMM0
MOVDQU xmmword ptr [RDX + 0x80],XMM1
MOVDQA XMM1,xmmword ptr [RSP]
PSHUFB XMM1,XMM0
MOVDQU xmmword ptr [RDX + 0x50],XMM1
MOVDQA XMM1,xmmword ptr [RSP + 0x10]
PSHUFB XMM1,XMM0
MOVDQU xmmword ptr [RDX + 0x60],XMM1
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RDX + 0xa8],RAX
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RDX + 0xb0],RAX
MOV RAX,qword ptr [R15 + 0x30]
MOV RSI,qword ptr [R15 + 0x38]
LAB_00148904:
LEA RDI,[RSP + 0x170]
CALL qword ptr [RAX + 0x40]
LEA RAX,[RSP + 0x70]
LEA RSI,[RSP + 0x170]
MOV ECX,0x9
MOV RDI,RAX
MOVSQ.REP RDI,RSI
SUB RBX,qword ptr [RSP + 0xc8]
ADD RBX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RAX + 0x10]
ADD qword ptr [R15],RCX
LEA RDI,[R15 + 0x48]
MOV RCX,qword ptr [RAX + 0x18]
MOV R8,qword ptr [RAX + 0x20]
MOV RDX,qword ptr [R15 + 0x50]
LAB_0014894a:
XOR ESI,ESI
CALL 0x0014934e
CMP dword ptr [RSP + 0x70],0x0
JNZ 0x00148985
MOV EAX,dword ptr [RSP + 0xa0]
MOVDQU XMM0,xmmword ptr [RSP + 0xa4]
PSHUFB XMM0,xmmword ptr [0x00181000]
BSWAP EAX
MOVDQU xmmword ptr [R14 + -0x60],XMM0
MOV qword ptr [R14 + -0x50],RAX
MOV qword ptr [R14 + -0x48],0x0
LAB_00148985:
MOV RAX,qword ptr [RSP + 0x98]
TEST RAX,RAX
JZ 0x00148999
LAB_00148992:
LEA RDI,[RSP + 0x70]
CALL RAX
LAB_00148999:
XOR EBP,EBP
LAB_0014899b:
MOV EAX,EBP
MOV RDX,RBX
ADD RSP,0x1b8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* evmone::Result evmone::instr::core::create_eof_impl<(evmone::Opcode)236>(evmone::StackTop, long,
evmone::ExecutionState&, unsigned char const*&) */
int1 [16]
evmone::instr::core::create_eof_impl<(evmone::Opcode)236>
(int1 (*param_1) [16],long param_2,long *param_3,long *param_4)
{
int1 auVar1 [16];
int1 auVar2 [16];
ulong uVar3;
long lVar4;
int1 auVar5 [16];
int1 auVar6 [16];
long lVar7;
ulong uVar8;
ulong uVar9;
long lVar10;
int8 uVar11;
int8 *puVar12;
int *piVar13;
byte bVar14;
int1 auVar15 [16];
ulong uVar16;
int1 auVar17 [16];
ulong local_1e8;
ulong uStack_1e0;
ulong local_1d8;
ulong uStack_1d0;
int local_178 [2];
long local_170;
long local_168;
uchar *local_160;
ulong local_158;
code *local_150;
uint local_148;
int1 local_144 [16];
uint local_130;
uint uStack_12c;
uint local_128;
uint uStack_124;
ulong local_120;
ulong local_118;
int8 local_104;
int8 uStack_fc;
int4 local_f4;
long local_f0;
ulong local_e8;
int1 local_e0 [16];
int1 local_d0 [16];
int1 local_c0 [16];
int1 local_b0 [16];
int8 local_88;
int8 local_80;
int8 local_78;
int8 uStack_70;
int4 local_68;
bVar14 = 0;
uVar11 = 0xb;
if ((*(byte *)(param_3[4] + 4) & 1) != 0) goto LAB_0014899b;
auVar6 = *param_1;
auVar5 = param_1[1];
uVar3 = *(ulong *)param_1[-2];
lVar10 = *(long *)(param_1[-2] + 8);
lVar7 = *(long *)param_1[-1];
lVar4 = *(long *)(param_1[-1] + 8);
auVar15 = param_1[-6];
auVar1 = param_1[-5];
auVar17 = param_1[-4];
auVar2 = param_1[-3];
*(int8 *)param_1[-6] = 0;
*(int8 *)(param_1[-6] + 8) = 0;
*(int8 *)param_1[-5] = 0;
*(int8 *)(param_1[-5] + 8) = 0;
param_3[10] = 0;
*(int1 *)param_3[9] = 0;
uVar16 = auVar17._0_8_;
if (auVar2 != (int1 [16])0x0 || auVar17 != (int1 [16])0x0) {
uVar11 = 3;
if (((auVar17._8_8_ != 0 || (auVar2._0_8_ != 0 || auVar2._8_8_ != 0)) || (uVar16 >> 0x20 != 0))
|| (uVar3 >> 0x20 != 0 || ((lVar7 != 0 || lVar10 != 0) || lVar4 != 0))) goto LAB_0014899b;
if ((ulong)param_3[2] < uVar16 + uVar3) {
param_2 = grow_memory(param_2,(Memory *)(param_3 + 1),uVar16 + uVar3);
}
if (param_2 < 0) goto LAB_0014899b;
}
lVar7 = *param_4 + 2;
*param_4 = lVar7;
lVar10 = param_3[4];
uVar11 = 0;
if (*(int *)(lVar10 + 8) < 0x400) {
if (auVar1 != (int1 [16])0x0 || auVar15 != (int1 [16])0x0) {
local_68 = *(int4 *)(lVar10 + 0x28);
local_78 = *(int8 *)(lVar10 + 0x18);
uStack_70 = *(int8 *)(lVar10 + 0x20);
/* try { // try from 00148777 to 00148781 has its CatchHandler @ 001489b4 */
(**(code **)(param_3[6] + 0x18))(&local_130,param_3[7]);
uVar9 = (ulong)(uStack_124 >> 0x18) | (((ulong)uStack_124 & 0xff0000) << 0x20) >> 0x28 |
(((ulong)uStack_124 & 0xff00) << 0x20) >> 0x18 |
(((ulong)uStack_124 & 0xff) << 0x20) >> 8 | ((ulong)local_128 & 0xff000000) << 8 |
((ulong)local_128 & 0xff0000) << 0x18 | ((ulong)local_128 & 0xff00) << 0x28 |
CONCAT44(uStack_124,local_128) << 0x38;
uVar8 = (ulong)(uStack_12c >> 0x18) | (((ulong)uStack_12c & 0xff0000) << 0x20) >> 0x28 |
(((ulong)uStack_12c & 0xff00) << 0x20) >> 0x18 |
(((ulong)uStack_12c & 0xff) << 0x20) >> 8 | ((ulong)local_130 & 0xff000000) << 8 |
((ulong)local_130 & 0xff0000) << 0x18 | ((ulong)local_130 & 0xff00) << 0x28 |
CONCAT44(uStack_12c,local_130) << 0x38;
local_1e8 = auVar1._0_8_;
uStack_1e0 = auVar1._8_8_;
local_1d8 = auVar15._0_8_;
uStack_1d0 = auVar15._8_8_;
if (uVar8 == uStack_1e0 && uVar9 == local_1e8) {
uVar8 = local_120 >> 0x38 | (local_120 & 0xff000000000000) >> 0x28 |
(local_120 & 0xff0000000000) >> 0x18 | (local_120 & 0xff00000000) >> 8 |
(local_120 & 0xff000000) << 8 | (local_120 & 0xff0000) << 0x18 |
(local_120 & 0xff00) << 0x28 | local_120 << 0x38;
uVar9 = local_118 >> 0x38 | (local_118 & 0xff000000000000) >> 0x28 |
(local_118 & 0xff0000000000) >> 0x18 | (local_118 & 0xff00000000) >> 8 |
(local_118 & 0xff000000) << 8 | (local_118 & 0xff0000) << 0x18 |
(local_118 & 0xff00) << 0x28 | local_118 << 0x38;
local_1e8 = local_1d8;
uStack_1e0 = uStack_1d0;
}
if (uVar8 < uStack_1e0 || uVar8 - uStack_1e0 < (ulong)(uVar9 < local_1e8)) goto LAB_0014899b;
lVar7 = *param_4;
}
auVar17 = EOF1Header::get_container
(param_3[0x3f] + 0x48,param_3[0xd],param_3[0xe],*(int1 *)(lVar7 + -1))
;
memset(&local_130,0,0xa8);
local_130 = 5;
lVar10 = param_2 + 0x3f;
if (-1 < param_2) {
lVar10 = param_2;
}
local_120 = param_2 - (lVar10 >> 6);
if (uVar16 != 0) {
local_f0 = uVar3 + param_3[1];
local_e8 = uVar16;
}
lVar10 = param_3[4];
local_f4 = *(int4 *)(lVar10 + 0x28);
local_104 = *(int8 *)(lVar10 + 0x18);
uStack_fc = *(int8 *)(lVar10 + 0x20);
local_128 = *(int *)(lVar10 + 8) + 1;
local_c0 = pshufb(auVar5,_DAT_00181000);
local_b0 = pshufb(auVar6,_DAT_00181000);
local_e0 = pshufb(auVar1,_DAT_00181000);
local_d0 = pshufb(auVar15,_DAT_00181000);
/* try { // try from 00148904 to 0014890e has its CatchHandler @ 001489b8 */
local_88 = auVar17._8_8_;
local_80 = auVar17._0_8_;
(**(code **)(param_3[6] + 0x40))(&local_78,param_3[7]);
puVar12 = &local_78;
piVar13 = local_178;
for (lVar10 = 9; lVar10 != 0; lVar10 = lVar10 + -1) {
*(int8 *)piVar13 = *puVar12;
puVar12 = puVar12 + (ulong)bVar14 * -2 + 1;
piVar13 = piVar13 + ((ulong)bVar14 * -2 + 1) * 2;
}
param_2 = (param_2 - local_120) + local_170;
*param_3 = *param_3 + local_168;
/* try { // try from 0014894a to 00148950 has its CatchHandler @ 001489b6 */
std::__cxx11::
basic_string<unsigned_char,evmc::byte_traits<unsigned_char>,std::allocator<unsigned_char>>::
_M_replace((basic_string<unsigned_char,evmc::byte_traits<unsigned_char>,std::allocator<unsigned_char>>
*)(param_3 + 9),0,param_3[10],local_160,local_158);
if (local_178[0] == 0) {
auVar15 = pshufb(local_144,_DAT_00181000);
param_1[-6] = auVar15;
*(ulong *)param_1[-5] =
(ulong)(local_148 >> 0x18 | (local_148 & 0xff0000) >> 8 | (local_148 & 0xff00) << 8 |
local_148 << 0x18);
*(int8 *)(param_1[-5] + 8) = 0;
}
if (local_150 != (code *)0x0) {
/* try { // try from 00148992 to 00148998 has its CatchHandler @ 001489b2 */
(*local_150)(local_178);
}
uVar11 = 0;
}
LAB_0014899b:
auVar15._8_8_ = param_2;
auVar15._0_8_ = uVar11;
return auVar15;
}
| |
44,775 | OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder::initializeControlVertexMap() | NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/irregularPatchBuilder.cpp | void
IrregularPatchBuilder::initializeControlVertexMap() {
//
// Add CV indices from the base face first -- be careful to ensure
// that a vector entry is made for each base face vertex in cases
// when repeated indices may occur:
Index const * baseVerts = getBaseFaceIndices();
int faceSize = _surface.GetFaceSize();
for (int i = 0; i < faceSize; ++i) {
addMeshControlVertex(baseVerts[i]);
if ((int)_controlVerts.size() == i) {
_controlVerts.push_back(baseVerts[i]);
}
}
//
// For each corner, add face-vertices to the map only for those
// incident faces that contribute to the control hull:
//
for (int corner = 0; corner < faceSize; ++corner) {
CornerHull & cHull = _cornerHullInfo[corner];
if (cHull.numControlFaces == 0) continue;
FaceVertex const & cTop = _surface.GetCornerTopology(corner);
FaceVertexSubset const & cSub = _surface.GetCornerSubset(corner);
// Special case of a single shared back-to-back face first:
if (cHull.singleSharedFace) {
int nextFace = cTop.GetFaceAfter(1);
addMeshControlVertices(getCornerFaceIndices(corner, nextFace),
cTop.GetFaceSize(nextFace));
continue;
}
// Follow the common pattern: faces after, boundary, faces before
// (no need to deal with isolated boundary vertex in this case)
if (cSub._numFacesAfter > 1) {
int nextFace = cTop.GetFaceAfter(1);
for (int j = 1; j < cSub._numFacesAfter; ++j) {
nextFace = cTop.GetFaceNext(nextFace);
addMeshControlVertices(getCornerFaceIndices(corner, nextFace),
cTop.GetFaceSize(nextFace));
}
}
if (cSub._numFacesBefore) {
int nextFace = cTop.GetFaceFirst(cSub);
for (int i = 0; i < cSub._numFacesBefore; ++i) {
addMeshControlVertices(getCornerFaceIndices(corner, nextFace),
cTop.GetFaceSize(nextFace));
nextFace = cTop.GetFaceNext(nextFace);
}
}
}
_numControlVerts = (int) _controlVerts.size();
} | O1 | cpp | OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder::initializeControlVertexMap():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rcx
movq 0x18(%rcx), %rdi
movswl 0x9a(%rdi), %esi
movswl 0x9c(%rdi), %edx
testl %edx, %edx
je 0x895c8
imull %esi, %edx
jmp 0x895d2
movq 0x60(%rdi), %rdx
movslq %esi, %rsi
movl (%rdx,%rsi,4), %edx
movslq 0x8(%rcx), %rsi
movq %rsi, 0x18(%rsp)
testq %rsi, %rsi
jle 0x89650
movq 0x8(%rax), %rax
movslq %edx, %rcx
leaq (%rax,%rcx,4), %r14
leaq 0x110(%rbx), %r15
xorl %r12d, %r12d
movl (%r14), %esi
movq %rbx, %rdi
callq 0x3afd0
movq 0x118(%rbx), %rsi
movq %rsi, %rax
subq 0x110(%rbx), %rax
shrq $0x2, %rax
movl %eax, %eax
cmpq %rax, %r12
jne 0x89642
cmpq 0x120(%rbx), %rsi
je 0x89637
movl (%r14), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x118(%rbx)
jmp 0x89642
movq %r15, %rdi
movq %r14, %rdx
callq 0x38ba0
incq %r12
addq $0x4, %r14
cmpq %r12, 0x18(%rsp)
jne 0x895f5
cmpl $0x0, 0x18(%rsp)
jle 0x89a25
xorl %eax, %eax
movq 0x28(%rbx), %rcx
movq %rax, 0x28(%rsp)
leaq (%rax,%rax,4), %rax
movq %rax, 0x10(%rsp)
cmpl $0x0, (%rcx,%rax,4)
je 0x89a12
movq 0x10(%rsp), %rax
leaq (%rcx,%rax,4), %rax
movq (%rbx), %rsi
movq (%rsi), %rdx
movq 0x28(%rsp), %rdi
imulq $0xe0, %rdi, %r9
movq 0x18(%rdx), %r8
addq %r9, %r8
testb $0x2, 0x10(%rax)
jne 0x896ef
leaq (%rdi,%rdi,2), %rax
shlq $0x2, %rax
addq 0x10(%rsi), %rax
movq %rax, 0x8(%rsp)
cmpw $0x2, 0x4(%rax)
movq %r8, 0x30(%rsp)
movq %r9, 0x20(%rsp)
jl 0x89898
movswl 0x9a(%r8), %eax
testb $0x1, 0x99(%r8)
jne 0x89792
incl %eax
movswl 0x2(%r8), %ecx
cltd
idivl %ecx
movl %edx, %r14d
jmp 0x897a1
movswl 0x9a(%r8), %eax
testb $0x1, 0x99(%r8)
jne 0x8970d
incl %eax
movswl 0x2(%r8), %edi
cltd
idivl %edi
jmp 0x8971b
cltq
movq 0xa8(%r8), %rdx
movswl 0x2(%rdx,%rax,4), %edx
movq 0x8(%rsi), %r14
movq 0x10(%rsp), %rax
movslq 0xc(%rcx,%rax,4), %rax
movswl 0x9c(%r8), %ecx
testl %ecx, %ecx
je 0x8973c
movl %edx, %esi
imull %ecx, %esi
jmp 0x89746
movq 0x60(%r8), %rsi
movslq %edx, %rdi
movl (%rsi,%rdi,4), %esi
testw %cx, %cx
jne 0x89759
movq 0x60(%r8), %rdi
movslq %edx, %rdx
movl 0x4(%rdi,%rdx,4), %ecx
subl (%rdi,%rdx,4), %ecx
cmpl $0x2, %ecx
jl 0x89a12
movslq %esi, %rdx
movl %ecx, %r15d
shlq $0x2, %rdx
leaq (%rdx,%rax,4), %rax
addq %rax, %r14
movl $0x1, %r12d
movl (%r14,%r12,4), %esi
movq %rbx, %rdi
callq 0x3afd0
incq %r12
cmpq %r12, %r15
jne 0x89779
jmp 0x89a12
cltq
movq 0xa8(%r8), %rcx
movswl 0x2(%rcx,%rax,4), %r14d
movq 0x8(%rsp), %rax
cmpw $0x2, 0x4(%rax)
jl 0x89898
movl $0x1, %r15d
movswl 0x98(%r8), %eax
btl $0x8, %eax
jb 0x897d6
movswl 0x2(%r8), %ecx
decl %ecx
cmpl %r14d, %ecx
jle 0x897ef
incl %r14d
jmp 0x897f7
movq 0xa8(%r8), %rax
leal 0x1(,%r14,2), %ecx
movslq %ecx, %rcx
movswl (%rax,%rcx,2), %r14d
jmp 0x897f7
andl $0x1, %eax
negl %eax
movl %eax, %r14d
movq (%rbx), %rax
movq (%rax), %rcx
movq 0x18(%rcx), %rdx
movswl 0x9c(%rdx,%r9), %ecx
testl %ecx, %ecx
je 0x89814
imull %r14d, %ecx
jmp 0x89821
addq %r9, %rdx
movq 0x60(%rdx), %rcx
movslq %r14d, %rdx
movl (%rcx,%rdx,4), %ecx
movswl 0x9c(%r8), %edx
testl %edx, %edx
jne 0x8983b
movq 0x60(%r8), %rsi
movslq %r14d, %rdi
movl 0x4(%rsi,%rdi,4), %edx
subl (%rsi,%rdi,4), %edx
cmpl $0x2, %edx
jl 0x89879
movq 0x28(%rbx), %rsi
movq 0x10(%rsp), %rdi
movslq 0xc(%rsi,%rdi,4), %rsi
movslq %ecx, %rcx
movl %edx, %ebp
shlq $0x2, %rcx
leaq (%rcx,%rsi,4), %r12
addq 0x8(%rax), %r12
movl $0x1, %r13d
movl (%r12,%r13,4), %esi
movq %rbx, %rdi
callq 0x3afd0
incq %r13
cmpq %r13, %rbp
jne 0x89865
incl %r15d
movq 0x8(%rsp), %rax
movswl 0x4(%rax), %eax
cmpl %eax, %r15d
movq 0x30(%rsp), %r8
movq 0x20(%rsp), %r9
jl 0x897b7
movq 0x8(%rsp), %rax
movswl 0x2(%rax), %eax
testl %eax, %eax
je 0x89a12
testw %ax, %ax
js 0x89a49
movswl 0x9a(%r8), %r14d
testb $0x1, 0x99(%r8)
jne 0x898da
subl %eax, %r14d
movswl 0x2(%r8), %ecx
addl %ecx, %r14d
movl %r14d, %eax
cltd
idivl %ecx
movl %edx, %r14d
jmp 0x89919
movslq %r14d, %rdx
movq 0xa8(%r8), %rcx
cmpw $0x1, %ax
je 0x898fe
movzwl %ax, %esi
cmpl $0x2, %esi
jne 0x89905
movswq (%rcx,%rdx,4), %rax
movswl (%rcx,%rax,4), %r14d
jmp 0x89919
movswl (%rcx,%rdx,4), %r14d
jmp 0x89919
incl %eax
addl %r14d, %r14d
movslq %r14d, %rdx
movswl (%rcx,%rdx,2), %r14d
decl %eax
cmpl $0x1, %eax
jg 0x89907
movq 0x8(%rsp), %rax
cmpw $0x0, 0x2(%rax)
jle 0x89a12
xorl %r15d, %r15d
movq (%rbx), %rax
movq (%rax), %rcx
movq 0x18(%rcx), %rdx
movswl 0x9c(%rdx,%r9), %ecx
testl %ecx, %ecx
je 0x89949
imull %r14d, %ecx
jmp 0x89956
addq %r9, %rdx
movq 0x60(%rdx), %rcx
movslq %r14d, %rdx
movl (%rcx,%rdx,4), %ecx
movswl 0x9c(%r8), %edx
testl %edx, %edx
jne 0x89970
movq 0x60(%r8), %rsi
movslq %r14d, %rdi
movl 0x4(%rsi,%rdi,4), %edx
subl (%rsi,%rdi,4), %edx
cmpl $0x2, %edx
jl 0x899ae
movq 0x28(%rbx), %rsi
movq 0x10(%rsp), %rdi
movslq 0xc(%rsi,%rdi,4), %rsi
movslq %ecx, %rcx
movl %edx, %ebp
shlq $0x2, %rcx
leaq (%rcx,%rsi,4), %r12
addq 0x8(%rax), %r12
movl $0x1, %r13d
movl (%r12,%r13,4), %esi
movq %rbx, %rdi
callq 0x3afd0
incq %r13
cmpq %r13, %rbp
jne 0x8999a
movq 0x30(%rsp), %r8
movswl 0x98(%r8), %eax
btl $0x8, %eax
jb 0x899d7
movswl 0x2(%r8), %ecx
decl %ecx
cmpl %r14d, %ecx
movq 0x20(%rsp), %r9
jle 0x899f5
incl %r14d
jmp 0x899fd
movq 0xa8(%r8), %rax
leal 0x1(,%r14,2), %ecx
movslq %ecx, %rcx
movswl (%rax,%rcx,2), %r14d
movq 0x20(%rsp), %r9
jmp 0x899fd
andl $0x1, %eax
negl %eax
movl %eax, %r14d
incl %r15d
movq 0x8(%rsp), %rax
movswl 0x2(%rax), %eax
cmpl %eax, %r15d
jl 0x8992c
movq 0x28(%rsp), %rax
incq %rax
cmpq 0x18(%rsp), %rax
jne 0x8965d
movq 0x118(%rbx), %rax
subq 0x110(%rbx), %rax
shrq $0x2, %rax
movl %eax, 0x14(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3465f(%rip), %rdi # 0xbe0af
leaq 0x35041(%rip), %rsi # 0xbea98
leaq 0x346ca(%rip), %rcx # 0xbe128
movl $0x120, %edx # imm = 0x120
callq 0x39560
| _ZN10OpenSubdiv6v3_6_03Bfr21IrregularPatchBuilder26initializeControlVertexMapEv:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov rbx, rdi
mov rax, [rdi]
mov rcx, [rax]
mov rdi, [rcx+18h]
movsx esi, word ptr [rdi+9Ah]
movsx edx, word ptr [rdi+9Ch]
test edx, edx
jz short loc_895C8
imul edx, esi
jmp short loc_895D2
loc_895C8:
mov rdx, [rdi+60h]
movsxd rsi, esi
mov edx, [rdx+rsi*4]
loc_895D2:
movsxd rsi, dword ptr [rcx+8]
mov [rsp+68h+var_50], rsi
test rsi, rsi
jle short loc_89650
mov rax, [rax+8]
movsxd rcx, edx
lea r14, [rax+rcx*4]
lea r15, [rbx+110h]
xor r12d, r12d
loc_895F5:
mov esi, [r14]; int
mov rdi, rbx; this
call __ZN10OpenSubdiv6v3_6_03Bfr21IrregularPatchBuilder20addMeshControlVertexEi; OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder::addMeshControlVertex(int)
mov rsi, [rbx+118h]
mov rax, rsi
sub rax, [rbx+110h]
shr rax, 2
mov eax, eax
cmp r12, rax
jnz short loc_89642
cmp rsi, [rbx+120h]
jz short loc_89637
mov eax, [r14]
mov [rsi], eax
add rsi, 4
mov [rbx+118h], rsi
jmp short loc_89642
loc_89637:
mov rdi, r15
mov rdx, r14
call __ZNSt6vectorIiSaIiEE17_M_realloc_insertIJRKiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_; std::vector<int>::_M_realloc_insert<int const&>(__gnu_cxx::__normal_iterator<int *,std::vector<int>>,int const&)
loc_89642:
inc r12
add r14, 4
cmp [rsp+68h+var_50], r12
jnz short loc_895F5
loc_89650:
cmp dword ptr [rsp+68h+var_50], 0
jle loc_89A25
xor eax, eax
loc_8965D:
mov rcx, [rbx+28h]
mov [rsp+68h+var_40], rax
lea rax, [rax+rax*4]
mov [rsp+68h+var_58], rax
cmp dword ptr [rcx+rax*4], 0
jz loc_89A12
mov rax, [rsp+68h+var_58]
lea rax, [rcx+rax*4]
mov rsi, [rbx]
mov rdx, [rsi]
mov rdi, [rsp+68h+var_40]
imul r9, rdi, 0E0h
mov r8, [rdx+18h]
add r8, r9
test byte ptr [rax+10h], 2
jnz short loc_896EF
lea rax, [rdi+rdi*2]
shl rax, 2
add rax, [rsi+10h]
mov [rsp+68h+var_60], rax
cmp word ptr [rax+4], 2
mov [rsp+68h+var_38], r8
mov [rsp+68h+var_48], r9
jl loc_89898
movsx eax, word ptr [r8+9Ah]
test byte ptr [r8+99h], 1
jnz loc_89792
inc eax
movsx ecx, word ptr [r8+2]
cdq
idiv ecx
mov r14d, edx
jmp loc_897A1
loc_896EF:
movsx eax, word ptr [r8+9Ah]
test byte ptr [r8+99h], 1
jnz short loc_8970D
inc eax
movsx edi, word ptr [r8+2]
cdq
idiv edi
jmp short loc_8971B
loc_8970D:
cdqe
mov rdx, [r8+0A8h]
movsx edx, word ptr [rdx+rax*4+2]
loc_8971B:
mov r14, [rsi+8]
mov rax, [rsp+68h+var_58]
movsxd rax, dword ptr [rcx+rax*4+0Ch]
movsx ecx, word ptr [r8+9Ch]
test ecx, ecx
jz short loc_8973C
mov esi, edx
imul esi, ecx
jmp short loc_89746
loc_8973C:
mov rsi, [r8+60h]
movsxd rdi, edx
mov esi, [rsi+rdi*4]
loc_89746:
test cx, cx
jnz short loc_89759
mov rdi, [r8+60h]
movsxd rdx, edx
mov ecx, [rdi+rdx*4+4]
sub ecx, [rdi+rdx*4]
loc_89759:
cmp ecx, 2
jl loc_89A12
movsxd rdx, esi
mov r15d, ecx
shl rdx, 2
lea rax, [rdx+rax*4]
add r14, rax
mov r12d, 1
loc_89779:
mov esi, [r14+r12*4]; int
mov rdi, rbx; this
call __ZN10OpenSubdiv6v3_6_03Bfr21IrregularPatchBuilder20addMeshControlVertexEi; OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder::addMeshControlVertex(int)
inc r12
cmp r15, r12
jnz short loc_89779
jmp loc_89A12
loc_89792:
cdqe
mov rcx, [r8+0A8h]
movsx r14d, word ptr [rcx+rax*4+2]
loc_897A1:
mov rax, [rsp+68h+var_60]
cmp word ptr [rax+4], 2
jl loc_89898
mov r15d, 1
loc_897B7:
movsx eax, word ptr [r8+98h]
bt eax, 8
jb short loc_897D6
movsx ecx, word ptr [r8+2]
dec ecx
cmp ecx, r14d
jle short loc_897EF
inc r14d
jmp short loc_897F7
loc_897D6:
mov rax, [r8+0A8h]
lea ecx, ds:1[r14*2]
movsxd rcx, ecx
movsx r14d, word ptr [rax+rcx*2]
jmp short loc_897F7
loc_897EF:
and eax, 1
neg eax
mov r14d, eax
loc_897F7:
mov rax, [rbx]
mov rcx, [rax]
mov rdx, [rcx+18h]
movsx ecx, word ptr [rdx+r9+9Ch]
test ecx, ecx
jz short loc_89814
imul ecx, r14d
jmp short loc_89821
loc_89814:
add rdx, r9
mov rcx, [rdx+60h]
movsxd rdx, r14d
mov ecx, [rcx+rdx*4]
loc_89821:
movsx edx, word ptr [r8+9Ch]
test edx, edx
jnz short loc_8983B
mov rsi, [r8+60h]
movsxd rdi, r14d
mov edx, [rsi+rdi*4+4]
sub edx, [rsi+rdi*4]
loc_8983B:
cmp edx, 2
jl short loc_89879
mov rsi, [rbx+28h]
mov rdi, [rsp+68h+var_58]
movsxd rsi, dword ptr [rsi+rdi*4+0Ch]
movsxd rcx, ecx
mov ebp, edx
shl rcx, 2
lea r12, [rcx+rsi*4]
add r12, [rax+8]
mov r13d, 1
loc_89865:
mov esi, [r12+r13*4]; int
mov rdi, rbx; this
call __ZN10OpenSubdiv6v3_6_03Bfr21IrregularPatchBuilder20addMeshControlVertexEi; OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder::addMeshControlVertex(int)
inc r13
cmp rbp, r13
jnz short loc_89865
loc_89879:
inc r15d
mov rax, [rsp+68h+var_60]
movsx eax, word ptr [rax+4]
cmp r15d, eax
mov r8, [rsp+68h+var_38]
mov r9, [rsp+68h+var_48]
jl loc_897B7
loc_89898:
mov rax, [rsp+68h+var_60]
movsx eax, word ptr [rax+2]
test eax, eax
jz loc_89A12
test ax, ax
js loc_89A49
movsx r14d, word ptr [r8+9Ah]
test byte ptr [r8+99h], 1
jnz short loc_898DA
sub r14d, eax
movsx ecx, word ptr [r8+2]
add r14d, ecx
mov eax, r14d
cdq
idiv ecx
mov r14d, edx
jmp short loc_89919
loc_898DA:
movsxd rdx, r14d
mov rcx, [r8+0A8h]
cmp ax, 1
jz short loc_898FE
movzx esi, ax
cmp esi, 2
jnz short loc_89905
movsx rax, word ptr [rcx+rdx*4]
movsx r14d, word ptr [rcx+rax*4]
jmp short loc_89919
loc_898FE:
movsx r14d, word ptr [rcx+rdx*4]
jmp short loc_89919
loc_89905:
inc eax
loc_89907:
add r14d, r14d
movsxd rdx, r14d
movsx r14d, word ptr [rcx+rdx*2]
dec eax
cmp eax, 1
jg short loc_89907
loc_89919:
mov rax, [rsp+68h+var_60]
cmp word ptr [rax+2], 0
jle loc_89A12
xor r15d, r15d
loc_8992C:
mov rax, [rbx]
mov rcx, [rax]
mov rdx, [rcx+18h]
movsx ecx, word ptr [rdx+r9+9Ch]
test ecx, ecx
jz short loc_89949
imul ecx, r14d
jmp short loc_89956
loc_89949:
add rdx, r9
mov rcx, [rdx+60h]
movsxd rdx, r14d
mov ecx, [rcx+rdx*4]
loc_89956:
movsx edx, word ptr [r8+9Ch]
test edx, edx
jnz short loc_89970
mov rsi, [r8+60h]
movsxd rdi, r14d
mov edx, [rsi+rdi*4+4]
sub edx, [rsi+rdi*4]
loc_89970:
cmp edx, 2
jl short loc_899AE
mov rsi, [rbx+28h]
mov rdi, [rsp+68h+var_58]
movsxd rsi, dword ptr [rsi+rdi*4+0Ch]
movsxd rcx, ecx
mov ebp, edx
shl rcx, 2
lea r12, [rcx+rsi*4]
add r12, [rax+8]
mov r13d, 1
loc_8999A:
mov esi, [r12+r13*4]; int
mov rdi, rbx; this
call __ZN10OpenSubdiv6v3_6_03Bfr21IrregularPatchBuilder20addMeshControlVertexEi; OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder::addMeshControlVertex(int)
inc r13
cmp rbp, r13
jnz short loc_8999A
loc_899AE:
mov r8, [rsp+68h+var_38]
movsx eax, word ptr [r8+98h]
bt eax, 8
jb short loc_899D7
movsx ecx, word ptr [r8+2]
dec ecx
cmp ecx, r14d
mov r9, [rsp+68h+var_48]
jle short loc_899F5
inc r14d
jmp short loc_899FD
loc_899D7:
mov rax, [r8+0A8h]
lea ecx, ds:1[r14*2]
movsxd rcx, ecx
movsx r14d, word ptr [rax+rcx*2]
mov r9, [rsp+68h+var_48]
jmp short loc_899FD
loc_899F5:
and eax, 1
neg eax
mov r14d, eax
loc_899FD:
inc r15d
mov rax, [rsp+68h+var_60]
movsx eax, word ptr [rax+2]
cmp r15d, eax
jl loc_8992C
loc_89A12:
mov rax, [rsp+68h+var_40]
inc rax
cmp rax, [rsp+68h+var_50]
jnz loc_8965D
loc_89A25:
mov rax, [rbx+118h]
sub rax, [rbx+110h]
shr rax, 2
mov [rbx+14h], eax
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_89A49:
lea rdi, aStep0; "step >= 0"
lea rsi, aWorkspaceLlm4b_36; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aIntOpensubdivV_19; "int OpenSubdiv::v3_6_0::Bfr::FaceVertex"...
mov edx, 120h
call ___assert_fail
| unsigned long long OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder::initializeControlVertexMap(int **this)
{
int *v2; // rax
long long v3; // rcx
long long v4; // rdi
int v5; // edx
int *v6; // r14
long long i; // r12
int *v8; // rsi
long long v9; // rax
int *v10; // rcx
int *v11; // rsi
long long v12; // r9
long long v13; // r8
int v14; // r14d
int v15; // edx
long long v16; // r14
long long v17; // rax
int v18; // ecx
int v19; // esi
long long v20; // r15
long long v21; // r14
long long j; // r12
int v23; // r15d
__int16 v24; // ax
long long v25; // rdx
int v26; // ecx
int v27; // edx
long long v28; // rbp
long long v29; // r12
long long k; // r13
int v31; // eax
int v32; // r14d
long long v33; // rcx
int v34; // eax
int v35; // r15d
long long v36; // rdx
int v37; // ecx
int v38; // edx
long long v39; // rbp
long long v40; // r12
long long m; // r13
__int16 v42; // ax
unsigned long long result; // rax
long long v44; // [rsp+8h] [rbp-60h]
long long v45; // [rsp+10h] [rbp-58h]
long long v46; // [rsp+18h] [rbp-50h]
long long v47; // [rsp+20h] [rbp-48h]
long long v48; // [rsp+28h] [rbp-40h]
long long v49; // [rsp+30h] [rbp-38h]
v2 = *this;
v3 = *(_QWORD *)*this;
v4 = *(_QWORD *)(v3 + 24);
if ( *(_WORD *)(v4 + 156) )
v5 = *(__int16 *)(v4 + 154) * *(__int16 *)(v4 + 156);
else
v5 = *(_DWORD *)(*(_QWORD *)(v4 + 96) + 4LL * *(__int16 *)(v4 + 154));
v46 = *(int *)(v3 + 8);
if ( v46 > 0 )
{
v6 = (int *)(*((_QWORD *)v2 + 1) + 4LL * v5);
for ( i = 0LL; i != v46; ++i )
{
OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder::addMeshControlVertex(
(OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder *)this,
*v6);
v8 = this[35];
if ( i == (unsigned int)((unsigned long long)((char *)v8 - (char *)this[34]) >> 2) )
{
if ( v8 == this[36] )
{
std::vector<int>::_M_realloc_insert<int const&>(this + 34, v8, v6);
}
else
{
*v8 = *v6;
this[35] = v8 + 1;
}
}
++v6;
}
}
if ( (int)v46 > 0 )
{
v9 = 0LL;
do
{
v10 = this[5];
v48 = v9;
v45 = 5 * v9;
if ( v10[5 * v9] )
{
v11 = *this;
v12 = 224 * v9;
v13 = 224 * v9 + *(_QWORD *)(*(_QWORD *)*this + 24LL);
if ( (v10[5 * v9 + 4] & 2) != 0 )
{
if ( (*(_BYTE *)(v13 + 153) & 1) != 0 )
v15 = *(__int16 *)(*(_QWORD *)(v13 + 168) + 4LL * *(__int16 *)(v13 + 154) + 2);
else
v15 = (*(__int16 *)(v13 + 154) + 1) % *(__int16 *)(v13 + 2);
v16 = *((_QWORD *)v11 + 1);
v17 = v10[5 * v9 + 3];
v18 = *(__int16 *)(v13 + 156);
if ( *(_WORD *)(v13 + 156) )
v19 = v18 * v15;
else
v19 = *(_DWORD *)(*(_QWORD *)(v13 + 96) + 4LL * v15);
if ( !(_WORD)v18 )
v18 = *(_DWORD *)(*(_QWORD *)(v13 + 96) + 4LL * v15 + 4) - *(_DWORD *)(*(_QWORD *)(v13 + 96) + 4LL * v15);
if ( v18 >= 2 )
{
v20 = (unsigned int)v18;
v21 = 4LL * v19 + 4 * v17 + v16;
for ( j = 1LL; j != v20; ++j )
OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder::addMeshControlVertex(
(OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder *)this,
*(_DWORD *)(v21 + 4 * j));
}
}
else
{
v44 = *((_QWORD *)v11 + 2) + 12 * v9;
v49 = 224 * v9 + *(_QWORD *)(*(_QWORD *)*this + 24LL);
v47 = 224 * v9;
if ( *(__int16 *)(v44 + 4) >= 2 )
{
v14 = (*(_BYTE *)(v13 + 153) & 1) != 0
? *(__int16 *)(*(_QWORD *)(v13 + 168) + 4LL * *(__int16 *)(v13 + 154) + 2)
: (*(__int16 *)(v13 + 154) + 1) % *(__int16 *)(v13 + 2);
if ( *(__int16 *)(v44 + 4) >= 2 )
{
v23 = 1;
do
{
v24 = *(_WORD *)(v13 + 152);
if ( (v24 & 0x100) != 0 )
{
v14 = *(__int16 *)(*(_QWORD *)(v13 + 168) + 2LL * (2 * v14 + 1));
}
else if ( *(__int16 *)(v13 + 2) - 1 <= v14 )
{
v14 = -(v24 & 1);
}
else
{
++v14;
}
v25 = *(_QWORD *)(*(_QWORD *)*this + 24LL);
if ( *(_WORD *)(v25 + v12 + 156) )
v26 = v14 * *(__int16 *)(v25 + v12 + 156);
else
v26 = *(_DWORD *)(*(_QWORD *)(v12 + v25 + 96) + 4LL * v14);
v27 = *(__int16 *)(v13 + 156);
if ( !*(_WORD *)(v13 + 156) )
v27 = *(_DWORD *)(*(_QWORD *)(v13 + 96) + 4LL * v14 + 4)
- *(_DWORD *)(*(_QWORD *)(v13 + 96) + 4LL * v14);
if ( v27 >= 2 )
{
v28 = (unsigned int)v27;
v29 = *((_QWORD *)*this + 1) + 4LL * v26 + 4LL * this[5][v45 + 3];
for ( k = 1LL; k != v28; ++k )
OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder::addMeshControlVertex(
(OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder *)this,
*(_DWORD *)(v29 + 4 * k));
}
++v23;
v13 = v49;
v12 = v47;
}
while ( v23 < *(__int16 *)(v44 + 4) );
}
}
v31 = *(__int16 *)(v44 + 2);
if ( *(_WORD *)(v44 + 2) )
{
if ( (v31 & 0x8000u) != 0 )
__assert_fail(
"step >= 0",
"/workspace/llm4binary/github/2025_star3/NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/../bfr/../bfr/../bfr/../bfr/faceVertex.h",
288LL,
"int OpenSubdiv::v3_6_0::Bfr::FaceVertex::GetFaceBefore(int) const");
v32 = *(__int16 *)(v13 + 154);
if ( (*(_BYTE *)(v13 + 153) & 1) != 0 )
{
v33 = *(_QWORD *)(v13 + 168);
if ( (_WORD)v31 == 1 )
{
v32 = *(__int16 *)(v33 + 4LL * *(__int16 *)(v13 + 154));
}
else if ( (unsigned __int16)v31 == 2 )
{
v32 = *(__int16 *)(v33 + 4LL * *(__int16 *)(v33 + 4LL * *(__int16 *)(v13 + 154)));
}
else
{
v34 = v31 + 1;
do
{
v32 = *(__int16 *)(v33 + 4LL * v32);
--v34;
}
while ( v34 > 1 );
}
}
else
{
v32 = (*(__int16 *)(v13 + 2) + v32 - v31) % *(__int16 *)(v13 + 2);
}
if ( *(__int16 *)(v44 + 2) > 0 )
{
v35 = 0;
do
{
v36 = *(_QWORD *)(*(_QWORD *)*this + 24LL);
if ( *(_WORD *)(v36 + v12 + 156) )
v37 = v32 * *(__int16 *)(v36 + v12 + 156);
else
v37 = *(_DWORD *)(*(_QWORD *)(v12 + v36 + 96) + 4LL * v32);
v38 = *(__int16 *)(v13 + 156);
if ( !*(_WORD *)(v13 + 156) )
v38 = *(_DWORD *)(*(_QWORD *)(v13 + 96) + 4LL * v32 + 4)
- *(_DWORD *)(*(_QWORD *)(v13 + 96) + 4LL * v32);
if ( v38 >= 2 )
{
v39 = (unsigned int)v38;
v40 = *((_QWORD *)*this + 1) + 4LL * v37 + 4LL * this[5][v45 + 3];
for ( m = 1LL; m != v39; ++m )
OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder::addMeshControlVertex(
(OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder *)this,
*(_DWORD *)(v40 + 4 * m));
}
v13 = v49;
v42 = *(_WORD *)(v49 + 152);
if ( (v42 & 0x100) != 0 )
{
v32 = *(__int16 *)(*(_QWORD *)(v49 + 168) + 2LL * (2 * v32 + 1));
v12 = v47;
}
else
{
v12 = v47;
if ( *(__int16 *)(v49 + 2) - 1 <= v32 )
v32 = -(v42 & 1);
else
++v32;
}
++v35;
}
while ( v35 < *(__int16 *)(v44 + 2) );
}
}
}
}
v9 = v48 + 1;
}
while ( v48 + 1 != v46 );
}
result = (unsigned long long)((char *)this[35] - (char *)this[34]) >> 2;
*((_DWORD *)this + 5) = result;
return result;
}
| initializeControlVertexMap:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV RBX,RDI
MOV RAX,qword ptr [RDI]
MOV RCX,qword ptr [RAX]
MOV RDI,qword ptr [RCX + 0x18]
MOVSX ESI,word ptr [RDI + 0x9a]
MOVSX EDX,word ptr [RDI + 0x9c]
TEST EDX,EDX
JZ 0x001895c8
IMUL EDX,ESI
JMP 0x001895d2
LAB_001895c8:
MOV RDX,qword ptr [RDI + 0x60]
MOVSXD RSI,ESI
MOV EDX,dword ptr [RDX + RSI*0x4]
LAB_001895d2:
MOVSXD RSI,dword ptr [RCX + 0x8]
MOV qword ptr [RSP + 0x18],RSI
TEST RSI,RSI
JLE 0x00189650
MOV RAX,qword ptr [RAX + 0x8]
MOVSXD RCX,EDX
LEA R14,[RAX + RCX*0x4]
LEA R15,[RBX + 0x110]
XOR R12D,R12D
LAB_001895f5:
MOV ESI,dword ptr [R14]
MOV RDI,RBX
CALL 0x0013afd0
MOV RSI,qword ptr [RBX + 0x118]
MOV RAX,RSI
SUB RAX,qword ptr [RBX + 0x110]
SHR RAX,0x2
MOV EAX,EAX
CMP R12,RAX
JNZ 0x00189642
CMP RSI,qword ptr [RBX + 0x120]
JZ 0x00189637
MOV EAX,dword ptr [R14]
MOV dword ptr [RSI],EAX
ADD RSI,0x4
MOV qword ptr [RBX + 0x118],RSI
JMP 0x00189642
LAB_00189637:
MOV RDI,R15
MOV RDX,R14
CALL 0x00138ba0
LAB_00189642:
INC R12
ADD R14,0x4
CMP qword ptr [RSP + 0x18],R12
JNZ 0x001895f5
LAB_00189650:
CMP dword ptr [RSP + 0x18],0x0
JLE 0x00189a25
XOR EAX,EAX
LAB_0018965d:
MOV RCX,qword ptr [RBX + 0x28]
MOV qword ptr [RSP + 0x28],RAX
LEA RAX,[RAX + RAX*0x4]
MOV qword ptr [RSP + 0x10],RAX
CMP dword ptr [RCX + RAX*0x4],0x0
JZ 0x00189a12
MOV RAX,qword ptr [RSP + 0x10]
LEA RAX,[RCX + RAX*0x4]
MOV RSI,qword ptr [RBX]
MOV RDX,qword ptr [RSI]
MOV RDI,qword ptr [RSP + 0x28]
IMUL R9,RDI,0xe0
MOV R8,qword ptr [RDX + 0x18]
ADD R8,R9
TEST byte ptr [RAX + 0x10],0x2
JNZ 0x001896ef
LEA RAX,[RDI + RDI*0x2]
SHL RAX,0x2
ADD RAX,qword ptr [RSI + 0x10]
MOV qword ptr [RSP + 0x8],RAX
CMP word ptr [RAX + 0x4],0x2
MOV qword ptr [RSP + 0x30],R8
MOV qword ptr [RSP + 0x20],R9
JL 0x00189898
MOVSX EAX,word ptr [R8 + 0x9a]
TEST byte ptr [R8 + 0x99],0x1
JNZ 0x00189792
INC EAX
MOVSX ECX,word ptr [R8 + 0x2]
CDQ
IDIV ECX
MOV R14D,EDX
JMP 0x001897a1
LAB_001896ef:
MOVSX EAX,word ptr [R8 + 0x9a]
TEST byte ptr [R8 + 0x99],0x1
JNZ 0x0018970d
INC EAX
MOVSX EDI,word ptr [R8 + 0x2]
CDQ
IDIV EDI
JMP 0x0018971b
LAB_0018970d:
CDQE
MOV RDX,qword ptr [R8 + 0xa8]
MOVSX EDX,word ptr [RDX + RAX*0x4 + 0x2]
LAB_0018971b:
MOV R14,qword ptr [RSI + 0x8]
MOV RAX,qword ptr [RSP + 0x10]
MOVSXD RAX,dword ptr [RCX + RAX*0x4 + 0xc]
MOVSX ECX,word ptr [R8 + 0x9c]
TEST ECX,ECX
JZ 0x0018973c
MOV ESI,EDX
IMUL ESI,ECX
JMP 0x00189746
LAB_0018973c:
MOV RSI,qword ptr [R8 + 0x60]
MOVSXD RDI,EDX
MOV ESI,dword ptr [RSI + RDI*0x4]
LAB_00189746:
TEST CX,CX
JNZ 0x00189759
MOV RDI,qword ptr [R8 + 0x60]
MOVSXD RDX,EDX
MOV ECX,dword ptr [RDI + RDX*0x4 + 0x4]
SUB ECX,dword ptr [RDI + RDX*0x4]
LAB_00189759:
CMP ECX,0x2
JL 0x00189a12
MOVSXD RDX,ESI
MOV R15D,ECX
SHL RDX,0x2
LEA RAX,[RDX + RAX*0x4]
ADD R14,RAX
MOV R12D,0x1
LAB_00189779:
MOV ESI,dword ptr [R14 + R12*0x4]
MOV RDI,RBX
CALL 0x0013afd0
INC R12
CMP R15,R12
JNZ 0x00189779
JMP 0x00189a12
LAB_00189792:
CDQE
MOV RCX,qword ptr [R8 + 0xa8]
MOVSX R14D,word ptr [RCX + RAX*0x4 + 0x2]
LAB_001897a1:
MOV RAX,qword ptr [RSP + 0x8]
CMP word ptr [RAX + 0x4],0x2
JL 0x00189898
MOV R15D,0x1
LAB_001897b7:
MOVSX EAX,word ptr [R8 + 0x98]
BT EAX,0x8
JC 0x001897d6
MOVSX ECX,word ptr [R8 + 0x2]
DEC ECX
CMP ECX,R14D
JLE 0x001897ef
INC R14D
JMP 0x001897f7
LAB_001897d6:
MOV RAX,qword ptr [R8 + 0xa8]
LEA ECX,[0x1 + R14*0x2]
MOVSXD RCX,ECX
MOVSX R14D,word ptr [RAX + RCX*0x2]
JMP 0x001897f7
LAB_001897ef:
AND EAX,0x1
NEG EAX
MOV R14D,EAX
LAB_001897f7:
MOV RAX,qword ptr [RBX]
MOV RCX,qword ptr [RAX]
MOV RDX,qword ptr [RCX + 0x18]
MOVSX ECX,word ptr [RDX + R9*0x1 + 0x9c]
TEST ECX,ECX
JZ 0x00189814
IMUL ECX,R14D
JMP 0x00189821
LAB_00189814:
ADD RDX,R9
MOV RCX,qword ptr [RDX + 0x60]
MOVSXD RDX,R14D
MOV ECX,dword ptr [RCX + RDX*0x4]
LAB_00189821:
MOVSX EDX,word ptr [R8 + 0x9c]
TEST EDX,EDX
JNZ 0x0018983b
MOV RSI,qword ptr [R8 + 0x60]
MOVSXD RDI,R14D
MOV EDX,dword ptr [RSI + RDI*0x4 + 0x4]
SUB EDX,dword ptr [RSI + RDI*0x4]
LAB_0018983b:
CMP EDX,0x2
JL 0x00189879
MOV RSI,qword ptr [RBX + 0x28]
MOV RDI,qword ptr [RSP + 0x10]
MOVSXD RSI,dword ptr [RSI + RDI*0x4 + 0xc]
MOVSXD RCX,ECX
MOV EBP,EDX
SHL RCX,0x2
LEA R12,[RCX + RSI*0x4]
ADD R12,qword ptr [RAX + 0x8]
MOV R13D,0x1
LAB_00189865:
MOV ESI,dword ptr [R12 + R13*0x4]
MOV RDI,RBX
CALL 0x0013afd0
INC R13
CMP RBP,R13
JNZ 0x00189865
LAB_00189879:
INC R15D
MOV RAX,qword ptr [RSP + 0x8]
MOVSX EAX,word ptr [RAX + 0x4]
CMP R15D,EAX
MOV R8,qword ptr [RSP + 0x30]
MOV R9,qword ptr [RSP + 0x20]
JL 0x001897b7
LAB_00189898:
MOV RAX,qword ptr [RSP + 0x8]
MOVSX EAX,word ptr [RAX + 0x2]
TEST EAX,EAX
JZ 0x00189a12
TEST AX,AX
JS 0x00189a49
MOVSX R14D,word ptr [R8 + 0x9a]
TEST byte ptr [R8 + 0x99],0x1
JNZ 0x001898da
SUB R14D,EAX
MOVSX ECX,word ptr [R8 + 0x2]
ADD R14D,ECX
MOV EAX,R14D
CDQ
IDIV ECX
MOV R14D,EDX
JMP 0x00189919
LAB_001898da:
MOVSXD RDX,R14D
MOV RCX,qword ptr [R8 + 0xa8]
CMP AX,0x1
JZ 0x001898fe
MOVZX ESI,AX
CMP ESI,0x2
JNZ 0x00189905
MOVSX RAX,word ptr [RCX + RDX*0x4]
MOVSX R14D,word ptr [RCX + RAX*0x4]
JMP 0x00189919
LAB_001898fe:
MOVSX R14D,word ptr [RCX + RDX*0x4]
JMP 0x00189919
LAB_00189905:
INC EAX
LAB_00189907:
ADD R14D,R14D
MOVSXD RDX,R14D
MOVSX R14D,word ptr [RCX + RDX*0x2]
DEC EAX
CMP EAX,0x1
JG 0x00189907
LAB_00189919:
MOV RAX,qword ptr [RSP + 0x8]
CMP word ptr [RAX + 0x2],0x0
JLE 0x00189a12
XOR R15D,R15D
LAB_0018992c:
MOV RAX,qword ptr [RBX]
MOV RCX,qword ptr [RAX]
MOV RDX,qword ptr [RCX + 0x18]
MOVSX ECX,word ptr [RDX + R9*0x1 + 0x9c]
TEST ECX,ECX
JZ 0x00189949
IMUL ECX,R14D
JMP 0x00189956
LAB_00189949:
ADD RDX,R9
MOV RCX,qword ptr [RDX + 0x60]
MOVSXD RDX,R14D
MOV ECX,dword ptr [RCX + RDX*0x4]
LAB_00189956:
MOVSX EDX,word ptr [R8 + 0x9c]
TEST EDX,EDX
JNZ 0x00189970
MOV RSI,qword ptr [R8 + 0x60]
MOVSXD RDI,R14D
MOV EDX,dword ptr [RSI + RDI*0x4 + 0x4]
SUB EDX,dword ptr [RSI + RDI*0x4]
LAB_00189970:
CMP EDX,0x2
JL 0x001899ae
MOV RSI,qword ptr [RBX + 0x28]
MOV RDI,qword ptr [RSP + 0x10]
MOVSXD RSI,dword ptr [RSI + RDI*0x4 + 0xc]
MOVSXD RCX,ECX
MOV EBP,EDX
SHL RCX,0x2
LEA R12,[RCX + RSI*0x4]
ADD R12,qword ptr [RAX + 0x8]
MOV R13D,0x1
LAB_0018999a:
MOV ESI,dword ptr [R12 + R13*0x4]
MOV RDI,RBX
CALL 0x0013afd0
INC R13
CMP RBP,R13
JNZ 0x0018999a
LAB_001899ae:
MOV R8,qword ptr [RSP + 0x30]
MOVSX EAX,word ptr [R8 + 0x98]
BT EAX,0x8
JC 0x001899d7
MOVSX ECX,word ptr [R8 + 0x2]
DEC ECX
CMP ECX,R14D
MOV R9,qword ptr [RSP + 0x20]
JLE 0x001899f5
INC R14D
JMP 0x001899fd
LAB_001899d7:
MOV RAX,qword ptr [R8 + 0xa8]
LEA ECX,[0x1 + R14*0x2]
MOVSXD RCX,ECX
MOVSX R14D,word ptr [RAX + RCX*0x2]
MOV R9,qword ptr [RSP + 0x20]
JMP 0x001899fd
LAB_001899f5:
AND EAX,0x1
NEG EAX
MOV R14D,EAX
LAB_001899fd:
INC R15D
MOV RAX,qword ptr [RSP + 0x8]
MOVSX EAX,word ptr [RAX + 0x2]
CMP R15D,EAX
JL 0x0018992c
LAB_00189a12:
MOV RAX,qword ptr [RSP + 0x28]
INC RAX
CMP RAX,qword ptr [RSP + 0x18]
JNZ 0x0018965d
LAB_00189a25:
MOV RAX,qword ptr [RBX + 0x118]
SUB RAX,qword ptr [RBX + 0x110]
SHR RAX,0x2
MOV dword ptr [RBX + 0x14],EAX
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00189a49:
LEA RDI,[0x1be0af]
LEA RSI,[0x1bea98]
LEA RCX,[0x1be128]
MOV EDX,0x120
CALL 0x00139560
|
/* OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder::initializeControlVertexMap() */
void __thiscall
OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder::initializeControlVertexMap
(IrregularPatchBuilder *this)
{
short sVar1;
int iVar2;
int *piVar3;
long *plVar4;
long lVar5;
long lVar6;
int iVar7;
int iVar8;
uint uVar9;
ulong uVar10;
long lVar11;
long lVar12;
ulong uVar13;
ulong uVar14;
ulong uVar15;
int *piVar16;
int iVar17;
lVar6 = **(long **)this;
lVar11 = *(long *)(lVar6 + 0x18);
if (*(short *)(lVar11 + 0x9c) == 0) {
iVar8 = *(int *)(*(long *)(lVar11 + 0x60) + (long)(int)*(short *)(lVar11 + 0x9a) * 4);
}
else {
iVar8 = (int)*(short *)(lVar11 + 0x9c) * (int)*(short *)(lVar11 + 0x9a);
}
iVar17 = *(int *)(lVar6 + 8);
uVar10 = (ulong)iVar17;
if (0 < (long)uVar10) {
piVar16 = (int *)((*(long **)this)[1] + (long)iVar8 * 4);
uVar13 = 0;
do {
addMeshControlVertex(this,*piVar16);
piVar3 = *(int **)(this + 0x118);
if (uVar13 == ((ulong)((long)piVar3 - *(long *)(this + 0x110)) >> 2 & 0xffffffff)) {
if (piVar3 == *(int **)(this + 0x120)) {
std::vector<int,std::allocator<int>>::_M_realloc_insert<int_const&>
((vector<int,std::allocator<int>> *)(this + 0x110),piVar3,piVar16);
}
else {
*piVar3 = *piVar16;
*(int **)(this + 0x118) = piVar3 + 1;
}
}
uVar13 = uVar13 + 1;
piVar16 = piVar16 + 1;
} while (uVar10 != uVar13);
}
if (0 < iVar17) {
uVar13 = 0;
do {
lVar6 = *(long *)(this + 0x28);
if (*(int *)(lVar6 + uVar13 * 0x14) != 0) {
plVar4 = *(long **)this;
lVar12 = uVar13 * 0xe0;
lVar11 = *(long *)(*plVar4 + 0x18) + lVar12;
if ((*(byte *)(lVar6 + uVar13 * 0x14 + 0x10) & 2) == 0) {
lVar6 = uVar13 * 0xc + plVar4[2];
if (1 < *(short *)(lVar6 + 4)) {
if ((*(byte *)(lVar11 + 0x99) & 1) == 0) {
uVar15 = (long)(*(short *)(lVar11 + 0x9a) + 1) % (long)(int)*(short *)(lVar11 + 2) &
0xffffffff;
}
else {
uVar15 = (ulong)(uint)(int)*(short *)(*(long *)(lVar11 + 0xa8) + 2 +
(long)(int)*(short *)(lVar11 + 0x9a) * 4);
}
if (1 < *(short *)(lVar6 + 4)) {
iVar8 = 1;
do {
iVar17 = (int)uVar15;
if (((uint)(int)*(short *)(lVar11 + 0x98) >> 8 & 1) == 0) {
if (iVar17 < *(short *)(lVar11 + 2) + -1) {
uVar15 = (ulong)(iVar17 + 1);
}
else {
uVar15 = (ulong)-((int)*(short *)(lVar11 + 0x98) & 1U);
}
}
else {
uVar15 = (ulong)(uint)(int)*(short *)(*(long *)(lVar11 + 0xa8) +
(long)(iVar17 * 2 + 1) * 2);
}
lVar5 = *(long *)(**(long **)this + 0x18);
sVar1 = *(short *)(lVar5 + 0x9c + lVar12);
iVar17 = (int)uVar15;
if (sVar1 == 0) {
iVar7 = *(int *)(*(long *)(lVar5 + lVar12 + 0x60) + (long)iVar17 * 4);
}
else {
iVar7 = sVar1 * iVar17;
}
uVar9 = (uint)*(short *)(lVar11 + 0x9c);
if (*(short *)(lVar11 + 0x9c) == 0) {
uVar9 = *(int *)(*(long *)(lVar11 + 0x60) + 4 + (long)iVar17 * 4) -
*(int *)(*(long *)(lVar11 + 0x60) + (long)iVar17 * 4);
}
if (1 < (int)uVar9) {
iVar17 = *(int *)(*(long *)(this + 0x28) + 0xc + uVar13 * 0x14);
lVar5 = (*(long **)this)[1];
uVar14 = 1;
do {
addMeshControlVertex
(this,*(int *)((long)iVar7 * 4 + (long)iVar17 * 4 + lVar5 + uVar14 * 4
));
uVar14 = uVar14 + 1;
} while (uVar9 != uVar14);
}
iVar8 = iVar8 + 1;
} while (iVar8 < *(short *)(lVar6 + 4));
}
}
sVar1 = *(short *)(lVar6 + 2);
if (sVar1 != 0) {
if (sVar1 < 0) {
/* WARNING: Subroutine does not return */
__assert_fail("step >= 0",
"/workspace/llm4binary/github/2025_star3/NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/../bfr/../bfr/../bfr/../bfr/faceVertex.h"
,0x120,
"int OpenSubdiv::v3_6_0::Bfr::FaceVertex::GetFaceBefore(int) const");
}
iVar8 = (int)*(short *)(lVar11 + 0x9a);
if ((*(byte *)(lVar11 + 0x99) & 1) == 0) {
iVar8 = ((iVar8 - sVar1) + (int)*(short *)(lVar11 + 2)) % (int)*(short *)(lVar11 + 2);
}
else {
lVar5 = *(long *)(lVar11 + 0xa8);
if (sVar1 == 1) {
iVar8 = (int)*(short *)(lVar5 + (long)iVar8 * 4);
}
else if (sVar1 == 2) {
iVar8 = (int)*(short *)(lVar5 + (long)*(short *)(lVar5 + (long)iVar8 * 4) * 4);
}
else {
iVar17 = sVar1 + 1;
do {
iVar8 = (int)*(short *)(lVar5 + (long)(iVar8 * 2) * 2);
iVar17 = iVar17 + -1;
} while (1 < iVar17);
}
}
if (0 < *(short *)(lVar6 + 2)) {
iVar17 = 0;
do {
lVar5 = *(long *)(**(long **)this + 0x18);
sVar1 = *(short *)(lVar5 + 0x9c + lVar12);
if (sVar1 == 0) {
iVar7 = *(int *)(*(long *)(lVar5 + lVar12 + 0x60) + (long)iVar8 * 4);
}
else {
iVar7 = sVar1 * iVar8;
}
uVar9 = (uint)*(short *)(lVar11 + 0x9c);
if (*(short *)(lVar11 + 0x9c) == 0) {
uVar9 = *(int *)(*(long *)(lVar11 + 0x60) + 4 + (long)iVar8 * 4) -
*(int *)(*(long *)(lVar11 + 0x60) + (long)iVar8 * 4);
}
if (1 < (int)uVar9) {
iVar2 = *(int *)(*(long *)(this + 0x28) + 0xc + uVar13 * 0x14);
lVar5 = (*(long **)this)[1];
uVar15 = 1;
do {
addMeshControlVertex
(this,*(int *)((long)iVar7 * 4 + (long)iVar2 * 4 + lVar5 + uVar15 * 4)
);
uVar15 = uVar15 + 1;
} while (uVar9 != uVar15);
}
if (((uint)(int)*(short *)(lVar11 + 0x98) >> 8 & 1) == 0) {
if (iVar8 < *(short *)(lVar11 + 2) + -1) {
iVar8 = iVar8 + 1;
}
else {
iVar8 = -((int)*(short *)(lVar11 + 0x98) & 1U);
}
}
else {
iVar8 = (int)*(short *)(*(long *)(lVar11 + 0xa8) + (long)(iVar8 * 2 + 1) * 2);
}
iVar17 = iVar17 + 1;
} while (iVar17 < *(short *)(lVar6 + 2));
}
}
}
else {
if ((*(byte *)(lVar11 + 0x99) & 1) == 0) {
iVar8 = (*(short *)(lVar11 + 0x9a) + 1) % (int)*(short *)(lVar11 + 2);
}
else {
iVar8 = (int)*(short *)(*(long *)(lVar11 + 0xa8) + 2 +
(long)(int)*(short *)(lVar11 + 0x9a) * 4);
}
lVar12 = plVar4[1];
iVar17 = *(int *)(lVar6 + 0xc + uVar13 * 0x14);
uVar9 = (uint)*(short *)(lVar11 + 0x9c);
if (*(short *)(lVar11 + 0x9c) == 0) {
iVar7 = *(int *)(*(long *)(lVar11 + 0x60) + (long)iVar8 * 4);
uVar9 = *(int *)(*(long *)(lVar11 + 0x60) + 4 + (long)iVar8 * 4) -
*(int *)(*(long *)(lVar11 + 0x60) + (long)iVar8 * 4);
}
else {
iVar7 = iVar8 * uVar9;
}
if (1 < (int)uVar9) {
uVar15 = 1;
do {
addMeshControlVertex
(this,*(int *)(lVar12 + (long)iVar7 * 4 + (long)iVar17 * 4 + uVar15 * 4));
uVar15 = uVar15 + 1;
} while (uVar9 != uVar15);
}
}
}
uVar13 = uVar13 + 1;
} while (uVar13 != uVar10);
}
*(int *)(this + 0x14) = (int)((ulong)(*(long *)(this + 0x118) - *(long *)(this + 0x110)) >> 2);
return;
}
| |
44,776 | my_strnncoll_binary | eloqsql/strings/ctype-bin.c | static int my_strnncoll_binary(CHARSET_INFO * cs __attribute__((unused)),
const uchar *s, size_t slen,
const uchar *t, size_t tlen,
my_bool t_is_prefix)
{
size_t len=MY_MIN(slen,tlen);
int cmp= memcmp(s,t,len);
return cmp ? cmp : (int)((t_is_prefix ? len : slen) - tlen);
} | O0 | c | my_strnncoll_binary:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %r9b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movb %al, -0x29(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x6bc16
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x6bc1e
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x26160
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0x6bc48
movl -0x3c(%rbp), %eax
movl %eax, -0x4c(%rbp)
jmp 0x6bc6e
movsbl -0x29(%rbp), %eax
cmpl $0x0, %eax
je 0x6bc5b
movq -0x38(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x6bc63
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
subq -0x28(%rbp), %rax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| my_strnncoll_binary:
push rbp
mov rbp, rsp
sub rsp, 60h
mov al, r9b
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_29], al
mov rax, [rbp+var_18]
cmp rax, [rbp+var_28]
jnb short loc_6BC16
mov rax, [rbp+var_18]
mov [rbp+var_48], rax
jmp short loc_6BC1E
loc_6BC16:
mov rax, [rbp+var_28]
mov [rbp+var_48], rax
loc_6BC1E:
mov rax, [rbp+var_48]
mov [rbp+var_38], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_38]
call _memcmp
mov [rbp+var_3C], eax
cmp [rbp+var_3C], 0
jz short loc_6BC48
mov eax, [rbp+var_3C]
mov [rbp+var_4C], eax
jmp short loc_6BC6E
loc_6BC48:
movsx eax, [rbp+var_29]
cmp eax, 0
jz short loc_6BC5B
mov rax, [rbp+var_38]
mov [rbp+var_58], rax
jmp short loc_6BC63
loc_6BC5B:
mov rax, [rbp+var_18]
mov [rbp+var_58], rax
loc_6BC63:
mov rax, [rbp+var_58]
sub rax, [rbp+var_28]
mov [rbp+var_4C], eax
loc_6BC6E:
mov eax, [rbp+var_4C]
add rsp, 60h
pop rbp
retn
| long long my_strnncoll_binary(
long long a1,
long long a2,
unsigned long long a3,
long long a4,
unsigned long long a5,
char a6)
{
int v7; // [rsp+8h] [rbp-58h]
unsigned long long v9; // [rsp+18h] [rbp-48h]
unsigned int v10; // [rsp+24h] [rbp-3Ch]
int v12; // [rsp+38h] [rbp-28h]
int v13; // [rsp+48h] [rbp-18h]
v13 = a3;
v12 = a5;
if ( a3 >= a5 )
v9 = a5;
else
v9 = a3;
v10 = memcmp(a2, a4, v9);
if ( v10 )
{
return v10;
}
else
{
if ( a6 )
v7 = v9;
else
v7 = v13;
return (unsigned int)(v7 - v12);
}
}
| my_strnncoll_binary:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV AL,R9B
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 byte ptr [RBP + -0x29],AL
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x28]
JNC 0x0016bc16
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x48],RAX
JMP 0x0016bc1e
LAB_0016bc16:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x48],RAX
LAB_0016bc1e:
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x38]
CALL 0x00126160
MOV dword ptr [RBP + -0x3c],EAX
CMP dword ptr [RBP + -0x3c],0x0
JZ 0x0016bc48
MOV EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x4c],EAX
JMP 0x0016bc6e
LAB_0016bc48:
MOVSX EAX,byte ptr [RBP + -0x29]
CMP EAX,0x0
JZ 0x0016bc5b
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x58],RAX
JMP 0x0016bc63
LAB_0016bc5b:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x58],RAX
LAB_0016bc63:
MOV RAX,qword ptr [RBP + -0x58]
SUB RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RBP + -0x4c],EAX
LAB_0016bc6e:
MOV EAX,dword ptr [RBP + -0x4c]
ADD RSP,0x60
POP RBP
RET
|
int my_strnncoll_binary(int8 param_1,void *param_2,ulong param_3,void *param_4,ulong param_5,
char param_6)
{
ulong local_60;
int local_54;
size_t local_50;
local_50 = param_5;
if (param_3 < param_5) {
local_50 = param_3;
}
local_54 = memcmp(param_2,param_4,local_50);
if (local_54 == 0) {
local_60 = param_3;
if (param_6 != '\0') {
local_60 = local_50;
}
local_54 = (int)local_60 - (int)param_5;
}
return local_54;
}
| |
44,777 | ma_mmap_pwrite | eloqsql/storage/maria/ma_dynrec.c | size_t _ma_mmap_pwrite(MARIA_HA *info, const uchar *Buffer,
size_t Count, my_off_t offset, myf MyFlags)
{
DBUG_PRINT("info", ("maria_write with mmap %d\n", info->dfile.file));
if (info->s->lock_key_trees)
mysql_rwlock_rdlock(&info->s->mmap_lock);
/*
The following test may fail in the following cases:
- We failed to remap a memory area (fragmented memory?)
- This thread has done some writes, but not yet extended the
memory mapped area.
*/
if (info->s->mmaped_length >= offset + Count)
{
memcpy(info->s->file_map + offset, Buffer, Count);
if (info->s->lock_key_trees)
mysql_rwlock_unlock(&info->s->mmap_lock);
return 0;
}
else
{
info->s->nonmmaped_inserts++;
if (info->s->lock_key_trees)
mysql_rwlock_unlock(&info->s->mmap_lock);
return my_pwrite(info->dfile.file, Buffer, Count, offset, MyFlags);
}
} | O3 | c | ma_mmap_pwrite:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r15
movq (%rdi), %rax
cmpb $0x0, 0x7e3(%rax)
je 0x3c498
leaq 0xb78(%rax), %rdi
cmpq $0x0, 0xc08(%rax)
jne 0x3c554
callq 0xa43b8
movq (%r15), %rax
leaq (%r14,%rbx), %rcx
cmpq %rcx, 0xa00(%rax)
jae 0x3c507
movq %r12, -0x30(%rbp)
incl 0xa08(%rax)
movq (%r15), %r12
cmpb $0x0, 0x7e3(%r12)
je 0x3c4e0
movq 0xc08(%r12), %rdi
addq $0xb78, %r12 # imm = 0xB78
testq %rdi, %rdi
jne 0x3c56a
movq %r12, %rdi
callq 0xa44e6
movl 0x480(%r15), %edi
movq %r13, %rsi
movq %rbx, %rdx
movq %r14, %rcx
movq -0x30(%rbp), %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa07ee
addq 0x5f0(%rax), %r14
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x29080
movq (%r15), %rbx
cmpb $0x0, 0x7e3(%rbx)
je 0x3c543
movq 0xc08(%rbx), %rdi
addq $0xb78, %rbx # imm = 0xB78
testq %rdi, %rdi
jne 0x3c57f
movq %rbx, %rdi
callq 0xa44e6
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9d219(%rip), %rsi # 0xd9774
movl $0xbb, %edx
callq 0x2ec50
jmp 0x3c498
leaq 0x349a9f(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x168(%rax)
jmp 0x3c4d8
leaq 0x349a8a(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x168(%rax)
jmp 0x3c53b
| _ma_mmap_pwrite:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r12, r8
mov r14, rcx
mov rbx, rdx
mov r13, rsi
mov r15, rdi
mov rax, [rdi]
cmp byte ptr [rax+7E3h], 0
jz short loc_3C498
lea rdi, [rax+0B78h]
cmp qword ptr [rax+0C08h], 0
jnz loc_3C554
call my_rw_rdlock
loc_3C498:
mov rax, [r15]
lea rcx, [r14+rbx]
cmp [rax+0A00h], rcx
jnb short loc_3C507
mov [rbp+var_30], r12
inc dword ptr [rax+0A08h]
mov r12, [r15]
cmp byte ptr [r12+7E3h], 0
jz short loc_3C4E0
mov rdi, [r12+0C08h]
add r12, 0B78h
test rdi, rdi
jnz loc_3C56A
loc_3C4D8:
mov rdi, r12
call my_rw_unlock
loc_3C4E0:
mov edi, [r15+480h]
mov rsi, r13
mov rdx, rbx
mov rcx, r14
mov r8, [rbp+var_30]
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp my_pwrite
loc_3C507:
add r14, [rax+5F0h]
mov rdi, r14
mov rsi, r13
mov rdx, rbx
call _memcpy
mov rbx, [r15]
cmp byte ptr [rbx+7E3h], 0
jz short loc_3C543
mov rdi, [rbx+0C08h]
add rbx, 0B78h
test rdi, rdi
jnz short loc_3C57F
loc_3C53B:
mov rdi, rbx
call my_rw_unlock
loc_3C543:
xor eax, eax
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3C554:
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 0BBh
call psi_rwlock_rdlock
jmp loc_3C498
loc_3C56A:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+168h]
jmp loc_3C4D8
loc_3C57F:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+168h]
jmp short loc_3C53B
| long long ma_mmap_pwrite(unsigned int *a1, long long a2, long long a3, long long a4, long long a5)
{
long long v9; // rax
long long v10; // rdi
long long v11; // rax
long long v12; // r12
long long v13; // rdi
long long v14; // r12
long long v16; // rbx
long long v17; // rdi
long long v18; // rbx
long long v19; // [rsp+0h] [rbp-30h]
v9 = *(_QWORD *)a1;
if ( *(_BYTE *)(*(_QWORD *)a1 + 2019LL) )
{
v10 = v9 + 2936;
if ( *(_QWORD *)(v9 + 3080) )
psi_rwlock_rdlock(v10, (long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_dynrec.c", 0xBBu);
else
my_rw_rdlock(v10);
}
v11 = *(_QWORD *)a1;
if ( *(_QWORD *)(*(_QWORD *)a1 + 2560LL) >= (unsigned long long)(a4 + a3) )
{
memcpy(*(_QWORD *)(v11 + 1520) + a4, a2, a3);
v16 = *(_QWORD *)a1;
if ( *(_BYTE *)(*(_QWORD *)a1 + 2019LL) )
{
v17 = *(_QWORD *)(v16 + 3080);
v18 = v16 + 2936;
if ( v17 )
((void ( *)(long long))PSI_server[45])(v17);
my_rw_unlock(v18);
}
return 0LL;
}
else
{
v19 = a5;
++*(_DWORD *)(v11 + 2568);
v12 = *(_QWORD *)a1;
if ( *(_BYTE *)(*(_QWORD *)a1 + 2019LL) )
{
v13 = *(_QWORD *)(v12 + 3080);
v14 = v12 + 2936;
if ( v13 )
((void ( *)(long long))PSI_server[45])(v13);
my_rw_unlock(v14);
}
return my_pwrite(a1[288], a2, a3, a4, v19);
}
}
| _ma_mmap_pwrite:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R12,R8
MOV R14,RCX
MOV RBX,RDX
MOV R13,RSI
MOV R15,RDI
MOV RAX,qword ptr [RDI]
CMP byte ptr [RAX + 0x7e3],0x0
JZ 0x0013c498
LEA RDI,[RAX + 0xb78]
CMP qword ptr [RAX + 0xc08],0x0
JNZ 0x0013c554
CALL 0x001a43b8
LAB_0013c498:
MOV RAX,qword ptr [R15]
LEA RCX,[R14 + RBX*0x1]
CMP qword ptr [RAX + 0xa00],RCX
JNC 0x0013c507
MOV qword ptr [RBP + -0x30],R12
INC dword ptr [RAX + 0xa08]
MOV R12,qword ptr [R15]
CMP byte ptr [R12 + 0x7e3],0x0
JZ 0x0013c4e0
MOV RDI,qword ptr [R12 + 0xc08]
ADD R12,0xb78
TEST RDI,RDI
JNZ 0x0013c56a
LAB_0013c4d8:
MOV RDI,R12
CALL 0x001a44e6
LAB_0013c4e0:
MOV EDI,dword ptr [R15 + 0x480]
MOV RSI,R13
MOV RDX,RBX
MOV RCX,R14
MOV R8,qword ptr [RBP + -0x30]
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x001a07ee
LAB_0013c507:
ADD R14,qword ptr [RAX + 0x5f0]
MOV RDI,R14
MOV RSI,R13
MOV RDX,RBX
CALL 0x00129080
MOV RBX,qword ptr [R15]
CMP byte ptr [RBX + 0x7e3],0x0
JZ 0x0013c543
MOV RDI,qword ptr [RBX + 0xc08]
ADD RBX,0xb78
TEST RDI,RDI
JNZ 0x0013c57f
LAB_0013c53b:
MOV RDI,RBX
CALL 0x001a44e6
LAB_0013c543:
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013c554:
LEA RSI,[0x1d9774]
MOV EDX,0xbb
CALL 0x0012ec50
JMP 0x0013c498
LAB_0013c56a:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x168]
JMP 0x0013c4d8
LAB_0013c57f:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x168]
JMP 0x0013c53b
|
int8
_ma_mmap_pwrite(long *param_1,void *param_2,size_t param_3,long param_4,int8 param_5)
{
long lVar1;
int8 uVar2;
lVar1 = *param_1;
if (*(char *)(lVar1 + 0x7e3) != '\0') {
if (*(long *)(lVar1 + 0xc08) == 0) {
my_rw_rdlock();
}
else {
psi_rwlock_rdlock(lVar1 + 0xb78,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_dynrec.c",0xbb);
}
}
lVar1 = *param_1;
if (*(ulong *)(lVar1 + 0xa00) < param_4 + param_3) {
*(int *)(lVar1 + 0xa08) = *(int *)(lVar1 + 0xa08) + 1;
lVar1 = *param_1;
if (*(char *)(lVar1 + 0x7e3) != '\0') {
if (*(long *)(lVar1 + 0xc08) != 0) {
(**(code **)(PSI_server + 0x168))();
}
my_rw_unlock(lVar1 + 0xb78);
}
uVar2 = my_pwrite((int)param_1[0x90],param_2,param_3,param_4,param_5);
return uVar2;
}
memcpy((void *)(param_4 + *(long *)(lVar1 + 0x5f0)),param_2,param_3);
lVar1 = *param_1;
if (*(char *)(lVar1 + 0x7e3) != '\0') {
if (*(long *)(lVar1 + 0xc08) != 0) {
(**(code **)(PSI_server + 0x168))();
}
my_rw_unlock(lVar1 + 0xb78);
}
return 0;
}
| |
44,778 | translog_buffer_lock | eloqsql/storage/maria/ma_loghandler.c | static void translog_buffer_lock(struct st_translog_buffer *buffer)
{
DBUG_ENTER("translog_buffer_lock");
DBUG_PRINT("enter",
("Lock buffer #%u: %p", buffer->buffer_no,
buffer));
mysql_mutex_lock(&buffer->mutex);
DBUG_VOID_RETURN;
} | O3 | c | translog_buffer_lock:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
addq $0x100090, %rdi # imm = 0x100090
cmpq $0x0, 0x1000d0(%rax)
jne 0x7b43d
popq %rbp
jmp 0x2b230
leaq 0x89ac1(%rip), %rsi # 0x104f05
movl $0x6cb, %edx # imm = 0x6CB
popq %rbp
jmp 0x324c0
| translog_buffer_lock:
push rbp
mov rbp, rsp
mov rax, rdi
add rdi, 100090h
cmp qword ptr [rax+1000D0h], 0
jnz short loc_7B43D
pop rbp
jmp _pthread_mutex_lock
loc_7B43D:
lea rsi, aWorkspaceLlm4b_12; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 6CBh
pop rbp
jmp psi_mutex_lock
| long long translog_buffer_lock(long long a1)
{
long long v2; // rdi
v2 = a1 + 1048720;
if ( *(_QWORD *)(a1 + 1048784) )
return psi_mutex_lock(v2, (long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c", 0x6CBu);
else
return pthread_mutex_lock(v2);
}
| translog_buffer_lock:
PUSH RBP
MOV RBP,RSP
MOV RAX,RDI
ADD RDI,0x100090
CMP qword ptr [RAX + 0x1000d0],0x0
JNZ 0x0017b43d
POP RBP
JMP 0x0012b230
LAB_0017b43d:
LEA RSI,[0x204f05]
MOV EDX,0x6cb
POP RBP
JMP 0x001324c0
|
void translog_buffer_lock(long param_1)
{
pthread_mutex_t *__mutex;
__mutex = (pthread_mutex_t *)((long)&Elf64_Phdr_ARRAY_00100040[1].p_paddr + param_1);
if (*(long *)((long)&Elf64_Phdr_ARRAY_00100040[2].p_filesz + param_1) == 0) {
pthread_mutex_lock(__mutex);
return;
}
psi_mutex_lock(__mutex,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
0x6cb);
return;
}
| |
44,779 | mysql_read_query_result_start_internal | eloqsql/libmariadb/libmariadb/mariadb_async.c | static void
mysql_read_query_result_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_read_query_result,
(parms->mysql),
parms->mysql,
my_bool,
r_my_bool)
} | O3 | c | mysql_read_query_result_start_internal:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rdi
movq 0x480(%rdi), %rax
movq 0x28(%rax), %rbx
callq 0x1bd38
movb %al, 0x8(%rbx)
movl $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| mysql_read_query_result_start_internal:
push rbp
mov rbp, rsp
push rbx
push rax
mov rdi, [rdi]
mov rax, [rdi+480h]
mov rbx, [rax+28h]
call mysql_read_query_result
mov [rbx+8], al
mov dword ptr [rbx], 0
add rsp, 8
pop rbx
pop rbp
retn
| bool mysql_read_query_result_start_internal(long long *a1)
{
long long v1; // rdi
long long v2; // rbx
bool result; // al
v1 = *a1;
v2 = *(_QWORD *)(*(_QWORD *)(v1 + 1152) + 40LL);
result = mysql_read_query_result(v1);
*(_BYTE *)(v2 + 8) = result;
*(_DWORD *)v2 = 0;
return result;
}
| mysql_read_query_result_start_internal:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RDI,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x480]
MOV RBX,qword ptr [RAX + 0x28]
CALL 0x0011bd38
MOV byte ptr [RBX + 0x8],AL
MOV dword ptr [RBX],0x0
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void mysql_read_query_result_start_internal(long *param_1)
{
int4 *puVar1;
int1 uVar2;
puVar1 = *(int4 **)(*(long *)(*param_1 + 0x480) + 0x28);
uVar2 = mysql_read_query_result();
*(int1 *)(puVar1 + 2) = uVar2;
*puVar1 = 0;
return;
}
| |
44,780 | free_bytecode_atoms | bluesky950520[P]quickjs/quickjs.c | static void free_bytecode_atoms(JSRuntime *rt,
const uint8_t *bc_buf, int bc_len,
BOOL use_short_opcodes)
{
int pos, len, op;
JSAtom atom;
const JSOpCode *oi;
pos = 0;
while (pos < bc_len) {
op = bc_buf[pos];
if (use_short_opcodes)
oi = &short_opcode_info(op);
else
oi = &opcode_info[op];
len = oi->size;
switch(oi->fmt) {
case OP_FMT_atom:
case OP_FMT_atom_u8:
case OP_FMT_atom_u16:
case OP_FMT_atom_label_u8:
case OP_FMT_atom_label_u16:
atom = get_u32(bc_buf + pos + 1);
JS_FreeAtomRT(rt, atom);
break;
default:
break;
}
pos += len;
}
} | O0 | c | free_bytecode_atoms:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movl %ecx, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x65304
movq 0x28(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x20(%rsp)
je 0x65290
cmpl $0xb3, 0x14(%rsp)
jl 0x6526c
movl 0x14(%rsp), %eax
addl $0x12, %eax
movl %eax, 0x4(%rsp)
jmp 0x65274
movl 0x14(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movslq %eax, %rcx
leaq 0xae1ce(%rip), %rax # 0x113450
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
jmp 0x652a8
movslq 0x14(%rsp), %rcx
leaq 0xae1b4(%rip), %rax # 0x113450
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
movl %eax, 0x18(%rsp)
movq 0x8(%rsp), %rax
movzbl 0x3(%rax), %eax
addl $-0x18, %eax
subl $0x4, %eax
ja 0x652f1
jmp 0x652c7
movq 0x28(%rsp), %rdi
movslq 0x1c(%rsp), %rax
addq %rax, %rdi
addq $0x1, %rdi
callq 0x654a0
movl %eax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0x2a090
jmp 0x652f3
jmp 0x652f3
movl 0x18(%rsp), %eax
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
jmp 0x6522e
addq $0x38, %rsp
retq
nopl (%rax)
| free_bytecode_atoms:
sub rsp, 38h
mov [rsp+38h+var_8], rdi
mov [rsp+38h+var_10], rsi
mov [rsp+38h+var_14], edx
mov [rsp+38h+var_18], ecx
mov [rsp+38h+var_1C], 0
loc_6522E:
mov eax, [rsp+38h+var_1C]
cmp eax, [rsp+38h+var_14]
jge loc_65304
mov rax, [rsp+38h+var_10]
movsxd rcx, [rsp+38h+var_1C]
movzx eax, byte ptr [rax+rcx]
mov [rsp+38h+var_24], eax
cmp [rsp+38h+var_18], 0
jz short loc_65290
cmp [rsp+38h+var_24], 0B3h
jl short loc_6526C
mov eax, [rsp+38h+var_24]
add eax, 12h
mov [rsp+38h+var_34], eax
jmp short loc_65274
loc_6526C:
mov eax, [rsp+38h+var_24]
mov [rsp+38h+var_34], eax
loc_65274:
mov eax, [rsp+38h+var_34]
movsxd rcx, eax
lea rax, opcode_info
shl rcx, 2
add rax, rcx
mov [rsp+38h+var_30], rax
jmp short loc_652A8
loc_65290:
movsxd rcx, [rsp+38h+var_24]
lea rax, opcode_info
shl rcx, 2
add rax, rcx
mov [rsp+38h+var_30], rax
loc_652A8:
mov rax, [rsp+38h+var_30]
movzx eax, byte ptr [rax]
mov [rsp+38h+var_20], eax
mov rax, [rsp+38h+var_30]
movzx eax, byte ptr [rax+3]
add eax, 0FFFFFFE8h
sub eax, 4
ja short loc_652F1
jmp short $+2
loc_652C7:
mov rdi, [rsp+38h+var_10]
movsxd rax, [rsp+38h+var_1C]
add rdi, rax
add rdi, 1
call get_u32
mov [rsp+38h+var_28], eax
mov rdi, [rsp+38h+var_8]
mov esi, [rsp+38h+var_28]
call JS_FreeAtomRT
jmp short loc_652F3
loc_652F1:
jmp short $+2
loc_652F3:
mov eax, [rsp+38h+var_20]
add eax, [rsp+38h+var_1C]
mov [rsp+38h+var_1C], eax
jmp loc_6522E
loc_65304:
add rsp, 38h
retn
| long long free_bytecode_atoms(long long a1, long long a2, int a3, int a4)
{
long long result; // rax
unsigned int v5; // eax
int v6; // [rsp+4h] [rbp-34h]
unsigned __int8 *v7; // [rsp+8h] [rbp-30h]
int v8; // [rsp+18h] [rbp-20h]
unsigned int i; // [rsp+1Ch] [rbp-1Ch]
for ( i = 0; ; i += v8 )
{
result = i;
if ( (int)i >= a3 )
break;
if ( a4 )
{
if ( *(unsigned __int8 *)(a2 + (int)i) < 0xB3u )
v6 = *(unsigned __int8 *)(a2 + (int)i);
else
v6 = *(unsigned __int8 *)(a2 + (int)i) + 18;
v7 = (unsigned __int8 *)&opcode_info + 4 * v6;
}
else
{
v7 = (unsigned __int8 *)&opcode_info + 4 * *(unsigned __int8 *)(a2 + (int)i);
}
v8 = *v7;
if ( (unsigned int)v7[3] - 24 <= 4 )
{
get_u32((int)i + a2 + 1);
JS_FreeAtomRT(a1, v5);
}
}
return result;
}
| free_bytecode_atoms:
SUB RSP,0x38
MOV qword ptr [RSP + 0x30],RDI
MOV qword ptr [RSP + 0x28],RSI
MOV dword ptr [RSP + 0x24],EDX
MOV dword ptr [RSP + 0x20],ECX
MOV dword ptr [RSP + 0x1c],0x0
LAB_0016522e:
MOV EAX,dword ptr [RSP + 0x1c]
CMP EAX,dword ptr [RSP + 0x24]
JGE 0x00165304
MOV RAX,qword ptr [RSP + 0x28]
MOVSXD RCX,dword ptr [RSP + 0x1c]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV dword ptr [RSP + 0x14],EAX
CMP dword ptr [RSP + 0x20],0x0
JZ 0x00165290
CMP dword ptr [RSP + 0x14],0xb3
JL 0x0016526c
MOV EAX,dword ptr [RSP + 0x14]
ADD EAX,0x12
MOV dword ptr [RSP + 0x4],EAX
JMP 0x00165274
LAB_0016526c:
MOV EAX,dword ptr [RSP + 0x14]
MOV dword ptr [RSP + 0x4],EAX
LAB_00165274:
MOV EAX,dword ptr [RSP + 0x4]
MOVSXD RCX,EAX
LEA RAX,[0x213450]
SHL RCX,0x2
ADD RAX,RCX
MOV qword ptr [RSP + 0x8],RAX
JMP 0x001652a8
LAB_00165290:
MOVSXD RCX,dword ptr [RSP + 0x14]
LEA RAX,[0x213450]
SHL RCX,0x2
ADD RAX,RCX
MOV qword ptr [RSP + 0x8],RAX
LAB_001652a8:
MOV RAX,qword ptr [RSP + 0x8]
MOVZX EAX,byte ptr [RAX]
MOV dword ptr [RSP + 0x18],EAX
MOV RAX,qword ptr [RSP + 0x8]
MOVZX EAX,byte ptr [RAX + 0x3]
ADD EAX,-0x18
SUB EAX,0x4
JA 0x001652f1
JMP 0x001652c7
LAB_001652c7:
MOV RDI,qword ptr [RSP + 0x28]
MOVSXD RAX,dword ptr [RSP + 0x1c]
ADD RDI,RAX
ADD RDI,0x1
CALL 0x001654a0
MOV dword ptr [RSP + 0x10],EAX
MOV RDI,qword ptr [RSP + 0x30]
MOV ESI,dword ptr [RSP + 0x10]
CALL 0x0012a090
JMP 0x001652f3
LAB_001652f1:
JMP 0x001652f3
LAB_001652f3:
MOV EAX,dword ptr [RSP + 0x18]
ADD EAX,dword ptr [RSP + 0x1c]
MOV dword ptr [RSP + 0x1c],EAX
JMP 0x0016522e
LAB_00165304:
ADD RSP,0x38
RET
|
void free_bytecode_atoms(int8 param_1,long param_2,int param_3,int param_4)
{
byte bVar1;
uint uVar2;
int4 uVar3;
byte *local_30;
int local_1c;
for (local_1c = 0; local_1c < param_3; local_1c = (uint)bVar1 + local_1c) {
uVar2 = (uint)*(byte *)(param_2 + local_1c);
if ((param_4 != 0) && (0xb2 < uVar2)) {
uVar2 = uVar2 + 0x12;
}
local_30 = opcode_info + (long)(int)uVar2 * 4;
bVar1 = *local_30;
if ((byte)opcode_info[(long)(int)uVar2 * 4 + 3] - 0x18 < 5) {
uVar3 = get_u32(param_2 + local_1c + 1);
JS_FreeAtomRT(param_1,uVar3);
}
}
return;
}
| |
44,781 | LefDefParser::lefiArray::bump(void***, int, int*) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiArray.cpp | void
lefiArray::bump(void ***arr,
int used,
int *allocated)
{
int size = *allocated * 2;
int i;
void **newa;
if (size == 0)
size = 2;
newa = (void**) lefMalloc(sizeof(void*) * size);
for (i = 0; i < used; i++) {
newa[i] = (*arr)[i];
}
if (*arr)
lefFree((char*) (*arr));
*allocated = size;
*arr = newa;
} | O3 | cpp | LefDefParser::lefiArray::bump(void***, int, int*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movl (%rcx), %eax
leal (%rax,%rax), %ecx
testl %eax, %eax
movl $0x2, %r12d
cmovnel %ecx, %r12d
movslq %r12d, %rdi
shlq $0x3, %rdi
callq 0x30c15
movq %rax, %r15
testl %ebp, %ebp
jle 0xaf0f
movl %ebp, %eax
xorl %ecx, %ecx
movq (%r14), %rdx
movq (%rdx,%rcx,8), %rdx
movq %rdx, (%r15,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0xaefc
movq (%r14), %rdi
testq %rdi, %rdi
je 0xaf1c
callq 0x322d0
movl %r12d, (%rbx)
movq %r15, (%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
| _ZN12LefDefParser9lefiArray4bumpEPPPviPi:
push rbp
push r15
push r14
push r12
push rbx
mov rbx, rcx
mov ebp, edx
mov r14, rsi
mov eax, [rcx]
lea ecx, [rax+rax]
test eax, eax
mov r12d, 2
cmovnz r12d, ecx
movsxd rdi, r12d
shl rdi, 3; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov r15, rax
test ebp, ebp
jle short loc_AF0F
mov eax, ebp
xor ecx, ecx
loc_AEFC:
mov rdx, [r14]
mov rdx, [rdx+rcx*8]
mov [r15+rcx*8], rdx
inc rcx
cmp rax, rcx
jnz short loc_AEFC
loc_AF0F:
mov rdi, [r14]; this
test rdi, rdi
jz short loc_AF1C
call _ZN12LefDefParser7lefFreeEPv; LefDefParser::lefFree(void *)
loc_AF1C:
mov [rbx], r12d
mov [r14], r15
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long LefDefParser::lefiArray::bump(LefDefParser::lefiArray *this, void ***a2, int a3, int *a4)
{
int v6; // eax
int v7; // ecx
int v8; // r12d
long long result; // rax
void **v10; // r15
long long v11; // rcx
v6 = *a4;
v7 = 2 * *a4;
v8 = 2;
if ( v6 )
v8 = v7;
result = LefDefParser::lefMalloc((LefDefParser *)(8LL * v8), (unsigned long long)a2);
v10 = (void **)result;
if ( a3 > 0 )
{
result = (unsigned int)a3;
v11 = 0LL;
do
{
v10[v11] = (*a2)[v11];
++v11;
}
while ( a3 != v11 );
}
if ( *a2 )
result = LefDefParser::lefFree((LefDefParser *)*a2, a2);
*a4 = v8;
*a2 = v10;
return result;
}
| bump:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RBX,RCX
MOV EBP,EDX
MOV R14,RSI
MOV EAX,dword ptr [RCX]
LEA ECX,[RAX + RAX*0x1]
TEST EAX,EAX
MOV R12D,0x2
CMOVNZ R12D,ECX
MOVSXD RDI,R12D
SHL RDI,0x3
CALL 0x00130c15
MOV R15,RAX
TEST EBP,EBP
JLE 0x0010af0f
MOV EAX,EBP
XOR ECX,ECX
LAB_0010aefc:
MOV RDX,qword ptr [R14]
MOV RDX,qword ptr [RDX + RCX*0x8]
MOV qword ptr [R15 + RCX*0x8],RDX
INC RCX
CMP RAX,RCX
JNZ 0x0010aefc
LAB_0010af0f:
MOV RDI,qword ptr [R14]
TEST RDI,RDI
JZ 0x0010af1c
CALL 0x001322d0
LAB_0010af1c:
MOV dword ptr [RBX],R12D
MOV qword ptr [R14],R15
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
/* LefDefParser::lefiArray::bump(void***, int, int*) */
void __thiscall
LefDefParser::lefiArray::bump(lefiArray *this,void ***param_1,int param_2,int *param_3)
{
void **ppvVar1;
ulong uVar2;
int iVar3;
iVar3 = 2;
if (*param_3 != 0) {
iVar3 = *param_3 * 2;
}
ppvVar1 = (void **)lefMalloc((LefDefParser *)((long)iVar3 << 3),(ulong)param_1);
if (0 < param_2) {
uVar2 = 0;
do {
ppvVar1[uVar2] = (*param_1)[uVar2];
uVar2 = uVar2 + 1;
} while ((uint)param_2 != uVar2);
}
if (*param_1 != (void **)0x0) {
lefFree(*param_1);
}
*param_3 = iVar3;
*param_1 = ppvVar1;
return;
}
| |
44,782 | js_number_constructor | bluesky950520[P]quickjs/quickjs.c | static JSValue js_number_constructor(JSContext *ctx, JSValue new_target,
int argc, JSValue *argv)
{
JSValue val, obj;
if (argc == 0) {
val = js_int32(0);
} else {
val = JS_ToNumeric(ctx, argv[0]);
if (JS_IsException(val))
return val;
switch(JS_VALUE_GET_TAG(val)) {
case JS_TAG_BIG_INT:
{
JSBigInt *p = JS_VALUE_GET_PTR(val);
double d;
bf_get_float64(&p->num, &d, BF_RNDN);
JS_FreeValue(ctx, val);
val = js_float64(d);
}
break;
default:
break;
}
}
if (!JS_IsUndefined(new_target)) {
obj = js_create_from_ctor(ctx, new_target, JS_CLASS_NUMBER);
if (!JS_IsException(obj))
JS_SetObjectData(ctx, obj, val);
return obj;
} else {
return val;
}
} | O0 | c | js_number_constructor:
subq $0xa8, %rsp
movq %rsi, 0x88(%rsp)
movq %rdx, 0x90(%rsp)
movq %rdi, 0x80(%rsp)
movl %ecx, 0x7c(%rsp)
movq %r8, 0x70(%rsp)
cmpl $0x0, 0x7c(%rsp)
jne 0x55dc9
xorl %edi, %edi
callq 0x32a00
movq %rax, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x68(%rsp)
jmp 0x55ea3
movq 0x80(%rsp), %rdi
movq 0x70(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0xd0ed0
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x60(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x22a00
cmpl $0x0, %eax
je 0x55e33
movq 0x60(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0xa0(%rsp)
jmp 0x55f6a
movl 0x68(%rsp), %eax
subl $-0x9, %eax
jne 0x55e9f
jmp 0x55e3e
movq 0x60(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
addq $0x8, %rdi
leaq 0x20(%rsp), %rsi
xorl %edx, %edx
callq 0xe9ae0
movq 0x80(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rdx
callq 0x229d0
movsd 0x20(%rsp), %xmm0
callq 0x4c3a0
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x68(%rsp)
jmp 0x55ea1
jmp 0x55ea1
jmp 0x55ea3
movq 0x88(%rsp), %rdi
movq 0x90(%rsp), %rsi
callq 0x2cfa0
cmpl $0x0, %eax
jne 0x55f50
movq 0x80(%rsp), %rdi
movq 0x88(%rsp), %rsi
movq 0x90(%rsp), %rdx
movl $0x4, %ecx
callq 0x53b40
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
movq (%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x22a00
cmpl $0x0, %eax
jne 0x55f34
movq 0x80(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq 0x60(%rsp), %rcx
movq 0x68(%rsp), %r8
callq 0x53d50
movq 0x50(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0xa0(%rsp)
jmp 0x55f6a
movq 0x60(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq 0x98(%rsp), %rax
movq 0xa0(%rsp), %rdx
addq $0xa8, %rsp
retq
nopw %cs:(%rax,%rax)
| js_number_constructor:
sub rsp, 0A8h
mov [rsp+0A8h+var_20], rsi
mov [rsp+0A8h+var_18], rdx
mov [rsp+0A8h+var_28], rdi
mov [rsp+0A8h+var_2C], ecx
mov [rsp+0A8h+var_38], r8
cmp [rsp+0A8h+var_2C], 0
jnz short loc_55DC9
xor edi, edi
call js_int32
mov [rsp+0A8h+var_68], rax
mov [rsp+0A8h+var_60], rdx
mov rax, [rsp+0A8h+var_68]
mov [rsp+0A8h+var_48], rax
mov rax, [rsp+0A8h+var_60]
mov [rsp+0A8h+var_40], rax
jmp loc_55EA3
loc_55DC9:
mov rdi, [rsp+0A8h+var_28]
mov rax, [rsp+0A8h+var_38]
mov rsi, [rax]
mov rdx, [rax+8]
call JS_ToNumeric
mov [rsp+0A8h+var_78], rax
mov [rsp+0A8h+var_70], rdx
mov rax, [rsp+0A8h+var_78]
mov [rsp+0A8h+var_48], rax
mov rax, [rsp+0A8h+var_70]
mov [rsp+0A8h+var_40], rax
mov rdi, [rsp+0A8h+var_48]
mov rsi, [rsp+0A8h+var_40]
call JS_IsException_1
cmp eax, 0
jz short loc_55E33
mov rax, [rsp+0A8h+var_48]
mov [rsp+0A8h+var_10], rax
mov rax, [rsp+0A8h+var_40]
mov [rsp+0A8h+var_8], rax
jmp loc_55F6A
loc_55E33:
mov eax, dword ptr [rsp+0A8h+var_40]
sub eax, 0FFFFFFF7h
jnz short loc_55E9F
jmp short $+2
loc_55E3E:
mov rax, [rsp+0A8h+var_48]
mov [rsp+0A8h+var_80], rax
mov rdi, [rsp+0A8h+var_80]
add rdi, 8
lea rsi, [rsp+0A8h+var_88]
xor edx, edx
call bf_get_float64
mov rdi, [rsp+0A8h+var_28]
mov rsi, [rsp+0A8h+var_48]
mov rdx, [rsp+0A8h+var_40]
call JS_FreeValue
movsd xmm0, [rsp+0A8h+var_88]
call js_float64
mov [rsp+0A8h+var_98], rax
mov [rsp+0A8h+var_90], rdx
mov rax, [rsp+0A8h+var_98]
mov [rsp+0A8h+var_48], rax
mov rax, [rsp+0A8h+var_90]
mov [rsp+0A8h+var_40], rax
jmp short loc_55EA1
loc_55E9F:
jmp short $+2
loc_55EA1:
jmp short $+2
loc_55EA3:
mov rdi, [rsp+0A8h+var_20]
mov rsi, [rsp+0A8h+var_18]
call JS_IsUndefined_0
cmp eax, 0
jnz loc_55F50
mov rdi, [rsp+0A8h+var_28]
mov rsi, [rsp+0A8h+var_20]
mov rdx, [rsp+0A8h+var_18]
mov ecx, 4
call js_create_from_ctor
mov [rsp+0A8h+var_A8], rax
mov [rsp+0A8h+var_A0], rdx
mov rax, [rsp+0A8h+var_A8]
mov [rsp+0A8h+var_58], rax
mov rax, [rsp+0A8h+var_A0]
mov [rsp+0A8h+var_50], rax
mov rdi, [rsp+0A8h+var_58]
mov rsi, [rsp+0A8h+var_50]
call JS_IsException_1
cmp eax, 0
jnz short loc_55F34
mov rdi, [rsp+0A8h+var_28]
mov rsi, [rsp+0A8h+var_58]
mov rdx, [rsp+0A8h+var_50]
mov rcx, [rsp+0A8h+var_48]
mov r8, [rsp+0A8h+var_40]
call JS_SetObjectData
loc_55F34:
mov rax, [rsp+0A8h+var_58]
mov [rsp+0A8h+var_10], rax
mov rax, [rsp+0A8h+var_50]
mov [rsp+0A8h+var_8], rax
jmp short loc_55F6A
loc_55F50:
mov rax, [rsp+0A8h+var_48]
mov [rsp+0A8h+var_10], rax
mov rax, [rsp+0A8h+var_40]
mov [rsp+0A8h+var_8], rax
loc_55F6A:
mov rax, [rsp+0A8h+var_10]
mov rdx, [rsp+0A8h+var_8]
add rsp, 0A8h
retn
| long long js_number_constructor(
long long a1,
long long a2,
long long a3,
int a4,
_QWORD *a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
double a10,
double a11,
__m128 a12,
__m128 a13)
{
long long v13; // rdx
long long v14; // rdx
long long v15; // rdx
long long v16; // rdx
double v17; // xmm4_8
double v18; // xmm5_8
double v20[2]; // [rsp+20h] [rbp-88h] BYREF
long long v21; // [rsp+30h] [rbp-78h]
long long v22; // [rsp+38h] [rbp-70h]
long long v23; // [rsp+40h] [rbp-68h]
long long v24; // [rsp+48h] [rbp-60h]
long long v25; // [rsp+50h] [rbp-58h]
long long v26; // [rsp+58h] [rbp-50h]
long long v27; // [rsp+60h] [rbp-48h]
long long v28; // [rsp+68h] [rbp-40h]
_QWORD *v29; // [rsp+70h] [rbp-38h]
int v30; // [rsp+7Ch] [rbp-2Ch]
long long v31; // [rsp+80h] [rbp-28h]
long long v32; // [rsp+88h] [rbp-20h]
long long v33; // [rsp+90h] [rbp-18h]
long long v34; // [rsp+98h] [rbp-10h]
long long v35; // [rsp+A0h] [rbp-8h]
v32 = a2;
v33 = a3;
v31 = a1;
v30 = a4;
v29 = a5;
if ( a4 )
{
v21 = JS_ToNumeric(v31, *v29, v29[1]);
v22 = v14;
v27 = v21;
v28 = v14;
if ( JS_IsException_1(v21, v14) )
{
v34 = v27;
v35 = v28;
return v34;
}
if ( (_DWORD)v28 == -9 )
{
*(_QWORD *)&v20[1] = v27;
bf_get_float64(v27 + 8, v20, 0LL);
JS_FreeValue(v31, v27, v28);
a6 = (__m128)*(unsigned long long *)&v20[0];
v27 = js_float64(v20[0]);
v28 = v15;
}
}
else
{
v23 = js_int32(0);
v24 = v13;
v27 = v23;
v28 = v13;
}
if ( JS_IsUndefined_0(v32, v33) )
{
v34 = v27;
v35 = v28;
}
else
{
v25 = js_create_from_ctor(v31, v32, v33, 4);
v26 = v16;
if ( !JS_IsException_1(v25, v16) )
JS_SetObjectData(v31, v25, v26, v27, v28, a6, a7, a8, a9, v17, v18, a12, a13);
v34 = v25;
v35 = v26;
}
return v34;
}
| js_number_constructor:
SUB RSP,0xa8
MOV qword ptr [RSP + 0x88],RSI
MOV qword ptr [RSP + 0x90],RDX
MOV qword ptr [RSP + 0x80],RDI
MOV dword ptr [RSP + 0x7c],ECX
MOV qword ptr [RSP + 0x70],R8
CMP dword ptr [RSP + 0x7c],0x0
JNZ 0x00155dc9
XOR EDI,EDI
CALL 0x00132a00
MOV qword ptr [RSP + 0x40],RAX
MOV qword ptr [RSP + 0x48],RDX
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x60],RAX
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x68],RAX
JMP 0x00155ea3
LAB_00155dc9:
MOV RDI,qword ptr [RSP + 0x80]
MOV RAX,qword ptr [RSP + 0x70]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
CALL 0x001d0ed0
MOV qword ptr [RSP + 0x30],RAX
MOV qword ptr [RSP + 0x38],RDX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x60],RAX
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x68],RAX
MOV RDI,qword ptr [RSP + 0x60]
MOV RSI,qword ptr [RSP + 0x68]
CALL 0x00122a00
CMP EAX,0x0
JZ 0x00155e33
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x98],RAX
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RSP + 0xa0],RAX
JMP 0x00155f6a
LAB_00155e33:
MOV EAX,dword ptr [RSP + 0x68]
SUB EAX,-0x9
JNZ 0x00155e9f
JMP 0x00155e3e
LAB_00155e3e:
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x28],RAX
MOV RDI,qword ptr [RSP + 0x28]
ADD RDI,0x8
LEA RSI,[RSP + 0x20]
XOR EDX,EDX
CALL 0x001e9ae0
MOV RDI,qword ptr [RSP + 0x80]
MOV RSI,qword ptr [RSP + 0x60]
MOV RDX,qword ptr [RSP + 0x68]
CALL 0x001229d0
MOVSD XMM0,qword ptr [RSP + 0x20]
CALL 0x0014c3a0
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x18],RDX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x60],RAX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x68],RAX
JMP 0x00155ea1
LAB_00155e9f:
JMP 0x00155ea1
LAB_00155ea1:
JMP 0x00155ea3
LAB_00155ea3:
MOV RDI,qword ptr [RSP + 0x88]
MOV RSI,qword ptr [RSP + 0x90]
CALL 0x0012cfa0
CMP EAX,0x0
JNZ 0x00155f50
MOV RDI,qword ptr [RSP + 0x80]
MOV RSI,qword ptr [RSP + 0x88]
MOV RDX,qword ptr [RSP + 0x90]
MOV ECX,0x4
CALL 0x00153b40
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x8],RDX
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSP + 0x50],RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x58],RAX
MOV RDI,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RSP + 0x58]
CALL 0x00122a00
CMP EAX,0x0
JNZ 0x00155f34
MOV RDI,qword ptr [RSP + 0x80]
MOV RSI,qword ptr [RSP + 0x50]
MOV RDX,qword ptr [RSP + 0x58]
MOV RCX,qword ptr [RSP + 0x60]
MOV R8,qword ptr [RSP + 0x68]
CALL 0x00153d50
LAB_00155f34:
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x98],RAX
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0xa0],RAX
JMP 0x00155f6a
LAB_00155f50:
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x98],RAX
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RSP + 0xa0],RAX
LAB_00155f6a:
MOV RAX,qword ptr [RSP + 0x98]
MOV RDX,qword ptr [RSP + 0xa0]
ADD RSP,0xa8
RET
|
int1 [16]
js_number_constructor
(int8 param_1,int8 param_2,int8 param_3,int param_4,int8 *param_5)
{
int iVar1;
int1 auVar2 [16];
int8 local_88;
long local_80;
int1 local_78 [16];
int1 local_68 [16];
int1 local_58 [16];
int1 local_48 [16];
int8 *local_38;
int local_2c;
int8 local_28;
int8 local_20;
int8 local_18;
local_38 = param_5;
local_2c = param_4;
local_28 = param_1;
local_20 = param_2;
local_18 = param_3;
if (param_4 == 0) {
local_68 = js_int32(0);
local_48 = local_68;
}
else {
local_78 = JS_ToNumeric(param_1,*param_5,param_5[1]);
local_48 = local_78;
iVar1 = JS_IsException(local_78._0_8_,local_78._8_8_);
if (iVar1 != 0) {
return local_48;
}
if (local_48._8_4_ == -9) {
local_80 = local_48._0_8_;
bf_get_float64(local_48._0_8_ + 8,&local_88,0);
JS_FreeValue(local_28,local_48._0_8_,local_48._8_8_);
auVar2 = js_float64(local_88);
local_48 = auVar2;
}
}
iVar1 = JS_IsUndefined(local_20,local_18);
auVar2 = local_48;
if (iVar1 == 0) {
local_58 = js_create_from_ctor(local_28,local_20,local_18,4);
iVar1 = JS_IsException(local_58._0_8_,local_58._8_8_);
auVar2 = local_58;
if (iVar1 == 0) {
JS_SetObjectData(local_28,local_58._0_8_,local_58._8_8_,local_48._0_8_,local_48._8_8_);
auVar2 = local_58;
}
}
return auVar2;
}
| |
44,783 | js_number_constructor | bluesky950520[P]quickjs/quickjs.c | static JSValue js_number_constructor(JSContext *ctx, JSValue new_target,
int argc, JSValue *argv)
{
JSValue val, obj;
if (argc == 0) {
val = js_int32(0);
} else {
val = JS_ToNumeric(ctx, argv[0]);
if (JS_IsException(val))
return val;
switch(JS_VALUE_GET_TAG(val)) {
case JS_TAG_BIG_INT:
{
JSBigInt *p = JS_VALUE_GET_PTR(val);
double d;
bf_get_float64(&p->num, &d, BF_RNDN);
JS_FreeValue(ctx, val);
val = js_float64(d);
}
break;
default:
break;
}
}
if (!JS_IsUndefined(new_target)) {
obj = js_create_from_ctor(ctx, new_target, JS_CLASS_NUMBER);
if (!JS_IsException(obj))
JS_SetObjectData(ctx, obj, val);
return obj;
} else {
return val;
}
} | O1 | c | js_number_constructor:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testl %ecx, %ecx
je 0x37cbb
movq (%r8), %rsi
movq 0x8(%r8), %rdx
movq %rsi, 0x8(%rsp)
cmpl $-0x9, %edx
jb 0x37c61
movq 0x8(%rsp), %rax
incl (%rax)
movq %rbx, %rdi
movl $0x1, %ecx
callq 0x41f0c
movq %rdx, %r12
movq %rax, 0x8(%rsp)
cmpl $0x6, %r12d
je 0x37cc8
cmpl $-0x9, %r12d
jne 0x37ccd
movq 0x8(%rsp), %r13
leaq 0x8(%r13), %rdi
leaq 0x10(%rsp), %rbp
movq %rbp, %rsi
xorl %edx, %edx
callq 0x878da
movq 0x18(%rbx), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x1ccb2
movsd (%rbp), %xmm0
movsd %xmm0, 0x8(%rsp)
movl $0x7, %ebp
jmp 0x37cd0
movq $0x0, 0x8(%rsp)
xorl %ebp, %ebp
jmp 0x37cd0
movq %rax, %r13
jmp 0x37d15
movq %r12, %rbp
cmpl $0x3, %r14d
jne 0x37ce0
movq 0x8(%rsp), %r13
movq %rbp, %r12
jmp 0x37d15
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl $0x4, %ecx
callq 0x36142
movq %rax, %r13
movq %rdx, %r12
cmpl $0x6, %r12d
je 0x37d15
movq 0x8(%rsp), %rcx
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %rbp, %r8
callq 0x3624e
movq %r13, %rax
movq %r12, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| js_number_constructor:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r14, rdx
mov r15, rsi
mov rbx, rdi
test ecx, ecx
jz short loc_37CBB
mov rsi, [r8]
mov rdx, [r8+8]
mov [rsp+48h+var_40], rsi
cmp edx, 0FFFFFFF7h
jb short loc_37C61
mov rax, [rsp+48h+var_40]
inc dword ptr [rax]
loc_37C61:
mov rdi, rbx
mov ecx, 1
call JS_ToNumberHintFree
mov r12, rdx
mov [rsp+48h+var_40], rax
cmp r12d, 6
jz short loc_37CC8
cmp r12d, 0FFFFFFF7h
jnz short loc_37CCD
mov r13, [rsp+48h+var_40]
lea rdi, [r13+8]
lea rbp, [rsp+48h+var_38]
mov rsi, rbp
xor edx, edx
call bf_get_float64
mov rdi, [rbx+18h]
mov rsi, r13
mov rdx, r12
call JS_FreeValueRT
movsd xmm0, qword ptr [rbp+0]
movsd [rsp+48h+var_40], xmm0
mov ebp, 7
jmp short loc_37CD0
loc_37CBB:
mov [rsp+48h+var_40], 0
xor ebp, ebp
jmp short loc_37CD0
loc_37CC8:
mov r13, rax
jmp short loc_37D15
loc_37CCD:
mov rbp, r12
loc_37CD0:
cmp r14d, 3
jnz short loc_37CE0
mov r13, [rsp+48h+var_40]
mov r12, rbp
jmp short loc_37D15
loc_37CE0:
mov rdi, rbx
mov rsi, r15
mov rdx, r14
mov ecx, 4
call js_create_from_ctor
mov r13, rax
mov r12, rdx
cmp r12d, 6
jz short loc_37D15
mov rcx, [rsp+48h+var_40]
mov rdi, rbx
mov rsi, r13
mov rdx, r12
mov r8, rbp
call JS_SetObjectData
loc_37D15:
mov rax, r13
mov rdx, r12
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| _DWORD * js_number_constructor(
long long a1,
long long a2,
long long a3,
int a4,
_QWORD *a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
double a10,
double a11,
__m128 a12,
__m128 a13)
{
_DWORD *v15; // rsi
long long v16; // rdx
long long v17; // rax
long long v18; // rdx
long long v19; // r12
long long v20; // rbp
unsigned long long v21; // r13
unsigned long long v22; // rax
int v23; // edx
long long v24; // r9
double v25; // xmm4_8
double v26; // xmm5_8
char v28; // [rsp+0h] [rbp-48h]
_DWORD *v29; // [rsp+8h] [rbp-40h]
_DWORD *v30; // [rsp+10h] [rbp-38h] BYREF
if ( a4 )
{
v15 = (_DWORD *)*a5;
v16 = a5[1];
if ( (unsigned int)v16 >= 0xFFFFFFF7 )
++*(_DWORD *)*a5;
v17 = JS_ToNumberHintFree(a1, v15, v16, 1LL);
v19 = v18;
v29 = (_DWORD *)v17;
if ( (_DWORD)v18 == 6 )
return (_DWORD *)v17;
if ( (_DWORD)v18 == -9 )
{
bf_get_float64(v17 + 8, &v30, 0LL);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v29, v19);
a6 = (__m128)(unsigned long long)v30;
v29 = v30;
v20 = 7LL;
}
else
{
v20 = v18;
}
}
else
{
v29 = 0LL;
v20 = 0LL;
}
if ( (_DWORD)a3 == 3 )
return v29;
v22 = js_create_from_ctor(a1, a2, a3, 4);
v21 = v22;
if ( v23 != 6 )
JS_SetObjectData(a1, v22, v23, v29, v20, a6, a7, a8, a9, v25, v26, a12, a13, v24, v28);
return (_DWORD *)v21;
}
| js_number_constructor:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
TEST ECX,ECX
JZ 0x00137cbb
MOV RSI,qword ptr [R8]
MOV RDX,qword ptr [R8 + 0x8]
MOV qword ptr [RSP + 0x8],RSI
CMP EDX,-0x9
JC 0x00137c61
MOV RAX,qword ptr [RSP + 0x8]
INC dword ptr [RAX]
LAB_00137c61:
MOV RDI,RBX
MOV ECX,0x1
CALL 0x00141f0c
MOV R12,RDX
MOV qword ptr [RSP + 0x8],RAX
CMP R12D,0x6
JZ 0x00137cc8
CMP R12D,-0x9
JNZ 0x00137ccd
MOV R13,qword ptr [RSP + 0x8]
LEA RDI,[R13 + 0x8]
LEA RBP,[RSP + 0x10]
MOV RSI,RBP
XOR EDX,EDX
CALL 0x001878da
MOV RDI,qword ptr [RBX + 0x18]
MOV RSI,R13
MOV RDX,R12
CALL 0x0011ccb2
MOVSD XMM0,qword ptr [RBP]
MOVSD qword ptr [RSP + 0x8],XMM0
MOV EBP,0x7
JMP 0x00137cd0
LAB_00137cbb:
MOV qword ptr [RSP + 0x8],0x0
XOR EBP,EBP
JMP 0x00137cd0
LAB_00137cc8:
MOV R13,RAX
JMP 0x00137d15
LAB_00137ccd:
MOV RBP,R12
LAB_00137cd0:
CMP R14D,0x3
JNZ 0x00137ce0
MOV R13,qword ptr [RSP + 0x8]
MOV R12,RBP
JMP 0x00137d15
LAB_00137ce0:
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
MOV ECX,0x4
CALL 0x00136142
MOV R13,RAX
MOV R12,RDX
CMP R12D,0x6
JZ 0x00137d15
MOV RCX,qword ptr [RSP + 0x8]
MOV RDI,RBX
MOV RSI,R13
MOV RDX,R12
MOV R8,RBP
CALL 0x0013624e
LAB_00137d15:
MOV RAX,R13
MOV RDX,R12
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int1 [16]
js_number_constructor
(long param_1,int8 param_2,int8 param_3,int param_4,int8 *param_5)
{
int *piVar1;
int8 uVar2;
int1 auVar3 [16];
int8 local_40;
long local_38;
if (param_4 == 0) {
auVar3 = ZEXT816(0);
}
else {
piVar1 = (int *)*param_5;
uVar2 = param_5[1];
if (0xfffffff6 < (uint)uVar2) {
*piVar1 = *piVar1 + 1;
}
auVar3 = JS_ToNumberHintFree(param_1,piVar1,uVar2,1);
if (auVar3._8_4_ == 6) {
return auVar3;
}
if (auVar3._8_4_ == -9) {
bf_get_float64(auVar3._0_8_ + 8,&local_38,0);
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),auVar3._0_8_,auVar3._8_8_);
auVar3._8_8_ = 7;
auVar3._0_8_ = local_38;
}
}
uVar2 = auVar3._8_8_;
local_40 = auVar3._0_8_;
if ((int)param_3 != 3) {
auVar3 = js_create_from_ctor(param_1,param_2,param_3,4);
if (auVar3._8_4_ != 6) {
JS_SetObjectData(param_1,auVar3._0_8_,auVar3._8_8_,local_40,uVar2);
}
}
return auVar3;
}
| |
44,784 | vsort_with_comparator | davidesantangelo[P]vsort/vsort.c | VSORT_API void vsort_with_comparator(void *arr, int n, size_t size, int (*compare)(const void *, const void *))
{
vsort_init();
if (!arr || n <= 1 || size == 0 || !compare)
return;
vsort_log_debug("Starting vsort (generic) for %d elements, size %zu (using qsort fallback).", n, size);
qsort(arr, n, size, compare);
vsort_log_debug("vsort (generic) completed for %d elements.", n);
} | O0 | c | vsort_with_comparator:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
callq 0x1920
cmpq $0x0, 0x20(%rsp)
je 0x1f4b
cmpl $0x1, 0x1c(%rsp)
jle 0x1f4b
cmpq $0x0, 0x10(%rsp)
je 0x1f4b
cmpq $0x0, 0x8(%rsp)
jne 0x1f4d
jmp 0x1f8f
movl 0x1c(%rsp), %esi
movq 0x10(%rsp), %rdx
leaq 0x3417(%rip), %rdi # 0x5374
movb $0x0, %al
callq 0x4610
movq 0x20(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x1080
movl 0x1c(%rsp), %esi
leaq 0x3437(%rip), %rdi # 0x53bf
movb $0x0, %al
callq 0x4610
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
| vsort_with_comparator:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov [rsp+28h+var_C], esi
mov [rsp+28h+var_18], rdx
mov [rsp+28h+var_20], rcx
call vsort_init
cmp [rsp+28h+var_8], 0
jz short loc_1F4B
cmp [rsp+28h+var_C], 1
jle short loc_1F4B
cmp [rsp+28h+var_18], 0
jz short loc_1F4B
cmp [rsp+28h+var_20], 0
jnz short loc_1F4D
loc_1F4B:
jmp short loc_1F8F
loc_1F4D:
mov esi, [rsp+28h+var_C]
mov rdx, [rsp+28h+var_18]
lea rdi, aStartingVsortG; "Starting vsort (generic) for %d element"...
mov al, 0
call vsort_log_debug
mov rdi, [rsp+28h+var_8]
movsxd rsi, [rsp+28h+var_C]
mov rdx, [rsp+28h+var_18]
mov rcx, [rsp+28h+var_20]
call _qsort
mov esi, [rsp+28h+var_C]
lea rdi, aVsortGenericCo; "vsort (generic) completed for %d elemen"...
mov al, 0
call vsort_log_debug
loc_1F8F:
add rsp, 28h
retn
| long long vsort_with_comparator(long long a1, int a2, long long a3, long long a4)
{
int v4; // ecx
int v5; // r8d
int v6; // r9d
int v7; // edx
int v8; // ecx
int v9; // r8d
int v10; // r9d
long long result; // rax
vsort_init();
if ( a1 && a2 > 1 && a3 )
{
if ( a4 )
{
vsort_log_debug(
(unsigned int)"Starting vsort (generic) for %d elements, size %zu (using qsort fallback).",
a2,
a3,
v4,
v5,
v6);
qsort(a1, a2, a3, a4);
return vsort_log_debug((unsigned int)"vsort (generic) completed for %d elements.", a2, v7, v8, v9, v10);
}
}
return result;
}
| vsort_with_comparator:
SUB RSP,0x28
MOV qword ptr [RSP + 0x20],RDI
MOV dword ptr [RSP + 0x1c],ESI
MOV qword ptr [RSP + 0x10],RDX
MOV qword ptr [RSP + 0x8],RCX
CALL 0x00101920
CMP qword ptr [RSP + 0x20],0x0
JZ 0x00101f4b
CMP dword ptr [RSP + 0x1c],0x1
JLE 0x00101f4b
CMP qword ptr [RSP + 0x10],0x0
JZ 0x00101f4b
CMP qword ptr [RSP + 0x8],0x0
JNZ 0x00101f4d
LAB_00101f4b:
JMP 0x00101f8f
LAB_00101f4d:
MOV ESI,dword ptr [RSP + 0x1c]
MOV RDX,qword ptr [RSP + 0x10]
LEA RDI,[0x105374]
MOV AL,0x0
CALL 0x00104610
MOV RDI,qword ptr [RSP + 0x20]
MOVSXD RSI,dword ptr [RSP + 0x1c]
MOV RDX,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP + 0x8]
CALL 0x00101080
MOV ESI,dword ptr [RSP + 0x1c]
LEA RDI,[0x1053bf]
MOV AL,0x0
CALL 0x00104610
LAB_00101f8f:
ADD RSP,0x28
RET
|
void vsort_with_comparator(void *param_1,int param_2,size_t param_3,__compar_fn_t param_4)
{
vsort_init();
if ((((param_1 != (void *)0x0) && (1 < param_2)) && (param_3 != 0)) &&
(param_4 != (__compar_fn_t)0x0)) {
vsort_log_debug("Starting vsort (generic) for %d elements, size %zu (using qsort fallback).",
param_2,param_3);
qsort(param_1,(long)param_2,param_3,param_4);
vsort_log_debug("vsort (generic) completed for %d elements.",param_2);
}
return;
}
| |
44,785 | vsort_with_comparator | davidesantangelo[P]vsort/vsort.c | VSORT_API void vsort_with_comparator(void *arr, int n, size_t size, int (*compare)(const void *, const void *))
{
vsort_init();
if (!arr || n <= 1 || size == 0 || !compare)
return;
vsort_log_debug("Starting vsort (generic) for %d elements, size %zu (using qsort fallback).", n, size);
qsort(arr, n, size, compare);
vsort_log_debug("vsort (generic) completed for %d elements.", n);
} | O3 | c | vsort_with_comparator:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r12
callq 0x19a4
testq %r12, %r12
sete %al
cmpl $0x2, %ebx
setl %cl
testq %r15, %r15
sete %dl
orb %al, %dl
testq %r14, %r14
sete %al
orb %cl, %al
orb %dl, %al
jne 0x1353
leaq 0x2048(%rip), %rdi # 0x3364
movl %ebx, %esi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2d92
movl %ebx, %esi
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x1080
leaq 0x2070(%rip), %rdi # 0x33af
movl %ebx, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2d92
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| vsort_with_comparator:
push r15
push r14
push r12
push rbx
push rax
mov r14, rcx
mov r15, rdx
mov ebx, esi
mov r12, rdi
call vsort_init
test r12, r12
setz al
cmp ebx, 2
setl cl
test r15, r15
setz dl
or dl, al
test r14, r14
setz al
or al, cl
or al, dl
jnz short loc_1353
lea rdi, aStartingVsortG; "Starting vsort (generic) for %d element"...
mov esi, ebx
mov rdx, r15
xor eax, eax
call vsort_log_debug
mov esi, ebx
mov rdi, r12
mov rdx, r15
mov rcx, r14
call _qsort
lea rdi, aVsortGenericCo; "vsort (generic) completed for %d elemen"...
mov esi, ebx
xor eax, eax
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
jmp vsort_log_debug
loc_1353:
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| char vsort_with_comparator(long long a1, int a2, long long a3, long long a4, long long a5, long long a6, char a7)
{
char v7; // al
int v10; // ecx
int v11; // r8d
int v12; // r9d
char result; // al
int v14; // edx
int v15; // ecx
int v16; // r8d
int v17; // r9d
char v18; // [rsp-8h] [rbp-28h]
v18 = v7;
vsort_init();
result = a1 == 0 || a3 == 0 || a2 < 2 || a4 == 0;
if ( !result )
{
LOBYTE(v10) = a2 < 2;
vsort_log_debug(
(unsigned int)"Starting vsort (generic) for %d elements, size %zu (using qsort fallback).",
a2,
a3,
v10,
v11,
v12,
v18);
qsort(a1, (unsigned int)a2, a3, a4);
return vsort_log_debug((unsigned int)"vsort (generic) completed for %d elements.", a2, v14, v15, v16, v17, a7);
}
return result;
}
| vsort_with_comparator:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RCX
MOV R15,RDX
MOV EBX,ESI
MOV R12,RDI
CALL 0x001019a4
TEST R12,R12
SETZ AL
CMP EBX,0x2
SETL CL
TEST R15,R15
SETZ DL
OR DL,AL
TEST R14,R14
SETZ AL
OR AL,CL
OR AL,DL
JNZ 0x00101353
LEA RDI,[0x103364]
MOV ESI,EBX
MOV RDX,R15
XOR EAX,EAX
CALL 0x00102d92
MOV ESI,EBX
MOV RDI,R12
MOV RDX,R15
MOV RCX,R14
CALL 0x00101080
LEA RDI,[0x1033af]
MOV ESI,EBX
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
JMP 0x00102d92
LAB_00101353:
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
void vsort_with_comparator(void *param_1,uint param_2,size_t param_3,__compar_fn_t param_4)
{
vsort_init();
if ((param_4 != (__compar_fn_t)0x0 && 1 < (int)param_2) &&
(param_3 != 0 && param_1 != (void *)0x0)) {
vsort_log_debug("Starting vsort (generic) for %d elements, size %zu (using qsort fallback).",
param_2,param_3);
qsort(param_1,(ulong)param_2,param_3,param_4);
vsort_log_debug("vsort (generic) completed for %d elements.",param_2);
return;
}
return;
}
| |
44,786 | fmt::v10::detail::adjust_precision(int&, int) | aimrt_mujoco_sim/_deps/fmt-src/include/fmt/format.h | inline FMT_CONSTEXPR20 void adjust_precision(int& precision, int exp10) {
// Adjust fixed precision by exponent because it is relative to decimal
// point.
if (exp10 > 0 && precision > max_value<int>() - exp10)
FMT_THROW(format_error("number is too big"));
precision += exp10;
} | O0 | c | fmt::v10::detail::adjust_precision(int&, int):
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
jle 0xb5814
movq 0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x8(%rsp)
callq 0xa6ee0
movl %eax, %ecx
movl 0x8(%rsp), %eax
subl 0x1c(%rsp), %ecx
cmpl %ecx, %eax
jle 0xb5814
movl $0x10, %edi
callq 0x8e630
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
leaq 0x328122(%rip), %rsi # 0x3dd8ff
callq 0x9f780
jmp 0xb57e4
movq (%rsp), %rdi
leaq 0x4440a1(%rip), %rsi # 0x4f9890
leaq -0x16036(%rip), %rdx # 0x9f7c0
callq 0x90860
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
callq 0x93710
jmp 0xb5826
movl 0x1c(%rsp), %ecx
movq 0x20(%rsp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
addq $0x28, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0x90db0
| _ZN3fmt3v106detail16adjust_precisionERii:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov [rsp+28h+var_C], esi
cmp [rsp+28h+var_C], 0
jle short loc_B5814
mov rax, [rsp+28h+var_8]
mov eax, [rax]
mov [rsp+28h+var_20], eax
call _ZN3fmt3v106detail9max_valueIiEET_v; fmt::v10::detail::max_value<int>(void)
mov ecx, eax
mov eax, [rsp+28h+var_20]
sub ecx, [rsp+28h+var_C]
cmp eax, ecx
jle short loc_B5814
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rdi, rax
mov rax, rdi
mov [rsp+28h+var_28], rax
lea rsi, aNumberIsTooBig; "number is too big"
call _ZN3fmt3v1012format_errorCI2St13runtime_errorEPKc
jmp short $+2
loc_B57E4:
mov rdi, [rsp+28h+var_28]; void *
lea rsi, _ZTIN3fmt3v1012format_errorE; lptinfo
lea rdx, _ZN3fmt3v1012format_errorD2Ev; void (*)(void *)
call ___cxa_throw
mov rdi, [rsp+28h+var_28]; void *
mov rcx, rax
mov eax, edx
mov [rsp+28h+var_18], rcx
mov [rsp+28h+var_1C], eax
call ___cxa_free_exception
jmp short loc_B5826
loc_B5814:
mov ecx, [rsp+28h+var_C]
mov rax, [rsp+28h+var_8]
add ecx, [rax]
mov [rax], ecx
add rsp, 28h
retn
loc_B5826:
mov rdi, [rsp+28h+var_18]
call __Unwind_Resume
| fmt::v10::detail * fmt::v10::detail::adjust_precision(fmt::v10::detail *this, int *a2)
{
fmt::v10::detail *result; // rax
std::runtime_error *exception; // [rsp+0h] [rbp-28h]
signed int v4; // [rsp+8h] [rbp-20h]
if ( (int)a2 > 0 )
{
v4 = *(_DWORD *)this;
if ( v4 > (int)(fmt::v10::detail::max_value<int>((long long)this) - (_DWORD)a2) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
ZN3fmt3v1012format_errorCI2St13runtime_errorEPKc(exception, "number is too big");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'fmt::v10::format_error,
(void (*)(void *))fmt::v10::format_error::~format_error);
}
}
result = this;
*(_DWORD *)this += (_DWORD)a2;
return result;
}
| adjust_precision:
SUB RSP,0x28
MOV qword ptr [RSP + 0x20],RDI
MOV dword ptr [RSP + 0x1c],ESI
CMP dword ptr [RSP + 0x1c],0x0
JLE 0x001b5814
MOV RAX,qword ptr [RSP + 0x20]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RSP + 0x8],EAX
CALL 0x001a6ee0
MOV ECX,EAX
MOV EAX,dword ptr [RSP + 0x8]
SUB ECX,dword ptr [RSP + 0x1c]
CMP EAX,ECX
JLE 0x001b5814
MOV EDI,0x10
CALL 0x0018e630
MOV RDI,RAX
MOV RAX,RDI
MOV qword ptr [RSP],RAX
LAB_001b57d6:
LEA RSI,[0x4dd8ff]
CALL 0x0019f780
LAB_001b57e2:
JMP 0x001b57e4
LAB_001b57e4:
MOV RDI,qword ptr [RSP]
LEA RSI,[0x5f9890]
LEA RDX,[0x19f7c0]
CALL 0x00190860
LAB_001b5814:
MOV ECX,dword ptr [RSP + 0x1c]
MOV RAX,qword ptr [RSP + 0x20]
ADD ECX,dword ptr [RAX]
MOV dword ptr [RAX],ECX
ADD RSP,0x28
RET
|
/* fmt::v10::detail::adjust_precision(int&, int) */
void fmt::v10::detail::adjust_precision(int *param_1,int param_2)
{
int iVar1;
int iVar2;
format_error *this;
if (0 < param_2) {
iVar1 = *param_1;
iVar2 = max_value<int>();
if (iVar2 - param_2 < iVar1) {
this = (format_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001b57d6 to 001b57e1 has its CatchHandler @ 001b57fb */
format_error::runtime_error(this,"number is too big");
/* WARNING: Subroutine does not return */
__cxa_throw(this,&format_error::typeinfo,format_error::~format_error);
}
}
*param_1 = param_2 + *param_1;
return;
}
| |
44,787 | my_hash_first_from_hash_value | eloqsql/mysys/hash.c | uchar* my_hash_first_from_hash_value(const HASH *hash,
my_hash_value_type hash_value,
const uchar *key,
size_t length,
HASH_SEARCH_STATE *current_record)
{
HASH_LINK *pos;
DBUG_ENTER("my_hash_first_from_hash_value");
if (hash->records)
{
uint flag= 1;
uint idx= my_hash_mask(hash_value,
hash->blength, hash->records);
do
{
pos= dynamic_element(&hash->array,idx,HASH_LINK*);
if (!hashcmp(hash,pos,key,length))
{
DBUG_PRINT("exit",("found key at %d",idx));
*current_record= idx;
DBUG_RETURN (pos->data);
}
if (flag)
{
flag=0; /* Reset flag */
if (my_hash_rec_mask(pos, hash->blength, hash->records) != idx)
break; /* Wrong link */
}
}
while ((idx=pos->next) != NO_RECORD);
}
*current_record= NO_RECORD;
DBUG_RETURN(0);
} | O0 | c | my_hash_first_from_hash_value:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xde25c
movl $0x1, -0x3c(%rbp)
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0xde280
movl %eax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x40(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0xde2d0
cmpl $0x0, %eax
jne 0xde217
jmp 0xde1fe
jmp 0xde200
movl -0x40(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xde26e
cmpl $0x0, -0x3c(%rbp)
je 0xde246
movl $0x0, -0x3c(%rbp)
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0xde370
cmpl -0x40(%rbp), %eax
je 0xde244
jmp 0xde25a
jmp 0xde246
jmp 0xde248
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x40(%rbp)
cmpl $-0x1, %eax
jne 0xde1cc
jmp 0xde25c
movq -0x30(%rbp), %rax
movl $0xffffffff, (%rax) # imm = 0xFFFFFFFF
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| my_hash_first_from_hash_value:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov rax, [rbp+var_10]
cmp qword ptr [rax+18h], 0
jz loc_DE25C
mov [rbp+var_3C], 1
mov edi, [rbp+var_14]
mov rax, [rbp+var_10]
mov rsi, [rax+10h]
mov rax, [rbp+var_10]
mov rdx, [rax+18h]
call my_hash_mask
mov [rbp+var_40], eax
loc_DE1CC:
mov rax, [rbp+var_10]
mov rax, [rax+28h]
mov ecx, [rbp+var_40]
shl rcx, 4
add rax, rcx
mov [rbp+var_38], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_38]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_28]
call hashcmp
cmp eax, 0
jnz short loc_DE217
jmp short $+2
loc_DE1FE:
jmp short $+2
loc_DE200:
mov ecx, [rbp+var_40]
mov rax, [rbp+var_30]
mov [rax], ecx
mov rax, [rbp+var_38]
mov rax, [rax+8]
mov [rbp+var_8], rax
jmp short loc_DE26E
loc_DE217:
cmp [rbp+var_3C], 0
jz short loc_DE246
mov [rbp+var_3C], 0
mov rdi, [rbp+var_38]
mov rax, [rbp+var_10]
mov rsi, [rax+10h]
mov rax, [rbp+var_10]
mov rdx, [rax+18h]
call my_hash_rec_mask
cmp eax, [rbp+var_40]
jz short loc_DE244
jmp short loc_DE25A
loc_DE244:
jmp short $+2
loc_DE246:
jmp short $+2
loc_DE248:
mov rax, [rbp+var_38]
mov eax, [rax]
mov [rbp+var_40], eax
cmp eax, 0FFFFFFFFh
jnz loc_DE1CC
loc_DE25A:
jmp short $+2
loc_DE25C:
mov rax, [rbp+var_30]
mov dword ptr [rax], 0FFFFFFFFh
mov [rbp+var_8], 0
loc_DE26E:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
| long long my_hash_first_from_hash_value(_QWORD *a1, unsigned int a2, long long a3, long long a4, unsigned int *a5)
{
unsigned int v6; // [rsp+0h] [rbp-40h]
int v7; // [rsp+4h] [rbp-3Ch]
long long v8; // [rsp+8h] [rbp-38h]
if ( a1[3] )
{
v7 = 1;
v6 = my_hash_mask(a2, a1[2], a1[3]);
while ( 1 )
{
v8 = 16LL * v6 + a1[5];
if ( !(unsigned int)hashcmp(a1, v8, a3, a4) )
break;
if ( !v7 || (v7 = 0, (unsigned int)my_hash_rec_mask(v8, a1[2], a1[3]) == v6) )
{
v6 = *(_DWORD *)v8;
if ( *(_DWORD *)v8 != -1 )
continue;
}
goto LABEL_8;
}
*a5 = v6;
return *(_QWORD *)(v8 + 8);
}
else
{
LABEL_8:
*a5 = -1;
return 0LL;
}
}
| my_hash_first_from_hash_value:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x18],0x0
JZ 0x001de25c
MOV dword ptr [RBP + -0x3c],0x1
MOV EDI,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x18]
CALL 0x001de280
MOV dword ptr [RBP + -0x40],EAX
LAB_001de1cc:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x28]
MOV ECX,dword ptr [RBP + -0x40]
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x28]
CALL 0x001de2d0
CMP EAX,0x0
JNZ 0x001de217
JMP 0x001de1fe
LAB_001de1fe:
JMP 0x001de200
LAB_001de200:
MOV ECX,dword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001de26e
LAB_001de217:
CMP dword ptr [RBP + -0x3c],0x0
JZ 0x001de246
MOV dword ptr [RBP + -0x3c],0x0
MOV RDI,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x18]
CALL 0x001de370
CMP EAX,dword ptr [RBP + -0x40]
JZ 0x001de244
JMP 0x001de25a
LAB_001de244:
JMP 0x001de246
LAB_001de246:
JMP 0x001de248
LAB_001de248:
MOV RAX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x40],EAX
CMP EAX,-0x1
JNZ 0x001de1cc
LAB_001de25a:
JMP 0x001de25c
LAB_001de25c:
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],0xffffffff
MOV qword ptr [RBP + -0x8],0x0
LAB_001de26e:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
int8
my_hash_first_from_hash_value
(long param_1,int4 param_2,int8 param_3,int8 param_4,uint *param_5)
{
bool bVar1;
int iVar2;
uint uVar3;
uint *puVar4;
uint local_48;
if (*(long *)(param_1 + 0x18) != 0) {
bVar1 = true;
local_48 = my_hash_mask(param_2,*(int8 *)(param_1 + 0x10),*(int8 *)(param_1 + 0x18))
;
do {
puVar4 = (uint *)(*(long *)(param_1 + 0x28) + (ulong)local_48 * 0x10);
iVar2 = hashcmp(param_1,puVar4,param_3,param_4);
if (iVar2 == 0) {
*param_5 = local_48;
return *(int8 *)(puVar4 + 2);
}
if (bVar1) {
bVar1 = false;
uVar3 = my_hash_rec_mask(puVar4,*(int8 *)(param_1 + 0x10),
*(int8 *)(param_1 + 0x18));
if (uVar3 != local_48) break;
}
local_48 = *puVar4;
} while (local_48 != 0xffffffff);
}
*param_5 = 0xffffffff;
return 0;
}
| |
44,788 | print_name | eloqsql/mysys/my_getopt.c | static uint print_name(const struct my_option *optp)
{
const char *s= optp->name;
for (;*s;s++)
putchar(*s == '_' ? '-' : *s);
return (uint)(s - optp->name);
} | O0 | c | print_name:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x7bf26
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5f, %eax
jne 0x7bf06
movl $0x2d, %eax
movl %eax, -0x14(%rbp)
jmp 0x7bf10
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x36b50
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x7bee7
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| print_name:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_10], rax
loc_7BEE7:
mov rax, [rbp+var_10]
cmp byte ptr [rax], 0
jz short loc_7BF26
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 5Fh ; '_'
jnz short loc_7BF06
mov eax, 2Dh ; '-'
mov [rbp+var_14], eax
jmp short loc_7BF10
loc_7BF06:
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
mov [rbp+var_14], eax
loc_7BF10:
mov edi, [rbp+var_14]
call _putchar
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp short loc_7BEE7
loc_7BF26:
mov rax, [rbp+var_10]
mov rcx, [rbp+var_8]
mov rcx, [rcx]
sub rax, rcx
add rsp, 20h
pop rbp
retn
| long long print_name(_BYTE **a1)
{
unsigned int v2; // [rsp+Ch] [rbp-14h]
_BYTE *i; // [rsp+10h] [rbp-10h]
for ( i = *a1; *i; ++i )
{
if ( *i == 95 )
v2 = 45;
else
v2 = (char)*i;
putchar(v2);
}
return i - *a1;
}
| print_name:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x10],RAX
LAB_0017bee7:
MOV RAX,qword ptr [RBP + -0x10]
CMP byte ptr [RAX],0x0
JZ 0x0017bf26
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x5f
JNZ 0x0017bf06
MOV EAX,0x2d
MOV dword ptr [RBP + -0x14],EAX
JMP 0x0017bf10
LAB_0017bf06:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
MOV dword ptr [RBP + -0x14],EAX
LAB_0017bf10:
MOV EDI,dword ptr [RBP + -0x14]
CALL 0x00136b50
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x0017bee7
LAB_0017bf26:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RCX]
SUB RAX,RCX
ADD RSP,0x20
POP RBP
RET
|
long print_name(long *param_1)
{
int local_1c;
char *local_18;
for (local_18 = (char *)*param_1; *local_18 != '\0'; local_18 = local_18 + 1) {
if (*local_18 == '_') {
local_1c = 0x2d;
}
else {
local_1c = (int)*local_18;
}
putchar(local_1c);
}
return (long)local_18 - *param_1;
}
| |
44,789 | my_strxfrm_pad_desc_and_reverse_nopad | eloqsql/strings/ctype-simple.c | size_t
my_strxfrm_pad_desc_and_reverse_nopad(CHARSET_INFO *cs,
uchar *str, uchar *frmend, uchar *strend,
uint nweights, uint flags, uint level)
{
if (nweights && frmend < strend && (flags & MY_STRXFRM_PAD_WITH_SPACE))
{
uint fill_length= MY_MIN((uint) (strend - frmend), nweights * cs->mbminlen);
memset(frmend, 0x00, fill_length);
frmend+= fill_length;
}
my_strxfrm_desc_and_reverse(str, frmend, flags, level);
if ((flags & MY_STRXFRM_PAD_TO_MAXLEN) && frmend < strend)
{
size_t fill_length= strend - frmend;
memset(frmend, 0x00, fill_length);
frmend= strend;
}
return frmend - str;
} | O3 | c | my_strxfrm_pad_desc_and_reverse_nopad:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r12d
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rbx
movl 0x10(%rbp), %ecx
testl %r8d, %r8d
sete %al
cmpq %r15, %rdx
setae %sil
testb $0x40, %r12b
sete %dl
orb %al, %dl
orb %sil, %dl
jne 0x3d17d
movl %r8d, %r13d
movl %r15d, %eax
imull 0x98(%rdi), %r13d
subl %r14d, %eax
cmpl %eax, %r13d
cmovael %eax, %r13d
movq %r14, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x241e0
movl 0x10(%rbp), %ecx
addq %r13, %r14
movq %rbx, %rdi
movq %r14, %rsi
movl %r12d, %edx
callq 0x3e9be
testb %r12b, %r12b
jns 0x3d1a8
cmpq %r15, %r14
jae 0x3d1a8
movq %r15, %rdx
subq %r14, %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x241e0
movq %r15, %r14
subq %rbx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_strxfrm_pad_desc_and_reverse_nopad:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r12d, r9d
mov r15, rcx
mov r14, rdx
mov rbx, rsi
mov ecx, [rbp+arg_0]
test r8d, r8d
setz al
cmp rdx, r15
setnb sil
test r12b, 40h
setz dl
or dl, al
or dl, sil
jnz short loc_3D17D
mov r13d, r8d
mov eax, r15d
imul r13d, [rdi+98h]
sub eax, r14d
cmp r13d, eax
cmovnb r13d, eax
mov rdi, r14
xor esi, esi
mov rdx, r13
call _memset
mov ecx, [rbp+arg_0]
add r14, r13
loc_3D17D:
mov rdi, rbx
mov rsi, r14
mov edx, r12d
call my_strxfrm_desc_and_reverse
test r12b, r12b
jns short loc_3D1A8
cmp r14, r15
jnb short loc_3D1A8
mov rdx, r15
sub rdx, r14
mov rdi, r14
xor esi, esi
call _memset
mov r14, r15
loc_3D1A8:
sub r14, rbx
mov rax, r14
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_strxfrm_pad_desc_and_reverse_nopad(
long long a1,
long long a2,
unsigned long long a3,
unsigned long long a4,
int a5,
unsigned int a6,
unsigned int a7)
{
unsigned long long v9; // r14
long long v10; // rcx
long long v11; // r13
v9 = a3;
v10 = a7;
if ( a3 < a4 && a5 != 0 && (a6 & 0x40) != 0 )
{
v11 = (unsigned int)(*(_DWORD *)(a1 + 152) * a5);
if ( (unsigned int)v11 >= (int)a4 - (int)a3 )
v11 = (unsigned int)(a4 - a3);
memset(a3, 0LL, v11);
v10 = a7;
v9 += v11;
}
my_strxfrm_desc_and_reverse(a2, v9, a6, v10);
if ( (a6 & 0x80u) != 0 && v9 < a4 )
{
memset(v9, 0LL, a4 - v9);
v9 = a4;
}
return v9 - a2;
}
| my_strxfrm_pad_desc_and_reverse_nopad:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R12D,R9D
MOV R15,RCX
MOV R14,RDX
MOV RBX,RSI
MOV ECX,dword ptr [RBP + 0x10]
TEST R8D,R8D
SETZ AL
CMP RDX,R15
SETNC SIL
TEST R12B,0x40
SETZ DL
OR DL,AL
OR DL,SIL
JNZ 0x0013d17d
MOV R13D,R8D
MOV EAX,R15D
IMUL R13D,dword ptr [RDI + 0x98]
SUB EAX,R14D
CMP R13D,EAX
CMOVNC R13D,EAX
MOV RDI,R14
XOR ESI,ESI
MOV RDX,R13
CALL 0x001241e0
MOV ECX,dword ptr [RBP + 0x10]
ADD R14,R13
LAB_0013d17d:
MOV RDI,RBX
MOV RSI,R14
MOV EDX,R12D
CALL 0x0013e9be
TEST R12B,R12B
JNS 0x0013d1a8
CMP R14,R15
JNC 0x0013d1a8
MOV RDX,R15
SUB RDX,R14
MOV RDI,R14
XOR ESI,ESI
CALL 0x001241e0
MOV R14,R15
LAB_0013d1a8:
SUB R14,RBX
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long my_strxfrm_pad_desc_and_reverse_nopad
(long param_1,long param_2,void *param_3,void *param_4,int param_5,uint param_6,
int4 param_7)
{
uint uVar1;
uint uVar2;
if (((param_6 & 0x40) != 0 && param_5 != 0) && param_3 < param_4) {
uVar2 = param_5 * *(int *)(param_1 + 0x98);
uVar1 = (int)param_4 - (int)param_3;
if (uVar1 <= uVar2) {
uVar2 = uVar1;
}
memset(param_3,0,(ulong)uVar2);
param_3 = (void *)((long)param_3 + (ulong)uVar2);
}
my_strxfrm_desc_and_reverse(param_2,param_3,param_6,param_7);
if (((char)param_6 < '\0') && (param_3 < param_4)) {
memset(param_3,0,(long)param_4 - (long)param_3);
param_3 = param_4;
}
return (long)param_3 - param_2;
}
| |
44,790 | evmone::grow_memory(long, evmone::Memory&, unsigned long) | corpus-core[P]colibri-stateless/build_O0/_deps/evmone_external-src/lib/evmone/instructions.hpp | [[gnu::noinline]] inline int64_t grow_memory(
int64_t gas_left, Memory& memory, uint64_t new_size) noexcept
{
// This implementation recomputes memory.size(). This value is already known to the caller
// and can be passed as a parameter, but this make no difference to the performance.
const auto new_words = num_words(new_size);
const auto current_words = static_cast<int64_t>(memory.size() / word_size);
const auto new_cost = 3 * new_words + new_words * new_words / 512;
const auto current_cost = 3 * current_words + current_words * current_words / 512;
const auto cost = new_cost - current_cost;
gas_left -= cost;
if (gas_left >= 0) [[likely]]
memory.grow(static_cast<size_t>(new_words * word_size));
return gas_left;
} | O0 | cpp | evmone::grow_memory(long, evmone::Memory&, unsigned long):
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x66f20
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x67090
shrq $0x5, %rax
movq %rax, -0x28(%rbp)
imulq $0x3, -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
imulq -0x20(%rbp), %rax
movl $0x200, %ecx # imm = 0x200
cqto
idivq %rcx
movq %rax, %rcx
movq -0x50(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x30(%rbp)
imulq $0x3, -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
imulq -0x28(%rbp), %rax
movl $0x200, %ecx # imm = 0x200
cqto
idivq %rcx
movq %rax, %rcx
movq -0x48(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
subq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rcx
movq -0x8(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jl 0x67169
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
shlq $0x5, %rsi
callq 0x67180
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| _ZN6evmone11grow_memoryElRNS_6MemoryEm:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rdi, [rbp+var_18]; this
call _ZN6evmone9num_wordsEm; evmone::num_words(ulong)
mov [rbp+var_20], rax
mov rdi, [rbp+var_10]; this
call _ZNK6evmone6Memory4sizeEv; evmone::Memory::size(void)
shr rax, 5
mov [rbp+var_28], rax
imul rax, [rbp+var_20], 3
mov [rbp+var_50], rax
mov rax, [rbp+var_20]
imul rax, [rbp+var_20]
mov ecx, 200h
cqo
idiv rcx
mov rcx, rax
mov rax, [rbp+var_50]
add rax, rcx
mov [rbp+var_30], rax
imul rax, [rbp+var_28], 3
mov [rbp+var_48], rax
mov rax, [rbp+var_28]
imul rax, [rbp+var_28]
mov ecx, 200h
cqo
idiv rcx
mov rcx, rax
mov rax, [rbp+var_48]
add rax, rcx
mov [rbp+var_38], rax
mov rax, [rbp+var_30]
sub rax, [rbp+var_38]
mov [rbp+var_40], rax
mov rcx, [rbp+var_40]
mov rax, [rbp+var_8]
sub rax, rcx
mov [rbp+var_8], rax
cmp [rbp+var_8], 0
jl short loc_67169
mov rdi, [rbp+var_10]; this
mov rsi, [rbp+var_20]
shl rsi, 5; unsigned __int64
call _ZN6evmone6Memory4growEm; evmone::Memory::grow(ulong)
loc_67169:
mov rax, [rbp+var_8]
add rsp, 50h
pop rbp
retn
| long long evmone::grow_memory(evmone *this, evmone::Memory *a2, evmone::Memory *a3)
{
unsigned long long v4; // [rsp+28h] [rbp-28h]
unsigned long long v5; // [rsp+30h] [rbp-20h]
v5 = evmone::num_words(a3);
v4 = (unsigned long long)evmone::Memory::size(a2) >> 5;
if ( (long long)((long long)this - ((long long)(v5 * v5) / 512 + 3 * v5 - ((long long)(v4 * v4) / 512 + 3 * v4))) >= 0 )
evmone::Memory::grow(a2, 32 * v5);
return (long long)this - ((long long)(v5 * v5) / 512 + 3 * v5 - ((long long)(v4 * v4) / 512 + 3 * v4));
}
| grow_memory:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00166f20
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00167090
SHR RAX,0x5
MOV qword ptr [RBP + -0x28],RAX
IMUL RAX,qword ptr [RBP + -0x20],0x3
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x20]
IMUL RAX,qword ptr [RBP + -0x20]
MOV ECX,0x200
CQO
IDIV RCX
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
IMUL RAX,qword ptr [RBP + -0x28],0x3
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x28]
IMUL RAX,qword ptr [RBP + -0x28]
MOV ECX,0x200
CQO
IDIV RCX
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RCX
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x30]
SUB RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x40],RAX
MOV RCX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x8]
SUB RAX,RCX
MOV qword ptr [RBP + -0x8],RAX
CMP qword ptr [RBP + -0x8],0x0
JL 0x00167169
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
SHL RSI,0x5
CALL 0x00167180
LAB_00167169:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x50
POP RBP
RET
|
/* evmone::grow_memory(long, evmone::Memory&, unsigned long) */
long evmone::grow_memory(long param_1,Memory *param_2,ulong param_3)
{
long lVar1;
ulong uVar2;
long lVar3;
lVar1 = num_words(param_3);
uVar2 = Memory::size(param_2);
uVar2 = uVar2 >> 5;
lVar3 = param_1 - ((lVar1 * 3 + (lVar1 * lVar1) / 0x200) -
(uVar2 * 3 + (long)(uVar2 * uVar2) / 0x200));
if (-1 < lVar3) {
Memory::grow(param_2,lVar1 << 5);
}
return lVar3;
}
| |
44,791 | mi_keydef_read | eloqsql/storage/myisam/mi_open.c | uchar *mi_keydef_read(uchar *ptr, MI_KEYDEF *keydef)
{
keydef->keysegs = (uint) *ptr++;
keydef->key_alg = *ptr++; /* Rtree or Btree */
keydef->flag = mi_uint2korr(ptr); ptr +=2;
keydef->block_length = mi_uint2korr(ptr); ptr +=2;
keydef->keylength = mi_uint2korr(ptr); ptr +=2;
keydef->minlength = mi_uint2korr(ptr); ptr +=2;
keydef->maxlength = mi_uint2korr(ptr); ptr +=2;
keydef->block_size_index= keydef->block_length/MI_MIN_KEY_BLOCK_LENGTH-1;
keydef->underflow_block_length=keydef->block_length/3;
keydef->version = 0; /* Not saved */
keydef->parser = &ft_default_parser;
keydef->ftkey_nr = 0;
return ptr;
} | O0 | c | mi_keydef_read:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movzbl (%rax), %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb (%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, 0xc(%rax)
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %eax
movzwl %ax, %eax
movq -0x8(%rbp), %rcx
movzbl (%rcx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0xa(%rax)
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %eax
movzwl %ax, %eax
movq -0x8(%rbp), %rcx
movzbl (%rcx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0xe(%rax)
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %eax
movzwl %ax, %eax
movq -0x8(%rbp), %rcx
movzbl (%rcx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x12(%rax)
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %eax
movzwl %ax, %eax
movq -0x8(%rbp), %rcx
movzbl (%rcx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x14(%rax)
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %eax
movzwl %ax, %eax
movq -0x8(%rbp), %rcx
movzbl (%rcx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x16(%rax)
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movzwl 0xe(%rax), %eax
movl $0x400, %ecx # imm = 0x400
cltd
idivl %ecx
subl $0x1, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x18(%rax)
movq -0x10(%rbp), %rax
movzwl 0xe(%rax), %eax
movl $0x3, %ecx
cltd
idivl %ecx
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x10(%rbp), %rax
leaq 0x21093b(%rip), %rcx # 0x2c6620
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
| mi_keydef_read:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov rcx, rax
add rcx, 1
mov [rbp+var_8], rcx
movzx eax, byte ptr [rax]
mov cx, ax
mov rax, [rbp+var_10]
mov [rax+8], cx
mov rax, [rbp+var_8]
mov rcx, rax
add rcx, 1
mov [rbp+var_8], rcx
mov cl, [rax]
mov rax, [rbp+var_10]
mov [rax+0Ch], cl
mov rax, [rbp+var_8]
movzx eax, byte ptr [rax+1]
movzx eax, ax
mov rcx, [rbp+var_8]
movzx ecx, byte ptr [rcx]
movzx ecx, cx
shl ecx, 8
or eax, ecx
mov cx, ax
mov rax, [rbp+var_10]
mov [rax+0Ah], cx
mov rax, [rbp+var_8]
add rax, 2
mov [rbp+var_8], rax
mov rax, [rbp+var_8]
movzx eax, byte ptr [rax+1]
movzx eax, ax
mov rcx, [rbp+var_8]
movzx ecx, byte ptr [rcx]
movzx ecx, cx
shl ecx, 8
or eax, ecx
mov cx, ax
mov rax, [rbp+var_10]
mov [rax+0Eh], cx
mov rax, [rbp+var_8]
add rax, 2
mov [rbp+var_8], rax
mov rax, [rbp+var_8]
movzx eax, byte ptr [rax+1]
movzx eax, ax
mov rcx, [rbp+var_8]
movzx ecx, byte ptr [rcx]
movzx ecx, cx
shl ecx, 8
or eax, ecx
mov cx, ax
mov rax, [rbp+var_10]
mov [rax+12h], cx
mov rax, [rbp+var_8]
add rax, 2
mov [rbp+var_8], rax
mov rax, [rbp+var_8]
movzx eax, byte ptr [rax+1]
movzx eax, ax
mov rcx, [rbp+var_8]
movzx ecx, byte ptr [rcx]
movzx ecx, cx
shl ecx, 8
or eax, ecx
mov cx, ax
mov rax, [rbp+var_10]
mov [rax+14h], cx
mov rax, [rbp+var_8]
add rax, 2
mov [rbp+var_8], rax
mov rax, [rbp+var_8]
movzx eax, byte ptr [rax+1]
movzx eax, ax
mov rcx, [rbp+var_8]
movzx ecx, byte ptr [rcx]
movzx ecx, cx
shl ecx, 8
or eax, ecx
mov cx, ax
mov rax, [rbp+var_10]
mov [rax+16h], cx
mov rax, [rbp+var_8]
add rax, 2
mov [rbp+var_8], rax
mov rax, [rbp+var_10]
movzx eax, word ptr [rax+0Eh]
mov ecx, 400h
cdq
idiv ecx
sub eax, 1
mov cx, ax
mov rax, [rbp+var_10]
mov [rax+18h], cx
mov rax, [rbp+var_10]
movzx eax, word ptr [rax+0Eh]
mov ecx, 3
cdq
idiv ecx
mov cx, ax
mov rax, [rbp+var_10]
mov [rax+10h], cx
mov rax, [rbp+var_10]
mov dword ptr [rax+1Ch], 0
mov rax, [rbp+var_10]
lea rcx, ft_default_parser
mov [rax+38h], rcx
mov rax, [rbp+var_10]
mov dword ptr [rax+20h], 0
mov rax, [rbp+var_8]
pop rbp
retn
| unsigned __int8 * mi_keydef_read(unsigned __int8 *a1, long long a2)
{
*(_WORD *)(a2 + 8) = *a1;
*(_BYTE *)(a2 + 12) = a1[1];
*(_WORD *)(a2 + 10) = _byteswap_ushort(*((_WORD *)a1 + 1));
*(_WORD *)(a2 + 14) = _byteswap_ushort(*((_WORD *)a1 + 2));
*(_WORD *)(a2 + 18) = _byteswap_ushort(*((_WORD *)a1 + 3));
*(_WORD *)(a2 + 20) = _byteswap_ushort(*((_WORD *)a1 + 4));
*(_WORD *)(a2 + 22) = _byteswap_ushort(*((_WORD *)a1 + 5));
*(_WORD *)(a2 + 24) = *(unsigned __int16 *)(a2 + 14) / 1024 - 1;
*(_WORD *)(a2 + 16) = *(unsigned __int16 *)(a2 + 14) / 3;
*(_DWORD *)(a2 + 28) = 0;
*(_QWORD *)(a2 + 56) = &ft_default_parser;
*(_DWORD *)(a2 + 32) = 0;
return a1 + 12;
}
| mi_keydef_read:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x8],RCX
MOVZX EAX,byte ptr [RAX]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x10]
MOV word ptr [RAX + 0x8],CX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x8],RCX
MOV CL,byte ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0xc],CL
MOV RAX,qword ptr [RBP + -0x8]
MOVZX EAX,byte ptr [RAX + 0x1]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x8]
MOVZX ECX,byte ptr [RCX]
MOVZX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x10]
MOV word ptr [RAX + 0xa],CX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x2
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOVZX EAX,byte ptr [RAX + 0x1]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x8]
MOVZX ECX,byte ptr [RCX]
MOVZX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x10]
MOV word ptr [RAX + 0xe],CX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x2
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOVZX EAX,byte ptr [RAX + 0x1]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x8]
MOVZX ECX,byte ptr [RCX]
MOVZX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x10]
MOV word ptr [RAX + 0x12],CX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x2
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOVZX EAX,byte ptr [RAX + 0x1]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x8]
MOVZX ECX,byte ptr [RCX]
MOVZX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x10]
MOV word ptr [RAX + 0x14],CX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x2
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOVZX EAX,byte ptr [RAX + 0x1]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x8]
MOVZX ECX,byte ptr [RCX]
MOVZX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x10]
MOV word ptr [RAX + 0x16],CX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x2
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,word ptr [RAX + 0xe]
MOV ECX,0x400
CDQ
IDIV ECX
SUB EAX,0x1
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x10]
MOV word ptr [RAX + 0x18],CX
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,word ptr [RAX + 0xe]
MOV ECX,0x3
CDQ
IDIV ECX
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x10]
MOV word ptr [RAX + 0x10],CX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x1c],0x0
MOV RAX,qword ptr [RBP + -0x10]
LEA RCX,[0x3c6620]
MOV qword ptr [RAX + 0x38],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x20],0x0
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
int1 [16] mi_keydef_read(byte *param_1,long param_2)
{
int1 auVar1 [16];
*(ushort *)(param_2 + 8) = (ushort)*param_1;
*(byte *)(param_2 + 0xc) = param_1[1];
*(ushort *)(param_2 + 10) = CONCAT11(param_1[2],param_1[3]);
*(ushort *)(param_2 + 0xe) = CONCAT11(param_1[4],param_1[5]);
*(ushort *)(param_2 + 0x12) = CONCAT11(param_1[6],param_1[7]);
*(ushort *)(param_2 + 0x14) = CONCAT11(param_1[8],param_1[9]);
*(ushort *)(param_2 + 0x16) = CONCAT11(param_1[10],param_1[0xb]);
auVar1._0_8_ = param_1 + 0xc;
*(ushort *)(param_2 + 0x18) = *(ushort *)(param_2 + 0xe) / 0x400 - 1;
*(ushort *)(param_2 + 0x10) = *(ushort *)(param_2 + 0xe) / 3;
*(int4 *)(param_2 + 0x1c) = 0;
*(int1 **)(param_2 + 0x38) = ft_default_parser;
*(int4 *)(param_2 + 0x20) = 0;
auVar1._8_8_ = (ulong)*(ushort *)(param_2 + 0xe) % 3;
return auVar1;
}
| |
44,792 | lunasvg::parseAttributeSelector(std::basic_string_view<char, std::char_traits<char>>&, lunasvg::SimpleSelector&) | dmazzella[P]pylunasvg/lunasvg/source/svgparser.cpp | static bool parseAttributeSelector(std::string_view& input, SimpleSelector& simpleSelector)
{
std::string name;
skipOptionalSpaces(input);
if(!readCSSIdentifier(input, name))
return false;
AttributeSelector a;
a.id = propertyid(name);
a.matchType = AttributeSelector::MatchType::None;
if(skipDelimiter(input, '='))
a.matchType = AttributeSelector::MatchType::Equals;
else if(skipString(input, "*="))
a.matchType = AttributeSelector::MatchType::Contains;
else if(skipString(input, "~="))
a.matchType = AttributeSelector::MatchType::Includes;
else if(skipString(input, "^="))
a.matchType = AttributeSelector::MatchType::StartsWith;
else if(skipString(input, "$="))
a.matchType = AttributeSelector::MatchType::EndsWith;
else if(skipString(input, "|="))
a.matchType = AttributeSelector::MatchType::DashEquals;
if(a.matchType != AttributeSelector::MatchType::None) {
skipOptionalSpaces(input);
if(!readCSSIdentifier(input, a.value)) {
if(input.empty() || !(input.front() == '\"' || input.front() == '\''))
return false;
auto quote = input.front();
input.remove_prefix(1);
auto n = input.find(quote);
if(n == std::string_view::npos)
return false;
a.value.assign(input.substr(0, n));
input.remove_prefix(n + 1);
}
}
skipOptionalSpaces(input);
if(!skipDelimiter(input, ']'))
return false;
simpleSelector.attributeSelectors.push_back(std::move(a));
return true;
} | O0 | cpp | lunasvg::parseAttributeSelector(std::basic_string_view<char, std::char_traits<char>>&, lunasvg::SimpleSelector&):
pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0xb520
movq -0x10(%rbp), %rdi
callq 0x332b0
movq -0x100(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x3fbe0
movb %al, -0xf1(%rbp)
jmp 0x3d944
movb -0xf1(%rbp), %al
testb $0x1, %al
jne 0x3d971
jmp 0x3d950
movb $0x0, -0x1(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0x3dd30
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x3dd47
leaq -0x70(%rbp), %rdi
callq 0x40520
leaq -0x38(%rbp), %rdi
callq 0xb3e0
movq %rax, -0x80(%rbp)
movq %rdx, -0x78(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x48f50
movb %al, -0x101(%rbp)
jmp 0x3d99c
movb -0x101(%rbp), %al
movb %al, -0x6c(%rbp)
movl $0x0, -0x70(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3d, %esi
callq 0x33420
testb $0x1, %al
jne 0x3d9c0
jmp 0x3d9e6
movl $0x1, -0x70(%rbp)
jmp 0x3dba0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x40580
jmp 0x3dd47
movq -0x10(%rbp), %rax
movq %rax, -0x118(%rbp)
leaq 0x4f452(%rip), %rsi # 0x8ce4a
leaq -0x90(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0x33260
movq -0x118(%rbp), %rdi
movq -0x110(%rbp), %rsi
callq 0x33360
movb %al, -0x102(%rbp)
jmp 0x3da26
movb -0x102(%rbp), %al
testb $0x1, %al
jne 0x3da32
jmp 0x3da3e
movl $0x2, -0x70(%rbp)
jmp 0x3db9e
movq -0x10(%rbp), %rax
movq %rax, -0x130(%rbp)
leaq 0x4f3fd(%rip), %rsi # 0x8ce4d
leaq -0xa0(%rbp), %rdi
movq %rdi, -0x128(%rbp)
callq 0x33260
movq -0x130(%rbp), %rdi
movq -0x128(%rbp), %rsi
callq 0x33360
movb %al, -0x119(%rbp)
jmp 0x3da7e
movb -0x119(%rbp), %al
testb $0x1, %al
jne 0x3da8a
jmp 0x3da96
movl $0x3, -0x70(%rbp)
jmp 0x3db9c
movq -0x10(%rbp), %rax
movq %rax, -0x148(%rbp)
leaq 0x4f3a8(%rip), %rsi # 0x8ce50
leaq -0xb0(%rbp), %rdi
movq %rdi, -0x140(%rbp)
callq 0x33260
movq -0x148(%rbp), %rdi
movq -0x140(%rbp), %rsi
callq 0x33360
movb %al, -0x131(%rbp)
jmp 0x3dad6
movb -0x131(%rbp), %al
testb $0x1, %al
jne 0x3dae2
jmp 0x3daee
movl $0x4, -0x70(%rbp)
jmp 0x3db9a
movq -0x10(%rbp), %rax
movq %rax, -0x160(%rbp)
leaq 0x4f353(%rip), %rsi # 0x8ce53
leaq -0xc0(%rbp), %rdi
movq %rdi, -0x158(%rbp)
callq 0x33260
movq -0x160(%rbp), %rdi
movq -0x158(%rbp), %rsi
callq 0x33360
movb %al, -0x149(%rbp)
jmp 0x3db2e
movb -0x149(%rbp), %al
testb $0x1, %al
jne 0x3db3a
jmp 0x3db43
movl $0x5, -0x70(%rbp)
jmp 0x3db98
movq -0x10(%rbp), %rax
movq %rax, -0x178(%rbp)
leaq 0x4f301(%rip), %rsi # 0x8ce56
leaq -0xd0(%rbp), %rdi
movq %rdi, -0x170(%rbp)
callq 0x33260
movq -0x178(%rbp), %rdi
movq -0x170(%rbp), %rsi
callq 0x33360
movb %al, -0x161(%rbp)
jmp 0x3db83
movb -0x161(%rbp), %al
testb $0x1, %al
jne 0x3db8f
jmp 0x3db96
movl $0x6, -0x70(%rbp)
jmp 0x3db98
jmp 0x3db9a
jmp 0x3db9c
jmp 0x3db9e
jmp 0x3dba0
cmpl $0x0, -0x70(%rbp)
je 0x3dce1
movq -0x10(%rbp), %rdi
callq 0x332b0
movq -0x10(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x3fbe0
movb %al, -0x179(%rbp)
jmp 0x3dbc8
movb -0x179(%rbp), %al
testb $0x1, %al
jne 0x3dcdf
jmp 0x3dbd8
movq -0x10(%rbp), %rdi
callq 0x20620
testb $0x1, %al
jne 0x3dc07
movq -0x10(%rbp), %rdi
callq 0x20640
movsbl (%rax), %eax
cmpl $0x22, %eax
je 0x3dc17
movq -0x10(%rbp), %rdi
callq 0x20640
movsbl (%rax), %eax
cmpl $0x27, %eax
je 0x3dc17
movb $0x0, -0x1(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0x3dd27
movq -0x10(%rbp), %rdi
callq 0x20640
movb (%rax), %al
movb %al, -0xd1(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x231b0
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movsbl -0xd1(%rbp), %esi
callq 0x23110
movq %rax, -0xe0(%rbp)
cmpq $-0x1, -0xe0(%rbp)
jne 0x3dc6b
movb $0x0, -0x1(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0x3dd27
leaq -0x68(%rbp), %rax
movq %rax, -0x198(%rbp)
movq -0x10(%rbp), %rdi
movq -0xe0(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x20660
movq %rdx, -0x190(%rbp)
movq %rax, -0x188(%rbp)
jmp 0x3dc9a
movq -0x198(%rbp), %rdi
movq -0x190(%rbp), %rax
movq -0x188(%rbp), %rcx
movq %rcx, -0xf0(%rbp)
movq %rax, -0xe8(%rbp)
leaq -0xf0(%rbp), %rsi
callq 0x330b0
jmp 0x3dccb
movq -0x10(%rbp), %rdi
movq -0xe0(%rbp), %rsi
addq $0x1, %rsi
callq 0x231b0
jmp 0x3dce1
movq -0x10(%rbp), %rdi
callq 0x332b0
movq -0x10(%rbp), %rdi
movl $0x5d, %esi
callq 0x33420
testb $0x1, %al
jne 0x3dd09
movb $0x0, -0x1(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0x3dd27
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
leaq -0x70(%rbp), %rsi
callq 0x40550
jmp 0x3dd1c
movb $0x1, -0x1(%rbp)
movl $0x1, -0x48(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x40580
leaq -0x38(%rbp), %rdi
callq 0xb7a8
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x1a0, %rsp # imm = 0x1A0
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0xb7a8
movq -0x40(%rbp), %rdi
callq 0xb6c0
nopl (%rax)
| _ZN7lunasvgL22parseAttributeSelectorERSt17basic_string_viewIcSt11char_traitsIcEERNS_14SimpleSelectorE:
push rbp
mov rbp, rsp
sub rsp, 1A0h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
lea rdi, [rbp+var_38]
mov [rbp+var_100], rdi
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev; std::string::basic_string(void)
mov rdi, [rbp+var_10]
call _ZN7lunasvg18skipOptionalSpacesERSt17basic_string_viewIcSt11char_traitsIcEE; lunasvg::skipOptionalSpaces(std::string_view &)
mov rsi, [rbp+var_100]
mov rdi, [rbp+var_10]
call _ZN7lunasvg17readCSSIdentifierERSt17basic_string_viewIcSt11char_traitsIcEERNSt7__cxx1112basic_stringIcS2_SaIcEEE; lunasvg::readCSSIdentifier(std::string_view &,std::string &)
mov [rbp+var_F1], al
jmp short $+2
loc_3D944:
mov al, [rbp+var_F1]
test al, 1
jnz short loc_3D971
jmp short $+2
loc_3D950:
mov [rbp+var_1], 0
mov [rbp+var_48], 1
jmp loc_3DD30
mov rcx, rax
mov eax, edx
mov [rbp+var_40], rcx
mov [rbp+var_44], eax
jmp loc_3DD47
loc_3D971:
lea rdi, [rbp+var_70]; this
call _ZN7lunasvg17AttributeSelectorC2Ev; lunasvg::AttributeSelector::AttributeSelector(void)
lea rdi, [rbp+var_38]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEcvSt17basic_string_viewIcS2_EEv; std::string::operator std::string_view(void)
mov [rbp+var_80], rax
mov [rbp+var_78], rdx
lea rdi, [rbp+var_80]
call _ZN7lunasvg10propertyidERKSt17basic_string_viewIcSt11char_traitsIcEE; lunasvg::propertyid(std::string_view const&)
mov [rbp+var_101], al
jmp short $+2
loc_3D99C:
mov al, [rbp+var_101]
mov [rbp+var_6C], al
mov [rbp+var_70], 0
mov rdi, [rbp+var_10]
mov esi, 3Dh ; '='
call _ZN7lunasvg13skipDelimiterERSt17basic_string_viewIcSt11char_traitsIcEEc; lunasvg::skipDelimiter(std::string_view &,char)
test al, 1
jnz short loc_3D9C0
jmp short loc_3D9E6
loc_3D9C0:
mov [rbp+var_70], 1
jmp loc_3DBA0
mov rcx, rax
mov eax, edx
mov [rbp+var_40], rcx
mov [rbp+var_44], eax
lea rdi, [rbp+var_70]; this
call _ZN7lunasvg17AttributeSelectorD2Ev; lunasvg::AttributeSelector::~AttributeSelector()
jmp loc_3DD47
loc_3D9E6:
mov rax, [rbp+var_10]
mov [rbp+var_118], rax
lea rsi, asc_8CE4A; "*="
lea rdi, [rbp+var_90]
mov [rbp+var_110], rdi
call _ZNSt17basic_string_viewIcSt11char_traitsIcEEC2EPKc; std::string_view::basic_string_view(char const*)
mov rdi, [rbp+var_118]
mov rsi, [rbp+var_110]
call _ZN7lunasvg10skipStringERSt17basic_string_viewIcSt11char_traitsIcEERKS3_; lunasvg::skipString(std::string_view &,std::string_view const&)
mov [rbp+var_102], al
jmp short $+2
loc_3DA26:
mov al, [rbp+var_102]
test al, 1
jnz short loc_3DA32
jmp short loc_3DA3E
loc_3DA32:
mov [rbp+var_70], 2
jmp loc_3DB9E
loc_3DA3E:
mov rax, [rbp+var_10]
mov [rbp+var_130], rax
lea rsi, asc_8CE4D; "~="
lea rdi, [rbp+var_A0]
mov [rbp+var_128], rdi
call _ZNSt17basic_string_viewIcSt11char_traitsIcEEC2EPKc; std::string_view::basic_string_view(char const*)
mov rdi, [rbp+var_130]
mov rsi, [rbp+var_128]
call _ZN7lunasvg10skipStringERSt17basic_string_viewIcSt11char_traitsIcEERKS3_; lunasvg::skipString(std::string_view &,std::string_view const&)
mov [rbp+var_119], al
jmp short $+2
loc_3DA7E:
mov al, [rbp+var_119]
test al, 1
jnz short loc_3DA8A
jmp short loc_3DA96
loc_3DA8A:
mov [rbp+var_70], 3
jmp loc_3DB9C
loc_3DA96:
mov rax, [rbp+var_10]
mov [rbp+var_148], rax
lea rsi, asc_8CE50; "^="
lea rdi, [rbp+var_B0]
mov [rbp+var_140], rdi
call _ZNSt17basic_string_viewIcSt11char_traitsIcEEC2EPKc; std::string_view::basic_string_view(char const*)
mov rdi, [rbp+var_148]
mov rsi, [rbp+var_140]
call _ZN7lunasvg10skipStringERSt17basic_string_viewIcSt11char_traitsIcEERKS3_; lunasvg::skipString(std::string_view &,std::string_view const&)
mov [rbp+var_131], al
jmp short $+2
loc_3DAD6:
mov al, [rbp+var_131]
test al, 1
jnz short loc_3DAE2
jmp short loc_3DAEE
loc_3DAE2:
mov [rbp+var_70], 4
jmp loc_3DB9A
loc_3DAEE:
mov rax, [rbp+var_10]
mov [rbp+var_160], rax
lea rsi, asc_8CE53; "$="
lea rdi, [rbp+var_C0]
mov [rbp+var_158], rdi
call _ZNSt17basic_string_viewIcSt11char_traitsIcEEC2EPKc; std::string_view::basic_string_view(char const*)
mov rdi, [rbp+var_160]
mov rsi, [rbp+var_158]
call _ZN7lunasvg10skipStringERSt17basic_string_viewIcSt11char_traitsIcEERKS3_; lunasvg::skipString(std::string_view &,std::string_view const&)
mov [rbp+var_149], al
jmp short $+2
loc_3DB2E:
mov al, [rbp+var_149]
test al, 1
jnz short loc_3DB3A
jmp short loc_3DB43
loc_3DB3A:
mov [rbp+var_70], 5
jmp short loc_3DB98
loc_3DB43:
mov rax, [rbp+var_10]
mov [rbp+var_178], rax
lea rsi, asc_8CE56; "|="
lea rdi, [rbp+var_D0]
mov [rbp+var_170], rdi
call _ZNSt17basic_string_viewIcSt11char_traitsIcEEC2EPKc; std::string_view::basic_string_view(char const*)
mov rdi, [rbp+var_178]
mov rsi, [rbp+var_170]
call _ZN7lunasvg10skipStringERSt17basic_string_viewIcSt11char_traitsIcEERKS3_; lunasvg::skipString(std::string_view &,std::string_view const&)
mov [rbp+var_161], al
jmp short $+2
loc_3DB83:
mov al, [rbp+var_161]
test al, 1
jnz short loc_3DB8F
jmp short loc_3DB96
loc_3DB8F:
mov [rbp+var_70], 6
loc_3DB96:
jmp short $+2
loc_3DB98:
jmp short $+2
loc_3DB9A:
jmp short $+2
loc_3DB9C:
jmp short $+2
loc_3DB9E:
jmp short $+2
loc_3DBA0:
cmp [rbp+var_70], 0
jz loc_3DCE1
mov rdi, [rbp+var_10]
call _ZN7lunasvg18skipOptionalSpacesERSt17basic_string_viewIcSt11char_traitsIcEE; lunasvg::skipOptionalSpaces(std::string_view &)
mov rdi, [rbp+var_10]
lea rsi, [rbp+var_68]
call _ZN7lunasvg17readCSSIdentifierERSt17basic_string_viewIcSt11char_traitsIcEERNSt7__cxx1112basic_stringIcS2_SaIcEEE; lunasvg::readCSSIdentifier(std::string_view &,std::string &)
mov [rbp+var_179], al
jmp short $+2
loc_3DBC8:
mov al, [rbp+var_179]
test al, 1
jnz loc_3DCDF
jmp short $+2
loc_3DBD8:
mov rdi, [rbp+var_10]
call _ZNKSt17basic_string_viewIcSt11char_traitsIcEE5emptyEv; std::string_view::empty(void)
test al, 1
jnz short loc_3DC07
mov rdi, [rbp+var_10]
call _ZNKSt17basic_string_viewIcSt11char_traitsIcEE5frontEv; std::string_view::front(void)
movsx eax, byte ptr [rax]
cmp eax, 22h ; '"'
jz short loc_3DC17
mov rdi, [rbp+var_10]
call _ZNKSt17basic_string_viewIcSt11char_traitsIcEE5frontEv; std::string_view::front(void)
movsx eax, byte ptr [rax]
cmp eax, 27h ; '''
jz short loc_3DC17
loc_3DC07:
mov [rbp+var_1], 0
mov [rbp+var_48], 1
jmp loc_3DD27
loc_3DC17:
mov rdi, [rbp+var_10]
call _ZNKSt17basic_string_viewIcSt11char_traitsIcEE5frontEv; std::string_view::front(void)
mov al, [rax]
mov [rbp+var_D1], al
mov rdi, [rbp+var_10]
mov esi, 1
call _ZNSt17basic_string_viewIcSt11char_traitsIcEE13remove_prefixEm; std::string_view::remove_prefix(ulong)
mov rdi, [rbp+var_10]
xor eax, eax
mov edx, eax
movsx esi, [rbp+var_D1]
call _ZNKSt17basic_string_viewIcSt11char_traitsIcEE4findEcm; std::string_view::find(char,ulong)
mov [rbp+var_E0], rax
cmp [rbp+var_E0], 0FFFFFFFFFFFFFFFFh
jnz short loc_3DC6B
mov [rbp+var_1], 0
mov [rbp+var_48], 1
jmp loc_3DD27
loc_3DC6B:
lea rax, [rbp+var_68]
mov [rbp+var_198], rax
mov rdi, [rbp+var_10]
mov rdx, [rbp+var_E0]
xor eax, eax
mov esi, eax
call _ZNKSt17basic_string_viewIcSt11char_traitsIcEE6substrEmm; std::string_view::substr(ulong,ulong)
mov [rbp+var_190], rdx
mov [rbp+var_188], rax
jmp short $+2
loc_3DC9A:
mov rdi, [rbp+var_198]
mov rax, [rbp+var_190]
mov rcx, [rbp+var_188]
mov [rbp+var_F0], rcx
mov [rbp+var_E8], rax
lea rsi, [rbp+var_F0]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6assignISt17basic_string_viewIcS2_EEENSt9enable_ifIXsr6__and_ISt14is_convertibleIRKT_S7_ESt6__not_IS9_IPSB_PKS4_EESE_IS9_ISC_PKcEEEE5valueERS4_E4typeESC_
jmp short $+2
loc_3DCCB:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_E0]
add rsi, 1
call _ZNSt17basic_string_viewIcSt11char_traitsIcEE13remove_prefixEm; std::string_view::remove_prefix(ulong)
loc_3DCDF:
jmp short $+2
loc_3DCE1:
mov rdi, [rbp+var_10]
call _ZN7lunasvg18skipOptionalSpacesERSt17basic_string_viewIcSt11char_traitsIcEE; lunasvg::skipOptionalSpaces(std::string_view &)
mov rdi, [rbp+var_10]
mov esi, 5Dh ; ']'
call _ZN7lunasvg13skipDelimiterERSt17basic_string_viewIcSt11char_traitsIcEEc; lunasvg::skipDelimiter(std::string_view &,char)
test al, 1
jnz short loc_3DD09
mov [rbp+var_1], 0
mov [rbp+var_48], 1
jmp short loc_3DD27
loc_3DD09:
mov rdi, [rbp+var_18]
add rdi, 8
lea rsi, [rbp+var_70]
call _ZNSt6vectorIN7lunasvg17AttributeSelectorESaIS1_EE9push_backEOS1_; std::vector<lunasvg::AttributeSelector>::push_back(lunasvg::AttributeSelector&&)
jmp short $+2
loc_3DD1C:
mov [rbp+var_1], 1
mov [rbp+var_48], 1
loc_3DD27:
lea rdi, [rbp+var_70]; this
call _ZN7lunasvg17AttributeSelectorD2Ev; lunasvg::AttributeSelector::~AttributeSelector()
loc_3DD30:
lea rdi, [rbp+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov al, [rbp+var_1]
and al, 1
add rsp, 1A0h
pop rbp
retn
loc_3DD47:
lea rdi, [rbp+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov rdi, [rbp+var_40]
call __Unwind_Resume
| char lunasvg::parseAttributeSelector(unsigned long long *a1, long long a2)
{
long long v2; // rdx
long long v3; // rdx
unsigned long long *v5; // [rsp+28h] [rbp-178h]
unsigned long long *v6; // [rsp+40h] [rbp-160h]
unsigned long long *v7; // [rsp+58h] [rbp-148h]
unsigned long long *v8; // [rsp+70h] [rbp-130h]
unsigned long long *v9; // [rsp+88h] [rbp-118h]
_QWORD v10[2]; // [rsp+B0h] [rbp-F0h] BYREF
long long v11; // [rsp+C0h] [rbp-E0h]
char v12; // [rsp+CFh] [rbp-D1h]
long long v13[2]; // [rsp+D0h] [rbp-D0h] BYREF
long long v14[2]; // [rsp+E0h] [rbp-C0h] BYREF
long long v15[2]; // [rsp+F0h] [rbp-B0h] BYREF
long long v16[2]; // [rsp+100h] [rbp-A0h] BYREF
long long v17[2]; // [rsp+110h] [rbp-90h] BYREF
_QWORD v18[2]; // [rsp+120h] [rbp-80h] BYREF
int v19; // [rsp+130h] [rbp-70h] BYREF
char v20; // [rsp+134h] [rbp-6Ch]
_BYTE v21[32]; // [rsp+138h] [rbp-68h] BYREF
int v22; // [rsp+158h] [rbp-48h]
_BYTE v23[32]; // [rsp+168h] [rbp-38h] BYREF
long long v24; // [rsp+188h] [rbp-18h]
unsigned long long *v25; // [rsp+190h] [rbp-10h]
char v26; // [rsp+19Fh] [rbp-1h]
v25 = a1;
v24 = a2;
std::string::basic_string(v23);
lunasvg::skipOptionalSpaces(v25);
if ( (lunasvg::readCSSIdentifier(v25, v23) & 1) != 0 )
{
lunasvg::AttributeSelector::AttributeSelector((lunasvg::AttributeSelector *)&v19);
v18[0] = std::string::operator std::string_view(v23);
v18[1] = v2;
v20 = lunasvg::propertyid(v18);
v19 = 0;
if ( (lunasvg::skipDelimiter(v25, 61) & 1) != 0 )
{
v19 = 1;
}
else
{
v9 = v25;
std::string_view::basic_string_view(v17, (long long)"*=");
if ( (lunasvg::skipString(v9, v17) & 1) != 0 )
{
v19 = 2;
}
else
{
v8 = v25;
std::string_view::basic_string_view(v16, (long long)"~=");
if ( (lunasvg::skipString(v8, v16) & 1) != 0 )
{
v19 = 3;
}
else
{
v7 = v25;
std::string_view::basic_string_view(v15, (long long)"^=");
if ( (lunasvg::skipString(v7, v15) & 1) != 0 )
{
v19 = 4;
}
else
{
v6 = v25;
std::string_view::basic_string_view(v14, (long long)"$=");
if ( (lunasvg::skipString(v6, v14) & 1) != 0 )
{
v19 = 5;
}
else
{
v5 = v25;
std::string_view::basic_string_view(v13, (long long)"|=");
if ( (lunasvg::skipString(v5, v13) & 1) != 0 )
v19 = 6;
}
}
}
}
}
if ( v19 )
{
lunasvg::skipOptionalSpaces(v25);
if ( (lunasvg::readCSSIdentifier(v25, v21) & 1) == 0 )
{
if ( std::string_view::empty(v25)
|| *(_BYTE *)std::string_view::front((long long)v25) != 34
&& *(_BYTE *)std::string_view::front((long long)v25) != 39 )
{
v26 = 0;
v22 = 1;
LABEL_28:
lunasvg::AttributeSelector::~AttributeSelector((lunasvg::AttributeSelector *)&v19);
goto LABEL_29;
}
v12 = *(_BYTE *)std::string_view::front((long long)v25);
std::string_view::remove_prefix(v25, 1LL);
v11 = std::string_view::find(v25, v12, 0LL);
if ( v11 == -1 )
{
v26 = 0;
v22 = 1;
goto LABEL_28;
}
v10[0] = std::string_view::substr(v25, 0LL, v11);
v10[1] = v3;
std::string::assign<std::string_view>((long long)v21, v10);
std::string_view::remove_prefix(v25, v11 + 1);
}
}
lunasvg::skipOptionalSpaces(v25);
if ( (lunasvg::skipDelimiter(v25, 93) & 1) != 0 )
{
std::vector<lunasvg::AttributeSelector>::push_back(v24 + 8, &v19);
v26 = 1;
}
else
{
v26 = 0;
}
v22 = 1;
goto LABEL_28;
}
v26 = 0;
v22 = 1;
LABEL_29:
std::string::~string(v23);
return v26 & 1;
}
| parseAttributeSelector:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x1a0
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
LEA RDI,[RBP + -0x38]
MOV qword ptr [RBP + -0x100],RDI
CALL 0x0010b520
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001332b0
MOV RSI,qword ptr [RBP + -0x100]
MOV RDI,qword ptr [RBP + -0x10]
LAB_0013d937:
CALL 0x0013fbe0
MOV byte ptr [RBP + -0xf1],AL
JMP 0x0013d944
LAB_0013d944:
MOV AL,byte ptr [RBP + -0xf1]
TEST AL,0x1
JNZ 0x0013d971
JMP 0x0013d950
LAB_0013d950:
MOV byte ptr [RBP + -0x1],0x0
MOV dword ptr [RBP + -0x48],0x1
JMP 0x0013dd30
LAB_0013d971:
LEA RDI,[RBP + -0x70]
CALL 0x00140520
LEA RDI,[RBP + -0x38]
CALL 0x0010b3e0
MOV qword ptr [RBP + -0x80],RAX
MOV qword ptr [RBP + -0x78],RDX
LAB_0013d98b:
LEA RDI,[RBP + -0x80]
CALL 0x00148f50
MOV byte ptr [RBP + -0x101],AL
JMP 0x0013d99c
LAB_0013d99c:
MOV AL,byte ptr [RBP + -0x101]
MOV byte ptr [RBP + -0x6c],AL
MOV dword ptr [RBP + -0x70],0x0
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x3d
CALL 0x00133420
TEST AL,0x1
JNZ 0x0013d9c0
JMP 0x0013d9e6
LAB_0013d9c0:
MOV dword ptr [RBP + -0x70],0x1
JMP 0x0013dba0
LAB_0013d9e6:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x118],RAX
LEA RSI,[0x18ce4a]
LEA RDI,[RBP + -0x90]
MOV qword ptr [RBP + -0x110],RDI
CALL 0x00133260
MOV RDI,qword ptr [RBP + -0x118]
MOV RSI,qword ptr [RBP + -0x110]
CALL 0x00133360
MOV byte ptr [RBP + -0x102],AL
JMP 0x0013da26
LAB_0013da26:
MOV AL,byte ptr [RBP + -0x102]
TEST AL,0x1
JNZ 0x0013da32
JMP 0x0013da3e
LAB_0013da32:
MOV dword ptr [RBP + -0x70],0x2
JMP 0x0013db9e
LAB_0013da3e:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x130],RAX
LEA RSI,[0x18ce4d]
LEA RDI,[RBP + -0xa0]
MOV qword ptr [RBP + -0x128],RDI
CALL 0x00133260
MOV RDI,qword ptr [RBP + -0x130]
MOV RSI,qword ptr [RBP + -0x128]
CALL 0x00133360
MOV byte ptr [RBP + -0x119],AL
JMP 0x0013da7e
LAB_0013da7e:
MOV AL,byte ptr [RBP + -0x119]
TEST AL,0x1
JNZ 0x0013da8a
JMP 0x0013da96
LAB_0013da8a:
MOV dword ptr [RBP + -0x70],0x3
JMP 0x0013db9c
LAB_0013da96:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x148],RAX
LEA RSI,[0x18ce50]
LEA RDI,[RBP + -0xb0]
MOV qword ptr [RBP + -0x140],RDI
CALL 0x00133260
MOV RDI,qword ptr [RBP + -0x148]
MOV RSI,qword ptr [RBP + -0x140]
CALL 0x00133360
MOV byte ptr [RBP + -0x131],AL
JMP 0x0013dad6
LAB_0013dad6:
MOV AL,byte ptr [RBP + -0x131]
TEST AL,0x1
JNZ 0x0013dae2
JMP 0x0013daee
LAB_0013dae2:
MOV dword ptr [RBP + -0x70],0x4
JMP 0x0013db9a
LAB_0013daee:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x160],RAX
LEA RSI,[0x18ce53]
LEA RDI,[RBP + -0xc0]
MOV qword ptr [RBP + -0x158],RDI
CALL 0x00133260
MOV RDI,qword ptr [RBP + -0x160]
MOV RSI,qword ptr [RBP + -0x158]
CALL 0x00133360
MOV byte ptr [RBP + -0x149],AL
JMP 0x0013db2e
LAB_0013db2e:
MOV AL,byte ptr [RBP + -0x149]
TEST AL,0x1
JNZ 0x0013db3a
JMP 0x0013db43
LAB_0013db3a:
MOV dword ptr [RBP + -0x70],0x5
JMP 0x0013db98
LAB_0013db43:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x178],RAX
LEA RSI,[0x18ce56]
LEA RDI,[RBP + -0xd0]
MOV qword ptr [RBP + -0x170],RDI
CALL 0x00133260
MOV RDI,qword ptr [RBP + -0x178]
MOV RSI,qword ptr [RBP + -0x170]
CALL 0x00133360
MOV byte ptr [RBP + -0x161],AL
JMP 0x0013db83
LAB_0013db83:
MOV AL,byte ptr [RBP + -0x161]
TEST AL,0x1
JNZ 0x0013db8f
JMP 0x0013db96
LAB_0013db8f:
MOV dword ptr [RBP + -0x70],0x6
LAB_0013db96:
JMP 0x0013db98
LAB_0013db98:
JMP 0x0013db9a
LAB_0013db9a:
JMP 0x0013db9c
LAB_0013db9c:
JMP 0x0013db9e
LAB_0013db9e:
JMP 0x0013dba0
LAB_0013dba0:
CMP dword ptr [RBP + -0x70],0x0
JZ 0x0013dce1
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001332b0
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[RBP + -0x68]
CALL 0x0013fbe0
MOV byte ptr [RBP + -0x179],AL
JMP 0x0013dbc8
LAB_0013dbc8:
MOV AL,byte ptr [RBP + -0x179]
TEST AL,0x1
JNZ 0x0013dcdf
JMP 0x0013dbd8
LAB_0013dbd8:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00120620
TEST AL,0x1
JNZ 0x0013dc07
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00120640
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x22
JZ 0x0013dc17
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00120640
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x27
JZ 0x0013dc17
LAB_0013dc07:
MOV byte ptr [RBP + -0x1],0x0
MOV dword ptr [RBP + -0x48],0x1
JMP 0x0013dd27
LAB_0013dc17:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00120640
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0xd1],AL
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x1
CALL 0x001231b0
MOV RDI,qword ptr [RBP + -0x10]
XOR EAX,EAX
MOV EDX,EAX
MOVSX ESI,byte ptr [RBP + -0xd1]
CALL 0x00123110
MOV qword ptr [RBP + -0xe0],RAX
CMP qword ptr [RBP + -0xe0],-0x1
JNZ 0x0013dc6b
MOV byte ptr [RBP + -0x1],0x0
MOV dword ptr [RBP + -0x48],0x1
JMP 0x0013dd27
LAB_0013dc6b:
LEA RAX,[RBP + -0x68]
MOV qword ptr [RBP + -0x198],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0xe0]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x00120660
MOV qword ptr [RBP + -0x190],RDX
MOV qword ptr [RBP + -0x188],RAX
JMP 0x0013dc9a
LAB_0013dc9a:
MOV RDI,qword ptr [RBP + -0x198]
MOV RAX,qword ptr [RBP + -0x190]
MOV RCX,qword ptr [RBP + -0x188]
MOV qword ptr [RBP + -0xf0],RCX
MOV qword ptr [RBP + -0xe8],RAX
LEA RSI,[RBP + -0xf0]
CALL 0x001330b0
JMP 0x0013dccb
LAB_0013dccb:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0xe0]
ADD RSI,0x1
CALL 0x001231b0
LAB_0013dcdf:
JMP 0x0013dce1
LAB_0013dce1:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001332b0
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x5d
CALL 0x00133420
TEST AL,0x1
JNZ 0x0013dd09
MOV byte ptr [RBP + -0x1],0x0
MOV dword ptr [RBP + -0x48],0x1
JMP 0x0013dd27
LAB_0013dd09:
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x8
LEA RSI,[RBP + -0x70]
CALL 0x00140550
LAB_0013dd1a:
JMP 0x0013dd1c
LAB_0013dd1c:
MOV byte ptr [RBP + -0x1],0x1
MOV dword ptr [RBP + -0x48],0x1
LAB_0013dd27:
LEA RDI,[RBP + -0x70]
CALL 0x00140580
LAB_0013dd30:
LEA RDI,[RBP + -0x38]
CALL 0x0010b7a8
MOV AL,byte ptr [RBP + -0x1]
AND AL,0x1
ADD RSP,0x1a0
POP RBP
RET
|
/* lunasvg::parseAttributeSelector(std::basic_string_view<char, std::char_traits<char> >&,
lunasvg::SimpleSelector&) */
ulong lunasvg::parseAttributeSelector(basic_string_view *param_1,SimpleSelector *param_2)
{
basic_string_view *pbVar1;
byte bVar2;
ulong uVar3;
char *pcVar4;
int8 uVar5;
int1 local_f8 [16];
ulong local_e8;
char local_d9;
basic_string_view<char,std::char_traits<char>> local_d8 [16];
basic_string_view<char,std::char_traits<char>> local_c8 [16];
basic_string_view<char,std::char_traits<char>> local_b8 [16];
basic_string_view<char,std::char_traits<char>> local_a8 [16];
basic_string_view<char,std::char_traits<char>> local_98 [16];
int1 local_88 [16];
int local_78;
int1 local_74;
string local_70 [32];
int4 local_50;
string local_40 [32];
SimpleSelector *local_20;
basic_string_view *local_18;
int1 local_9;
local_20 = param_2;
local_18 = param_1;
std::__cxx11::string::string(local_40);
skipOptionalSpaces(local_18);
/* try { // try from 0013d937 to 0013d93b has its CatchHandler @ 0013d960 */
bVar2 = readCSSIdentifier(local_18,local_40);
if ((bVar2 & 1) == 0) {
local_9 = 0;
local_50 = 1;
goto LAB_0013dd30;
}
AttributeSelector::AttributeSelector((AttributeSelector *)&local_78);
local_88 = std::__cxx11::string::operator_cast_to_basic_string_view(local_40);
/* try { // try from 0013d98b to 0013dd19 has its CatchHandler @ 0013d9cc */
local_74 = propertyid((basic_string_view *)local_88);
local_78 = 0;
uVar3 = skipDelimiter(local_18,'=');
pbVar1 = local_18;
if ((uVar3 & 1) == 0) {
std::basic_string_view<char,std::char_traits<char>>::basic_string_view(local_98,"*=");
bVar2 = skipString(pbVar1,(basic_string_view *)local_98);
pbVar1 = local_18;
if ((bVar2 & 1) == 0) {
std::basic_string_view<char,std::char_traits<char>>::basic_string_view(local_a8,"~=");
bVar2 = skipString(pbVar1,(basic_string_view *)local_a8);
pbVar1 = local_18;
if ((bVar2 & 1) == 0) {
std::basic_string_view<char,std::char_traits<char>>::basic_string_view(local_b8,"^=");
bVar2 = skipString(pbVar1,(basic_string_view *)local_b8);
pbVar1 = local_18;
if ((bVar2 & 1) == 0) {
std::basic_string_view<char,std::char_traits<char>>::basic_string_view(local_c8,"$=");
bVar2 = skipString(pbVar1,(basic_string_view *)local_c8);
pbVar1 = local_18;
if ((bVar2 & 1) == 0) {
std::basic_string_view<char,std::char_traits<char>>::basic_string_view(local_d8,"|=");
bVar2 = skipString(pbVar1,(basic_string_view *)local_d8);
if ((bVar2 & 1) != 0) {
local_78 = 6;
}
}
else {
local_78 = 5;
}
}
else {
local_78 = 4;
}
}
else {
local_78 = 3;
}
}
else {
local_78 = 2;
}
}
else {
local_78 = 1;
}
if (local_78 == 0) {
LAB_0013dce1:
skipOptionalSpaces(local_18);
uVar3 = skipDelimiter(local_18,']');
if ((uVar3 & 1) == 0) {
local_9 = 0;
}
else {
std::vector<lunasvg::AttributeSelector,std::allocator<lunasvg::AttributeSelector>>::push_back
((vector<lunasvg::AttributeSelector,std::allocator<lunasvg::AttributeSelector>> *)
(local_20 + 8),(AttributeSelector *)&local_78);
local_9 = 1;
}
}
else {
skipOptionalSpaces(local_18);
bVar2 = readCSSIdentifier(local_18,local_70);
if ((bVar2 & 1) != 0) goto LAB_0013dce1;
uVar3 = std::basic_string_view<char,std::char_traits<char>>::empty
((basic_string_view<char,std::char_traits<char>> *)local_18);
if ((uVar3 & 1) == 0) {
pcVar4 = (char *)std::basic_string_view<char,std::char_traits<char>>::front
((basic_string_view<char,std::char_traits<char>> *)local_18);
if (*pcVar4 != '\"') {
pcVar4 = (char *)std::basic_string_view<char,std::char_traits<char>>::front
((basic_string_view<char,std::char_traits<char>> *)local_18);
if (*pcVar4 != '\'') goto LAB_0013dc07;
}
pcVar4 = (char *)std::basic_string_view<char,std::char_traits<char>>::front
((basic_string_view<char,std::char_traits<char>> *)local_18);
local_d9 = *pcVar4;
std::basic_string_view<char,std::char_traits<char>>::remove_prefix
((basic_string_view<char,std::char_traits<char>> *)local_18,1);
local_e8 = std::basic_string_view<char,std::char_traits<char>>::find
((basic_string_view<char,std::char_traits<char>> *)local_18,local_d9,0);
if (local_e8 != 0xffffffffffffffff) {
local_f8 = std::basic_string_view<char,std::char_traits<char>>::substr
((basic_string_view<char,std::char_traits<char>> *)local_18,0,local_e8)
;
std::__cxx11::string::assign<std::basic_string_view<char,std::char_traits<char>>>
(local_70,(basic_string_view *)local_f8);
std::basic_string_view<char,std::char_traits<char>>::remove_prefix
((basic_string_view<char,std::char_traits<char>> *)local_18,local_e8 + 1);
goto LAB_0013dce1;
}
local_9 = 0;
}
else {
LAB_0013dc07:
local_9 = 0;
}
}
local_50 = 1;
AttributeSelector::~AttributeSelector((AttributeSelector *)&local_78);
LAB_0013dd30:
uVar5 = std::__cxx11::string::~string(local_40);
return CONCAT71((int7)((ulong)uVar5 >> 8),local_9) & 0xffffffffffffff01;
}
| |
44,793 | get_collation_number_internal | eloqsql/mysys/charset.c | static uint
get_collation_number_internal(const char *name)
{
CHARSET_INFO **cs;
for (cs= all_charsets;
cs < all_charsets + array_elements(all_charsets);
cs++)
{
if (cs[0] && cs[0]->coll_name.str &&
!my_strcasecmp(&my_charset_latin1, cs[0]->coll_name.str, name))
return cs[0]->number;
}
return 0;
} | O0 | c | get_collation_number_internal:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0xba7cfd(%rip), %rax # 0xc85660
movq %rax, -0x18(%rbp)
leaq 0xba7cf2(%rip), %rax # 0xc85660
addq $0x4000, %rax # imm = 0x4000
cmpq %rax, -0x18(%rbp)
jae 0xdd9df
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0xdd9cf
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x20(%rax)
je 0xdd9cf
leaq 0x293a57(%rip), %rax # 0x3713f0
movq 0xc0(%rax), %rax
movq 0x40(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movq 0x20(%rcx), %rsi
movq -0x10(%rbp), %rdx
leaq 0x293a36(%rip), %rdi # 0x3713f0
callq *%rax
cmpl $0x0, %eax
jne 0xdd9cf
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0xdd9e6
jmp 0xdd9d1
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0xdd967
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
| get_collation_number_internal:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
lea rax, all_charsets
mov [rbp+var_18], rax
loc_DD967:
lea rax, all_charsets
add rax, 4000h
cmp [rbp+var_18], rax
jnb short loc_DD9DF
mov rax, [rbp+var_18]
cmp qword ptr [rax], 0
jz short loc_DD9CF
mov rax, [rbp+var_18]
mov rax, [rax]
cmp qword ptr [rax+20h], 0
jz short loc_DD9CF
lea rax, my_charset_latin1
mov rax, [rax+0C0h]
mov rax, [rax+40h]
mov rcx, [rbp+var_18]
mov rcx, [rcx]
mov rsi, [rcx+20h]
mov rdx, [rbp+var_10]
lea rdi, my_charset_latin1
call rax
cmp eax, 0
jnz short loc_DD9CF
mov rax, [rbp+var_18]
mov rax, [rax]
mov eax, [rax]
mov [rbp+var_4], eax
jmp short loc_DD9E6
loc_DD9CF:
jmp short $+2
loc_DD9D1:
mov rax, [rbp+var_18]
add rax, 8
mov [rbp+var_18], rax
jmp short loc_DD967
loc_DD9DF:
mov [rbp+var_4], 0
loc_DD9E6:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
| long long get_collation_number_internal(long long a1)
{
unsigned int **i; // [rsp+8h] [rbp-18h]
for ( i = (unsigned int **)all_charsets; i < &all_charsets[2048]; ++i )
{
if ( *i
&& *((_QWORD *)*i + 4)
&& !(*(unsigned int ( **)(void *, _QWORD, long long))(*((_QWORD *)&my_charset_latin1 + 24) + 64LL))(
&my_charset_latin1,
*((_QWORD *)*i + 4),
a1) )
{
return **i;
}
}
return 0;
}
| get_collation_number_internal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
LEA RAX,[0xd85660]
MOV qword ptr [RBP + -0x18],RAX
LAB_001dd967:
LEA RAX,[0xd85660]
ADD RAX,0x4000
CMP qword ptr [RBP + -0x18],RAX
JNC 0x001dd9df
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX],0x0
JZ 0x001dd9cf
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
CMP qword ptr [RAX + 0x20],0x0
JZ 0x001dd9cf
LEA RAX,[0x4713f0]
MOV RAX,qword ptr [RAX + 0xc0]
MOV RAX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX]
MOV RSI,qword ptr [RCX + 0x20]
MOV RDX,qword ptr [RBP + -0x10]
LEA RDI,[0x4713f0]
CALL RAX
CMP EAX,0x0
JNZ 0x001dd9cf
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001dd9e6
LAB_001dd9cf:
JMP 0x001dd9d1
LAB_001dd9d1:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x8
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001dd967
LAB_001dd9df:
MOV dword ptr [RBP + -0x4],0x0
LAB_001dd9e6:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int4 get_collation_number_internal(int8 param_1)
{
int iVar1;
long *local_20;
local_20 = &all_charsets;
while( true ) {
if ((long *)0xd8965f < local_20) {
return 0;
}
if (((*local_20 != 0) && (*(long *)(*local_20 + 0x20) != 0)) &&
(iVar1 = (**(code **)(PTR_my_collation_8bit_simple_ci_handler_004714b0 + 0x40))
(&my_charset_latin1,*(int8 *)(*local_20 + 0x20),param_1), iVar1 == 0
)) break;
local_20 = local_20 + 1;
}
return *(int4 *)*local_20;
}
| |
44,794 | get_collation_number_internal | eloqsql/mysys/charset.c | static uint
get_collation_number_internal(const char *name)
{
CHARSET_INFO **cs;
for (cs= all_charsets;
cs < all_charsets + array_elements(all_charsets);
cs++)
{
if (cs[0] && cs[0]->coll_name.str &&
!my_strcasecmp(&my_charset_latin1, cs[0]->coll_name.str, name))
return cs[0]->number;
}
return 0;
} | O3 | c | get_collation_number_internal:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq $-0x8, %r15
leaq 0xb7324d(%rip), %r12 # 0xc08890
leaq 0x31fb26(%rip), %r14 # 0x3b5170
movq 0x8(%r12,%r15), %rax
testq %rax, %rax
je 0x95671
movq 0x20(%rax), %rsi
testq %rsi, %rsi
je 0x95671
movq 0xc0(%r14), %rax
movq %r14, %rdi
movq %rbx, %rdx
callq *0x40(%rax)
testl %eax, %eax
je 0x95682
addq $0x8, %r15
cmpq $0x3ff8, %r15 # imm = 0x3FF8
jb 0x9564a
xorl %eax, %eax
jmp 0x95689
movq 0x8(%r12,%r15), %rax
movl (%rax), %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| get_collation_number_internal:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov rbx, rdi
mov r15, 0FFFFFFFFFFFFFFF8h
lea r12, all_charsets
lea r14, my_charset_latin1
loc_9564A:
mov rax, [r12+r15+8]
test rax, rax
jz short loc_95671
mov rsi, [rax+20h]
test rsi, rsi
jz short loc_95671
mov rax, [r14+0C0h]
mov rdi, r14
mov rdx, rbx
call qword ptr [rax+40h]
test eax, eax
jz short loc_95682
loc_95671:
add r15, 8
cmp r15, 3FF8h
jb short loc_9564A
xor eax, eax
jmp short loc_95689
loc_95682:
mov rax, [r12+r15+8]
mov eax, [rax]
loc_95689:
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long get_collation_number_internal(long long a1)
{
long long v1; // r15
long long v2; // rax
long long v3; // rsi
v1 = 0x1FFFFFFFFFFFFFFFLL;
while ( 1 )
{
v2 = all_charsets[v1 + 1];
if ( v2 )
{
v3 = *(_QWORD *)(v2 + 32);
if ( v3 )
{
if ( !(*(unsigned int ( **)(void *, long long, long long))(*((_QWORD *)&my_charset_latin1 + 24) + 64LL))(
&my_charset_latin1,
v3,
a1) )
break;
}
}
if ( (unsigned long long)++v1 >= 2047 )
return 0LL;
}
return *(unsigned int *)all_charsets[v1 + 1];
}
| get_collation_number_internal:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RBX,RDI
MOV R15,-0x8
LEA R12,[0xd08890]
LEA R14,[0x4b5170]
LAB_0019564a:
MOV RAX,qword ptr [R12 + R15*0x1 + 0x8]
TEST RAX,RAX
JZ 0x00195671
MOV RSI,qword ptr [RAX + 0x20]
TEST RSI,RSI
JZ 0x00195671
MOV RAX,qword ptr [R14 + 0xc0]
MOV RDI,R14
MOV RDX,RBX
CALL qword ptr [RAX + 0x40]
TEST EAX,EAX
JZ 0x00195682
LAB_00195671:
ADD R15,0x8
CMP R15,0x3ff8
JC 0x0019564a
XOR EAX,EAX
JMP 0x00195689
LAB_00195682:
MOV RAX,qword ptr [R12 + R15*0x1 + 0x8]
MOV EAX,dword ptr [RAX]
LAB_00195689:
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
int4 get_collation_number_internal(int8 param_1)
{
long lVar1;
int iVar2;
ulong uVar3;
uVar3 = 0xfffffffffffffff8;
while (((*(long *)((long)&DAT_00d08898 + uVar3) == 0 ||
(lVar1 = *(long *)(*(long *)((long)&DAT_00d08898 + uVar3) + 0x20), lVar1 == 0)) ||
(iVar2 = (**(code **)(PTR_my_collation_8bit_simple_ci_handler_004b5230 + 0x40))
(&my_charset_latin1,lVar1,param_1), iVar2 != 0))) {
uVar3 = uVar3 + 8;
if (0x3ff7 < uVar3) {
return 0;
}
}
return **(int4 **)((long)&DAT_00d08898 + uVar3);
}
| |
44,795 | ftxui::Screen::ApplyShader() | Andrewchistyakov[P]flashcards_lyc/build_O2/_deps/ftxui-src/src/ftxui/screen/screen.cpp | void Screen::ApplyShader() {
// Merge box characters togethers.
for (int y = 0; y < dimy_; ++y) {
for (int x = 0; x < dimx_; ++x) {
// Box drawing character uses exactly 3 byte.
Pixel& cur = pixels_[y][x];
if (!ShouldAttemptAutoMerge(cur)) {
continue;
}
if (x > 0) {
Pixel& left = pixels_[y][x-1];
if (ShouldAttemptAutoMerge(left)) {
UpgradeLeftRight(left.character, cur.character);
}
}
if (y > 0) {
Pixel& top = pixels_[y-1][x];
if (ShouldAttemptAutoMerge(top)) {
UpgradeTopDown(top.character, cur.character);
}
}
}
}
} | O2 | cpp | ftxui::Screen::ApplyShader():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorl %ecx, %ecx
movslq 0x14(%rbx), %rax
cmpq %rax, %rcx
jge 0x30923
movq %rcx, 0x18(%rsp)
imulq $0x18, %rcx, %rbp
xorl %r13d, %r13d
xorl %r12d, %r12d
movslq 0x10(%rbx), %rax
cmpq %rax, %r12
jge 0x30916
movq 0x18(%rbx), %rax
movq (%rax,%rbp), %r15
cmpb $0x0, (%r15,%r13)
jns 0x3087d
cmpq $0x3, 0x10(%r15,%r13)
jne 0x3087d
testq %r13, %r13
je 0x307ba
cmpb $0x0, -0x30(%r15,%r13)
jns 0x307ba
cmpq $0x3, -0x20(%r15,%r13)
jne 0x307ba
leaq (%r15,%r13), %rdi
addq $-0x28, %rdi
movq %rdi, 0x10(%rsp)
callq 0x30b80
movq %rax, %r14
leaq 0x22c48(%rip), %rax # 0x53380
cmpq %rax, %r14
je 0x307ba
leaq (%r15,%r13), %rdi
addq $0x8, %rdi
movq %rdi, 0x8(%rsp)
callq 0x30b80
movq %rax, %rdx
leaq 0x22c27(%rip), %rax # 0x53380
cmpq %rax, %rdx
je 0x307ba
movzwl 0x40(%r14), %eax
testb $0x30, %al
jne 0x307ae
movzwl 0x40(%rdx), %ecx
testb $0x3, %cl
je 0x307ae
movq %rdx, 0x20(%rsp)
shll $0x4, %ecx
andl $0x30, %ecx
orl %ecx, %eax
movw %ax, 0x2(%rsp)
leaq 0x2(%rsp), %rdi
callq 0x30bea
leaq 0x22c1d(%rip), %rcx # 0x533b0
cmpq %rcx, %rax
je 0x307a9
addq $0x28, %rax
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0xc240
movq 0x20(%rsp), %rdx
movzwl 0x40(%rdx), %eax
testb $0x3, %al
je 0x30889
cmpq $0x0, 0x18(%rsp)
je 0x3087d
movq 0x18(%rbx), %rax
movq -0x18(%rax,%rbp), %rax
cmpb $0x0, (%rax,%r13)
jns 0x3087d
cmpq $0x3, 0x10(%rax,%r13)
jne 0x3087d
leaq (%rax,%r13), %rdi
addq $0x8, %rdi
movq %rdi, 0x10(%rsp)
callq 0x30b80
movq %rax, %r14
leaq 0x22b7e(%rip), %rax # 0x53380
cmpq %rax, %r14
je 0x3087d
addq %r13, %r15
addq $0x8, %r15
movq %r15, %rdi
callq 0x30b80
movq %rax, %rdx
leaq 0x22b60(%rip), %rax # 0x53380
cmpq %rax, %rdx
je 0x3087d
movzwl 0x40(%r14), %eax
testb $-0x40, %al
jne 0x30875
movzwl 0x40(%rdx), %ecx
testb $0xc, %cl
je 0x30875
movq %rdx, 0x8(%rsp)
andl $0xc, %ecx
shll $0x4, %ecx
orl %ecx, %eax
movw %ax, 0x6(%rsp)
leaq 0x6(%rsp), %rdi
callq 0x30bea
leaq 0x22b56(%rip), %rcx # 0x533b0
cmpq %rcx, %rax
je 0x30870
addq $0x28, %rax
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0xc240
movq 0x8(%rsp), %rdx
movzwl 0x40(%rdx), %eax
testb $0xc, %al
je 0x308d1
incq %r12
addq $0x30, %r13
jmp 0x306cf
movzwl 0x40(%r14), %ecx
testb $0x30, %cl
je 0x307ba
shrl $0x4, %ecx
andl $0x3, %ecx
orl %ecx, %eax
movw %ax, (%rsp)
movq %rsp, %rdi
callq 0x30bea
leaq 0x22afe(%rip), %rcx # 0x533b0
cmpq %rcx, %rax
je 0x307ba
addq $0x28, %rax
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xc240
jmp 0x307ba
movzwl 0x40(%r14), %ecx
testb $-0x40, %cl
je 0x3087d
shrl $0x4, %ecx
andl $0xc, %ecx
orl %ecx, %eax
movw %ax, 0x4(%rsp)
leaq 0x4(%rsp), %rdi
callq 0x30bea
leaq 0x22ab7(%rip), %rcx # 0x533b0
cmpq %rcx, %rax
je 0x3087d
addq $0x28, %rax
movq %r15, %rdi
movq %rax, %rsi
callq 0xc240
jmp 0x3087d
movq 0x18(%rsp), %rcx
incq %rcx
jmp 0x306b3
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZN5ftxui6Screen11ApplyShaderEv:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rbx, rdi
xor ecx, ecx
loc_306B3:
movsxd rax, dword ptr [rbx+14h]
cmp rcx, rax
jge loc_30923
mov [rsp+58h+var_40], rcx
imul rbp, rcx, 18h
xor r13d, r13d
xor r12d, r12d
loc_306CF:
movsxd rax, dword ptr [rbx+10h]
cmp r12, rax
jge loc_30916
mov rax, [rbx+18h]
mov r15, [rax+rbp]
cmp byte ptr [r15+r13], 0
jns loc_3087D
cmp qword ptr [r15+r13+10h], 3
jnz loc_3087D
test r13, r13
jz loc_307BA
cmp byte ptr [r15+r13-30h], 0
jns loc_307BA
cmp qword ptr [r15+r13-20h], 3
jnz loc_307BA
lea rdi, [r15+r13]
add rdi, 0FFFFFFFFFFFFFFD8h
mov [rsp+58h+var_48], rdi
call _ZNKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN5ftxui12_GLOBAL__N_112TileEncodingESt4lessIS5_ESaISt4pairIKS5_S8_EEE4findERSC_; std::map<std::string,ftxui::`anonymous namespace'::TileEncoding>::find(std::string const&)
mov r14, rax
lea rax, dword_53380
cmp r14, rax
jz short loc_307BA
lea rdi, [r15+r13]
add rdi, 8
mov [rsp+58h+var_50], rdi
call _ZNKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN5ftxui12_GLOBAL__N_112TileEncodingESt4lessIS5_ESaISt4pairIKS5_S8_EEE4findERSC_; std::map<std::string,ftxui::`anonymous namespace'::TileEncoding>::find(std::string const&)
mov rdx, rax
lea rax, dword_53380
cmp rdx, rax
jz short loc_307BA
movzx eax, word ptr [r14+40h]
test al, 30h
jnz short loc_307AE
movzx ecx, word ptr [rdx+40h]
test cl, 3
jz short loc_307AE
mov [rsp+58h+var_38], rdx
shl ecx, 4
and ecx, 30h
or eax, ecx
mov [rsp+58h+var_56], ax
lea rdi, [rsp+58h+var_56]
call _ZNKSt3mapIN5ftxui12_GLOBAL__N_112TileEncodingENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4lessIS2_ESaISt4pairIKS2_S8_EEE4findERSC_; std::map<ftxui::`anonymous namespace'::TileEncoding,std::string>::find(ftxui::`anonymous namespace'::TileEncoding const&)
lea rcx, dword_533B0
cmp rax, rcx
jz short loc_307A9
add rax, 28h ; '('
mov rdi, [rsp+58h+var_48]
mov rsi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_assignERKS4_; std::string::_M_assign(std::string const&)
loc_307A9:
mov rdx, [rsp+58h+var_38]
loc_307AE:
movzx eax, word ptr [rdx+40h]
test al, 3
jz loc_30889
loc_307BA:
cmp [rsp+58h+var_40], 0
jz loc_3087D
mov rax, [rbx+18h]
mov rax, [rax+rbp-18h]
cmp byte ptr [rax+r13], 0
jns loc_3087D
cmp qword ptr [rax+r13+10h], 3
jnz loc_3087D
lea rdi, [rax+r13]
add rdi, 8
mov [rsp+58h+var_48], rdi
call _ZNKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN5ftxui12_GLOBAL__N_112TileEncodingESt4lessIS5_ESaISt4pairIKS5_S8_EEE4findERSC_; std::map<std::string,ftxui::`anonymous namespace'::TileEncoding>::find(std::string const&)
mov r14, rax
lea rax, dword_53380
cmp r14, rax
jz short loc_3087D
add r15, r13
add r15, 8
mov rdi, r15
call _ZNKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN5ftxui12_GLOBAL__N_112TileEncodingESt4lessIS5_ESaISt4pairIKS5_S8_EEE4findERSC_; std::map<std::string,ftxui::`anonymous namespace'::TileEncoding>::find(std::string const&)
mov rdx, rax
lea rax, dword_53380
cmp rdx, rax
jz short loc_3087D
movzx eax, word ptr [r14+40h]
test al, 0C0h
jnz short loc_30875
movzx ecx, word ptr [rdx+40h]
test cl, 0Ch
jz short loc_30875
mov [rsp+58h+var_50], rdx
and ecx, 0Ch
shl ecx, 4
or eax, ecx
mov [rsp+58h+var_52], ax
lea rdi, [rsp+58h+var_52]
call _ZNKSt3mapIN5ftxui12_GLOBAL__N_112TileEncodingENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4lessIS2_ESaISt4pairIKS2_S8_EEE4findERSC_; std::map<ftxui::`anonymous namespace'::TileEncoding,std::string>::find(ftxui::`anonymous namespace'::TileEncoding const&)
lea rcx, dword_533B0
cmp rax, rcx
jz short loc_30870
add rax, 28h ; '('
mov rdi, [rsp+58h+var_48]
mov rsi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_assignERKS4_; std::string::_M_assign(std::string const&)
loc_30870:
mov rdx, [rsp+58h+var_50]
loc_30875:
movzx eax, word ptr [rdx+40h]
test al, 0Ch
jz short loc_308D1
loc_3087D:
inc r12
add r13, 30h ; '0'
jmp loc_306CF
loc_30889:
movzx ecx, word ptr [r14+40h]
test cl, 30h
jz loc_307BA
shr ecx, 4
and ecx, 3
or eax, ecx
mov [rsp+58h+var_58], ax
mov rdi, rsp
call _ZNKSt3mapIN5ftxui12_GLOBAL__N_112TileEncodingENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4lessIS2_ESaISt4pairIKS2_S8_EEE4findERSC_; std::map<ftxui::`anonymous namespace'::TileEncoding,std::string>::find(ftxui::`anonymous namespace'::TileEncoding const&)
lea rcx, dword_533B0
cmp rax, rcx
jz loc_307BA
add rax, 28h ; '('
mov rdi, [rsp+58h+var_50]
mov rsi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_assignERKS4_; std::string::_M_assign(std::string const&)
jmp loc_307BA
loc_308D1:
movzx ecx, word ptr [r14+40h]
test cl, 0C0h
jz short loc_3087D
shr ecx, 4
and ecx, 0Ch
or eax, ecx
mov [rsp+58h+var_54], ax
lea rdi, [rsp+58h+var_54]
call _ZNKSt3mapIN5ftxui12_GLOBAL__N_112TileEncodingENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4lessIS2_ESaISt4pairIKS2_S8_EEE4findERSC_; std::map<ftxui::`anonymous namespace'::TileEncoding,std::string>::find(ftxui::`anonymous namespace'::TileEncoding const&)
lea rcx, dword_533B0
cmp rax, rcx
jz loc_3087D
add rax, 28h ; '('
mov rdi, r15
mov rsi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_assignERKS4_; std::string::_M_assign(std::string const&)
jmp loc_3087D
loc_30916:
mov rcx, [rsp+58h+var_40]
inc rcx
jmp loc_306B3
loc_30923:
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ftxui::Screen::ApplyShader(ftxui::Screen *this)
{
long long i; // rcx
long long result; // rax
long long v3; // rbp
long long v4; // r13
long long j; // r12
long long v6; // r15
long long v7; // r14
long long v8; // rdx
__int16 v9; // ax
__int16 v10; // cx
int *v11; // rax
__int16 v12; // ax
long long v13; // rax
long long v14; // r14
long long v15; // r15
long long v16; // rdx
__int16 v17; // ax
__int16 v18; // cx
int *v19; // rax
__int16 v20; // ax
int *v21; // rax
int *v22; // rax
__int16 v23; // [rsp+0h] [rbp-58h] BYREF
__int16 v24; // [rsp+2h] [rbp-56h] BYREF
__int16 v25; // [rsp+4h] [rbp-54h] BYREF
__int16 v26; // [rsp+6h] [rbp-52h] BYREF
long long v27; // [rsp+8h] [rbp-50h]
long long v28; // [rsp+10h] [rbp-48h]
long long v29; // [rsp+18h] [rbp-40h]
long long v30; // [rsp+20h] [rbp-38h]
for ( i = 0LL; ; i = v29 + 1 )
{
result = *((int *)this + 5);
if ( i >= result )
break;
v29 = i;
v3 = 24 * i;
v4 = 0LL;
for ( j = 0LL; j < *((int *)this + 4); ++j )
{
v6 = *(_QWORD *)(*((_QWORD *)this + 3) + v3);
if ( *(char *)(v6 + v4) < 0 && *(_QWORD *)(v6 + v4 + 16) == 3LL )
{
if ( v4 )
{
if ( *(char *)(v6 + v4 - 48) < 0 && *(_QWORD *)(v6 + v4 - 32) == 3LL )
{
v28 = v6 + v4 - 40;
v7 = std::map<std::string,ftxui::`anonymous namespace'::TileEncoding>::find(v28);
if ( (int *)v7 != &dword_53380 )
{
v27 = v6 + v4 + 8;
v8 = std::map<std::string,ftxui::`anonymous namespace'::TileEncoding>::find(v27);
if ( (int *)v8 != &dword_53380 )
{
v9 = *(_WORD *)(v7 + 64);
if ( (v9 & 0x30) == 0 )
{
v10 = *(_WORD *)(v8 + 64);
if ( (v10 & 3) != 0 )
{
v30 = v8;
v24 = (16 * (_BYTE)v10) & 0x30 | v9;
v11 = (int *)std::map<ftxui::`anonymous namespace'::TileEncoding,std::string>::find(&v24);
if ( v11 != &dword_533B0 )
std::string::_M_assign(v28, v11 + 10);
v8 = v30;
}
}
v12 = *(_WORD *)(v8 + 64);
if ( (v12 & 3) == 0 && (*(_WORD *)(v7 + 64) & 0x30) != 0 )
{
v23 = (*(_WORD *)(v7 + 64) >> 4) & 3 | v12;
v21 = (int *)std::map<ftxui::`anonymous namespace'::TileEncoding,std::string>::find(&v23);
if ( v21 != &dword_533B0 )
std::string::_M_assign(v27, v21 + 10);
}
}
}
}
}
if ( v29 )
{
v13 = *(_QWORD *)(*((_QWORD *)this + 3) + v3 - 24);
if ( *(char *)(v13 + v4) < 0 && *(_QWORD *)(v13 + v4 + 16) == 3LL )
{
v28 = v13 + v4 + 8;
v14 = ((long long (*)(void))std::map<std::string,ftxui::`anonymous namespace'::TileEncoding>::find)();
if ( (int *)v14 != &dword_53380 )
{
v15 = v4 + v6 + 8;
v16 = std::map<std::string,ftxui::`anonymous namespace'::TileEncoding>::find(v15);
if ( (int *)v16 != &dword_53380 )
{
v17 = *(_WORD *)(v14 + 64);
if ( (v17 & 0xC0) == 0 )
{
v18 = *(_WORD *)(v16 + 64);
if ( (v18 & 0xC) != 0 )
{
v27 = v16;
v26 = (16 * (v18 & 0xC)) | v17;
v19 = (int *)std::map<ftxui::`anonymous namespace'::TileEncoding,std::string>::find(&v26);
if ( v19 != &dword_533B0 )
std::string::_M_assign(v28, v19 + 10);
v16 = v27;
}
}
v20 = *(_WORD *)(v16 + 64);
if ( (v20 & 0xC) == 0 && (*(_WORD *)(v14 + 64) & 0xC0) != 0 )
{
v25 = (*(_WORD *)(v14 + 64) >> 4) & 0xC | v20;
v22 = (int *)std::map<ftxui::`anonymous namespace'::TileEncoding,std::string>::find(&v25);
if ( v22 != &dword_533B0 )
std::string::_M_assign(v15, v22 + 10);
}
}
}
}
}
}
v4 += 48LL;
}
}
return result;
}
| ApplyShader:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
XOR ECX,ECX
LAB_001306b3:
MOVSXD RAX,dword ptr [RBX + 0x14]
CMP RCX,RAX
JGE 0x00130923
MOV qword ptr [RSP + 0x18],RCX
IMUL RBP,RCX,0x18
XOR R13D,R13D
XOR R12D,R12D
LAB_001306cf:
MOVSXD RAX,dword ptr [RBX + 0x10]
CMP R12,RAX
JGE 0x00130916
MOV RAX,qword ptr [RBX + 0x18]
MOV R15,qword ptr [RAX + RBP*0x1]
CMP byte ptr [R15 + R13*0x1],0x0
JNS 0x0013087d
CMP qword ptr [R15 + R13*0x1 + 0x10],0x3
JNZ 0x0013087d
TEST R13,R13
JZ 0x001307ba
CMP byte ptr [R15 + R13*0x1 + -0x30],0x0
JNS 0x001307ba
CMP qword ptr [R15 + R13*0x1 + -0x20],0x3
JNZ 0x001307ba
LEA RDI,[R15 + R13*0x1]
ADD RDI,-0x28
MOV qword ptr [RSP + 0x10],RDI
CALL 0x00130b80
MOV R14,RAX
LEA RAX,[0x153380]
CMP R14,RAX
JZ 0x001307ba
LEA RDI,[R15 + R13*0x1]
ADD RDI,0x8
MOV qword ptr [RSP + 0x8],RDI
CALL 0x00130b80
MOV RDX,RAX
LEA RAX,[0x153380]
CMP RDX,RAX
JZ 0x001307ba
MOVZX EAX,word ptr [R14 + 0x40]
TEST AL,0x30
JNZ 0x001307ae
MOVZX ECX,word ptr [RDX + 0x40]
TEST CL,0x3
JZ 0x001307ae
MOV qword ptr [RSP + 0x20],RDX
SHL ECX,0x4
AND ECX,0x30
OR EAX,ECX
MOV word ptr [RSP + 0x2],AX
LEA RDI,[RSP + 0x2]
CALL 0x00130bea
LEA RCX,[0x1533b0]
CMP RAX,RCX
JZ 0x001307a9
ADD RAX,0x28
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,RAX
CALL 0x0010c240
LAB_001307a9:
MOV RDX,qword ptr [RSP + 0x20]
LAB_001307ae:
MOVZX EAX,word ptr [RDX + 0x40]
TEST AL,0x3
JZ 0x00130889
LAB_001307ba:
CMP qword ptr [RSP + 0x18],0x0
JZ 0x0013087d
MOV RAX,qword ptr [RBX + 0x18]
MOV RAX,qword ptr [RAX + RBP*0x1 + -0x18]
CMP byte ptr [RAX + R13*0x1],0x0
JNS 0x0013087d
CMP qword ptr [RAX + R13*0x1 + 0x10],0x3
JNZ 0x0013087d
LEA RDI,[RAX + R13*0x1]
ADD RDI,0x8
MOV qword ptr [RSP + 0x10],RDI
CALL 0x00130b80
MOV R14,RAX
LEA RAX,[0x153380]
CMP R14,RAX
JZ 0x0013087d
ADD R15,R13
ADD R15,0x8
MOV RDI,R15
CALL 0x00130b80
MOV RDX,RAX
LEA RAX,[0x153380]
CMP RDX,RAX
JZ 0x0013087d
MOVZX EAX,word ptr [R14 + 0x40]
TEST AL,0xc0
JNZ 0x00130875
MOVZX ECX,word ptr [RDX + 0x40]
TEST CL,0xc
JZ 0x00130875
MOV qword ptr [RSP + 0x8],RDX
AND ECX,0xc
SHL ECX,0x4
OR EAX,ECX
MOV word ptr [RSP + 0x6],AX
LEA RDI,[RSP + 0x6]
CALL 0x00130bea
LEA RCX,[0x1533b0]
CMP RAX,RCX
JZ 0x00130870
ADD RAX,0x28
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,RAX
CALL 0x0010c240
LAB_00130870:
MOV RDX,qword ptr [RSP + 0x8]
LAB_00130875:
MOVZX EAX,word ptr [RDX + 0x40]
TEST AL,0xc
JZ 0x001308d1
LAB_0013087d:
INC R12
ADD R13,0x30
JMP 0x001306cf
LAB_00130889:
MOVZX ECX,word ptr [R14 + 0x40]
TEST CL,0x30
JZ 0x001307ba
SHR ECX,0x4
AND ECX,0x3
OR EAX,ECX
MOV word ptr [RSP],AX
MOV RDI,RSP
CALL 0x00130bea
LEA RCX,[0x1533b0]
CMP RAX,RCX
JZ 0x001307ba
ADD RAX,0x28
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,RAX
CALL 0x0010c240
JMP 0x001307ba
LAB_001308d1:
MOVZX ECX,word ptr [R14 + 0x40]
TEST CL,0xc0
JZ 0x0013087d
SHR ECX,0x4
AND ECX,0xc
OR EAX,ECX
MOV word ptr [RSP + 0x4],AX
LEA RDI,[RSP + 0x4]
CALL 0x00130bea
LEA RCX,[0x1533b0]
CMP RAX,RCX
JZ 0x0013087d
ADD RAX,0x28
MOV RDI,R15
MOV RSI,RAX
CALL 0x0010c240
JMP 0x0013087d
LAB_00130916:
MOV RCX,qword ptr [RSP + 0x18]
INC RCX
JMP 0x001306b3
LAB_00130923:
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* ftxui::Screen::ApplyShader() */
void __thiscall ftxui::Screen::ApplyShader(Screen *this)
{
long lVar1;
long lVar2;
long lVar3;
string *psVar4;
long lVar5;
long lVar6;
long lVar7;
long lVar8;
string *psVar9;
ushort local_58;
ushort local_56;
ushort local_54;
ushort local_52;
string *local_50;
string *local_48;
long local_40;
long local_38;
for (local_40 = 0; local_40 < *(int *)(this + 0x14); local_40 = local_40 + 1) {
lVar6 = local_40 * 0x18;
lVar8 = 0;
for (lVar7 = 0; lVar7 < *(int *)(this + 0x10); lVar7 = lVar7 + 1) {
lVar5 = *(long *)(*(long *)(this + 0x18) + lVar6);
if ((*(char *)(lVar5 + lVar8) < '\0') && (*(long *)(lVar5 + 0x10 + lVar8) == 3)) {
if ((lVar8 != 0) &&
((*(char *)(lVar5 + -0x30 + lVar8) < '\0' && (*(long *)(lVar5 + -0x20 + lVar8) == 3)))) {
local_48 = (string *)(lVar5 + lVar8 + -0x28);
lVar1 = std::
map<std::__cxx11::string,ftxui::(anonymous_namespace)::TileEncoding,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,ftxui::(anonymous_namespace)::TileEncoding>>>
::find(local_48);
if (lVar1 != 0x153380) {
local_50 = (string *)(lVar5 + lVar8 + 8);
lVar2 = std::
map<std::__cxx11::string,ftxui::(anonymous_namespace)::TileEncoding,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,ftxui::(anonymous_namespace)::TileEncoding>>>
::find(local_50);
if (lVar2 != 0x153380) {
if (((*(ushort *)(lVar1 + 0x40) & 0x30) == 0) &&
((*(ushort *)(lVar2 + 0x40) & 3) != 0)) {
local_56 = *(ushort *)(lVar1 + 0x40) |
(ushort)((*(ushort *)(lVar2 + 0x40) & 3) << 4);
local_38 = lVar2;
lVar3 = std::
map<ftxui::(anonymous_namespace)::TileEncoding,std::__cxx11::string,std::less<ftxui::(anonymous_namespace)::TileEncoding>,std::allocator<std::pair<ftxui::(anonymous_namespace)::TileEncoding_const,std::__cxx11::string>>>
::find((TileEncoding *)&local_56);
lVar2 = local_38;
if (lVar3 != 0x1533b0) {
std::__cxx11::string::_M_assign(local_48);
lVar2 = local_38;
}
}
if (((*(ushort *)(lVar2 + 0x40) & 3) == 0) &&
((*(ushort *)(lVar1 + 0x40) & 0x30) != 0)) {
local_58 = *(ushort *)(lVar2 + 0x40) | *(ushort *)(lVar1 + 0x40) >> 4 & 3;
lVar1 = std::
map<ftxui::(anonymous_namespace)::TileEncoding,std::__cxx11::string,std::less<ftxui::(anonymous_namespace)::TileEncoding>,std::allocator<std::pair<ftxui::(anonymous_namespace)::TileEncoding_const,std::__cxx11::string>>>
::find((TileEncoding *)&local_58);
if (lVar1 != 0x1533b0) {
std::__cxx11::string::_M_assign(local_50);
}
}
}
}
}
if (((local_40 != 0) &&
(lVar1 = *(long *)(*(long *)(this + 0x18) + -0x18 + lVar6),
*(char *)(lVar1 + lVar8) < '\0')) && (*(long *)(lVar1 + 0x10 + lVar8) == 3)) {
local_48 = (string *)(lVar1 + lVar8 + 8);
lVar1 = std::
map<std::__cxx11::string,ftxui::(anonymous_namespace)::TileEncoding,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,ftxui::(anonymous_namespace)::TileEncoding>>>
::find(local_48);
if (lVar1 != 0x153380) {
psVar9 = (string *)(lVar5 + lVar8 + 8);
psVar4 = (string *)
std::
map<std::__cxx11::string,ftxui::(anonymous_namespace)::TileEncoding,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,ftxui::(anonymous_namespace)::TileEncoding>>>
::find(psVar9);
if (psVar4 != (string *)((anonymous_namespace)::tile_encoding_abi_cxx11_ + 8)) {
if (((*(ushort *)(lVar1 + 0x40) & 0xc0) == 0) &&
((*(ushort *)(psVar4 + 0x40) & 0xc) != 0)) {
local_52 = *(ushort *)(lVar1 + 0x40) |
(ushort)((*(ushort *)(psVar4 + 0x40) & 0xc) << 4);
local_50 = psVar4;
lVar5 = std::
map<ftxui::(anonymous_namespace)::TileEncoding,std::__cxx11::string,std::less<ftxui::(anonymous_namespace)::TileEncoding>,std::allocator<std::pair<ftxui::(anonymous_namespace)::TileEncoding_const,std::__cxx11::string>>>
::find((TileEncoding *)&local_52);
psVar4 = local_50;
if (lVar5 != 0x1533b0) {
std::__cxx11::string::_M_assign(local_48);
psVar4 = local_50;
}
}
if (((*(ushort *)(psVar4 + 0x40) & 0xc) == 0) &&
((*(ushort *)(lVar1 + 0x40) & 0xc0) != 0)) {
local_54 = *(ushort *)(psVar4 + 0x40) | *(ushort *)(lVar1 + 0x40) >> 4 & 0xc;
lVar5 = std::
map<ftxui::(anonymous_namespace)::TileEncoding,std::__cxx11::string,std::less<ftxui::(anonymous_namespace)::TileEncoding>,std::allocator<std::pair<ftxui::(anonymous_namespace)::TileEncoding_const,std::__cxx11::string>>>
::find((TileEncoding *)&local_54);
if (lVar5 != 0x1533b0) {
std::__cxx11::string::_M_assign(psVar9);
}
}
}
}
}
}
lVar8 = lVar8 + 0x30;
}
}
return;
}
| |
44,796 | my_hash_sort_ucs2_nopad_bin | eloqsql/strings/ctype-ucs2.c | static void
my_hash_sort_ucs2_nopad_bin(CHARSET_INFO *cs __attribute__((unused)),
const uchar *key, size_t len,
ulong *nr1, ulong *nr2)
{
const uchar *end= key + len;
register ulong m1= *nr1, m2= *nr2;
for ( ; key < end ; key++)
{
MY_HASH_ADD(m1, m2, (uint)*key);
}
*nr1= m1;
*nr2= m2;
} | O3 | c | my_hash_sort_ucs2_nopad_bin:
movq (%rcx), %rax
movq (%r8), %rdi
testq %rdx, %rdx
jle 0x55375
pushq %rbp
movq %rsp, %rbp
addq %rsi, %rdx
movl %eax, %r9d
andl $0x3f, %r9d
addq %rdi, %r9
movzbl (%rsi), %r10d
imulq %r9, %r10
movq %rax, %r9
shlq $0x8, %r9
addq %r10, %r9
xorq %r9, %rax
addq $0x3, %rdi
incq %rsi
cmpq %rdx, %rsi
jb 0x55349
popq %rbp
movq %rax, (%rcx)
movq %rdi, (%r8)
retq
| my_hash_sort_ucs2_nopad_bin:
mov rax, [rcx]
mov rdi, [r8]
test rdx, rdx
jle short loc_55375
push rbp
mov rbp, rsp
add rdx, rsi
loc_55349:
mov r9d, eax
and r9d, 3Fh
add r9, rdi
movzx r10d, byte ptr [rsi]
imul r10, r9
mov r9, rax
shl r9, 8
add r9, r10
xor rax, r9
add rdi, 3
inc rsi
cmp rsi, rdx
jb short loc_55349
pop rbp
loc_55375:
mov [rcx], rax
mov [r8], rdi
retn
| long long my_hash_sort_ucs2_nopad_bin(long long a1, unsigned __int8 *a2, long long a3, long long *a4, long long *a5)
{
long long result; // rax
long long v6; // rdi
unsigned __int8 *v7; // rdx
result = *a4;
v6 = *a5;
if ( a3 > 0 )
{
v7 = &a2[a3];
do
{
result ^= (v6 + (result & 0x3F)) * *a2 + (result << 8);
v6 += 3LL;
++a2;
}
while ( a2 < v7 );
}
*a4 = result;
*a5 = v6;
return result;
}
| my_hash_sort_ucs2_nopad_bin:
MOV RAX,qword ptr [RCX]
MOV RDI,qword ptr [R8]
TEST RDX,RDX
JLE 0x00155375
PUSH RBP
MOV RBP,RSP
ADD RDX,RSI
LAB_00155349:
MOV R9D,EAX
AND R9D,0x3f
ADD R9,RDI
MOVZX R10D,byte ptr [RSI]
IMUL R10,R9
MOV R9,RAX
SHL R9,0x8
ADD R9,R10
XOR RAX,R9
ADD RDI,0x3
INC RSI
CMP RSI,RDX
JC 0x00155349
POP RBP
LAB_00155375:
MOV qword ptr [RCX],RAX
MOV qword ptr [R8],RDI
RET
|
void my_hash_sort_ucs2_nopad_bin
(int8 param_1,byte *param_2,long param_3,ulong *param_4,long *param_5)
{
ulong uVar1;
byte *pbVar2;
long lVar3;
uVar1 = *param_4;
lVar3 = *param_5;
if (0 < param_3) {
pbVar2 = param_2 + param_3;
do {
uVar1 = uVar1 ^ uVar1 * 0x100 + (ulong)*param_2 * ((ulong)((uint)uVar1 & 0x3f) + lVar3);
lVar3 = lVar3 + 3;
param_2 = param_2 + 1;
} while (param_2 < pbVar2);
}
*param_4 = uVar1;
*param_5 = lVar3;
return;
}
| |
44,797 | llama_sbatch::split_seq(unsigned long) | monkey531[P]llama/src/llama-batch.cpp | llama_ubatch llama_sbatch::split_seq(size_t n_ubatch) {
n_ubatch = n_tokens < n_ubatch ? n_tokens : n_ubatch;
llama_ubatch ubatch = reserve_ubatch(n_ubatch, /* has_embd */ batch->embd != nullptr);
if (!seq.empty()) {
llama_sbatch_seq & s = seq[seq.size() - 1];
size_t length = s.length < n_ubatch ? s.length : n_ubatch;
GGML_ASSERT(s.n_seq_id > 0); // should not be mixed with simple splits
add_seq_to_ubatch(ubatch, s, length);
}
return ubatch;
} | O3 | cpp | llama_sbatch::split_seq(unsigned long):
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x60(%rsi), %rdx
cmpq %r14, %rax
cmovbq %rax, %r14
xorl %ecx, %ecx
cmpq $0x0, 0x10(%rdx)
setne %cl
movq %r14, %rdx
callq 0x6a260
movq 0x50(%r15), %rax
cmpq %rax, 0x48(%r15)
je 0x979f6
cmpl $0x0, -0x20(%rax)
jle 0x979ff
movq %rax, %rdx
addq $-0x20, %rdx
movq -0x8(%rax), %rax
cmpq %r14, %rax
cmovbq %rax, %r14
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rcx
callq 0x66d30
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x7c05a(%rip), %rdi # 0x113a60
leaq 0x789b7(%rip), %rdx # 0x1103c4
leaq 0x7c1c2(%rip), %rcx # 0x113bd6
movl $0xba, %esi
xorl %eax, %eax
callq 0x6af70
| _ZN12llama_sbatch9split_seqEm:
push r15
push r14
push rbx
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov rax, [rsi]
mov rdx, [rsi+60h]
cmp rax, r14
cmovb r14, rax
xor ecx, ecx
cmp qword ptr [rdx+10h], 0
setnz cl
mov rdx, r14; bool
call __ZN12llama_sbatch14reserve_ubatchEmb; llama_sbatch::reserve_ubatch(ulong,bool)
mov rax, [r15+50h]
cmp [r15+48h], rax
jz short loc_979F6
cmp dword ptr [rax-20h], 0
jle short loc_979FF
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFE0h
mov rax, [rax-8]
cmp rax, r14
cmovb r14, rax
mov rdi, r15
mov rsi, rbx
mov rcx, r14
call __ZN12llama_sbatch17add_seq_to_ubatchER12llama_ubatchR16llama_sbatch_seqm; llama_sbatch::add_seq_to_ubatch(llama_ubatch &,llama_sbatch_seq &,ulong)
loc_979F6:
mov rax, rbx
pop rbx
pop r14
pop r15
retn
loc_979FF:
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aSNSeqId0; "s.n_seq_id > 0"
mov esi, 0BAh
xor eax, eax
call _ggml_abort
| llama_sbatch * llama_sbatch::split_seq(llama_sbatch *this, unsigned long long *a2, unsigned long long a3)
{
unsigned long long v3; // r14
unsigned long long v4; // rax
long long v5; // rdx
unsigned long long v6; // rax
double v8; // xmm0_8
v3 = a3;
if ( *a2 < a3 )
v3 = *a2;
llama_sbatch::reserve_ubatch(this, (unsigned long long)a2, v3);
v4 = a2[10];
if ( a2[9] == v4 )
return this;
if ( *(int *)(v4 - 32) > 0 )
{
v5 = v4 - 32;
v6 = *(_QWORD *)(v4 - 8);
if ( v6 < v3 )
v3 = v6;
llama_sbatch::add_seq_to_ubatch((long long)a2, (char *)this, v5, v3);
return this;
}
v8 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/src/llama-batch.cpp",
186LL,
"GGML_ASSERT(%s) failed",
"s.n_seq_id > 0");
return (llama_sbatch *)llama_sbatch::from_batch(v8);
}
| split_seq:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RSI]
MOV RDX,qword ptr [RSI + 0x60]
CMP RAX,R14
CMOVC R14,RAX
XOR ECX,ECX
CMP qword ptr [RDX + 0x10],0x0
SETNZ CL
MOV RDX,R14
CALL 0x0016a260
MOV RAX,qword ptr [R15 + 0x50]
CMP qword ptr [R15 + 0x48],RAX
JZ 0x001979f6
CMP dword ptr [RAX + -0x20],0x0
JLE 0x001979ff
MOV RDX,RAX
ADD RDX,-0x20
MOV RAX,qword ptr [RAX + -0x8]
CMP RAX,R14
CMOVC R14,RAX
MOV RDI,R15
MOV RSI,RBX
MOV RCX,R14
CALL 0x00166d30
LAB_001979f6:
MOV RAX,RBX
POP RBX
POP R14
POP R15
RET
LAB_001979ff:
LEA RDI,[0x213a60]
LEA RDX,[0x2103c4]
LEA RCX,[0x213bd6]
MOV ESI,0xba
XOR EAX,EAX
CALL 0x0016af70
|
/* llama_sbatch::split_seq(unsigned long) */
ulong llama_sbatch::split_seq(ulong param_1)
{
long lVar1;
ulong in_RDX;
llama_sbatch *in_RSI;
if (*(ulong *)in_RSI < in_RDX) {
in_RDX = *(ulong *)in_RSI;
}
reserve_ubatch(param_1,SUB81(in_RSI,0));
lVar1 = *(long *)(in_RSI + 0x50);
if (*(long *)(in_RSI + 0x48) != lVar1) {
if (*(int *)(lVar1 + -0x20) < 1) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/src/llama-batch.cpp",
0xba,"GGML_ASSERT(%s) failed","s.n_seq_id > 0");
}
if (*(ulong *)(lVar1 + -8) < in_RDX) {
in_RDX = *(ulong *)(lVar1 + -8);
}
add_seq_to_ubatch(in_RSI,(llama_ubatch *)param_1,(llama_sbatch_seq *)(lVar1 + -0x20),in_RDX);
}
return param_1;
}
| |
44,798 | my_time_init | eloqsql/mysys/my_getsystime.c | void my_time_init()
{
#ifdef _WIN32
compile_time_assert(sizeof(LARGE_INTEGER) ==
sizeof(query_performance_frequency));
QueryPerformanceFrequency((LARGE_INTEGER *)&query_performance_frequency);
DBUG_ASSERT(query_performance_frequency);
#endif
} | O0 | c | my_time_init:
pushq %rbp
movq %rsp, %rbp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_time_init:
push rbp
mov rbp, rsp
pop rbp
retn
| void my_time_init()
{
;
}
| my_time_init:
PUSH RBP
MOV RBP,RSP
POP RBP
RET
|
void my_time_init(void)
{
return;
}
| |
44,799 | my_strnxfrm_uca_pad | eloqsql/strings/ctype-uca.c | static uchar *
my_strnxfrm_uca_pad(uchar *dst, uchar *de, int weight)
{
for ( ; dst < de; )
{
*dst++= weight >> 8;
if (dst < de)
*dst++= weight & 0xFF;
}
return dst;
} | O0 | c | my_strnxfrm_uca_pad:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x611f9
movl -0x14(%rbp), %eax
sarl $0x8, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x611f7
movl -0x14(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
jmp 0x611af
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| my_strnxfrm_uca_pad:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
loc_611AF:
mov rax, [rbp+var_8]
cmp rax, [rbp+var_10]
jnb short loc_611F9
mov eax, [rbp+var_14]
sar eax, 8
mov cl, al
mov rax, [rbp+var_8]
mov rdx, rax
add rdx, 1
mov [rbp+var_8], rdx
mov [rax], cl
mov rax, [rbp+var_8]
cmp rax, [rbp+var_10]
jnb short loc_611F7
mov eax, [rbp+var_14]
and eax, 0FFh
mov cl, al
mov rax, [rbp+var_8]
mov rdx, rax
add rdx, 1
mov [rbp+var_8], rdx
mov [rax], cl
loc_611F7:
jmp short loc_611AF
loc_611F9:
mov rax, [rbp+var_8]
pop rbp
retn
| _BYTE * my_strnxfrm_uca_pad(_BYTE *a1, unsigned long long a2, __int16 a3)
{
_BYTE *v3; // rax
_BYTE *v4; // rax
while ( (unsigned long long)a1 < a2 )
{
v3 = a1++;
*v3 = HIBYTE(a3);
if ( (unsigned long long)a1 < a2 )
{
v4 = a1++;
*v4 = a3;
}
}
return a1;
}
| my_strnxfrm_uca_pad:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
LAB_001611af:
MOV RAX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RBP + -0x10]
JNC 0x001611f9
MOV EAX,dword ptr [RBP + -0x14]
SAR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x8]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x8],RDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RBP + -0x10]
JNC 0x001611f7
MOV EAX,dword ptr [RBP + -0x14]
AND EAX,0xff
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x8]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x8],RDX
MOV byte ptr [RAX],CL
LAB_001611f7:
JMP 0x001611af
LAB_001611f9:
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
int1 * my_strnxfrm_uca_pad(int1 *param_1,int1 *param_2,int4 param_3)
{
int1 *puVar1;
int1 *local_10;
puVar1 = param_1;
while (local_10 = puVar1, local_10 < param_2) {
puVar1 = local_10 + 1;
*local_10 = (char)((uint)param_3 >> 8);
if (puVar1 < param_2) {
*puVar1 = (char)param_3;
puVar1 = local_10 + 2;
}
}
return local_10;
}
|
Subsets and Splits
C++ Functions With Standard Library Dependencies
Identifies C++ functions that depend on standard library components, revealing patterns in how developers utilize STL libraries and potentially highlighting common coding practices or dependencies in the dataset.
C++ Standard Library Function Analysis
Filters C++ code examples that use standard library containers and types, providing useful insights into common programming patterns and data structures in the dataset.
Random Training Function Samples
Performs basic filtering and random sampling of assembly code data without revealing meaningful patterns or relationships.
Random Training Function Samples
Retrieves a random sample of 1000 records from the training dataset, providing basic data exploration but offering limited analytical value beyond seeing raw entries.