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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
53,900 | js_compile_regexp | bluesky950520[P]quickjs/quickjs.c | static JSValue js_compile_regexp(JSContext *ctx, JSValue pattern,
JSValue flags)
{
const char *str;
int re_flags, mask;
uint8_t *re_bytecode_buf;
size_t i, len;
int re_bytecode_len;
JSValue ret;
char error_msg[64];
re_flags = 0;
if (!JS_IsUndefined(flags)) {
str = JS_ToCStringLen(ctx, &len, flags);
if (!str)
return JS_EXCEPTION;
/* XXX: re_flags = LRE_FLAG_OCTAL unless strict mode? */
for (i = 0; i < len; i++) {
switch(str[i]) {
case 'd':
mask = LRE_FLAG_INDICES;
break;
case 'g':
mask = LRE_FLAG_GLOBAL;
break;
case 'i':
mask = LRE_FLAG_IGNORECASE;
break;
case 'm':
mask = LRE_FLAG_MULTILINE;
break;
case 's':
mask = LRE_FLAG_DOTALL;
break;
case 'u':
mask = LRE_FLAG_UNICODE;
break;
case 'v':
mask = LRE_FLAG_UNICODE_SETS;
break;
case 'y':
mask = LRE_FLAG_STICKY;
break;
default:
goto bad_flags;
}
if ((re_flags & mask) != 0) {
bad_flags:
JS_FreeCString(ctx, str);
return JS_ThrowSyntaxError(ctx, "invalid regular expression flags");
}
re_flags |= mask;
}
JS_FreeCString(ctx, str);
}
if (re_flags & LRE_FLAG_UNICODE)
if (re_flags & LRE_FLAG_UNICODE_SETS)
return JS_ThrowSyntaxError(ctx, "invalid regular expression flags");
str = JS_ToCStringLen2(ctx, &len, pattern, !(re_flags & LRE_FLAG_UNICODE));
if (!str)
return JS_EXCEPTION;
re_bytecode_buf = lre_compile(&re_bytecode_len, error_msg,
sizeof(error_msg), str, len, re_flags, ctx);
JS_FreeCString(ctx, str);
if (!re_bytecode_buf) {
JS_ThrowSyntaxError(ctx, "%s", error_msg);
return JS_EXCEPTION;
}
ret = js_new_string8_len(ctx, (char *)re_bytecode_buf, re_bytecode_len);
js_free(ctx, re_bytecode_buf);
return ret;
} | O1 | c | js_compile_regexp:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
xorl %r15d, %r15d
cmpl $0x3, %r8d
jne 0x335b0
movl %r15d, %eax
notl %eax
testl $0x110, %eax # imm = 0x110
jne 0x336ae
leaq 0x6c51c(%rip), %rsi # 0x9fab4
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x224d1
movl $0x6, %r14d
jmp 0x337dd
leaq 0x10(%rsp), %rsi
xorl %r15d, %r15d
movq %rbx, %rdi
movq %rcx, %rdx
movq %r8, %rcx
xorl %r8d, %r8d
callq 0x20bf7
movl $0x6, %r14d
testq %rax, %rax
je 0x337dd
movq 0x10(%rsp), %rcx
testq %rcx, %rcx
je 0x33680
xorl %r15d, %r15d
leaq 0x692f0(%rip), %rdx # 0x9c8e0
leaq 0x692c1(%rip), %rsi # 0x9c8b8
xorl %edi, %edi
movzbl (%rax,%rdi), %r8d
leal -0x64(%r8), %r9d
cmpl $0x9, %r9d
jbe 0x33628
addl $-0x73, %r8d
cmpl $0x6, %r8d
ja 0x33789
movslq (%rdx,%r8,4), %r8
addq %rdx, %r8
jmpq *%r8
movl $0x8, %r8d
jmp 0x33668
movslq (%rsi,%r9,4), %r8
addq %rsi, %r8
jmpq *%r8
movl $0x40, %r8d
jmp 0x33668
movl $0x2, %r8d
jmp 0x33668
movl $0x1, %r8d
jmp 0x33668
movl $0x4, %r8d
jmp 0x33668
movl $0x100, %r8d # imm = 0x100
jmp 0x33668
movl $0x10, %r8d
jmp 0x33668
movl $0x20, %r8d
testl %r15d, %r8d
jne 0x33789
orl %r8d, %r15d
incq %rdi
cmpq %rdi, %rcx
jne 0x335f9
movq 0x18(%rbx), %rdi
movl -0x18(%rax), %ecx
leal -0x1(%rcx), %edx
movl %edx, -0x18(%rax)
cmpl $0x1, %ecx
jg 0x33581
addq $-0x18, %rax
movq %rax, %rsi
movq $-0x7, %rdx
callq 0x21266
jmp 0x33581
xorl %r8d, %r8d
testb $0x10, %r15b
sete %r8b
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %r13, %rdx
movq %r12, %rcx
callq 0x20bf7
movl $0x6, %r14d
testq %rax, %rax
je 0x33784
movq %rax, %r12
movq 0x10(%rsp), %r8
movq %rbx, (%rsp)
leaq 0x1c(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movl $0x40, %edx
movq %rax, %rcx
movl %r15d, %r9d
callq 0x94801
movq %rax, %r15
movq 0x18(%rbx), %rdi
movl -0x18(%r12), %eax
leal -0x1(%rax), %ecx
movl %ecx, -0x18(%r12)
cmpl $0x1, %eax
jg 0x3372d
addq $-0x18, %r12
movq %r12, %rsi
movq $-0x7, %rdx
callq 0x21266
testq %r15, %r15
je 0x337c4
movl 0x1c(%rsp), %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x201dd
movq %rax, %r12
movq %rdx, %r14
movq 0x18(%rbx), %rbx
decq 0x28(%rbx)
movq %r15, %rdi
callq *0x20(%rbx)
movq 0x30(%rbx), %rcx
movq 0x40(%rbx), %rdi
subq %rax, %rcx
addq $-0x8, %rcx
movq %rcx, 0x30(%rbx)
movq %r15, %rsi
callq *0x10(%rbx)
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
andq %r12, %rax
movl %r12d, %r15d
jmp 0x337df
xorl %r15d, %r15d
jmp 0x337dd
movq 0x18(%rbx), %rdi
movl -0x18(%rax), %ecx
leal -0x1(%rcx), %edx
movl %edx, -0x18(%rax)
cmpl $0x1, %ecx
jg 0x337ae
addq $-0x18, %rax
movq %rax, %rsi
movq $-0x7, %rdx
callq 0x21266
leaq 0x6c2ff(%rip), %rsi # 0x9fab4
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x224d1
jmp 0x337dd
leaq 0x6df03(%rip), %rsi # 0xa16ce
xorl %r15d, %r15d
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x224d1
xorl %eax, %eax
orq %rax, %r15
movq %r15, %rax
movq %r14, %rdx
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| js_compile_regexp:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 60h
mov r12, rdx
mov r13, rsi
mov rbx, rdi
xor r15d, r15d
cmp r8d, 3
jnz short loc_335B0
loc_33581:
mov eax, r15d
not eax
test eax, 110h
jnz loc_336AE
lea rsi, aInvalidRegular; "invalid regular expression flags"
xor r15d, r15d
mov rdi, rbx
xor eax, eax
call JS_ThrowSyntaxError
mov r14d, 6
jmp loc_337DD
loc_335B0:
lea rsi, [rsp+88h+var_78]
xor r15d, r15d
mov rdi, rbx
mov rdx, rcx
mov rcx, r8
xor r8d, r8d
call JS_ToCStringLen2
mov r14d, 6
test rax, rax
jz loc_337DD
mov rcx, [rsp+88h+var_78]
test rcx, rcx
jz loc_33680
xor r15d, r15d
lea rdx, jpt_3361D
lea rsi, jpt_3362F
xor edi, edi
loc_335F9:
movzx r8d, byte ptr [rax+rdi]
lea r9d, [r8-64h]; switch 10 cases
cmp r9d, 9
jbe short loc_33628
def_3362F:
add r8d, 0FFFFFF8Dh; jumptable 000000000003362F default case
cmp r8d, 6
ja def_3361D; jumptable 000000000003361D default case, cases 116,119,120
movsxd r8, ds:(jpt_3361D - 9C8E0h)[rdx+r8*4]
add r8, rdx
jmp r8; switch jump
loc_33620:
mov r8d, 8; jumptable 000000000003361D case 115
jmp short loc_33668
loc_33628:
movsxd r8, ds:(jpt_3362F - 9C8B8h)[rsi+r9*4]
add r8, rsi
jmp r8; switch jump
loc_33632:
mov r8d, 40h ; '@'; jumptable 000000000003362F case 100
jmp short loc_33668
loc_3363A:
mov r8d, 2; jumptable 000000000003362F case 105
jmp short loc_33668
loc_33642:
mov r8d, 1; jumptable 000000000003362F case 103
jmp short loc_33668
loc_3364A:
mov r8d, 4; jumptable 000000000003362F case 109
jmp short loc_33668
loc_33652:
mov r8d, 100h; jumptable 000000000003361D case 118
jmp short loc_33668
loc_3365A:
mov r8d, 10h; jumptable 000000000003361D case 117
jmp short loc_33668
loc_33662:
mov r8d, 20h ; ' '; jumptable 000000000003361D case 121
loc_33668:
test r8d, r15d
jnz def_3361D; jumptable 000000000003361D default case, cases 116,119,120
or r15d, r8d
inc rdi
cmp rcx, rdi
jnz loc_335F9
loc_33680:
mov rdi, [rbx+18h]
mov ecx, [rax-18h]
lea edx, [rcx-1]
mov [rax-18h], edx
cmp ecx, 1
jg loc_33581
add rax, 0FFFFFFFFFFFFFFE8h
mov rsi, rax
mov rdx, 0FFFFFFFFFFFFFFF9h
call js_free_value_rt
jmp loc_33581
loc_336AE:
xor r8d, r8d
test r15b, 10h
setz r8b
lea rsi, [rsp+88h+var_78]
mov rdi, rbx
mov rdx, r13
mov rcx, r12
call JS_ToCStringLen2
mov r14d, 6
test rax, rax
jz loc_33784
mov r12, rax
mov r8, [rsp+88h+var_78]
mov [rsp+88h+var_88], rbx
lea rdi, [rsp+88h+var_6C]
lea rsi, [rsp+88h+var_68]
mov edx, 40h ; '@'
mov rcx, rax
mov r9d, r15d
call lre_compile
mov r15, rax
mov rdi, [rbx+18h]
mov eax, [r12-18h]
lea ecx, [rax-1]
mov [r12-18h], ecx
cmp eax, 1
jg short loc_3372D
add r12, 0FFFFFFFFFFFFFFE8h
mov rsi, r12
mov rdx, 0FFFFFFFFFFFFFFF9h
call js_free_value_rt
loc_3372D:
test r15, r15
jz loc_337C4
mov edx, [rsp+88h+var_6C]
mov rdi, rbx
mov rsi, r15
call js_new_string8_len
mov r12, rax
mov r14, rdx
mov rbx, [rbx+18h]
dec qword ptr [rbx+28h]
mov rdi, r15
call qword ptr [rbx+20h]
mov rcx, [rbx+30h]
mov rdi, [rbx+40h]
sub rcx, rax
add rcx, 0FFFFFFFFFFFFFFF8h
mov [rbx+30h], rcx
mov rsi, r15
call qword ptr [rbx+10h]
mov rax, 0FFFFFFFF00000000h
and rax, r12
mov r15d, r12d
jmp short loc_337DF
loc_33784:
xor r15d, r15d
jmp short loc_337DD
def_3361D:
mov rdi, [rbx+18h]; jumptable 000000000003361D default case, cases 116,119,120
mov ecx, [rax-18h]
lea edx, [rcx-1]
mov [rax-18h], edx
cmp ecx, 1
jg short loc_337AE
add rax, 0FFFFFFFFFFFFFFE8h
mov rsi, rax
mov rdx, 0FFFFFFFFFFFFFFF9h
call js_free_value_rt
loc_337AE:
lea rsi, aInvalidRegular; "invalid regular expression flags"
xor r15d, r15d
mov rdi, rbx
xor eax, eax
call JS_ThrowSyntaxError
jmp short loc_337DD
loc_337C4:
lea rsi, aUnsupportedKey+15h; "%s"
xor r15d, r15d
lea rdx, [rsp+88h+var_68]
mov rdi, rbx
xor eax, eax
call JS_ThrowSyntaxError
loc_337DD:
xor eax, eax
loc_337DF:
or r15, rax
mov rax, r15
mov rdx, r14
add rsp, 60h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
| unsigned long long js_compile_regexp(
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 v14; // r12
long long v16; // r15
long long v17; // rax
long long v18; // rdi
long long v19; // rdi
long long v20; // rax
long long v21; // r12
long long v22; // r8
long long v23; // r9
long long v24; // r15
__m128 v25; // xmm4
__m128 v26; // xmm5
long long v27; // rdi
int v28; // eax
long long v29; // rcx
long long v30; // r12
long long v31; // rbx
long long v32; // rax
long long v33; // rdi
unsigned long long v34; // rax
long long v35; // rdi
char v37; // [rsp+0h] [rbp-88h]
char v38; // [rsp+0h] [rbp-88h]
long long v39; // [rsp+10h] [rbp-78h] BYREF
unsigned int v40; // [rsp+1Ch] [rbp-6Ch] BYREF
_BYTE v41[104]; // [rsp+20h] [rbp-68h] BYREF
v14 = a3;
LODWORD(v16) = 0;
if ( (_DWORD)a5 != 3 )
{
v16 = 0LL;
v17 = JS_ToCStringLen2(a1, &v39, a4, a5, 0);
if ( !v17 )
goto LABEL_32;
if ( v39 )
{
LODWORD(v16) = 0;
v18 = 0LL;
while ( 1 )
{
a5 = *(unsigned __int8 *)(v17 + v18);
a6 = (unsigned int)(a5 - 100);
switch ( *(_BYTE *)(v17 + v18) )
{
case 'd':
a5 = 64LL;
goto LABEL_18;
case 'e':
case 'f':
case 'h':
case 'j':
case 'k':
case 'l':
goto LABEL_28;
case 'g':
a5 = 1LL;
goto LABEL_18;
case 'i':
a5 = 2LL;
goto LABEL_18;
case 'm':
a5 = 4LL;
LABEL_18:
if ( ((unsigned int)v16 & (unsigned int)a5) != 0 )
{
LABEL_28:
v35 = *(_QWORD *)(a1 + 24);
a4 = *(unsigned int *)(v17 - 24);
a3 = (unsigned int)(a4 - 1);
*(_DWORD *)(v17 - 24) = a3;
if ( (int)a4 <= 1 )
js_free_value_rt(v35, (_QWORD *)(v17 - 24), -7);
LABEL_3:
v16 = 0LL;
JS_ThrowSyntaxError(
a1,
(long long)"invalid regular expression flags",
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v37);
LABEL_32:
v34 = 0LL;
return v34 | v16;
}
LODWORD(v16) = a5 | v16;
if ( v39 == ++v18 )
goto LABEL_20;
break;
default:
a5 = (unsigned int)(a5 - 115);
switch ( (int)a5 )
{
case 0:
a5 = 8LL;
goto LABEL_18;
case 2:
a5 = 16LL;
goto LABEL_18;
case 3:
a5 = 256LL;
goto LABEL_18;
case 6:
a5 = 32LL;
goto LABEL_18;
default:
goto LABEL_28;
}
}
}
}
LABEL_20:
v19 = *(_QWORD *)(a1 + 24);
a4 = *(unsigned int *)(v17 - 24);
a3 = (unsigned int)(a4 - 1);
*(_DWORD *)(v17 - 24) = a3;
if ( (int)a4 <= 1 )
js_free_value_rt(v19, (_QWORD *)(v17 - 24), -7);
}
if ( (~(_WORD)v16 & 0x110) == 0 )
goto LABEL_3;
v20 = JS_ToCStringLen2(a1, &v39, a2, v14, (v16 & 0x10) == 0);
if ( !v20 )
{
v16 = 0LL;
goto LABEL_32;
}
v21 = v20;
v24 = lre_compile((unsigned int)&v40, (unsigned int)v41, 64, v20, v39, v16, a1);
v27 = *(_QWORD *)(a1 + 24);
v28 = *(_DWORD *)(v21 - 24);
v29 = (unsigned int)(v28 - 1);
*(_DWORD *)(v21 - 24) = v29;
if ( v28 <= 1 )
js_free_value_rt(v27, (_QWORD *)(v21 - 24), -7);
if ( !v24 )
{
v16 = 0LL;
JS_ThrowSyntaxError(a1, (long long)"%s", (long long)v41, v29, v22, v23, a7, a8, a9, a10, v25, v26, a13, a14, v38);
goto LABEL_32;
}
v30 = js_new_string8_len(a1, v24, v40);
v31 = *(_QWORD *)(a1 + 24);
--*(_QWORD *)(v31 + 40);
v32 = (*(long long ( **)(long long))(v31 + 32))(v24);
v33 = *(_QWORD *)(v31 + 64);
*(_QWORD *)(v31 + 48) = *(_QWORD *)(v31 + 48) - v32 - 8;
(*(void ( **)(long long, long long))(v31 + 16))(v33, v24);
v34 = v30 & 0xFFFFFFFF00000000LL;
v16 = (unsigned int)v30;
return v34 | v16;
}
| |||
53,901 | js_compile_regexp | bluesky950520[P]quickjs/quickjs.c | static JSValue js_compile_regexp(JSContext *ctx, JSValue pattern,
JSValue flags)
{
const char *str;
int re_flags, mask;
uint8_t *re_bytecode_buf;
size_t i, len;
int re_bytecode_len;
JSValue ret;
char error_msg[64];
re_flags = 0;
if (!JS_IsUndefined(flags)) {
str = JS_ToCStringLen(ctx, &len, flags);
if (!str)
return JS_EXCEPTION;
/* XXX: re_flags = LRE_FLAG_OCTAL unless strict mode? */
for (i = 0; i < len; i++) {
switch(str[i]) {
case 'd':
mask = LRE_FLAG_INDICES;
break;
case 'g':
mask = LRE_FLAG_GLOBAL;
break;
case 'i':
mask = LRE_FLAG_IGNORECASE;
break;
case 'm':
mask = LRE_FLAG_MULTILINE;
break;
case 's':
mask = LRE_FLAG_DOTALL;
break;
case 'u':
mask = LRE_FLAG_UNICODE;
break;
case 'v':
mask = LRE_FLAG_UNICODE_SETS;
break;
case 'y':
mask = LRE_FLAG_STICKY;
break;
default:
goto bad_flags;
}
if ((re_flags & mask) != 0) {
bad_flags:
JS_FreeCString(ctx, str);
return JS_ThrowSyntaxError(ctx, "invalid regular expression flags");
}
re_flags |= mask;
}
JS_FreeCString(ctx, str);
}
if (re_flags & LRE_FLAG_UNICODE)
if (re_flags & LRE_FLAG_UNICODE_SETS)
return JS_ThrowSyntaxError(ctx, "invalid regular expression flags");
str = JS_ToCStringLen2(ctx, &len, pattern, !(re_flags & LRE_FLAG_UNICODE));
if (!str)
return JS_EXCEPTION;
re_bytecode_buf = lre_compile(&re_bytecode_len, error_msg,
sizeof(error_msg), str, len, re_flags, ctx);
JS_FreeCString(ctx, str);
if (!re_bytecode_buf) {
JS_ThrowSyntaxError(ctx, "%s", error_msg);
return JS_EXCEPTION;
}
ret = js_new_string8_len(ctx, (char *)re_bytecode_buf, re_bytecode_len);
js_free(ctx, re_bytecode_buf);
return ret;
} | O2 | c | js_compile_regexp:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
xorl %r14d, %r14d
pushq $0x6
popq %rbx
cmpl $0x3, %r8d
jne 0x2cc7b
xorl %r8d, %r8d
testb $0x10, %r14b
sete %r8b
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
movq %r13, %rdx
movq %r12, %rcx
callq 0x1adbb
testq %rax, %rax
je 0x2cd17
movq %rax, %r12
movq 0x10(%rsp), %r8
movq %r15, (%rsp)
leaq 0x1c(%rsp), %rdi
leaq 0x20(%rsp), %rsi
pushq $0x40
popq %rdx
movq %rax, %rcx
movl %r14d, %r9d
callq 0x7bb8d
movq %rax, %r14
movq %r15, %rdi
movq %r12, %rsi
callq 0x1b057
testq %r14, %r14
je 0x2cd59
movl 0x1c(%rsp), %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1a4e8
movq %rax, %r12
movq %rdx, %rbx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1726e
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
andq %r12, %rax
movl %r12d, %r14d
jmp 0x2cd74
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
movq %rcx, %rdx
movq %r8, %rcx
callq 0x36bee
xorl %r14d, %r14d
testq %rax, %rax
je 0x2cd72
movq 0x10(%rsp), %rcx
pushq $0x40
popq %r9
leaq 0x56bd6(%rip), %rsi # 0x83880
leaq 0x56ba7(%rip), %r10 # 0x83858
pushq $0x2
popq %rbp
pushq $0x4
popq %rdi
xorl %r8d, %r8d
cmpq %r8, %rcx
je 0x2cd29
movzbl (%rax,%r8), %edx
leal -0x64(%rdx), %r11d
cmpl $0x9, %r11d
jbe 0x2cce3
addl $-0x73, %edx
cmpl $0x6, %edx
ja 0x2cd1c
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
pushq $0x8
jmp 0x2cd09
movslq (%r10,%r11,4), %r11
addq %r10, %r11
movl %r9d, %edx
jmpq *%r11
pushq $0x1
jmp 0x2cd09
movl %ebp, %edx
jmp 0x2cd0a
movl %edi, %edx
jmp 0x2cd0a
movl $0x100, %edx # imm = 0x100
jmp 0x2cd0a
pushq $0x10
jmp 0x2cd09
pushq $0x20
popq %rdx
testl %r14d, %edx
jne 0x2cd1c
orl %edx, %r14d
incq %r8
jmp 0x2ccba
xorl %r14d, %r14d
jmp 0x2cd72
movq %r15, %rdi
movq %rax, %rsi
callq 0x1b057
jmp 0x2cd43
movq %r15, %rdi
movq %rax, %rsi
callq 0x1b057
movl %r14d, %eax
notl %eax
testw $0x110, %ax # imm = 0x110
jne 0x2cbe4
leaq 0x59cba(%rip), %rsi # 0x86a04
xorl %r14d, %r14d
movq %r15, %rdi
xorl %eax, %eax
callq 0x1c5bb
jmp 0x2cd72
leaq 0x5b8a8(%rip), %rsi # 0x88608
xorl %r14d, %r14d
leaq 0x20(%rsp), %rdx
movq %r15, %rdi
xorl %eax, %eax
callq 0x1c5bb
xorl %eax, %eax
orq %rax, %r14
movq %r14, %rax
movq %rbx, %rdx
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| js_compile_regexp:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov r12, rdx
mov r13, rsi
mov r15, rdi
xor r14d, r14d
push 6
pop rbx
cmp r8d, 3
jnz loc_2CC7B
loc_2CBE4:
xor r8d, r8d
test r14b, 10h
setz r8b
lea rsi, [rsp+98h+var_88]
mov rdi, r15
mov rdx, r13
mov rcx, r12
call JS_ToCStringLen2
test rax, rax
jz loc_2CD17
mov r12, rax
mov r8, [rsp+98h+var_88]
mov [rsp+98h+var_98], r15
lea rdi, [rsp+98h+var_7C]
lea rsi, [rsp+98h+var_78]
push 40h ; '@'
pop rdx
mov rcx, rax
mov r9d, r14d
call lre_compile
mov r14, rax
mov rdi, r15
mov rsi, r12
call JS_FreeCString
test r14, r14
jz loc_2CD59
mov edx, [rsp+98h+var_7C]
mov rdi, r15
mov rsi, r14
call js_new_string8_len
mov r12, rax
mov rbx, rdx
mov rdi, r15
mov rsi, r14
call js_free
mov rax, 0FFFFFFFF00000000h
and rax, r12
mov r14d, r12d
jmp loc_2CD74
loc_2CC7B:
lea rsi, [rsp+98h+var_88]
mov rdi, r15
mov rdx, rcx
mov rcx, r8
call JS_ToCStringLen_0
xor r14d, r14d
test rax, rax
jz loc_2CD72
mov rcx, [rsp+98h+var_88]
push 40h ; '@'
pop r9
lea rsi, jpt_2CCDD
lea r10, jpt_2CCED
push 2
pop rbp
push 4
pop rdi
xor r8d, r8d
loc_2CCBA:
cmp rcx, r8
jz short loc_2CD29
movzx edx, byte ptr [rax+r8]
lea r11d, [rdx-64h]; switch 10 cases
cmp r11d, 9
jbe short loc_2CCE3
def_2CCED:
add edx, 0FFFFFF8Dh; jumptable 000000000002CCED default case
cmp edx, 6
ja short def_2CCDD; jumptable 000000000002CCDD default case, cases 116,119,120
movsxd rdx, ds:(jpt_2CCDD - 83880h)[rsi+rdx*4]
add rdx, rsi
jmp rdx; switch jump
loc_2CCDF:
push 8; jumptable 000000000002CCDD case 115
jmp short loc_2CD09
loc_2CCE3:
movsxd r11, ds:(jpt_2CCED - 83858h)[r10+r11*4]
add r11, r10
mov edx, r9d
jmp r11; switch jump
loc_2CCF0:
push 1; jumptable 000000000002CCED case 103
jmp short loc_2CD09
loc_2CCF4:
mov edx, ebp; jumptable 000000000002CCED case 105
jmp short loc_2CD0A; jumptable 000000000002CCED case 100
loc_2CCF8:
mov edx, edi; jumptable 000000000002CCED case 109
jmp short loc_2CD0A; jumptable 000000000002CCED case 100
loc_2CCFC:
mov edx, 100h; jumptable 000000000002CCDD case 118
jmp short loc_2CD0A; jumptable 000000000002CCED case 100
loc_2CD03:
push 10h; jumptable 000000000002CCDD case 117
jmp short loc_2CD09
loc_2CD07:
push 20h ; ' '; jumptable 000000000002CCDD case 121
loc_2CD09:
pop rdx
loc_2CD0A:
test edx, r14d; jumptable 000000000002CCED case 100
jnz short def_2CCDD; jumptable 000000000002CCDD default case, cases 116,119,120
or r14d, edx
inc r8
jmp short loc_2CCBA
loc_2CD17:
xor r14d, r14d
jmp short loc_2CD72
def_2CCDD:
mov rdi, r15; jumptable 000000000002CCDD default case, cases 116,119,120
mov rsi, rax
call JS_FreeCString
jmp short loc_2CD43
loc_2CD29:
mov rdi, r15
mov rsi, rax
call JS_FreeCString
mov eax, r14d
not eax
test ax, 110h
jnz loc_2CBE4
loc_2CD43:
lea rsi, aInvalidRegular; "invalid regular expression flags"
xor r14d, r14d
mov rdi, r15
xor eax, eax
call JS_ThrowSyntaxError
jmp short loc_2CD72
loc_2CD59:
lea rsi, aUnsupportedKey+15h; "%s"
xor r14d, r14d
lea rdx, [rsp+98h+var_78]
mov rdi, r15
xor eax, eax
call JS_ThrowSyntaxError
loc_2CD72:
xor eax, eax
loc_2CD74:
or r14, rax
mov rax, r14
mov rdx, rbx
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| unsigned long long js_compile_regexp(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
double a10,
double a11,
__m128 a12,
__m128 a13)
{
long long v14; // r14
long long v15; // rax
long long v16; // r12
long long v17; // r14
long long v18; // rcx
long long v19; // r8
long long v20; // r9
__m128 v21; // xmm4
__m128 v22; // xmm5
long long v23; // r12
unsigned long long v24; // rax
long long v25; // rax
long long v26; // r8
int v27; // edx
long long v28; // rdx
long long v29; // rcx
long long v30; // r8
long long v31; // r9
__m128 v32; // xmm4
__m128 v33; // xmm5
char v35; // [rsp+0h] [rbp-98h]
char v36; // [rsp+0h] [rbp-98h]
long long v37; // [rsp+10h] [rbp-88h] BYREF
unsigned int v38; // [rsp+1Ch] [rbp-7Ch] BYREF
_BYTE v39[120]; // [rsp+20h] [rbp-78h] BYREF
LODWORD(v14) = 0;
if ( (_DWORD)a5 != 3 )
{
v25 = JS_ToCStringLen_0(a1, &v37, a4, a5);
v14 = 0LL;
if ( !v25 )
{
LABEL_19:
v24 = 0LL;
return v24 | v14;
}
v26 = 0LL;
while ( 2 )
{
if ( v37 != v26 )
{
v27 = 64;
switch ( *(_BYTE *)(v25 + v26) )
{
case 'd':
goto LABEL_12;
case 'g':
v27 = 1;
goto LABEL_12;
case 'i':
v27 = 2;
goto LABEL_12;
case 'm':
v27 = 4;
LABEL_12:
if ( ((unsigned int)v14 & v27) != 0 )
goto LABEL_15;
LODWORD(v14) = v27 | v14;
++v26;
continue;
default:
LABEL_15:
JS_FreeCString(a1, v25);
goto LABEL_17;
}
}
break;
}
JS_FreeCString(a1, v25);
if ( (~(_WORD)v14 & 0x110) == 0 )
{
LABEL_17:
v14 = 0LL;
JS_ThrowSyntaxError(
a1,
(long long)"invalid regular expression flags",
v28,
v29,
v30,
v31,
a6,
a7,
a8,
a9,
v32,
v33,
a12,
a13,
v35);
goto LABEL_19;
}
}
v15 = JS_ToCStringLen2(a1, &v37, a2, a3, (v14 & 0x10) == 0);
if ( !v15 )
{
v14 = 0LL;
goto LABEL_19;
}
v16 = v15;
v17 = lre_compile((unsigned int)&v38, (unsigned int)v39, 64, v15, v37, v14, a1);
JS_FreeCString(a1, v16);
if ( !v17 )
{
v14 = 0LL;
JS_ThrowSyntaxError(a1, (long long)"%s", (long long)v39, v18, v19, v20, a6, a7, a8, a9, v21, v22, a12, a13, v36);
goto LABEL_19;
}
v23 = js_new_string8_len(a1, v17, v38);
js_free(a1, v17);
v24 = v23 & 0xFFFFFFFF00000000LL;
v14 = (unsigned int)v23;
return v24 | v14;
}
| js_compile_regexp:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R12,RDX
MOV R13,RSI
MOV R15,RDI
XOR R14D,R14D
PUSH 0x6
POP RBX
CMP R8D,0x3
JNZ 0x0012cc7b
LAB_0012cbe4:
XOR R8D,R8D
TEST R14B,0x10
SETZ R8B
LEA RSI,[RSP + 0x10]
MOV RDI,R15
MOV RDX,R13
MOV RCX,R12
CALL 0x0011adbb
TEST RAX,RAX
JZ 0x0012cd17
MOV R12,RAX
MOV R8,qword ptr [RSP + 0x10]
MOV qword ptr [RSP],R15
LEA RDI,[RSP + 0x1c]
LEA RSI,[RSP + 0x20]
PUSH 0x40
POP RDX
MOV RCX,RAX
MOV R9D,R14D
CALL 0x0017bb8d
MOV R14,RAX
MOV RDI,R15
MOV RSI,R12
CALL 0x0011b057
TEST R14,R14
JZ 0x0012cd59
MOV EDX,dword ptr [RSP + 0x1c]
MOV RDI,R15
MOV RSI,R14
CALL 0x0011a4e8
MOV R12,RAX
MOV RBX,RDX
MOV RDI,R15
MOV RSI,R14
CALL 0x0011726e
MOV RAX,-0x100000000
AND RAX,R12
MOV R14D,R12D
JMP 0x0012cd74
LAB_0012cc7b:
LEA RSI,[RSP + 0x10]
MOV RDI,R15
MOV RDX,RCX
MOV RCX,R8
CALL 0x00136bee
XOR R14D,R14D
TEST RAX,RAX
JZ 0x0012cd72
MOV RCX,qword ptr [RSP + 0x10]
PUSH 0x40
POP R9
LEA RSI,[0x183880]
LEA R10,[0x183858]
PUSH 0x2
POP RBP
PUSH 0x4
POP RDI
XOR R8D,R8D
LAB_0012ccba:
CMP RCX,R8
JZ 0x0012cd29
MOVZX EDX,byte ptr [RAX + R8*0x1]
LEA R11D,[RDX + -0x64]
CMP R11D,0x9
JBE 0x0012cce3
default:
ADD EDX,-0x73
CMP EDX,0x6
JA 0x0012cd1c
MOVSXD RDX,dword ptr [RSI + RDX*0x4]
ADD RDX,RSI
switchD:
JMP RDX
caseD_73:
PUSH 0x8
JMP 0x0012cd09
LAB_0012cce3:
MOVSXD R11,dword ptr [R10 + R11*0x4]
ADD R11,R10
MOV EDX,R9D
switchD:
JMP R11
caseD_67:
PUSH 0x1
JMP 0x0012cd09
caseD_69:
MOV EDX,EBP
JMP 0x0012cd0a
caseD_6d:
MOV EDX,EDI
JMP 0x0012cd0a
caseD_76:
MOV EDX,0x100
JMP 0x0012cd0a
caseD_75:
PUSH 0x10
JMP 0x0012cd09
caseD_79:
PUSH 0x20
LAB_0012cd09:
POP RDX
caseD_64:
TEST EDX,R14D
JNZ 0x0012cd1c
OR R14D,EDX
INC R8
JMP 0x0012ccba
LAB_0012cd17:
XOR R14D,R14D
JMP 0x0012cd72
caseD_74:
MOV RDI,R15
MOV RSI,RAX
CALL 0x0011b057
JMP 0x0012cd43
LAB_0012cd29:
MOV RDI,R15
MOV RSI,RAX
CALL 0x0011b057
MOV EAX,R14D
NOT EAX
TEST AX,0x110
JNZ 0x0012cbe4
LAB_0012cd43:
LEA RSI,[0x186a04]
XOR R14D,R14D
MOV RDI,R15
XOR EAX,EAX
CALL 0x0011c5bb
JMP 0x0012cd72
LAB_0012cd59:
LEA RSI,[0x188608]
XOR R14D,R14D
LEA RDX,[RSP + 0x20]
MOV RDI,R15
XOR EAX,EAX
CALL 0x0011c5bb
LAB_0012cd72:
XOR EAX,EAX
LAB_0012cd74:
OR R14,RAX
MOV RAX,R14
MOV RDX,RBX
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int1 [16]
js_compile_regexp(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5)
{
long lVar1;
long lVar2;
ulong uVar3;
uint uVar4;
int8 uVar5;
uint uVar6;
ulong uVar7;
int1 auVar8 [16];
long local_88;
int4 local_7c;
int1 local_78 [72];
uVar6 = 0;
uVar5 = 6;
if ((int)param_5 == 3) {
LAB_0012cbe4:
lVar1 = JS_ToCStringLen2(param_1,&local_88,param_2,param_3,(uVar6 & 0x10) == 0);
if (lVar1 != 0) {
lVar2 = lre_compile(&local_7c,local_78,0x40,lVar1,local_88,uVar6,param_1);
JS_FreeCString(param_1,lVar1);
if (lVar2 != 0) {
auVar8 = js_new_string8_len(param_1,lVar2,local_7c);
uVar5 = auVar8._8_8_;
js_free(param_1,lVar2);
uVar3 = auVar8._0_8_ & 0xffffffff00000000;
uVar7 = auVar8._0_8_ & 0xffffffff;
goto LAB_0012cd74;
}
JS_ThrowSyntaxError(param_1,"%s",local_78);
}
}
else {
lVar1 = JS_ToCStringLen(param_1,&local_88,param_4,param_5);
uVar6 = 0;
if (lVar1 != 0) {
for (lVar2 = 0; local_88 != lVar2; lVar2 = lVar2 + 1) {
uVar4 = 0x40;
switch(*(int1 *)(lVar1 + lVar2)) {
case 100:
break;
case 0x65:
case 0x66:
case 0x68:
case 0x6a:
case 0x6b:
case 0x6c:
goto switchD_0012ccdd_caseD_74;
case 0x67:
uVar4 = 1;
break;
case 0x69:
uVar4 = 2;
break;
case 0x6d:
uVar4 = 4;
break;
default:
switch(*(int1 *)(lVar1 + lVar2)) {
case 0x73:
uVar4 = 8;
break;
default:
goto switchD_0012ccdd_caseD_74;
case 0x75:
uVar4 = 0x10;
break;
case 0x76:
uVar4 = 0x100;
break;
case 0x79:
uVar4 = 0x20;
}
}
if ((uVar4 & uVar6) != 0) {
switchD_0012ccdd_caseD_74:
JS_FreeCString(param_1,lVar1);
goto LAB_0012cd43;
}
uVar6 = uVar6 | uVar4;
}
JS_FreeCString(param_1,lVar1);
if ((~uVar6 & 0x110) != 0) goto LAB_0012cbe4;
LAB_0012cd43:
JS_ThrowSyntaxError(param_1,"invalid regular expression flags");
}
}
uVar7 = 0;
uVar3 = 0;
LAB_0012cd74:
auVar8._8_8_ = uVar5;
auVar8._0_8_ = uVar7 | uVar3;
return auVar8;
}
| |
53,902 | maria_page_filler_set_bitmap | eloqsql/storage/maria/ma_pagecrc.c | my_bool maria_page_filler_set_bitmap(PAGECACHE_IO_HOOK_ARGS *args)
{
uchar *page= args->page;
MARIA_SHARE *share= (MARIA_SHARE *)args->data;
DBUG_ENTER("maria_page_filler_set_bitmap");
int4store_aligned(page + share->block_size - CRC_SIZE,
MARIA_NO_CRC_BITMAP_PAGE);
DBUG_RETURN(0);
} | O0 | c | maria_page_filler_set_bitmap:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movl 0x7bc(%rcx), %ecx
addq %rcx, %rax
addq $-0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0xfffffffe, (%rax) # imm = 0xFFFFFFFE
jmp 0x3f9f4
jmp 0x3f9f6
xorl %eax, %eax
popq %rbp
retq
nopw (%rax,%rax)
| maria_page_filler_set_bitmap:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_10], rax
mov rax, [rbp+var_8]
mov rax, [rax+10h]
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
mov rcx, [rbp+var_18]
mov ecx, [rcx+7BCh]
add rax, rcx
add rax, 0FFFFFFFFFFFFFFFCh
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov dword ptr [rax], 0FFFFFFFEh
jmp short $+2
loc_3F9F4:
jmp short $+2
loc_3F9F6:
xor eax, eax
pop rbp
retn
| long long maria_page_filler_set_bitmap(_QWORD *a1)
{
*(_DWORD *)(*(unsigned int *)(a1[2] + 1980LL) + *a1 - 4LL) = -2;
return 0LL;
}
| maria_page_filler_set_bitmap:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RCX + 0x7bc]
ADD RAX,RCX
ADD RAX,-0x4
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],0xfffffffe
JMP 0x0013f9f4
LAB_0013f9f4:
JMP 0x0013f9f6
LAB_0013f9f6:
XOR EAX,EAX
POP RBP
RET
|
int8 maria_page_filler_set_bitmap(long *param_1)
{
*(int4 *)(*param_1 + (ulong)*(uint *)(param_1[2] + 0x7bc) + -4) = 0xfffffffe;
return 0;
}
| |
53,903 | ma_init | eloqsql/libmariadb/libmariadb/ma_init.c | void ma_init(void)
{
if (ma_init_done)
return;
ma_init_done=1;
{
#ifdef _WIN32
my_win_init();
#endif
return;
}
} | O0 | c | ma_init:
pushq %rbp
movq %rsp, %rbp
leaq 0x3abb0e(%rip), %rax # 0x402ac9
cmpb $0x0, (%rax)
je 0x56fc2
jmp 0x56fcc
leaq 0x3abb00(%rip), %rax # 0x402ac9
movb $0x1, (%rax)
popq %rbp
retq
nop
| ma_init:
push rbp
mov rbp, rsp
lea rax, ma_init_done
cmp byte ptr [rax], 0
jz short loc_56FC2
jmp short loc_56FCC
loc_56FC2:
lea rax, ma_init_done
mov byte ptr [rax], 1
loc_56FCC:
pop rbp
retn
| void *ma_init()
{
void *result; // rax
result = &ma_init_done;
if ( !ma_init_done )
{
result = &ma_init_done;
ma_init_done = 1;
}
return result;
}
| ma_init:
PUSH RBP
MOV RBP,RSP
LEA RAX,[0x502ac9]
CMP byte ptr [RAX],0x0
JZ 0x00156fc2
JMP 0x00156fcc
LAB_00156fc2:
LEA RAX,[0x502ac9]
MOV byte ptr [RAX],0x1
LAB_00156fcc:
POP RBP
RET
|
void ma_init(void)
{
if (ma_init_done == '\0') {
ma_init_done = '\x01';
}
return;
}
| |
53,904 | my_open_parent_dir_nosymlinks | eloqsql/mysys/my_symlink.c | const char *my_open_parent_dir_nosymlinks(const char *pathname, int *pdfd)
{
char buf[FN_REFLEN + 1];
char *s= buf, *e= buf+1, *end= strnmov(buf, pathname, sizeof(buf));
int fd, dfd= -1;
if (*end)
{
errno= ENAMETOOLONG;
return NULL;
}
if (*s != '/') /* not an absolute path */
{
errno= ENOENT;
return NULL;
}
for (;;)
{
if (*e == '/') /* '//' in the path */
{
errno= ENOENT;
goto err;
}
while (*e && *e != '/')
e++;
*e= 0;
if (!memcmp(s, ".", 2) || !memcmp(s, "..", 3))
{
errno= ENOENT;
goto err;
}
if (++e >= end)
{
*pdfd= dfd;
return pathname + (s - buf);
}
fd = openat(dfd, s, O_NOFOLLOW | O_PATH | O_CLOEXEC);
if (fd < 0)
goto err;
if (dfd >= 0)
close(dfd);
dfd= fd;
s= e;
}
err:
if (dfd >= 0)
close(dfd);
return NULL;
} | O0 | c | my_open_parent_dir_nosymlinks:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp # imm = 0x260
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x220(%rbp)
movq %rsi, -0x228(%rbp)
leaq -0x210(%rbp), %rax
movq %rax, -0x230(%rbp)
leaq -0x210(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x238(%rbp)
leaq -0x210(%rbp), %rdi
movq -0x220(%rbp), %rsi
movl $0x201, %edx # imm = 0x201
callq 0xd5800
movq %rax, -0x240(%rbp)
movl $0xffffffff, -0x248(%rbp) # imm = 0xFFFFFFFF
movq -0x240(%rbp), %rax
cmpb $0x0, (%rax)
je 0x81516
callq 0x28040
movl $0x24, (%rax)
movq $0x0, -0x218(%rbp)
jmp 0x816ca
movq -0x230(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x81540
callq 0x28040
movl $0x2, (%rax)
movq $0x0, -0x218(%rbp)
jmp 0x816ca
jmp 0x81542
movq -0x238(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x81561
callq 0x28040
movl $0x2, (%rax)
jmp 0x816ab
jmp 0x81563
movq -0x238(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x249(%rbp)
je 0x81590
movq -0x238(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
setne %al
movb %al, -0x249(%rbp)
movb -0x249(%rbp), %al
testb $0x1, %al
jne 0x8159c
jmp 0x815b0
movq -0x238(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x238(%rbp)
jmp 0x81563
movq -0x238(%rbp), %rax
movb $0x0, (%rax)
movq -0x230(%rbp), %rax
movw (%rax), %ax
subw $0x2e, %ax
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x815f0
movq -0x230(%rbp), %rdi
leaq 0x56d95(%rip), %rsi # 0xd8376
movl $0x3, %edx
callq 0x28160
cmpl $0x0, %eax
jne 0x81600
callq 0x28040
movl $0x2, (%rax)
jmp 0x816ab
movq -0x238(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x238(%rbp)
cmpq -0x240(%rbp), %rax
jb 0x8164e
movl -0x248(%rbp), %ecx
movq -0x228(%rbp), %rax
movl %ecx, (%rax)
movq -0x220(%rbp), %rax
movq -0x230(%rbp), %rcx
leaq -0x210(%rbp), %rdx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x218(%rbp)
jmp 0x816ca
movl -0x248(%rbp), %edi
movq -0x230(%rbp), %rsi
movl $0x2a0000, %edx # imm = 0x2A0000
movb $0x0, %al
callq 0x28360
movl %eax, -0x244(%rbp)
cmpl $0x0, -0x244(%rbp)
jge 0x81678
jmp 0x816ab
cmpl $0x0, -0x248(%rbp)
jl 0x8168c
movl -0x248(%rbp), %edi
callq 0x286d0
movl -0x244(%rbp), %eax
movl %eax, -0x248(%rbp)
movq -0x238(%rbp), %rax
movq %rax, -0x230(%rbp)
jmp 0x81542
cmpl $0x0, -0x248(%rbp)
jl 0x816bf
movl -0x248(%rbp), %edi
callq 0x286d0
movq $0x0, -0x218(%rbp)
movq -0x218(%rbp), %rax
movq %rax, -0x258(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x816fa
movq -0x258(%rbp), %rax
addq $0x260, %rsp # imm = 0x260
popq %rbp
retq
callq 0x283b0
nop
| my_open_parent_dir_nosymlinks:
push rbp
mov rbp, rsp
sub rsp, 260h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_220], rdi
mov [rbp+var_228], rsi
lea rax, [rbp+var_210]
mov [rbp+var_230], rax
lea rax, [rbp+var_210]
add rax, 1
mov [rbp+var_238], rax
lea rdi, [rbp+var_210]
mov rsi, [rbp+var_220]
mov edx, 201h
call strnmov
mov [rbp+var_240], rax
mov [rbp+var_248], 0FFFFFFFFh
mov rax, [rbp+var_240]
cmp byte ptr [rax], 0
jz short loc_81516
call ___errno_location
mov dword ptr [rax], 24h ; '$'
mov [rbp+var_218], 0
jmp loc_816CA
loc_81516:
mov rax, [rbp+var_230]
movsx eax, byte ptr [rax]
cmp eax, 2Fh ; '/'
jz short loc_81540
call ___errno_location
mov dword ptr [rax], 2
mov [rbp+var_218], 0
jmp loc_816CA
loc_81540:
jmp short $+2
loc_81542:
mov rax, [rbp+var_238]
movsx eax, byte ptr [rax]
cmp eax, 2Fh ; '/'
jnz short loc_81561
call ___errno_location
mov dword ptr [rax], 2
jmp loc_816AB
loc_81561:
jmp short $+2
loc_81563:
mov rax, [rbp+var_238]
movsx ecx, byte ptr [rax]
xor eax, eax
cmp ecx, 0
mov [rbp+var_249], al
jz short loc_81590
mov rax, [rbp+var_238]
movsx eax, byte ptr [rax]
cmp eax, 2Fh ; '/'
setnz al
mov [rbp+var_249], al
loc_81590:
mov al, [rbp+var_249]
test al, 1
jnz short loc_8159C
jmp short loc_815B0
loc_8159C:
mov rax, [rbp+var_238]
add rax, 1
mov [rbp+var_238], rax
jmp short loc_81563
loc_815B0:
mov rax, [rbp+var_238]
mov byte ptr [rax], 0
mov rax, [rbp+var_230]
mov ax, [rax]
sub ax, 2Eh ; '.'
setnz al
movzx eax, al
cmp eax, 0
jz short loc_815F0
mov rdi, [rbp+var_230]
lea rsi, aTesting+8; ".."
mov edx, 3
call _memcmp
cmp eax, 0
jnz short loc_81600
loc_815F0:
call ___errno_location
mov dword ptr [rax], 2
jmp loc_816AB
loc_81600:
mov rax, [rbp+var_238]
add rax, 1
mov [rbp+var_238], rax
cmp rax, [rbp+var_240]
jb short loc_8164E
mov ecx, [rbp+var_248]
mov rax, [rbp+var_228]
mov [rax], ecx
mov rax, [rbp+var_220]
mov rcx, [rbp+var_230]
lea rdx, [rbp+var_210]
sub rcx, rdx
add rax, rcx
mov [rbp+var_218], rax
jmp short loc_816CA
loc_8164E:
mov edi, [rbp+var_248]
mov rsi, [rbp+var_230]
mov edx, offset unk_2A0000
mov al, 0
call _openat64
mov [rbp+var_244], eax
cmp [rbp+var_244], 0
jge short loc_81678
jmp short loc_816AB
loc_81678:
cmp [rbp+var_248], 0
jl short loc_8168C
mov edi, [rbp+var_248]
call _close
loc_8168C:
mov eax, [rbp+var_244]
mov [rbp+var_248], eax
mov rax, [rbp+var_238]
mov [rbp+var_230], rax
jmp loc_81542
loc_816AB:
cmp [rbp+var_248], 0
jl short loc_816BF
mov edi, [rbp+var_248]
call _close
loc_816BF:
mov [rbp+var_218], 0
loc_816CA:
mov rax, [rbp+var_218]
mov [rbp+var_258], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_816FA
mov rax, [rbp+var_258]
add rsp, 260h
pop rbp
retn
loc_816FA:
call ___stack_chk_fail
| long long my_open_parent_dir_nosymlinks(long long a1, int *a2)
{
long long v2; // rcx
bool v4; // [rsp+17h] [rbp-249h]
int v5; // [rsp+18h] [rbp-248h]
int v6; // [rsp+1Ch] [rbp-244h]
const char *v7; // [rsp+20h] [rbp-240h]
const char *v8; // [rsp+28h] [rbp-238h]
const char *v9; // [rsp+30h] [rbp-230h]
char v11; // [rsp+50h] [rbp-210h] BYREF
_BYTE v12[527]; // [rsp+51h] [rbp-20Fh] BYREF
*(_QWORD *)&v12[519] = __readfsqword(0x28u);
v9 = &v11;
v8 = v12;
v7 = (const char *)strnmov(&v11, a1, 513LL);
v5 = -1;
if ( *v7 )
{
*(_DWORD *)__errno_location() = 36;
return 0LL;
}
else if ( v11 == 47 )
{
while ( *v8 != 47 )
{
while ( 1 )
{
v2 = (unsigned int)*v8;
v4 = 0;
if ( *v8 )
v4 = *v8 != 47;
if ( !v4 )
break;
++v8;
}
*v8 = 0;
if ( *(_WORD *)v9 == 46 || !(unsigned int)strcmp(v9, "..") )
break;
if ( ++v8 >= v7 )
{
*a2 = v5;
return v9 - &v11 + a1;
}
v6 = openat64((unsigned int)v5, v9, &unk_2A0000, v2);
if ( v6 < 0 )
goto LABEL_20;
if ( v5 >= 0 )
close((unsigned int)v5);
v5 = v6;
v9 = v8;
}
*(_DWORD *)__errno_location() = 2;
LABEL_20:
if ( v5 >= 0 )
close((unsigned int)v5);
return 0LL;
}
else
{
*(_DWORD *)__errno_location() = 2;
return 0LL;
}
}
| my_open_parent_dir_nosymlinks:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x260
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x220],RDI
MOV qword ptr [RBP + -0x228],RSI
LEA RAX,[RBP + -0x210]
MOV qword ptr [RBP + -0x230],RAX
LEA RAX,[RBP + -0x210]
ADD RAX,0x1
MOV qword ptr [RBP + -0x238],RAX
LEA RDI,[RBP + -0x210]
MOV RSI,qword ptr [RBP + -0x220]
MOV EDX,0x201
CALL 0x001d5800
MOV qword ptr [RBP + -0x240],RAX
MOV dword ptr [RBP + -0x248],0xffffffff
MOV RAX,qword ptr [RBP + -0x240]
CMP byte ptr [RAX],0x0
JZ 0x00181516
CALL 0x00128040
MOV dword ptr [RAX],0x24
MOV qword ptr [RBP + -0x218],0x0
JMP 0x001816ca
LAB_00181516:
MOV RAX,qword ptr [RBP + -0x230]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2f
JZ 0x00181540
CALL 0x00128040
MOV dword ptr [RAX],0x2
MOV qword ptr [RBP + -0x218],0x0
JMP 0x001816ca
LAB_00181540:
JMP 0x00181542
LAB_00181542:
MOV RAX,qword ptr [RBP + -0x238]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2f
JNZ 0x00181561
CALL 0x00128040
MOV dword ptr [RAX],0x2
JMP 0x001816ab
LAB_00181561:
JMP 0x00181563
LAB_00181563:
MOV RAX,qword ptr [RBP + -0x238]
MOVSX ECX,byte ptr [RAX]
XOR EAX,EAX
CMP ECX,0x0
MOV byte ptr [RBP + -0x249],AL
JZ 0x00181590
MOV RAX,qword ptr [RBP + -0x238]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2f
SETNZ AL
MOV byte ptr [RBP + -0x249],AL
LAB_00181590:
MOV AL,byte ptr [RBP + -0x249]
TEST AL,0x1
JNZ 0x0018159c
JMP 0x001815b0
LAB_0018159c:
MOV RAX,qword ptr [RBP + -0x238]
ADD RAX,0x1
MOV qword ptr [RBP + -0x238],RAX
JMP 0x00181563
LAB_001815b0:
MOV RAX,qword ptr [RBP + -0x238]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x230]
MOV AX,word ptr [RAX]
SUB AX,0x2e
SETNZ AL
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x001815f0
MOV RDI,qword ptr [RBP + -0x230]
LEA RSI,[0x1d8376]
MOV EDX,0x3
CALL 0x00128160
CMP EAX,0x0
JNZ 0x00181600
LAB_001815f0:
CALL 0x00128040
MOV dword ptr [RAX],0x2
JMP 0x001816ab
LAB_00181600:
MOV RAX,qword ptr [RBP + -0x238]
ADD RAX,0x1
MOV qword ptr [RBP + -0x238],RAX
CMP RAX,qword ptr [RBP + -0x240]
JC 0x0018164e
MOV ECX,dword ptr [RBP + -0x248]
MOV RAX,qword ptr [RBP + -0x228]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x220]
MOV RCX,qword ptr [RBP + -0x230]
LEA RDX,[RBP + -0x210]
SUB RCX,RDX
ADD RAX,RCX
MOV qword ptr [RBP + -0x218],RAX
JMP 0x001816ca
LAB_0018164e:
MOV EDI,dword ptr [RBP + -0x248]
MOV RSI,qword ptr [RBP + -0x230]
MOV EDX,0x2a0000
MOV AL,0x0
CALL 0x00128360
MOV dword ptr [RBP + -0x244],EAX
CMP dword ptr [RBP + -0x244],0x0
JGE 0x00181678
JMP 0x001816ab
LAB_00181678:
CMP dword ptr [RBP + -0x248],0x0
JL 0x0018168c
MOV EDI,dword ptr [RBP + -0x248]
CALL 0x001286d0
LAB_0018168c:
MOV EAX,dword ptr [RBP + -0x244]
MOV dword ptr [RBP + -0x248],EAX
MOV RAX,qword ptr [RBP + -0x238]
MOV qword ptr [RBP + -0x230],RAX
JMP 0x00181542
LAB_001816ab:
CMP dword ptr [RBP + -0x248],0x0
JL 0x001816bf
MOV EDI,dword ptr [RBP + -0x248]
CALL 0x001286d0
LAB_001816bf:
MOV qword ptr [RBP + -0x218],0x0
LAB_001816ca:
MOV RAX,qword ptr [RBP + -0x218]
MOV qword ptr [RBP + -0x258],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001816fa
MOV RAX,qword ptr [RBP + -0x258]
ADD RSP,0x260
POP RBP
RET
LAB_001816fa:
CALL 0x001283b0
|
long my_open_parent_dir_nosymlinks(long param_1,int *param_2)
{
int iVar1;
short *psVar2;
int *piVar3;
long in_FS_OFFSET;
bool bVar4;
int local_250;
short *local_240;
short *local_238;
long local_220;
int1 local_218 [520];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_238 = (short *)local_218;
local_240 = (short *)(local_218 + 1);
psVar2 = (short *)strnmov(local_218,param_1,0x201);
local_250 = -1;
if ((char)*psVar2 == '\0') {
iVar1 = local_250;
if (local_218[0] == '/') {
while (local_250 = iVar1, (char)*local_240 != '/') {
while( true ) {
bVar4 = false;
if ((char)*local_240 != '\0') {
bVar4 = (char)*local_240 != '/';
}
if (!bVar4) break;
local_240 = (short *)((long)local_240 + 1);
}
*(char *)local_240 = '\0';
if ((*local_238 == 0x2e) || (iVar1 = memcmp(local_238,"..",3), iVar1 == 0)) {
piVar3 = __errno_location();
*piVar3 = 2;
goto LAB_001816ab;
}
local_240 = (short *)((long)local_240 + 1);
if (psVar2 <= local_240) {
*param_2 = local_250;
local_220 = (long)local_238 + (param_1 - (long)local_218);
goto LAB_001816ca;
}
iVar1 = openat64(local_250,(char *)local_238,0x2a0000);
if (iVar1 < 0) goto LAB_001816ab;
local_238 = local_240;
if (-1 < local_250) {
close(local_250);
}
}
piVar3 = __errno_location();
*piVar3 = 2;
LAB_001816ab:
if (-1 < local_250) {
close(local_250);
}
local_220 = 0;
}
else {
piVar3 = __errno_location();
*piVar3 = 2;
local_220 = 0;
}
}
else {
piVar3 = __errno_location();
*piVar3 = 0x24;
local_220 = 0;
}
LAB_001816ca:
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_220;
}
| |
53,905 | google::protobuf::DescriptorBuilder::ValidateEnumOptions(google::protobuf::EnumDescriptor*, google::protobuf::EnumDescriptorProto const&) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.cc | void DescriptorBuilder::ValidateEnumOptions(EnumDescriptor* enm,
const EnumDescriptorProto& proto) {
VALIDATE_OPTIONS_FROM_ARRAY(enm, value, EnumValue);
if (!enm->options().has_allow_alias() || !enm->options().allow_alias()) {
std::map<int, std::string> used_values;
for (int i = 0; i < enm->value_count(); ++i) {
const EnumValueDescriptor* enum_value = enm->value(i);
if (used_values.find(enum_value->number()) != used_values.end()) {
std::string error =
"\"" + enum_value->full_name() +
"\" uses the same enum value as \"" +
used_values[enum_value->number()] +
"\". If this is intended, set "
"'option allow_alias = true;' to the enum definition.";
if (!enm->options().allow_alias()) {
// Generate error if duplicated enum values are explicitly disallowed.
AddError(enm->full_name(), proto.value(i),
DescriptorPool::ErrorCollector::NUMBER, error);
}
} else {
used_values[enum_value->number()] = enum_value->full_name();
}
}
}
} | O3 | cpp | google::protobuf::DescriptorBuilder::ValidateEnumOptions(google::protobuf::EnumDescriptor*, google::protobuf::EnumDescriptorProto const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdx, 0x70(%rsp)
movq %rsi, %r14
movq %rdi, 0x68(%rsp)
movq 0x20(%rsi), %rax
testb $0x1, 0x28(%rax)
je 0x35c94
cmpb $0x0, 0x48(%rax)
jne 0x35f2e
leaq 0xa0(%rsp), %rbp
movl $0x0, (%rbp)
xorl %eax, %eax
movq %rax, 0x8(%rbp)
movq %rbp, 0x10(%rbp)
movq %rbp, 0x18(%rbp)
movq %rax, 0x20(%rbp)
cmpl $0x0, 0x4(%r14)
jle 0x35f21
xorl %r15d, %r15d
leaq 0x78(%rsp), %r12
movq 0x28(%r14), %rax
movq %r15, %rcx
shlq $0x5, %rcx
leaq (%rax,%rcx), %rbx
movl 0x4(%rax,%rcx), %eax
movq 0xa8(%rsp), %rdi
testq %rdi, %rdi
je 0x35d1d
movq %rbp, %r8
movq %r8, %rcx
movq %rdi, %rdx
movl 0x20(%rdi), %esi
xorl %edi, %edi
cmpl %eax, %esi
setl %dil
movq %rdx, %r8
cmovlq %rcx, %r8
movq 0x10(%rdx,%rdi,8), %rdi
testq %rdi, %rdi
jne 0x35ceb
cmpq %rbp, %r8
je 0x35d1d
cmpl %eax, %esi
cmovlq %rcx, %rdx
cmpl 0x20(%rdx), %eax
jge 0x35d5b
movq 0x8(%rbx), %rbx
movl %eax, 0x8(%rsp)
leaq 0x98(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3f486
addq $0x20, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x138c8
incq %r15
movslq 0x4(%r14), %rax
cmpq %rax, %r15
jl 0x35cc8
jmp 0x35f21
movq 0x8(%rbx), %rdx
addq $0x20, %rdx
movq %r12, %r13
movq %r12, %rdi
leaq 0x8129b(%rip), %rsi # 0xb700b
callq 0x1397f
movq %r13, %rdi
leaq 0x81bae(%rip), %rsi # 0xb792d
callq 0x13a08
leaq 0x38(%rsp), %rsi
movq %rsi, 0x28(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x35dac
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x35db2
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
movq %rdx, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movl 0x4(%rbx), %eax
movl %eax, 0x4(%rsp)
leaq 0x98(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x3f486
movq (%rax), %rsi
movq 0x8(%rax), %rdx
leaq 0x28(%rsp), %rdi
callq 0x13a4e
leaq 0x58(%rsp), %rsi
movq %rsi, 0x48(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x35e1c
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
jmp 0x35e22
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
movq %rdx, 0x50(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x48(%rsp), %rdi
leaq 0x81b07(%rip), %rsi # 0xb794d
callq 0x13a08
leaq 0x18(%rsp), %rsi
movq %rsi, 0x8(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x35e73
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x35e79
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x35ea5
callq 0xf330
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x35eb9
callq 0xf330
movq 0x78(%rsp), %rdi
leaq 0x88(%rsp), %rax
cmpq %rax, %rdi
je 0x35ed0
callq 0xf330
movq 0x20(%r14), %rax
cmpb $0x0, 0x48(%rax)
jne 0x35f04
movq 0x8(%r14), %rsi
addq $0x20, %rsi
movq 0x70(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax,%r15,8), %rdx
movq 0x68(%rsp), %rdi
movl $0x1, %ecx
leaq 0x8(%rsp), %r8
callq 0x279ac
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x35d46
callq 0xf330
jmp 0x35d46
leaq 0x98(%rsp), %rdi
callq 0x40af6
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
jmp 0x35f93
movq %rax, %rbx
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x35f72
callq 0xf330
jmp 0x35f72
movq %rax, %rbx
jmp 0x35f86
jmp 0x35f9f
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x35f86
callq 0xf330
movq 0x78(%rsp), %rdi
leaq 0x88(%rsp), %rax
cmpq %rax, %rdi
je 0x35fa2
callq 0xf330
jmp 0x35fa2
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x40af6
movq %rbx, %rdi
callq 0xf570
nop
| _ZN6google8protobuf17DescriptorBuilder19ValidateEnumOptionsEPNS0_14EnumDescriptorERKNS0_19EnumDescriptorProtoE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0C8h
mov [rsp+0F8h+var_88], rdx
mov r14, rsi
mov [rsp+0F8h+var_90], rdi
mov rax, [rsi+20h]
test byte ptr [rax+28h], 1
jz short loc_35C94
cmp byte ptr [rax+48h], 0
jnz loc_35F2E
loc_35C94:
lea rbp, [rsp+0F8h+var_58]
mov dword ptr [rbp+0], 0
xor eax, eax
mov [rbp+8], rax
mov [rbp+10h], rbp
mov [rbp+18h], rbp
mov [rbp+20h], rax
cmp dword ptr [r14+4], 0
jle loc_35F21
xor r15d, r15d
lea r12, [rsp+0F8h+var_80]
loc_35CC8:
mov rax, [r14+28h]
mov rcx, r15
shl rcx, 5
lea rbx, [rax+rcx]
mov eax, [rax+rcx+4]
mov rdi, [rsp+0F8h+var_50]
test rdi, rdi
jz short loc_35D1D
mov r8, rbp
loc_35CEB:
mov rcx, r8
mov rdx, rdi
mov esi, [rdi+20h]
xor edi, edi
cmp esi, eax
setl dil
mov r8, rdx
cmovl r8, rcx
mov rdi, [rdx+rdi*8+10h]
test rdi, rdi
jnz short loc_35CEB
cmp r8, rbp
jz short loc_35D1D
cmp esi, eax
cmovl rdx, rcx
cmp eax, [rdx+20h]
jge short loc_35D5B
loc_35D1D:
mov rbx, [rbx+8]
mov dword ptr [rsp+0F8h+var_F0], eax
lea rdi, [rsp+0F8h+var_60]
lea rsi, [rsp+0F8h+var_F0]
call _ZNSt3mapIiNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4lessIiESaISt4pairIKiS5_EEEixEOi; std::map<int,std::string>::operator[](int &&)
add rbx, 20h ; ' '
mov rdi, rax
mov rsi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_assignERKS4_; std::string::_M_assign(std::string const&)
loc_35D46:
inc r15
movsxd rax, dword ptr [r14+4]
cmp r15, rax
jl loc_35CC8
jmp loc_35F21
loc_35D5B:
mov rdx, [rbx+8]
add rdx, 20h ; ' '
mov r13, r12
mov rdi, r12
lea rsi, aNoteThatEnumVa+82h; "\""
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
mov rdi, r13
lea rsi, aUsesTheSameEnu; "\" uses the same enum value as \""
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea rsi, [rsp+0F8h+var_C0]
mov [rsp+0F8h+var_D0], rsi
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_35DAC
mov [rsp+0F8h+var_D0], rdx
mov rdx, [rcx]
mov [rsp+0F8h+var_C0], rdx
jmp short loc_35DB2
loc_35DAC:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [rsi], xmm0
loc_35DB2:
mov rdx, [rax+8]
mov [rsp+0F8h+var_C8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
mov eax, [rbx+4]
mov [rsp+0F8h+var_F4], eax
lea rdi, [rsp+0F8h+var_60]
lea rsi, [rsp+0F8h+var_F4]
call _ZNSt3mapIiNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4lessIiESaISt4pairIKiS5_EEEixEOi; std::map<int,std::string>::operator[](int &&)
mov rsi, [rax]
mov rdx, [rax+8]
lea rdi, [rsp+0F8h+var_D0]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
lea rsi, [rsp+0F8h+var_A0]
mov [rsp+0F8h+var_B0], rsi
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_35E1C
mov [rsp+0F8h+var_B0], rdx
mov rdx, [rcx]
mov [rsp+0F8h+var_A0], rdx
jmp short loc_35E22
loc_35E1C:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [rsi], xmm0
loc_35E22:
mov rdx, [rax+8]
mov [rsp+0F8h+var_A8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
lea rdi, [rsp+0F8h+var_B0]
lea rsi, aIfThisIsIntend; "\". If this is intended, set 'option al"...
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea rsi, [rsp+0F8h+var_E0]
mov [rsp+0F8h+var_F0], rsi
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_35E73
mov [rsp+0F8h+var_F0], rdx
mov rdx, [rcx]
mov [rsp+0F8h+var_E0], rdx
jmp short loc_35E79
loc_35E73:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [rsi], xmm0
loc_35E79:
mov rdx, [rax+8]
mov [rsp+0F8h+var_E8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
mov rdi, [rsp+0F8h+var_B0]; void *
lea rax, [rsp+0F8h+var_A0]
cmp rdi, rax
jz short loc_35EA5
call __ZdlPv; operator delete(void *)
loc_35EA5:
mov rdi, [rsp+0F8h+var_D0]; void *
lea rax, [rsp+0F8h+var_C0]
cmp rdi, rax
jz short loc_35EB9
call __ZdlPv; operator delete(void *)
loc_35EB9:
mov rdi, [rsp+0F8h+var_80]; void *
lea rax, [rsp+0F8h+var_70]
cmp rdi, rax
jz short loc_35ED0
call __ZdlPv; operator delete(void *)
loc_35ED0:
mov rax, [r14+20h]
cmp byte ptr [rax+48h], 0
jnz short loc_35F04
mov rsi, [r14+8]
add rsi, 20h ; ' '
mov rax, [rsp+0F8h+var_88]
mov rax, [rax+28h]
mov rdx, [rax+r15*8+8]
mov rdi, [rsp+0F8h+var_90]
mov ecx, 1
lea r8, [rsp+0F8h+var_F0]
call _ZN6google8protobuf17DescriptorBuilder8AddErrorERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS0_7MessageENS0_14DescriptorPool14ErrorCollector13ErrorLocationES9_; google::protobuf::DescriptorBuilder::AddError(std::string const&,google::protobuf::Message const&,google::protobuf::DescriptorPool::ErrorCollector::ErrorLocation,std::string const&)
loc_35F04:
mov rdi, [rsp+0F8h+var_F0]; void *
lea rax, [rsp+0F8h+var_E0]
cmp rdi, rax
jz loc_35D46
call __ZdlPv; operator delete(void *)
jmp loc_35D46
loc_35F21:
lea rdi, [rsp+0F8h+var_60]
call _ZNSt8_Rb_treeIiSt4pairIKiNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEESt10_Select1stIS8_ESt4lessIiESaIS8_EED2Ev; std::_Rb_tree<int,std::pair<int const,std::string>,std::_Select1st<std::pair<int const,std::string>>,std::less<int>,std::allocator<std::pair<int const,std::string>>>::~_Rb_tree()
loc_35F2E:
add rsp, 0C8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov rdi, [rsp+arg_0]
lea rax, [rsp+arg_10]
jmp short loc_35F93
mov rbx, rax
mov rdi, [rsp+arg_40]; void *
lea rax, [rsp+arg_50]
cmp rdi, rax
jz short loc_35F72
call __ZdlPv; operator delete(void *)
jmp short loc_35F72
mov rbx, rax
jmp short loc_35F86
jmp short loc_35F9F
mov rbx, rax
loc_35F72:
mov rdi, [rsp+arg_20]; void *
lea rax, [rsp+arg_30]
cmp rdi, rax
jz short loc_35F86
call __ZdlPv; operator delete(void *)
loc_35F86:
mov rdi, [rsp+arg_70]; void *
lea rax, [rsp+arg_80]
loc_35F93:
cmp rdi, rax
jz short loc_35FA2
call __ZdlPv; operator delete(void *)
jmp short loc_35FA2
loc_35F9F:
mov rbx, rax
loc_35FA2:
lea rdi, [rsp+arg_90]
call _ZNSt8_Rb_treeIiSt4pairIKiNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEESt10_Select1stIS8_ESt4lessIiESaIS8_EED2Ev; std::_Rb_tree<int,std::pair<int const,std::string>,std::_Select1st<std::pair<int const,std::string>>,std::less<int>,std::allocator<std::pair<int const,std::string>>>::~_Rb_tree()
mov rdi, rbx
call __Unwind_Resume
| long long google::protobuf::DescriptorBuilder::ValidateEnumOptions(
google::protobuf::DescriptorBuilder *this,
google::protobuf::EnumDescriptor *a2,
const google::protobuf::EnumDescriptorProto *a3)
{
long long result; // rax
long long v5; // r15
long long v6; // rbx
int v7; // eax
int *v8; // rdi
int *v9; // r8
int *v10; // rcx
int *v11; // rdx
int v12; // esi
long long v13; // rbx
_QWORD *v14; // rax
long long v15; // rax
__int128 *v16; // rcx
long long v17; // rax
_QWORD *v18; // rax
__int128 *v19; // rcx
long long v20; // rax
__int128 *v21; // rcx
int v22; // [rsp+4h] [rbp-F4h] BYREF
void *v23[2]; // [rsp+8h] [rbp-F0h] BYREF
__int128 v24; // [rsp+18h] [rbp-E0h] BYREF
void *v25[2]; // [rsp+28h] [rbp-D0h] BYREF
__int128 v26; // [rsp+38h] [rbp-C0h] BYREF
void *v27[2]; // [rsp+48h] [rbp-B0h] BYREF
__int128 v28; // [rsp+58h] [rbp-A0h] BYREF
google::protobuf::DescriptorBuilder *v29; // [rsp+68h] [rbp-90h]
const google::protobuf::EnumDescriptorProto *v30; // [rsp+70h] [rbp-88h]
void *v31[2]; // [rsp+78h] [rbp-80h] BYREF
char v32; // [rsp+88h] [rbp-70h] BYREF
char v33[8]; // [rsp+98h] [rbp-60h] BYREF
int v34; // [rsp+A0h] [rbp-58h] BYREF
int *v35; // [rsp+A8h] [rbp-50h]
int *v36; // [rsp+B0h] [rbp-48h]
int *v37; // [rsp+B8h] [rbp-40h]
long long v38; // [rsp+C0h] [rbp-38h]
v30 = a3;
v29 = this;
result = *((_QWORD *)a2 + 4);
if ( (*(_BYTE *)(result + 40) & 1) == 0 || !*(_BYTE *)(result + 72) )
{
v34 = 0;
v35 = 0LL;
v36 = &v34;
v37 = &v34;
v38 = 0LL;
if ( *((int *)a2 + 1) > 0 )
{
v5 = 0LL;
do
{
v6 = *((_QWORD *)a2 + 5) + 32 * v5;
v7 = *(_DWORD *)(v6 + 4);
v8 = v35;
if ( !v35 )
goto LABEL_14;
v9 = &v34;
do
{
v10 = v9;
v11 = v8;
v12 = v8[8];
v9 = v8;
if ( v12 < v7 )
v9 = v10;
v8 = *(int **)&v8[2 * (v12 < v7) + 4];
}
while ( v8 );
if ( v9 == &v34 )
goto LABEL_14;
if ( v12 < v7 )
v11 = v10;
if ( v7 >= v11[8] )
{
std::operator+<char>((long long)v31, (long long)"\"", (_QWORD *)(*(_QWORD *)(v6 + 8) + 32LL));
v15 = std::string::append((long long)v31, (long long)"\" uses the same enum value as \"");
v25[0] = &v26;
v16 = (__int128 *)(v15 + 16);
if ( *(_QWORD *)v15 == v15 + 16 )
{
v26 = *v16;
}
else
{
v25[0] = *(void **)v15;
*(_QWORD *)&v26 = *(_QWORD *)v16;
}
v25[1] = *(void **)(v15 + 8);
*(_QWORD *)v15 = v16;
*(_QWORD *)(v15 + 8) = 0LL;
*(_BYTE *)(v15 + 16) = 0;
v22 = *(_DWORD *)(v6 + 4);
v17 = std::map<int,std::string>::operator[](v33, &v22);
v18 = std::string::_M_append(v25, *(_BYTE **)v17, *(_QWORD *)(v17 + 8));
v27[0] = &v28;
v19 = (__int128 *)(v18 + 2);
if ( (_QWORD *)*v18 == v18 + 2 )
{
v28 = *v19;
}
else
{
v27[0] = *(void **)v18;
*(_QWORD *)&v28 = *(_QWORD *)v19;
}
v27[1] = *((void **)v18 + 1);
*v18 = v19;
v18[1] = 0LL;
*((_BYTE *)v18 + 16) = 0;
v20 = std::string::append(
(long long)v27,
(long long)"\". If this is intended, set 'option allow_alias = true;' to the enum definition.");
v23[0] = &v24;
v21 = (__int128 *)(v20 + 16);
if ( *(_QWORD *)v20 == v20 + 16 )
{
v24 = *v21;
}
else
{
v23[0] = *(void **)v20;
*(_QWORD *)&v24 = *(_QWORD *)v21;
}
v23[1] = *(void **)(v20 + 8);
*(_QWORD *)v20 = v21;
*(_QWORD *)(v20 + 8) = 0LL;
*(_BYTE *)(v20 + 16) = 0;
if ( v27[0] != &v28 )
operator delete(v27[0]);
if ( v25[0] != &v26 )
operator delete(v25[0]);
if ( v31[0] != &v32 )
operator delete(v31[0]);
if ( !*(_BYTE *)(*((_QWORD *)a2 + 4) + 72LL) )
google::protobuf::DescriptorBuilder::AddError(
(long long)v29,
*((_QWORD *)a2 + 1) + 32LL,
*(_QWORD *)(*((_QWORD *)v30 + 5) + 8 * v5 + 8),
1u,
(long long)v23);
if ( v23[0] != &v24 )
operator delete(v23[0]);
}
else
{
LABEL_14:
v13 = *(_QWORD *)(v6 + 8);
LODWORD(v23[0]) = v7;
v14 = (_QWORD *)std::map<int,std::string>::operator[](v33, v23);
std::string::_M_assign(v14, (_QWORD *)(v13 + 32));
}
++v5;
}
while ( v5 < *((int *)a2 + 1) );
}
return std::_Rb_tree<int,std::pair<int const,std::string>,std::_Select1st<std::pair<int const,std::string>>,std::less<int>,std::allocator<std::pair<int const,std::string>>>::~_Rb_tree(v33);
}
return result;
}
| ValidateEnumOptions:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xc8
MOV qword ptr [RSP + 0x70],RDX
MOV R14,RSI
MOV qword ptr [RSP + 0x68],RDI
MOV RAX,qword ptr [RSI + 0x20]
TEST byte ptr [RAX + 0x28],0x1
JZ 0x00135c94
CMP byte ptr [RAX + 0x48],0x0
JNZ 0x00135f2e
LAB_00135c94:
LEA RBP,[RSP + 0xa0]
MOV dword ptr [RBP],0x0
XOR EAX,EAX
MOV qword ptr [RBP + 0x8],RAX
MOV qword ptr [RBP + 0x10],RBP
MOV qword ptr [RBP + 0x18],RBP
MOV qword ptr [RBP + 0x20],RAX
CMP dword ptr [R14 + 0x4],0x0
JLE 0x00135f21
XOR R15D,R15D
LEA R12,[RSP + 0x78]
LAB_00135cc8:
MOV RAX,qword ptr [R14 + 0x28]
MOV RCX,R15
SHL RCX,0x5
LEA RBX,[RAX + RCX*0x1]
MOV EAX,dword ptr [RAX + RCX*0x1 + 0x4]
MOV RDI,qword ptr [RSP + 0xa8]
TEST RDI,RDI
JZ 0x00135d1d
MOV R8,RBP
LAB_00135ceb:
MOV RCX,R8
MOV RDX,RDI
MOV ESI,dword ptr [RDI + 0x20]
XOR EDI,EDI
CMP ESI,EAX
SETL DIL
MOV R8,RDX
CMOVL R8,RCX
MOV RDI,qword ptr [RDX + RDI*0x8 + 0x10]
TEST RDI,RDI
JNZ 0x00135ceb
CMP R8,RBP
JZ 0x00135d1d
CMP ESI,EAX
CMOVL RDX,RCX
CMP EAX,dword ptr [RDX + 0x20]
JGE 0x00135d5b
LAB_00135d1d:
MOV RBX,qword ptr [RBX + 0x8]
MOV dword ptr [RSP + 0x8],EAX
LAB_00135d25:
LEA RDI,[RSP + 0x98]
LEA RSI,[RSP + 0x8]
CALL 0x0013f486
ADD RBX,0x20
MOV RDI,RAX
MOV RSI,RBX
CALL 0x001138c8
LAB_00135d46:
INC R15
MOVSXD RAX,dword ptr [R14 + 0x4]
CMP R15,RAX
JL 0x00135cc8
JMP 0x00135f21
LAB_00135d5b:
MOV RDX,qword ptr [RBX + 0x8]
ADD RDX,0x20
LAB_00135d63:
MOV R13,R12
MOV RDI,R12
LEA RSI,[0x1b700b]
CALL 0x0011397f
LAB_00135d75:
MOV RDI,R13
LEA RSI,[0x1b792d]
CALL 0x00113a08
LEA RSI,[RSP + 0x38]
MOV qword ptr [RSP + 0x28],RSI
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x00135dac
MOV qword ptr [RSP + 0x28],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x38],RDX
JMP 0x00135db2
LAB_00135dac:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RSI],XMM0
LAB_00135db2:
MOV RDX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x30],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
MOV EAX,dword ptr [RBX + 0x4]
MOV dword ptr [RSP + 0x4],EAX
LAB_00135dd1:
LEA RDI,[RSP + 0x98]
LEA RSI,[RSP + 0x4]
CALL 0x0013f486
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
LEA RDI,[RSP + 0x28]
CALL 0x00113a4e
LEA RSI,[RSP + 0x58]
MOV qword ptr [RSP + 0x48],RSI
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x00135e1c
MOV qword ptr [RSP + 0x48],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x58],RDX
JMP 0x00135e22
LAB_00135e1c:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RSI],XMM0
LAB_00135e22:
MOV RDX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x50],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
LAB_00135e3a:
LEA RDI,[RSP + 0x48]
LEA RSI,[0x1b794d]
CALL 0x00113a08
LEA RSI,[RSP + 0x18]
MOV qword ptr [RSP + 0x8],RSI
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x00135e73
MOV qword ptr [RSP + 0x8],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x18],RDX
JMP 0x00135e79
LAB_00135e73:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RSI],XMM0
LAB_00135e79:
MOV RDX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x10],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
MOV RDI,qword ptr [RSP + 0x48]
LEA RAX,[RSP + 0x58]
CMP RDI,RAX
JZ 0x00135ea5
CALL 0x0010f330
LAB_00135ea5:
MOV RDI,qword ptr [RSP + 0x28]
LEA RAX,[RSP + 0x38]
CMP RDI,RAX
JZ 0x00135eb9
CALL 0x0010f330
LAB_00135eb9:
MOV RDI,qword ptr [RSP + 0x78]
LEA RAX,[RSP + 0x88]
CMP RDI,RAX
JZ 0x00135ed0
CALL 0x0010f330
LAB_00135ed0:
MOV RAX,qword ptr [R14 + 0x20]
CMP byte ptr [RAX + 0x48],0x0
JNZ 0x00135f04
MOV RSI,qword ptr [R14 + 0x8]
ADD RSI,0x20
MOV RAX,qword ptr [RSP + 0x70]
MOV RAX,qword ptr [RAX + 0x28]
MOV RDX,qword ptr [RAX + R15*0x8 + 0x8]
LAB_00135ef0:
MOV RDI,qword ptr [RSP + 0x68]
MOV ECX,0x1
LEA R8,[RSP + 0x8]
CALL 0x001279ac
LAB_00135f04:
MOV RDI,qword ptr [RSP + 0x8]
LEA RAX,[RSP + 0x18]
CMP RDI,RAX
JZ 0x00135d46
CALL 0x0010f330
JMP 0x00135d46
LAB_00135f21:
LEA RDI,[RSP + 0x98]
CALL 0x00140af6
LAB_00135f2e:
ADD RSP,0xc8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* google::protobuf::DescriptorBuilder::ValidateEnumOptions(google::protobuf::EnumDescriptor*,
google::protobuf::EnumDescriptorProto const&) */
void __thiscall
google::protobuf::DescriptorBuilder::ValidateEnumOptions
(DescriptorBuilder *this,EnumDescriptor *param_1,EnumDescriptorProto *param_2)
{
long lVar1;
int iVar2;
int iVar3;
int4 *puVar4;
string *this_00;
long *plVar5;
int8 *puVar6;
long *plVar7;
int4 *puVar8;
int4 *puVar9;
int4 *puVar10;
long lVar11;
int local_f4;
long *local_f0;
long local_e8;
long local_e0;
long lStack_d8;
long *local_d0;
long local_c8;
long local_c0;
long lStack_b8;
long *local_b0;
long local_a8;
long local_a0;
long lStack_98;
DescriptorBuilder *local_90;
EnumDescriptorProto *local_88;
int1 *local_80 [2];
int1 local_70 [16];
map<int,std::__cxx11::string,std::less<int>,std::allocator<std::pair<int_const,std::__cxx11::string>>>
local_60 [8];
int4 local_58 [2];
int4 *local_50;
int4 *local_48;
int4 *local_40;
int8 local_38;
if (((*(byte *)(*(long *)(param_1 + 0x20) + 0x28) & 1) == 0) ||
(*(char *)(*(long *)(param_1 + 0x20) + 0x48) == '\0')) {
local_58[0] = 0;
local_50 = (int4 *)0x0;
local_38 = 0;
local_90 = this;
local_88 = param_2;
local_48 = local_58;
local_40 = local_58;
if (0 < *(int *)(param_1 + 4)) {
lVar11 = 0;
do {
lVar1 = *(long *)(param_1 + 0x28) + lVar11 * 0x20;
iVar2 = *(int *)(*(long *)(param_1 + 0x28) + 4 + lVar11 * 0x20);
puVar4 = local_50;
puVar10 = local_58;
if (local_50 == (int4 *)0x0) {
LAB_00135d1d:
lVar1 = *(long *)(lVar1 + 8);
local_f0 = (long *)CONCAT44(local_f0._4_4_,iVar2);
/* try { // try from 00135d25 to 00135d45 has its CatchHandler @ 00135f9f */
this_00 = (string *)
std::
map<int,std::__cxx11::string,std::less<int>,std::allocator<std::pair<int_const,std::__cxx11::string>>>
::operator[](local_60,(int *)&local_f0);
std::__cxx11::string::_M_assign(this_00,(string *)(lVar1 + 0x20));
}
else {
do {
puVar9 = puVar10;
puVar8 = puVar4;
iVar3 = puVar8[8];
puVar10 = puVar8;
if (iVar3 < iVar2) {
puVar10 = puVar9;
}
puVar4 = *(int4 **)(puVar8 + (ulong)(iVar3 < iVar2) * 2 + 4);
} while (*(int4 **)(puVar8 + (ulong)(iVar3 < iVar2) * 2 + 4) != (int4 *)0x0);
if (puVar10 == local_58) goto LAB_00135d1d;
if (iVar3 < iVar2) {
puVar8 = puVar9;
}
if (iVar2 < (int)puVar8[8]) goto LAB_00135d1d;
/* try { // try from 00135d63 to 00135d74 has its CatchHandler @ 00135f6d */
std::operator+((char *)local_80,(string *)0x1b700b);
/* try { // try from 00135d75 to 00135d83 has its CatchHandler @ 00135f68 */
plVar5 = (long *)std::__cxx11::string::append
((string *)local_80,"\" uses the same enum value as \"");
local_d0 = &local_c0;
plVar7 = plVar5 + 2;
if ((long *)*plVar5 == plVar7) {
local_c0 = *plVar7;
lStack_b8 = plVar5[3];
}
else {
local_c0 = *plVar7;
local_d0 = (long *)*plVar5;
}
local_c8 = plVar5[1];
*plVar5 = (long)plVar7;
plVar5[1] = 0;
*(int1 *)(plVar5 + 2) = 0;
local_f4 = *(int *)(lVar1 + 4);
/* try { // try from 00135dd1 to 00135df3 has its CatchHandler @ 00135f6f */
puVar6 = (int8 *)
std::
map<int,std::__cxx11::string,std::less<int>,std::allocator<std::pair<int_const,std::__cxx11::string>>>
::operator[](local_60,&local_f4);
plVar5 = (long *)std::__cxx11::string::_M_append
((string *)&local_d0,(char *)*puVar6,puVar6[1]);
local_b0 = &local_a0;
plVar7 = plVar5 + 2;
if ((long *)*plVar5 == plVar7) {
local_a0 = *plVar7;
lStack_98 = plVar5[3];
}
else {
local_a0 = *plVar7;
local_b0 = (long *)*plVar5;
}
local_a8 = plVar5[1];
*plVar5 = (long)plVar7;
plVar5[1] = 0;
*(int1 *)(plVar5 + 2) = 0;
/* try { // try from 00135e3a to 00135e4a has its CatchHandler @ 00135f4f */
plVar5 = (long *)std::__cxx11::string::append
((string *)&local_b0,
"\". If this is intended, set \'option allow_alias = true;\' to the enum definition."
);
local_f0 = &local_e0;
plVar7 = plVar5 + 2;
if ((long *)*plVar5 == plVar7) {
local_e0 = *plVar7;
lStack_d8 = plVar5[3];
}
else {
local_e0 = *plVar7;
local_f0 = (long *)*plVar5;
}
local_e8 = plVar5[1];
*plVar5 = (long)plVar7;
plVar5[1] = 0;
*(int1 *)(plVar5 + 2) = 0;
if (local_b0 != &local_a0) {
operator_delete(local_b0);
}
if (local_d0 != &local_c0) {
operator_delete(local_d0);
}
if (local_80[0] != local_70) {
operator_delete(local_80[0]);
}
if (*(char *)(*(long *)(param_1 + 0x20) + 0x48) == '\0') {
/* try { // try from 00135ef0 to 00135f03 has its CatchHandler @ 00135f40 */
AddError(local_90,*(long *)(param_1 + 8) + 0x20,
*(int8 *)(*(long *)(local_88 + 0x28) + 8 + lVar11 * 8),1,&local_f0);
}
if (local_f0 != &local_e0) {
operator_delete(local_f0);
}
}
lVar11 = lVar11 + 1;
} while (lVar11 < *(int *)(param_1 + 4));
}
std::
_Rb_tree<int,std::pair<int_const,std::__cxx11::string>,std::_Select1st<std::pair<int_const,std::__cxx11::string>>,std::less<int>,std::allocator<std::pair<int_const,std::__cxx11::string>>>
::~_Rb_tree((_Rb_tree<int,std::pair<int_const,std::__cxx11::string>,std::_Select1st<std::pair<int_const,std::__cxx11::string>>,std::less<int>,std::allocator<std::pair<int_const,std::__cxx11::string>>>
*)local_60);
}
return;
}
| |
53,906 | nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::reset() | monkey531[P]llama/common/./json.hpp | void reset() noexcept
{
token_buffer.clear();
token_string.clear();
token_string.push_back(char_traits<char_type>::to_char_type(current));
} | O1 | cpp | nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::reset():
pushq %rax
movq %rdi, %rax
movq $0x0, 0x58(%rdi)
movq 0x50(%rdi), %rcx
movb $0x0, (%rcx)
addq $0x38, %rdi
movq 0x38(%rax), %rcx
cmpq %rcx, 0x40(%rax)
je 0x470f3
movq %rcx, 0x40(%rax)
movb 0x14(%rax), %al
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
callq 0x3a8ea
popq %rax
retq
movq %rax, %rdi
callq 0x2c043
| _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE5resetEv:
push rax
mov rax, rdi
mov qword ptr [rdi+58h], 0
mov rcx, [rdi+50h]
mov byte ptr [rcx], 0
add rdi, 38h ; '8'
mov rcx, [rax+38h]
cmp [rax+40h], rcx
jz short loc_470F3
mov [rax+40h], rcx
loc_470F3:
mov al, [rax+14h]
lea rsi, [rsp+8+var_1]
mov [rsi], al
call _ZNSt6vectorIcSaIcEE12emplace_backIJcEEERcDpOT_; std::vector<char>::emplace_back<char>(char &&)
pop rax
retn
mov rdi, rax
call __clang_call_terminate
| void __spoils<rdx,rcx,r8,r9,r10,r11,xmm4,xmm5> nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::reset(
long long a1)
{
long long v2; // rdi
long long v3; // rcx
char v4; // [rsp+1h] [rbp-1h] BYREF
*(_QWORD *)(a1 + 88) = 0LL;
**(_BYTE **)(a1 + 80) = 0;
v2 = a1 + 56;
v3 = *(_QWORD *)(a1 + 56);
if ( *(_QWORD *)(a1 + 64) != v3 )
*(_QWORD *)(a1 + 64) = v3;
v4 = *(_BYTE *)(a1 + 20);
std::vector<char>::emplace_back<char>(v2, &v4);
}
| reset:
PUSH RAX
MOV RAX,RDI
MOV qword ptr [RDI + 0x58],0x0
MOV RCX,qword ptr [RDI + 0x50]
MOV byte ptr [RCX],0x0
ADD RDI,0x38
MOV RCX,qword ptr [RAX + 0x38]
CMP qword ptr [RAX + 0x40],RCX
JZ 0x001470f3
MOV qword ptr [RAX + 0x40],RCX
LAB_001470f3:
MOV AL,byte ptr [RAX + 0x14]
LEA RSI,[RSP + 0x7]
MOV byte ptr [RSI],AL
LAB_001470fd:
CALL 0x0013a8ea
POP RAX
RET
|
/* nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>,
nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > > >::reset() */
int8 __thiscall
nlohmann::json_abi_v3_11_3::detail::
lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
::reset(lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*this)
{
int8 in_RAX;
int8 uStack_8;
*(int8 *)(this + 0x58) = 0;
**(int1 **)(this + 0x50) = 0;
if (*(long *)(this + 0x40) != *(long *)(this + 0x38)) {
*(long *)(this + 0x40) = *(long *)(this + 0x38);
}
uStack_8 = CONCAT17(this[0x14],(int7)in_RAX);
/* try { // try from 001470fd to 00147101 has its CatchHandler @ 00147104 */
std::vector<char,std::allocator<char>>::emplace_back<char>
((vector<char,std::allocator<char>> *)(this + 0x38),(char *)((long)&uStack_8 + 7));
return uStack_8;
}
| |
53,907 | nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::reset() | monkey531[P]llama/common/./json.hpp | void reset() noexcept
{
token_buffer.clear();
token_string.clear();
token_string.push_back(char_traits<char_type>::to_char_type(current));
} | O2 | cpp | nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::reset():
pushq %rax
movq %rdi, %rax
andq $0x0, 0x58(%rdi)
movq 0x50(%rdi), %rcx
movb $0x0, (%rcx)
addq $0x38, %rdi
movq 0x38(%rax), %rcx
cmpq %rcx, 0x40(%rax)
je 0x418be
movq %rcx, 0x40(%rax)
movb 0x14(%rax), %al
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
callq 0x375c8
popq %rax
retq
movq %rax, %rdi
callq 0x2b230
nop
| _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE5resetEv:
push rax
mov rax, rdi
and qword ptr [rdi+58h], 0
mov rcx, [rdi+50h]
mov byte ptr [rcx], 0
add rdi, 38h ; '8'
mov rcx, [rax+38h]
cmp [rax+40h], rcx
jz short loc_418BE
mov [rax+40h], rcx
loc_418BE:
mov al, [rax+14h]
lea rsi, [rsp+8+var_1]
mov [rsi], al
call _ZNSt6vectorIcSaIcEE12emplace_backIJcEEERcDpOT_; std::vector<char>::emplace_back<char>(char &&)
pop rax
retn
mov rdi, rax
call __clang_call_terminate
| void __spoils<rdx,rcx,r8,r9,r10,r11,xmm4,xmm5> nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::reset(
long long a1)
{
long long v2; // rdi
long long v3; // rcx
char v4; // [rsp+1h] [rbp-1h] BYREF
*(_QWORD *)(a1 + 88) = 0LL;
**(_BYTE **)(a1 + 80) = 0;
v2 = a1 + 56;
v3 = *(_QWORD *)(a1 + 56);
if ( *(_QWORD *)(a1 + 64) != v3 )
*(_QWORD *)(a1 + 64) = v3;
v4 = *(_BYTE *)(a1 + 20);
std::vector<char>::emplace_back<char>(v2, &v4);
}
| |||
53,908 | llm_build_context::build_inp_KQ_mask_swa(bool) | monkey531[P]llama/src/llama.cpp | struct ggml_tensor * build_inp_KQ_mask_swa(bool causal = true) {
GGML_ASSERT(hparams.n_swa > 0);
lctx.inp_KQ_mask_swa = causal
? ggml_new_tensor_2d(ctx0, GGML_TYPE_F32, n_kv, GGML_PAD(n_tokens, GGML_KQ_MASK_PAD))
: ggml_new_tensor_2d(ctx0, GGML_TYPE_F32, n_tokens, GGML_PAD(n_tokens, GGML_KQ_MASK_PAD));
cb(lctx.inp_KQ_mask_swa, "KQ_mask_swa", -1);
ggml_set_input(lctx.inp_KQ_mask_swa);
return flash_attn ? ggml_cast(ctx0, lctx.inp_KQ_mask_swa, GGML_TYPE_F16) : lctx.inp_KQ_mask_swa;
} | O2 | cpp | llm_build_context::build_inp_KQ_mask_swa(bool):
pushq %rbx
movq 0x10(%rdi), %rax
cmpl $0x0, 0x18(%rax)
je 0xca4e0
movq %rdi, %rbx
movq 0xe8(%rdi), %rdi
movslq 0xb0(%rbx), %rcx
movl %ecx, %eax
testb %sil, %sil
je 0xca469
movl 0xb4(%rbx), %eax
movslq %eax, %rdx
addq $0x1f, %rcx
andq $-0x20, %rcx
xorl %esi, %esi
callq 0xa4000
movq 0x8(%rbx), %rcx
movq %rax, 0x410(%rcx)
movq 0xd8(%rbx), %rdi
leaq 0x74bef(%rip), %rdx # 0x13f083
pushq $-0x1
popq %rcx
movq %rax, %rsi
callq 0x9b040
movq 0x8(%rbx), %rax
movq 0x410(%rax), %rdi
callq 0x9dc30
cmpb $0x1, 0xc8(%rbx)
jne 0xca4d3
movq 0x8(%rbx), %rax
movq 0xe8(%rbx), %rdi
movq 0x410(%rax), %rsi
pushq $0x1
popq %rdx
popq %rbx
jmp 0x9cf70
movq 0x8(%rbx), %rax
movq 0x410(%rax), %rax
popq %rbx
retq
leaq 0x73e55(%rip), %rdi # 0x13e33c
leaq 0x73e96(%rip), %rdx # 0x13e384
leaq 0x74b7c(%rip), %rcx # 0x13f071
movl $0x52d, %esi # imm = 0x52D
xorl %eax, %eax
callq 0xa6ac0
nop
| _ZN17llm_build_context21build_inp_KQ_mask_swaEb:
push rbx
mov rax, [rdi+10h]
cmp dword ptr [rax+18h], 0
jz loc_CA4E0
mov rbx, rdi
mov rdi, [rdi+0E8h]
movsxd rcx, dword ptr [rbx+0B0h]
mov eax, ecx
test sil, sil
jz short loc_CA469
mov eax, [rbx+0B4h]
loc_CA469:
movsxd rdx, eax
add rcx, 1Fh
and rcx, 0FFFFFFFFFFFFFFE0h
xor esi, esi
call _ggml_new_tensor_2d
mov rcx, [rbx+8]
mov [rcx+410h], rax
mov rdi, [rbx+0D8h]
lea rdx, aKqMaskSwa; "KQ_mask_swa"
push 0FFFFFFFFFFFFFFFFh
pop rcx
mov rsi, rax
call __ZNKSt8functionIFvP11ggml_tensorPKciEEclES1_S3_i; std::function<void ()(ggml_tensor *,char const*,int)>::operator()(ggml_tensor *,char const*,int)
mov rax, [rbx+8]
mov rdi, [rax+410h]
call _ggml_set_input
cmp byte ptr [rbx+0C8h], 1
jnz short loc_CA4D3
mov rax, [rbx+8]
mov rdi, [rbx+0E8h]
mov rsi, [rax+410h]
push 1
pop rdx
pop rbx
jmp _ggml_cast
loc_CA4D3:
mov rax, [rbx+8]
mov rax, [rax+410h]
pop rbx
retn
loc_CA4E0:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aHparamsNSwa0; "hparams.n_swa > 0"
mov esi, 52Dh
xor eax, eax
call _ggml_abort
nop
| long long llm_build_context::build_inp_KQ_mask_swa(llm_build_context *this, char a2)
{
long long v3; // rdi
int v4; // eax
long long v5; // rax
if ( *(_DWORD *)(*((_QWORD *)this + 2) + 24LL) )
{
v3 = *((_QWORD *)this + 29);
v4 = *((_DWORD *)this + 44);
if ( a2 )
v4 = *((_DWORD *)this + 45);
v5 = ggml_new_tensor_2d(v3, 0LL, v4, (*((int *)this + 44) + 31LL) & 0xFFFFFFFFFFFFFFE0LL);
*(_QWORD *)(*((_QWORD *)this + 1) + 1040LL) = v5;
std::function<void ()(ggml_tensor *,char const*,int)>::operator()(*((_QWORD *)this + 27), v5, "KQ_mask_swa", -1LL);
ggml_set_input(*(_QWORD *)(*((_QWORD *)this + 1) + 1040LL));
if ( *((_BYTE *)this + 200) == 1 )
return ggml_cast(*((_QWORD *)this + 29), *(_QWORD *)(*((_QWORD *)this + 1) + 1040LL), 1LL);
else
return *(_QWORD *)(*((_QWORD *)this + 1) + 1040LL);
}
else
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/src/llama.cpp",
1325LL,
"GGML_ASSERT(%s) failed",
"hparams.n_swa > 0");
return llm_build_context::build_inp_s_copy((llm_build_context *)"/workspace/llm4binary/github/2025_star3/monkey531[P]"
"llama/src/llama.cpp");
}
}
| build_inp_KQ_mask_swa:
PUSH RBX
MOV RAX,qword ptr [RDI + 0x10]
CMP dword ptr [RAX + 0x18],0x0
JZ 0x001ca4e0
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0xe8]
MOVSXD RCX,dword ptr [RBX + 0xb0]
MOV EAX,ECX
TEST SIL,SIL
JZ 0x001ca469
MOV EAX,dword ptr [RBX + 0xb4]
LAB_001ca469:
MOVSXD RDX,EAX
ADD RCX,0x1f
AND RCX,-0x20
XOR ESI,ESI
CALL 0x001a4000
MOV RCX,qword ptr [RBX + 0x8]
MOV qword ptr [RCX + 0x410],RAX
MOV RDI,qword ptr [RBX + 0xd8]
LEA RDX,[0x23f083]
PUSH -0x1
POP RCX
MOV RSI,RAX
CALL 0x0019b040
MOV RAX,qword ptr [RBX + 0x8]
MOV RDI,qword ptr [RAX + 0x410]
CALL 0x0019dc30
CMP byte ptr [RBX + 0xc8],0x1
JNZ 0x001ca4d3
MOV RAX,qword ptr [RBX + 0x8]
MOV RDI,qword ptr [RBX + 0xe8]
MOV RSI,qword ptr [RAX + 0x410]
PUSH 0x1
POP RDX
POP RBX
JMP 0x0019cf70
LAB_001ca4d3:
MOV RAX,qword ptr [RBX + 0x8]
MOV RAX,qword ptr [RAX + 0x410]
POP RBX
RET
LAB_001ca4e0:
LEA RDI,[0x23e33c]
LEA RDX,[0x23e384]
LEA RCX,[0x23f071]
MOV ESI,0x52d
XOR EAX,EAX
CALL 0x001a6ac0
|
/* llm_build_context::build_inp_KQ_mask_swa(bool) */
int8 __thiscall llm_build_context::build_inp_KQ_mask_swa(llm_build_context *this,bool param_1)
{
int iVar1;
ggml_tensor *pgVar2;
int8 uVar3;
long lVar4;
if (*(int *)(*(long *)(this + 0x10) + 0x18) == 0) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/src/llama.cpp",0x52d,
"GGML_ASSERT(%s) failed","hparams.n_swa > 0");
}
iVar1 = *(int *)(this + 0xb0);
lVar4 = (long)iVar1;
if (param_1) {
iVar1 = *(int *)(this + 0xb4);
}
pgVar2 = (ggml_tensor *)
ggml_new_tensor_2d(*(int8 *)(this + 0xe8),0,(long)iVar1,
lVar4 + 0x1fU & 0xffffffffffffffe0);
*(ggml_tensor **)(*(long *)(this + 8) + 0x410) = pgVar2;
std::function<void(ggml_tensor*,char_const*,int)>::operator()
(*(function<void(ggml_tensor*,char_const*,int)> **)(this + 0xd8),pgVar2,"KQ_mask_swa",-1
);
ggml_set_input(*(int8 *)(*(long *)(this + 8) + 0x410));
if (this[200] == (llm_build_context)0x1) {
uVar3 = ggml_cast(*(int8 *)(this + 0xe8),*(int8 *)(*(long *)(this + 8) + 0x410),1);
return uVar3;
}
return *(int8 *)(*(long *)(this + 8) + 0x410);
}
| |
53,909 | uf_blob | eloqsql/storage/myisam/mi_packrec.c | static void uf_blob(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff,
uchar *to, uchar *end)
{
if (get_bit(bit_buff))
bzero((uchar*) to,(end-to));
else
{
ulong length=get_bits(bit_buff,rec->space_length_bits);
uint pack_length=(uint) (end-to)-portable_sizeof_char_ptr;
if (bit_buff->blob_pos+length > bit_buff->blob_end)
{
bit_buff->error=1;
bzero((uchar*) to,(end-to));
return;
}
decode_bytes(rec,bit_buff,bit_buff->blob_pos,bit_buff->blob_pos+length);
_mi_store_blob_length((uchar*) to,pack_length,length);
memcpy(to+pack_length, &bit_buff->blob_pos, sizeof(char*));
bit_buff->blob_pos+=length;
}
} | O3 | c | uf_blob:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
movl 0x4(%rsi), %eax
testl %eax, %eax
je 0x86bc3
movl (%r15), %r12d
decl %eax
movl %eax, 0x4(%r15)
btl %eax, %r12d
jae 0x86be0
subq %r14, %rbx
jmp 0x86c5d
movq %r15, %rdi
callq 0x85675
movl $0x1f, 0x4(%r15)
movl (%r15), %r12d
movl $0x1f, %eax
testl %r12d, %r12d
js 0x86bbb
movq %r13, %rdx
movl 0x1c(%r13), %r13d
movl %eax, %ecx
subl %r13d, %ecx
movq %rdx, -0x30(%rbp)
jae 0x86c2c
subl %eax, %r13d
movl %eax, %eax
leaq 0x5d032(%rip), %rcx # 0xe3c30
andl (%rcx,%rax,4), %r12d
movl %r13d, %ecx
shll %cl, %r12d
movq %r15, %rdi
callq 0x85675
movl $0x20, %eax
subl %r13d, %eax
movl %eax, 0x4(%r15)
movl (%r15), %eax
negl %r13d
movl %r13d, %ecx
shrl %cl, %eax
addl %eax, %r12d
jmp 0x86c41
movl %ecx, 0x4(%r15)
shrl %cl, %r12d
movl 0x1c(%rdx), %eax
leaq 0x5cff3(%rip), %rcx # 0xe3c30
andl (%rcx,%rax,4), %r12d
movl %r12d, %r13d
subq %r14, %rbx
movq 0x18(%r15), %rdx
leaq (%rdx,%r13), %rcx
cmpq 0x20(%r15), %rcx
jbe 0x86c78
movl $0x1, 0x28(%r15)
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x29270
addl $-0x8, %ebx
movq -0x30(%rbp), %rdi
movq %r15, %rsi
callq 0x85f66
movq %r14, %rdi
movl %ebx, %esi
movl %r13d, %edx
callq 0x7c353
movq 0x18(%r15), %rax
movq %rax, (%r14,%rbx)
addq %r13, 0x18(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| uf_blob_0:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rcx
mov r14, rdx
mov r15, rsi
mov r13, rdi
mov eax, [rsi+4]
test eax, eax
jz short loc_86BC3
mov r12d, [r15]
dec eax
mov [r15+4], eax
bt r12d, eax
jnb short loc_86BE0
loc_86BBB:
sub rbx, r14
jmp loc_86C5D
loc_86BC3:
mov rdi, r15
call fill_buffer_0
mov dword ptr [r15+4], 1Fh
mov r12d, [r15]
mov eax, 1Fh
test r12d, r12d
js short loc_86BBB
loc_86BE0:
mov rdx, r13
mov r13d, [r13+1Ch]
mov ecx, eax
sub ecx, r13d
mov [rbp+var_30], rdx
jnb short loc_86C2C
sub r13d, eax
mov eax, eax
lea rcx, mask_0
and r12d, [rcx+rax*4]
mov ecx, r13d
shl r12d, cl
mov rdi, r15
call fill_buffer_0
mov eax, 20h ; ' '
sub eax, r13d
mov [r15+4], eax
mov eax, [r15]
neg r13d
mov ecx, r13d
shr eax, cl
add r12d, eax
jmp short loc_86C41
loc_86C2C:
mov [r15+4], ecx
shr r12d, cl
mov eax, [rdx+1Ch]
lea rcx, mask_0
and r12d, [rcx+rax*4]
loc_86C41:
mov r13d, r12d
sub rbx, r14
mov rdx, [r15+18h]
lea rcx, [rdx+r13]
cmp rcx, [r15+20h]
jbe short loc_86C78
mov dword ptr [r15+28h], 1
loc_86C5D:
mov rdi, r14
xor esi, esi
mov rdx, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _memset
loc_86C78:
add ebx, 0FFFFFFF8h
mov rdi, [rbp+var_30]
mov rsi, r15
call decode_bytes_0
mov rdi, r14
mov esi, ebx
mov edx, r13d
call _mi_store_blob_length
mov rax, [r15+18h]
mov [r14+rbx], rax
add [r15+18h], r13
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long uf_blob_0(long long a1, long long a2, _BYTE *a3, long long a4)
{
int v6; // eax
unsigned int v7; // r12d
unsigned int v8; // eax
long long v9; // rbx
unsigned int v10; // r13d
int v11; // ecx
int v12; // r13d
int v13; // r12d
unsigned int v14; // r12d
_BYTE *v15; // rdx
_BYTE *v16; // rcx
long long result; // rax
long long v18; // rbx
v6 = *(_DWORD *)(a2 + 4);
if ( v6 )
{
v7 = *(_DWORD *)a2;
v8 = v6 - 1;
*(_DWORD *)(a2 + 4) = v8;
if ( _bittest((const int *)&v7, v8) )
{
LABEL_3:
v9 = a4 - (_QWORD)a3;
return memset(a3, 0LL, v9);
}
}
else
{
fill_buffer_0(a2);
*(_DWORD *)(a2 + 4) = 31;
v7 = *(_DWORD *)a2;
v8 = 31;
if ( *(int *)a2 < 0 )
goto LABEL_3;
}
v10 = *(_DWORD *)(a1 + 28);
v11 = v8 - v10;
if ( v8 >= v10 )
{
*(_DWORD *)(a2 + 4) = v11;
v14 = mask_0[*(unsigned int *)(a1 + 28)] & (v7 >> v11);
}
else
{
v12 = v10 - v8;
v13 = (mask_0[v8] & v7) << v12;
fill_buffer_0(a2);
*(_DWORD *)(a2 + 4) = 32 - v12;
v14 = (*(_DWORD *)a2 >> -(char)v12) + v13;
}
v9 = a4 - (_QWORD)a3;
v15 = *(_BYTE **)(a2 + 24);
v16 = &v15[v14];
if ( (unsigned long long)v16 > *(_QWORD *)(a2 + 32) )
{
*(_DWORD *)(a2 + 40) = 1;
return memset(a3, 0LL, v9);
}
v18 = (unsigned int)(v9 - 8);
decode_bytes_0(a1, a2, v15, v16);
mi_store_blob_length(a3, v18, v14);
result = *(_QWORD *)(a2 + 24);
*(_QWORD *)&a3[v18] = result;
*(_QWORD *)(a2 + 24) += v14;
return result;
}
| uf_blob:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RCX
MOV R14,RDX
MOV R15,RSI
MOV R13,RDI
MOV EAX,dword ptr [RSI + 0x4]
TEST EAX,EAX
JZ 0x00186bc3
MOV R12D,dword ptr [R15]
DEC EAX
MOV dword ptr [R15 + 0x4],EAX
BT R12D,EAX
JNC 0x00186be0
LAB_00186bbb:
SUB RBX,R14
JMP 0x00186c5d
LAB_00186bc3:
MOV RDI,R15
CALL 0x00185675
MOV dword ptr [R15 + 0x4],0x1f
MOV R12D,dword ptr [R15]
MOV EAX,0x1f
TEST R12D,R12D
JS 0x00186bbb
LAB_00186be0:
MOV RDX,R13
MOV R13D,dword ptr [R13 + 0x1c]
MOV ECX,EAX
SUB ECX,R13D
MOV qword ptr [RBP + -0x30],RDX
JNC 0x00186c2c
SUB R13D,EAX
MOV EAX,EAX
LEA RCX,[0x1e3c30]
AND R12D,dword ptr [RCX + RAX*0x4]
MOV ECX,R13D
SHL R12D,CL
MOV RDI,R15
CALL 0x00185675
MOV EAX,0x20
SUB EAX,R13D
MOV dword ptr [R15 + 0x4],EAX
MOV EAX,dword ptr [R15]
NEG R13D
MOV ECX,R13D
SHR EAX,CL
ADD R12D,EAX
JMP 0x00186c41
LAB_00186c2c:
MOV dword ptr [R15 + 0x4],ECX
SHR R12D,CL
MOV EAX,dword ptr [RDX + 0x1c]
LEA RCX,[0x1e3c30]
AND R12D,dword ptr [RCX + RAX*0x4]
LAB_00186c41:
MOV R13D,R12D
SUB RBX,R14
MOV RDX,qword ptr [R15 + 0x18]
LEA RCX,[RDX + R13*0x1]
CMP RCX,qword ptr [R15 + 0x20]
JBE 0x00186c78
MOV dword ptr [R15 + 0x28],0x1
LAB_00186c5d:
MOV RDI,R14
XOR ESI,ESI
MOV RDX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00129270
LAB_00186c78:
ADD EBX,-0x8
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,R15
CALL 0x00185f66
MOV RDI,R14
MOV ESI,EBX
MOV EDX,R13D
CALL 0x0017c353
MOV RAX,qword ptr [R15 + 0x18]
MOV qword ptr [R14 + RBX*0x1],RAX
ADD qword ptr [R15 + 0x18],R13
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void uf_blob(long param_1,uint *param_2,void *param_3,long param_4)
{
uint uVar1;
uint uVar2;
uint uVar3;
byte bVar4;
size_t __n;
uint uVar5;
ulong uVar6;
if (param_2[1] == 0) {
fill_buffer(param_2);
param_2[1] = 0x1f;
uVar5 = *param_2;
uVar3 = 0x1f;
if (-1 < (int)uVar5) goto LAB_00186be0;
}
else {
uVar5 = *param_2;
uVar3 = param_2[1] - 1;
param_2[1] = uVar3;
if ((uVar5 >> (uVar3 & 0x1f) & 1) == 0) {
LAB_00186be0:
uVar1 = *(uint *)(param_1 + 0x1c);
if (uVar3 < uVar1) {
uVar2 = (&mask)[uVar3];
bVar4 = (byte)(uVar1 - uVar3);
fill_buffer(param_2);
param_2[1] = 0x20 - (uVar1 - uVar3);
uVar5 = ((uVar5 & uVar2) << (bVar4 & 0x1f)) + (*param_2 >> (-bVar4 & 0x1f));
}
else {
param_2[1] = uVar3 - uVar1;
uVar5 = uVar5 >> ((byte)(uVar3 - uVar1) & 0x1f) & (&mask)[*(uint *)(param_1 + 0x1c)];
}
uVar6 = (ulong)uVar5;
__n = param_4 - (long)param_3;
if (*(long *)(param_2 + 6) + uVar6 <= *(ulong *)(param_2 + 8)) {
uVar5 = (int)__n - 8;
decode_bytes(param_1,param_2);
_mi_store_blob_length(param_3,uVar5,uVar6);
*(int8 *)((long)param_3 + (ulong)uVar5) = *(int8 *)(param_2 + 6);
*(ulong *)(param_2 + 6) = *(long *)(param_2 + 6) + uVar6;
return;
}
param_2[10] = 1;
goto LAB_00186c5d;
}
}
__n = param_4 - (long)param_3;
LAB_00186c5d:
memset(param_3,0,__n);
return;
}
| |
53,910 | ulight::(anonymous namespace)::Parser::try_match_content(ulight::(anonymous namespace)::Content_Context, ulight::(anonymous namespace)::Parser::Bracket_Levels&) | ulight/src/main/cpp/mmml.cpp | [[nodiscard]]
bool try_match_content(Content_Context context, Bracket_Levels& levels)
{
if (peek(u8'\\') && (try_match_escaped() || try_match_directive())) {
return true;
}
const std::size_t initial_pos = m_pos;
for (; !eof(); ++m_pos) {
const char8_t c = m_source[m_pos];
if (c == u8'\\') {
const std::u8string_view remainder { m_source.substr(m_pos + 1) };
// Trailing \ at the end of the file.
// No need to break, we'll just run into it next iteration.
if (remainder.empty()) {
continue;
}
// Escape sequence such as `\{`.
// We treat these as separate in the AST, not as content.
if (is_mmml_escapeable(remainder.front())) {
break;
}
// Directive names; also not part of content.
// No matter what, a backslash followed by a directive name character forms a
// directive because the remaining arguments and the block are optional.
// I.e. we can break with certainty despite only having examined one character.
const std::expected<utf8::Code_Point_And_Length, utf8::Error_Code> next_point
= utf8::decode_and_length(remainder);
ULIGHT_ASSERT(next_point);
if (is_mmml_directive_name_character(next_point->code_point)) {
break;
}
continue;
}
// At the document level, we don't care about brace mismatches,
// commas, etc.
if (context == Content_Context::document) {
continue;
}
if (context == Content_Context::argument_value) {
if (c == u8',') {
break;
}
if (c == u8'[') {
++levels.square;
}
if (c == u8']' && levels.square-- == 0) {
break;
}
}
if (c == u8'{') {
++levels.brace;
}
if (c == u8'}' && levels.brace-- == 0) {
break;
}
}
ULIGHT_ASSERT(m_pos >= initial_pos);
if (m_pos == initial_pos) {
return false;
}
m_out.push_back({ AST_Instruction_Type::text, m_pos - initial_pos });
return true;
} | O0 | cpp | ulight::(anonymous namespace)::Parser::try_match_content(ulight::(anonymous namespace)::Content_Context, ulight::(anonymous namespace)::Parser::Bracket_Levels&):
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
movl $0x5c, %esi
callq 0x15c10
testb $0x1, %al
jne 0x15904
jmp 0x1592f
movq -0xa8(%rbp), %rdi
callq 0x15c70
testb $0x1, %al
jne 0x15926
movq -0xa8(%rbp), %rdi
callq 0x15d30
testb $0x1, %al
jne 0x15926
jmp 0x1592f
movb $0x1, -0x1(%rbp)
jmp 0x15bf4
movq -0xa8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0xa8(%rbp), %rdi
callq 0x15780
xorb $-0x1, %al
testb $0x1, %al
jne 0x15955
jmp 0x15b39
movq -0xa8(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movq 0x18(%rax), %rsi
callq 0xb3a0
movb (%rax), %al
movb %al, -0x29(%rbp)
movzbl -0x29(%rbp), %eax
cmpl $0x5c, %eax
jne 0x15a88
movq -0xa8(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movq 0x18(%rax), %rsi
addq $0x1, %rsi
movq $-0x1, %rdx
callq 0xb1d0
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xb350
testb $0x1, %al
jne 0x159b7
jmp 0x159bc
jmp 0x15b21
leaq -0x40(%rbp), %rdi
callq 0xbcb0
movzbl (%rax), %edi
callq 0x18100
testb $0x1, %al
jne 0x159d3
jmp 0x159d8
jmp 0x15b39
movups -0x40(%rbp), %xmm0
movaps %xmm0, -0x60(%rbp)
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0xc040
movb %dl, -0x68(%rbp)
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x4c(%rbp)
movb -0x68(%rbp), %al
movb %al, -0x44(%rbp)
leaq -0x4c(%rbp), %rdi
callq 0xc1e0
movb $0x0, -0x79(%rbp)
testb $0x1, %al
jne 0x15a15
jmp 0x15a17
jmp 0x15a68
movl $0x20, %edi
callq 0x50a0
movq %rax, %rdi
movq %rdi, -0xb0(%rbp)
movq %rdi, -0x78(%rbp)
movb $0x1, -0x79(%rbp)
movb $0x0, (%rdi)
addq $0x8, %rdi
leaq 0x6d2b(%rip), %rsi # 0x1c76c
callq 0x6d80
movq -0xb0(%rbp), %rdi
leaq 0x1411c(%rip), %rax # 0x29b70
movq %rax, 0x18(%rdi)
leaq 0x12b81(%rip), %rsi # 0x285e0
xorl %eax, %eax
movl %eax, %edx
callq 0x51d0
leaq -0x4c(%rbp), %rdi
callq 0x18160
movl (%rax), %edi
callq 0x18140
testb $0x1, %al
jne 0x15a7e
jmp 0x15a83
jmp 0x15b39
jmp 0x15b21
cmpb $0x0, -0x11(%rbp)
jne 0x15a93
jmp 0x15b21
cmpb $0x1, -0x11(%rbp)
jne 0x15ae2
movzbl -0x29(%rbp), %eax
cmpl $0x2c, %eax
jne 0x15aa7
jmp 0x15b39
movzbl -0x29(%rbp), %eax
cmpl $0x5b, %eax
jne 0x15abe
movq -0x20(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movzbl -0x29(%rbp), %eax
cmpl $0x5d, %eax
jne 0x15ae0
movq -0x20(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, (%rcx)
cmpq $0x0, %rax
jne 0x15ae0
jmp 0x15b39
jmp 0x15ae2
movzbl -0x29(%rbp), %eax
cmpl $0x7b, %eax
jne 0x15afb
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movzbl -0x29(%rbp), %eax
cmpl $0x7d, %eax
jne 0x15b1f
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x15b1f
jmp 0x15b39
jmp 0x15b21
movq -0xa8(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
jmp 0x1593e
movq -0xa8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x28(%rbp), %rcx
movb $0x0, -0x89(%rbp)
cmpq %rcx, %rax
jb 0x15b56
jmp 0x15bad
movl $0x20, %edi
callq 0x50a0
movq %rax, %rdi
movq %rdi, -0xb8(%rbp)
movq %rdi, -0x88(%rbp)
movb $0x1, -0x89(%rbp)
movb $0x0, (%rdi)
addq $0x8, %rdi
leaq 0x6c52(%rip), %rsi # 0x1c7d8
callq 0x6d80
movq -0xb8(%rbp), %rdi
leaq 0x13fef(%rip), %rax # 0x29b88
movq %rax, 0x18(%rdi)
leaq 0x12a3c(%rip), %rsi # 0x285e0
xorl %eax, %eax
movl %eax, %edx
callq 0x51d0
movq -0xa8(%rbp), %rax
movq 0x18(%rax), %rax
cmpq -0x28(%rbp), %rax
jne 0x15bc4
movb $0x0, -0x1(%rbp)
jmp 0x15bf4
movq -0xa8(%rbp), %rax
movq (%rax), %rdi
movb $0x2, -0xa0(%rbp)
movq 0x18(%rax), %rax
subq -0x28(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0xa0(%rbp), %rsi
callq 0x17230
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZN6ulight12_GLOBAL__N_16Parser17try_match_contentENS0_15Content_ContextERNS1_14Bracket_LevelsE:
push rbp
mov rbp, rsp
sub rsp, 0C0h
mov al, sil
mov [rbp+var_10], rdi
mov [rbp+var_11], al
mov [rbp+var_20], rdx
mov rdi, [rbp+var_10]
mov [rbp+var_A8], rdi
mov esi, 5Ch ; '\'
call _ZNK6ulight12_GLOBAL__N_16Parser4peekEDu; ulight::`anonymous namespace'::Parser::peek(char8_t)
test al, 1
jnz short loc_15904
jmp short loc_1592F
loc_15904:
mov rdi, [rbp+var_A8]; this
call _ZN6ulight12_GLOBAL__N_16Parser17try_match_escapedEv; ulight::`anonymous namespace'::Parser::try_match_escaped(void)
test al, 1
jnz short loc_15926
mov rdi, [rbp+var_A8]; this
call _ZN6ulight12_GLOBAL__N_16Parser19try_match_directiveEv; ulight::`anonymous namespace'::Parser::try_match_directive(void)
test al, 1
jnz short loc_15926
jmp short loc_1592F
loc_15926:
mov [rbp+var_1], 1
jmp loc_15BF4
loc_1592F:
mov rax, [rbp+var_A8]
mov rax, [rax+18h]
mov [rbp+var_28], rax
loc_1593E:
mov rdi, [rbp+var_A8]; this
call _ZNK6ulight12_GLOBAL__N_16Parser3eofEv; ulight::`anonymous namespace'::Parser::eof(void)
xor al, 0FFh
test al, 1
jnz short loc_15955
jmp loc_15B39
loc_15955:
mov rax, [rbp+var_A8]
mov rdi, rax
add rdi, 8
mov rsi, [rax+18h]
call _ZNKSt17basic_string_viewIDuSt11char_traitsIDuEEixEm; std::u8string_view::operator[](ulong)
mov al, [rax]
mov [rbp+var_29], al
movzx eax, [rbp+var_29]
cmp eax, 5Ch ; '\'
jnz loc_15A88
mov rax, [rbp+var_A8]
mov rdi, rax
add rdi, 8
mov rsi, [rax+18h]
add rsi, 1
mov rdx, 0FFFFFFFFFFFFFFFFh
call _ZNKSt17basic_string_viewIDuSt11char_traitsIDuEE6substrEmm; std::u8string_view::substr(ulong,ulong)
mov qword ptr [rbp+var_40], rax
mov qword ptr [rbp+var_40+8], rdx
lea rdi, [rbp+var_40]
call _ZNKSt17basic_string_viewIDuSt11char_traitsIDuEE5emptyEv; std::u8string_view::empty(void)
test al, 1
jnz short loc_159B7
jmp short loc_159BC
loc_159B7:
jmp loc_15B21
loc_159BC:
lea rdi, [rbp+var_40]
call _ZNKSt17basic_string_viewIDuSt11char_traitsIDuEE5frontEv; std::u8string_view::front(void)
movzx edi, byte ptr [rax]
call _ZN6ulight18is_mmml_escapeableEDu; ulight::is_mmml_escapeable(char8_t)
test al, 1
jnz short loc_159D3
jmp short loc_159D8
loc_159D3:
jmp loc_15B39
loc_159D8:
movups xmm0, [rbp+var_40]
movaps [rbp+var_60], xmm0
mov rdi, qword ptr [rbp+var_60]
mov rsi, qword ptr [rbp+var_60+8]
call _ZN6ulight4utf817decode_and_lengthESt17basic_string_viewIDuSt11char_traitsIDuEE; ulight::utf8::decode_and_length(std::u8string_view)
mov [rbp+var_68], dl
mov [rbp+var_70], rax
mov rax, [rbp+var_70]
mov [rbp+var_4C], rax
mov al, [rbp+var_68]
mov [rbp+var_44], al
lea rdi, [rbp+var_4C]
call _ZNKSt8expectedIN6ulight4utf821Code_Point_And_LengthENS1_10Error_CodeEEcvbEv; std::expected<ulight::utf8::Code_Point_And_Length,ulight::utf8::Error_Code>::operator bool(void)
mov [rbp+var_79], 0
test al, 1
jnz short loc_15A15
jmp short loc_15A17
loc_15A15:
jmp short loc_15A68
loc_15A17:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rdi, rax
mov [rbp+var_B0], rdi
mov [rbp+var_78], rdi
mov [rbp+var_79], 1
mov byte ptr [rdi], 0
add rdi, 8
lea rsi, aNextPoint; "next_point"
call _ZNSt17basic_string_viewIDuSt11char_traitsIDuEEC2EPKDu; std::u8string_view::basic_string_view(char8_t const*)
mov rdi, [rbp+var_B0]; void *
lea rax, off_29B70; "/workspace/llm4binary/github2025/ulight"...
mov [rdi+18h], rax
lea rsi, _ZTIN6ulight15Assertion_ErrorE; lptinfo
xor eax, eax
mov edx, eax; void (*)(void *)
call ___cxa_throw
loc_15A68:
lea rdi, [rbp+var_4C]
call _ZNKSt8expectedIN6ulight4utf821Code_Point_And_LengthENS1_10Error_CodeEEptEv; std::expected<ulight::utf8::Code_Point_And_Length,ulight::utf8::Error_Code>::operator->(void)
mov edi, [rax]
call _ZN6ulight32is_mmml_directive_name_characterEDi; ulight::is_mmml_directive_name_character(char32_t)
test al, 1
jnz short loc_15A7E
jmp short loc_15A83
loc_15A7E:
jmp loc_15B39
loc_15A83:
jmp loc_15B21
loc_15A88:
cmp [rbp+var_11], 0
jnz short loc_15A93
jmp loc_15B21
loc_15A93:
cmp [rbp+var_11], 1
jnz short loc_15AE2
movzx eax, [rbp+var_29]
cmp eax, 2Ch ; ','
jnz short loc_15AA7
jmp loc_15B39
loc_15AA7:
movzx eax, [rbp+var_29]
cmp eax, 5Bh ; '['
jnz short loc_15ABE
mov rax, [rbp+var_20]
mov rcx, [rax]
add rcx, 1
mov [rax], rcx
loc_15ABE:
movzx eax, [rbp+var_29]
cmp eax, 5Dh ; ']'
jnz short loc_15AE0
mov rcx, [rbp+var_20]
mov rax, [rcx]
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rcx], rdx
cmp rax, 0
jnz short loc_15AE0
jmp short loc_15B39
loc_15AE0:
jmp short $+2
loc_15AE2:
movzx eax, [rbp+var_29]
cmp eax, 7Bh ; '{'
jnz short loc_15AFB
mov rax, [rbp+var_20]
mov rcx, [rax+8]
add rcx, 1
mov [rax+8], rcx
loc_15AFB:
movzx eax, [rbp+var_29]
cmp eax, 7Dh ; '}'
jnz short loc_15B1F
mov rcx, [rbp+var_20]
mov rax, [rcx+8]
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rcx+8], rdx
cmp rax, 0
jnz short loc_15B1F
jmp short loc_15B39
loc_15B1F:
jmp short $+2
loc_15B21:
mov rax, [rbp+var_A8]
mov rcx, [rax+18h]
add rcx, 1
mov [rax+18h], rcx
jmp loc_1593E
loc_15B39:
mov rax, [rbp+var_A8]
mov rax, [rax+18h]
mov rcx, [rbp+var_28]
mov [rbp+var_89], 0
cmp rax, rcx
jb short loc_15B56
jmp short loc_15BAD
loc_15B56:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rdi, rax
mov [rbp+var_B8], rdi
mov [rbp+var_88], rdi
mov [rbp+var_89], 1
mov byte ptr [rdi], 0
add rdi, 8
lea rsi, aMPosInitialPos; "m_pos >= initial_pos"
call _ZNSt17basic_string_viewIDuSt11char_traitsIDuEEC2EPKDu; std::u8string_view::basic_string_view(char8_t const*)
mov rdi, [rbp+var_B8]; void *
lea rax, off_29B88; "/workspace/llm4binary/github2025/ulight"...
mov [rdi+18h], rax
lea rsi, _ZTIN6ulight15Assertion_ErrorE; lptinfo
xor eax, eax
mov edx, eax; void (*)(void *)
call ___cxa_throw
loc_15BAD:
mov rax, [rbp+var_A8]
mov rax, [rax+18h]
cmp rax, [rbp+var_28]
jnz short loc_15BC4
mov [rbp+var_1], 0
jmp short loc_15BF4
loc_15BC4:
mov rax, [rbp+var_A8]
mov rdi, [rax]
mov [rbp+var_A0], 2
mov rax, [rax+18h]
sub rax, [rbp+var_28]
mov [rbp+var_98], rax
lea rsi, [rbp+var_A0]
call _ZNSt6vectorIN6ulight15AST_InstructionENSt3pmr21polymorphic_allocatorIS1_EEE9push_backEOS1_; std::vector<ulight::AST_Instruction,std::pmr::polymorphic_allocator<ulight::AST_Instruction>>::push_back(ulight::AST_Instruction&&)
mov [rbp+var_1], 1
loc_15BF4:
mov al, [rbp+var_1]
and al, 1
add rsp, 0C0h
pop rbp
retn
| char ulight::`anonymous namespace'::Parser::try_match_content(
ulight::_anonymous_namespace_::Parser *a1,
char a2,
_QWORD *a3)
{
__int128 v3; // rax
unsigned __int8 *v4; // rax
long long v5; // rax
char v6; // dl
unsigned int *v7; // rax
char is_mmml_directive_name_character; // al
long long v10; // rax
unsigned long long v11; // rax
long long v12; // rdi
long long *v14; // [rsp+8h] [rbp-B8h]
long long *exception; // [rsp+10h] [rbp-B0h]
char v17[8]; // [rsp+20h] [rbp-A0h] BYREF
unsigned long long v18; // [rsp+28h] [rbp-98h]
char v19; // [rsp+37h] [rbp-89h]
long long *v20; // [rsp+38h] [rbp-88h]
char v21; // [rsp+47h] [rbp-79h]
long long *v22; // [rsp+48h] [rbp-78h]
long long v23; // [rsp+50h] [rbp-70h]
char v24; // [rsp+58h] [rbp-68h]
__int128 v25; // [rsp+60h] [rbp-60h]
long long v26; // [rsp+74h] [rbp-4Ch] BYREF
char v27; // [rsp+7Ch] [rbp-44h]
__int128 v28; // [rsp+80h] [rbp-40h] BYREF
char v29; // [rsp+97h] [rbp-29h]
unsigned long long v30; // [rsp+98h] [rbp-28h]
_QWORD *v31; // [rsp+A0h] [rbp-20h]
char v32; // [rsp+AFh] [rbp-11h]
ulight::_anonymous_namespace_::Parser *v33; // [rsp+B0h] [rbp-10h]
v33 = a1;
v32 = a2;
v31 = a3;
if ( (ulight::`anonymous namespace'::Parser::peek(a1, 92LL) & 1) != 0
&& ((ulight::`anonymous namespace'::Parser::try_match_escaped(a1) & 1) != 0
|| (ulight::`anonymous namespace'::Parser::try_match_directive(a1) & 1) != 0) )
{
return 1;
}
v30 = *((_QWORD *)a1 + 3);
while ( !ulight::`anonymous namespace'::Parser::eof(a1) )
{
v29 = *(_BYTE *)std::u8string_view::operator[]((long long)a1 + 8, *((_QWORD *)a1 + 3));
if ( v29 == 92 )
{
*(_QWORD *)&v3 = std::u8string_view::substr((_QWORD *)a1 + 1, *((_QWORD *)a1 + 3) + 1LL, -1LL);
v28 = v3;
if ( !std::u8string_view::empty(&v28) )
{
v4 = (unsigned __int8 *)std::u8string_view::front((long long)&v28);
if ( (ulight::is_mmml_escapeable(*v4) & 1) != 0 )
break;
v25 = v28;
v5 = ulight::utf8::decode_and_length(v28, *((long long *)&v28 + 1));
v24 = v6;
v23 = v5;
v26 = v5;
v27 = v6;
v21 = 0;
if ( (std::expected<ulight::utf8::Code_Point_And_Length,ulight::utf8::Error_Code>::operator bool((long long)&v26) & 1) == 0 )
{
exception = (long long *)__cxa_allocate_exception(0x20uLL);
v22 = exception;
v21 = 1;
*(_BYTE *)exception = 0;
std::u8string_view::basic_string_view(exception + 1, (long long)"next_point");
exception[3] = (long long)off_29B70;
__cxa_throw(exception, (struct type_info *)&`typeinfo for'ulight::Assertion_Error, 0LL);
}
v7 = (unsigned int *)std::expected<ulight::utf8::Code_Point_And_Length,ulight::utf8::Error_Code>::operator->(&v26);
is_mmml_directive_name_character = ulight::is_mmml_directive_name_character(*v7);
if ( (is_mmml_directive_name_character & 1) != 0 )
break;
}
}
else if ( v32 )
{
if ( v32 == 1 )
{
if ( v29 == 44 )
break;
if ( v29 == 91 )
++*v31;
if ( v29 == 93 && !(*v31)-- )
break;
}
if ( v29 == 123 )
++v31[1];
if ( v29 == 125 )
{
v10 = v31[1];
v31[1] = v10 - 1;
if ( !v10 )
break;
}
}
++*((_QWORD *)a1 + 3);
}
v11 = *((_QWORD *)a1 + 3);
v19 = 0;
if ( v11 < v30 )
{
v14 = (long long *)__cxa_allocate_exception(0x20uLL);
v20 = v14;
v19 = 1;
*(_BYTE *)v14 = 0;
std::u8string_view::basic_string_view(v14 + 1, (long long)"m_pos >= initial_pos");
v14[3] = (long long)off_29B88;
__cxa_throw(v14, (struct type_info *)&`typeinfo for'ulight::Assertion_Error, 0LL);
}
if ( *((_QWORD *)a1 + 3) == v30 )
return 0;
v12 = *(_QWORD *)a1;
v17[0] = 2;
v18 = *((_QWORD *)a1 + 3) - v30;
std::vector<ulight::AST_Instruction,std::pmr::polymorphic_allocator<ulight::AST_Instruction>>::push_back(v12, v17);
return 1;
}
| try_match_content:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xc0
MOV AL,SIL
MOV qword ptr [RBP + -0x10],RDI
MOV byte ptr [RBP + -0x11],AL
MOV qword ptr [RBP + -0x20],RDX
MOV RDI,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0xa8],RDI
MOV ESI,0x5c
CALL 0x00115c10
TEST AL,0x1
JNZ 0x00115904
JMP 0x0011592f
LAB_00115904:
MOV RDI,qword ptr [RBP + -0xa8]
CALL 0x00115c70
TEST AL,0x1
JNZ 0x00115926
MOV RDI,qword ptr [RBP + -0xa8]
CALL 0x00115d30
TEST AL,0x1
JNZ 0x00115926
JMP 0x0011592f
LAB_00115926:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00115bf4
LAB_0011592f:
MOV RAX,qword ptr [RBP + -0xa8]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RBP + -0x28],RAX
LAB_0011593e:
MOV RDI,qword ptr [RBP + -0xa8]
CALL 0x00115780
XOR AL,0xff
TEST AL,0x1
JNZ 0x00115955
JMP 0x00115b39
LAB_00115955:
MOV RAX,qword ptr [RBP + -0xa8]
MOV RDI,RAX
ADD RDI,0x8
MOV RSI,qword ptr [RAX + 0x18]
CALL 0x0010b3a0
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x29],AL
MOVZX EAX,byte ptr [RBP + -0x29]
CMP EAX,0x5c
JNZ 0x00115a88
MOV RAX,qword ptr [RBP + -0xa8]
MOV RDI,RAX
ADD RDI,0x8
MOV RSI,qword ptr [RAX + 0x18]
ADD RSI,0x1
MOV RDX,-0x1
CALL 0x0010b1d0
MOV qword ptr [RBP + -0x40],RAX
MOV qword ptr [RBP + -0x38],RDX
LEA RDI,[RBP + -0x40]
CALL 0x0010b350
TEST AL,0x1
JNZ 0x001159b7
JMP 0x001159bc
LAB_001159b7:
JMP 0x00115b21
LAB_001159bc:
LEA RDI,[RBP + -0x40]
CALL 0x0010bcb0
MOVZX EDI,byte ptr [RAX]
CALL 0x00118100
TEST AL,0x1
JNZ 0x001159d3
JMP 0x001159d8
LAB_001159d3:
JMP 0x00115b39
LAB_001159d8:
MOVUPS XMM0,xmmword ptr [RBP + -0x40]
MOVAPS xmmword ptr [RBP + -0x60],XMM0
MOV RDI,qword ptr [RBP + -0x60]
MOV RSI,qword ptr [RBP + -0x58]
CALL 0x0010c040
MOV byte ptr [RBP + -0x68],DL
MOV qword ptr [RBP + -0x70],RAX
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RBP + -0x4c],RAX
MOV AL,byte ptr [RBP + -0x68]
MOV byte ptr [RBP + -0x44],AL
LEA RDI,[RBP + -0x4c]
CALL 0x0010c1e0
MOV byte ptr [RBP + -0x79],0x0
TEST AL,0x1
JNZ 0x00115a15
JMP 0x00115a17
LAB_00115a15:
JMP 0x00115a68
LAB_00115a17:
MOV EDI,0x20
CALL 0x001050a0
MOV RDI,RAX
MOV qword ptr [RBP + -0xb0],RDI
MOV qword ptr [RBP + -0x78],RDI
MOV byte ptr [RBP + -0x79],0x1
MOV byte ptr [RDI],0x0
ADD RDI,0x8
LEA RSI,[0x11c76c]
CALL 0x00106d80
MOV RDI,qword ptr [RBP + -0xb0]
LEA RAX,[0x129b70]
MOV qword ptr [RDI + 0x18],RAX
LEA RSI,[0x1285e0]
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001051d0
LAB_00115a68:
LEA RDI,[RBP + -0x4c]
CALL 0x00118160
MOV EDI,dword ptr [RAX]
CALL 0x00118140
TEST AL,0x1
JNZ 0x00115a7e
JMP 0x00115a83
LAB_00115a7e:
JMP 0x00115b39
LAB_00115a83:
JMP 0x00115b21
LAB_00115a88:
CMP byte ptr [RBP + -0x11],0x0
JNZ 0x00115a93
JMP 0x00115b21
LAB_00115a93:
CMP byte ptr [RBP + -0x11],0x1
JNZ 0x00115ae2
MOVZX EAX,byte ptr [RBP + -0x29]
CMP EAX,0x2c
JNZ 0x00115aa7
JMP 0x00115b39
LAB_00115aa7:
MOVZX EAX,byte ptr [RBP + -0x29]
CMP EAX,0x5b
JNZ 0x00115abe
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX]
ADD RCX,0x1
MOV qword ptr [RAX],RCX
LAB_00115abe:
MOVZX EAX,byte ptr [RBP + -0x29]
CMP EAX,0x5d
JNZ 0x00115ae0
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RCX]
MOV RDX,RAX
ADD RDX,-0x1
MOV qword ptr [RCX],RDX
CMP RAX,0x0
JNZ 0x00115ae0
JMP 0x00115b39
LAB_00115ae0:
JMP 0x00115ae2
LAB_00115ae2:
MOVZX EAX,byte ptr [RBP + -0x29]
CMP EAX,0x7b
JNZ 0x00115afb
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX + 0x8]
ADD RCX,0x1
MOV qword ptr [RAX + 0x8],RCX
LAB_00115afb:
MOVZX EAX,byte ptr [RBP + -0x29]
CMP EAX,0x7d
JNZ 0x00115b1f
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,RAX
ADD RDX,-0x1
MOV qword ptr [RCX + 0x8],RDX
CMP RAX,0x0
JNZ 0x00115b1f
JMP 0x00115b39
LAB_00115b1f:
JMP 0x00115b21
LAB_00115b21:
MOV RAX,qword ptr [RBP + -0xa8]
MOV RCX,qword ptr [RAX + 0x18]
ADD RCX,0x1
MOV qword ptr [RAX + 0x18],RCX
JMP 0x0011593e
LAB_00115b39:
MOV RAX,qword ptr [RBP + -0xa8]
MOV RAX,qword ptr [RAX + 0x18]
MOV RCX,qword ptr [RBP + -0x28]
MOV byte ptr [RBP + -0x89],0x0
CMP RAX,RCX
JC 0x00115b56
JMP 0x00115bad
LAB_00115b56:
MOV EDI,0x20
CALL 0x001050a0
MOV RDI,RAX
MOV qword ptr [RBP + -0xb8],RDI
MOV qword ptr [RBP + -0x88],RDI
MOV byte ptr [RBP + -0x89],0x1
MOV byte ptr [RDI],0x0
ADD RDI,0x8
LEA RSI,[0x11c7d8]
CALL 0x00106d80
MOV RDI,qword ptr [RBP + -0xb8]
LEA RAX,[0x129b88]
MOV qword ptr [RDI + 0x18],RAX
LEA RSI,[0x1285e0]
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001051d0
LAB_00115bad:
MOV RAX,qword ptr [RBP + -0xa8]
MOV RAX,qword ptr [RAX + 0x18]
CMP RAX,qword ptr [RBP + -0x28]
JNZ 0x00115bc4
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00115bf4
LAB_00115bc4:
MOV RAX,qword ptr [RBP + -0xa8]
MOV RDI,qword ptr [RAX]
MOV byte ptr [RBP + -0xa0],0x2
MOV RAX,qword ptr [RAX + 0x18]
SUB RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x98],RAX
LEA RSI,[RBP + -0xa0]
CALL 0x00117230
MOV byte ptr [RBP + -0x1],0x1
LAB_00115bf4:
MOV AL,byte ptr [RBP + -0x1]
AND AL,0x1
ADD RSP,0xc0
POP RBP
RET
|
/* ulight::(anonymous namespace)::Parser::try_match_content(ulight::(anonymous
namespace)::Content_Context, ulight::(anonymous namespace)::Parser::Bracket_Levels&) */
int1 __thiscall
ulight::(anonymous_namespace)::Parser::try_match_content(Parser *this,char param_2,long *param_3)
{
long lVar1;
int8 uVar2;
int8 uVar3;
byte bVar4;
bool bVar5;
ulong uVar6;
char *pcVar7;
uchar *puVar8;
wchar32 *pwVar9;
int1 *puVar10;
int1 extraout_DL;
int1 auVar11 [16];
AST_Instruction local_a8 [8];
long local_a0;
int1 local_91;
int1 *local_90;
int1 local_81;
int1 *local_80;
int8 local_78;
int1 local_70;
int4 local_68;
int4 uStack_64;
int4 uStack_60;
int4 uStack_5c;
int8 local_54;
int1 local_4c;
int1 local_48 [16];
char local_31;
ulong local_30;
long *local_28;
char local_19;
Parser *local_18;
int1 local_9;
local_28 = param_3;
local_19 = param_2;
local_18 = this;
uVar6 = peek(this,'\\');
if (((uVar6 & 1) == 0) ||
((uVar6 = try_match_escaped(this), (uVar6 & 1) == 0 &&
(uVar6 = try_match_directive(this), (uVar6 & 1) == 0)))) {
local_30 = *(ulong *)(this + 0x18);
while( true ) {
bVar4 = eof(this);
if (((bVar4 ^ 0xff) & 1) == 0) break;
pcVar7 = (char *)std::basic_string_view<char8_t,std::char_traits<char8_t>>::operator[]
((basic_string_view<char8_t,std::char_traits<char8_t>> *)(this + 8)
,*(ulong *)(this + 0x18));
local_31 = *pcVar7;
if (local_31 == '\\') {
auVar11 = std::basic_string_view<char8_t,std::char_traits<char8_t>>::substr
((basic_string_view<char8_t,std::char_traits<char8_t>> *)(this + 8),
*(long *)(this + 0x18) + 1,0xffffffffffffffff);
local_48 = auVar11;
uVar6 = std::basic_string_view<char8_t,std::char_traits<char8_t>>::empty
((basic_string_view<char8_t,std::char_traits<char8_t>> *)local_48);
if ((uVar6 & 1) == 0) {
puVar8 = (uchar *)std::basic_string_view<char8_t,std::char_traits<char8_t>>::front
((basic_string_view<char8_t,std::char_traits<char8_t>> *)
local_48);
uVar6 = is_mmml_escapeable(*puVar8);
uVar3 = local_48._8_8_;
uVar2 = local_48._0_8_;
if ((uVar6 & 1) != 0) break;
local_68 = local_48._0_4_;
uStack_64 = local_48._4_4_;
uStack_60 = local_48._8_4_;
uStack_5c = local_48._12_4_;
local_78 = utf8::decode_and_length((utf8 *)uVar2,uVar3);
local_70 = extraout_DL;
local_54 = local_78;
local_4c = extraout_DL;
bVar5 = std::expected::operator_cast_to_bool((expected *)&local_54);
local_81 = 0;
if (!bVar5) {
puVar10 = (int1 *)__cxa_allocate_exception(0x20);
local_81 = 1;
*puVar10 = 0;
local_80 = puVar10;
std::basic_string_view<char8_t,std::char_traits<char8_t>>::basic_string_view
((basic_string_view<char8_t,std::char_traits<char8_t>> *)(puVar10 + 8),
(uchar *)"next_point");
*(int ***)(puVar10 + 0x18) = &PTR_s__workspace_llm4binary_github2025_00129b70;
/* WARNING: Subroutine does not return */
__cxa_throw(puVar10,&Assertion_Error::typeinfo,0);
}
pwVar9 = (wchar32 *)
std::expected<ulight::utf8::Code_Point_And_Length,ulight::utf8::Error_Code>::
operator->((expected<ulight::utf8::Code_Point_And_Length,ulight::utf8::Error_Code>
*)&local_54);
uVar6 = is_mmml_directive_name_character(*pwVar9);
if ((uVar6 & 1) != 0) break;
}
}
else if (local_19 != '\0') {
if (local_19 == '\x01') {
if (local_31 == ',') break;
if (local_31 == '[') {
*local_28 = *local_28 + 1;
}
if ((local_31 == ']') && (lVar1 = *local_28, *local_28 = lVar1 + -1, lVar1 == 0)) break;
}
if (local_31 == '{') {
local_28[1] = local_28[1] + 1;
}
if ((local_31 == '}') && (lVar1 = local_28[1], local_28[1] = lVar1 + -1, lVar1 == 0)) break;
}
*(long *)(this + 0x18) = *(long *)(this + 0x18) + 1;
}
local_91 = 0;
if (*(ulong *)(this + 0x18) < local_30) {
puVar10 = (int1 *)__cxa_allocate_exception(0x20);
local_91 = 1;
*puVar10 = 0;
local_90 = puVar10;
std::basic_string_view<char8_t,std::char_traits<char8_t>>::basic_string_view
((basic_string_view<char8_t,std::char_traits<char8_t>> *)(puVar10 + 8),
(uchar *)"m_pos >= initial_pos");
*(int ***)(puVar10 + 0x18) = &PTR_s__workspace_llm4binary_github2025_00129b88;
/* WARNING: Subroutine does not return */
__cxa_throw(puVar10,&Assertion_Error::typeinfo,0);
}
if (*(ulong *)(this + 0x18) == local_30) {
local_9 = 0;
}
else {
local_a8[0] = (AST_Instruction)0x2;
local_a0 = *(long *)(this + 0x18) - local_30;
std::vector<ulight::AST_Instruction,std::pmr::polymorphic_allocator<ulight::AST_Instruction>>
::push_back(*(vector<ulight::AST_Instruction,std::pmr::polymorphic_allocator<ulight::AST_Instruction>>
**)this,local_a8);
local_9 = 1;
}
}
else {
local_9 = 1;
}
return local_9;
}
| |
53,911 | get_charsets_dir | eloqsql/mysys/charset.c | char *get_charsets_dir(char *buf)
{
const char *sharedir= SHAREDIR;
char *res;
DBUG_ENTER("get_charsets_dir");
if (charsets_dir != NULL)
strmake(buf, charsets_dir, FN_REFLEN-1);
else
{
if (test_if_hard_path(sharedir) ||
is_prefix(sharedir, DEFAULT_CHARSET_HOME))
strxmov(buf, sharedir, "/", CHARSET_DIR, NullS);
else
strxmov(buf, DEFAULT_CHARSET_HOME, "/", sharedir, "/", CHARSET_DIR,
NullS);
}
res= convert_dirname(buf,buf,NullS);
DBUG_PRINT("info",("charsets dir: '%s'", buf));
DBUG_RETURN(res);
} | O0 | c | get_charsets_dir:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x772cc(%rip), %rax # 0x15610f
movq %rax, -0x10(%rbp)
leaq 0xb9d0f2(%rip), %rax # 0xc7bf40
cmpq $0x0, (%rax)
je 0xdee6e
movq -0x8(%rbp), %rdi
leaq 0xb9d0e1(%rip), %rax # 0xc7bf40
movq (%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x1514b0
jmp 0xdeee8
movq -0x10(%rbp), %rdi
callq 0xf3b70
cmpl $0x0, %eax
jne 0xdee91
movq -0x10(%rbp), %rdi
leaq 0x772a1(%rip), %rsi # 0x156128
callq 0x14dd00
cmpl $0x0, %eax
je 0xdeeb5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x78707(%rip), %rdx # 0x1575a7
leaq 0x77294(%rip), %rcx # 0x15613b
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x151590
jmp 0xdeee6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
leaq 0x77264(%rip), %rsi # 0x156128
leaq 0x786dc(%rip), %r8 # 0x1575a7
leaq 0x77269(%rip), %r9 # 0x15613b
xorl %eax, %eax
movq %r8, %rdx
movq $0x0, (%rsp)
movb $0x0, %al
callq 0x151590
jmp 0xdeee8
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xe2e90
movq %rax, -0x18(%rbp)
jmp 0xdeeff
jmp 0xdef01
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| get_charsets_dir:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
lea rax, aHomeMonoInstal; "/home/mono/install/share"
mov [rbp+var_10], rax
lea rax, charsets_dir
cmp qword ptr [rax], 0
jz short loc_DEE6E
mov rdi, [rbp+var_8]
lea rax, charsets_dir
mov rsi, [rax]
mov edx, 1FFh
call strmake
jmp short loc_DEEE8
loc_DEE6E:
mov rdi, [rbp+var_10]
call test_if_hard_path
cmp eax, 0
jnz short loc_DEE91
mov rdi, [rbp+var_10]
lea rsi, aHomeMonoInstal_0; "/home/mono/install"
call is_prefix
cmp eax, 0
jz short loc_DEEB5
loc_DEE91:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
lea rdx, word_1575A7
lea rcx, aCharsets; "charsets/"
xor eax, eax
mov r8d, eax
mov al, 0
call strxmov
jmp short loc_DEEE6
loc_DEEB5:
mov rdi, [rbp+var_8]
mov rcx, [rbp+var_10]
lea rsi, aHomeMonoInstal_0; "/home/mono/install"
lea r8, word_1575A7
lea r9, aCharsets; "charsets/"
xor eax, eax
mov rdx, r8
mov [rsp+30h+var_30], 0
mov al, 0
call strxmov
loc_DEEE6:
jmp short $+2
loc_DEEE8:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_8]
xor eax, eax
mov edx, eax
call convert_dirname
mov [rbp+var_18], rax
jmp short $+2
loc_DEEFF:
jmp short $+2
loc_DEF01:
mov rax, [rbp+var_18]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
add rsp, 30h
pop rbp
retn
| long long get_charsets_dir(long long a1)
{
int v1; // r9d
if ( charsets_dir )
{
strmake(a1, charsets_dir, 511LL);
}
else if ( (unsigned int)test_if_hard_path("/home/mono/install/share")
|| (unsigned int)is_prefix("/home/mono/install/share", "/home/mono/install") )
{
strxmov(a1, (unsigned int)"/home/mono/install/share", (unsigned int)&word_1575A7, (unsigned int)"charsets/", 0, v1);
}
else
{
strxmov(
a1,
(unsigned int)"/home/mono/install",
(unsigned int)&word_1575A7,
(unsigned int)"/home/mono/install/share",
(unsigned int)&word_1575A7,
(unsigned int)"charsets/");
}
return convert_dirname(a1, a1, 0LL);
}
| get_charsets_dir:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
LEA RAX,[0x25610f]
MOV qword ptr [RBP + -0x10],RAX
LEA RAX,[0xd7bf40]
CMP qword ptr [RAX],0x0
JZ 0x001dee6e
MOV RDI,qword ptr [RBP + -0x8]
LEA RAX,[0xd7bf40]
MOV RSI,qword ptr [RAX]
MOV EDX,0x1ff
CALL 0x002514b0
JMP 0x001deee8
LAB_001dee6e:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001f3b70
CMP EAX,0x0
JNZ 0x001dee91
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x256128]
CALL 0x0024dd00
CMP EAX,0x0
JZ 0x001deeb5
LAB_001dee91:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
LEA RDX,[0x2575a7]
LEA RCX,[0x25613b]
XOR EAX,EAX
MOV R8D,EAX
MOV AL,0x0
CALL 0x00251590
JMP 0x001deee6
LAB_001deeb5:
MOV RDI,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x10]
LEA RSI,[0x256128]
LEA R8,[0x2575a7]
LEA R9,[0x25613b]
XOR EAX,EAX
MOV RDX,R8
MOV qword ptr [RSP],0x0
MOV AL,0x0
CALL 0x00251590
LAB_001deee6:
JMP 0x001deee8
LAB_001deee8:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x8]
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001e2e90
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001deeff
LAB_001deeff:
JMP 0x001def01
LAB_001def01:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RSP,0x30
POP RBP
RET
|
int8 get_charsets_dir(int8 param_1)
{
int iVar1;
int8 uVar2;
if (charsets_dir == 0) {
iVar1 = test_if_hard_path("/home/mono/install/share");
if ((iVar1 == 0) &&
(iVar1 = is_prefix("/home/mono/install/share","/home/mono/install"), iVar1 == 0)) {
strxmov(param_1,"/home/mono/install",&DAT_002575a7,"/home/mono/install/share",&DAT_002575a7,
"charsets/",0);
}
else {
strxmov(param_1,"/home/mono/install/share",&DAT_002575a7,"charsets/",0);
}
}
else {
strmake(param_1,charsets_dir,0x1ff);
}
uVar2 = convert_dirname(param_1,param_1,0);
return uVar2;
}
| |
53,912 | get_charsets_dir | eloqsql/mysys/charset.c | char *get_charsets_dir(char *buf)
{
const char *sharedir= SHAREDIR;
char *res;
DBUG_ENTER("get_charsets_dir");
if (charsets_dir != NULL)
strmake(buf, charsets_dir, FN_REFLEN-1);
else
{
if (test_if_hard_path(sharedir) ||
is_prefix(sharedir, DEFAULT_CHARSET_HOME))
strxmov(buf, sharedir, "/", CHARSET_DIR, NullS);
else
strxmov(buf, DEFAULT_CHARSET_HOME, "/", sharedir, "/", CHARSET_DIR,
NullS);
}
res= convert_dirname(buf,buf,NullS);
DBUG_PRINT("info",("charsets dir: '%s'", buf));
DBUG_RETURN(res);
} | O3 | c | get_charsets_dir:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xb6d231(%rip), %rax # 0xc02430
movq (%rax), %rsi
testq %rsi, %rsi
je 0x95216
movl $0x1ff, %edx # imm = 0x1FF
movq %rbx, %rdi
callq 0xd9de4
jmp 0x9525f
leaq 0x48eea(%rip), %rdi # 0xde107
callq 0xa149a
testl %eax, %eax
jne 0x9523d
leaq 0x48eda(%rip), %rdi # 0xde107
leaq 0x48eec(%rip), %rsi # 0xde120
callq 0xd84c4
testl %eax, %eax
je 0x95272
leaq 0x48ec3(%rip), %rsi # 0xde107
leaq 0x4a34d(%rip), %rdx # 0xdf598
leaq 0x48ee1(%rip), %rcx # 0xde133
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0xd9e3c
movq %rbx, %rdi
movq %rbx, %rsi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9765f
movq $0x0, (%rsp)
leaq 0x48e9f(%rip), %rsi # 0xde120
leaq 0x48e7f(%rip), %rcx # 0xde107
leaq 0x4a309(%rip), %rdx # 0xdf598
leaq 0x48e9d(%rip), %r9 # 0xde133
movq %rbx, %rdi
movq %rdx, %r8
xorl %eax, %eax
callq 0xd9e3c
jmp 0x9525f
| get_charsets_dir:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
lea rax, charsets_dir
mov rsi, [rax]
test rsi, rsi
jz short loc_95216
mov edx, 1FFh
mov rdi, rbx
call strmake
jmp short loc_9525F
loc_95216:
lea rdi, aHomeMonoInstal; "/home/mono/install/share"
call test_if_hard_path
test eax, eax
jnz short loc_9523D
lea rdi, aHomeMonoInstal; "/home/mono/install/share"
lea rsi, aHomeMonoInstal_0; "/home/mono/install"
call is_prefix
test eax, eax
jz short loc_95272
loc_9523D:
lea rsi, aHomeMonoInstal; "/home/mono/install/share"
lea rdx, unk_DF598
lea rcx, aCharsets; "charsets/"
mov rdi, rbx
xor r8d, r8d
xor eax, eax
call strxmov
loc_9525F:
mov rdi, rbx
mov rsi, rbx
xor edx, edx
add rsp, 8
pop rbx
pop rbp
jmp convert_dirname
loc_95272:
mov [rsp+10h+var_10], 0
lea rsi, aHomeMonoInstal_0; "/home/mono/install"
lea rcx, aHomeMonoInstal; "/home/mono/install/share"
lea rdx, unk_DF598
lea r9, aCharsets; "charsets/"
mov rdi, rbx
mov r8, rdx
xor eax, eax
call strxmov
jmp short loc_9525F
| long long get_charsets_dir(long long a1)
{
int v1; // r9d
if ( charsets_dir )
{
strmake(a1, charsets_dir, 511LL);
}
else if ( (unsigned int)test_if_hard_path("/home/mono/install/share")
|| (unsigned int)is_prefix("/home/mono/install/share", "/home/mono/install") )
{
strxmov(a1, (unsigned int)"/home/mono/install/share", (unsigned int)&unk_DF598, (unsigned int)"charsets/", 0, v1);
}
else
{
strxmov(
a1,
(unsigned int)"/home/mono/install",
(unsigned int)&unk_DF598,
(unsigned int)"/home/mono/install/share",
(unsigned int)&unk_DF598,
(unsigned int)"charsets/");
}
return convert_dirname(a1, a1, 0LL);
}
| get_charsets_dir:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
LEA RAX,[0xd02430]
MOV RSI,qword ptr [RAX]
TEST RSI,RSI
JZ 0x00195216
MOV EDX,0x1ff
MOV RDI,RBX
CALL 0x001d9de4
JMP 0x0019525f
LAB_00195216:
LEA RDI,[0x1de107]
CALL 0x001a149a
TEST EAX,EAX
JNZ 0x0019523d
LEA RDI,[0x1de107]
LEA RSI,[0x1de120]
CALL 0x001d84c4
TEST EAX,EAX
JZ 0x00195272
LAB_0019523d:
LEA RSI,[0x1de107]
LEA RDX,[0x1df598]
LEA RCX,[0x1de133]
MOV RDI,RBX
XOR R8D,R8D
XOR EAX,EAX
CALL 0x001d9e3c
LAB_0019525f:
MOV RDI,RBX
MOV RSI,RBX
XOR EDX,EDX
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x0019765f
LAB_00195272:
MOV qword ptr [RSP],0x0
LEA RSI,[0x1de120]
LEA RCX,[0x1de107]
LEA RDX,[0x1df598]
LEA R9,[0x1de133]
MOV RDI,RBX
MOV R8,RDX
XOR EAX,EAX
CALL 0x001d9e3c
JMP 0x0019525f
|
void get_charsets_dir(int8 param_1)
{
int iVar1;
if (charsets_dir == 0) {
iVar1 = test_if_hard_path("/home/mono/install/share");
if (iVar1 == 0) {
iVar1 = is_prefix("/home/mono/install/share","/home/mono/install");
if (iVar1 == 0) {
strxmov(param_1,"/home/mono/install",&DAT_001df598,"/home/mono/install/share",&DAT_001df598,
"charsets/",0);
goto LAB_0019525f;
}
}
strxmov(param_1,"/home/mono/install/share",&DAT_001df598,"charsets/",0);
}
else {
strmake(param_1,charsets_dir,0x1ff);
}
LAB_0019525f:
convert_dirname(param_1,param_1,0);
return;
}
| |
53,913 | my_hash_sort_utf16_nopad_bin | eloqsql/strings/ctype-ucs2.c | static void
my_hash_sort_utf16_nopad_bin(CHARSET_INFO *cs __attribute__((unused)),
const uchar *pos, size_t len,
ulong *nr1, ulong *nr2)
{
const uchar *end= pos + len;
register ulong m1= *nr1, m2= *nr2;
for ( ; pos < end ; pos++)
{
MY_HASH_ADD(m1, m2, (uint)*pos);
}
*nr1= m1;
*nr2= m2;
} | O3 | c | my_hash_sort_utf16_nopad_bin:
movq (%rcx), %rax
movq (%r8), %rdi
testq %rdx, %rdx
jle 0x4aa08
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 0x4a9dc
popq %rbp
movq %rax, (%rcx)
movq %rdi, (%r8)
retq
| my_hash_sort_utf16_nopad_bin:
mov rax, [rcx]
mov rdi, [r8]
test rdx, rdx
jle short loc_4AA08
push rbp
mov rbp, rsp
add rdx, rsi
loc_4A9DC:
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_4A9DC
pop rbp
loc_4AA08:
mov [rcx], rax
mov [r8], rdi
retn
| long long my_hash_sort_utf16_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_utf16_nopad_bin:
MOV RAX,qword ptr [RCX]
MOV RDI,qword ptr [R8]
TEST RDX,RDX
JLE 0x0014aa08
PUSH RBP
MOV RBP,RSP
ADD RDX,RSI
LAB_0014a9dc:
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 0x0014a9dc
POP RBP
LAB_0014aa08:
MOV qword ptr [RCX],RAX
MOV qword ptr [R8],RDI
RET
|
void my_hash_sort_utf16_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;
}
| |
53,914 | evmone::baseline::(anonymous namespace)::analyze_jumpdests(std::basic_string_view<unsigned char, evmc::byte_traits<unsigned char>>) | corpus-core[P]colibri-stateless/build_O0/_deps/evmone_external-src/lib/evmone/baseline_analysis.cpp | CodeAnalysis::JumpdestMap analyze_jumpdests(bytes_view code)
{
// To find if op is any PUSH opcode (OP_PUSH1 <= op <= OP_PUSH32)
// it can be noticed that OP_PUSH32 is INT8_MAX (0x7f) therefore
// static_cast<int8_t>(op) <= OP_PUSH32 is always true and can be skipped.
static_assert(OP_PUSH32 == std::numeric_limits<int8_t>::max());
CodeAnalysis::JumpdestMap map(code.size()); // Allocate and init bitmap with zeros.
for (size_t i = 0; i < code.size(); ++i)
{
const auto op = code[i];
if (static_cast<int8_t>(op) >= OP_PUSH1) // If any PUSH opcode (see explanation above).
i += op - size_t{OP_PUSH1 - 1}; // Skip PUSH data.
else if (INTX_UNLIKELY(op == OP_JUMPDEST))
map[i] = true;
}
return map;
} | O0 | cpp | evmone::baseline::(anonymous namespace)::analyze_jumpdests(std::basic_string_view<unsigned char, evmc::byte_traits<unsigned char>>):
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movb $0x0, -0x19(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3e5d0
movq %rax, -0x60(%rbp)
leaq -0x1a(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x7a230
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
callq 0x7a250
jmp 0x98663
leaq -0x1a(%rbp), %rdi
callq 0x7a290
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3e5d0
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jae 0x9874e
movq -0x38(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x694e0
movb (%rax), %al
movb %al, -0x39(%rbp)
movsbl -0x39(%rbp), %eax
cmpl $0x60, %eax
jl 0x986dc
movzbl -0x39(%rbp), %eax
subq $0x5f, %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x9873b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1a(%rbp), %rdi
callq 0x7a290
jmp 0x9876e
movzbl -0x39(%rbp), %eax
cmpl $0x5b, %eax
jne 0x98739
movq -0x68(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x7a4c0
movq %rdx, -0x88(%rbp)
movq %rax, -0x80(%rbp)
jmp 0x986ff
movq -0x88(%rbp), %rax
movq -0x80(%rbp), %rcx
movq %rcx, -0x50(%rbp)
movq %rax, -0x48(%rbp)
leaq -0x50(%rbp), %rdi
movl $0x1, %esi
callq 0x7a520
jmp 0x98739
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x71b70
jmp 0x9876e
jmp 0x9873b
jmp 0x9873d
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x98674
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x98761
movq -0x68(%rbp), %rdi
callq 0x71b70
movq -0x70(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x23320
nopw (%rax,%rax)
| _ZN6evmone8baseline12_GLOBAL__N_117analyze_jumpdestsESt17basic_string_viewIhN4evmc11byte_traitsIhEEE:
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_68], rdi
mov rax, rdi
mov [rbp+var_70], rax
mov [rbp+var_8], rdi
mov [rbp+var_18], rsi
mov [rbp+var_10], rdx
mov [rbp+var_19], 0
lea rdi, [rbp+var_18]
call _ZNKSt17basic_string_viewIhN4evmc11byte_traitsIhEEE4sizeEv; std::basic_string_view<uchar,evmc::byte_traits<uchar>>::size(void)
mov [rbp+var_60], rax
lea rdi, [rbp+var_1A]
mov [rbp+var_58], rdi
call _ZNSaIbEC2Ev; std::allocator<bool>::allocator(void)
mov rdi, [rbp+var_68]
mov rsi, [rbp+var_60]
mov rdx, [rbp+var_58]
call _ZNSt6vectorIbSaIbEEC2EmRKS0_; std::vector<bool>::vector(ulong,std::allocator<bool> const&)
jmp short $+2
loc_98663:
lea rdi, [rbp+var_1A]
call _ZNSaIbED2Ev; std::allocator<bool>::~allocator()
mov [rbp+var_38], 0
loc_98674:
mov rax, [rbp+var_38]
mov [rbp+var_78], rax
lea rdi, [rbp+var_18]
call _ZNKSt17basic_string_viewIhN4evmc11byte_traitsIhEEE4sizeEv; std::basic_string_view<uchar,evmc::byte_traits<uchar>>::size(void)
mov rcx, rax
mov rax, [rbp+var_78]
cmp rax, rcx
jnb loc_9874E
mov rsi, [rbp+var_38]
lea rdi, [rbp+var_18]
call _ZNKSt17basic_string_viewIhN4evmc11byte_traitsIhEEEixEm; std::basic_string_view<uchar,evmc::byte_traits<uchar>>::operator[](ulong)
mov al, [rax]
mov [rbp+var_39], al
movsx eax, [rbp+var_39]
cmp eax, 60h ; '`'
jl short loc_986DC
movzx eax, [rbp+var_39]
sub rax, 5Fh ; '_'
add rax, [rbp+var_38]
mov [rbp+var_38], rax
jmp short loc_9873B
mov rcx, rax
mov eax, edx
mov [rbp+var_28], rcx
mov [rbp+var_2C], eax
lea rdi, [rbp+var_1A]
call _ZNSaIbED2Ev; std::allocator<bool>::~allocator()
jmp loc_9876E
loc_986DC:
movzx eax, [rbp+var_39]
cmp eax, 5Bh ; '['
jnz short loc_98739
mov rdi, [rbp+var_68]
mov rsi, [rbp+var_38]
call _ZNSt6vectorIbSaIbEEixEm; std::vector<bool>::operator[](ulong)
mov [rbp+var_88], rdx
mov [rbp+var_80], rax
jmp short $+2
loc_986FF:
mov rax, [rbp+var_88]
mov rcx, [rbp+var_80]
mov [rbp+var_50], rcx
mov [rbp+var_48], rax
lea rdi, [rbp+var_50]
mov esi, 1
call _ZNSt14_Bit_referenceaSEb; std::_Bit_reference::operator=(bool)
jmp short loc_98739
mov rdi, [rbp+var_68]
mov rcx, rax
mov eax, edx
mov [rbp+var_28], rcx
mov [rbp+var_2C], eax
call _ZNSt6vectorIbSaIbEED2Ev; std::vector<bool>::~vector()
jmp short loc_9876E
loc_98739:
jmp short $+2
loc_9873B:
jmp short $+2
loc_9873D:
mov rax, [rbp+var_38]
add rax, 1
mov [rbp+var_38], rax
jmp loc_98674
loc_9874E:
mov [rbp+var_19], 1
test [rbp+var_19], 1
jnz short loc_98761
mov rdi, [rbp+var_68]
call _ZNSt6vectorIbSaIbEED2Ev; std::vector<bool>::~vector()
loc_98761:
mov rax, [rbp+var_70]
add rsp, 90h
pop rbp
retn
loc_9876E:
mov rdi, [rbp+var_28]
call __Unwind_Resume
| long long evmone::baseline::`anonymous namespace'::analyze_jumpdests(long long a1, long long a2, long long a3)
{
long long v3; // rdx
unsigned long long v5; // [rsp+18h] [rbp-78h]
long long v6; // [rsp+30h] [rbp-60h]
_QWORD v7[2]; // [rsp+40h] [rbp-50h] BYREF
unsigned __int8 v8; // [rsp+57h] [rbp-39h]
unsigned long long i; // [rsp+58h] [rbp-38h]
_BYTE v10[2]; // [rsp+76h] [rbp-1Ah] BYREF
_QWORD v11[3]; // [rsp+78h] [rbp-18h] BYREF
v11[2] = a1;
v11[0] = a2;
v11[1] = a3;
v10[1] = 0;
v6 = std::basic_string_view<unsigned char,evmc::byte_traits<unsigned char>>::size((long long)v11);
std::allocator<bool>::allocator((long long)v10);
std::vector<bool>::vector(a1, v6, (long long)v10);
std::allocator<bool>::~allocator();
for ( i = 0LL; ; ++i )
{
v5 = i;
if ( v5 >= std::basic_string_view<unsigned char,evmc::byte_traits<unsigned char>>::size((long long)v11) )
break;
v8 = *(_BYTE *)std::basic_string_view<unsigned char,evmc::byte_traits<unsigned char>>::operator[]((long long)v11, i);
if ( (char)v8 < 96 )
{
if ( v8 == 91 )
{
v7[0] = std::vector<bool>::operator[](a1, i);
v7[1] = v3;
std::_Bit_reference::operator=((long long)v7, 1);
}
}
else
{
i += v8 - 95LL;
}
}
return a1;
}
| analyze_jumpdests:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV qword ptr [RBP + -0x68],RDI
MOV RAX,RDI
MOV qword ptr [RBP + -0x70],RAX
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x10],RDX
MOV byte ptr [RBP + -0x19],0x0
LEA RDI,[RBP + -0x18]
CALL 0x0013e5d0
MOV qword ptr [RBP + -0x60],RAX
LEA RDI,[RBP + -0x1a]
MOV qword ptr [RBP + -0x58],RDI
CALL 0x0017a230
MOV RDI,qword ptr [RBP + -0x68]
MOV RSI,qword ptr [RBP + -0x60]
MOV RDX,qword ptr [RBP + -0x58]
LAB_0019865c:
CALL 0x0017a250
JMP 0x00198663
LAB_00198663:
LEA RDI,[RBP + -0x1a]
CALL 0x0017a290
MOV qword ptr [RBP + -0x38],0x0
LAB_00198674:
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x78],RAX
LEA RDI,[RBP + -0x18]
CALL 0x0013e5d0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x78]
CMP RAX,RCX
JNC 0x0019874e
MOV RSI,qword ptr [RBP + -0x38]
LEA RDI,[RBP + -0x18]
CALL 0x001694e0
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x39],AL
MOVSX EAX,byte ptr [RBP + -0x39]
CMP EAX,0x60
JL 0x001986dc
MOVZX EAX,byte ptr [RBP + -0x39]
SUB RAX,0x5f
ADD RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x38],RAX
JMP 0x0019873b
LAB_001986dc:
MOVZX EAX,byte ptr [RBP + -0x39]
CMP EAX,0x5b
JNZ 0x00198739
MOV RDI,qword ptr [RBP + -0x68]
MOV RSI,qword ptr [RBP + -0x38]
LAB_001986ed:
CALL 0x0017a4c0
LAB_001986f2:
MOV qword ptr [RBP + -0x88],RDX
MOV qword ptr [RBP + -0x80],RAX
JMP 0x001986ff
LAB_001986ff:
MOV RAX,qword ptr [RBP + -0x88]
MOV RCX,qword ptr [RBP + -0x80]
MOV qword ptr [RBP + -0x50],RCX
MOV qword ptr [RBP + -0x48],RAX
LEA RDI,[RBP + -0x50]
MOV ESI,0x1
CALL 0x0017a520
JMP 0x00198739
LAB_00198739:
JMP 0x0019873b
LAB_0019873b:
JMP 0x0019873d
LAB_0019873d:
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x1
MOV qword ptr [RBP + -0x38],RAX
JMP 0x00198674
LAB_0019874e:
MOV byte ptr [RBP + -0x19],0x1
TEST byte ptr [RBP + -0x19],0x1
JNZ 0x00198761
MOV RDI,qword ptr [RBP + -0x68]
CALL 0x00171b70
LAB_00198761:
MOV RAX,qword ptr [RBP + -0x70]
ADD RSP,0x90
POP RBP
RET
|
/* WARNING: Removing unreachable block (ram,0x00198758) */
/* evmone::baseline::(anonymous namespace)::analyze_jumpdests(std::basic_string_view<unsigned char,
evmc::byte_traits<unsigned char> >) */
vector<bool,std::allocator<bool>> *
evmone::baseline::(anonymous_namespace)::analyze_jumpdests
(vector<bool,std::allocator<bool>> *param_1,int8 param_2,int8 param_3)
{
ulong uVar1;
ulong uVar2;
byte *pbVar3;
int1 auVar4 [16];
int1 local_58 [16];
byte local_41;
ulong local_40;
allocator local_22;
int1 local_21;
int8 local_20;
int8 local_18;
vector<bool,std::allocator<bool>> *local_10;
local_21 = 0;
local_20 = param_2;
local_18 = param_3;
local_10 = param_1;
uVar1 = std::basic_string_view<unsigned_char,evmc::byte_traits<unsigned_char>>::size
((basic_string_view<unsigned_char,evmc::byte_traits<unsigned_char>> *)&local_20)
;
std::allocator<bool>::allocator();
/* try { // try from 0019865c to 00198660 has its CatchHandler @ 001986c2 */
std::vector<bool,std::allocator<bool>>::vector(param_1,uVar1,&local_22);
std::allocator<bool>::~allocator((allocator<bool> *)&local_22);
local_40 = 0;
while( true ) {
uVar1 = local_40;
uVar2 = std::basic_string_view<unsigned_char,evmc::byte_traits<unsigned_char>>::size
((basic_string_view<unsigned_char,evmc::byte_traits<unsigned_char>> *)
&local_20);
if (uVar2 <= uVar1) break;
pbVar3 = (byte *)std::basic_string_view<unsigned_char,evmc::byte_traits<unsigned_char>>::
operator[]((basic_string_view<unsigned_char,evmc::byte_traits<unsigned_char>> *
)&local_20,local_40);
local_41 = *pbVar3;
if ((char)local_41 < '`') {
if (local_41 == 0x5b) {
/* try { // try from 001986ed to 001986f1 has its CatchHandler @ 00198722 */
auVar4 = std::vector<bool,std::allocator<bool>>::operator[](param_1,local_40);
local_58 = auVar4;
std::_Bit_reference::operator=((_Bit_reference *)local_58,true);
}
}
else {
local_40 = ((ulong)local_41 - 0x5f) + local_40;
}
local_40 = local_40 + 1;
}
return param_1;
}
| |
53,915 | maria_page_crc_check_data | eloqsql/storage/maria/ma_pagecrc.c | my_bool maria_page_crc_check_data(int res, PAGECACHE_IO_HOOK_ARGS *args)
{
uchar *page= args->page;
pgcache_page_no_t page_no= args->pageno;
MARIA_SHARE *share= (MARIA_SHARE *)args->data;
if (res)
{
return 1;
}
return (maria_page_crc_check(page, (uint32) page_no, share,
MARIA_NO_CRC_NORMAL_PAGE,
share->block_size - CRC_SIZE));
} | O3 | c | maria_page_crc_check_data:
pushq %rbp
movq %rsp, %rbp
testl %edi, %edi
je 0x74c83
movb $0x1, %al
popq %rbp
retq
movq 0x10(%rsi), %rdx
movl 0x8(%rsi), %eax
movq (%rsi), %rdi
movl 0x7bc(%rdx), %r8d
addl $-0x4, %r8d
movq %rax, %rsi
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
popq %rbp
jmp 0x74b70
| maria_page_crc_check_data:
push rbp
mov rbp, rsp
test edi, edi
jz short loc_74C83
mov al, 1
pop rbp
retn
loc_74C83:
mov rdx, [rsi+10h]
mov eax, [rsi+8]
mov rdi, [rsi]
mov r8d, [rdx+7BCh]
add r8d, 0FFFFFFFCh
mov rsi, rax
mov ecx, 0FFFFFFFFh
pop rbp
jmp maria_page_crc_check
| char maria_page_crc_check_data(int a1, long long a2)
{
if ( a1 )
return 1;
else
return maria_page_crc_check(
*(_QWORD *)a2,
*(_DWORD *)(a2 + 8),
*(_QWORD *)(a2 + 16),
-1,
*(_DWORD *)(*(_QWORD *)(a2 + 16) + 1980LL) - 4);
}
| maria_page_crc_check_data:
PUSH RBP
MOV RBP,RSP
TEST EDI,EDI
JZ 0x00174c83
MOV AL,0x1
POP RBP
RET
LAB_00174c83:
MOV RDX,qword ptr [RSI + 0x10]
MOV EAX,dword ptr [RSI + 0x8]
MOV RDI,qword ptr [RSI]
MOV R8D,dword ptr [RDX + 0x7bc]
ADD R8D,-0x4
MOV RSI,RAX
MOV ECX,0xffffffff
POP RBP
JMP 0x00174b70
|
int8 maria_page_crc_check_data(int param_1,int8 *param_2)
{
int8 uVar1;
if (param_1 != 0) {
return 1;
}
uVar1 = maria_page_crc_check
(*param_2,*(int4 *)(param_2 + 1),param_2[2],0xffffffff,
*(int *)(param_2[2] + 0x7bc) + -4);
return uVar1;
}
| |
53,916 | my_seek | eloqsql/mysys/my_seek.c | my_off_t my_seek(File fd, my_off_t pos, int whence, myf MyFlags)
{
os_off_t newpos= -1;
DBUG_ENTER("my_seek");
DBUG_PRINT("my",("fd: %d Pos: %llu Whence: %d MyFlags: %lu",
fd, (ulonglong) pos, whence, MyFlags));
DBUG_ASSERT(pos != MY_FILEPOS_ERROR); /* safety check */
/*
Make sure we are using a valid file descriptor!
*/
DBUG_ASSERT(fd != -1);
#ifdef _WIN32
newpos= my_win_lseek(fd, pos, whence);
#else
newpos= lseek(fd, pos, whence);
#endif
if (newpos == (os_off_t) -1)
{
my_errno= errno;
if (MyFlags & MY_WME)
my_error(EE_CANT_SEEK, MYF(0), my_filename(fd), my_errno);
DBUG_PRINT("error", ("lseek: %llu errno: %d", (ulonglong) newpos, errno));
DBUG_RETURN(MY_FILEPOS_ERROR);
}
if ((my_off_t) newpos != pos)
{
DBUG_PRINT("exit",("pos: %llu", (ulonglong) newpos));
}
DBUG_RETURN((my_off_t) newpos);
} | O3 | c | my_seek:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movl %edi, %r14d
callq 0x29760
movq %rax, %rbx
cmpq $-0x1, %rax
jne 0xa0bd0
callq 0x297b0
movl (%rax), %r12d
callq 0xa1afa
movl %r12d, (%rax)
testb $0x10, %r15b
je 0xa0bd0
movl %r14d, %edi
callq 0xa8fd8
movq %rax, %r14
callq 0xa1afa
movl (%rax), %ecx
movl $0x21, %edi
xorl %esi, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x9e1af
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| my_seek:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov r15, rcx
mov r14d, edi
call _lseek64
mov rbx, rax
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_A0BD0
call ___errno_location
mov r12d, [rax]
call _my_thread_var
mov [rax], r12d
test r15b, 10h
jz short loc_A0BD0
mov edi, r14d
call my_filename
mov r14, rax
call _my_thread_var
mov ecx, [rax]
mov edi, 21h ; '!'
xor esi, esi
mov rdx, r14
xor eax, eax
call my_error
loc_A0BD0:
mov rax, rbx
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long my_seek(long long a1, const char *a2, long long a3, char a4)
{
long long v5; // rbx
int v6; // r12d
long long v7; // r14
unsigned int *v8; // rax
v5 = lseek64();
if ( v5 == -1 )
{
v6 = *(_DWORD *)__errno_location(a1);
*(_DWORD *)my_thread_var(a1, a2) = v6;
if ( (a4 & 0x10) != 0 )
{
v7 = my_filename((unsigned int)a1);
v8 = (unsigned int *)my_thread_var((unsigned int)a1, a2);
my_error(0x21u, 0LL, v7, *v8);
}
}
return v5;
}
| my_seek:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R15,RCX
MOV R14D,EDI
CALL 0x00129760
MOV RBX,RAX
CMP RAX,-0x1
JNZ 0x001a0bd0
CALL 0x001297b0
MOV R12D,dword ptr [RAX]
CALL 0x001a1afa
MOV dword ptr [RAX],R12D
TEST R15B,0x10
JZ 0x001a0bd0
MOV EDI,R14D
CALL 0x001a8fd8
MOV R14,RAX
CALL 0x001a1afa
MOV ECX,dword ptr [RAX]
MOV EDI,0x21
XOR ESI,ESI
MOV RDX,R14
XOR EAX,EAX
CALL 0x0019e1af
LAB_001a0bd0:
MOV RAX,RBX
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
__off64_t my_seek(int param_1,__off64_t param_2,int param_3,ulong param_4)
{
int iVar1;
__off64_t _Var2;
int *piVar3;
int8 uVar4;
int4 *puVar5;
_Var2 = lseek64(param_1,param_2,param_3);
if (_Var2 == -1) {
piVar3 = __errno_location();
iVar1 = *piVar3;
piVar3 = (int *)_my_thread_var();
*piVar3 = iVar1;
if ((param_4 & 0x10) != 0) {
uVar4 = my_filename(param_1);
puVar5 = (int4 *)_my_thread_var();
my_error(0x21,0,uVar4,*puVar5);
}
}
return _Var2;
}
| |
53,917 | mi_ft_segiterator_dummy_init | eloqsql/storage/myisam/ft_update.c | void _mi_ft_segiterator_dummy_init(const uchar *record, uint len,
FT_SEG_ITERATOR *ftsi)
{
DBUG_ENTER("_mi_ft_segiterator_dummy_init");
ftsi->num=1;
ftsi->seg=0;
ftsi->pos=record;
ftsi->len=len;
DBUG_VOID_RETURN;
} | O3 | c | mi_ft_segiterator_dummy_init:
pushq %rbp
movq %rsp, %rbp
movl $0x1, (%rdx)
movq $0x0, 0x8(%rdx)
movq %rdi, 0x18(%rdx)
movl %esi, 0x4(%rdx)
popq %rbp
retq
| _mi_ft_segiterator_dummy_init:
push rbp
mov rbp, rsp
mov dword ptr [rdx], 1
mov qword ptr [rdx+8], 0
mov [rdx+18h], rdi
mov [rdx+4], esi
pop rbp
retn
| void mi_ft_segiterator_dummy_init(long long a1, int a2, long long a3)
{
*(_DWORD *)a3 = 1;
*(_QWORD *)(a3 + 8) = 0LL;
*(_QWORD *)(a3 + 24) = a1;
*(_DWORD *)(a3 + 4) = a2;
}
| _mi_ft_segiterator_dummy_init:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RDX],0x1
MOV qword ptr [RDX + 0x8],0x0
MOV qword ptr [RDX + 0x18],RDI
MOV dword ptr [RDX + 0x4],ESI
POP RBP
RET
|
void _mi_ft_segiterator_dummy_init(int8 param_1,int4 param_2,int4 *param_3)
{
*param_3 = 1;
*(int8 *)(param_3 + 2) = 0;
*(int8 *)(param_3 + 6) = param_1;
param_3[1] = param_2;
return;
}
| |
53,918 | KeyCallback | csit-sgu[P]mit-game-2025-team-tyler/Libraries/raylib/src/platforms/rcore_desktop_glfw.c | static void KeyCallback(GLFWwindow *window, int key, int scancode, int action, int mods)
{
if (key < 0) return; // Security check, macOS fn key generates -1
// WARNING: GLFW could return GLFW_REPEAT, we need to consider it as 1
// to work properly with our implementation (IsKeyDown/IsKeyUp checks)
if (action == GLFW_RELEASE) CORE.Input.Keyboard.currentKeyState[key] = 0;
else if(action == GLFW_PRESS) CORE.Input.Keyboard.currentKeyState[key] = 1;
else if(action == GLFW_REPEAT) CORE.Input.Keyboard.keyRepeatInFrame[key] = 1;
// WARNING: Check if CAPS/NUM key modifiers are enabled and force down state for those keys
if (((key == KEY_CAPS_LOCK) && ((mods & GLFW_MOD_CAPS_LOCK) > 0)) ||
((key == KEY_NUM_LOCK) && ((mods & GLFW_MOD_NUM_LOCK) > 0))) CORE.Input.Keyboard.currentKeyState[key] = 1;
// Check if there is space available in the key queue
if ((CORE.Input.Keyboard.keyPressedQueueCount < MAX_KEY_PRESSED_QUEUE) && (action == GLFW_PRESS))
{
// Add character to the queue
CORE.Input.Keyboard.keyPressedQueue[CORE.Input.Keyboard.keyPressedQueueCount] = key;
CORE.Input.Keyboard.keyPressedQueueCount++;
}
// Check the exit key to set close window
if ((key == CORE.Input.Keyboard.exitKey) && (action == GLFW_PRESS)) glfwSetWindowShouldClose(platform.handle, GLFW_TRUE);
} | O3 | c | KeyCallback:
testl %esi, %esi
js 0x7183f
movl %ecx, %eax
movl %esi, %edx
cmpl $0x2, %ecx
ja 0x717b7
movl %eax, %ecx
leaq 0xc3439(%rip), %rdi # 0x134bd8
movq (%rdi,%rcx,8), %rdi
leal (,%rax,8), %ecx
movl $0x10100, %r9d # imm = 0x10100
shrl %cl, %r9d
movb %r9b, (%rdi,%rdx)
cmpl $0x118, %esi # imm = 0x118
sete %cl
movl %r8d, %edi
andl $0x10, %edi
shrl $0x4, %edi
testb %dil, %cl
jne 0x717e4
cmpl $0x11a, %esi # imm = 0x11A
setne %cl
testb $0x20, %r8b
sete %dil
orb %cl, %dil
jne 0x717f3
leaq 0xca3d5(%rip), %rcx # 0x13bbc0
movb $0x1, 0xc4(%rdx,%rcx)
movslq 0xcaaca(%rip), %rcx # 0x13c2c4
cmpq $0x10, %rcx
setge %dl
cmpl $0x1, %eax
setne %dil
orb %dl, %dil
jne 0x71821
leaq 0xca3ac(%rip), %rdx # 0x13bbc0
movl %esi, 0x6c4(%rdx,%rcx,4)
incl 0xcaaa3(%rip) # 0x13c2c4
cmpl $0x1, %eax
jne 0x7183f
cmpl %esi, 0xca454(%rip) # 0x13bc80
jne 0x7183f
movq 0xcae73(%rip), %rdi # 0x13c6a8
movl $0x1, %esi
jmp 0xc0ccf
retq
| KeyCallback:
test esi, esi
js locret_7183F
mov eax, ecx
mov edx, esi
cmp ecx, 2
ja short loc_717B7
mov ecx, eax
lea rdi, off_134BD8
mov rdi, [rdi+rcx*8]
lea ecx, ds:0[rax*8]
mov r9d, 10100h
shr r9d, cl
mov [rdi+rdx], r9b
loc_717B7:
cmp esi, 118h
setz cl
mov edi, r8d
and edi, 10h
shr edi, 4
test cl, dil
jnz short loc_717E4
cmp esi, 11Ah
setnz cl
test r8b, 20h
setz dil
or dil, cl
jnz short loc_717F3
loc_717E4:
lea rcx, CORE
mov byte ptr [rdx+rcx+0C4h], 1
loc_717F3:
movsxd rcx, cs:dword_13C2C4
cmp rcx, 10h
setnl dl
cmp eax, 1
setnz dil
or dil, dl
jnz short loc_71821
lea rdx, CORE
mov [rdx+rcx*4+6C4h], esi
inc cs:dword_13C2C4
loc_71821:
cmp eax, 1
jnz short locret_7183F
cmp cs:dword_13BC80, esi
jnz short locret_7183F
mov rdi, cs:platform_0
mov esi, 1
jmp glfwSetWindowShouldClose
locret_7183F:
retn
| void KeyCallback(long long a1, int a2, long long a3, unsigned int a4, char a5)
{
if ( a2 >= 0 )
{
if ( a4 <= 2 )
*((_BYTE *)*(&off_134BD8 + a4) + (unsigned int)a2) = 0x10100u >> (8 * a4);
if ( (((unsigned __int8)(a5 & 0x10) >> 4) & (a2 == 280)) != 0 || a2 == 282 && (a5 & 0x20) != 0 )
*((_BYTE *)&CORE[24] + (unsigned int)a2 + 4) = 1;
if ( dword_13C2C4 < 16LL && a4 == 1 )
*((_DWORD *)&CORE[216] + ++dword_13C2C4) = a2;
if ( a4 == 1 && dword_13BC80 == a2 )
glfwSetWindowShouldClose(platform_0, 1LL);
}
}
| KeyCallback:
TEST ESI,ESI
JS 0x0017183f
MOV EAX,ECX
MOV EDX,ESI
CMP ECX,0x2
JA 0x001717b7
MOV ECX,EAX
LEA RDI,[0x234bd8]
MOV RDI,qword ptr [RDI + RCX*0x8]
LEA ECX,[RAX*0x8]
MOV R9D,0x10100
SHR R9D,CL
MOV byte ptr [RDI + RDX*0x1],R9B
LAB_001717b7:
CMP ESI,0x118
SETZ CL
MOV EDI,R8D
AND EDI,0x10
SHR EDI,0x4
TEST CL,DIL
JNZ 0x001717e4
CMP ESI,0x11a
SETNZ CL
TEST R8B,0x20
SETZ DIL
OR DIL,CL
JNZ 0x001717f3
LAB_001717e4:
LEA RCX,[0x23bbc0]
MOV byte ptr [RDX + RCX*0x1 + 0xc4],0x1
LAB_001717f3:
MOVSXD RCX,dword ptr [0x0023c2c4]
CMP RCX,0x10
SETGE DL
CMP EAX,0x1
SETNZ DIL
OR DIL,DL
JNZ 0x00171821
LEA RDX,[0x23bbc0]
MOV dword ptr [RDX + RCX*0x4 + 0x6c4],ESI
INC dword ptr [0x0023c2c4]
LAB_00171821:
CMP EAX,0x1
JNZ 0x0017183f
CMP dword ptr [0x0023bc80],ESI
JNZ 0x0017183f
MOV RDI,qword ptr [0x0023c6a8]
MOV ESI,0x1
JMP 0x001c0ccf
LAB_0017183f:
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void KeyCallback(int8 param_1,uint param_2,int8 param_3,uint param_4,uint param_5)
{
if (-1 < (int)param_2) {
if (param_4 < 3) {
(&PTR_DAT_00234bd8)[param_4][param_2] = (char)(0x10100 >> ((char)param_4 * '\b' & 0x1fU));
}
if (((param_2 == 0x118 & (byte)((param_5 & 0x10) >> 4)) != 0) ||
((param_5 & 0x20) != 0 && param_2 == 0x11a)) {
(&DAT_0023bc84)[param_2] = 1;
}
if (param_4 == 1 && (long)_DAT_0023c2c4 < 0x10) {
*(uint *)(&DAT_0023c284 + (long)_DAT_0023c2c4 * 4) = param_2;
_DAT_0023c2c4 = _DAT_0023c2c4 + 1;
}
if ((param_4 == 1) && (_DAT_0023bc80 == param_2)) {
glfwSetWindowShouldClose(platform_0,1);
return;
}
}
return;
}
| |
53,919 | ma_bitmap_delete_all | eloqsql/storage/maria/ma_bitmap.c | void _ma_bitmap_delete_all(MARIA_SHARE *share)
{
MARIA_FILE_BITMAP *bitmap= &share->bitmap;
DBUG_ENTER("_ma_bitmap_delete_all");
if (bitmap->map) /* Not in create */
{
bzero(bitmap->map, bitmap->block_size);
bitmap->changed= 1;
bitmap->page= 0;
bitmap->used_size= bitmap->full_tail_size= bitmap->full_head_size= 0;
bitmap->total_size= bitmap->max_total_size;
}
DBUG_VOID_RETURN;
} | O3 | c | ma_bitmap_delete_all:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xa18(%rdi), %rdi
testq %rdi, %rdi
je 0x3fe49
movl 0xb44(%rbx), %edx
xorl %r14d, %r14d
xorl %esi, %esi
callq 0x292c0
movb $0x1, 0xa30(%rbx)
movq %r14, 0xa20(%rbx)
movl $0x0, 0xa3c(%rbx)
movq %r14, 0xa34(%rbx)
movl 0xb3c(%rbx), %eax
movl %eax, 0xb38(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
| _ma_bitmap_delete_all:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdi
mov rdi, [rdi+0A18h]
test rdi, rdi
jz short loc_3FE49
mov edx, [rbx+0B44h]
xor r14d, r14d
xor esi, esi
call _memset
mov byte ptr [rbx+0A30h], 1
mov [rbx+0A20h], r14
mov dword ptr [rbx+0A3Ch], 0
mov [rbx+0A34h], r14
mov eax, [rbx+0B3Ch]
mov [rbx+0B38h], eax
loc_3FE49:
pop rbx
pop r14
pop rbp
retn
| long long ma_bitmap_delete_all(long long a1)
{
long long v2; // rdi
long long result; // rax
v2 = *(_QWORD *)(a1 + 2584);
if ( v2 )
{
memset(v2, 0LL, *(unsigned int *)(a1 + 2884));
*(_BYTE *)(a1 + 2608) = 1;
*(_QWORD *)(a1 + 2592) = 0LL;
*(_DWORD *)(a1 + 2620) = 0;
*(_QWORD *)(a1 + 2612) = 0LL;
result = *(unsigned int *)(a1 + 2876);
*(_DWORD *)(a1 + 2872) = result;
}
return result;
}
| _ma_bitmap_delete_all:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0xa18]
TEST RDI,RDI
JZ 0x0013fe49
MOV EDX,dword ptr [RBX + 0xb44]
XOR R14D,R14D
XOR ESI,ESI
CALL 0x001292c0
MOV byte ptr [RBX + 0xa30],0x1
MOV qword ptr [RBX + 0xa20],R14
MOV dword ptr [RBX + 0xa3c],0x0
MOV qword ptr [RBX + 0xa34],R14
MOV EAX,dword ptr [RBX + 0xb3c]
MOV dword ptr [RBX + 0xb38],EAX
LAB_0013fe49:
POP RBX
POP R14
POP RBP
RET
|
void _ma_bitmap_delete_all(long param_1)
{
if (*(void **)(param_1 + 0xa18) != (void *)0x0) {
memset(*(void **)(param_1 + 0xa18),0,(ulong)*(uint *)(param_1 + 0xb44));
*(int1 *)(param_1 + 0xa30) = 1;
*(int8 *)(param_1 + 0xa20) = 0;
*(int4 *)(param_1 + 0xa3c) = 0;
*(int8 *)(param_1 + 0xa34) = 0;
*(int4 *)(param_1 + 0xb38) = *(int4 *)(param_1 + 0xb3c);
}
return;
}
| |
53,920 | lo0bits | eloqsql/strings/dtoa.c | static int lo0bits(ULong *y)
{
register int k;
register ULong x= *y;
if (x & 7)
{
if (x & 1)
return 0;
if (x & 2)
{
*y= x >> 1;
return 1;
}
*y= x >> 2;
return 2;
}
k= 0;
if (!(x & 0xffff))
{
k= 16;
x>>= 16;
}
if (!(x & 0xff))
{
k+= 8;
x>>= 8;
}
if (!(x & 0xf))
{
k+= 4;
x>>= 4;
}
if (!(x & 0x3))
{
k+= 2;
x>>= 2;
}
if (!(x & 1))
{
k++;
x>>= 1;
if (!x)
return 32;
}
*y= x;
return k;
} | O0 | c | lo0bits:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
andl $0x7, %eax
cmpl $0x0, %eax
je 0x79cdd
movl -0x18(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x79ca3
movl $0x0, -0x4(%rbp)
jmp 0x79d96
movl -0x18(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x79cc5
movl -0x18(%rbp), %ecx
shrl %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x79d96
movl -0x18(%rbp), %ecx
shrl $0x2, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl $0x2, -0x4(%rbp)
jmp 0x79d96
movl $0x0, -0x14(%rbp)
movl -0x18(%rbp), %eax
andl $0xffff, %eax # imm = 0xFFFF
cmpl $0x0, %eax
jne 0x79d01
movl $0x10, -0x14(%rbp)
movl -0x18(%rbp), %eax
shrl $0x10, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
andl $0xff, %eax
cmpl $0x0, %eax
jne 0x79d20
movl -0x14(%rbp), %eax
addl $0x8, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
shrl $0x8, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
andl $0xf, %eax
cmpl $0x0, %eax
jne 0x79d3d
movl -0x14(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
shrl $0x4, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0x79d5a
movl -0x14(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
shrl $0x2, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x79d87
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
shrl %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x79d85
movl $0x20, -0x4(%rbp)
jmp 0x79d96
jmp 0x79d87
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
| lo0bits:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov eax, [rax]
mov [rbp+var_18], eax
mov eax, [rbp+var_18]
and eax, 7
cmp eax, 0
jz short loc_79CDD
mov eax, [rbp+var_18]
and eax, 1
cmp eax, 0
jz short loc_79CA3
mov [rbp+var_4], 0
jmp loc_79D96
loc_79CA3:
mov eax, [rbp+var_18]
and eax, 2
cmp eax, 0
jz short loc_79CC5
mov ecx, [rbp+var_18]
shr ecx, 1
mov rax, [rbp+var_10]
mov [rax], ecx
mov [rbp+var_4], 1
jmp loc_79D96
loc_79CC5:
mov ecx, [rbp+var_18]
shr ecx, 2
mov rax, [rbp+var_10]
mov [rax], ecx
mov [rbp+var_4], 2
jmp loc_79D96
loc_79CDD:
mov [rbp+var_14], 0
mov eax, [rbp+var_18]
and eax, 0FFFFh
cmp eax, 0
jnz short loc_79D01
mov [rbp+var_14], 10h
mov eax, [rbp+var_18]
shr eax, 10h
mov [rbp+var_18], eax
loc_79D01:
mov eax, [rbp+var_18]
and eax, 0FFh
cmp eax, 0
jnz short loc_79D20
mov eax, [rbp+var_14]
add eax, 8
mov [rbp+var_14], eax
mov eax, [rbp+var_18]
shr eax, 8
mov [rbp+var_18], eax
loc_79D20:
mov eax, [rbp+var_18]
and eax, 0Fh
cmp eax, 0
jnz short loc_79D3D
mov eax, [rbp+var_14]
add eax, 4
mov [rbp+var_14], eax
mov eax, [rbp+var_18]
shr eax, 4
mov [rbp+var_18], eax
loc_79D3D:
mov eax, [rbp+var_18]
and eax, 3
cmp eax, 0
jnz short loc_79D5A
mov eax, [rbp+var_14]
add eax, 2
mov [rbp+var_14], eax
mov eax, [rbp+var_18]
shr eax, 2
mov [rbp+var_18], eax
loc_79D5A:
mov eax, [rbp+var_18]
and eax, 1
cmp eax, 0
jnz short loc_79D87
mov eax, [rbp+var_14]
add eax, 1
mov [rbp+var_14], eax
mov eax, [rbp+var_18]
shr eax, 1
mov [rbp+var_18], eax
cmp [rbp+var_18], 0
jnz short loc_79D85
mov [rbp+var_4], 20h ; ' '
jmp short loc_79D96
loc_79D85:
jmp short $+2
loc_79D87:
mov ecx, [rbp+var_18]
mov rax, [rbp+var_10]
mov [rax], ecx
mov eax, [rbp+var_14]
mov [rbp+var_4], eax
loc_79D96:
mov eax, [rbp+var_4]
pop rbp
retn
| long long lo0bits(unsigned int *a1)
{
unsigned int v2; // [rsp+0h] [rbp-18h]
unsigned int v3; // [rsp+4h] [rbp-14h]
v2 = *a1;
if ( (*a1 & 7) != 0 )
{
if ( (v2 & 1) != 0 )
{
return 0;
}
else if ( (v2 & 2) != 0 )
{
*a1 = v2 >> 1;
return 1;
}
else
{
*a1 = v2 >> 2;
return 2;
}
}
else
{
v3 = 0;
if ( !(_WORD)v2 )
{
v3 = 16;
v2 >>= 16;
}
if ( !(_BYTE)v2 )
{
v3 += 8;
v2 >>= 8;
}
if ( (v2 & 0xF) == 0 )
{
v3 += 4;
v2 >>= 4;
}
if ( (v2 & 3) == 0 )
{
v3 += 2;
v2 >>= 2;
}
if ( (v2 & 1) != 0 || (++v3, (v2 >>= 1) != 0) )
{
*a1 = v2;
return v3;
}
else
{
return 32;
}
}
}
| lo0bits:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x18],EAX
MOV EAX,dword ptr [RBP + -0x18]
AND EAX,0x7
CMP EAX,0x0
JZ 0x00179cdd
MOV EAX,dword ptr [RBP + -0x18]
AND EAX,0x1
CMP EAX,0x0
JZ 0x00179ca3
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00179d96
LAB_00179ca3:
MOV EAX,dword ptr [RBP + -0x18]
AND EAX,0x2
CMP EAX,0x0
JZ 0x00179cc5
MOV ECX,dword ptr [RBP + -0x18]
SHR ECX,0x1
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],ECX
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00179d96
LAB_00179cc5:
MOV ECX,dword ptr [RBP + -0x18]
SHR ECX,0x2
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],ECX
MOV dword ptr [RBP + -0x4],0x2
JMP 0x00179d96
LAB_00179cdd:
MOV dword ptr [RBP + -0x14],0x0
MOV EAX,dword ptr [RBP + -0x18]
AND EAX,0xffff
CMP EAX,0x0
JNZ 0x00179d01
MOV dword ptr [RBP + -0x14],0x10
MOV EAX,dword ptr [RBP + -0x18]
SHR EAX,0x10
MOV dword ptr [RBP + -0x18],EAX
LAB_00179d01:
MOV EAX,dword ptr [RBP + -0x18]
AND EAX,0xff
CMP EAX,0x0
JNZ 0x00179d20
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x8
MOV dword ptr [RBP + -0x14],EAX
MOV EAX,dword ptr [RBP + -0x18]
SHR EAX,0x8
MOV dword ptr [RBP + -0x18],EAX
LAB_00179d20:
MOV EAX,dword ptr [RBP + -0x18]
AND EAX,0xf
CMP EAX,0x0
JNZ 0x00179d3d
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x4
MOV dword ptr [RBP + -0x14],EAX
MOV EAX,dword ptr [RBP + -0x18]
SHR EAX,0x4
MOV dword ptr [RBP + -0x18],EAX
LAB_00179d3d:
MOV EAX,dword ptr [RBP + -0x18]
AND EAX,0x3
CMP EAX,0x0
JNZ 0x00179d5a
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x2
MOV dword ptr [RBP + -0x14],EAX
MOV EAX,dword ptr [RBP + -0x18]
SHR EAX,0x2
MOV dword ptr [RBP + -0x18],EAX
LAB_00179d5a:
MOV EAX,dword ptr [RBP + -0x18]
AND EAX,0x1
CMP EAX,0x0
JNZ 0x00179d87
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
MOV EAX,dword ptr [RBP + -0x18]
SHR EAX,0x1
MOV dword ptr [RBP + -0x18],EAX
CMP dword ptr [RBP + -0x18],0x0
JNZ 0x00179d85
MOV dword ptr [RBP + -0x4],0x20
JMP 0x00179d96
LAB_00179d85:
JMP 0x00179d87
LAB_00179d87:
MOV ECX,dword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],ECX
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x4],EAX
LAB_00179d96:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int lo0bits(uint *param_1)
{
uint local_20;
int local_1c;
int local_c;
local_20 = *param_1;
if ((local_20 & 7) == 0) {
local_1c = 0;
if ((local_20 & 0xffff) == 0) {
local_1c = 0x10;
local_20 = local_20 >> 0x10;
}
if ((local_20 & 0xff) == 0) {
local_1c = local_1c + 8;
local_20 = local_20 >> 8;
}
if ((local_20 & 0xf) == 0) {
local_1c = local_1c + 4;
local_20 = local_20 >> 4;
}
if ((local_20 & 3) == 0) {
local_1c = local_1c + 2;
local_20 = local_20 >> 2;
}
if ((local_20 & 1) == 0) {
local_1c = local_1c + 1;
local_20 = local_20 >> 1;
if (local_20 == 0) {
return 0x20;
}
}
*param_1 = local_20;
local_c = local_1c;
}
else if ((local_20 & 1) == 0) {
if ((local_20 & 2) == 0) {
*param_1 = local_20 >> 2;
local_c = 2;
}
else {
*param_1 = local_20 >> 1;
local_c = 1;
}
}
else {
local_c = 0;
}
return local_c;
}
| |
53,921 | process_str_arg | eloqsql/strings/my_vsnprintf.c | static char *process_str_arg(CHARSET_INFO *cs, char *to, const char *end,
longlong length_arg, size_t width, char *par,
uint print_type, my_bool nice_cut)
{
int well_formed_error;
uint dots= 0;
size_t plen, left_len= (size_t) (end - to) + 1, slen=0;
my_bool left_fill= 1;
size_t length;
/*
The sign of the length argument specific the string should be right
or left adjusted
*/
if (length_arg < 0)
{
length= (size_t) -length_arg;
left_fill= 0;
}
else
length= (size_t) length_arg;
if (!par)
par = (char*) "(null)";
if (nice_cut)
{
plen= slen= strnlen(par, width + 1);
if (plen > width)
plen= width;
if (left_len <= plen)
{
plen = left_len - 1;
length= plen;
}
if ((slen > plen))
{
if (plen < 3)
{
dots= (uint) plen;
plen= 0;
}
else
{
dots= 3;
plen-= 3;
}
}
}
else
{
plen= slen= strnlen(par, width);
dots= 0;
if (left_len <= plen)
{
plen = left_len - 1;
length= plen;
}
}
plen= my_well_formed_length(cs, par, par + plen, width, &well_formed_error);
if (print_type & ESCAPED_ARG)
{
const char *org_to= to;
to= backtick_string(cs, to, end, par, plen + dots, '`', MY_TEST(dots));
plen= (size_t) (to - org_to);
dots= 0;
}
else
{
if (left_fill)
{
if (plen + dots < length)
to= strfill(to, length - plen - dots, ' ');
}
to= strnmov(to,par,plen);
if (dots)
to= strfill(to, dots, '.');
}
if (!left_fill && plen + dots < length)
to= strfill(to, length - plen - dots, ' ');
return to;
} | O3 | c | process_str_arg:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r15
movq %rdi, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
movq %rdx, %r14
movq %rsi, -0x38(%rbp)
subq %rsi, %r14
leaq 0x1(%r14), %rbx
movq %rcx, %r13
negq %r13
movq %rcx, -0x40(%rbp)
cmovsq %rcx, %r13
testq %r9, %r9
leaq 0x8719(%rip), %r12 # 0xdefdb
cmovneq %r9, %r12
cmpb $0x0, 0x18(%rbp)
je 0xd690a
leaq 0x1(%r15), %rsi
movq %r12, %rdi
callq 0x29510
cmpq %r15, %rax
movq %r15, %rdx
cmovbq %rax, %rdx
cmpq %rdx, %rbx
cmovbeq %r14, %rdx
cmovbeq %r14, %r13
movl $0x0, -0x2c(%rbp)
cmpq %rdx, %rax
movq %r13, -0x48(%rbp)
jbe 0xd693b
cmpq $0x2, %rdx
ja 0xd6930
movl %edx, -0x2c(%rbp)
xorl %edx, %edx
jmp 0xd693b
movq %r12, %rdi
movq %r15, %rsi
callq 0x29510
movq %rax, %rdx
cmpq %rax, %rbx
cmovbeq %r14, %rdx
cmovbeq %r14, %r13
movq %r13, -0x48(%rbp)
movl $0x0, -0x2c(%rbp)
jmp 0xd693b
addq $-0x3, %rdx
movl $0x3, -0x2c(%rbp)
addq %r12, %rdx
movq -0x58(%rbp), %rdi
movq 0xb8(%rdi), %rax
leaq -0x70(%rbp), %rbx
movq %r12, %rsi
movq %r15, %rcx
movq %rbx, %r8
callq *0xc8(%rax)
movq (%rbx), %r13
subq %r12, %r13
movl 0x10(%rbp), %eax
testb $0x8, %al
jne 0xd69a3
movq -0x40(%rbp), %rbx
testq %rbx, %rbx
js 0xd6a76
movl -0x2c(%rbp), %r14d
movl %r14d, %eax
addq %r13, %rax
movq -0x48(%rbp), %rsi
subq %rax, %rsi
jbe 0xd6a80
movq -0x38(%rbp), %rdi
movl $0x20, %edx
callq 0xd71a8
movq %rax, %rdi
jmp 0xd6a84
movl -0x2c(%rbp), %eax
addq %rax, %r13
xorps %xmm0, %xmm0
movaps %xmm0, -0x70(%rbp)
movq $0x0, -0x60(%rbp)
cmpq %r13, %r14
jbe 0xd6b00
movq -0x38(%rbp), %rax
leaq 0x1(%rax), %r15
movb $0x60, (%rax)
testq %r13, %r13
jle 0xd6aaf
addq %r12, %r13
xorl %r14d, %r14d
cmpl $0x0, -0x2c(%rbp)
je 0xd6a06
movl %r14d, %eax
movq %r15, -0x70(%rbp,%rax,8)
movl %r14d, %eax
incl %eax
movl $0xaaaaaaab, %ecx # imm = 0xAAAAAAAB
imulq %rcx, %rax
shrq $0x21, %rax
leal (%rax,%rax,2), %eax
negl %eax
addl %eax, %r14d
incl %r14d
movb (%r12), %bl
movq -0x58(%rbp), %rdi
movq 0xb8(%rdi), %rax
movq %r12, %rsi
movq %r13, %rdx
callq *0xc0(%rax)
cmpl $0x2, %eax
movl $0x1, %ecx
cmovll %ecx, %eax
jge 0xd6a47
cmpb $0x60, %bl
jne 0xd6a47
leaq 0x1(%r15), %rdi
cmpq -0x50(%rbp), %rdi
jae 0xd6b00
movb $0x60, (%r15)
jmp 0xd6a4a
movq %r15, %rdi
movl %eax, %ebx
leaq (%rdi,%rbx), %rax
cmpq -0x50(%rbp), %rax
jae 0xd6b00
movq %r12, %rsi
movq %rbx, %rdx
callq 0xd7208
movq %rax, %r15
addq %rbx, %r12
cmpq %r13, %r12
jb 0xd69db
jmp 0xd6ab2
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %r14d
jmp 0xd6a84
movq -0x38(%rbp), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xd7208
movq %rax, %r15
testl %r14d, %r14d
je 0xd6b14
movl %r14d, %r14d
movq %r15, %rdi
movq %r14, %rsi
movl $0x2e, %edx
callq 0xd71a8
movq %rax, %r15
jmp 0xd6b17
xorl %r14d, %r14d
leaq 0x1(%r15), %rax
cmpq -0x50(%rbp), %rax
jae 0xd6b00
cmpl $0x0, -0x2c(%rbp)
je 0xd6b62
subl $0x1, %r14d
movl $0x2, %eax
cmovbl %eax, %r14d
movq -0x70(%rbp,%r14,8), %rdx
testq %rdx, %rdx
je 0xd6b00
movl $0x1, %ecx
subl $0x1, %r14d
cmovbl %eax, %r14d
movq -0x70(%rbp,%r14,8), %r15
testq %r15, %r15
je 0xd6b4a
incl %ecx
movq %r15, %rdx
cmpl $0x3, %ecx
jne 0xd6ae2
jmp 0xd6b4d
movq -0x38(%rbp), %rax
movb $0x0, (%rax)
movq %rax, %r15
movq -0x40(%rbp), %rbx
movq %r15, %r13
subq %rax, %r13
xorl %r14d, %r14d
testq %rbx, %rbx
jns 0xd6b38
addq %r14, %r13
movq -0x48(%rbp), %rsi
subq %r13, %rsi
jbe 0xd6b38
movq %r15, %rdi
movl $0x20, %edx
callq 0xd71a8
movq %rax, %r15
movq %r15, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r15
movl %ecx, %ebx
movq %r15, %rdi
movl $0x2e, %esi
movq %rbx, %rdx
callq 0x292c0
addq %rbx, %r15
movb $0x60, (%r15)
incq %r15
movq -0x40(%rbp), %rbx
movq -0x38(%rbp), %rax
jmp 0xd6b0e
| process_str_arg:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov r15, r8
mov [rbp+var_58], rdi
mov [rbp+var_50], rdx
mov r14, rdx
mov [rbp+var_38], rsi
sub r14, rsi
lea rbx, [r14+1]
mov r13, rcx
neg r13
mov [rbp+var_40], rcx
cmovs r13, rcx
test r9, r9
lea r12, aNull; "(null)"
cmovnz r12, r9
cmp [rbp+arg_8], 0
jz short loc_D690A
lea rsi, [r15+1]
mov rdi, r12
call _strnlen
cmp rax, r15
mov rdx, r15
cmovb rdx, rax
cmp rbx, rdx
cmovbe rdx, r14
cmovbe r13, r14
mov [rbp+var_2C], 0
cmp rax, rdx
mov [rbp+var_48], r13
jbe short loc_D693B
cmp rdx, 2
ja short loc_D6930
mov [rbp+var_2C], edx
xor edx, edx
jmp short loc_D693B
loc_D690A:
mov rdi, r12
mov rsi, r15
call _strnlen
mov rdx, rax
cmp rbx, rax
cmovbe rdx, r14
cmovbe r13, r14
mov [rbp+var_48], r13
mov [rbp+var_2C], 0
jmp short loc_D693B
loc_D6930:
add rdx, 0FFFFFFFFFFFFFFFDh
mov [rbp+var_2C], 3
loc_D693B:
add rdx, r12
mov rdi, [rbp+var_58]
mov rax, [rdi+0B8h]
lea rbx, [rbp+var_70]
mov rsi, r12
mov rcx, r15
mov r8, rbx
call qword ptr [rax+0C8h]
mov r13, [rbx]
sub r13, r12
mov eax, [rbp+arg_0]
test al, 8
jnz short loc_D69A3
mov rbx, [rbp+var_40]
test rbx, rbx
js loc_D6A76
mov r14d, [rbp+var_2C]
mov eax, r14d
add rax, r13
mov rsi, [rbp+var_48]
sub rsi, rax
jbe loc_D6A80
mov rdi, [rbp+var_38]
mov edx, 20h ; ' '
call strfill
mov rdi, rax
jmp loc_D6A84
loc_D69A3:
mov eax, [rbp+var_2C]
add r13, rax
xorps xmm0, xmm0
movaps [rbp+var_70], xmm0
mov [rbp+var_60], 0
cmp r14, r13
jbe loc_D6B00
mov rax, [rbp+var_38]
lea r15, [rax+1]
mov byte ptr [rax], 60h ; '`'
test r13, r13
jle loc_D6AAF
add r13, r12
xor r14d, r14d
loc_D69DB:
cmp [rbp+var_2C], 0
jz short loc_D6A06
mov eax, r14d
mov qword ptr [rbp+rax*8+var_70], r15
mov eax, r14d
inc eax
mov ecx, 0AAAAAAABh
imul rax, rcx
shr rax, 21h
lea eax, [rax+rax*2]
neg eax
add r14d, eax
inc r14d
loc_D6A06:
mov bl, [r12]
mov rdi, [rbp+var_58]
mov rax, [rdi+0B8h]
mov rsi, r12
mov rdx, r13
call qword ptr [rax+0C0h]
cmp eax, 2
mov ecx, 1
cmovl eax, ecx
jge short loc_D6A47
cmp bl, 60h ; '`'
jnz short loc_D6A47
lea rdi, [r15+1]
cmp rdi, [rbp+var_50]
jnb loc_D6B00
mov byte ptr [r15], 60h ; '`'
jmp short loc_D6A4A
loc_D6A47:
mov rdi, r15
loc_D6A4A:
mov ebx, eax
lea rax, [rdi+rbx]
cmp rax, [rbp+var_50]
jnb loc_D6B00
mov rsi, r12
mov rdx, rbx
call strnmov
mov r15, rax
add r12, rbx
cmp r12, r13
jb loc_D69DB
jmp short loc_D6AB2
loc_D6A76:
mov rdi, [rbp+var_38]
mov r14d, [rbp+var_2C]
jmp short loc_D6A84
loc_D6A80:
mov rdi, [rbp+var_38]
loc_D6A84:
mov rsi, r12
mov rdx, r13
call strnmov
mov r15, rax
test r14d, r14d
jz short loc_D6B14
mov r14d, r14d
mov rdi, r15
mov rsi, r14
mov edx, 2Eh ; '.'
call strfill
mov r15, rax
jmp short loc_D6B17
loc_D6AAF:
xor r14d, r14d
loc_D6AB2:
lea rax, [r15+1]
cmp rax, [rbp+var_50]
jnb short loc_D6B00
cmp [rbp+var_2C], 0
jz loc_D6B62
sub r14d, 1
mov eax, 2
cmovb r14d, eax
mov rdx, qword ptr [rbp+r14*8+var_70]
test rdx, rdx
jz short loc_D6B00
mov ecx, 1
loc_D6AE2:
sub r14d, 1
cmovb r14d, eax
mov r15, qword ptr [rbp+r14*8+var_70]
test r15, r15
jz short loc_D6B4A
inc ecx
mov rdx, r15
cmp ecx, 3
jnz short loc_D6AE2
jmp short loc_D6B4D
loc_D6B00:
mov rax, [rbp+var_38]
mov byte ptr [rax], 0
mov r15, rax
mov rbx, [rbp+var_40]
loc_D6B0E:
mov r13, r15
sub r13, rax
loc_D6B14:
xor r14d, r14d
loc_D6B17:
test rbx, rbx
jns short loc_D6B38
add r13, r14
mov rsi, [rbp+var_48]
sub rsi, r13
jbe short loc_D6B38
mov rdi, r15
mov edx, 20h ; ' '
call strfill
mov r15, rax
loc_D6B38:
mov rax, r15
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_D6B4A:
mov r15, rdx
loc_D6B4D:
mov ebx, ecx
mov rdi, r15
mov esi, 2Eh ; '.'
mov rdx, rbx
call _memset
add r15, rbx
loc_D6B62:
mov byte ptr [r15], 60h ; '`'
inc r15
mov rbx, [rbp+var_40]
mov rax, [rbp+var_38]
jmp short loc_D6B0E
| long long process_str_arg(
long long a1,
_BYTE *a2,
unsigned long long a3,
long long a4,
unsigned long long a5,
const char *a6,
char a7,
char a8)
{
unsigned long long v9; // r14
unsigned long long v10; // rbx
long long v11; // r13
const char *v12; // r12
unsigned long long v13; // rax
unsigned long long v14; // rdx
long long v15; // rcx
long long v16; // r8
long long v17; // r9
long long v18; // r13
long long v19; // rbx
long long v20; // r14
unsigned long long v21; // rax
long long v22; // rdi
long long v23; // r13
_BYTE *v24; // r15
const char *v25; // r13
unsigned int v26; // r14d
char v27; // bl
unsigned int v28; // eax
_BYTE *v29; // rdi
long long v30; // rbx
long long v31; // rax
long long v32; // r15
bool v33; // cf
long long v34; // r14
long long v35; // rdx
unsigned int v36; // ecx
long long v37; // r15
_BYTE *v38; // rax
unsigned long long v39; // r13
long long v41; // rbx
__int128 v42; // [rsp+0h] [rbp-70h] BYREF
long long v43; // [rsp+10h] [rbp-60h]
long long v44; // [rsp+18h] [rbp-58h]
unsigned long long v45; // [rsp+20h] [rbp-50h]
unsigned long long v46; // [rsp+28h] [rbp-48h]
long long v47; // [rsp+30h] [rbp-40h]
_BYTE *v48; // [rsp+38h] [rbp-38h]
unsigned int v49; // [rsp+44h] [rbp-2Ch]
v44 = a1;
v45 = a3;
v48 = a2;
v9 = a3 - (_QWORD)a2;
v10 = a3 - (_QWORD)a2 + 1;
v11 = -a4;
v47 = a4;
if ( a4 > 0 )
v11 = a4;
v12 = "(null)";
if ( a6 )
v12 = a6;
if ( a8 )
{
v13 = strnlen(v12, a5 + 1);
v14 = a5;
if ( v13 < a5 )
v14 = v13;
if ( v10 <= v14 )
{
v14 = v9;
v11 = v9;
}
v49 = 0;
v46 = v11;
if ( v13 > v14 )
{
if ( v14 > 2 )
{
v14 -= 3LL;
v49 = 3;
}
else
{
v49 = v14;
v14 = 0LL;
}
}
}
else
{
v14 = strnlen(v12, a5);
if ( v10 <= v14 )
{
v14 = v9;
v11 = v9;
}
v46 = v11;
v49 = 0;
}
(*(void ( **)(long long, const char *, const char *, unsigned long long, __int128 *))(*(_QWORD *)(v44 + 184)
+ 200LL))(
v44,
v12,
&v12[v14],
a5,
&v42);
v18 = v42 - (_QWORD)v12;
if ( (a7 & 8) != 0 )
{
v23 = v49 + v18;
v42 = 0LL;
v43 = 0LL;
if ( v9 > v23 )
{
v24 = v48 + 1;
*v48 = 96;
if ( v23 > 0 )
{
v25 = &v12[v23];
v26 = 0;
while ( 1 )
{
if ( v49 )
{
*((_QWORD *)&v42 + v26) = v24;
v15 = 2863311531LL;
v26 += -3 * ((v26 + 1) / 3) + 1;
}
v27 = *v12;
v28 = (*(long long ( **)(long long, const char *, const char *, long long, long long, long long, _QWORD, _QWORD, long long))(*(_QWORD *)(v44 + 184) + 192LL))(
v44,
v12,
v25,
v15,
v16,
v17,
v42,
*((_QWORD *)&v42 + 1),
v43);
if ( (int)v28 < 2 && (v28 = 1, v27 == 96) )
{
v29 = v24 + 1;
if ( (unsigned long long)(v24 + 1) >= v45 )
goto LABEL_50;
*v24 = 96;
}
else
{
v29 = v24;
}
v30 = v28;
if ( (unsigned long long)&v29[v28] >= v45 )
goto LABEL_50;
v24 = (_BYTE *)strnmov(v29, v12, v28);
v12 += v30;
if ( v12 >= v25 )
goto LABEL_39;
}
}
v26 = 0;
LABEL_39:
if ( (unsigned long long)(v24 + 1) >= v45 )
goto LABEL_50;
if ( !v49 )
{
LABEL_59:
*v24 = 96;
v32 = (long long)(v24 + 1);
v19 = v47;
v38 = v48;
goto LABEL_51;
}
v33 = v26 == 0;
v34 = v26 - 1;
if ( v33 )
v34 = 2LL;
v35 = *((_QWORD *)&v42 + v34);
if ( v35 )
{
v36 = 1;
while ( 1 )
{
v33 = (_DWORD)v34 == 0;
v34 = (unsigned int)(v34 - 1);
if ( v33 )
v34 = 2LL;
v37 = *((_QWORD *)&v42 + v34);
if ( !v37 )
break;
++v36;
v35 = *((_QWORD *)&v42 + v34);
if ( v36 == 3 )
goto LABEL_58;
}
v37 = v35;
LABEL_58:
v41 = v36;
memset(v37, 46LL, v36);
v24 = (_BYTE *)(v41 + v37);
goto LABEL_59;
}
}
LABEL_50:
v38 = v48;
*v48 = 0;
v32 = (long long)v38;
v19 = v47;
LABEL_51:
v18 = v32 - (_QWORD)v38;
LABEL_52:
v20 = 0LL;
goto LABEL_53;
}
v19 = v47;
if ( v47 < 0 )
{
v22 = (long long)v48;
LODWORD(v20) = v49;
}
else
{
LODWORD(v20) = v49;
v21 = v18 + v49;
if ( v46 <= v21 )
v22 = (long long)v48;
else
v22 = strfill(v48, v46 - v21, 32LL);
}
v31 = strnmov(v22, v12, v18);
v32 = v31;
if ( !(_DWORD)v20 )
goto LABEL_52;
v20 = (unsigned int)v20;
v32 = strfill(v31, (unsigned int)v20, 46LL);
LABEL_53:
if ( v19 < 0 )
{
v39 = v20 + v18;
if ( v46 > v39 )
return strfill(v32, v46 - v39, 32LL);
}
return v32;
}
| process_str_arg:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R15,R8
MOV qword ptr [RBP + -0x58],RDI
MOV qword ptr [RBP + -0x50],RDX
MOV R14,RDX
MOV qword ptr [RBP + -0x38],RSI
SUB R14,RSI
LEA RBX,[R14 + 0x1]
MOV R13,RCX
NEG R13
MOV qword ptr [RBP + -0x40],RCX
CMOVS R13,RCX
TEST R9,R9
LEA R12,[0x1defdb]
CMOVNZ R12,R9
CMP byte ptr [RBP + 0x18],0x0
JZ 0x001d690a
LEA RSI,[R15 + 0x1]
MOV RDI,R12
CALL 0x00129510
CMP RAX,R15
MOV RDX,R15
CMOVC RDX,RAX
CMP RBX,RDX
CMOVBE RDX,R14
CMOVBE R13,R14
MOV dword ptr [RBP + -0x2c],0x0
CMP RAX,RDX
MOV qword ptr [RBP + -0x48],R13
JBE 0x001d693b
CMP RDX,0x2
JA 0x001d6930
MOV dword ptr [RBP + -0x2c],EDX
XOR EDX,EDX
JMP 0x001d693b
LAB_001d690a:
MOV RDI,R12
MOV RSI,R15
CALL 0x00129510
MOV RDX,RAX
CMP RBX,RAX
CMOVBE RDX,R14
CMOVBE R13,R14
MOV qword ptr [RBP + -0x48],R13
MOV dword ptr [RBP + -0x2c],0x0
JMP 0x001d693b
LAB_001d6930:
ADD RDX,-0x3
MOV dword ptr [RBP + -0x2c],0x3
LAB_001d693b:
ADD RDX,R12
MOV RDI,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RDI + 0xb8]
LEA RBX,[RBP + -0x70]
MOV RSI,R12
MOV RCX,R15
MOV R8,RBX
CALL qword ptr [RAX + 0xc8]
MOV R13,qword ptr [RBX]
SUB R13,R12
MOV EAX,dword ptr [RBP + 0x10]
TEST AL,0x8
JNZ 0x001d69a3
MOV RBX,qword ptr [RBP + -0x40]
TEST RBX,RBX
JS 0x001d6a76
MOV R14D,dword ptr [RBP + -0x2c]
MOV EAX,R14D
ADD RAX,R13
MOV RSI,qword ptr [RBP + -0x48]
SUB RSI,RAX
JBE 0x001d6a80
MOV RDI,qword ptr [RBP + -0x38]
MOV EDX,0x20
CALL 0x001d71a8
MOV RDI,RAX
JMP 0x001d6a84
LAB_001d69a3:
MOV EAX,dword ptr [RBP + -0x2c]
ADD R13,RAX
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RBP + -0x70],XMM0
MOV qword ptr [RBP + -0x60],0x0
CMP R14,R13
JBE 0x001d6b00
MOV RAX,qword ptr [RBP + -0x38]
LEA R15,[RAX + 0x1]
MOV byte ptr [RAX],0x60
TEST R13,R13
JLE 0x001d6aaf
ADD R13,R12
XOR R14D,R14D
LAB_001d69db:
CMP dword ptr [RBP + -0x2c],0x0
JZ 0x001d6a06
MOV EAX,R14D
MOV qword ptr [RBP + RAX*0x8 + -0x70],R15
MOV EAX,R14D
INC EAX
MOV ECX,0xaaaaaaab
IMUL RAX,RCX
SHR RAX,0x21
LEA EAX,[RAX + RAX*0x2]
NEG EAX
ADD R14D,EAX
INC R14D
LAB_001d6a06:
MOV BL,byte ptr [R12]
MOV RDI,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RDI + 0xb8]
MOV RSI,R12
MOV RDX,R13
CALL qword ptr [RAX + 0xc0]
CMP EAX,0x2
MOV ECX,0x1
CMOVL EAX,ECX
JGE 0x001d6a47
CMP BL,0x60
JNZ 0x001d6a47
LEA RDI,[R15 + 0x1]
CMP RDI,qword ptr [RBP + -0x50]
JNC 0x001d6b00
MOV byte ptr [R15],0x60
JMP 0x001d6a4a
LAB_001d6a47:
MOV RDI,R15
LAB_001d6a4a:
MOV EBX,EAX
LEA RAX,[RDI + RBX*0x1]
CMP RAX,qword ptr [RBP + -0x50]
JNC 0x001d6b00
MOV RSI,R12
MOV RDX,RBX
CALL 0x001d7208
MOV R15,RAX
ADD R12,RBX
CMP R12,R13
JC 0x001d69db
JMP 0x001d6ab2
LAB_001d6a76:
MOV RDI,qword ptr [RBP + -0x38]
MOV R14D,dword ptr [RBP + -0x2c]
JMP 0x001d6a84
LAB_001d6a80:
MOV RDI,qword ptr [RBP + -0x38]
LAB_001d6a84:
MOV RSI,R12
MOV RDX,R13
CALL 0x001d7208
MOV R15,RAX
TEST R14D,R14D
JZ 0x001d6b14
MOV R14D,R14D
MOV RDI,R15
MOV RSI,R14
MOV EDX,0x2e
CALL 0x001d71a8
MOV R15,RAX
JMP 0x001d6b17
LAB_001d6aaf:
XOR R14D,R14D
LAB_001d6ab2:
LEA RAX,[R15 + 0x1]
CMP RAX,qword ptr [RBP + -0x50]
JNC 0x001d6b00
CMP dword ptr [RBP + -0x2c],0x0
JZ 0x001d6b62
SUB R14D,0x1
MOV EAX,0x2
CMOVC R14D,EAX
MOV RDX,qword ptr [RBP + R14*0x8 + -0x70]
TEST RDX,RDX
JZ 0x001d6b00
MOV ECX,0x1
LAB_001d6ae2:
SUB R14D,0x1
CMOVC R14D,EAX
MOV R15,qword ptr [RBP + R14*0x8 + -0x70]
TEST R15,R15
JZ 0x001d6b4a
INC ECX
MOV RDX,R15
CMP ECX,0x3
JNZ 0x001d6ae2
JMP 0x001d6b4d
LAB_001d6b00:
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX],0x0
MOV R15,RAX
MOV RBX,qword ptr [RBP + -0x40]
LAB_001d6b0e:
MOV R13,R15
SUB R13,RAX
LAB_001d6b14:
XOR R14D,R14D
LAB_001d6b17:
TEST RBX,RBX
JNS 0x001d6b38
ADD R13,R14
MOV RSI,qword ptr [RBP + -0x48]
SUB RSI,R13
JBE 0x001d6b38
MOV RDI,R15
MOV EDX,0x20
CALL 0x001d71a8
MOV R15,RAX
LAB_001d6b38:
MOV RAX,R15
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001d6b4a:
MOV R15,RDX
LAB_001d6b4d:
MOV EBX,ECX
MOV RDI,R15
MOV ESI,0x2e
MOV RDX,RBX
CALL 0x001292c0
ADD R15,RBX
LAB_001d6b62:
MOV byte ptr [R15],0x60
INC R15
MOV RBX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x38]
JMP 0x001d6b0e
|
int1 *
process_str_arg(long param_1,int1 *param_2,int1 *param_3,ulong param_4,ulong param_5,
char *param_6,uint param_7,char param_8)
{
char cVar1;
void *pvVar2;
uint uVar3;
uint uVar4;
size_t sVar5;
int1 *puVar6;
void *__s;
long lVar7;
char *__string;
long lVar8;
ulong uVar9;
char *pcVar10;
int iVar11;
ulong uVar12;
long local_78 [4];
int1 *local_58;
ulong local_50;
ulong local_48;
int1 *local_40;
uint local_34;
uVar12 = (long)param_3 - (long)param_2;
local_50 = -param_4;
if (0 < (long)param_4) {
local_50 = param_4;
}
__string = "(null)";
if (param_6 != (char *)0x0) {
__string = param_6;
}
local_78[3] = param_1;
local_58 = param_3;
local_48 = param_4;
local_40 = param_2;
if (param_8 == '\0') {
uVar9 = strnlen(__string,param_5);
if (uVar12 + 1 <= uVar9) {
local_50 = uVar12;
uVar9 = uVar12;
}
local_34 = 0;
}
else {
sVar5 = strnlen(__string,param_5 + 1);
uVar9 = param_5;
if (sVar5 < param_5) {
uVar9 = sVar5;
}
if (uVar12 + 1 <= uVar9) {
local_50 = uVar12;
uVar9 = uVar12;
}
local_34 = 0;
if (uVar9 < sVar5) {
if (uVar9 < 3) {
local_34 = (uint)uVar9;
uVar9 = 0;
}
else {
uVar9 = uVar9 - 3;
local_34 = 3;
}
}
}
(**(code **)(*(long *)(local_78[3] + 0xb8) + 200))
(local_78[3],__string,__string + uVar9,param_5,local_78);
uVar4 = local_34;
uVar9 = local_48;
lVar8 = local_78[0] - (long)__string;
if ((param_7 & 8) == 0) {
puVar6 = local_40;
if ((-1 < (long)local_48) &&
(lVar7 = local_50 - ((ulong)local_34 + lVar8),
(ulong)local_34 + lVar8 <= local_50 && lVar7 != 0)) {
puVar6 = (int1 *)strfill(local_40,lVar7,0x20);
}
uVar12 = (ulong)uVar4;
puVar6 = (int1 *)strnmov(puVar6,__string,lVar8);
if (uVar4 != 0) {
puVar6 = (int1 *)strfill(puVar6,uVar12,0x2e);
goto LAB_001d6b17;
}
}
else {
uVar9 = lVar8 + (ulong)local_34;
local_78[0] = 0;
local_78[1] = 0;
local_78[2] = 0;
if (uVar9 < uVar12) {
puVar6 = local_40 + 1;
*local_40 = 0x60;
if ((long)uVar9 < 1) {
iVar11 = 0;
}
else {
pcVar10 = __string + uVar9;
uVar12 = 0;
do {
if (local_34 != 0) {
local_78[uVar12] = (long)puVar6;
uVar12 = (ulong)((int)uVar12 + (((int)uVar12 + 1U) / 3) * -3 + 1);
}
iVar11 = (int)uVar12;
cVar1 = *__string;
uVar4 = (**(code **)(*(long *)(local_78[3] + 0xb8) + 0xc0))(local_78[3],__string,pcVar10);
if (((int)uVar4 < 2) && (uVar4 = 1, cVar1 == '`')) {
if (local_58 <= puVar6 + 1) goto LAB_001d6b00;
*puVar6 = 0x60;
puVar6 = puVar6 + 1;
}
uVar9 = (ulong)uVar4;
if (local_58 <= puVar6 + uVar9) goto LAB_001d6b00;
puVar6 = (int1 *)strnmov(puVar6,__string,uVar9);
__string = __string + uVar9;
} while (__string < pcVar10);
}
if (local_58 <= puVar6 + 1) goto LAB_001d6b00;
if (local_34 != 0) {
uVar4 = iVar11 - 1;
if (iVar11 == 0) {
uVar4 = 2;
}
uVar12 = (ulong)uVar4;
if ((void *)local_78[uVar12] == (void *)0x0) goto LAB_001d6b00;
uVar4 = 1;
__s = (void *)local_78[uVar12];
do {
uVar3 = (int)uVar12 - 1;
if ((int)uVar12 == 0) {
uVar3 = 2;
}
uVar12 = (ulong)uVar3;
pvVar2 = (void *)local_78[uVar12];
} while ((pvVar2 != (void *)0x0) && (uVar4 = uVar4 + 1, __s = pvVar2, uVar4 != 3));
memset(__s,0x2e,(ulong)uVar4);
puVar6 = (int1 *)((long)__s + (ulong)uVar4);
}
*puVar6 = 0x60;
puVar6 = puVar6 + 1;
}
else {
LAB_001d6b00:
*local_40 = 0;
puVar6 = local_40;
}
lVar8 = (long)puVar6 - (long)local_40;
uVar9 = local_48;
}
uVar12 = 0;
LAB_001d6b17:
if (((long)uVar9 < 0) &&
(lVar7 = local_50 - (lVar8 + uVar12), lVar8 + uVar12 <= local_50 && lVar7 != 0)) {
puVar6 = (int1 *)strfill(puVar6,lVar7,0x20);
}
return puVar6;
}
| |
53,922 | void OpenSubdiv::v3_6_0::Far::internal::(anonymous namespace)::adjustBSplineBoundaryWeights<float>(int, float*) | NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/patchBasis.cpp | void
adjustBSplineBoundaryWeights(int boundary, REAL w[16]) {
if ((boundary & 1) != 0) {
for (int i = 0; i < 4; ++i) {
w[i + 8] -= w[i + 0];
w[i + 4] += w[i + 0] * 2.0f;
w[i + 0] = 0.0f;
}
}
if ((boundary & 2) != 0) {
for (int i = 0; i < 16; i += 4) {
w[i + 1] -= w[i + 3];
w[i + 2] += w[i + 3] * 2.0f;
w[i + 3] = 0.0f;
}
}
if ((boundary & 4) != 0) {
for (int i = 0; i < 4; ++i) {
w[i + 4] -= w[i + 12];
w[i + 8] += w[i + 12] * 2.0f;
w[i + 12] = 0.0f;
}
}
if ((boundary & 8) != 0) {
for (int i = 0; i < 16; i += 4) {
w[i + 2] -= w[i + 0];
w[i + 1] += w[i + 0] * 2.0f;
w[i + 0] = 0.0f;
}
}
} | O0 | cpp | void OpenSubdiv::v3_6_0::Far::internal::(anonymous namespace)::adjustBSplineBoundaryWeights<float>(int, float*):
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x12e3ee
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0x12e3ec
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x8, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x4, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm1
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x12e361
jmp 0x12e3ee
movl -0x4(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x12e491
movl $0x0, -0x18(%rbp)
cmpl $0x10, -0x18(%rbp)
jge 0x12e48f
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm1
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x18(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x18(%rbp)
jmp 0x12e404
jmp 0x12e491
movl -0x4(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x12e534
movl $0x0, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
jge 0x12e532
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0xc, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x4, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0xc, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x8, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm1
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0xc, %ecx
movslq %ecx, %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x12e4a7
jmp 0x12e534
movl -0x4(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x12e5d7
movl $0x0, -0x20(%rbp)
cmpl $0x10, -0x20(%rbp)
jge 0x12e5d5
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm1
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x20(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x20(%rbp)
jmp 0x12e54a
jmp 0x12e5d7
popq %rbp
retq
nopl (%rax)
| _ZN10OpenSubdiv6v3_6_03Far8internal12_GLOBAL__N_128adjustBSplineBoundaryWeightsIdEEviPT_:
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov eax, [rbp+var_4]
and eax, 1
cmp eax, 0
jz loc_12E3EE
mov [rbp+var_14], 0
loc_12E361:
cmp [rbp+var_14], 4
jge loc_12E3EC
mov rax, [rbp+var_10]
mov ecx, [rbp+var_14]
add ecx, 0
movsxd rcx, ecx
movsd xmm1, qword ptr [rax+rcx*8]
mov rax, [rbp+var_10]
mov ecx, [rbp+var_14]
add ecx, 8
movsxd rcx, ecx
movsd xmm0, qword ptr [rax+rcx*8]
subsd xmm0, xmm1
movsd qword ptr [rax+rcx*8], xmm0
mov rax, [rbp+var_10]
mov ecx, [rbp+var_14]
add ecx, 0
movsxd rcx, ecx
movsd xmm0, qword ptr [rax+rcx*8]
mov rax, [rbp+var_10]
mov ecx, [rbp+var_14]
add ecx, 4
movsxd rcx, ecx
movsd xmm1, qword ptr [rax+rcx*8]
addsd xmm0, xmm0
addsd xmm0, xmm1
movsd qword ptr [rax+rcx*8], xmm0
mov rax, [rbp+var_10]
mov ecx, [rbp+var_14]
add ecx, 0
movsxd rcx, ecx
xorps xmm0, xmm0
movsd qword ptr [rax+rcx*8], xmm0
mov eax, [rbp+var_14]
add eax, 1
mov [rbp+var_14], eax
jmp loc_12E361
loc_12E3EC:
jmp short $+2
loc_12E3EE:
mov eax, [rbp+var_4]
and eax, 2
cmp eax, 0
jz loc_12E491
mov [rbp+var_18], 0
loc_12E404:
cmp [rbp+var_18], 10h
jge loc_12E48F
mov rax, [rbp+var_10]
mov ecx, [rbp+var_18]
add ecx, 3
movsxd rcx, ecx
movsd xmm1, qword ptr [rax+rcx*8]
mov rax, [rbp+var_10]
mov ecx, [rbp+var_18]
add ecx, 1
movsxd rcx, ecx
movsd xmm0, qword ptr [rax+rcx*8]
subsd xmm0, xmm1
movsd qword ptr [rax+rcx*8], xmm0
mov rax, [rbp+var_10]
mov ecx, [rbp+var_18]
add ecx, 3
movsxd rcx, ecx
movsd xmm0, qword ptr [rax+rcx*8]
mov rax, [rbp+var_10]
mov ecx, [rbp+var_18]
add ecx, 2
movsxd rcx, ecx
movsd xmm1, qword ptr [rax+rcx*8]
addsd xmm0, xmm0
addsd xmm0, xmm1
movsd qword ptr [rax+rcx*8], xmm0
mov rax, [rbp+var_10]
mov ecx, [rbp+var_18]
add ecx, 3
movsxd rcx, ecx
xorps xmm0, xmm0
movsd qword ptr [rax+rcx*8], xmm0
mov eax, [rbp+var_18]
add eax, 4
mov [rbp+var_18], eax
jmp loc_12E404
loc_12E48F:
jmp short $+2
loc_12E491:
mov eax, [rbp+var_4]
and eax, 4
cmp eax, 0
jz loc_12E534
mov [rbp+var_1C], 0
loc_12E4A7:
cmp [rbp+var_1C], 4
jge loc_12E532
mov rax, [rbp+var_10]
mov ecx, [rbp+var_1C]
add ecx, 0Ch
movsxd rcx, ecx
movsd xmm1, qword ptr [rax+rcx*8]
mov rax, [rbp+var_10]
mov ecx, [rbp+var_1C]
add ecx, 4
movsxd rcx, ecx
movsd xmm0, qword ptr [rax+rcx*8]
subsd xmm0, xmm1
movsd qword ptr [rax+rcx*8], xmm0
mov rax, [rbp+var_10]
mov ecx, [rbp+var_1C]
add ecx, 0Ch
movsxd rcx, ecx
movsd xmm0, qword ptr [rax+rcx*8]
mov rax, [rbp+var_10]
mov ecx, [rbp+var_1C]
add ecx, 8
movsxd rcx, ecx
movsd xmm1, qword ptr [rax+rcx*8]
addsd xmm0, xmm0
addsd xmm0, xmm1
movsd qword ptr [rax+rcx*8], xmm0
mov rax, [rbp+var_10]
mov ecx, [rbp+var_1C]
add ecx, 0Ch
movsxd rcx, ecx
xorps xmm0, xmm0
movsd qword ptr [rax+rcx*8], xmm0
mov eax, [rbp+var_1C]
add eax, 1
mov [rbp+var_1C], eax
jmp loc_12E4A7
loc_12E532:
jmp short $+2
loc_12E534:
mov eax, [rbp+var_4]
and eax, 8
cmp eax, 0
jz loc_12E5D7
mov [rbp+var_20], 0
loc_12E54A:
cmp [rbp+var_20], 10h
jge loc_12E5D5
mov rax, [rbp+var_10]
mov ecx, [rbp+var_20]
add ecx, 0
movsxd rcx, ecx
movsd xmm1, qword ptr [rax+rcx*8]
mov rax, [rbp+var_10]
mov ecx, [rbp+var_20]
add ecx, 2
movsxd rcx, ecx
movsd xmm0, qword ptr [rax+rcx*8]
subsd xmm0, xmm1
movsd qword ptr [rax+rcx*8], xmm0
mov rax, [rbp+var_10]
mov ecx, [rbp+var_20]
add ecx, 0
movsxd rcx, ecx
movsd xmm0, qword ptr [rax+rcx*8]
mov rax, [rbp+var_10]
mov ecx, [rbp+var_20]
add ecx, 1
movsxd rcx, ecx
movsd xmm1, qword ptr [rax+rcx*8]
addsd xmm0, xmm0
addsd xmm0, xmm1
movsd qword ptr [rax+rcx*8], xmm0
mov rax, [rbp+var_10]
mov ecx, [rbp+var_20]
add ecx, 0
movsxd rcx, ecx
xorps xmm0, xmm0
movsd qword ptr [rax+rcx*8], xmm0
mov eax, [rbp+var_20]
add eax, 4
mov [rbp+var_20], eax
jmp loc_12E54A
loc_12E5D5:
jmp short $+2
loc_12E5D7:
pop rbp
retn
| long long OpenSubdiv::v3_6_0::Far::internal::`anonymous namespace'::adjustBSplineBoundaryWeights<double>(
char a1,
long long a2)
{
double v2; // xmm0_8
double v3; // xmm0_8
long long result; // rax
int m; // [rsp+0h] [rbp-20h]
int k; // [rsp+4h] [rbp-1Ch]
int j; // [rsp+8h] [rbp-18h]
int i; // [rsp+Ch] [rbp-14h]
if ( (a1 & 1) != 0 )
{
for ( i = 0; i < 4; ++i )
{
*(double *)(a2 + 8LL * (i + 8)) = *(double *)(a2 + 8LL * (i + 8)) - *(double *)(a2 + 8LL * i);
*(double *)(a2 + 8LL * (i + 4)) = *(double *)(a2 + 8LL * i)
+ *(double *)(a2 + 8LL * i)
+ *(double *)(a2 + 8LL * (i + 4));
*(_QWORD *)(a2 + 8LL * i) = 0LL;
}
}
if ( (a1 & 2) != 0 )
{
for ( j = 0; j < 16; j += 4 )
{
*(double *)(a2 + 8LL * (j + 1)) = *(double *)(a2 + 8LL * (j + 1)) - *(double *)(a2 + 8LL * (j + 3));
v2 = *(double *)(a2 + 8LL * (j + 3));
*(double *)(a2 + 8LL * (j + 2)) = v2 + v2 + *(double *)(a2 + 8LL * (j + 2));
*(_QWORD *)(a2 + 8LL * (j + 3)) = 0LL;
}
}
if ( (a1 & 4) != 0 )
{
for ( k = 0; k < 4; ++k )
{
*(double *)(a2 + 8LL * (k + 4)) = *(double *)(a2 + 8LL * (k + 4)) - *(double *)(a2 + 8LL * (k + 12));
v3 = *(double *)(a2 + 8LL * (k + 12));
*(double *)(a2 + 8LL * (k + 8)) = v3 + v3 + *(double *)(a2 + 8LL * (k + 8));
*(_QWORD *)(a2 + 8LL * (k + 12)) = 0LL;
}
}
result = a1 & 8;
if ( (a1 & 8) != 0 )
{
for ( m = 0; m < 16; m += 4 )
{
*(double *)(a2 + 8LL * (m + 2)) = *(double *)(a2 + 8LL * (m + 2)) - *(double *)(a2 + 8LL * m);
*(double *)(a2 + 8LL * (m + 1)) = *(double *)(a2 + 8LL * m)
+ *(double *)(a2 + 8LL * m)
+ *(double *)(a2 + 8LL * (m + 1));
*(_QWORD *)(a2 + 8LL * m) = 0LL;
result = (unsigned int)(m + 4);
}
}
return result;
}
| |||
53,923 | void OpenSubdiv::v3_6_0::Far::internal::(anonymous namespace)::adjustBSplineBoundaryWeights<float>(int, float*) | NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/patchBasis.cpp | void
adjustBSplineBoundaryWeights(int boundary, REAL w[16]) {
if ((boundary & 1) != 0) {
for (int i = 0; i < 4; ++i) {
w[i + 8] -= w[i + 0];
w[i + 4] += w[i + 0] * 2.0f;
w[i + 0] = 0.0f;
}
}
if ((boundary & 2) != 0) {
for (int i = 0; i < 16; i += 4) {
w[i + 1] -= w[i + 3];
w[i + 2] += w[i + 3] * 2.0f;
w[i + 3] = 0.0f;
}
}
if ((boundary & 4) != 0) {
for (int i = 0; i < 4; ++i) {
w[i + 4] -= w[i + 12];
w[i + 8] += w[i + 12] * 2.0f;
w[i + 12] = 0.0f;
}
}
if ((boundary & 8) != 0) {
for (int i = 0; i < 16; i += 4) {
w[i + 2] -= w[i + 0];
w[i + 1] += w[i + 0] * 2.0f;
w[i + 0] = 0.0f;
}
}
} | O1 | cpp | void OpenSubdiv::v3_6_0::Far::internal::(anonymous namespace)::adjustBSplineBoundaryWeights<float>(int, float*):
testb $0x1, %dil
je 0x5dda7
movq $-0x4, %rax
movss 0x10(%rsi,%rax,4), %xmm0
movss 0x30(%rsi,%rax,4), %xmm1
subss %xmm0, %xmm1
movss %xmm1, 0x30(%rsi,%rax,4)
addss %xmm0, %xmm0
addss 0x20(%rsi,%rax,4), %xmm0
movss %xmm0, 0x20(%rsi,%rax,4)
movl $0x0, 0x10(%rsi,%rax,4)
incq %rax
jne 0x5dd74
testb $0x2, %dil
je 0x5ddec
movq $-0x4, %rax
movss 0x14(%rsi,%rax,4), %xmm0
movss 0x1c(%rsi,%rax,4), %xmm1
subss %xmm1, %xmm0
movss %xmm0, 0x14(%rsi,%rax,4)
addss %xmm1, %xmm1
addss 0x18(%rsi,%rax,4), %xmm1
movss %xmm1, 0x18(%rsi,%rax,4)
movl $0x0, 0x1c(%rsi,%rax,4)
addq $0x4, %rax
cmpq $0xc, %rax
jb 0x5ddb4
testb $0x4, %dil
je 0x5de2c
movq $-0x4, %rax
movss 0x20(%rsi,%rax,4), %xmm0
movss 0x40(%rsi,%rax,4), %xmm1
subss %xmm1, %xmm0
movss %xmm0, 0x20(%rsi,%rax,4)
addss %xmm1, %xmm1
addss 0x30(%rsi,%rax,4), %xmm1
movss %xmm1, 0x30(%rsi,%rax,4)
movl $0x0, 0x40(%rsi,%rax,4)
incq %rax
jne 0x5ddf9
testb $0x8, %dil
je 0x5de71
movq $-0x4, %rax
movss 0x10(%rsi,%rax,4), %xmm0
movss 0x18(%rsi,%rax,4), %xmm1
subss %xmm0, %xmm1
movss %xmm1, 0x18(%rsi,%rax,4)
addss %xmm0, %xmm0
addss 0x14(%rsi,%rax,4), %xmm0
movss %xmm0, 0x14(%rsi,%rax,4)
movl $0x0, 0x10(%rsi,%rax,4)
addq $0x4, %rax
cmpq $0xc, %rax
jb 0x5de39
retq
| _ZN10OpenSubdiv6v3_6_03Far8internal12_GLOBAL__N_128adjustBSplineBoundaryWeightsIfEEviPT_:
test dil, 1
jz short loc_5DDA7
mov rax, 0FFFFFFFFFFFFFFFCh
loc_5DD74:
movss xmm0, dword ptr [rsi+rax*4+10h]
movss xmm1, dword ptr [rsi+rax*4+30h]
subss xmm1, xmm0
movss dword ptr [rsi+rax*4+30h], xmm1
addss xmm0, xmm0
addss xmm0, dword ptr [rsi+rax*4+20h]
movss dword ptr [rsi+rax*4+20h], xmm0
mov dword ptr [rsi+rax*4+10h], 0
inc rax
jnz short loc_5DD74
loc_5DDA7:
test dil, 2
jz short loc_5DDEC
mov rax, 0FFFFFFFFFFFFFFFCh
loc_5DDB4:
movss xmm0, dword ptr [rsi+rax*4+14h]
movss xmm1, dword ptr [rsi+rax*4+1Ch]
subss xmm0, xmm1
movss dword ptr [rsi+rax*4+14h], xmm0
addss xmm1, xmm1
addss xmm1, dword ptr [rsi+rax*4+18h]
movss dword ptr [rsi+rax*4+18h], xmm1
mov dword ptr [rsi+rax*4+1Ch], 0
add rax, 4
cmp rax, 0Ch
jb short loc_5DDB4
loc_5DDEC:
test dil, 4
jz short loc_5DE2C
mov rax, 0FFFFFFFFFFFFFFFCh
loc_5DDF9:
movss xmm0, dword ptr [rsi+rax*4+20h]
movss xmm1, dword ptr [rsi+rax*4+40h]
subss xmm0, xmm1
movss dword ptr [rsi+rax*4+20h], xmm0
addss xmm1, xmm1
addss xmm1, dword ptr [rsi+rax*4+30h]
movss dword ptr [rsi+rax*4+30h], xmm1
mov dword ptr [rsi+rax*4+40h], 0
inc rax
jnz short loc_5DDF9
loc_5DE2C:
test dil, 8
jz short locret_5DE71
mov rax, 0FFFFFFFFFFFFFFFCh
loc_5DE39:
movss xmm0, dword ptr [rsi+rax*4+10h]
movss xmm1, dword ptr [rsi+rax*4+18h]
subss xmm1, xmm0
movss dword ptr [rsi+rax*4+18h], xmm1
addss xmm0, xmm0
addss xmm0, dword ptr [rsi+rax*4+14h]
movss dword ptr [rsi+rax*4+14h], xmm0
mov dword ptr [rsi+rax*4+10h], 0
add rax, 4
cmp rax, 0Ch
jb short loc_5DE39
locret_5DE71:
retn
| void OpenSubdiv::v3_6_0::Far::internal::`anonymous namespace'::adjustBSplineBoundaryWeights<float>(
char a1,
long long a2)
{
long long v2; // rax
float v3; // xmm0_4
unsigned long long v4; // rax
float v5; // xmm1_4
long long v6; // rax
float v7; // xmm1_4
unsigned long long v8; // rax
float v9; // xmm0_4
if ( (a1 & 1) != 0 )
{
v2 = -4LL;
do
{
v3 = *(float *)(a2 + 4 * v2 + 16);
*(float *)(a2 + 4 * v2 + 48) = *(float *)(a2 + 4 * v2 + 48) - v3;
*(float *)(a2 + 4 * v2 + 32) = (float)(v3 + v3) + *(float *)(a2 + 4 * v2 + 32);
*(_DWORD *)(a2 + 4 * v2++ + 16) = 0;
}
while ( v2 );
}
if ( (a1 & 2) != 0 )
{
v4 = -4LL;
do
{
v5 = *(float *)(a2 + 4 * v4 + 28);
*(float *)(a2 + 4 * v4 + 20) = *(float *)(a2 + 4 * v4 + 20) - v5;
*(float *)(a2 + 4 * v4 + 24) = (float)(v5 + v5) + *(float *)(a2 + 4 * v4 + 24);
*(_DWORD *)(a2 + 4 * v4 + 28) = 0;
v4 += 4LL;
}
while ( v4 < 0xC );
}
if ( (a1 & 4) != 0 )
{
v6 = -4LL;
do
{
v7 = *(float *)(a2 + 4 * v6 + 64);
*(float *)(a2 + 4 * v6 + 32) = *(float *)(a2 + 4 * v6 + 32) - v7;
*(float *)(a2 + 4 * v6 + 48) = (float)(v7 + v7) + *(float *)(a2 + 4 * v6 + 48);
*(_DWORD *)(a2 + 4 * v6++ + 64) = 0;
}
while ( v6 );
}
if ( (a1 & 8) != 0 )
{
v8 = -4LL;
do
{
v9 = *(float *)(a2 + 4 * v8 + 16);
*(float *)(a2 + 4 * v8 + 24) = *(float *)(a2 + 4 * v8 + 24) - v9;
*(float *)(a2 + 4 * v8 + 20) = (float)(v9 + v9) + *(float *)(a2 + 4 * v8 + 20);
*(_DWORD *)(a2 + 4 * v8 + 16) = 0;
v8 += 4LL;
}
while ( v8 < 0xC );
}
}
| adjustBSplineBoundaryWeights<float>:
TEST DIL,0x1
JZ 0x0015dda7
MOV RAX,-0x4
LAB_0015dd74:
MOVSS XMM0,dword ptr [RSI + RAX*0x4 + 0x10]
MOVSS XMM1,dword ptr [RSI + RAX*0x4 + 0x30]
SUBSS XMM1,XMM0
MOVSS dword ptr [RSI + RAX*0x4 + 0x30],XMM1
ADDSS XMM0,XMM0
ADDSS XMM0,dword ptr [RSI + RAX*0x4 + 0x20]
MOVSS dword ptr [RSI + RAX*0x4 + 0x20],XMM0
MOV dword ptr [RSI + RAX*0x4 + 0x10],0x0
INC RAX
JNZ 0x0015dd74
LAB_0015dda7:
TEST DIL,0x2
JZ 0x0015ddec
MOV RAX,-0x4
LAB_0015ddb4:
MOVSS XMM0,dword ptr [RSI + RAX*0x4 + 0x14]
MOVSS XMM1,dword ptr [RSI + RAX*0x4 + 0x1c]
SUBSS XMM0,XMM1
MOVSS dword ptr [RSI + RAX*0x4 + 0x14],XMM0
ADDSS XMM1,XMM1
ADDSS XMM1,dword ptr [RSI + RAX*0x4 + 0x18]
MOVSS dword ptr [RSI + RAX*0x4 + 0x18],XMM1
MOV dword ptr [RSI + RAX*0x4 + 0x1c],0x0
ADD RAX,0x4
CMP RAX,0xc
JC 0x0015ddb4
LAB_0015ddec:
TEST DIL,0x4
JZ 0x0015de2c
MOV RAX,-0x4
LAB_0015ddf9:
MOVSS XMM0,dword ptr [RSI + RAX*0x4 + 0x20]
MOVSS XMM1,dword ptr [RSI + RAX*0x4 + 0x40]
SUBSS XMM0,XMM1
MOVSS dword ptr [RSI + RAX*0x4 + 0x20],XMM0
ADDSS XMM1,XMM1
ADDSS XMM1,dword ptr [RSI + RAX*0x4 + 0x30]
MOVSS dword ptr [RSI + RAX*0x4 + 0x30],XMM1
MOV dword ptr [RSI + RAX*0x4 + 0x40],0x0
INC RAX
JNZ 0x0015ddf9
LAB_0015de2c:
TEST DIL,0x8
JZ 0x0015de71
MOV RAX,-0x4
LAB_0015de39:
MOVSS XMM0,dword ptr [RSI + RAX*0x4 + 0x10]
MOVSS XMM1,dword ptr [RSI + RAX*0x4 + 0x18]
SUBSS XMM1,XMM0
MOVSS dword ptr [RSI + RAX*0x4 + 0x18],XMM1
ADDSS XMM0,XMM0
ADDSS XMM0,dword ptr [RSI + RAX*0x4 + 0x14]
MOVSS dword ptr [RSI + RAX*0x4 + 0x14],XMM0
MOV dword ptr [RSI + RAX*0x4 + 0x10],0x0
ADD RAX,0x4
CMP RAX,0xc
JC 0x0015de39
LAB_0015de71:
RET
|
/* void OpenSubdiv::v3_6_0::Far::internal::(anonymous
namespace)::adjustBSplineBoundaryWeights<float>(int, float*) */
void OpenSubdiv::v3_6_0::Far::internal::(anonymous_namespace)::adjustBSplineBoundaryWeights<float>
(int param_1,float *param_2)
{
float fVar1;
long lVar2;
ulong uVar3;
if ((param_1 & 1U) != 0) {
lVar2 = -4;
do {
fVar1 = param_2[lVar2 + 4];
param_2[lVar2 + 0xc] = param_2[lVar2 + 0xc] - fVar1;
param_2[lVar2 + 8] = fVar1 + fVar1 + param_2[lVar2 + 8];
param_2[lVar2 + 4] = 0.0;
lVar2 = lVar2 + 1;
} while (lVar2 != 0);
}
if ((param_1 & 2U) != 0) {
uVar3 = 0xfffffffffffffffc;
do {
fVar1 = param_2[uVar3 + 7];
param_2[uVar3 + 5] = param_2[uVar3 + 5] - fVar1;
param_2[uVar3 + 6] = fVar1 + fVar1 + param_2[uVar3 + 6];
param_2[uVar3 + 7] = 0.0;
uVar3 = uVar3 + 4;
} while (uVar3 < 0xc);
}
if ((param_1 & 4U) != 0) {
lVar2 = -4;
do {
fVar1 = param_2[lVar2 + 0x10];
param_2[lVar2 + 8] = param_2[lVar2 + 8] - fVar1;
param_2[lVar2 + 0xc] = fVar1 + fVar1 + param_2[lVar2 + 0xc];
param_2[lVar2 + 0x10] = 0.0;
lVar2 = lVar2 + 1;
} while (lVar2 != 0);
}
if ((param_1 & 8U) != 0) {
uVar3 = 0xfffffffffffffffc;
do {
fVar1 = param_2[uVar3 + 4];
param_2[uVar3 + 6] = param_2[uVar3 + 6] - fVar1;
param_2[uVar3 + 5] = fVar1 + fVar1 + param_2[uVar3 + 5];
param_2[uVar3 + 4] = 0.0;
uVar3 = uVar3 + 4;
} while (uVar3 < 0xc);
}
return;
}
| |
53,924 | void OpenSubdiv::v3_6_0::Far::internal::(anonymous namespace)::adjustBSplineBoundaryWeights<float>(int, float*) | NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/patchBasis.cpp | void
adjustBSplineBoundaryWeights(int boundary, REAL w[16]) {
if ((boundary & 1) != 0) {
for (int i = 0; i < 4; ++i) {
w[i + 8] -= w[i + 0];
w[i + 4] += w[i + 0] * 2.0f;
w[i + 0] = 0.0f;
}
}
if ((boundary & 2) != 0) {
for (int i = 0; i < 16; i += 4) {
w[i + 1] -= w[i + 3];
w[i + 2] += w[i + 3] * 2.0f;
w[i + 3] = 0.0f;
}
}
if ((boundary & 4) != 0) {
for (int i = 0; i < 4; ++i) {
w[i + 4] -= w[i + 12];
w[i + 8] += w[i + 12] * 2.0f;
w[i + 12] = 0.0f;
}
}
if ((boundary & 8) != 0) {
for (int i = 0; i < 16; i += 4) {
w[i + 2] -= w[i + 0];
w[i + 1] += w[i + 0] * 2.0f;
w[i + 0] = 0.0f;
}
}
} | O2 | cpp | void OpenSubdiv::v3_6_0::Far::internal::(anonymous namespace)::adjustBSplineBoundaryWeights<float>(int, float*):
testb $0x1, %dil
jne 0x74516
testb $0x2, %dil
jne 0x74550
testb $0x4, %dil
jne 0x7458a
testb $0x8, %dil
jne 0x745ce
retq
pushq $-0x20
popq %rax
testq %rax, %rax
je 0x744ff
movsd 0x20(%rsi,%rax), %xmm0
movsd 0x60(%rsi,%rax), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x60(%rsi,%rax)
addsd %xmm0, %xmm0
addsd 0x40(%rsi,%rax), %xmm0
movsd %xmm0, 0x40(%rsi,%rax)
andq $0x0, 0x20(%rsi,%rax)
addq $0x8, %rax
jmp 0x74519
xorl %eax, %eax
cmpq $0xf, %rax
ja 0x74505
movsd 0x8(%rsi,%rax,8), %xmm0
movsd 0x18(%rsi,%rax,8), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsi,%rax,8)
addsd %xmm1, %xmm1
addsd 0x10(%rsi,%rax,8), %xmm1
movsd %xmm1, 0x10(%rsi,%rax,8)
andq $0x0, 0x18(%rsi,%rax,8)
addq $0x4, %rax
jmp 0x74552
pushq $-0x20
popq %rax
testq %rax, %rax
je 0x7450b
movsd 0x40(%rsi,%rax), %xmm0
movsd 0x80(%rsi,%rax), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rsi,%rax)
addsd %xmm1, %xmm1
addsd 0x60(%rsi,%rax), %xmm1
movsd %xmm1, 0x60(%rsi,%rax)
andq $0x0, 0x80(%rsi,%rax)
addq $0x8, %rax
jmp 0x7458d
xorl %eax, %eax
cmpq $0xf, %rax
ja 0x74515
movsd (%rsi,%rax,8), %xmm0
movsd 0x10(%rsi,%rax,8), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsi,%rax,8)
addsd %xmm0, %xmm0
addsd 0x8(%rsi,%rax,8), %xmm0
movsd %xmm0, 0x8(%rsi,%rax,8)
andq $0x0, (%rsi,%rax,8)
addq $0x4, %rax
jmp 0x745d0
| _ZN10OpenSubdiv6v3_6_03Far8internal12_GLOBAL__N_128adjustBSplineBoundaryWeightsIdEEviPT_:
test dil, 1
jnz short loc_74516
loc_744FF:
test dil, 2
jnz short loc_74550
loc_74505:
test dil, 4
jnz short loc_7458A
loc_7450B:
test dil, 8
jnz loc_745CE
locret_74515:
retn
loc_74516:
push 0FFFFFFFFFFFFFFE0h
pop rax
loc_74519:
test rax, rax
jz short loc_744FF
movsd xmm0, qword ptr [rsi+rax+20h]
movsd xmm1, qword ptr [rsi+rax+60h]
subsd xmm1, xmm0
movsd qword ptr [rsi+rax+60h], xmm1
addsd xmm0, xmm0
addsd xmm0, qword ptr [rsi+rax+40h]
movsd qword ptr [rsi+rax+40h], xmm0
and qword ptr [rsi+rax+20h], 0
add rax, 8
jmp short loc_74519
loc_74550:
xor eax, eax
loc_74552:
cmp rax, 0Fh
ja short loc_74505
movsd xmm0, qword ptr [rsi+rax*8+8]
movsd xmm1, qword ptr [rsi+rax*8+18h]
subsd xmm0, xmm1
movsd qword ptr [rsi+rax*8+8], xmm0
addsd xmm1, xmm1
addsd xmm1, qword ptr [rsi+rax*8+10h]
movsd qword ptr [rsi+rax*8+10h], xmm1
and qword ptr [rsi+rax*8+18h], 0
add rax, 4
jmp short loc_74552
loc_7458A:
push 0FFFFFFFFFFFFFFE0h
pop rax
loc_7458D:
test rax, rax
jz loc_7450B
movsd xmm0, qword ptr [rsi+rax+40h]
movsd xmm1, qword ptr [rsi+rax+80h]
subsd xmm0, xmm1
movsd qword ptr [rsi+rax+40h], xmm0
addsd xmm1, xmm1
addsd xmm1, qword ptr [rsi+rax+60h]
movsd qword ptr [rsi+rax+60h], xmm1
and qword ptr [rsi+rax+80h], 0
add rax, 8
jmp short loc_7458D
loc_745CE:
xor eax, eax
loc_745D0:
cmp rax, 0Fh
ja locret_74515
movsd xmm0, qword ptr [rsi+rax*8]
movsd xmm1, qword ptr [rsi+rax*8+10h]
subsd xmm1, xmm0
movsd qword ptr [rsi+rax*8+10h], xmm1
addsd xmm0, xmm0
addsd xmm0, qword ptr [rsi+rax*8+8]
movsd qword ptr [rsi+rax*8+8], xmm0
and qword ptr [rsi+rax*8], 0
add rax, 4
jmp short loc_745D0
| void OpenSubdiv::v3_6_0::Far::internal::`anonymous namespace'::adjustBSplineBoundaryWeights<double>(
char a1,
long long a2)
{
long long i; // rax
double v3; // xmm0_8
unsigned long long j; // rax
double v5; // xmm1_8
long long k; // rax
double v7; // xmm1_8
unsigned long long m; // rax
double v9; // xmm0_8
if ( (a1 & 1) != 0 )
{
for ( i = -32LL; i; i += 8LL )
{
v3 = *(double *)(a2 + i + 32);
*(double *)(a2 + i + 96) = *(double *)(a2 + i + 96) - v3;
*(double *)(a2 + i + 64) = v3 + v3 + *(double *)(a2 + i + 64);
*(_QWORD *)(a2 + i + 32) = 0LL;
}
}
if ( (a1 & 2) != 0 )
{
for ( j = 0LL; j <= 0xF; j += 4LL )
{
v5 = *(double *)(a2 + 8 * j + 24);
*(double *)(a2 + 8 * j + 8) = *(double *)(a2 + 8 * j + 8) - v5;
*(double *)(a2 + 8 * j + 16) = v5 + v5 + *(double *)(a2 + 8 * j + 16);
*(_QWORD *)(a2 + 8 * j + 24) = 0LL;
}
}
if ( (a1 & 4) != 0 )
{
for ( k = -32LL; k; k += 8LL )
{
v7 = *(double *)(a2 + k + 128);
*(double *)(a2 + k + 64) = *(double *)(a2 + k + 64) - v7;
*(double *)(a2 + k + 96) = v7 + v7 + *(double *)(a2 + k + 96);
*(_QWORD *)(a2 + k + 128) = 0LL;
}
}
if ( (a1 & 8) != 0 )
{
for ( m = 0LL; m <= 0xF; m += 4LL )
{
v9 = *(double *)(a2 + 8 * m);
*(double *)(a2 + 8 * m + 16) = *(double *)(a2 + 8 * m + 16) - v9;
*(double *)(a2 + 8 * m + 8) = v9 + v9 + *(double *)(a2 + 8 * m + 8);
*(_QWORD *)(a2 + 8 * m) = 0LL;
}
}
}
| adjustBSplineBoundaryWeights<double>:
TEST DIL,0x1
JNZ 0x00174516
LAB_001744ff:
TEST DIL,0x2
JNZ 0x00174550
LAB_00174505:
TEST DIL,0x4
JNZ 0x0017458a
LAB_0017450b:
TEST DIL,0x8
JNZ 0x001745ce
LAB_00174515:
RET
LAB_00174516:
PUSH -0x20
POP RAX
LAB_00174519:
TEST RAX,RAX
JZ 0x001744ff
MOVSD XMM0,qword ptr [RSI + RAX*0x1 + 0x20]
MOVSD XMM1,qword ptr [RSI + RAX*0x1 + 0x60]
SUBSD XMM1,XMM0
MOVSD qword ptr [RSI + RAX*0x1 + 0x60],XMM1
ADDSD XMM0,XMM0
ADDSD XMM0,qword ptr [RSI + RAX*0x1 + 0x40]
MOVSD qword ptr [RSI + RAX*0x1 + 0x40],XMM0
AND qword ptr [RSI + RAX*0x1 + 0x20],0x0
ADD RAX,0x8
JMP 0x00174519
LAB_00174550:
XOR EAX,EAX
LAB_00174552:
CMP RAX,0xf
JA 0x00174505
MOVSD XMM0,qword ptr [RSI + RAX*0x8 + 0x8]
MOVSD XMM1,qword ptr [RSI + RAX*0x8 + 0x18]
SUBSD XMM0,XMM1
MOVSD qword ptr [RSI + RAX*0x8 + 0x8],XMM0
ADDSD XMM1,XMM1
ADDSD XMM1,qword ptr [RSI + RAX*0x8 + 0x10]
MOVSD qword ptr [RSI + RAX*0x8 + 0x10],XMM1
AND qword ptr [RSI + RAX*0x8 + 0x18],0x0
ADD RAX,0x4
JMP 0x00174552
LAB_0017458a:
PUSH -0x20
POP RAX
LAB_0017458d:
TEST RAX,RAX
JZ 0x0017450b
MOVSD XMM0,qword ptr [RSI + RAX*0x1 + 0x40]
MOVSD XMM1,qword ptr [RSI + RAX*0x1 + 0x80]
SUBSD XMM0,XMM1
MOVSD qword ptr [RSI + RAX*0x1 + 0x40],XMM0
ADDSD XMM1,XMM1
ADDSD XMM1,qword ptr [RSI + RAX*0x1 + 0x60]
MOVSD qword ptr [RSI + RAX*0x1 + 0x60],XMM1
AND qword ptr [RSI + RAX*0x1 + 0x80],0x0
ADD RAX,0x8
JMP 0x0017458d
LAB_001745ce:
XOR EAX,EAX
LAB_001745d0:
CMP RAX,0xf
JA 0x00174515
MOVSD XMM0,qword ptr [RSI + RAX*0x8]
MOVSD XMM1,qword ptr [RSI + RAX*0x8 + 0x10]
SUBSD XMM1,XMM0
MOVSD qword ptr [RSI + RAX*0x8 + 0x10],XMM1
ADDSD XMM0,XMM0
ADDSD XMM0,qword ptr [RSI + RAX*0x8 + 0x8]
MOVSD qword ptr [RSI + RAX*0x8 + 0x8],XMM0
AND qword ptr [RSI + RAX*0x8],0x0
ADD RAX,0x4
JMP 0x001745d0
|
/* void OpenSubdiv::v3_6_0::Far::internal::(anonymous
namespace)::adjustBSplineBoundaryWeights<double>(int, double*) */
void OpenSubdiv::v3_6_0::Far::internal::(anonymous_namespace)::adjustBSplineBoundaryWeights<double>
(int param_1,double *param_2)
{
double dVar1;
long lVar2;
ulong uVar3;
if ((param_1 & 1U) != 0) {
for (lVar2 = -0x20; lVar2 != 0; lVar2 = lVar2 + 8) {
dVar1 = *(double *)((long)param_2 + lVar2 + 0x20);
*(double *)((long)param_2 + lVar2 + 0x60) = *(double *)((long)param_2 + lVar2 + 0x60) - dVar1;
*(double *)((long)param_2 + lVar2 + 0x40) =
dVar1 + dVar1 + *(double *)((long)param_2 + lVar2 + 0x40);
*(int8 *)((long)param_2 + lVar2 + 0x20) = 0;
}
}
if ((param_1 & 2U) != 0) {
for (uVar3 = 0; uVar3 < 0x10; uVar3 = uVar3 + 4) {
dVar1 = param_2[uVar3 + 3];
param_2[uVar3 + 1] = param_2[uVar3 + 1] - dVar1;
param_2[uVar3 + 2] = dVar1 + dVar1 + param_2[uVar3 + 2];
param_2[uVar3 + 3] = 0.0;
}
}
if ((param_1 & 4U) != 0) {
for (lVar2 = -0x20; lVar2 != 0; lVar2 = lVar2 + 8) {
dVar1 = *(double *)((long)param_2 + lVar2 + 0x80);
*(double *)((long)param_2 + lVar2 + 0x40) = *(double *)((long)param_2 + lVar2 + 0x40) - dVar1;
*(double *)((long)param_2 + lVar2 + 0x60) =
dVar1 + dVar1 + *(double *)((long)param_2 + lVar2 + 0x60);
*(int8 *)((long)param_2 + lVar2 + 0x80) = 0;
}
}
if ((param_1 & 8U) != 0) {
for (uVar3 = 0; uVar3 < 0x10; uVar3 = uVar3 + 4) {
dVar1 = param_2[uVar3];
param_2[uVar3 + 2] = param_2[uVar3 + 2] - dVar1;
param_2[uVar3 + 1] = dVar1 + dVar1 + param_2[uVar3 + 1];
param_2[uVar3] = 0.0;
}
}
return;
}
| |
53,925 | void OpenSubdiv::v3_6_0::Far::internal::(anonymous namespace)::adjustBSplineBoundaryWeights<float>(int, float*) | NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/patchBasis.cpp | void
adjustBSplineBoundaryWeights(int boundary, REAL w[16]) {
if ((boundary & 1) != 0) {
for (int i = 0; i < 4; ++i) {
w[i + 8] -= w[i + 0];
w[i + 4] += w[i + 0] * 2.0f;
w[i + 0] = 0.0f;
}
}
if ((boundary & 2) != 0) {
for (int i = 0; i < 16; i += 4) {
w[i + 1] -= w[i + 3];
w[i + 2] += w[i + 3] * 2.0f;
w[i + 3] = 0.0f;
}
}
if ((boundary & 4) != 0) {
for (int i = 0; i < 4; ++i) {
w[i + 4] -= w[i + 12];
w[i + 8] += w[i + 12] * 2.0f;
w[i + 12] = 0.0f;
}
}
if ((boundary & 8) != 0) {
for (int i = 0; i < 16; i += 4) {
w[i + 2] -= w[i + 0];
w[i + 1] += w[i + 0] * 2.0f;
w[i + 0] = 0.0f;
}
}
} | O3 | cpp | void OpenSubdiv::v3_6_0::Far::internal::(anonymous namespace)::adjustBSplineBoundaryWeights<float>(int, float*):
testb $0x1, %dil
je 0x604ac
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups 0x20(%rsi), %xmm2
subps %xmm0, %xmm2
movups %xmm2, 0x20(%rsi)
addps %xmm0, %xmm0
addps %xmm1, %xmm0
movups %xmm0, 0x10(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
testb $0x2, %dil
je 0x604f1
movq $-0x4, %rax
movss 0x14(%rsi,%rax,4), %xmm0
movss 0x1c(%rsi,%rax,4), %xmm1
subss %xmm1, %xmm0
movss %xmm0, 0x14(%rsi,%rax,4)
addss %xmm1, %xmm1
addss 0x18(%rsi,%rax,4), %xmm1
movss %xmm1, 0x18(%rsi,%rax,4)
movl $0x0, 0x1c(%rsi,%rax,4)
addq $0x4, %rax
cmpq $0xc, %rax
jb 0x604b9
testb $0x4, %dil
je 0x6051b
movups 0x10(%rsi), %xmm0
movups 0x20(%rsi), %xmm1
movups 0x30(%rsi), %xmm2
subps %xmm2, %xmm0
movups %xmm0, 0x10(%rsi)
addps %xmm2, %xmm2
addps %xmm1, %xmm2
movups %xmm2, 0x20(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rsi)
testb $0x8, %dil
je 0x60560
movq $-0x4, %rax
movss 0x10(%rsi,%rax,4), %xmm0
movss 0x18(%rsi,%rax,4), %xmm1
subss %xmm0, %xmm1
movss %xmm1, 0x18(%rsi,%rax,4)
addss %xmm0, %xmm0
addss 0x14(%rsi,%rax,4), %xmm0
movss %xmm0, 0x14(%rsi,%rax,4)
movl $0x0, 0x10(%rsi,%rax,4)
addq $0x4, %rax
cmpq $0xc, %rax
jb 0x60528
retq
| _ZN10OpenSubdiv6v3_6_03Far8internal12_GLOBAL__N_128adjustBSplineBoundaryWeightsIfEEviPT_:
test dil, 1
jz short loc_604AC
movups xmm0, xmmword ptr [rsi]
movups xmm1, xmmword ptr [rsi+10h]
movups xmm2, xmmword ptr [rsi+20h]
subps xmm2, xmm0
movups xmmword ptr [rsi+20h], xmm2
addps xmm0, xmm0
addps xmm0, xmm1
movups xmmword ptr [rsi+10h], xmm0
xorps xmm0, xmm0
movups xmmword ptr [rsi], xmm0
loc_604AC:
test dil, 2
jz short loc_604F1
mov rax, 0FFFFFFFFFFFFFFFCh
loc_604B9:
movss xmm0, dword ptr [rsi+rax*4+14h]
movss xmm1, dword ptr [rsi+rax*4+1Ch]
subss xmm0, xmm1
movss dword ptr [rsi+rax*4+14h], xmm0
addss xmm1, xmm1
addss xmm1, dword ptr [rsi+rax*4+18h]
movss dword ptr [rsi+rax*4+18h], xmm1
mov dword ptr [rsi+rax*4+1Ch], 0
add rax, 4
cmp rax, 0Ch
jb short loc_604B9
loc_604F1:
test dil, 4
jz short loc_6051B
movups xmm0, xmmword ptr [rsi+10h]
movups xmm1, xmmword ptr [rsi+20h]
movups xmm2, xmmword ptr [rsi+30h]
subps xmm0, xmm2
movups xmmword ptr [rsi+10h], xmm0
addps xmm2, xmm2
addps xmm2, xmm1
movups xmmword ptr [rsi+20h], xmm2
xorps xmm0, xmm0
movups xmmword ptr [rsi+30h], xmm0
loc_6051B:
test dil, 8
jz short locret_60560
mov rax, 0FFFFFFFFFFFFFFFCh
loc_60528:
movss xmm0, dword ptr [rsi+rax*4+10h]
movss xmm1, dword ptr [rsi+rax*4+18h]
subss xmm1, xmm0
movss dword ptr [rsi+rax*4+18h], xmm1
addss xmm0, xmm0
addss xmm0, dword ptr [rsi+rax*4+14h]
movss dword ptr [rsi+rax*4+14h], xmm0
mov dword ptr [rsi+rax*4+10h], 0
add rax, 4
cmp rax, 0Ch
jb short loc_60528
locret_60560:
retn
| void OpenSubdiv::v3_6_0::Far::internal::`anonymous namespace'::adjustBSplineBoundaryWeights<float>(
char a1,
__m128 *a2)
{
__m128 v2; // xmm0
__m128 v3; // xmm1
unsigned long long v4; // rax
float v5; // xmm1_4
__m128 v6; // xmm1
__m128 v7; // xmm2
unsigned long long v8; // rax
float v9; // xmm0_4
if ( (a1 & 1) != 0 )
{
v2 = *a2;
v3 = a2[1];
a2[2] = _mm_sub_ps(a2[2], *a2);
a2[1] = _mm_add_ps(_mm_add_ps(v2, v2), v3);
*a2 = 0LL;
}
if ( (a1 & 2) != 0 )
{
v4 = 0x3FFFFFFFFFFFFFFFLL;
do
{
v5 = a2[v4 + 1].m128_f32[3];
a2[v4 + 1].m128_f32[1] = a2[v4 + 1].m128_f32[1] - v5;
a2[v4 + 1].m128_f32[2] = (float)(v5 + v5) + a2[v4 + 1].m128_f32[2];
a2[++v4].m128_i32[3] = 0;
}
while ( v4 < 3 );
}
if ( (a1 & 4) != 0 )
{
v6 = a2[2];
v7 = a2[3];
a2[1] = _mm_sub_ps(a2[1], v7);
a2[2] = _mm_add_ps(_mm_add_ps(v7, v7), v6);
a2[3] = 0LL;
}
if ( (a1 & 8) != 0 )
{
v8 = 0x3FFFFFFFFFFFFFFFLL;
do
{
v9 = a2[v8 + 1].m128_f32[0];
a2[v8 + 1].m128_f32[2] = a2[v8 + 1].m128_f32[2] - v9;
a2[v8 + 1].m128_f32[1] = (float)(v9 + v9) + a2[v8 + 1].m128_f32[1];
a2[++v8].m128_i32[0] = 0;
}
while ( v8 < 3 );
}
}
| adjustBSplineBoundaryWeights<float>:
TEST DIL,0x1
JZ 0x001604ac
MOVUPS XMM0,xmmword ptr [RSI]
MOVUPS XMM1,xmmword ptr [RSI + 0x10]
MOVUPS XMM2,xmmword ptr [RSI + 0x20]
SUBPS XMM2,XMM0
MOVUPS xmmword ptr [RSI + 0x20],XMM2
ADDPS XMM0,XMM0
ADDPS XMM0,XMM1
MOVUPS xmmword ptr [RSI + 0x10],XMM0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSI],XMM0
LAB_001604ac:
TEST DIL,0x2
JZ 0x001604f1
MOV RAX,-0x4
LAB_001604b9:
MOVSS XMM0,dword ptr [RSI + RAX*0x4 + 0x14]
MOVSS XMM1,dword ptr [RSI + RAX*0x4 + 0x1c]
SUBSS XMM0,XMM1
MOVSS dword ptr [RSI + RAX*0x4 + 0x14],XMM0
ADDSS XMM1,XMM1
ADDSS XMM1,dword ptr [RSI + RAX*0x4 + 0x18]
MOVSS dword ptr [RSI + RAX*0x4 + 0x18],XMM1
MOV dword ptr [RSI + RAX*0x4 + 0x1c],0x0
ADD RAX,0x4
CMP RAX,0xc
JC 0x001604b9
LAB_001604f1:
TEST DIL,0x4
JZ 0x0016051b
MOVUPS XMM0,xmmword ptr [RSI + 0x10]
MOVUPS XMM1,xmmword ptr [RSI + 0x20]
MOVUPS XMM2,xmmword ptr [RSI + 0x30]
SUBPS XMM0,XMM2
MOVUPS xmmword ptr [RSI + 0x10],XMM0
ADDPS XMM2,XMM2
ADDPS XMM2,XMM1
MOVUPS xmmword ptr [RSI + 0x20],XMM2
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSI + 0x30],XMM0
LAB_0016051b:
TEST DIL,0x8
JZ 0x00160560
MOV RAX,-0x4
LAB_00160528:
MOVSS XMM0,dword ptr [RSI + RAX*0x4 + 0x10]
MOVSS XMM1,dword ptr [RSI + RAX*0x4 + 0x18]
SUBSS XMM1,XMM0
MOVSS dword ptr [RSI + RAX*0x4 + 0x18],XMM1
ADDSS XMM0,XMM0
ADDSS XMM0,dword ptr [RSI + RAX*0x4 + 0x14]
MOVSS dword ptr [RSI + RAX*0x4 + 0x14],XMM0
MOV dword ptr [RSI + RAX*0x4 + 0x10],0x0
ADD RAX,0x4
CMP RAX,0xc
JC 0x00160528
LAB_00160560:
RET
|
/* void OpenSubdiv::v3_6_0::Far::internal::(anonymous
namespace)::adjustBSplineBoundaryWeights<float>(int, float*) */
void OpenSubdiv::v3_6_0::Far::internal::(anonymous_namespace)::adjustBSplineBoundaryWeights<float>
(int param_1,float *param_2)
{
float fVar1;
float fVar2;
float fVar3;
float fVar4;
ulong uVar5;
if ((param_1 & 1U) != 0) {
fVar1 = *param_2;
fVar2 = param_2[1];
fVar3 = param_2[2];
fVar4 = param_2[3];
param_2[8] = param_2[8] - fVar1;
param_2[9] = param_2[9] - fVar2;
param_2[10] = param_2[10] - fVar3;
param_2[0xb] = param_2[0xb] - fVar4;
param_2[4] = fVar1 + fVar1 + param_2[4];
param_2[5] = fVar2 + fVar2 + param_2[5];
param_2[6] = fVar3 + fVar3 + param_2[6];
param_2[7] = fVar4 + fVar4 + param_2[7];
param_2[0] = 0.0;
param_2[1] = 0.0;
param_2[2] = 0.0;
param_2[3] = 0.0;
}
if ((param_1 & 2U) != 0) {
uVar5 = 0xfffffffffffffffc;
do {
fVar1 = param_2[uVar5 + 7];
param_2[uVar5 + 5] = param_2[uVar5 + 5] - fVar1;
param_2[uVar5 + 6] = fVar1 + fVar1 + param_2[uVar5 + 6];
param_2[uVar5 + 7] = 0.0;
uVar5 = uVar5 + 4;
} while (uVar5 < 0xc);
}
if ((param_1 & 4U) != 0) {
fVar1 = param_2[0xc];
fVar2 = param_2[0xd];
fVar3 = param_2[0xe];
fVar4 = param_2[0xf];
param_2[4] = param_2[4] - fVar1;
param_2[5] = param_2[5] - fVar2;
param_2[6] = param_2[6] - fVar3;
param_2[7] = param_2[7] - fVar4;
param_2[8] = fVar1 + fVar1 + param_2[8];
param_2[9] = fVar2 + fVar2 + param_2[9];
param_2[10] = fVar3 + fVar3 + param_2[10];
param_2[0xb] = fVar4 + fVar4 + param_2[0xb];
param_2[0xc] = 0.0;
param_2[0xd] = 0.0;
param_2[0xe] = 0.0;
param_2[0xf] = 0.0;
}
if ((param_1 & 8U) != 0) {
uVar5 = 0xfffffffffffffffc;
do {
fVar1 = param_2[uVar5 + 4];
param_2[uVar5 + 6] = param_2[uVar5 + 6] - fVar1;
param_2[uVar5 + 5] = fVar1 + fVar1 + param_2[uVar5 + 5];
param_2[uVar5 + 4] = 0.0;
uVar5 = uVar5 + 4;
} while (uVar5 < 0xc);
}
return;
}
| |
53,926 | wait_for_readers | eloqsql/mysys/mf_keycache.c | static void wait_for_readers(SIMPLE_KEY_CACHE_CB *keycache,
BLOCK_LINK *block)
{
struct st_my_thread_var *thread= my_thread_var;
DBUG_ASSERT(block->status & (BLOCK_READ | BLOCK_IN_USE));
DBUG_ASSERT(!(block->status & (BLOCK_IN_FLUSH | BLOCK_CHANGED)));
DBUG_ASSERT(block->hash_link);
DBUG_ASSERT(block->hash_link->block == block);
/* Linked in file_blocks or changed_blocks hash. */
DBUG_ASSERT(block->prev_changed && *block->prev_changed == block);
/* Not linked in LRU ring. */
DBUG_ASSERT(!block->next_used);
DBUG_ASSERT(!block->prev_used);
while (block->hash_link->requests)
{
KEYCACHE_DBUG_PRINT("wait_for_readers: wait",
("suspend thread %ld block %u",
(ulong) thread->id, BLOCK_NUMBER(block)));
/* There must be no other waiter. We have no queue here. */
DBUG_ASSERT(!block->condvar);
block->condvar= &thread->suspend;
keycache_pthread_cond_wait(&thread->suspend, &keycache->cache_lock);
block->condvar= NULL;
}
} | O0 | c | wait_for_readers:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0xf7440
movq %rax, -0x18(%rbp)
jmp 0xe686b
jmp 0xe686d
jmp 0xe686f
jmp 0xe6871
jmp 0xe6873
jmp 0xe6875
jmp 0xe6877
jmp 0xe6879
jmp 0xe687b
jmp 0xe687d
jmp 0xe687f
jmp 0xe6881
jmp 0xe6883
jmp 0xe6885
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x0, 0x28(%rax)
je 0xe68dd
jmp 0xe6895
jmp 0xe6897
jmp 0xe6899
jmp 0xe689b
movq -0x18(%rbp), %rcx
addq $0x8, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rsi
addq $0xc0, %rsi
leaq 0x6ec0c(%rip), %rdx # 0x1554d1
movl $0x68f, %ecx # imm = 0x68F
callq 0xe61e0
movq -0x10(%rbp), %rax
movq $0x0, 0x68(%rax)
jmp 0xe6885
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| wait_for_readers_0:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
call _my_thread_var
mov [rbp+var_18], rax
jmp short $+2
loc_E686B:
jmp short $+2
loc_E686D:
jmp short $+2
loc_E686F:
jmp short $+2
loc_E6871:
jmp short $+2
loc_E6873:
jmp short $+2
loc_E6875:
jmp short $+2
loc_E6877:
jmp short $+2
loc_E6879:
jmp short $+2
loc_E687B:
jmp short $+2
loc_E687D:
jmp short $+2
loc_E687F:
jmp short $+2
loc_E6881:
jmp short $+2
loc_E6883:
jmp short $+2
loc_E6885:
mov rax, [rbp+var_10]
mov rax, [rax+20h]
cmp dword ptr [rax+28h], 0
jz short loc_E68DD
jmp short $+2
loc_E6895:
jmp short $+2
loc_E6897:
jmp short $+2
loc_E6899:
jmp short $+2
loc_E689B:
mov rcx, [rbp+var_18]
add rcx, 8
mov rax, [rbp+var_10]
mov [rax+68h], rcx
mov rdi, [rbp+var_18]
add rdi, 8
mov rsi, [rbp+var_8]
add rsi, 0C0h
lea rdx, aWorkspaceLlm4b_36; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 68Fh
call inline_mysql_cond_wait_4
mov rax, [rbp+var_10]
mov qword ptr [rax+68h], 0
jmp short loc_E6885
loc_E68DD:
add rsp, 20h
pop rbp
retn
| long long wait_for_readers_0(long long a1, long long a2)
{
long long result; // rax
long long v3; // [rsp+8h] [rbp-18h]
v3 = my_thread_var(a1, (const char *)a2);
while ( 1 )
{
result = *(_QWORD *)(a2 + 32);
if ( !*(_DWORD *)(result + 40) )
break;
*(_QWORD *)(a2 + 104) = v3 + 8;
inline_mysql_cond_wait_4(
v3 + 8,
a1 + 192,
(long long)"/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c",
0x68Fu);
*(_QWORD *)(a2 + 104) = 0LL;
}
return result;
}
| wait_for_readers:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
CALL 0x001f7440
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001e686b
LAB_001e686b:
JMP 0x001e686d
LAB_001e686d:
JMP 0x001e686f
LAB_001e686f:
JMP 0x001e6871
LAB_001e6871:
JMP 0x001e6873
LAB_001e6873:
JMP 0x001e6875
LAB_001e6875:
JMP 0x001e6877
LAB_001e6877:
JMP 0x001e6879
LAB_001e6879:
JMP 0x001e687b
LAB_001e687b:
JMP 0x001e687d
LAB_001e687d:
JMP 0x001e687f
LAB_001e687f:
JMP 0x001e6881
LAB_001e6881:
JMP 0x001e6883
LAB_001e6883:
JMP 0x001e6885
LAB_001e6885:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x20]
CMP dword ptr [RAX + 0x28],0x0
JZ 0x001e68dd
JMP 0x001e6895
LAB_001e6895:
JMP 0x001e6897
LAB_001e6897:
JMP 0x001e6899
LAB_001e6899:
JMP 0x001e689b
LAB_001e689b:
MOV RCX,qword ptr [RBP + -0x18]
ADD RCX,0x8
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x68],RCX
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x8
MOV RSI,qword ptr [RBP + -0x8]
ADD RSI,0xc0
LEA RDX,[0x2554d1]
MOV ECX,0x68f
CALL 0x001e61e0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x68],0x0
JMP 0x001e6885
LAB_001e68dd:
ADD RSP,0x20
POP RBP
RET
|
void wait_for_readers(long param_1,long param_2)
{
long lVar1;
lVar1 = _my_thread_var();
while (*(int *)(*(long *)(param_2 + 0x20) + 0x28) != 0) {
*(long *)(param_2 + 0x68) = lVar1 + 8;
inline_mysql_cond_wait
(lVar1 + 8,param_1 + 0xc0,
"/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c",0x68f);
*(int8 *)(param_2 + 0x68) = 0;
}
return;
}
| |
53,927 | translog_read_record_header | eloqsql/storage/maria/ma_loghandler.c | int translog_read_record_header(LSN lsn, TRANSLOG_HEADER_BUFFER *buff)
{
TRANSLOG_PAGE_SIZE_BUFF psize_buff;
uchar *page;
translog_size_t res, page_offset= LSN_OFFSET(lsn) % TRANSLOG_PAGE_SIZE;
PAGECACHE_BLOCK_LINK *direct_link;
TRANSLOG_ADDRESS addr;
TRANSLOG_VALIDATOR_DATA data;
DBUG_ENTER("translog_read_record_header");
DBUG_PRINT("enter", ("LSN: " LSN_FMT, LSN_IN_PARTS(lsn)));
DBUG_ASSERT(LSN_OFFSET(lsn) % TRANSLOG_PAGE_SIZE != 0);
DBUG_ASSERT(translog_status == TRANSLOG_OK ||
translog_status == TRANSLOG_READONLY);
buff->lsn= lsn;
buff->groups_no= 0;
data.addr= &addr;
data.was_recovered= 0;
addr= lsn;
addr-= page_offset; /* offset decreasing */
res= (!(page= translog_get_page(&data, psize_buff.buffer, &direct_link))) ?
RECHEADER_READ_ERROR :
translog_read_record_header_from_buffer(page, page_offset, buff, 0);
translog_free_link(direct_link);
DBUG_RETURN(res);
} | O0 | c | translog_read_record_header:
pushq %rbp
movq %rsp, %rbp
subq $0x2050, %rsp # imm = 0x2050
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x2010(%rbp)
movq %rsi, -0x2018(%rbp)
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq -0x2010(%rbp), %rax
andq $0x1fff, %rax # imm = 0x1FFF
movl %eax, -0x2028(%rbp)
jmp 0x53085
jmp 0x53087
jmp 0x53089
jmp 0x5308b
jmp 0x5308d
movq -0x2010(%rbp), %rcx
movq -0x2018(%rbp), %rax
movq %rcx, (%rax)
movq -0x2018(%rbp), %rax
movl $0x0, 0x418(%rax)
leaq -0x2038(%rbp), %rax
movq %rax, -0x2048(%rbp)
movb $0x0, -0x2040(%rbp)
movq -0x2010(%rbp), %rax
movq %rax, -0x2038(%rbp)
movl -0x2028(%rbp), %eax
movl %eax, %ecx
movq -0x2038(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x2038(%rbp)
leaq -0x2008(%rbp), %rsi
leaq -0x2048(%rbp), %rdi
leaq -0x2030(%rbp), %rdx
callq 0x52160
movq %rax, -0x2020(%rbp)
cmpq $0x0, %rax
jne 0x5311f
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
movl %eax, -0x204c(%rbp)
jmp 0x53143
movq -0x2020(%rbp), %rdi
movl -0x2028(%rbp), %eax
movq -0x2018(%rbp), %rdx
xorl %ecx, %ecx
movzwl %ax, %esi
callq 0x54da0
movl %eax, -0x204c(%rbp)
movl -0x204c(%rbp), %eax
movl %eax, -0x2024(%rbp)
movq -0x2030(%rbp), %rdi
callq 0x54d40
movl -0x2024(%rbp), %eax
movl %eax, -0x2050(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x53188
movl -0x2050(%rbp), %eax
addq $0x2050, %rsp # imm = 0x2050
popq %rbp
retq
callq 0x2a270
nopl (%rax)
| translog_read_record_header:
push rbp
mov rbp, rsp
sub rsp, 2050h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_2010], rdi
mov [rbp+var_2018], rsi
mov rax, 0FFFFFFFFh
and rax, [rbp+var_2010]
and rax, 1FFFh
mov [rbp+var_2028], eax
jmp short $+2
loc_53085:
jmp short $+2
loc_53087:
jmp short $+2
loc_53089:
jmp short $+2
loc_5308B:
jmp short $+2
loc_5308D:
mov rcx, [rbp+var_2010]
mov rax, [rbp+var_2018]
mov [rax], rcx
mov rax, [rbp+var_2018]
mov dword ptr [rax+418h], 0
lea rax, [rbp+var_2038]
mov [rbp+var_2048], rax
mov [rbp+var_2040], 0
mov rax, [rbp+var_2010]
mov [rbp+var_2038], rax
mov eax, [rbp+var_2028]
mov ecx, eax
mov rax, [rbp+var_2038]
sub rax, rcx
mov [rbp+var_2038], rax
lea rsi, [rbp+var_2008]
lea rdi, [rbp+var_2048]
lea rdx, [rbp+var_2030]
call translog_get_page
mov [rbp+var_2020], rax
cmp rax, 0
jnz short loc_5311F
mov eax, 0FFFFFFFFh
mov [rbp+var_204C], eax
jmp short loc_53143
loc_5311F:
mov rdi, [rbp+var_2020]
mov eax, [rbp+var_2028]
mov rdx, [rbp+var_2018]
xor ecx, ecx
movzx esi, ax
call translog_read_record_header_from_buffer
mov [rbp+var_204C], eax
loc_53143:
mov eax, [rbp+var_204C]
mov [rbp+var_2024], eax
mov rdi, [rbp+var_2030]
call translog_free_link
mov eax, [rbp+var_2024]
mov [rbp+var_2050], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_53188
mov eax, [rbp+var_2050]
add rsp, 2050h
pop rbp
retn
loc_53188:
call ___stack_chk_fail
| long long translog_read_record_header(long long a1, _QWORD *a2)
{
int record_header_from_buffer; // [rsp+4h] [rbp-204Ch]
long long *v4; // [rsp+8h] [rbp-2048h] BYREF
char v5; // [rsp+10h] [rbp-2040h]
long long v6; // [rsp+18h] [rbp-2038h] BYREF
long long v7; // [rsp+20h] [rbp-2030h] BYREF
unsigned int v8; // [rsp+28h] [rbp-2028h]
unsigned int v9; // [rsp+2Ch] [rbp-2024h]
long long page; // [rsp+30h] [rbp-2020h]
_QWORD *v11; // [rsp+38h] [rbp-2018h]
long long v12; // [rsp+40h] [rbp-2010h]
_BYTE v13[8192]; // [rsp+48h] [rbp-2008h] BYREF
unsigned long long v14; // [rsp+2048h] [rbp-8h]
v14 = __readfsqword(0x28u);
v12 = a1;
v11 = a2;
v8 = a1 & 0x1FFF;
*a2 = a1;
*((_DWORD *)v11 + 262) = 0;
v4 = &v6;
v5 = 0;
v6 = v12 - v8;
page = translog_get_page(&v4, (long long)v13, (char *)&v7);
if ( page )
record_header_from_buffer = translog_read_record_header_from_buffer(page, (unsigned __int16)v8, v11, 0LL);
else
record_header_from_buffer = -1;
v9 = record_header_from_buffer;
translog_free_link(v7);
return v9;
}
| translog_read_record_header:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x2050
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x2010],RDI
MOV qword ptr [RBP + -0x2018],RSI
MOV RAX,0xffffffff
AND RAX,qword ptr [RBP + -0x2010]
AND RAX,0x1fff
MOV dword ptr [RBP + -0x2028],EAX
JMP 0x00153085
LAB_00153085:
JMP 0x00153087
LAB_00153087:
JMP 0x00153089
LAB_00153089:
JMP 0x0015308b
LAB_0015308b:
JMP 0x0015308d
LAB_0015308d:
MOV RCX,qword ptr [RBP + -0x2010]
MOV RAX,qword ptr [RBP + -0x2018]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x2018]
MOV dword ptr [RAX + 0x418],0x0
LEA RAX,[RBP + -0x2038]
MOV qword ptr [RBP + -0x2048],RAX
MOV byte ptr [RBP + -0x2040],0x0
MOV RAX,qword ptr [RBP + -0x2010]
MOV qword ptr [RBP + -0x2038],RAX
MOV EAX,dword ptr [RBP + -0x2028]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x2038]
SUB RAX,RCX
MOV qword ptr [RBP + -0x2038],RAX
LEA RSI,[RBP + -0x2008]
LEA RDI,[RBP + -0x2048]
LEA RDX,[RBP + -0x2030]
CALL 0x00152160
MOV qword ptr [RBP + -0x2020],RAX
CMP RAX,0x0
JNZ 0x0015311f
MOV EAX,0xffffffff
MOV dword ptr [RBP + -0x204c],EAX
JMP 0x00153143
LAB_0015311f:
MOV RDI,qword ptr [RBP + -0x2020]
MOV EAX,dword ptr [RBP + -0x2028]
MOV RDX,qword ptr [RBP + -0x2018]
XOR ECX,ECX
MOVZX ESI,AX
CALL 0x00154da0
MOV dword ptr [RBP + -0x204c],EAX
LAB_00153143:
MOV EAX,dword ptr [RBP + -0x204c]
MOV dword ptr [RBP + -0x2024],EAX
MOV RDI,qword ptr [RBP + -0x2030]
CALL 0x00154d40
MOV EAX,dword ptr [RBP + -0x2024]
MOV dword ptr [RBP + -0x2050],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00153188
MOV EAX,dword ptr [RBP + -0x2050]
ADD RSP,0x2050
POP RBP
RET
LAB_00153188:
CALL 0x0012a270
|
int4 translog_read_record_header(long param_1,long *param_2)
{
long in_FS_OFFSET;
int4 local_2054;
long *local_2050;
int1 local_2048;
long local_2040;
int8 local_2038;
uint local_2030;
int4 local_202c;
long local_2028;
long *local_2020;
long local_2018;
int1 local_2010 [8192];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_2030 = (uint)param_1 & 0x1fff;
*param_2 = param_1;
*(int4 *)(param_2 + 0x83) = 0;
local_2050 = &local_2040;
local_2048 = 0;
local_2040 = param_1 - (ulong)local_2030;
local_2020 = param_2;
local_2018 = param_1;
local_2028 = translog_get_page(&local_2050,local_2010,&local_2038);
if (local_2028 == 0) {
local_2054 = 0xffffffff;
}
else {
local_2054 = translog_read_record_header_from_buffer
(local_2028,local_2030 & 0xffff,local_2020,0);
}
local_202c = local_2054;
translog_free_link(local_2038);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return local_202c;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
53,928 | testing::Message& testing::Message::operator<<<char [7]>(char const (&) [7]) | seiftnesse[P]memoryallocator/build_O0/_deps/googletest-src/googletest/include/gtest/gtest-message.h | inline Message& operator<<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the global
// namespace, but not other namespaces, including the testing
// namespace which Google Test's Message class is in.
//
// To allow STL containers (and other types that has a << operator
// defined in the global namespace) to be used in Google Test
// assertions, testing::Message must access the custom << operator
// from the global namespace. With this using declaration,
// overloads of << defined in the global namespace and those
// visible via Koenig lookup are both exposed in this function.
using ::operator<<;
*ss_ << val;
return *this;
} | O0 | c | testing::Message& testing::Message::operator<<<char [7]>(char const (&) [7]):
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x18ed0
movq %rax, %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
callq 0xbdd0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| _ZN7testing7MessagelsIdEERS0_RKT_:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rdi, [rbp+var_8]
mov [rbp+var_18], rdi
call _ZNKSt10unique_ptrINSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEESt14default_deleteIS5_EEdeEv; std::unique_ptr<std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>>::operator*(void)
mov rdi, rax
add rdi, 10h
mov rax, [rbp+var_10]
movsd xmm0, qword ptr [rax]
call __ZNSolsEd; std::ostream::operator<<(double)
mov rax, [rbp+var_18]
add rsp, 20h
pop rbp
retn
| long long testing::Message::operator<<<double>(long long a1, double *a2)
{
long long v2; // rax
v2 = std::unique_ptr<std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>>::operator*(a1);
std::ostream::operator<<(v2 + 16, *a2);
return a1;
}
| operator<<:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RDI,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x18],RDI
CALL 0x00118ed0
MOV RDI,RAX
ADD RDI,0x10
MOV RAX,qword ptr [RBP + -0x10]
MOVSD XMM0,qword ptr [RAX]
CALL 0x0010bdd0
MOV RAX,qword ptr [RBP + -0x18]
ADD RSP,0x20
POP RBP
RET
|
/* testing::Message& testing::Message::TEMPNAMEPLACEHOLDERVALUE(double const&) */
Message * __thiscall testing::Message::operator<<(Message *this,double *param_1)
{
long lVar1;
lVar1 = std::
unique_ptr<std::__cxx11::stringstream,std::default_delete<std::__cxx11::stringstream>>::
operator*((unique_ptr<std::__cxx11::stringstream,std::default_delete<std::__cxx11::stringstream>>
*)this);
std::ostream::operator<<((ostream *)(lVar1 + 0x10),*param_1);
return this;
}
| |
53,929 | mysql_local_infile_read | eloqsql/libmariadb/libmariadb/ma_loaddata.c | static
int mysql_local_infile_read(void *ptr, char * buf, unsigned int buf_len)
{
MYSQL_INFILE_INFO *info = (MYSQL_INFILE_INFO *)ptr;
size_t count;
count= ma_read((void *)buf, 1, (size_t)buf_len, info->fp);
if (count == (size_t)-1)
{
info->error_no = errno;
snprintf((char *)info->error_msg, sizeof(info->error_msg),
CER(CR_FILE_READ), info->filename, info->error_no);
}
return((int)count);
} | O3 | c | mysql_local_infile_read:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rax
movq %rdi, %rbx
movl %edx, %edx
movq (%rdi), %rcx
movl $0x1, %esi
movq %rax, %rdi
callq 0x2ad16
movq %rax, %r14
cmpq $-0x1, %rax
jne 0x25adf
callq 0x13060
movl (%rax), %eax
movl %eax, 0x8(%rbx)
leaq 0x283fc(%rip), %rcx # 0x4deb0
movq 0x28(%rcx), %r8
movq 0x210(%rbx), %r9
addq $0xc, %rbx
movl %eax, (%rsp)
movl $0x201, %esi # imm = 0x201
movl $0x201, %ecx # imm = 0x201
movq %rbx, %rdi
movl $0x1, %edx
xorl %eax, %eax
callq 0x132c0
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
| mysql_local_infile_read:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 10h
mov rax, rsi
mov rbx, rdi
mov edx, edx
mov rcx, [rdi]
mov esi, 1
mov rdi, rax
call ma_read
mov r14, rax
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_25ADF
call ___errno_location
mov eax, [rax]
mov [rbx+8], eax
lea rcx, mariadb_client_errors
mov r8, [rcx+28h]
mov r9, [rbx+210h]
add rbx, 0Ch
mov [rsp+20h+var_20], eax
mov esi, 201h
mov ecx, 201h
mov rdi, rbx
mov edx, 1
xor eax, eax
call ___snprintf_chk
loc_25ADF:
mov eax, r14d
add rsp, 10h
pop rbx
pop r14
pop rbp
retn
| long long mysql_local_infile_read(long long a1, long long a2, unsigned int a3)
{
long long v3; // r14
int v4; // eax
v3 = ma_read(a2, 1LL, a3, *(_QWORD *)a1);
if ( v3 == -1 )
{
v4 = *(_DWORD *)__errno_location(a2);
*(_DWORD *)(a1 + 8) = v4;
__snprintf_chk(a1 + 12, 513LL, 1LL, 513LL, mariadb_client_errors[5], *(_QWORD *)(a1 + 528), v4);
}
return (unsigned int)v3;
}
| mysql_local_infile_read:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV RAX,RSI
MOV RBX,RDI
MOV EDX,EDX
MOV RCX,qword ptr [RDI]
MOV ESI,0x1
MOV RDI,RAX
CALL 0x0012ad16
MOV R14,RAX
CMP RAX,-0x1
JNZ 0x00125adf
CALL 0x00113060
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBX + 0x8],EAX
LEA RCX,[0x14deb0]
MOV R8,qword ptr [RCX + 0x28]
MOV R9,qword ptr [RBX + 0x210]
ADD RBX,0xc
MOV dword ptr [RSP],EAX
MOV ESI,0x201
MOV ECX,0x201
MOV RDI,RBX
MOV EDX,0x1
XOR EAX,EAX
CALL 0x001132c0
LAB_00125adf:
MOV EAX,R14D
ADD RSP,0x10
POP RBX
POP R14
POP RBP
RET
|
ulong mysql_local_infile_read(int8 *param_1,int8 param_2,int4 param_3)
{
int iVar1;
ulong uVar2;
int *piVar3;
uVar2 = ma_read(param_2,1,param_3,*param_1);
if (uVar2 == 0xffffffffffffffff) {
piVar3 = __errno_location();
iVar1 = *piVar3;
*(int *)(param_1 + 1) = iVar1;
__snprintf_chk((long)param_1 + 0xc,0x201,1,0x201,mariadb_client_errors._40_8_,param_1[0x42],
iVar1);
}
return uVar2 & 0xffffffff;
}
| |
53,930 | my_strnxfrm_win1250ch | eloqsql/strings/ctype-win1250ch.c | static size_t
my_strnxfrm_win1250ch(CHARSET_INFO *cs __attribute__((unused)),
uchar *dest, size_t len,
uint nweights_arg __attribute__((unused)),
const uchar *src, size_t srclen, uint flags)
{
int value;
const uchar *p;
int pass = 0;
size_t totlen = 0;
p = src;
if (!(flags & 0x0F)) /* All levels by default */
flags|= 0x0F;
while (totlen < len)
{
NEXT_CMP_VALUE(src, p, pass, value, (int)srclen);
if (!value)
break;
if ((1 << pass) & flags)
dest[totlen++] = value;
}
if ((flags & MY_STRXFRM_PAD_TO_MAXLEN) && len > totlen)
{
memset(dest + totlen, 0x00, len - totlen);
totlen= len;
}
return totlen;
} | O3 | c | my_strnxfrm_win1250ch:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, -0x50(%rbp)
movl 0x10(%rbp), %eax
movl %eax, %edx
orl $0xf, %edx
testb $0xf, %al
cmovnel %eax, %edx
xorl %r10d, %r10d
testq %rbx, %rbx
je 0x5ca7c
movslq %r9d, %rdi
movl $0x1, %eax
subq %r8, %rax
movq %rax, -0x60(%rbp)
leaq 0x285071(%rip), %r14 # 0x2e1990
leaq 0x29cb3a(%rip), %r15 # 0x2f9460
xorl %eax, %eax
movq %r8, %r11
movq %rbx, -0x48(%rbp)
movq %r9, -0x40(%rbp)
movq %r8, -0x38(%rbp)
movl %edx, -0x2c(%rbp)
movq %r11, %rsi
subq %r8, %rsi
cmpq %rdi, %rsi
jge 0x5c956
testl %r10d, %r10d
je 0x5ca18
movl $0x9, %r12d
jmp 0x5c977
testl %r9d, %r9d
jle 0x5ca80
testl %r10d, %r10d
jne 0x5ca80
movl $0x1, %r10d
movl $0x9, %r12d
movq %r8, %r11
movq %r14, %rsi
movzbl (%r11), %ecx
movb (%rsi,%rcx), %sil
cmpb $-0x1, %sil
jne 0x5ca58
movq %r12, -0x68(%rbp)
movq %r10, -0x58(%rbp)
movq %r11, %rdx
subq %r8, %rdx
movq -0x60(%rbp), %rcx
leaq (%rcx,%r11), %r13
xorl %r10d, %r10d
movq %r10, %rbx
shlq $0x4, %rbx
movq (%rbx,%r15), %rsi
movb (%rsi), %r9b
testb %r9b, %r9b
je 0x5c9e8
cmpq %rdi, %rdx
jge 0x5c9e8
incq %rsi
movq %r13, %r14
movq %r11, %r12
cmpb (%r12), %r9b
jne 0x5c9f0
incq %r12
movb (%rsi), %r9b
testb %r9b, %r9b
je 0x5c9eb
leaq 0x1(%r14), %rcx
incq %rsi
cmpq %rdi, %r14
movq %rcx, %r14
jl 0x5c9c6
jmp 0x5c9eb
movq %r11, %r12
testb %r9b, %r9b
je 0x5ca2d
incq %r10
cmpq $0x50, %r10
jne 0x5c9a5
movb $-0x1, %sil
movq -0x48(%rbp), %rbx
movq -0x40(%rbp), %r9
movq -0x38(%rbp), %r8
movl -0x2c(%rbp), %edx
movq -0x58(%rbp), %r10
leaq 0x284f7a(%rip), %r14 # 0x2e1990
jmp 0x5ca5d
xorl %r10d, %r10d
movl $0x8, %r12d
leaq 0x284e68(%rip), %rsi # 0x2e1890
jmp 0x5c97a
addq %r15, %rbx
movq -0x68(%rbp), %rcx
movb (%rbx,%rcx), %sil
decq %r12
movq %r12, %r11
movq -0x48(%rbp), %rbx
movq -0x40(%rbp), %r9
movq -0x38(%rbp), %r8
movl -0x2c(%rbp), %edx
movq -0x58(%rbp), %r10
leaq 0x284f38(%rip), %r14 # 0x2e1990
testb %sil, %sil
je 0x5ca80
btl %r10d, %edx
jae 0x5ca6e
movq -0x50(%rbp), %rcx
movb %sil, (%rcx,%rax)
incq %rax
incq %r11
cmpq %rbx, %rax
jb 0x5c93a
jmp 0x5ca9b
xorl %eax, %eax
jmp 0x5ca9b
testb %dl, %dl
jns 0x5ca9b
movq -0x50(%rbp), %rdi
addq %rax, %rdi
movq %rbx, %rdx
subq %rax, %rdx
xorl %esi, %esi
callq 0x241e0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_strnxfrm_win1250ch:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov rbx, rdx
mov [rbp+var_50], rsi
mov eax, [rbp+arg_0]
mov edx, eax
or edx, 0Fh
test al, 0Fh
cmovnz edx, eax
xor r10d, r10d
test rbx, rbx
jz loc_5CA7C
movsxd rdi, r9d
mov eax, 1
sub rax, r8
mov [rbp+var_60], rax
lea r14, _sort_order_win1250ch2
lea r15, doubles_0
xor eax, eax
mov r11, r8
mov [rbp+var_48], rbx
mov [rbp+var_40], r9
mov [rbp+var_38], r8
mov [rbp+var_2C], edx
loc_5C93A:
mov rsi, r11
sub rsi, r8
cmp rsi, rdi
jge short loc_5C956
test r10d, r10d
jz loc_5CA18
mov r12d, 9
jmp short loc_5C977
loc_5C956:
test r9d, r9d
jle loc_5CA80
test r10d, r10d
jnz loc_5CA80
mov r10d, 1
mov r12d, 9
mov r11, r8
loc_5C977:
mov rsi, r14
loc_5C97A:
movzx ecx, byte ptr [r11]
mov sil, [rsi+rcx]
cmp sil, 0FFh
jnz loc_5CA58
mov [rbp+var_68], r12
mov [rbp+var_58], r10
mov rdx, r11
sub rdx, r8
mov rcx, [rbp+var_60]
lea r13, [rcx+r11]
xor r10d, r10d
loc_5C9A5:
mov rbx, r10
shl rbx, 4
mov rsi, [rbx+r15]
mov r9b, [rsi]
test r9b, r9b
jz short loc_5C9E8
cmp rdx, rdi
jge short loc_5C9E8
inc rsi
mov r14, r13
mov r12, r11
loc_5C9C6:
cmp r9b, [r12]
jnz short loc_5C9F0
inc r12
mov r9b, [rsi]
test r9b, r9b
jz short loc_5C9EB
lea rcx, [r14+1]
inc rsi
cmp r14, rdi
mov r14, rcx
jl short loc_5C9C6
jmp short loc_5C9EB
loc_5C9E8:
mov r12, r11
loc_5C9EB:
test r9b, r9b
jz short loc_5CA2D
loc_5C9F0:
inc r10
cmp r10, 50h ; 'P'
jnz short loc_5C9A5
mov sil, 0FFh
mov rbx, [rbp+var_48]
mov r9, [rbp+var_40]
mov r8, [rbp+var_38]
mov edx, [rbp+var_2C]
mov r10, [rbp+var_58]
lea r14, _sort_order_win1250ch2
jmp short loc_5CA5D
loc_5CA18:
xor r10d, r10d
mov r12d, 8
lea rsi, _sort_order_win1250ch1
jmp loc_5C97A
loc_5CA2D:
add rbx, r15
mov rcx, [rbp+var_68]
mov sil, [rbx+rcx]
dec r12
mov r11, r12
mov rbx, [rbp+var_48]
mov r9, [rbp+var_40]
mov r8, [rbp+var_38]
mov edx, [rbp+var_2C]
mov r10, [rbp+var_58]
lea r14, _sort_order_win1250ch2
loc_5CA58:
test sil, sil
jz short loc_5CA80
loc_5CA5D:
bt edx, r10d
jnb short loc_5CA6E
mov rcx, [rbp+var_50]
mov [rcx+rax], sil
inc rax
loc_5CA6E:
inc r11
cmp rax, rbx
jb loc_5C93A
jmp short loc_5CA9B
loc_5CA7C:
xor eax, eax
jmp short loc_5CA9B
loc_5CA80:
test dl, dl
jns short loc_5CA9B
mov rdi, [rbp+var_50]
add rdi, rax
mov rdx, rbx
sub rdx, rax
xor esi, esi
call _memset
mov rax, rbx
loc_5CA9B:
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| unsigned long long my_strnxfrm_win1250ch(
long long a1,
long long a2,
unsigned long long a3,
long long a4,
unsigned __int8 *a5,
int a6,
int a7)
{
int v8; // edx
long long v9; // r10
long long v10; // rdi
unsigned long long result; // rax
unsigned __int8 *v12; // r11
long long v13; // r12
_BYTE *v14; // rsi
char v15; // si
long long v16; // r10
char *v17; // rsi
char v18; // r9
char *v19; // rsi
unsigned __int8 *v20; // r14
_BYTE *v21; // r12
long long v23; // [rsp+8h] [rbp-68h]
long long v24; // [rsp+10h] [rbp-60h]
long long v25; // [rsp+18h] [rbp-58h]
unsigned long long v27; // [rsp+28h] [rbp-48h]
int v28; // [rsp+30h] [rbp-40h]
unsigned __int8 *v29; // [rsp+38h] [rbp-38h]
int v30; // [rsp+44h] [rbp-2Ch]
v8 = a7 | 0xF;
if ( (a7 & 0xF) != 0 )
v8 = a7;
v9 = 0LL;
if ( !a3 )
return 0LL;
v10 = a6;
v24 = 1LL - (_QWORD)a5;
result = 0LL;
v12 = a5;
v27 = a3;
v28 = a6;
v29 = a5;
v30 = v8;
while ( 2 )
{
if ( v12 - a5 >= v10 )
{
if ( a6 <= 0 || (_DWORD)v9 )
break;
v9 = 1LL;
v13 = 9LL;
v12 = a5;
}
else
{
if ( !(_DWORD)v9 )
{
v9 = 0LL;
v13 = 8LL;
v14 = &sort_order_win1250ch1;
goto LABEL_12;
}
v13 = 9LL;
}
v14 = &sort_order_win1250ch2;
LABEL_12:
v15 = v14[*v12];
if ( v15 != -1 )
goto LABEL_27;
v23 = v13;
v25 = v9;
v16 = 0LL;
while ( 1 )
{
v17 = (char *)*(&doubles_0 + 2 * v16);
v18 = *v17;
if ( !*v17 || v12 - a5 >= v10 )
break;
v19 = v17 + 1;
v20 = &v12[v24];
v21 = v12;
while ( v18 == *v21 )
{
++v21;
v18 = *v19;
if ( *v19 )
{
++v19;
if ( (long long)v20++ < v10 )
continue;
}
goto LABEL_22;
}
LABEL_23:
if ( ++v16 == 80 )
{
v15 = -1;
a3 = v27;
a6 = v28;
a5 = v29;
v8 = v30;
v9 = v25;
goto LABEL_28;
}
}
v21 = v12;
LABEL_22:
if ( v18 )
goto LABEL_23;
v15 = *((_BYTE *)&doubles_0 + 16 * v16 + v23);
v12 = v21 - 1;
a3 = v27;
a6 = v28;
a5 = v29;
v8 = v30;
v9 = v25;
LABEL_27:
if ( v15 )
{
LABEL_28:
if ( _bittest(&v8, v9) )
*(_BYTE *)(a2 + result++) = v15;
++v12;
if ( result >= a3 )
return result;
continue;
}
break;
}
if ( (v8 & 0x80u) != 0 )
{
memset(result + a2, 0LL, a3 - result);
return a3;
}
return result;
}
| my_strnxfrm_win1250ch:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV RBX,RDX
MOV qword ptr [RBP + -0x50],RSI
MOV EAX,dword ptr [RBP + 0x10]
MOV EDX,EAX
OR EDX,0xf
TEST AL,0xf
CMOVNZ EDX,EAX
XOR R10D,R10D
TEST RBX,RBX
JZ 0x0015ca7c
MOVSXD RDI,R9D
MOV EAX,0x1
SUB RAX,R8
MOV qword ptr [RBP + -0x60],RAX
LEA R14,[0x3e1990]
LEA R15,[0x3f9460]
XOR EAX,EAX
MOV R11,R8
MOV qword ptr [RBP + -0x48],RBX
MOV qword ptr [RBP + -0x40],R9
MOV qword ptr [RBP + -0x38],R8
MOV dword ptr [RBP + -0x2c],EDX
LAB_0015c93a:
MOV RSI,R11
SUB RSI,R8
CMP RSI,RDI
JGE 0x0015c956
TEST R10D,R10D
JZ 0x0015ca18
MOV R12D,0x9
JMP 0x0015c977
LAB_0015c956:
TEST R9D,R9D
JLE 0x0015ca80
TEST R10D,R10D
JNZ 0x0015ca80
MOV R10D,0x1
MOV R12D,0x9
MOV R11,R8
LAB_0015c977:
MOV RSI,R14
LAB_0015c97a:
MOVZX ECX,byte ptr [R11]
MOV SIL,byte ptr [RSI + RCX*0x1]
CMP SIL,0xff
JNZ 0x0015ca58
MOV qword ptr [RBP + -0x68],R12
MOV qword ptr [RBP + -0x58],R10
MOV RDX,R11
SUB RDX,R8
MOV RCX,qword ptr [RBP + -0x60]
LEA R13,[RCX + R11*0x1]
XOR R10D,R10D
LAB_0015c9a5:
MOV RBX,R10
SHL RBX,0x4
MOV RSI,qword ptr [RBX + R15*0x1]
MOV R9B,byte ptr [RSI]
TEST R9B,R9B
JZ 0x0015c9e8
CMP RDX,RDI
JGE 0x0015c9e8
INC RSI
MOV R14,R13
MOV R12,R11
LAB_0015c9c6:
CMP R9B,byte ptr [R12]
JNZ 0x0015c9f0
INC R12
MOV R9B,byte ptr [RSI]
TEST R9B,R9B
JZ 0x0015c9eb
LEA RCX,[R14 + 0x1]
INC RSI
CMP R14,RDI
MOV R14,RCX
JL 0x0015c9c6
JMP 0x0015c9eb
LAB_0015c9e8:
MOV R12,R11
LAB_0015c9eb:
TEST R9B,R9B
JZ 0x0015ca2d
LAB_0015c9f0:
INC R10
CMP R10,0x50
JNZ 0x0015c9a5
MOV SIL,0xff
MOV RBX,qword ptr [RBP + -0x48]
MOV R9,qword ptr [RBP + -0x40]
MOV R8,qword ptr [RBP + -0x38]
MOV EDX,dword ptr [RBP + -0x2c]
MOV R10,qword ptr [RBP + -0x58]
LEA R14,[0x3e1990]
JMP 0x0015ca5d
LAB_0015ca18:
XOR R10D,R10D
MOV R12D,0x8
LEA RSI,[0x3e1890]
JMP 0x0015c97a
LAB_0015ca2d:
ADD RBX,R15
MOV RCX,qword ptr [RBP + -0x68]
MOV SIL,byte ptr [RBX + RCX*0x1]
DEC R12
MOV R11,R12
MOV RBX,qword ptr [RBP + -0x48]
MOV R9,qword ptr [RBP + -0x40]
MOV R8,qword ptr [RBP + -0x38]
MOV EDX,dword ptr [RBP + -0x2c]
MOV R10,qword ptr [RBP + -0x58]
LEA R14,[0x3e1990]
LAB_0015ca58:
TEST SIL,SIL
JZ 0x0015ca80
LAB_0015ca5d:
BT EDX,R10D
JNC 0x0015ca6e
MOV RCX,qword ptr [RBP + -0x50]
MOV byte ptr [RCX + RAX*0x1],SIL
INC RAX
LAB_0015ca6e:
INC R11
CMP RAX,RBX
JC 0x0015c93a
JMP 0x0015ca9b
LAB_0015ca7c:
XOR EAX,EAX
JMP 0x0015ca9b
LAB_0015ca80:
TEST DL,DL
JNS 0x0015ca9b
MOV RDI,qword ptr [RBP + -0x50]
ADD RDI,RAX
MOV RDX,RBX
SUB RDX,RAX
XOR ESI,ESI
CALL 0x001241e0
MOV RAX,RBX
LAB_0015ca9b:
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong my_strnxfrm_win1250ch
(int8 param_1,long param_2,ulong param_3,int8 param_4,byte *param_5,
int param_6,uint param_7)
{
uint uVar1;
byte *pbVar2;
byte *pbVar3;
byte *pbVar4;
ulong uVar5;
char cVar6;
int1 *puVar7;
byte *pbVar8;
byte bVar9;
int iVar10;
long lVar11;
byte *pbVar12;
byte *pbVar13;
long lVar14;
uVar1 = param_7 | 0xf;
if ((param_7 & 0xf) != 0) {
uVar1 = param_7;
}
iVar10 = 0;
if (param_3 == 0) {
uVar5 = 0;
}
else {
uVar5 = 0;
pbVar12 = param_5;
do {
if ((long)pbVar12 - (long)param_5 < (long)param_6) {
if (iVar10 != 0) goto LAB_0015c977;
iVar10 = 0;
lVar14 = 8;
puVar7 = _sort_order_win1250ch1;
}
else {
if ((param_6 < 1) || (iVar10 != 0)) goto LAB_0015ca80;
iVar10 = 1;
pbVar12 = param_5;
LAB_0015c977:
lVar14 = 9;
puVar7 = _sort_order_win1250ch2;
}
cVar6 = puVar7[*pbVar12];
if (cVar6 == -1) {
lVar11 = 0;
do {
pbVar8 = (&doubles)[lVar11 * 2];
bVar9 = *pbVar8;
pbVar13 = pbVar12;
pbVar4 = pbVar12 + (1 - (long)param_5);
pbVar3 = pbVar12 + -(long)param_5;
if (bVar9 != 0) {
while (pbVar2 = pbVar4, (long)pbVar3 < (long)param_6) {
pbVar8 = pbVar8 + 1;
if (bVar9 != *pbVar13) goto LAB_0015c9f0;
pbVar13 = pbVar13 + 1;
bVar9 = *pbVar8;
if (bVar9 == 0) break;
pbVar4 = pbVar2 + 1;
pbVar3 = pbVar2;
}
}
if (bVar9 == 0) {
cVar6 = *(char *)((long)&doubles + lVar14 + lVar11 * 0x10);
pbVar12 = pbVar13 + -1;
goto LAB_0015ca58;
}
LAB_0015c9f0:
lVar11 = lVar11 + 1;
} while (lVar11 != 0x50);
cVar6 = -1;
}
else {
LAB_0015ca58:
if (cVar6 == '\0') {
LAB_0015ca80:
if (-1 < (char)uVar1) {
return uVar5;
}
memset((void *)(param_2 + uVar5),0,param_3 - uVar5);
return param_3;
}
}
if ((uVar1 >> iVar10 & 1) != 0) {
*(char *)(param_2 + uVar5) = cVar6;
uVar5 = uVar5 + 1;
}
pbVar12 = pbVar12 + 1;
} while (uVar5 < param_3);
}
return uVar5;
}
| |
53,931 | mi_memmap_file | eloqsql/storage/myisam/mi_packrec.c | my_bool _mi_memmap_file(MI_INFO *info)
{
MYISAM_SHARE *share=info->s;
my_bool eom;
DBUG_ENTER("mi_memmap_file");
if (!info->s->file_map)
{
my_off_t data_file_length= share->state.state.data_file_length;
if (myisam_mmap_size != SIZE_T_MAX)
{
mysql_mutex_lock(&THR_LOCK_myisam_mmap);
eom= data_file_length > myisam_mmap_size - myisam_mmap_used - MEMMAP_EXTRA_MARGIN;
if (!eom)
myisam_mmap_used+= data_file_length + MEMMAP_EXTRA_MARGIN;
mysql_mutex_unlock(&THR_LOCK_myisam_mmap);
}
else
eom= data_file_length > myisam_mmap_size - MEMMAP_EXTRA_MARGIN;
if (eom)
{
DBUG_PRINT("warning", ("File is too large for mmap"));
DBUG_RETURN(0);
}
if (mysql_file_seek(info->dfile, 0L, MY_SEEK_END, MYF(0)) <
share->state.state.data_file_length+MEMMAP_EXTRA_MARGIN)
{
DBUG_PRINT("warning",("File isn't extended for memmap"));
if (myisam_mmap_size != SIZE_T_MAX)
{
mysql_mutex_lock(&THR_LOCK_myisam_mmap);
myisam_mmap_used-= data_file_length + MEMMAP_EXTRA_MARGIN;
mysql_mutex_unlock(&THR_LOCK_myisam_mmap);
}
DBUG_RETURN(0);
}
if (mi_dynmap_file(info,
share->state.state.data_file_length +
MEMMAP_EXTRA_MARGIN))
{
if (myisam_mmap_size != SIZE_T_MAX)
{
mysql_mutex_lock(&THR_LOCK_myisam_mmap);
myisam_mmap_used-= data_file_length + MEMMAP_EXTRA_MARGIN;
mysql_mutex_unlock(&THR_LOCK_myisam_mmap);
}
DBUG_RETURN(0);
}
}
info->opt_flag|= MEMMAP_USED;
info->read_record= share->read_record= _mi_read_mempack_record;
share->read_rnd= _mi_read_rnd_mempack_record;
DBUG_RETURN(1);
} | O3 | c | mi_memmap_file:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq (%rdi), %r13
cmpq $0x0, 0x270(%r13)
je 0x82eae
orb $0x20, 0x1c8(%rbx)
leaq 0x1cd(%rip), %rax # 0x83058
movq %rax, 0x298(%r13)
movq %rax, 0x140(%rbx)
leaq 0x259(%rip), %rax # 0x830f9
movq %rax, 0x2b8(%r13)
movb $0x1, %al
jmp 0x82ff8
movq 0x40(%r13), %r12
leaq 0x30454f(%rip), %r14 # 0x387408
cmpq $-0x1, (%r14)
je 0x82f23
leaq 0xb87bf2(%rip), %r15 # 0xc0aab8
cmpq $0x0, 0x40(%r15)
jne 0x83007
leaq 0xb87be0(%rip), %rdi # 0xc0aab8
callq 0x29220
movq (%r14), %r14
leaq 0xb7ed29(%rip), %rax # 0xc01c10
movq (%rax), %rcx
subq %rcx, %r14
addq $-0x7, %r14
cmpq %r14, %r12
ja 0x82f00
addq %r12, %rcx
addq $0x7, %rcx
movq %rcx, (%rax)
movq 0x40(%r15), %rdi
testq %rdi, %rdi
jne 0x83011
leaq 0xb87ba4(%rip), %rdi # 0xc0aab8
callq 0x291e0
cmpq %r14, %r12
jbe 0x82f2d
jmp 0x82ff6
cmpq $-0x8, %r12
ja 0x82ff6
movl 0x1c0(%rbx), %r14d
leaq 0x305185(%rip), %r15 # 0x3880c0
movq (%r15), %rax
leaq -0x78(%rbp), %rdi
movl %r14d, %esi
movl $0x8, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x83026
movl %r14d, %edi
xorl %esi, %esi
movl $0x2, %edx
xorl %ecx, %ecx
callq 0xa1acc
movq 0x40(%r13), %rsi
addq $0x7, %rsi
cmpq %rsi, %rax
leaq 0x30448c(%rip), %r14 # 0x387408
jae 0x82f99
cmpq $-0x1, (%r14)
je 0x82ff6
leaq 0xb87b2d(%rip), %rbx # 0xc0aab8
cmpq $0x0, 0x40(%rbx)
je 0x82fc1
callq 0x2e56b
jmp 0x82fcd
movq %rbx, %rdi
callq 0x77948
testb %al, %al
je 0x82e7d
cmpq $-0x1, (%r14)
je 0x82ff6
leaq 0xb87b02(%rip), %rbx # 0xc0aab8
cmpq $0x0, 0x40(%rbx)
jne 0x8304e
leaq 0xb87af0(%rip), %rdi # 0xc0aab8
callq 0x29220
leaq 0xb7ec3c(%rip), %rax # 0xc01c10
movq (%rax), %rcx
subq %r12, %rcx
addq $-0x7, %rcx
movq %rcx, (%rax)
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
jne 0x83043
leaq 0xb87ac7(%rip), %rdi # 0xc0aab8
callq 0x291e0
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2e4d3
jmp 0x82edd
leaq 0x3050a8(%rip), %rax # 0x3880c0
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x82f0d
leaq -0x30(%rbp), %rcx
movq %rax, %rdi
movl %r14d, %esi
movq %rcx, %r14
movq %rcx, %rdx
callq 0x2e4f0
movq (%r14), %rax
jmp 0x82f6a
movq (%r15), %rax
callq *0x160(%rax)
jmp 0x82fea
callq 0x2e54d
jmp 0x82fcd
| _mi_memmap_file:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov rbx, rdi
mov r13, [rdi]
cmp qword ptr [r13+270h], 0
jz short loc_82EAE
loc_82E7D:
or byte ptr [rbx+1C8h], 20h
lea rax, _mi_read_mempack_record
mov [r13+298h], rax
mov [rbx+140h], rax
lea rax, _mi_read_rnd_mempack_record
mov [r13+2B8h], rax
mov al, 1
jmp loc_82FF8
loc_82EAE:
mov r12, [r13+40h]
lea r14, myisam_mmap_size
cmp qword ptr [r14], 0FFFFFFFFFFFFFFFFh
jz short loc_82F23
lea r15, THR_LOCK_myisam_mmap
cmp qword ptr [r15+40h], 0
jnz loc_83007
lea rdi, THR_LOCK_myisam_mmap
call _pthread_mutex_lock
loc_82EDD:
mov r14, [r14]
lea rax, myisam_mmap_used
mov rcx, [rax]
sub r14, rcx
add r14, 0FFFFFFFFFFFFFFF9h
cmp r12, r14
ja short loc_82F00
add rcx, r12
add rcx, 7
mov [rax], rcx
loc_82F00:
mov rdi, [r15+40h]
test rdi, rdi
jnz loc_83011
loc_82F0D:
lea rdi, THR_LOCK_myisam_mmap
call _pthread_mutex_unlock
cmp r12, r14
jbe short loc_82F2D
jmp loc_82FF6
loc_82F23:
cmp r12, 0FFFFFFFFFFFFFFF8h
ja loc_82FF6
loc_82F2D:
mov r14d, [rbx+1C0h]
lea r15, PSI_server
mov rax, [r15]
lea rdi, [rbp+var_78]
mov esi, r14d
mov edx, 8
call qword ptr [rax+158h]
test rax, rax
jnz loc_83026
mov edi, r14d
xor esi, esi
mov edx, 2
xor ecx, ecx
call my_seek
loc_82F6A:
mov rsi, [r13+40h]
add rsi, 7
cmp rax, rsi
lea r14, myisam_mmap_size
jnb short loc_82F99
cmp qword ptr [r14], 0FFFFFFFFFFFFFFFFh
jz short loc_82FF6
lea rbx, THR_LOCK_myisam_mmap
cmp qword ptr [rbx+40h], 0
jz short loc_82FC1
call _mi_memmap_file_cold_4
jmp short loc_82FCD
loc_82F99:
mov rdi, rbx
call mi_dynmap_file
test al, al
jz loc_82E7D
cmp qword ptr [r14], 0FFFFFFFFFFFFFFFFh
jz short loc_82FF6
lea rbx, THR_LOCK_myisam_mmap
cmp qword ptr [rbx+40h], 0
jnz loc_8304E
loc_82FC1:
lea rdi, THR_LOCK_myisam_mmap
call _pthread_mutex_lock
loc_82FCD:
lea rax, myisam_mmap_used
mov rcx, [rax]
sub rcx, r12
add rcx, 0FFFFFFFFFFFFFFF9h
mov [rax], rcx
mov rdi, [rbx+40h]
test rdi, rdi
jnz short loc_83043
loc_82FEA:
lea rdi, THR_LOCK_myisam_mmap
call _pthread_mutex_unlock
loc_82FF6:
xor eax, eax
loc_82FF8:
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_83007:
call _mi_memmap_file_cold_1
jmp loc_82EDD
loc_83011:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp loc_82F0D
loc_83026:
lea rcx, [rbp+var_30]
mov rdi, rax
mov esi, r14d
mov r14, rcx
mov rdx, rcx
call _mi_memmap_file_cold_2
mov rax, [r14]
jmp loc_82F6A
loc_83043:
mov rax, [r15]
call qword ptr [rax+160h]
jmp short loc_82FEA
loc_8304E:
call _mi_memmap_file_cold_3
jmp loc_82FCD
| char mi_memmap_file(unsigned int *a1)
{
_QWORD *v1; // r13
unsigned long long v3; // r12
unsigned long long v4; // r14
unsigned int v5; // r14d
long long v6; // rax
unsigned long long v7; // rax
unsigned long long v8; // rsi
_BYTE v9[72]; // [rsp+8h] [rbp-78h] BYREF
unsigned long long v10[6]; // [rsp+50h] [rbp-30h] BYREF
v1 = *(_QWORD **)a1;
if ( *(_QWORD *)(*(_QWORD *)a1 + 624LL) )
goto LABEL_2;
v3 = v1[8];
if ( myisam_mmap_size == -1LL )
{
if ( v3 > 0xFFFFFFFFFFFFFFF8LL )
return 0;
}
else
{
if ( THR_LOCK_myisam_mmap[8] )
mi_memmap_file_cold_1();
else
pthread_mutex_lock(THR_LOCK_myisam_mmap);
v4 = myisam_mmap_size - myisam_mmap_used - 7LL;
if ( v3 <= v4 )
myisam_mmap_used += v3 + 7;
if ( THR_LOCK_myisam_mmap[8] )
PSI_server[44]();
pthread_mutex_unlock(THR_LOCK_myisam_mmap);
if ( v3 > v4 )
return 0;
}
v5 = a1[112];
v6 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v9, v5, 8LL);
if ( v6 )
{
mi_memmap_file_cold_2(v6, v5, v10);
v7 = v10[0];
}
else
{
v7 = my_seek(v5, 0LL, 2LL, 0LL);
}
v8 = v1[8] + 7LL;
if ( v7 >= v8 )
{
if ( !(unsigned __int8)mi_dynmap_file(a1, v8) )
{
LABEL_2:
*((_BYTE *)a1 + 456) |= 0x20u;
v1[83] = mi_read_mempack_record;
*((_QWORD *)a1 + 40) = mi_read_mempack_record;
v1[87] = mi_read_rnd_mempack_record;
return 1;
}
if ( myisam_mmap_size != -1LL )
{
if ( THR_LOCK_myisam_mmap[8] )
{
mi_memmap_file_cold_3();
goto LABEL_23;
}
goto LABEL_22;
}
}
else if ( myisam_mmap_size != -1LL )
{
if ( THR_LOCK_myisam_mmap[8] )
{
mi_memmap_file_cold_4();
LABEL_23:
myisam_mmap_used = myisam_mmap_used - v3 - 7;
if ( THR_LOCK_myisam_mmap[8] )
PSI_server[44]();
pthread_mutex_unlock(THR_LOCK_myisam_mmap);
return 0;
}
LABEL_22:
pthread_mutex_lock(THR_LOCK_myisam_mmap);
goto LABEL_23;
}
return 0;
}
| _mi_memmap_file:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV RBX,RDI
MOV R13,qword ptr [RDI]
CMP qword ptr [R13 + 0x270],0x0
JZ 0x00182eae
LAB_00182e7d:
OR byte ptr [RBX + 0x1c8],0x20
LEA RAX,[0x183058]
MOV qword ptr [R13 + 0x298],RAX
MOV qword ptr [RBX + 0x140],RAX
LEA RAX,[0x1830f9]
MOV qword ptr [R13 + 0x2b8],RAX
MOV AL,0x1
JMP 0x00182ff8
LAB_00182eae:
MOV R12,qword ptr [R13 + 0x40]
LEA R14,[0x487408]
CMP qword ptr [R14],-0x1
JZ 0x00182f23
LEA R15,[0xd0aab8]
CMP qword ptr [R15 + 0x40],0x0
JNZ 0x00183007
LEA RDI,[0xd0aab8]
CALL 0x00129220
LAB_00182edd:
MOV R14,qword ptr [R14]
LEA RAX,[0xd01c10]
MOV RCX,qword ptr [RAX]
SUB R14,RCX
ADD R14,-0x7
CMP R12,R14
JA 0x00182f00
ADD RCX,R12
ADD RCX,0x7
MOV qword ptr [RAX],RCX
LAB_00182f00:
MOV RDI,qword ptr [R15 + 0x40]
TEST RDI,RDI
JNZ 0x00183011
LAB_00182f0d:
LEA RDI,[0xd0aab8]
CALL 0x001291e0
CMP R12,R14
JBE 0x00182f2d
JMP 0x00182ff6
LAB_00182f23:
CMP R12,-0x8
JA 0x00182ff6
LAB_00182f2d:
MOV R14D,dword ptr [RBX + 0x1c0]
LEA R15,[0x4880c0]
MOV RAX,qword ptr [R15]
LEA RDI,[RBP + -0x78]
MOV ESI,R14D
MOV EDX,0x8
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x00183026
MOV EDI,R14D
XOR ESI,ESI
MOV EDX,0x2
XOR ECX,ECX
CALL 0x001a1acc
LAB_00182f6a:
MOV RSI,qword ptr [R13 + 0x40]
ADD RSI,0x7
CMP RAX,RSI
LEA R14,[0x487408]
JNC 0x00182f99
CMP qword ptr [R14],-0x1
JZ 0x00182ff6
LEA RBX,[0xd0aab8]
CMP qword ptr [RBX + 0x40],0x0
JZ 0x00182fc1
CALL 0x0012e56b
JMP 0x00182fcd
LAB_00182f99:
MOV RDI,RBX
CALL 0x00177948
TEST AL,AL
JZ 0x00182e7d
CMP qword ptr [R14],-0x1
JZ 0x00182ff6
LEA RBX,[0xd0aab8]
CMP qword ptr [RBX + 0x40],0x0
JNZ 0x0018304e
LAB_00182fc1:
LEA RDI,[0xd0aab8]
CALL 0x00129220
LAB_00182fcd:
LEA RAX,[0xd01c10]
MOV RCX,qword ptr [RAX]
SUB RCX,R12
ADD RCX,-0x7
MOV qword ptr [RAX],RCX
MOV RDI,qword ptr [RBX + 0x40]
TEST RDI,RDI
JNZ 0x00183043
LAB_00182fea:
LEA RDI,[0xd0aab8]
CALL 0x001291e0
LAB_00182ff6:
XOR EAX,EAX
LAB_00182ff8:
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00183007:
CALL 0x0012e4d3
JMP 0x00182edd
LAB_00183011:
LEA RAX,[0x4880c0]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x00182f0d
LAB_00183026:
LEA RCX,[RBP + -0x30]
MOV RDI,RAX
MOV ESI,R14D
MOV R14,RCX
MOV RDX,RCX
CALL 0x0012e4f0
MOV RAX,qword ptr [R14]
JMP 0x00182f6a
LAB_00183043:
MOV RAX,qword ptr [R15]
CALL qword ptr [RAX + 0x160]
JMP 0x00182fea
LAB_0018304e:
CALL 0x0012e54d
JMP 0x00182fcd
|
int8 _mi_memmap_file(long *param_1)
{
int4 uVar1;
long lVar2;
ulong uVar3;
char cVar4;
long lVar5;
ulong uVar6;
int1 local_80 [72];
ulong local_38;
lVar2 = *param_1;
if (*(long *)(lVar2 + 0x270) != 0) {
LAB_00182e7d:
*(byte *)(param_1 + 0x39) = *(byte *)(param_1 + 0x39) | 0x20;
*(code **)(lVar2 + 0x298) = _mi_read_mempack_record;
param_1[0x28] = (long)_mi_read_mempack_record;
*(code **)(lVar2 + 0x2b8) = _mi_read_rnd_mempack_record;
return 0x183001;
}
uVar3 = *(ulong *)(lVar2 + 0x40);
if (myisam_mmap_size == -1) {
if (0xfffffffffffffff8 < uVar3) {
return 0;
}
}
else {
if (THR_LOCK_myisam_mmap._64_8_ == 0) {
pthread_mutex_lock((pthread_mutex_t *)THR_LOCK_myisam_mmap);
}
else {
_mi_memmap_file_cold_1();
}
uVar6 = (myisam_mmap_size - myisam_mmap_used) - 7;
if (uVar3 <= uVar6) {
myisam_mmap_used = myisam_mmap_used + uVar3 + 7;
}
if (THR_LOCK_myisam_mmap._64_8_ != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock((pthread_mutex_t *)THR_LOCK_myisam_mmap);
if (uVar6 < uVar3) {
return 0;
}
}
uVar1 = (int4)param_1[0x38];
lVar5 = (**(code **)(PSI_server + 0x158))(local_80,uVar1,8);
if (lVar5 == 0) {
local_38 = my_seek(uVar1,0,2,0);
}
else {
_mi_memmap_file_cold_2(lVar5,uVar1,&local_38);
}
if (local_38 < *(long *)(lVar2 + 0x40) + 7U) {
if (myisam_mmap_size == -1) {
return 0;
}
if (THR_LOCK_myisam_mmap._64_8_ != 0) {
_mi_memmap_file_cold_4();
goto LAB_00182fcd;
}
}
else {
cVar4 = mi_dynmap_file(param_1);
if (cVar4 == '\0') goto LAB_00182e7d;
if (myisam_mmap_size == -1) {
return 0;
}
if (THR_LOCK_myisam_mmap._64_8_ != 0) {
_mi_memmap_file_cold_3();
goto LAB_00182fcd;
}
}
pthread_mutex_lock((pthread_mutex_t *)THR_LOCK_myisam_mmap);
LAB_00182fcd:
myisam_mmap_used = (myisam_mmap_used - uVar3) + -7;
if (THR_LOCK_myisam_mmap._64_8_ != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock((pthread_mutex_t *)THR_LOCK_myisam_mmap);
return 0;
}
| |
53,932 | ps_fetch_int32 | eloqsql/libmariadb/libmariadb/ma_stmt_codec.c | static
void ps_fetch_int32(MYSQL_BIND *r_param, const MYSQL_FIELD * const field,
unsigned char **row)
{
switch (r_param->buffer_type) {
/* case MYSQL_TYPE_TINY:
ps_fetch_from_1_to_8_bytes(r_param, field, row, 1);
break;
case MYSQL_TYPE_YEAR:
case MYSQL_TYPE_SHORT:
ps_fetch_from_1_to_8_bytes(r_param, field, row, 2);
break; */
case MYSQL_TYPE_INT24:
case MYSQL_TYPE_LONG:
ps_fetch_from_1_to_8_bytes(r_param, field, row, 4);
break;
default:
{
int32 sval= sint4korr(*row);
longlong lval= field->flags & UNSIGNED_FLAG ? (longlong)(uint32) sval : (longlong)sval;
convert_from_long(r_param, field, lval, field->flags & UNSIGNED_FLAG);
(*row) += 4;
}
break;
}
} | O3 | c | ps_fetch_int32:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl 0x60(%rdi), %eax
cmpl $0x9, %eax
je 0x266f5
cmpl $0x3, %eax
jne 0x26708
movq %rbx, %rdx
movl $0x4, %ecx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x25ad8
movq (%rbx), %rax
movslq (%rax), %rax
movl 0x64(%rsi), %ecx
andl $0x20, %ecx
movl %eax, %edx
cmoveq %rax, %rdx
callq 0x271b3
addq $0x4, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| ps_fetch_int32:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdx
mov eax, [rdi+60h]
cmp eax, 9
jz short loc_266F5
cmp eax, 3
jnz short loc_26708
loc_266F5:
mov rdx, rbx
mov ecx, 4
add rsp, 8
pop rbx
pop rbp
jmp ps_fetch_from_1_to_8_bytes
loc_26708:
mov rax, [rbx]
movsxd rax, dword ptr [rax]
mov ecx, [rsi+64h]
and ecx, 20h
mov edx, eax
cmovz rdx, rax
call convert_from_long
add qword ptr [rbx], 4
add rsp, 8
pop rbx
pop rbp
retn
| long long ps_fetch_int32(long long a1, long long a2, _BYTE **a3)
{
int v4; // eax
long long result; // rax
long long v6; // rdx
v4 = *(_DWORD *)(a1 + 96);
if ( v4 == 9 || v4 == 3 )
return ps_fetch_from_1_to_8_bytes(a1, a2, a3, 4u);
v6 = *(unsigned int *)*a3;
if ( (*(_DWORD *)(a2 + 100) & 0x20) == 0 )
v6 = *(int *)*a3;
result = convert_from_long(a1, a2, v6, *(_DWORD *)(a2 + 100) & 0x20);
*a3 += 4;
return result;
}
| ps_fetch_int32:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV EAX,dword ptr [RDI + 0x60]
CMP EAX,0x9
JZ 0x001266f5
CMP EAX,0x3
JNZ 0x00126708
LAB_001266f5:
MOV RDX,RBX
MOV ECX,0x4
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x00125ad8
LAB_00126708:
MOV RAX,qword ptr [RBX]
MOVSXD RAX,dword ptr [RAX]
MOV ECX,dword ptr [RSI + 0x64]
AND ECX,0x20
MOV EDX,EAX
CMOVZ RDX,RAX
CALL 0x001271b3
ADD qword ptr [RBX],0x4
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void ps_fetch_int32(long param_1,long param_2,long *param_3)
{
ulong uVar1;
if ((*(int *)(param_1 + 0x60) != 9) && (*(int *)(param_1 + 0x60) != 3)) {
uVar1 = (ulong)*(uint *)*param_3;
if ((*(uint *)(param_2 + 100) & 0x20) == 0) {
uVar1 = (long)(int)*(uint *)*param_3;
}
convert_from_long(param_1,param_2,uVar1);
*param_3 = *param_3 + 4;
return;
}
ps_fetch_from_1_to_8_bytes(param_1,param_2,param_3,4);
return;
}
| |
53,933 | Item::val_int_from_str(int*) | eloqsql/sql/item.cc | longlong Item::val_int_from_str(int *error)
{
char buff[MAX_FIELD_WIDTH];
String tmp(buff,sizeof(buff), &my_charset_bin), *res;
/*
For a string result, we must first get the string and then convert it
to a longlong
*/
if (!(res= val_str(&tmp)))
{
*error= 0;
return 0;
}
Converter_strtoll10_with_warn cnv(NULL, Warn_filter_all(),
res->charset(), res->ptr(), res->length());
*error= cnv.error();
return cnv.result();
} | O0 | cpp | Item::val_int_from_str(int*):
pushq %rbp
movq %rsp, %rbp
subq $0x3d0, %rsp # imm = 0x3D0
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x320(%rbp)
movq %rsi, -0x328(%rbp)
movq -0x320(%rbp), %rax
movq %rax, -0x398(%rbp)
leaq 0xe6c535(%rip), %rcx # 0x1b8be10
leaq -0x348(%rbp), %rdi
movq %rdi, -0x390(%rbp)
leaq -0x310(%rbp), %rsi
movl $0x2fe, %edx # imm = 0x2FE
callq 0x857a50
movq -0x398(%rbp), %rdi
movq -0x390(%rbp), %rsi
movq (%rdi), %rax
movq 0x108(%rax), %rax
callq *%rax
movq %rax, -0x388(%rbp)
jmp 0xd1f91d
movq -0x388(%rbp), %rax
movq %rax, -0x350(%rbp)
cmpq $0x0, %rax
jne 0xd1f97b
movq -0x328(%rbp), %rax
movl $0x0, (%rax)
movq $0x0, -0x318(%rbp)
movl $0x1, -0x360(%rbp)
jmp 0xd1fa5f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x358(%rbp)
movl %eax, -0x35c(%rbp)
leaq -0x348(%rbp), %rdi
callq 0x81bf40
jmp 0xd1fa9b
leaq -0x37c(%rbp), %rdi
callq 0x8e8ea0
jmp 0xd1f989
movw -0x37c(%rbp), %ax
movw %ax, -0x37a(%rbp)
movq -0x350(%rbp), %rdi
callq 0x8835a0
movq %rax, -0x3a0(%rbp)
jmp 0xd1f9ac
movq -0x350(%rbp), %rdi
addq $0x8, %rdi
callq 0x81bf20
movq %rax, -0x3a8(%rbp)
jmp 0xd1f9c5
movq -0x350(%rbp), %rdi
addq $0x8, %rdi
callq 0x81be40
movl %eax, -0x3ac(%rbp)
jmp 0xd1f9dd
movq -0x3a8(%rbp), %r8
movq -0x3a0(%rbp), %rcx
movl -0x3ac(%rbp), %eax
movl %eax, %eax
movl %eax, %r9d
movzwl -0x37a(%rbp), %edx
xorl %eax, %eax
movl %eax, %esi
leaq -0x378(%rbp), %rdi
callq 0x8e8d60
jmp 0xd1fa0f
leaq -0x378(%rbp), %rdi
callq 0xd3c160
movl %eax, -0x3b0(%rbp)
jmp 0xd1fa23
movl -0x3b0(%rbp), %ecx
movq -0x328(%rbp), %rax
movl %ecx, (%rax)
leaq -0x378(%rbp), %rdi
callq 0x8e8de0
movq %rax, -0x3b8(%rbp)
jmp 0xd1fa47
movq -0x3b8(%rbp), %rax
movq %rax, -0x318(%rbp)
movl $0x1, -0x360(%rbp)
leaq -0x348(%rbp), %rdi
callq 0x81bf40
movq -0x318(%rbp), %rax
movq %rax, -0x3c0(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xd1fac7
movq -0x3c0(%rbp), %rax
addq $0x3d0, %rsp # imm = 0x3D0
popq %rbp
retq
movq -0x358(%rbp), %rax
movq %rax, -0x3c8(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xd1fac7
movq -0x3c8(%rbp), %rdi
callq 0x775a20
callq 0x7754c0
nopl (%rax)
| _ZN4Item16val_int_from_strEPi:
push rbp
mov rbp, rsp
sub rsp, 3D0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_320], rdi
mov [rbp+var_328], rsi
mov rax, [rbp+var_320]
mov [rbp+var_398], rax
lea rcx, my_charset_bin; charset_info_st *
lea rdi, [rbp+var_348]; this
mov [rbp+var_390], rdi
lea rsi, [rbp+var_310]; char *
mov edx, 2FEh; unsigned __int64
call _ZN6StringC2EPcmPK15charset_info_st; String::String(char *,ulong,charset_info_st const*)
mov rdi, [rbp+var_398]
mov rsi, [rbp+var_390]
mov rax, [rdi]
mov rax, [rax+108h]
call rax
mov [rbp+var_388], rax
jmp short $+2
loc_D1F91D:
mov rax, [rbp+var_388]
mov [rbp+var_350], rax
cmp rax, 0
jnz short loc_D1F97B
mov rax, [rbp+var_328]
mov dword ptr [rax], 0
mov [rbp+var_318], 0
mov [rbp+var_360], 1
jmp loc_D1FA5F
mov rcx, rax
mov eax, edx
mov [rbp+var_358], rcx
mov [rbp+var_35C], eax
lea rdi, [rbp+var_348]; void *
call _ZN6StringD2Ev; String::~String()
jmp loc_D1FA9B
loc_D1F97B:
lea rdi, [rbp+var_37C]; this
call _ZN12Value_source15Warn_filter_allC2Ev; Value_source::Warn_filter_all::Warn_filter_all(void)
jmp short $+2
loc_D1F989:
mov ax, [rbp+var_37C]
mov [rbp+var_37A], ax
mov rdi, [rbp+var_350]; this
call _ZNK7Charset7charsetEv; Charset::charset(void)
mov [rbp+var_3A0], rax
jmp short $+2
loc_D1F9AC:
mov rdi, [rbp+var_350]
add rdi, 8; this
call _ZNK13Binary_string3ptrEv; Binary_string::ptr(void)
mov [rbp+var_3A8], rax
jmp short $+2
loc_D1F9C5:
mov rdi, [rbp+var_350]
add rdi, 8; this
call _ZNK13Binary_string6lengthEv; Binary_string::length(void)
mov [rbp+var_3AC], eax
jmp short $+2
loc_D1F9DD:
mov r8, [rbp+var_3A8]
mov rcx, [rbp+var_3A0]
mov eax, [rbp+var_3AC]
mov eax, eax
mov r9d, eax
movzx edx, [rbp+var_37A]
xor eax, eax
mov esi, eax
lea rdi, [rbp+var_378]
call _ZN12Value_source29Converter_strtoll10_with_warnC2EP3THDNS_11Warn_filterEPK15charset_info_stPKcm; Value_source::Converter_strtoll10_with_warn::Converter_strtoll10_with_warn(THD *,Value_source::Warn_filter,charset_info_st const*,char const*,ulong)
jmp short $+2
loc_D1FA0F:
lea rdi, [rbp+var_378]; this
call _ZNK12Value_source26Converter_string_to_number5errorEv; Value_source::Converter_string_to_number::error(void)
mov [rbp+var_3B0], eax
jmp short $+2
loc_D1FA23:
mov ecx, [rbp+var_3B0]
mov rax, [rbp+var_328]
mov [rax], ecx
lea rdi, [rbp+var_378]; this
call _ZNK12Value_source28Converter_string_to_longlong6resultEv; Value_source::Converter_string_to_longlong::result(void)
mov [rbp+var_3B8], rax
jmp short $+2
loc_D1FA47:
mov rax, [rbp+var_3B8]
mov [rbp+var_318], rax
mov [rbp+var_360], 1
loc_D1FA5F:
lea rdi, [rbp+var_348]; void *
call _ZN6StringD2Ev; String::~String()
mov rax, [rbp+var_318]
mov [rbp+var_3C0], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_D1FAC7
mov rax, [rbp+var_3C0]
add rsp, 3D0h
pop rbp
retn
loc_D1FA9B:
mov rax, [rbp+var_358]
mov [rbp+var_3C8], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_D1FAC7
mov rdi, [rbp+var_3C8]
call __Unwind_Resume
loc_D1FAC7:
call ___stack_chk_fail
| long long Item::val_int_from_str(Item *this, int *a2)
{
int v3; // [rsp+20h] [rbp-3B0h]
unsigned int v4; // [rsp+24h] [rbp-3ACh]
const char *v5; // [rsp+28h] [rbp-3A8h]
const charset_info_st *v6; // [rsp+30h] [rbp-3A0h]
unsigned __int16 v7; // [rsp+54h] [rbp-37Ch] BYREF
unsigned __int16 v8; // [rsp+56h] [rbp-37Ah]
_BYTE v9[24]; // [rsp+58h] [rbp-378h] BYREF
int v10; // [rsp+70h] [rbp-360h]
Charset *v11; // [rsp+80h] [rbp-350h]
char v12[32]; // [rsp+88h] [rbp-348h] BYREF
int *v13; // [rsp+A8h] [rbp-328h]
Item *v14; // [rsp+B0h] [rbp-320h]
long long v15; // [rsp+B8h] [rbp-318h]
char v16[776]; // [rsp+C0h] [rbp-310h] BYREF
unsigned long long v17; // [rsp+3C8h] [rbp-8h]
v17 = __readfsqword(0x28u);
v14 = this;
v13 = a2;
String::String((String *)v12, v16, 0x2FEuLL, (const charset_info_st *)&my_charset_bin);
v11 = (Charset *)(*(long long ( **)(Item *, char *))(*(_QWORD *)this + 264LL))(this, v12);
if ( v11 )
{
Value_source::Warn_filter_all::Warn_filter_all((Value_source::Warn_filter_all *)&v7);
v8 = v7;
v6 = (const charset_info_st *)Charset::charset(v11);
v5 = (const char *)Binary_string::ptr((Charset *)((char *)v11 + 8));
v4 = Binary_string::length((Charset *)((char *)v11 + 8));
Value_source::Converter_strtoll10_with_warn::Converter_strtoll10_with_warn(
(Value_source::Converter_strtoll10 *)v9,
0LL,
v8,
v6,
v5,
v4);
v3 = Value_source::Converter_string_to_number::error((Value_source::Converter_string_to_number *)v9);
*v13 = v3;
v15 = Value_source::Converter_string_to_longlong::result((Value_source::Converter_string_to_longlong *)v9);
}
else
{
*v13 = 0;
v15 = 0LL;
}
v10 = 1;
String::~String(v12);
return v15;
}
| read_fields:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x1f0
CALL 0x00d1fa20
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0xb0]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0xc8]
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0xb0]
MOV RDI,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0xc8]
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0xb0]
MOV RDI,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0xc8]
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0xb0]
MOV RDI,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0xc8]
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x18],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0xb0]
MOV RDI,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0xc8]
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x20],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0xb0]
MOV RDI,qword ptr [RAX + 0x28]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0xc8]
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x28],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0xb0]
MOV RDI,qword ptr [RAX + 0x30]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0xc8]
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x20]
CMP RCX,0x0
SETNZ CL
AND CL,0x1
MOV byte ptr [RAX + 0x40],CL
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0xb0]
MOV RDI,qword ptr [RAX + 0x38]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0xc8]
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x30],RCX
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x1f0
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00d1fa30
MOV RDI,qword ptr [RBP + -0x20]
MOV dword ptr [RDI + 0x44],0xffffffff
CALL 0x00d21fd0
ADD RSP,0x20
POP RBP
RET
|
/* sequence_definition::read_fields(TABLE*) */
void __thiscall sequence_definition::read_fields(sequence_definition *this,TABLE *param_1)
{
st_bitmap *psVar1;
int8 uVar2;
long lVar3;
psVar1 = (st_bitmap *)::dbug_tmp_use_all_columns(param_1,(st_bitmap **)(param_1 + 0x1f0));
uVar2 = (**(code **)(*(long *)**(int8 **)(param_1 + 0xb0) + 200))();
*(int8 *)this = uVar2;
uVar2 = (**(code **)(**(long **)(*(long *)(param_1 + 0xb0) + 8) + 200))();
*(int8 *)(this + 8) = uVar2;
uVar2 = (**(code **)(**(long **)(*(long *)(param_1 + 0xb0) + 0x10) + 200))();
*(int8 *)(this + 0x10) = uVar2;
uVar2 = (**(code **)(**(long **)(*(long *)(param_1 + 0xb0) + 0x18) + 200))();
*(int8 *)(this + 0x18) = uVar2;
uVar2 = (**(code **)(**(long **)(*(long *)(param_1 + 0xb0) + 0x20) + 200))();
*(int8 *)(this + 0x20) = uVar2;
uVar2 = (**(code **)(**(long **)(*(long *)(param_1 + 0xb0) + 0x28) + 200))();
*(int8 *)(this + 0x28) = uVar2;
lVar3 = (**(code **)(**(long **)(*(long *)(param_1 + 0xb0) + 0x30) + 200))();
this[0x40] = (sequence_definition)(lVar3 != 0);
uVar2 = (**(code **)(**(long **)(*(long *)(param_1 + 0xb0) + 0x38) + 200))();
*(int8 *)(this + 0x30) = uVar2;
dbug_tmp_restore_column_map((st_bitmap **)(param_1 + 0x1f0),psVar1);
*(int4 *)(this + 0x44) = 0xffffffff;
print_dbug();
return;
}
| |
53,934 | my_scan_utf32 | eloqsql/strings/ctype-ucs2.c | static size_t
my_scan_utf32(CHARSET_INFO *cs,
const char *str, const char *end, int sequence_type)
{
const char *str0= str;
switch (sequence_type)
{
case MY_SEQ_SPACES:
for ( ; str < end; )
{
my_wc_t wc;
int res= my_utf32_uni(cs, &wc, (uchar*) str, (uchar*) end);
if (res < 0 || wc != ' ')
break;
str+= res;
}
return (size_t) (str - str0);
case MY_SEQ_NONSPACES:
DBUG_ASSERT(0); /* Not implemented */
/* pass through */
default:
return 0;
}
} | O3 | c | my_scan_utf32:
cmpl $0x2, %ecx
jne 0x4c2f9
pushq %rbp
movq %rsp, %rbp
movq %rsi, %rcx
movq %rcx, %rax
cmpq %rdx, %rcx
jae 0x4c2f4
leaq 0x4(%rax), %rcx
cmpq %rdx, %rcx
ja 0x4c2f4
movzbl (%rax), %ecx
shll $0x18, %ecx
movzbl 0x1(%rax), %edi
shll $0x10, %edi
orl %ecx, %edi
xorl %ecx, %ecx
cmpl $0x110000, %edi # imm = 0x110000
setb %cl
movzwl 0x2(%rax), %r8d
rolw $0x8, %r8w
movzwl %r8w, %r8d
orl %edi, %r8d
leaq (%rax,%rcx,4), %rcx
cmpl $0x20, %r8d
je 0x4c2ae
subq %rsi, %rax
popq %rbp
retq
xorl %eax, %eax
retq
| my_scan_utf32:
cmp ecx, 2
jnz short loc_4C2F9
push rbp
mov rbp, rsp
mov rcx, rsi
loc_4C2AE:
mov rax, rcx
cmp rcx, rdx
jnb short loc_4C2F4
lea rcx, [rax+4]
cmp rcx, rdx
ja short loc_4C2F4
movzx ecx, byte ptr [rax]
shl ecx, 18h
movzx edi, byte ptr [rax+1]
shl edi, 10h
or edi, ecx
xor ecx, ecx
cmp edi, offset unk_110000
setb cl
movzx r8d, word ptr [rax+2]
rol r8w, 8
movzx r8d, r8w
or r8d, edi
lea rcx, [rax+rcx*4]
cmp r8d, 20h ; ' '
jz short loc_4C2AE
loc_4C2F4:
sub rax, rsi
pop rbp
retn
loc_4C2F9:
xor eax, eax
retn
| long long my_scan_utf32(long long a1, unsigned __int8 *a2, unsigned long long a3, int a4)
{
unsigned __int8 *v4; // rcx
unsigned __int8 *v5; // rax
unsigned int v6; // edi
if ( a4 != 2 )
return 0LL;
v4 = a2;
do
{
v5 = v4;
if ( (unsigned long long)v4 >= a3 )
break;
if ( (unsigned long long)(v4 + 4) > a3 )
break;
v6 = (*v4 << 24) | (v4[1] << 16);
v4 += 4 * (v6 < (unsigned int)&unk_110000);
}
while ( (v6 | (unsigned __int16)__ROL2__(*((_WORD *)v5 + 1), 8)) == 0x20 );
return v5 - a2;
}
| my_scan_utf32:
CMP ECX,0x2
JNZ 0x0014c2f9
PUSH RBP
MOV RBP,RSP
MOV RCX,RSI
LAB_0014c2ae:
MOV RAX,RCX
CMP RCX,RDX
JNC 0x0014c2f4
LEA RCX,[RAX + 0x4]
CMP RCX,RDX
JA 0x0014c2f4
MOVZX ECX,byte ptr [RAX]
SHL ECX,0x18
MOVZX EDI,byte ptr [RAX + 0x1]
SHL EDI,0x10
OR EDI,ECX
XOR ECX,ECX
CMP EDI,0x110000
SETC CL
MOVZX R8D,word ptr [RAX + 0x2]
ROL R8W,0x8
MOVZX R8D,R8W
OR R8D,EDI
LEA RCX,[RAX + RCX*0x4]
CMP R8D,0x20
JZ 0x0014c2ae
LAB_0014c2f4:
SUB RAX,RSI
POP RBP
RET
LAB_0014c2f9:
XOR EAX,EAX
RET
|
long my_scan_utf32(int8 param_1,byte *param_2,byte *param_3,int param_4)
{
byte *pbVar1;
byte *pbVar2;
uint uVar3;
pbVar1 = param_2;
if (param_4 != 2) {
return 0;
}
do {
pbVar2 = pbVar1;
if ((param_3 <= pbVar2) || (param_3 < pbVar2 + 4)) break;
uVar3 = (uint)pbVar2[1] << 0x10 | (uint)*pbVar2 << 0x18;
pbVar1 = pbVar2 + (ulong)(uVar3 < 0x110000) * 4;
} while (((ushort)(*(ushort *)(pbVar2 + 2) << 8 | *(ushort *)(pbVar2 + 2) >> 8) | uVar3) == 0x20);
return (long)pbVar2 - (long)param_2;
}
| |
53,935 | pow5mult | eloqsql/strings/dtoa.c | static Bigint *pow5mult(Bigint *b, int k, Stack_alloc *alloc)
{
Bigint *b1, *p5, *p51=NULL;
int i;
static int p05[3]= { 5, 25, 125 };
my_bool overflow= FALSE;
if ((i= k & 3))
b= multadd(b, p05[i-1], 0, alloc);
if (!(k>>= 2))
return b;
p5= p5_a;
for (;;)
{
if (k & 1)
{
b1= mult(b, p5, alloc);
Bfree(b, alloc);
b= b1;
}
if (!(k>>= 1))
break;
/* Calculate next power of 5 */
if (overflow)
{
p51= mult(p5, p5, alloc);
Bfree(p5, alloc);
p5= p51;
}
else if (p5 < p5_a + P5A_MAX)
++p5;
else if (p5 == p5_a + P5A_MAX)
{
p5= mult(p5, p5, alloc);
overflow= TRUE;
}
}
if (p51)
Bfree(p51, alloc);
return b;
} | O0 | c | pow5mult:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x38(%rbp)
movb $0x0, -0x3d(%rbp)
movl -0x14(%rbp), %eax
andl $0x3, %eax
movl %eax, -0x3c(%rbp)
cmpl $0x0, %eax
je 0x7b063
movq -0x10(%rbp), %rdi
movl -0x3c(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x315a5f(%rip), %rax # 0x390ab0
movl (%rax,%rcx,4), %esi
movq -0x20(%rbp), %rcx
xorl %edx, %edx
callq 0x7b9b0
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
sarl $0x2, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jne 0x7b07e
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7b174
leaq 0x315a3b(%rip), %rax # 0x390ac0
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x7b0be
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x7b180
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x7b3d0
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
sarl %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jne 0x7b0d0
jmp 0x7b158
cmpb $0x0, -0x3d(%rbp)
je 0x7b102
movq -0x30(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x7b180
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x7b3d0
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x7b153
leaq 0x3159b7(%rip), %rax # 0x390ac0
addq $0x90, %rax
cmpq %rax, -0x30(%rbp)
jae 0x7b123
movq -0x30(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x30(%rbp)
jmp 0x7b151
leaq 0x315996(%rip), %rax # 0x390ac0
addq $0x90, %rax
cmpq %rax, -0x30(%rbp)
jne 0x7b14f
movq -0x30(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x7b180
movq %rax, -0x30(%rbp)
movb $0x1, -0x3d(%rbp)
jmp 0x7b151
jmp 0x7b153
jmp 0x7b089
cmpq $0x0, -0x38(%rbp)
je 0x7b16c
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x7b3d0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
| pow5mult:
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_38], 0
mov [rbp+var_3D], 0
mov eax, [rbp+var_14]
and eax, 3
mov [rbp+var_3C], eax
cmp eax, 0
jz short loc_7B063
mov rdi, [rbp+var_10]
mov eax, [rbp+var_3C]
sub eax, 1
movsxd rcx, eax
lea rax, pow5mult_p05
mov esi, [rax+rcx*4]
mov rcx, [rbp+var_20]
xor edx, edx
call multadd
mov [rbp+var_10], rax
loc_7B063:
mov eax, [rbp+var_14]
sar eax, 2
mov [rbp+var_14], eax
cmp eax, 0
jnz short loc_7B07E
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
jmp loc_7B174
loc_7B07E:
lea rax, p5_a
mov [rbp+var_30], rax
loc_7B089:
mov eax, [rbp+var_14]
and eax, 1
cmp eax, 0
jz short loc_7B0BE
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_20]
call mult
mov [rbp+var_28], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
call Bfree
mov rax, [rbp+var_28]
mov [rbp+var_10], rax
loc_7B0BE:
mov eax, [rbp+var_14]
sar eax, 1
mov [rbp+var_14], eax
cmp eax, 0
jnz short loc_7B0D0
jmp loc_7B158
loc_7B0D0:
cmp [rbp+var_3D], 0
jz short loc_7B102
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_20]
call mult
mov [rbp+var_38], rax
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_20]
call Bfree
mov rax, [rbp+var_38]
mov [rbp+var_30], rax
jmp short loc_7B153
loc_7B102:
lea rax, p5_a
add rax, 90h
cmp [rbp+var_30], rax
jnb short loc_7B123
mov rax, [rbp+var_30]
add rax, 18h
mov [rbp+var_30], rax
jmp short loc_7B151
loc_7B123:
lea rax, p5_a
add rax, 90h
cmp [rbp+var_30], rax
jnz short loc_7B14F
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_20]
call mult
mov [rbp+var_30], rax
mov [rbp+var_3D], 1
loc_7B14F:
jmp short $+2
loc_7B151:
jmp short $+2
loc_7B153:
jmp loc_7B089
loc_7B158:
cmp [rbp+var_38], 0
jz short loc_7B16C
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_20]
call Bfree
loc_7B16C:
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
loc_7B174:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
| long long pow5mult(long long a1, int a2, long long a3)
{
char v4; // [rsp+3h] [rbp-3Dh]
_BYTE v5[12]; // [rsp+4h] [rbp-3Ch]
_UNKNOWN **v6; // [rsp+10h] [rbp-30h]
long long v7; // [rsp+18h] [rbp-28h]
int v9; // [rsp+2Ch] [rbp-14h]
long long v10; // [rsp+30h] [rbp-10h]
v10 = a1;
*(_DWORD *)&v5[8] = 0;
v4 = 0;
*(_QWORD *)v5 = a2 & 3;
if ( (a2 & 3) != 0 )
v10 = multadd(a1, pow5mult_p05[*(_DWORD *)v5 - 1], 0LL, a3);
v9 = a2 >> 2;
if ( !(a2 >> 2) )
return v10;
v6 = &p5_a;
while ( 1 )
{
if ( (v9 & 1) != 0 )
{
v7 = mult(v10, v6, a3);
Bfree(v10, a3);
v10 = v7;
}
v9 >>= 1;
if ( !v9 )
break;
if ( v4 )
{
*(_QWORD *)&v5[4] = mult(v6, v6, a3);
Bfree(v6, a3);
v6 = *(_UNKNOWN ***)&v5[4];
}
else if ( v6 >= &p5_a + 18 )
{
if ( v6 == &p5_a + 18 )
{
v6 = (_UNKNOWN **)mult(v6, v6, a3);
v4 = 1;
}
}
else
{
v6 += 3;
}
}
if ( *(_QWORD *)&v5[4] )
Bfree(*(_QWORD *)&v5[4], a3);
return v10;
}
| pow5mult:
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 + -0x38],0x0
MOV byte ptr [RBP + -0x3d],0x0
MOV EAX,dword ptr [RBP + -0x14]
AND EAX,0x3
MOV dword ptr [RBP + -0x3c],EAX
CMP EAX,0x0
JZ 0x0017b063
MOV RDI,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x3c]
SUB EAX,0x1
MOVSXD RCX,EAX
LEA RAX,[0x490ab0]
MOV ESI,dword ptr [RAX + RCX*0x4]
MOV RCX,qword ptr [RBP + -0x20]
XOR EDX,EDX
CALL 0x0017b9b0
MOV qword ptr [RBP + -0x10],RAX
LAB_0017b063:
MOV EAX,dword ptr [RBP + -0x14]
SAR EAX,0x2
MOV dword ptr [RBP + -0x14],EAX
CMP EAX,0x0
JNZ 0x0017b07e
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0017b174
LAB_0017b07e:
LEA RAX,[0x490ac0]
MOV qword ptr [RBP + -0x30],RAX
LAB_0017b089:
MOV EAX,dword ptr [RBP + -0x14]
AND EAX,0x1
CMP EAX,0x0
JZ 0x0017b0be
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x0017b180
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x0017b3d0
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x10],RAX
LAB_0017b0be:
MOV EAX,dword ptr [RBP + -0x14]
SAR EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
CMP EAX,0x0
JNZ 0x0017b0d0
JMP 0x0017b158
LAB_0017b0d0:
CMP byte ptr [RBP + -0x3d],0x0
JZ 0x0017b102
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x0017b180
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x0017b3d0
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x30],RAX
JMP 0x0017b153
LAB_0017b102:
LEA RAX,[0x490ac0]
ADD RAX,0x90
CMP qword ptr [RBP + -0x30],RAX
JNC 0x0017b123
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x18
MOV qword ptr [RBP + -0x30],RAX
JMP 0x0017b151
LAB_0017b123:
LEA RAX,[0x490ac0]
ADD RAX,0x90
CMP qword ptr [RBP + -0x30],RAX
JNZ 0x0017b14f
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x0017b180
MOV qword ptr [RBP + -0x30],RAX
MOV byte ptr [RBP + -0x3d],0x1
LAB_0017b14f:
JMP 0x0017b151
LAB_0017b151:
JMP 0x0017b153
LAB_0017b153:
JMP 0x0017b089
LAB_0017b158:
CMP qword ptr [RBP + -0x38],0x0
JZ 0x0017b16c
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x0017b3d0
LAB_0017b16c:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
LAB_0017b174:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
int8 pow5mult(int8 param_1,uint param_2,int8 param_3)
{
bool bVar1;
int8 uVar2;
int1 *local_40;
int1 *local_38;
uint local_1c;
int8 local_18;
int8 local_10;
local_40 = (int1 *)0x0;
bVar1 = false;
local_18 = param_1;
if ((param_2 & 3) != 0) {
local_18 = multadd(param_1,*(int4 *)(pow5mult_p05 + (long)(int)((param_2 & 3) - 1) * 4),0,
param_3);
}
local_1c = (int)param_2 >> 2;
if (local_1c == 0) {
local_10 = local_18;
}
else {
local_38 = p5_a;
while( true ) {
if ((local_1c & 1) != 0) {
uVar2 = mult(local_18,local_38,param_3);
Bfree(local_18,param_3);
local_18 = uVar2;
}
local_1c = (int)local_1c >> 1;
if (local_1c == 0) break;
if (bVar1) {
local_40 = (int1 *)mult(local_38,local_38,param_3);
Bfree(local_38,param_3);
local_38 = local_40;
}
else if (local_38 < (int1 *)0x490b50) {
local_38 = local_38 + 0x18;
}
else if (local_38 == (int1 *)0x490b50) {
local_38 = (int1 *)mult(0x490b50,0x490b50,param_3);
bVar1 = true;
}
}
if (local_40 != (int1 *)0x0) {
Bfree(local_40,param_3);
}
local_10 = local_18;
}
return local_10;
}
| |
53,936 | stbtt__dict_get_ints | dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-truetype.h | static void stbtt__dict_get_ints(stbtt__buf *b, int key, int outcount, stbtt_uint32 *out)
{
int i;
stbtt__buf operands = stbtt__dict_get(b, key);
for (i = 0; i < outcount && operands.cursor < operands.size; i++)
out[i] = stbtt__cff_int(&operands);
} | O1 | c | stbtt__dict_get_ints:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, 0x4(%rsp)
cmpl $0x0, 0xc(%rdi)
js 0x25fc8
movq %rcx, %rbx
movl %esi, %r15d
movq %rdi, %r14
movl $0x0, 0x8(%rdi)
movl 0x8(%r14), %r13d
movl 0xc(%r14), %eax
cmpl %eax, %r13d
jge 0x25f46
movslq %r13d, %rsi
movq (%r14), %rdi
movb (%rdi,%rsi), %r8b
movb $0x1, %dl
movl %r13d, %ecx
cmpb $0x1c, %r8b
jb 0x25ec9
testb $0x1, %dl
je 0x25fa9
movq %r14, %rdi
cmpb $0x1e, %r8b
jne 0x25ea6
movl $0x1, %esi
callq 0x25b4a
movl 0xc(%r14), %ecx
movslq 0x8(%r14), %rax
cmpl %ecx, %eax
cmovgl %eax, %ecx
movslq %ecx, %rcx
leal 0x1(%rax), %edx
cmpq %rax, %rcx
je 0x25eab
movq (%r14), %rsi
movl %edx, 0x8(%r14)
movzbl (%rsi,%rax), %esi
movl %esi, %edi
notl %edi
testb $0xf, %dil
je 0x25eab
incq %rax
andl $-0x10, %esi
incl %edx
cmpl $0xf0, %esi
jne 0x25e7a
jmp 0x25eab
callq 0x260f6
movl 0x8(%r14), %ecx
movl 0xc(%r14), %eax
cmpl %eax, %ecx
setl %dl
jge 0x25ed9
movslq %ecx, %rsi
movq (%r14), %rdi
movb (%rdi,%rsi), %r8b
jmp 0x25e45
testb %dl, %dl
je 0x25ed9
leal 0x1(%rcx), %edx
movl %edx, 0x8(%r14)
movb (%rdi,%rsi), %dl
jmp 0x25edb
xorl %edx, %edx
cmpb $0xc, %dl
jne 0x25f03
movslq 0x8(%r14), %rsi
movl $0x100, %edx # imm = 0x100
cmpl %eax, %esi
jge 0x25f06
movq (%r14), %rdx
leal 0x1(%rsi), %edi
movl %edi, 0x8(%r14)
movzbl (%rdx,%rsi), %edx
orl $0x100, %edx # imm = 0x100
jmp 0x25f06
movzbl %dl, %edx
cmpl %r15d, %edx
jne 0x25f3b
movl %ecx, %r12d
subl %r13d, %r12d
movl %r12d, %esi
orl %r13d, %esi
js 0x25f2a
cmpl %r13d, %eax
setl %sil
cmpl %ecx, %eax
setl %al
orb %sil, %al
je 0x25f31
xorl %ebp, %ebp
xorl %r12d, %r12d
jmp 0x25f3b
addq (%r14), %r13
shlq $0x20, %r12
movq %r13, %rbp
cmpl %r15d, %edx
jne 0x25e25
jmp 0x25f54
testl %eax, %eax
js 0x25f4f
movq (%r14), %rbp
jmp 0x25f51
xorl %ebp, %ebp
xorl %r12d, %r12d
movq %rbp, 0x8(%rsp)
movq %r12, 0x10(%rsp)
movl 0x4(%rsp), %eax
testl %eax, %eax
jle 0x25f9a
cmpl 0x14(%rsp), %r12d
jge 0x25f9a
movl %eax, %r15d
movl $0x1, %r12d
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x260f6
movl %eax, -0x4(%rbx,%r12,4)
cmpq %r15, %r12
jae 0x25f9a
incq %r12
movl 0x14(%rsp), %eax
cmpl %eax, 0x10(%rsp)
jl 0x25f7b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1ef12(%rip), %rdi # 0x44ec2
leaq 0x1edcf(%rip), %rsi # 0x44d86
leaq 0x1ef0d(%rip), %rcx # 0x44ecb
movl $0x4c2, %edx # imm = 0x4C2
callq 0xa200
leaq 0x1ee23(%rip), %rdi # 0x44df2
leaq 0x1edb0(%rip), %rsi # 0x44d86
leaq 0x1ee2d(%rip), %rcx # 0x44e0a
movl $0x47d, %edx # imm = 0x47D
callq 0xa200
| stbtt__dict_get_ints:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov [rsp+48h+var_44], edx
cmp dword ptr [rdi+0Ch], 0
js loc_25FC8
mov rbx, rcx
mov r15d, esi
mov r14, rdi
mov dword ptr [rdi+8], 0
loc_25E25:
mov r13d, [r14+8]
mov eax, [r14+0Ch]
cmp r13d, eax
jge loc_25F46
movsxd rsi, r13d
mov rdi, [r14]
mov r8b, [rdi+rsi]
mov dl, 1
mov ecx, r13d
loc_25E45:
cmp r8b, 1Ch
jb short loc_25EC9
test dl, 1
jz loc_25FA9
mov rdi, r14
cmp r8b, 1Eh
jnz short loc_25EA6
mov esi, 1
call stbtt__buf_skip
mov ecx, [r14+0Ch]
movsxd rax, dword ptr [r14+8]
cmp eax, ecx
cmovg ecx, eax
movsxd rcx, ecx
lea edx, [rax+1]
loc_25E7A:
cmp rcx, rax
jz short loc_25EAB
mov rsi, [r14]
mov [r14+8], edx
movzx esi, byte ptr [rsi+rax]
mov edi, esi
not edi
test dil, 0Fh
jz short loc_25EAB
inc rax
and esi, 0FFFFFFF0h
inc edx
cmp esi, 0F0h
jnz short loc_25E7A
jmp short loc_25EAB
loc_25EA6:
call stbtt__cff_int
loc_25EAB:
mov ecx, [r14+8]
mov eax, [r14+0Ch]
cmp ecx, eax
setl dl
jge short loc_25ED9
movsxd rsi, ecx
mov rdi, [r14]
mov r8b, [rdi+rsi]
jmp loc_25E45
loc_25EC9:
test dl, dl
jz short loc_25ED9
lea edx, [rcx+1]
mov [r14+8], edx
mov dl, [rdi+rsi]
jmp short loc_25EDB
loc_25ED9:
xor edx, edx
loc_25EDB:
cmp dl, 0Ch
jnz short loc_25F03
movsxd rsi, dword ptr [r14+8]
mov edx, 100h
cmp esi, eax
jge short loc_25F06
mov rdx, [r14]
lea edi, [rsi+1]
mov [r14+8], edi
movzx edx, byte ptr [rdx+rsi]
or edx, 100h
jmp short loc_25F06
loc_25F03:
movzx edx, dl
loc_25F06:
cmp edx, r15d
jnz short loc_25F3B
mov r12d, ecx
sub r12d, r13d
mov esi, r12d
or esi, r13d
js short loc_25F2A
cmp eax, r13d
setl sil
cmp eax, ecx
setl al
or al, sil
jz short loc_25F31
loc_25F2A:
xor ebp, ebp
xor r12d, r12d
jmp short loc_25F3B
loc_25F31:
add r13, [r14]
shl r12, 20h
mov rbp, r13
loc_25F3B:
cmp edx, r15d
jnz loc_25E25
jmp short loc_25F54
loc_25F46:
test eax, eax
js short loc_25F4F
mov rbp, [r14]
jmp short loc_25F51
loc_25F4F:
xor ebp, ebp
loc_25F51:
xor r12d, r12d
loc_25F54:
mov [rsp+48h+var_40], rbp
mov [rsp+48h+var_38], r12
mov eax, [rsp+48h+var_44]
test eax, eax
jle short loc_25F9A
cmp r12d, dword ptr [rsp+48h+var_38+4]
jge short loc_25F9A
mov r15d, eax
mov r12d, 1
lea r14, [rsp+48h+var_40]
loc_25F7B:
mov rdi, r14
call stbtt__cff_int
mov [rbx+r12*4-4], eax
cmp r12, r15
jnb short loc_25F9A
inc r12
mov eax, dword ptr [rsp+48h+var_38+4]
cmp dword ptr [rsp+48h+var_38], eax
jl short loc_25F7B
loc_25F9A:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_25FA9:
lea rdi, aB028; "b0 >= 28"
lea rsi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidStbttCffSk; "void stbtt__cff_skip_operand(stbtt__buf"...
mov edx, 4C2h
call ___assert_fail
loc_25FC8:
lea rdi, aOBSizeO0; "!(o > b->size || o < 0)"
lea rsi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidStbttBufSe; "void stbtt__buf_seek(stbtt__buf *, int)"
mov edx, 47Dh
call ___assert_fail
| long long stbtt__dict_get_ints(long long a1, long long a2, long long a3, long long a4)
{
long long v4; // rbp
unsigned long long v5; // r12
long long v6; // rbx
int v7; // r15d
long long v9; // r13
int v10; // eax
long long v11; // rdi
unsigned __int8 v12; // r8
int v13; // ecx
long long v14; // rax
long long v15; // rsi
long long v16; // rdx
long long result; // rax
unsigned long long v18; // r12
int v19; // [rsp+4h] [rbp-44h]
long long v20; // [rsp+8h] [rbp-40h] BYREF
unsigned long long v21; // [rsp+10h] [rbp-38h]
v19 = a3;
if ( *(int *)(a1 + 12) < 0 )
__assert_fail(
"!(o > b->size || o < 0)",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-truetype.h",
1149LL,
"void stbtt__buf_seek(stbtt__buf *, int)");
v6 = a4;
v7 = a2;
*(_DWORD *)(a1 + 8) = 0;
while ( 1 )
{
v9 = *(unsigned int *)(a1 + 8);
v10 = *(_DWORD *)(a1 + 12);
if ( (int)v9 >= v10 )
break;
a2 = (int)v9;
v11 = *(_QWORD *)a1;
v12 = *(_BYTE *)(*(_QWORD *)a1 + (int)v9);
LOBYTE(a3) = 1;
a4 = (unsigned int)v9;
while ( v12 >= 0x1Cu )
{
if ( (a3 & 1) == 0 )
__assert_fail(
"b0 >= 28",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-truetype.h",
1218LL,
"void stbtt__cff_skip_operand(stbtt__buf *)");
if ( v12 == 30 )
{
a2 = 1LL;
stbtt__buf_skip(a1, 1);
v13 = *(_DWORD *)(a1 + 12);
v14 = *(int *)(a1 + 8);
if ( (int)v14 > v13 )
v13 = *(_DWORD *)(a1 + 8);
a3 = (unsigned int)(v14 + 1);
do
{
if ( v13 == v14 )
break;
v15 = *(_QWORD *)a1;
*(_DWORD *)(a1 + 8) = a3;
a2 = *(unsigned __int8 *)(v15 + v14);
if ( (~(_BYTE)a2 & 0xF) == 0 )
break;
++v14;
a2 = (unsigned int)a2 & 0xFFFFFFF0;
a3 = (unsigned int)(a3 + 1);
}
while ( (_DWORD)a2 != 240 );
}
else
{
stbtt__cff_int(a1, a2, a3, a4);
}
a4 = *(unsigned int *)(a1 + 8);
v10 = *(_DWORD *)(a1 + 12);
LOBYTE(a3) = (int)a4 < v10;
if ( (int)a4 >= v10 )
goto LABEL_20;
a2 = (int)a4;
v11 = *(_QWORD *)a1;
v12 = *(_BYTE *)(*(_QWORD *)a1 + (int)a4);
}
if ( (_BYTE)a3 )
{
*(_DWORD *)(a1 + 8) = a4 + 1;
LOBYTE(a3) = *(_BYTE *)(v11 + a2);
goto LABEL_21;
}
LABEL_20:
LOBYTE(a3) = 0;
LABEL_21:
if ( (_BYTE)a3 == 12 )
{
a2 = *(int *)(a1 + 8);
a3 = 256LL;
if ( (int)a2 < v10 )
{
v16 = *(_QWORD *)a1;
*(_DWORD *)(a1 + 8) = a2 + 1;
a3 = *(unsigned __int8 *)(v16 + a2) | 0x100u;
}
}
else
{
a3 = (unsigned __int8)a3;
}
if ( (_DWORD)a3 == v7 )
{
a2 = (unsigned int)v9 | ((_DWORD)a4 - (_DWORD)v9);
if ( (int)(v9 | (a4 - v9)) < 0 || (LOBYTE(a2) = v10 < (int)v9, v10 < (int)v9 || v10 < (int)a4) )
{
v4 = 0LL;
v5 = 0LL;
}
else
{
v5 = (unsigned long long)(unsigned int)(a4 - v9) << 32;
v4 = *(_QWORD *)a1 + v9;
}
}
if ( (_DWORD)a3 == v7 )
goto LABEL_36;
}
if ( v10 < 0 )
v4 = 0LL;
else
v4 = *(_QWORD *)a1;
v5 = 0LL;
LABEL_36:
v20 = v4;
v21 = v5;
result = (unsigned int)v19;
if ( v19 > 0 && (int)v5 < SHIDWORD(v21) )
{
v18 = 1LL;
do
{
result = stbtt__cff_int(&v20, a2, a3, a4);
*(_DWORD *)(v6 + 4 * v18 - 4) = result;
if ( v18 >= (unsigned int)v19 )
break;
++v18;
result = HIDWORD(v21);
}
while ( (int)v21 < SHIDWORD(v21) );
}
return result;
}
| stbtt__dict_get_ints:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV dword ptr [RSP + 0x4],EDX
CMP dword ptr [RDI + 0xc],0x0
JS 0x00125fc8
MOV RBX,RCX
MOV R15D,ESI
MOV R14,RDI
MOV dword ptr [RDI + 0x8],0x0
LAB_00125e25:
MOV R13D,dword ptr [R14 + 0x8]
MOV EAX,dword ptr [R14 + 0xc]
CMP R13D,EAX
JGE 0x00125f46
MOVSXD RSI,R13D
MOV RDI,qword ptr [R14]
MOV R8B,byte ptr [RDI + RSI*0x1]
MOV DL,0x1
MOV ECX,R13D
LAB_00125e45:
CMP R8B,0x1c
JC 0x00125ec9
TEST DL,0x1
JZ 0x00125fa9
MOV RDI,R14
CMP R8B,0x1e
JNZ 0x00125ea6
MOV ESI,0x1
CALL 0x00125b4a
MOV ECX,dword ptr [R14 + 0xc]
MOVSXD RAX,dword ptr [R14 + 0x8]
CMP EAX,ECX
CMOVG ECX,EAX
MOVSXD RCX,ECX
LEA EDX,[RAX + 0x1]
LAB_00125e7a:
CMP RCX,RAX
JZ 0x00125eab
MOV RSI,qword ptr [R14]
MOV dword ptr [R14 + 0x8],EDX
MOVZX ESI,byte ptr [RSI + RAX*0x1]
MOV EDI,ESI
NOT EDI
TEST DIL,0xf
JZ 0x00125eab
INC RAX
AND ESI,0xfffffff0
INC EDX
CMP ESI,0xf0
JNZ 0x00125e7a
JMP 0x00125eab
LAB_00125ea6:
CALL 0x001260f6
LAB_00125eab:
MOV ECX,dword ptr [R14 + 0x8]
MOV EAX,dword ptr [R14 + 0xc]
CMP ECX,EAX
SETL DL
JGE 0x00125ed9
MOVSXD RSI,ECX
MOV RDI,qword ptr [R14]
MOV R8B,byte ptr [RDI + RSI*0x1]
JMP 0x00125e45
LAB_00125ec9:
TEST DL,DL
JZ 0x00125ed9
LEA EDX,[RCX + 0x1]
MOV dword ptr [R14 + 0x8],EDX
MOV DL,byte ptr [RDI + RSI*0x1]
JMP 0x00125edb
LAB_00125ed9:
XOR EDX,EDX
LAB_00125edb:
CMP DL,0xc
JNZ 0x00125f03
MOVSXD RSI,dword ptr [R14 + 0x8]
MOV EDX,0x100
CMP ESI,EAX
JGE 0x00125f06
MOV RDX,qword ptr [R14]
LEA EDI,[RSI + 0x1]
MOV dword ptr [R14 + 0x8],EDI
MOVZX EDX,byte ptr [RDX + RSI*0x1]
OR EDX,0x100
JMP 0x00125f06
LAB_00125f03:
MOVZX EDX,DL
LAB_00125f06:
CMP EDX,R15D
JNZ 0x00125f3b
MOV R12D,ECX
SUB R12D,R13D
MOV ESI,R12D
OR ESI,R13D
JS 0x00125f2a
CMP EAX,R13D
SETL SIL
CMP EAX,ECX
SETL AL
OR AL,SIL
JZ 0x00125f31
LAB_00125f2a:
XOR EBP,EBP
XOR R12D,R12D
JMP 0x00125f3b
LAB_00125f31:
ADD R13,qword ptr [R14]
SHL R12,0x20
MOV RBP,R13
LAB_00125f3b:
CMP EDX,R15D
JNZ 0x00125e25
JMP 0x00125f54
LAB_00125f46:
TEST EAX,EAX
JS 0x00125f4f
MOV RBP,qword ptr [R14]
JMP 0x00125f51
LAB_00125f4f:
XOR EBP,EBP
LAB_00125f51:
XOR R12D,R12D
LAB_00125f54:
MOV qword ptr [RSP + 0x8],RBP
MOV qword ptr [RSP + 0x10],R12
MOV EAX,dword ptr [RSP + 0x4]
TEST EAX,EAX
JLE 0x00125f9a
CMP R12D,dword ptr [RSP + 0x14]
JGE 0x00125f9a
MOV R15D,EAX
MOV R12D,0x1
LEA R14,[RSP + 0x8]
LAB_00125f7b:
MOV RDI,R14
CALL 0x001260f6
MOV dword ptr [RBX + R12*0x4 + -0x4],EAX
CMP R12,R15
JNC 0x00125f9a
INC R12
MOV EAX,dword ptr [RSP + 0x14]
CMP dword ptr [RSP + 0x10],EAX
JL 0x00125f7b
LAB_00125f9a:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00125fa9:
LEA RDI,[0x144ec2]
LEA RSI,[0x144d86]
LEA RCX,[0x144ecb]
MOV EDX,0x4c2
CALL 0x0010a200
LAB_00125fc8:
LEA RDI,[0x144df2]
LEA RSI,[0x144d86]
LEA RCX,[0x144e0a]
MOV EDX,0x47d
CALL 0x0010a200
|
void stbtt__dict_get_ints(long *param_1,uint param_2,uint param_3,long param_4)
{
byte *pbVar1;
uint uVar2;
bool bVar3;
int4 uVar4;
long lVar5;
uint uVar6;
int iVar7;
int iVar8;
uint uVar9;
long unaff_RBP;
long lVar10;
byte bVar11;
long unaff_R12;
ulong uVar12;
long local_40;
int8 local_38;
if (*(int *)((long)param_1 + 0xc) < 0) {
/* WARNING: Subroutine does not return */
__assert_fail("!(o > b->size || o < 0)",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-truetype.h"
,0x47d,"void stbtt__buf_seek(stbtt__buf *, int)");
}
*(int4 *)(param_1 + 1) = 0;
do {
uVar2 = *(uint *)(param_1 + 1);
iVar8 = *(int *)((long)param_1 + 0xc);
if (iVar8 <= (int)uVar2) {
if (iVar8 < 0) {
unaff_RBP = 0;
}
else {
unaff_RBP = *param_1;
}
unaff_R12 = 0;
break;
}
lVar10 = (long)(int)uVar2;
lVar5 = *param_1;
bVar3 = true;
bVar11 = *(byte *)(lVar5 + lVar10);
uVar12 = (ulong)uVar2;
while (uVar6 = (uint)uVar12, 0x1b < bVar11) {
if (!bVar3) {
/* WARNING: Subroutine does not return */
__assert_fail("b0 >= 28",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-truetype.h"
,0x4c2,"void stbtt__cff_skip_operand(stbtt__buf *)");
}
if (bVar11 == 0x1e) {
stbtt__buf_skip(param_1,1);
iVar8 = (int)param_1[1];
lVar5 = (long)iVar8;
iVar7 = *(int *)((long)param_1 + 0xc);
if (*(int *)((long)param_1 + 0xc) < iVar8) {
iVar7 = iVar8;
}
while (iVar8 = iVar8 + 1, iVar7 != lVar5) {
*(int *)(param_1 + 1) = iVar8;
pbVar1 = (byte *)(*param_1 + lVar5);
if (((~*pbVar1 & 0xf) == 0) || (lVar5 = lVar5 + 1, (*pbVar1 & 0xf0) == 0xf0)) break;
}
}
else {
stbtt__cff_int(param_1);
}
uVar6 = *(uint *)(param_1 + 1);
uVar12 = (ulong)uVar6;
iVar8 = *(int *)((long)param_1 + 0xc);
bVar3 = (int)uVar6 < iVar8;
if (iVar8 <= (int)uVar6) goto LAB_00125ed9;
lVar10 = (long)(int)uVar6;
lVar5 = *param_1;
bVar11 = *(byte *)(lVar5 + lVar10);
}
if (bVar3) {
*(uint *)(param_1 + 1) = uVar6 + 1;
bVar11 = *(byte *)(lVar5 + lVar10);
}
else {
LAB_00125ed9:
bVar11 = 0;
}
if (bVar11 == 0xc) {
iVar7 = (int)param_1[1];
uVar9 = 0x100;
if (iVar7 < iVar8) {
*(int *)(param_1 + 1) = iVar7 + 1;
uVar9 = *(byte *)(*param_1 + (long)iVar7) | 0x100;
}
}
else {
uVar9 = (uint)bVar11;
}
if (uVar9 == param_2) {
if (((int)(uVar6 - uVar2 | uVar2) < 0) || (iVar8 < (int)uVar6 || iVar8 < (int)uVar2)) {
unaff_RBP = 0;
unaff_R12 = 0;
}
else {
unaff_RBP = (ulong)uVar2 + *param_1;
unaff_R12 = (ulong)(uVar6 - uVar2) << 0x20;
}
}
} while (uVar9 != param_2);
if ((0 < (int)param_3) &&
(local_38._4_4_ = (int)((ulong)unaff_R12 >> 0x20), (int)unaff_R12 < local_38._4_4_)) {
uVar12 = 1;
local_40 = unaff_RBP;
local_38 = unaff_R12;
do {
uVar4 = stbtt__cff_int(&local_40);
*(int4 *)(param_4 + -4 + uVar12 * 4) = uVar4;
if (param_3 <= uVar12) {
return;
}
uVar12 = uVar12 + 1;
} while ((int)local_38 < local_38._4_4_);
}
return;
}
| |
53,937 | add_import | bluesky950520[P]quickjs/quickjs.c | static int add_import(JSParseState *s, JSModuleDef *m,
JSAtom local_name, JSAtom import_name)
{
JSContext *ctx = s->ctx;
int i, var_idx;
JSImportEntry *mi;
BOOL is_local;
if (local_name == JS_ATOM_arguments || local_name == JS_ATOM_eval)
return js_parse_error(s, "invalid import binding");
if (local_name != JS_ATOM_default) {
for (i = 0; i < s->cur_func->closure_var_count; i++) {
if (s->cur_func->closure_var[i].var_name == local_name)
return js_parse_error(s, "duplicate import binding");
}
}
is_local = (import_name == JS_ATOM__star_);
var_idx = add_closure_var(ctx, s->cur_func, is_local, FALSE,
m->import_entries_count,
local_name, TRUE, TRUE, JS_VAR_NORMAL);
if (var_idx < 0)
return -1;
if (js_resize_array(ctx, (void **)&m->import_entries,
sizeof(JSImportEntry),
&m->import_entries_size,
m->import_entries_count + 1))
return -1;
mi = &m->import_entries[m->import_entries_count++];
mi->import_name = JS_DupAtom(ctx, import_name);
mi->var_idx = var_idx;
return 0;
} | O1 | c | add_import:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %r9d
movq %rsi, %r15
movq (%rdi), %r14
cmpl $0x16, %edx
je 0x6cdcf
cmpl $0x3b, %r9d
je 0x6cd87
cmpl $0x4e, %r9d
jne 0x6cda0
leaq 0x345da(%rip), %rsi # 0xa1368
xorl %eax, %eax
callq 0x2fce9
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
jmp 0x6ce4a
movq 0x90(%rdi), %rcx
movslq 0x198(%rcx), %rax
testq %rax, %rax
jle 0x6cdcf
movq 0x1a0(%rcx), %rcx
xorl %edx, %edx
cmpl %r9d, 0x4(%rcx,%rdx,8)
je 0x6ce56
incq %rdx
cmpq %rdx, %rax
jne 0x6cdbc
xorl %edx, %edx
cmpl $0x7e, %ebx
sete %dl
movq 0x90(%rdi), %rsi
movl 0x50(%r15), %r8d
subq $0x8, %rsp
movl $0x1, %eax
movq %r14, %rdi
xorl %ecx, %ecx
pushq $0x0
pushq %rax
pushq %rax
callq 0x6ce80
addq $0x20, %rsp
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
testl %eax, %eax
js 0x6ce4a
movl %eax, %ebp
movl 0x50(%r15), %r8d
cmpl %r8d, 0x54(%r15)
jle 0x6ce62
movslq 0x50(%r15), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x50(%r15)
leaq (%rax,%rax,2), %rax
shlq $0x2, %rax
addq 0x48(%r15), %rax
cmpl $0xe0, %ebx
jl 0x6ce42
movq 0x18(%r14), %rcx
movq 0x68(%rcx), %rcx
movl %ebx, %edx
movq (%rcx,%rdx,8), %rcx
incl (%rcx)
movl %ebx, 0x4(%rax)
movl %ebp, (%rax)
xorl %r12d, %r12d
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x34522(%rip), %rsi # 0xa137f
jmp 0x6cd8e
leaq 0x48(%r15), %rsi
leaq 0x54(%r15), %rcx
incl %r8d
movq %r14, %rdi
movl $0xc, %edx
callq 0x434ef
testl %eax, %eax
jne 0x6ce4a
jmp 0x6ce13
| add_import:
push rbp
push r15
push r14
push r12
push rbx
mov ebx, ecx
mov r9d, edx
mov r15, rsi
mov r14, [rdi]
cmp edx, 16h
jz short loc_6CDCF
cmp r9d, 3Bh ; ';'
jz short loc_6CD87
cmp r9d, 4Eh ; 'N'
jnz short loc_6CDA0
loc_6CD87:
lea rsi, aInvalidImportB; "invalid import binding"
loc_6CD8E:
xor eax, eax
call js_parse_error
mov r12d, 0FFFFFFFFh
jmp loc_6CE4A
loc_6CDA0:
mov rcx, [rdi+90h]
movsxd rax, dword ptr [rcx+198h]
test rax, rax
jle short loc_6CDCF
mov rcx, [rcx+1A0h]
xor edx, edx
loc_6CDBC:
cmp [rcx+rdx*8+4], r9d
jz loc_6CE56
inc rdx
cmp rax, rdx
jnz short loc_6CDBC
loc_6CDCF:
xor edx, edx
cmp ebx, 7Eh ; '~'
setz dl
mov rsi, [rdi+90h]
mov r8d, [r15+50h]
sub rsp, 8
mov eax, 1
mov rdi, r14
xor ecx, ecx
push 0
push rax
push rax
call add_closure_var
add rsp, 20h
mov r12d, 0FFFFFFFFh
test eax, eax
js short loc_6CE4A
mov ebp, eax
mov r8d, [r15+50h]
cmp [r15+54h], r8d
jle short loc_6CE62
loc_6CE13:
movsxd rax, dword ptr [r15+50h]
lea ecx, [rax+1]
mov [r15+50h], ecx
lea rax, [rax+rax*2]
shl rax, 2
add rax, [r15+48h]
cmp ebx, 0E0h
jl short loc_6CE42
mov rcx, [r14+18h]
mov rcx, [rcx+68h]
mov edx, ebx
mov rcx, [rcx+rdx*8]
inc dword ptr [rcx]
loc_6CE42:
mov [rax+4], ebx
mov [rax], ebp
xor r12d, r12d
loc_6CE4A:
mov eax, r12d
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_6CE56:
lea rsi, aDuplicateImpor; "duplicate import binding"
jmp loc_6CD8E
loc_6CE62:
lea rsi, [r15+48h]
lea rcx, [r15+54h]
inc r8d
mov rdi, r14
mov edx, 0Ch
call js_realloc_array
test eax, eax
jnz short loc_6CE4A
jmp short loc_6CE13
| long long add_import(
long long *a1,
long long a2,
long long a3,
long long a4,
long long a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13)
{
int v13; // ebx
long long v14; // r9
long long v15; // r14
const char *v16; // rsi
unsigned int v17; // r12d
long long v18; // rcx
long long v19; // rax
int v20; // eax
int v21; // ebp
int v22; // r8d
long long v23; // rax
int *v24; // rax
_DWORD *v25; // rcx
char v27; // [rsp+0h] [rbp-28h]
v13 = a4;
v14 = (unsigned int)a3;
v15 = *a1;
if ( (_DWORD)a3 != 22 )
{
if ( (_DWORD)a3 == 59 || (_DWORD)a3 == 78 )
{
v16 = "invalid import binding";
LABEL_5:
js_parse_error(a1, (long long)v16, a3, a4, a5, v14, a6, a7, a8, a9, a10, a11, a12, a13, v27);
return (unsigned int)-1;
}
v18 = a1[18];
v19 = *(int *)(v18 + 408);
if ( v19 > 0 )
{
a4 = *(_QWORD *)(v18 + 416);
a3 = 0LL;
while ( *(_DWORD *)(a4 + 8 * a3 + 4) != (_DWORD)v14 )
{
if ( v19 == ++a3 )
goto LABEL_10;
}
v16 = "duplicate import binding";
goto LABEL_5;
}
}
LABEL_10:
v20 = add_closure_var(*a1, a1[18], v13 == 126, 0, *(_DWORD *)(a2 + 80), v14, 1, 1, 0);
v17 = -1;
if ( v20 >= 0 )
{
v21 = v20;
v22 = *(_DWORD *)(a2 + 80);
if ( *(_DWORD *)(a2 + 84) > v22
|| !(unsigned int)js_realloc_array(v15, (long long *)(a2 + 72), 0xCu, (_DWORD *)(a2 + 84), v22 + 1) )
{
v23 = *(int *)(a2 + 80);
*(_DWORD *)(a2 + 80) = v23 + 1;
v24 = (int *)(*(_QWORD *)(a2 + 72) + 12 * v23);
if ( v13 >= 224 )
{
v25 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(v15 + 24) + 104LL) + 8LL * (unsigned int)v13);
++*v25;
}
v24[1] = v13;
*v24 = v21;
return 0;
}
}
return v17;
}
| add_import:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV EBX,ECX
MOV R9D,EDX
MOV R15,RSI
MOV R14,qword ptr [RDI]
CMP EDX,0x16
JZ 0x0016cdcf
CMP R9D,0x3b
JZ 0x0016cd87
CMP R9D,0x4e
JNZ 0x0016cda0
LAB_0016cd87:
LEA RSI,[0x1a1368]
LAB_0016cd8e:
XOR EAX,EAX
CALL 0x0012fce9
MOV R12D,0xffffffff
JMP 0x0016ce4a
LAB_0016cda0:
MOV RCX,qword ptr [RDI + 0x90]
MOVSXD RAX,dword ptr [RCX + 0x198]
TEST RAX,RAX
JLE 0x0016cdcf
MOV RCX,qword ptr [RCX + 0x1a0]
XOR EDX,EDX
LAB_0016cdbc:
CMP dword ptr [RCX + RDX*0x8 + 0x4],R9D
JZ 0x0016ce56
INC RDX
CMP RAX,RDX
JNZ 0x0016cdbc
LAB_0016cdcf:
XOR EDX,EDX
CMP EBX,0x7e
SETZ DL
MOV RSI,qword ptr [RDI + 0x90]
MOV R8D,dword ptr [R15 + 0x50]
SUB RSP,0x8
MOV EAX,0x1
MOV RDI,R14
XOR ECX,ECX
PUSH 0x0
PUSH RAX
PUSH RAX
CALL 0x0016ce80
ADD RSP,0x20
MOV R12D,0xffffffff
TEST EAX,EAX
JS 0x0016ce4a
MOV EBP,EAX
MOV R8D,dword ptr [R15 + 0x50]
CMP dword ptr [R15 + 0x54],R8D
JLE 0x0016ce62
LAB_0016ce13:
MOVSXD RAX,dword ptr [R15 + 0x50]
LEA ECX,[RAX + 0x1]
MOV dword ptr [R15 + 0x50],ECX
LEA RAX,[RAX + RAX*0x2]
SHL RAX,0x2
ADD RAX,qword ptr [R15 + 0x48]
CMP EBX,0xe0
JL 0x0016ce42
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_0016ce42:
MOV dword ptr [RAX + 0x4],EBX
MOV dword ptr [RAX],EBP
XOR R12D,R12D
LAB_0016ce4a:
MOV EAX,R12D
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0016ce56:
LEA RSI,[0x1a137f]
JMP 0x0016cd8e
LAB_0016ce62:
LEA RSI,[R15 + 0x48]
LEA RCX,[R15 + 0x54]
INC R8D
MOV RDI,R14
MOV EDX,0xc
CALL 0x001434ef
TEST EAX,EAX
JNZ 0x0016ce4a
JMP 0x0016ce13
|
int8 add_import(long *param_1,long param_2,int param_3,uint param_4)
{
long lVar1;
int *piVar2;
int iVar3;
int iVar4;
long lVar5;
int *piVar6;
long lVar7;
char *pcVar8;
int8 uVar9;
lVar1 = *param_1;
if (param_3 != 0x16) {
if ((param_3 == 0x3b) || (param_3 == 0x4e)) {
pcVar8 = "invalid import binding";
LAB_0016cd8e:
js_parse_error(param_1,pcVar8);
return 0xffffffff;
}
lVar5 = (long)*(int *)(param_1[0x12] + 0x198);
if (0 < lVar5) {
lVar7 = 0;
do {
if (*(int *)(*(long *)(param_1[0x12] + 0x1a0) + 4 + lVar7 * 8) == param_3) {
pcVar8 = "duplicate import binding";
goto LAB_0016cd8e;
}
lVar7 = lVar7 + 1;
} while (lVar5 != lVar7);
}
}
iVar3 = add_closure_var(lVar1,param_1[0x12],param_4 == 0x7e,0,*(int4 *)(param_2 + 0x50),
param_3,1,1,0);
uVar9 = 0xffffffff;
if ((-1 < iVar3) &&
((*(int *)(param_2 + 0x50) < *(int *)(param_2 + 0x54) ||
(iVar4 = js_realloc_array(lVar1,param_2 + 0x48,0xc,param_2 + 0x54,*(int *)(param_2 + 0x50) + 1
), iVar4 == 0)))) {
iVar4 = *(int *)(param_2 + 0x50);
*(int *)(param_2 + 0x50) = iVar4 + 1;
piVar6 = (int *)((long)iVar4 * 0xc + *(long *)(param_2 + 0x48));
if (0xdf < (int)param_4) {
piVar2 = *(int **)(*(long *)(*(long *)(lVar1 + 0x18) + 0x68) + (ulong)param_4 * 8);
*piVar2 = *piVar2 + 1;
}
piVar6[1] = param_4;
*piVar6 = iVar3;
uVar9 = 0;
}
return uVar9;
}
| |
53,938 | add_import | bluesky950520[P]quickjs/quickjs.c | static int add_import(JSParseState *s, JSModuleDef *m,
JSAtom local_name, JSAtom import_name)
{
JSContext *ctx = s->ctx;
int i, var_idx;
JSImportEntry *mi;
BOOL is_local;
if (local_name == JS_ATOM_arguments || local_name == JS_ATOM_eval)
return js_parse_error(s, "invalid import binding");
if (local_name != JS_ATOM_default) {
for (i = 0; i < s->cur_func->closure_var_count; i++) {
if (s->cur_func->closure_var[i].var_name == local_name)
return js_parse_error(s, "duplicate import binding");
}
}
is_local = (import_name == JS_ATOM__star_);
var_idx = add_closure_var(ctx, s->cur_func, is_local, FALSE,
m->import_entries_count,
local_name, TRUE, TRUE, JS_VAR_NORMAL);
if (var_idx < 0)
return -1;
if (js_resize_array(ctx, (void **)&m->import_entries,
sizeof(JSImportEntry),
&m->import_entries_size,
m->import_entries_count + 1))
return -1;
mi = &m->import_entries[m->import_entries_count++];
mi->import_name = JS_DupAtom(ctx, import_name);
mi->var_idx = var_idx;
return 0;
} | O2 | c | add_import:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
cmpl $0x4e, %edx
je 0x5bda0
movl %edx, %r9d
cmpl $0x3b, %edx
je 0x5bda0
movl %ecx, %ebx
movq %rsi, %r14
movq (%rdi), %r15
cmpl $0x16, %r9d
jne 0x5bdc2
movq 0x90(%rdi), %rsi
xorl %edx, %edx
cmpl $0x7e, %ebx
sete %dl
movl 0x50(%r14), %r8d
pushq $0x1
popq %rax
andl $0x0, 0x10(%rsp)
movl %eax, 0x8(%rsp)
movl %eax, (%rsp)
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x5bdfd
pushq $-0x1
popq %r12
testl %eax, %eax
js 0x5bdb2
movl %eax, %ebp
leaq 0x48(%r14), %rsi
leaq 0x54(%r14), %rcx
movl 0x50(%r14), %r8d
incl %r8d
pushq $0xc
popq %rdx
movq %r15, %rdi
callq 0x3b0ef
testl %eax, %eax
jne 0x5bdb2
movslq 0x50(%r14), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x50(%r14)
imulq $0xc, %rax, %rax
addq 0x48(%r14), %rax
cmpl $0xe0, %ebx
jl 0x5bd96
movq 0x18(%r15), %rcx
movq 0x68(%rcx), %rcx
movl %ebx, %edx
movq (%rcx,%rdx,8), %rcx
incl (%rcx)
movl %ebx, 0x4(%rax)
movl %ebp, (%rax)
xorl %r12d, %r12d
jmp 0x5bdb2
leaq 0x2c4fb(%rip), %rsi # 0x882a2
xorl %eax, %eax
callq 0x28457
pushq $-0x1
popq %r12
movl %r12d, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x90(%rdi), %rsi
movl 0x198(%rsi), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
cmpq %rcx, %rax
je 0x5bd1e
movq 0x1a0(%rsi), %rdx
leaq 0x1(%rcx), %r8
cmpl %r9d, 0x4(%rdx,%rcx,8)
movq %r8, %rcx
jne 0x5bdd6
leaq 0x2c4be(%rip), %rsi # 0x882b9
jmp 0x5bda7
| add_import:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 20h
cmp edx, 4Eh ; 'N'
jz loc_5BDA0
mov r9d, edx
cmp edx, 3Bh ; ';'
jz loc_5BDA0
mov ebx, ecx
mov r14, rsi
mov r15, [rdi]
cmp r9d, 16h
jnz loc_5BDC2
mov rsi, [rdi+90h]
loc_5BD1E:
xor edx, edx
cmp ebx, 7Eh ; '~'
setz dl
mov r8d, [r14+50h]
push 1
pop rax
and [rsp+48h+var_38], 0
mov [rsp+48h+var_40], eax
mov [rsp+48h+var_48], eax
mov rdi, r15
xor ecx, ecx
call add_closure_var
push 0FFFFFFFFFFFFFFFFh
pop r12
test eax, eax
js short loc_5BDB2
mov ebp, eax
lea rsi, [r14+48h]
lea rcx, [r14+54h]
mov r8d, [r14+50h]
inc r8d
push 0Ch
pop rdx
mov rdi, r15
call js_resize_array
test eax, eax
jnz short loc_5BDB2
movsxd rax, dword ptr [r14+50h]
lea ecx, [rax+1]
mov [r14+50h], ecx
imul rax, 0Ch
add rax, [r14+48h]
cmp ebx, 0E0h
jl short loc_5BD96
mov rcx, [r15+18h]
mov rcx, [rcx+68h]
mov edx, ebx
mov rcx, [rcx+rdx*8]
inc dword ptr [rcx]
loc_5BD96:
mov [rax+4], ebx
mov [rax], ebp
xor r12d, r12d
jmp short loc_5BDB2
loc_5BDA0:
lea rsi, aInvalidImportB; "invalid import binding"
loc_5BDA7:
xor eax, eax
call js_parse_error
push 0FFFFFFFFFFFFFFFFh
pop r12
loc_5BDB2:
mov eax, r12d
add rsp, 20h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_5BDC2:
mov rsi, [rdi+90h]
mov eax, [rsi+198h]
xor ecx, ecx
test eax, eax
cmovle eax, ecx
loc_5BDD6:
cmp rax, rcx
jz loc_5BD1E
mov rdx, [rsi+1A0h]
lea r8, [rcx+1]
cmp [rdx+rcx*8+4], r9d
mov rcx, r8
jnz short loc_5BDD6
lea rsi, aDuplicateImpor; "duplicate import binding"
jmp short loc_5BDA7
| long long add_import(
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)
{
int v14; // ebx
long long v16; // r15
long long v17; // rsi
int v18; // eax
unsigned int v19; // r12d
int v20; // ebp
long long v21; // rax
int *v22; // rax
_DWORD *v23; // rcx
const char *v24; // rsi
long long v26; // rax
char v28; // [rsp+0h] [rbp-48h]
if ( (_DWORD)a3 == 78 || (a6 = (unsigned int)a3, (_DWORD)a3 == 59) )
{
v24 = "invalid import binding";
LABEL_11:
js_parse_error(a1, (long long)v24, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v28);
return (unsigned int)-1;
}
else
{
v14 = a4;
v16 = *a1;
if ( (_DWORD)a3 == 22 )
{
v17 = a1[18];
}
else
{
v17 = a1[18];
v26 = *(unsigned int *)(v17 + 408);
a4 = 0LL;
if ( (int)v26 <= 0 )
v26 = 0LL;
while ( v26 != a4 )
{
a3 = *(_QWORD *)(v17 + 416);
a5 = a4 + 1;
if ( *(_DWORD *)(a3 + 8 * a4++ + 4) == (_DWORD)a6 )
{
v24 = "duplicate import binding";
goto LABEL_11;
}
}
}
v18 = add_closure_var(v16, v17, v14 == 126, 0, *(_DWORD *)(a2 + 80), a6, 1, 1, 0);
v19 = -1;
if ( v18 >= 0 )
{
v20 = v18;
if ( !(unsigned int)js_resize_array(v16, a2 + 72, 12LL, (_DWORD *)(a2 + 84), *(_DWORD *)(a2 + 80) + 1) )
{
v21 = *(int *)(a2 + 80);
*(_DWORD *)(a2 + 80) = v21 + 1;
v22 = (int *)(*(_QWORD *)(a2 + 72) + 12 * v21);
if ( v14 >= 224 )
{
v23 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(v16 + 24) + 104LL) + 8LL * (unsigned int)v14);
++*v23;
}
v22[1] = v14;
*v22 = v20;
return 0;
}
}
}
return v19;
}
| add_import:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x20
CMP EDX,0x4e
JZ 0x0015bda0
MOV R9D,EDX
CMP EDX,0x3b
JZ 0x0015bda0
MOV EBX,ECX
MOV R14,RSI
MOV R15,qword ptr [RDI]
CMP R9D,0x16
JNZ 0x0015bdc2
MOV RSI,qword ptr [RDI + 0x90]
LAB_0015bd1e:
XOR EDX,EDX
CMP EBX,0x7e
SETZ DL
MOV R8D,dword ptr [R14 + 0x50]
PUSH 0x1
POP RAX
AND dword ptr [RSP + 0x10],0x0
MOV dword ptr [RSP + 0x8],EAX
MOV dword ptr [RSP],EAX
MOV RDI,R15
XOR ECX,ECX
CALL 0x0015bdfd
PUSH -0x1
POP R12
TEST EAX,EAX
JS 0x0015bdb2
MOV EBP,EAX
LEA RSI,[R14 + 0x48]
LEA RCX,[R14 + 0x54]
MOV R8D,dword ptr [R14 + 0x50]
INC R8D
PUSH 0xc
POP RDX
MOV RDI,R15
CALL 0x0013b0ef
TEST EAX,EAX
JNZ 0x0015bdb2
MOVSXD RAX,dword ptr [R14 + 0x50]
LEA ECX,[RAX + 0x1]
MOV dword ptr [R14 + 0x50],ECX
IMUL RAX,RAX,0xc
ADD RAX,qword ptr [R14 + 0x48]
CMP EBX,0xe0
JL 0x0015bd96
MOV RCX,qword ptr [R15 + 0x18]
MOV RCX,qword ptr [RCX + 0x68]
MOV EDX,EBX
MOV RCX,qword ptr [RCX + RDX*0x8]
INC dword ptr [RCX]
LAB_0015bd96:
MOV dword ptr [RAX + 0x4],EBX
MOV dword ptr [RAX],EBP
XOR R12D,R12D
JMP 0x0015bdb2
LAB_0015bda0:
LEA RSI,[0x1882a2]
LAB_0015bda7:
XOR EAX,EAX
CALL 0x00128457
PUSH -0x1
POP R12
LAB_0015bdb2:
MOV EAX,R12D
ADD RSP,0x20
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0015bdc2:
MOV RSI,qword ptr [RDI + 0x90]
MOV EAX,dword ptr [RSI + 0x198]
XOR ECX,ECX
TEST EAX,EAX
CMOVLE EAX,ECX
LAB_0015bdd6:
CMP RAX,RCX
JZ 0x0015bd1e
MOV RDX,qword ptr [RSI + 0x1a0]
LEA R8,[RCX + 0x1]
CMP dword ptr [RDX + RCX*0x8 + 0x4],R9D
MOV RCX,R8
JNZ 0x0015bdd6
LEA RSI,[0x1882b9]
JMP 0x0015bda7
|
int4 add_import(long *param_1,long param_2,int param_3,uint param_4)
{
long lVar1;
long lVar2;
int *piVar3;
int iVar4;
int iVar5;
int *piVar6;
ulong uVar7;
ulong uVar8;
long lVar9;
char *pcVar10;
if ((param_3 == 0x4e) || (param_3 == 0x3b)) {
pcVar10 = "invalid import binding";
}
else {
lVar2 = *param_1;
if (param_3 == 0x16) {
lVar9 = param_1[0x12];
LAB_0015bd1e:
iVar4 = add_closure_var(lVar2,lVar9,param_4 == 0x7e,0,*(int4 *)(param_2 + 0x50),param_3,
1,1,0);
if (iVar4 < 0) {
return 0xffffffff;
}
iVar5 = js_resize_array(lVar2,param_2 + 0x48,0xc,param_2 + 0x54,*(int *)(param_2 + 0x50) + 1);
if (iVar5 != 0) {
return 0xffffffff;
}
iVar5 = *(int *)(param_2 + 0x50);
*(int *)(param_2 + 0x50) = iVar5 + 1;
piVar6 = (int *)((long)iVar5 * 0xc + *(long *)(param_2 + 0x48));
if (0xdf < (int)param_4) {
piVar3 = *(int **)(*(long *)(*(long *)(lVar2 + 0x18) + 0x68) + (ulong)param_4 * 8);
*piVar3 = *piVar3 + 1;
}
piVar6[1] = param_4;
*piVar6 = iVar4;
return 0;
}
lVar9 = param_1[0x12];
uVar8 = 0;
uVar7 = (ulong)*(uint *)(lVar9 + 0x198);
if ((int)*(uint *)(lVar9 + 0x198) < 1) {
uVar7 = uVar8;
}
do {
if (uVar7 == uVar8) goto LAB_0015bd1e;
lVar1 = uVar8 * 8;
uVar8 = uVar8 + 1;
} while (*(int *)(*(long *)(lVar9 + 0x1a0) + 4 + lVar1) != param_3);
pcVar10 = "duplicate import binding";
}
js_parse_error(param_1,pcVar10);
return 0xffffffff;
}
| |
53,939 | my_like_range_czech | eloqsql/strings/ctype-czech.c | static my_bool my_like_range_czech(CHARSET_INFO *cs __attribute__((unused)),
const char *ptr,size_t ptr_length,
pbool escape, pbool w_one, pbool w_many,
size_t res_length, char *min_str,
char *max_str,
size_t *min_length,size_t *max_length)
{
#ifdef EXAMPLE
uchar value;
const char *end=ptr+ptr_length;
char *min_org=min_str;
char *min_end=min_str+res_length;
for (; ptr != end && min_str != min_end ; ptr++)
{
if (*ptr == w_one) /* '_' in SQL */
{ break; }
if (*ptr == w_many) /* '%' in SQL */
{ break; }
if (*ptr == escape && ptr+1 != end)
{ ptr++; } /* Skip escape */
value = CZ_SORT_TABLE[0][(int) (uchar) *ptr];
if (value == 0) /* Ignore in the first pass */
{ continue; }
if (value <= 2) /* End of pass or end of string */
{ break; }
if (value == 255) /* Double char too compicated */
{ break; }
*min_str++= *max_str++ = *ptr;
}
if (cs->state & MY_CS_BINSORT)
*min_length= (size_t) (min_str - min_org);
else
{
/* 'a\0\0... is the smallest possible string */
*min_length= res_length;
}
/* a\ff\ff... is the biggest possible string */
*max_length= res_length;
while (min_str != min_end)
{
*min_str++ = min_sort_char; /* Because of key compression */
*max_str++ = max_sort_char;
}
return 0;
#else
return 1;
#endif
} | O3 | c | my_like_range_czech:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r11
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %r12
movq 0x10(%rbp), %r15
leaq (%r12,%r15), %r10
testq %rdx, %rdx
sete %sil
testq %r15, %r15
sete %bl
orb %sil, %bl
jne 0x36690
addq %r11, %rdx
leaq 0x87ed9(%rip), %r13 # 0xbe517
movq %r12, %r14
movb (%r11), %bl
cmpb %r8b, %bl
je 0x36693
cmpb %r9b, %bl
je 0x36693
leaq 0x1(%r11), %rsi
cmpq %rdx, %rsi
cmoveq %r11, %rsi
cmpb %cl, %bl
cmovneq %r11, %rsi
movzbl (%rsi), %r11d
movb (%r11,%r13), %bl
testb %bl, %bl
je 0x3667e
incb %bl
cmpb $0x4, %bl
jb 0x36693
movb %r11b, (%rax)
incq %rax
movb %r11b, (%r14)
incq %r14
incq %rsi
cmpq %rdx, %rsi
je 0x36693
movq %rsi, %r11
cmpq %r10, %r14
jne 0x36641
jmp 0x36693
movq %r12, %r14
movq %r14, %rcx
subq %r12, %rcx
testb $0x10, 0xc(%rdi)
cmoveq %r15, %rcx
movq 0x28(%rbp), %rdx
movq %rcx, (%rdx)
movq 0x30(%rbp), %rcx
movq %r15, (%rcx)
cmpq %r10, %r14
je 0x366c3
movb $0x20, (%r14)
incq %r14
movb $0x39, (%rax)
incq %rax
jmp 0x366af
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_like_range_czech:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
mov r11, rsi
mov rax, [rbp+arg_10]
mov r12, [rbp+arg_8]
mov r15, [rbp+arg_0]
lea r10, [r12+r15]
test rdx, rdx
setz sil
test r15, r15
setz bl
or bl, sil
jnz short loc_36690
add rdx, r11
lea r13, unk_BE517
mov r14, r12
loc_36641:
mov bl, [r11]
cmp bl, r8b
jz short loc_36693
cmp bl, r9b
jz short loc_36693
lea rsi, [r11+1]
cmp rsi, rdx
cmovz rsi, r11
cmp bl, cl
cmovnz rsi, r11
movzx r11d, byte ptr [rsi]
mov bl, [r11+r13]
test bl, bl
jz short loc_3667E
inc bl
cmp bl, 4
jb short loc_36693
mov [rax], r11b
inc rax
mov [r14], r11b
inc r14
loc_3667E:
inc rsi
cmp rsi, rdx
jz short loc_36693
mov r11, rsi
cmp r14, r10
jnz short loc_36641
jmp short loc_36693
loc_36690:
mov r14, r12
loc_36693:
mov rcx, r14
sub rcx, r12
test byte ptr [rdi+0Ch], 10h
cmovz rcx, r15
mov rdx, [rbp+arg_18]
mov [rdx], rcx
mov rcx, [rbp+arg_20]
mov [rcx], r15
loc_366AF:
cmp r14, r10
jz short loc_366C3
mov byte ptr [r14], 20h ; ' '
inc r14
mov byte ptr [rax], 39h ; '9'
inc rax
jmp short loc_366AF
loc_366C3:
xor eax, eax
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_like_range_czech(
long long a1,
unsigned __int8 *a2,
long long a3,
char a4,
char a5,
char a6,
long long a7,
long long a8,
_BYTE *a9,
long long *a10,
_QWORD *a11)
{
unsigned __int8 *v11; // r11
_BYTE *v13; // r10
unsigned __int8 *v14; // rdx
_BYTE *v15; // r14
unsigned __int8 v16; // bl
unsigned __int8 *v17; // rsi
long long v18; // r11
char v19; // bl
unsigned __int8 *v20; // rsi
long long v21; // rcx
v11 = a2;
v13 = (_BYTE *)(a8 + a7);
if ( a3 == 0 || a7 == 0 )
{
v15 = (_BYTE *)a8;
}
else
{
v14 = &a2[a3];
v15 = (_BYTE *)a8;
do
{
v16 = *v11;
if ( *v11 == a5 || v16 == a6 )
break;
v17 = v11 + 1;
if ( v11 + 1 == v14 )
v17 = v11;
if ( v16 != a4 )
v17 = v11;
v18 = *v17;
v19 = byte_BE517[v18];
if ( v19 )
{
if ( (unsigned __int8)(v19 + 1) < 4u )
break;
*a9++ = v18;
*v15++ = v18;
}
v20 = v17 + 1;
if ( v20 == v14 )
break;
v11 = v20;
}
while ( v15 != v13 );
}
v21 = (long long)&v15[-a8];
if ( (*(_BYTE *)(a1 + 12) & 0x10) == 0 )
v21 = a7;
*a10 = v21;
*a11 = a7;
while ( v15 != v13 )
{
*v15++ = 32;
*a9++ = 57;
}
return 0LL;
}
| my_like_range_czech:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV R11,RSI
MOV RAX,qword ptr [RBP + 0x20]
MOV R12,qword ptr [RBP + 0x18]
MOV R15,qword ptr [RBP + 0x10]
LEA R10,[R12 + R15*0x1]
TEST RDX,RDX
SETZ SIL
TEST R15,R15
SETZ BL
OR BL,SIL
JNZ 0x00136690
ADD RDX,R11
LEA R13,[0x1be517]
MOV R14,R12
LAB_00136641:
MOV BL,byte ptr [R11]
CMP BL,R8B
JZ 0x00136693
CMP BL,R9B
JZ 0x00136693
LEA RSI,[R11 + 0x1]
CMP RSI,RDX
CMOVZ RSI,R11
CMP BL,CL
CMOVNZ RSI,R11
MOVZX R11D,byte ptr [RSI]
MOV BL,byte ptr [R11 + R13*0x1]
TEST BL,BL
JZ 0x0013667e
INC BL
CMP BL,0x4
JC 0x00136693
MOV byte ptr [RAX],R11B
INC RAX
MOV byte ptr [R14],R11B
INC R14
LAB_0013667e:
INC RSI
CMP RSI,RDX
JZ 0x00136693
MOV R11,RSI
CMP R14,R10
JNZ 0x00136641
JMP 0x00136693
LAB_00136690:
MOV R14,R12
LAB_00136693:
MOV RCX,R14
SUB RCX,R12
TEST byte ptr [RDI + 0xc],0x10
CMOVZ RCX,R15
MOV RDX,qword ptr [RBP + 0x28]
MOV qword ptr [RDX],RCX
MOV RCX,qword ptr [RBP + 0x30]
MOV qword ptr [RCX],R15
LAB_001366af:
CMP R14,R10
JZ 0x001366c3
MOV byte ptr [R14],0x20
INC R14
MOV byte ptr [RAX],0x39
INC RAX
JMP 0x001366af
LAB_001366c3:
XOR EAX,EAX
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8
my_like_range_czech(long param_1,byte *param_2,long param_3,byte param_4,byte param_5,byte param_6,
long param_7,byte *param_8,byte *param_9,long *param_10,long *param_11)
{
byte bVar1;
long lVar2;
byte *pbVar3;
byte *pbVar4;
byte *pbVar5;
pbVar5 = param_8;
if (param_7 != 0 && param_3 != 0) {
pbVar3 = param_2 + param_3;
while ((bVar1 = *param_2, bVar1 != param_5 && (bVar1 != param_6))) {
pbVar4 = param_2 + 1;
if (param_2 + 1 == pbVar3) {
pbVar4 = param_2;
}
if (bVar1 != param_4) {
pbVar4 = param_2;
}
bVar1 = *pbVar4;
if ((&DAT_001be517)[bVar1] != '\0') {
if ((byte)((&DAT_001be517)[bVar1] + 1) < 4) break;
*param_9 = bVar1;
param_9 = param_9 + 1;
*pbVar5 = bVar1;
pbVar5 = pbVar5 + 1;
}
param_2 = pbVar4 + 1;
if ((param_2 == pbVar3) || (pbVar5 == param_8 + param_7)) break;
}
}
lVar2 = (long)pbVar5 - (long)param_8;
if ((*(byte *)(param_1 + 0xc) & 0x10) == 0) {
lVar2 = param_7;
}
*param_10 = lVar2;
*param_11 = param_7;
for (; pbVar5 != param_8 + param_7; pbVar5 = pbVar5 + 1) {
*pbVar5 = 0x20;
*param_9 = 0x39;
param_9 = param_9 + 1;
}
return 0;
}
| |
53,940 | ma_init_dynamic_array | eloqsql/libmariadb/libmariadb/ma_array.c | my_bool ma_init_dynamic_array(DYNAMIC_ARRAY *array, uint element_size,
uint init_alloc, uint alloc_increment CALLER_INFO_PROTO)
{
if (!alloc_increment)
{
alloc_increment=max((8192-MALLOC_OVERHEAD)/element_size,16);
if (init_alloc > 8 && alloc_increment > init_alloc * 2)
alloc_increment=init_alloc*2;
}
if (!init_alloc)
init_alloc=alloc_increment;
array->elements=0;
array->max_element=init_alloc;
array->alloc_increment=alloc_increment;
array->size_of_element=element_size;
if (!(array->buffer=(char*) malloc(element_size*init_alloc)))
{
array->max_element=0;
return(TRUE);
}
return(FALSE);
} | O0 | c | ma_init_dynamic_array:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x476b5
movl $0x1ff8, %eax # imm = 0x1FF8
xorl %edx, %edx
divl -0x14(%rbp)
cmpl $0x10, %eax
jbe 0x47689
movl $0x1ff8, %eax # imm = 0x1FF8
xorl %edx, %edx
divl -0x14(%rbp)
movl %eax, -0x20(%rbp)
jmp 0x47693
movl $0x10, %eax
movl %eax, -0x20(%rbp)
jmp 0x47693
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x8, -0x18(%rbp)
jbe 0x476b3
movl -0x1c(%rbp), %eax
movl -0x18(%rbp), %ecx
shll %ecx
cmpl %ecx, %eax
jbe 0x476b3
movl -0x18(%rbp), %eax
shll %eax
movl %eax, -0x1c(%rbp)
jmp 0x476b5
cmpl $0x0, -0x18(%rbp)
jne 0x476c1
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
movl -0x14(%rbp), %eax
imull -0x18(%rbp), %eax
movl %eax, %eax
movl %eax, %edi
callq 0x135b0
movq -0x10(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x47718
movq -0x10(%rbp), %rax
movl $0x0, 0xc(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x4771c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| ma_init_dynamic_array:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov [rbp+var_1C], ecx
cmp [rbp+var_1C], 0
jnz short loc_476B5
mov eax, 1FF8h
xor edx, edx
div [rbp+var_14]
cmp eax, 10h
jbe short loc_47689
mov eax, 1FF8h
xor edx, edx
div [rbp+var_14]
mov [rbp+var_20], eax
jmp short loc_47693
loc_47689:
mov eax, 10h
mov [rbp+var_20], eax
jmp short $+2
loc_47693:
mov eax, [rbp+var_20]
mov [rbp+var_1C], eax
cmp [rbp+var_18], 8
jbe short loc_476B3
mov eax, [rbp+var_1C]
mov ecx, [rbp+var_18]
shl ecx, 1
cmp eax, ecx
jbe short loc_476B3
mov eax, [rbp+var_18]
shl eax, 1
mov [rbp+var_1C], eax
loc_476B3:
jmp short $+2
loc_476B5:
cmp [rbp+var_18], 0
jnz short loc_476C1
mov eax, [rbp+var_1C]
mov [rbp+var_18], eax
loc_476C1:
mov rax, [rbp+var_10]
mov dword ptr [rax+8], 0
mov ecx, [rbp+var_18]
mov rax, [rbp+var_10]
mov [rax+0Ch], ecx
mov ecx, [rbp+var_1C]
mov rax, [rbp+var_10]
mov [rax+10h], ecx
mov ecx, [rbp+var_14]
mov rax, [rbp+var_10]
mov [rax+14h], ecx
mov eax, [rbp+var_14]
imul eax, [rbp+var_18]
mov eax, eax
mov edi, eax
call _malloc
mov rcx, [rbp+var_10]
mov [rcx], rax
cmp rax, 0
jnz short loc_47718
mov rax, [rbp+var_10]
mov dword ptr [rax+0Ch], 0
mov [rbp+var_1], 1
jmp short loc_4771C
loc_47718:
mov [rbp+var_1], 0
loc_4771C:
mov al, [rbp+var_1]
add rsp, 20h
pop rbp
retn
| char ma_init_dynamic_array(long long a1, unsigned int a2, unsigned int a3, int a4)
{
long long v4; // rax
unsigned int v6; // [rsp+0h] [rbp-20h]
int v7; // [rsp+4h] [rbp-1Ch]
unsigned int v8; // [rsp+8h] [rbp-18h]
v8 = a3;
v7 = a4;
if ( !a4 )
{
v6 = 0x1FF8 / a2 <= 0x10 ? 16 : 0x1FF8 / a2;
v7 = v6;
if ( a3 > 8 && v6 > 2 * a3 )
v7 = 2 * a3;
}
if ( !a3 )
v8 = v7;
*(_DWORD *)(a1 + 8) = 0;
*(_DWORD *)(a1 + 12) = v8;
*(_DWORD *)(a1 + 16) = v7;
*(_DWORD *)(a1 + 20) = a2;
v4 = malloc(v8 * a2);
*(_QWORD *)a1 = v4;
if ( v4 )
return 0;
*(_DWORD *)(a1 + 12) = 0;
return 1;
}
| ma_init_dynamic_array:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV dword ptr [RBP + -0x1c],ECX
CMP dword ptr [RBP + -0x1c],0x0
JNZ 0x001476b5
MOV EAX,0x1ff8
XOR EDX,EDX
DIV dword ptr [RBP + -0x14]
CMP EAX,0x10
JBE 0x00147689
MOV EAX,0x1ff8
XOR EDX,EDX
DIV dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x20],EAX
JMP 0x00147693
LAB_00147689:
MOV EAX,0x10
MOV dword ptr [RBP + -0x20],EAX
JMP 0x00147693
LAB_00147693:
MOV EAX,dword ptr [RBP + -0x20]
MOV dword ptr [RBP + -0x1c],EAX
CMP dword ptr [RBP + -0x18],0x8
JBE 0x001476b3
MOV EAX,dword ptr [RBP + -0x1c]
MOV ECX,dword ptr [RBP + -0x18]
SHL ECX,0x1
CMP EAX,ECX
JBE 0x001476b3
MOV EAX,dword ptr [RBP + -0x18]
SHL EAX,0x1
MOV dword ptr [RBP + -0x1c],EAX
LAB_001476b3:
JMP 0x001476b5
LAB_001476b5:
CMP dword ptr [RBP + -0x18],0x0
JNZ 0x001476c1
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x18],EAX
LAB_001476c1:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x8],0x0
MOV ECX,dword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xc],ECX
MOV ECX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x10],ECX
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x14],ECX
MOV EAX,dword ptr [RBP + -0x14]
IMUL EAX,dword ptr [RBP + -0x18]
MOV EAX,EAX
MOV EDI,EAX
CALL 0x001135b0
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX],RAX
CMP RAX,0x0
JNZ 0x00147718
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xc],0x0
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0014771c
LAB_00147718:
MOV byte ptr [RBP + -0x1],0x0
LAB_0014771c:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x20
POP RBP
RET
|
bool ma_init_dynamic_array(int8 *param_1,uint param_2,uint param_3,uint param_4)
{
void *pvVar1;
uint local_28;
uint local_24;
uint local_20;
local_24 = param_4;
if (param_4 == 0) {
if ((uint)(0x1ff8 / (ulong)param_2) < 0x11) {
local_28 = 0x10;
}
else {
local_28 = (uint)(0x1ff8 / (ulong)param_2);
}
local_24 = local_28;
if ((8 < param_3) && (param_3 * 2 < local_28)) {
local_24 = param_3 << 1;
}
}
local_20 = param_3;
if (param_3 == 0) {
local_20 = local_24;
}
*(int4 *)(param_1 + 1) = 0;
*(uint *)((long)param_1 + 0xc) = local_20;
*(uint *)(param_1 + 2) = local_24;
*(uint *)((long)param_1 + 0x14) = param_2;
pvVar1 = malloc((ulong)(param_2 * local_20));
*param_1 = pvVar1;
if (pvVar1 == (void *)0x0) {
*(int4 *)((long)param_1 + 0xc) = 0;
}
return pvVar1 == (void *)0x0;
}
| |
53,941 | minja::Value::dump(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, int, int, bool) const | monkey531[P]llama/common/minja.hpp | void dump(std::ostringstream & out, int indent = -1, int level = 0, bool to_json = false) const {
auto print_indent = [&](int level) {
if (indent > 0) {
out << "\n";
for (int i = 0, n = level * indent; i < n; ++i) out << ' ';
}
};
auto print_sub_sep = [&]() {
out << ',';
if (indent < 0) out << ' ';
else print_indent(level + 1);
};
auto string_quote = to_json ? '"' : '\'';
if (is_null()) out << "null";
else if (array_) {
out << "[";
print_indent(level + 1);
for (size_t i = 0; i < array_->size(); ++i) {
if (i) print_sub_sep();
(*array_)[i].dump(out, indent, level + 1, to_json);
}
print_indent(level);
out << "]";
} else if (object_) {
out << "{";
print_indent(level + 1);
for (auto begin = object_->begin(), it = begin; it != object_->end(); ++it) {
if (it != begin) print_sub_sep();
if (it->first.is_string()) {
dump_string(it->first, out, string_quote);
} else {
out << string_quote << it->first.dump() << string_quote;
}
out << ": ";
it->second.dump(out, indent, level + 1, to_json);
}
print_indent(level);
out << "}";
} else if (callable_) {
throw std::runtime_error("Cannot dump callable to JSON");
} else if (is_boolean() && !to_json) {
out << (this->to_bool() ? "True" : "False");
} else if (is_string() && !to_json) {
dump_string(primitive_, out, string_quote);
} else {
out << primitive_.dump();
}
} | O2 | cpp | minja::Value::dump(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, int, int, bool) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r8d, %r12d
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xc(%rsp), %rax
movl %edx, (%rax)
leaq 0x8(%rsp), %rdx
movl %ecx, (%rdx)
leaq 0x18(%rsp), %rcx
movq %rax, (%rcx)
movq %rsi, 0x8(%rcx)
movq %rsi, 0x48(%rsp)
movq %rax, 0x50(%rsp)
movq %rcx, 0x58(%rsp)
movq %rdx, 0x60(%rsp)
xorl %r15d, %r15d
testl %r8d, %r8d
sete %bpl
callq 0x67bbe
testb %al, %al
je 0x678f6
leaq 0x511cc(%rip), %rsi # 0xb8abd
jmp 0x67b41
cmpq $0x0, 0x10(%rbx)
je 0x67999
leaq 0x51f8e(%rip), %rsi # 0xb9896
movq %r14, %rdi
callq 0x248e0
movl 0x8(%rsp), %esi
incl %esi
leaq 0x18(%rsp), %rdi
callq 0x67bde
xorl %r13d, %r13d
movl %r12d, %eax
pushq $0x50
popq %r12
movzbl %al, %ebp
xorl %r15d, %r15d
movq 0x10(%rbx), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rax
subq %rdi, %rax
cqto
idivq %r12
cmpq %rax, %r15
jae 0x6797f
testq %r15, %r15
je 0x6795e
leaq 0x48(%rsp), %rdi
callq 0x67c2a
movq 0x10(%rbx), %rax
movq (%rax), %rdi
addq %r13, %rdi
movl 0xc(%rsp), %edx
movl 0x8(%rsp), %ecx
incl %ecx
movq %r14, %rsi
movl %ebp, %r8d
callq 0x67892
incq %r15
addq $0x50, %r13
jmp 0x67930
movl 0x8(%rsp), %esi
leaq 0x18(%rsp), %rdi
callq 0x67bde
leaq 0x4f837(%rip), %rsi # 0xb71cb
jmp 0x67b41
movb %bpl, %r15b
leal (%r15,%r15,4), %ebp
addl $0x22, %ebp
cmpq $0x0, 0x20(%rbx)
je 0x67acc
leaq 0x507d0(%rip), %rsi # 0xb8185
movq %r14, %rdi
callq 0x248e0
movl 0x8(%rsp), %esi
incl %esi
leaq 0x18(%rsp), %rdi
callq 0x67bde
movq 0x20(%rbx), %rax
movq (%rax), %r15
xorl %r13d, %r13d
movsbl %bpl, %ebp
movl %r12d, %ecx
leaq 0x51ec0(%rip), %r12 # 0xb98a5
movzbl %cl, %ecx
movl %ecx, 0x14(%rsp)
movl %ebp, 0x10(%rsp)
cmpq 0x8(%rax), %r15
je 0x67ab5
testq %r13, %r13
je 0x67a09
leaq 0x48(%rsp), %rdi
callq 0x67c2a
cmpb $0x3, (%r15)
jne 0x67a1e
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x67c60
jmp 0x67a7e
movq %r14, %rdi
movq %r13, %r14
movq %rbx, %r13
movq %rdi, %rbx
movl %ebp, %esi
callq 0x24a90
movq %rax, %rbp
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
pushq $-0x1
popq %rdx
pushq $0x20
popq %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x6180a
movq %rbp, %rdi
movl 0x10(%rsp), %ebp
leaq 0x28(%rsp), %rsi
callq 0x24810
movq %rax, %rdi
movl %ebp, %esi
callq 0x24a90
leaq 0x28(%rsp), %rdi
callq 0x25288
movq %rbx, %rax
movq %r13, %rbx
movq %r14, %r13
movq %rax, %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x248e0
leaq 0x10(%r15), %rdi
movl 0xc(%rsp), %edx
movl 0x8(%rsp), %ecx
incl %ecx
movq %r14, %rsi
movl 0x14(%rsp), %r8d
callq 0x67892
addq $0x60, %r15
movq 0x20(%rbx), %rax
addq $-0x60, %r13
jmp 0x679f0
movl 0x8(%rsp), %esi
leaq 0x18(%rsp), %rdi
callq 0x67bde
leaq 0x54e85(%rip), %rsi # 0xbc94f
jmp 0x67b41
cmpq $0x0, 0x30(%rbx)
jne 0x67b69
movb 0x40(%rbx), %al
cmpb $0x4, %al
setne %cl
orb %r12b, %cl
je 0x67b25
addq $0x40, %rbx
cmpb $0x3, %al
setne %al
orb %r12b, %al
je 0x67b58
leaq 0x28(%rsp), %r15
pushq $-0x1
popq %rdx
pushq $0x20
popq %rcx
movq %r15, %rdi
movq %rbx, %rsi
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x6180a
movq %r14, %rdi
movq %r15, %rsi
callq 0x24810
leaq 0x28(%rsp), %rdi
callq 0x25288
jmp 0x67b49
movq %rbx, %rdi
callq 0x6732c
leaq 0x50670(%rip), %rcx # 0xb81a4
leaq 0x5066e(%rip), %rsi # 0xb81a9
testb %al, %al
cmovneq %rcx, %rsi
movq %r14, %rdi
callq 0x248e0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movsbl %bpl, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x67c60
jmp 0x67b49
pushq $0x10
popq %rdi
callq 0x24480
movq %rax, %r14
leaq 0x5060c(%rip), %rsi # 0xb8187
movq %rax, %rdi
callq 0x24340
movq 0x9b466(%rip), %rsi # 0x102ff0
movq 0x9b3c7(%rip), %rdx # 0x102f58
movq %r14, %rdi
callq 0x24fa0
jmp 0x67ba8
movq %rax, %rbx
movq %r14, %rdi
callq 0x246c0
jmp 0x67bb5
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x25288
movq %rbx, %rdi
callq 0x25020
nop
| _ZNK5minja5Value4dumpERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEEiib:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov r12d, r8d
mov r14, rsi
mov rbx, rdi
lea rax, [rsp+98h+var_8C]
mov [rax], edx
lea rdx, [rsp+98h+var_90]
mov [rdx], ecx
lea rcx, [rsp+98h+var_80]
mov [rcx], rax
mov [rcx+8], rsi
mov [rsp+98h+var_50], rsi
mov [rsp+98h+var_48], rax
mov [rsp+98h+var_40], rcx
mov [rsp+98h+var_38], rdx
xor r15d, r15d
test r8d, r8d
setz bpl
call _ZNK5minja5Value7is_nullEv; minja::Value::is_null(void)
test al, al
jz short loc_678F6
lea rsi, aOnNull_0+5; "null"
jmp loc_67B41
loc_678F6:
cmp qword ptr [rbx+10h], 0
jz loc_67999
lea rsi, aBytes+9; "["
mov rdi, r14
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov esi, [rsp+98h+var_90]
inc esi
lea rdi, [rsp+98h+var_80]
call _ZZNK5minja5Value4dumpERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEEiibENKUliE_clEi; minja::Value::dump(std::ostringstream &,int,int,bool)::{lambda(int)#1}::operator()(int)
xor r13d, r13d
mov eax, r12d
push 50h ; 'P'
pop r12
movzx ebp, al
xor r15d, r15d
loc_67930:
mov rax, [rbx+10h]
mov rdi, [rax]
mov rax, [rax+8]
sub rax, rdi
cqo
idiv r12
cmp r15, rax
jnb short loc_6797F
test r15, r15
jz short loc_6795E
lea rdi, [rsp+98h+var_50]
call _ZZNK5minja5Value4dumpERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEEiibENKUlvE_clEv; minja::Value::dump(std::ostringstream &,int,int,bool)::{lambda(void)#1}::operator()(void)
mov rax, [rbx+10h]
mov rdi, [rax]
loc_6795E:
add rdi, r13; this
mov edx, [rsp+98h+var_8C]
mov ecx, [rsp+98h+var_90]
inc ecx
mov rsi, r14
mov r8d, ebp
call _ZNK5minja5Value4dumpERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEEiib; minja::Value::dump(std::ostringstream &,int,int,bool)
inc r15
add r13, 50h ; 'P'
jmp short loc_67930
loc_6797F:
mov esi, [rsp+98h+var_90]
lea rdi, [rsp+98h+var_80]
call _ZZNK5minja5Value4dumpERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEEiibENKUliE_clEi; minja::Value::dump(std::ostringstream &,int,int,bool)::{lambda(int)#1}::operator()(int)
lea rsi, asc_B71CA+1; "]"
jmp loc_67B41
loc_67999:
mov r15b, bpl
lea ebp, [r15+r15*4]
add ebp, 22h ; '"'
cmp qword ptr [rbx+20h], 0
jz loc_67ACC
lea rsi, asc_B8185; "{"
mov rdi, r14
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov esi, [rsp+98h+var_90]
inc esi
lea rdi, [rsp+98h+var_80]
call _ZZNK5minja5Value4dumpERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEEiibENKUliE_clEi; minja::Value::dump(std::ostringstream &,int,int,bool)::{lambda(int)#1}::operator()(int)
mov rax, [rbx+20h]
mov r15, [rax]
xor r13d, r13d
movsx ebp, bpl
mov ecx, r12d
lea r12, aSubtype+9; ": "
movzx ecx, cl
mov [rsp+98h+var_84], ecx
mov [rsp+98h+var_88], ebp
loc_679F0:
cmp r15, [rax+8]
jz loc_67AB5
test r13, r13
jz short loc_67A09
lea rdi, [rsp+98h+var_50]
call _ZZNK5minja5Value4dumpERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEEiibENKUlvE_clEv; minja::Value::dump(std::ostringstream &,int,int,bool)::{lambda(void)#1}::operator()(void)
loc_67A09:
cmp byte ptr [r15], 3
jnz short loc_67A1E
mov rdi, r15
mov rsi, r14
mov edx, ebp
call _ZN5minja5Value11dump_stringERKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES5_IhSaIhEEvEERNS6_19basic_ostringstreamIcS9_SA_EEc; minja::Value::dump_string(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,std::ostringstream &,char)
jmp short loc_67A7E
loc_67A1E:
mov rdi, r14
mov r14, r13
mov r13, rbx
mov rbx, rdi
mov esi, ebp
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_c; std::operator<<<std::char_traits<char>>(std::ostream &,char)
mov rbp, rax
lea rdi, [rsp+98h+var_70]
mov rsi, r15
push 0FFFFFFFFFFFFFFFFh
pop rdx
push 20h ; ' '
pop rcx
xor r8d, r8d
xor r9d, r9d
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dumpEicbNS0_6detail15error_handler_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>::dump(int,char,bool,nlohmann::json_abi_v3_11_3::detail::error_handler_t)
mov rdi, rbp
mov ebp, [rsp+98h+var_88]
lea rsi, [rsp+98h+var_70]
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
mov rdi, rax
mov esi, ebp
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_c; std::operator<<<std::char_traits<char>>(std::ostream &,char)
lea rdi, [rsp+98h+var_70]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rax, rbx
mov rbx, r13
mov r13, r14
mov r14, rax
loc_67A7E:
mov rdi, r14
mov rsi, r12
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
lea rdi, [r15+10h]
mov edx, [rsp+98h+var_8C]
mov ecx, [rsp+98h+var_90]
inc ecx
mov rsi, r14
mov r8d, [rsp+98h+var_84]
call _ZNK5minja5Value4dumpERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEEiib; minja::Value::dump(std::ostringstream &,int,int,bool)
add r15, 60h ; '`'
mov rax, [rbx+20h]
add r13, 0FFFFFFFFFFFFFFA0h
jmp loc_679F0
loc_67AB5:
mov esi, [rsp+98h+var_90]
lea rdi, [rsp+98h+var_80]
call _ZZNK5minja5Value4dumpERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEEiibENKUliE_clEi; minja::Value::dump(std::ostringstream &,int,int,bool)::{lambda(int)#1}::operator()(int)
lea rsi, aNT020+17h; "}"
jmp short loc_67B41
loc_67ACC:
cmp qword ptr [rbx+30h], 0
jnz loc_67B69
mov al, [rbx+40h]
cmp al, 4
setnz cl
or cl, r12b
jz short loc_67B25
add rbx, 40h ; '@'
cmp al, 3
setnz al
or al, r12b
jz short loc_67B58
lea r15, [rsp+98h+var_70]
push 0FFFFFFFFFFFFFFFFh
pop rdx
push 20h ; ' '
pop rcx
mov rdi, r15
mov rsi, rbx
xor r8d, r8d
xor r9d, r9d
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dumpEicbNS0_6detail15error_handler_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>::dump(int,char,bool,nlohmann::json_abi_v3_11_3::detail::error_handler_t)
mov rdi, r14
mov rsi, r15
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
lea rdi, [rsp+98h+var_70]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_67B49
loc_67B25:
mov rdi, rbx; this
call _ZNK5minja5Value7to_boolEv; minja::Value::to_bool(void)
lea rcx, aTrue_0; "True"
lea rsi, aFalse; "False"
test al, al
cmovnz rsi, rcx
loc_67B41:
mov rdi, r14
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
loc_67B49:
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_67B58:
movsx edx, bpl
mov rdi, rbx
mov rsi, r14
call _ZN5minja5Value11dump_stringERKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES5_IhSaIhEEvEERNS6_19basic_ostringstreamIcS9_SA_EEc; minja::Value::dump_string(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,std::ostringstream &,char)
jmp short loc_67B49
loc_67B69:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aCannotDumpCall; "Cannot dump callable to JSON"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp short loc_67BA8
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_67BB5
loc_67BA8:
mov rbx, rax
lea rdi, [rsp+98h+var_70]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_67BB5:
mov rdi, rbx
call __Unwind_Resume
| void minja::Value::dump(long long a1, long long a2, unsigned int a3, unsigned int a4, int a5)
{
unsigned __int8 v5; // r12
long long v6; // r14
long long v7; // rbx
bool v8; // bp
char *v9; // rsi
long long v10; // r13
unsigned long long i; // r15
long long *v12; // rax
long long v13; // rdi
bool v14; // r15
unsigned int v15; // ebp
_BYTE **v16; // rax
_BYTE *v17; // r15
long long v18; // r13
long long v19; // rdi
long long v20; // r14
long long v21; // r13
long long v22; // rbx
long long v23; // rbp
long long v24; // rdi
long long v25; // rax
long long v26; // rax
char v27; // al
long long v28; // rbx
std::runtime_error *exception; // r14
unsigned int v30; // [rsp+8h] [rbp-90h] BYREF
unsigned int v31; // [rsp+Ch] [rbp-8Ch] BYREF
unsigned int v32; // [rsp+10h] [rbp-88h]
unsigned int v33; // [rsp+14h] [rbp-84h]
_QWORD v34[2]; // [rsp+18h] [rbp-80h] BYREF
_BYTE v35[32]; // [rsp+28h] [rbp-70h] BYREF
_QWORD v36[10]; // [rsp+48h] [rbp-50h] BYREF
v5 = a5;
v6 = a2;
v7 = a1;
v31 = a3;
v30 = a4;
v34[0] = &v31;
v34[1] = a2;
v36[0] = a2;
v36[1] = &v31;
v36[2] = v34;
v36[3] = &v30;
v8 = a5 == 0;
if ( (unsigned __int8)minja::Value::is_null((minja::Value *)a1) )
{
v9 = "null";
LABEL_26:
std::operator<<<std::char_traits<char>>(v6, v9);
return;
}
if ( *(_QWORD *)(a1 + 16) )
{
std::operator<<<std::char_traits<char>>(a2, "[");
minja::Value::dump(std::ostringstream &,int,int,bool)const::{lambda(int)#1}::operator()(v34, v30 + 1);
v10 = 0LL;
for ( i = 0LL; ; ++i )
{
v12 = *(long long **)(v7 + 16);
v13 = *v12;
if ( i >= (v12[1] - *v12) / 80 )
break;
if ( i )
{
minja::Value::dump(std::ostringstream &,int,int,bool)const::{lambda(void)#1}::operator()(v36);
v13 = **(_QWORD **)(v7 + 16);
}
minja::Value::dump(v10 + v13, a2, v31, v30 + 1, v5);
v10 += 80LL;
}
minja::Value::dump(std::ostringstream &,int,int,bool)const::{lambda(int)#1}::operator()(v34, v30);
v9 = "]";
goto LABEL_26;
}
v14 = v8;
LOBYTE(v15) = 5 * v8 + 34;
if ( *(_QWORD *)(a1 + 32) )
{
std::operator<<<std::char_traits<char>>(a2, "{");
minja::Value::dump(std::ostringstream &,int,int,bool)const::{lambda(int)#1}::operator()(v34, v30 + 1);
v16 = *(_BYTE ***)(a1 + 32);
v17 = *v16;
v18 = 0LL;
v15 = (char)v15;
v33 = v5;
v32 = (char)v15;
while ( v17 != v16[1] )
{
if ( v18 )
minja::Value::dump(std::ostringstream &,int,int,bool)const::{lambda(void)#1}::operator()(v36);
if ( *v17 == 3 )
{
minja::Value::dump_string(v17, v6, v15);
}
else
{
v19 = v6;
v20 = v18;
v21 = v7;
v22 = v19;
v23 = std::operator<<<std::char_traits<char>>(v19, v15);
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>::dump(
(long long)v35,
(long long)v17,
-1,
32,
0,
0);
v24 = v23;
v15 = v32;
v25 = std::operator<<<char>(v24, v35);
std::operator<<<std::char_traits<char>>(v25, v15);
std::string::~string(v35);
v26 = v22;
v7 = v21;
v18 = v20;
v6 = v26;
}
std::operator<<<std::char_traits<char>>(v6, ": ");
minja::Value::dump(v17 + 16, v6, v31, v30 + 1, v33);
v17 += 96;
v16 = *(_BYTE ***)(v7 + 32);
v18 -= 96LL;
}
minja::Value::dump(std::ostringstream &,int,int,bool)const::{lambda(int)#1}::operator()(v34, v30);
v9 = "}";
goto LABEL_26;
}
if ( *(_QWORD *)(a1 + 48) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Cannot dump callable to JSON");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v27 = *(_BYTE *)(a1 + 64);
if ( !(v5 | (v27 != 4)) )
{
v9 = "False";
if ( (unsigned __int8)minja::Value::to_bool((minja::Value *)a1) )
v9 = "True";
goto LABEL_26;
}
v28 = a1 + 64;
if ( v5 | (v27 != 3) )
{
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>::dump(
(long long)v35,
v28,
-1,
32,
0,
0);
std::operator<<<char>(a2, v35);
std::string::~string(v35);
}
else
{
minja::Value::dump_string(v28, a2, (unsigned int)(char)(5 * v14 + 34));
}
}
| dump:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R12D,R8D
MOV R14,RSI
MOV RBX,RDI
LEA RAX,[RSP + 0xc]
MOV dword ptr [RAX],EDX
LEA RDX,[RSP + 0x8]
MOV dword ptr [RDX],ECX
LEA RCX,[RSP + 0x18]
MOV qword ptr [RCX],RAX
MOV qword ptr [RCX + 0x8],RSI
MOV qword ptr [RSP + 0x48],RSI
MOV qword ptr [RSP + 0x50],RAX
MOV qword ptr [RSP + 0x58],RCX
MOV qword ptr [RSP + 0x60],RDX
XOR R15D,R15D
TEST R8D,R8D
SETZ BPL
CALL 0x00167bbe
TEST AL,AL
JZ 0x001678f6
LEA RSI,[0x1b8abd]
JMP 0x00167b41
LAB_001678f6:
CMP qword ptr [RBX + 0x10],0x0
JZ 0x00167999
LEA RSI,[0x1b9896]
MOV RDI,R14
CALL 0x001248e0
MOV ESI,dword ptr [RSP + 0x8]
INC ESI
LEA RDI,[RSP + 0x18]
CALL 0x00167bde
XOR R13D,R13D
MOV EAX,R12D
PUSH 0x50
POP R12
MOVZX EBP,AL
XOR R15D,R15D
LAB_00167930:
MOV RAX,qword ptr [RBX + 0x10]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x8]
SUB RAX,RDI
CQO
IDIV R12
CMP R15,RAX
JNC 0x0016797f
TEST R15,R15
JZ 0x0016795e
LEA RDI,[RSP + 0x48]
CALL 0x00167c2a
MOV RAX,qword ptr [RBX + 0x10]
MOV RDI,qword ptr [RAX]
LAB_0016795e:
ADD RDI,R13
MOV EDX,dword ptr [RSP + 0xc]
MOV ECX,dword ptr [RSP + 0x8]
INC ECX
MOV RSI,R14
MOV R8D,EBP
CALL 0x00167892
INC R15
ADD R13,0x50
JMP 0x00167930
LAB_0016797f:
MOV ESI,dword ptr [RSP + 0x8]
LEA RDI,[RSP + 0x18]
CALL 0x00167bde
LEA RSI,[0x1b71cb]
JMP 0x00167b41
LAB_00167999:
MOV R15B,BPL
LEA EBP,[R15 + R15*0x4]
ADD EBP,0x22
CMP qword ptr [RBX + 0x20],0x0
JZ 0x00167acc
LEA RSI,[0x1b8185]
MOV RDI,R14
CALL 0x001248e0
MOV ESI,dword ptr [RSP + 0x8]
INC ESI
LEA RDI,[RSP + 0x18]
CALL 0x00167bde
MOV RAX,qword ptr [RBX + 0x20]
MOV R15,qword ptr [RAX]
XOR R13D,R13D
MOVSX EBP,BPL
MOV ECX,R12D
LEA R12,[0x1b98a5]
MOVZX ECX,CL
MOV dword ptr [RSP + 0x14],ECX
MOV dword ptr [RSP + 0x10],EBP
LAB_001679f0:
CMP R15,qword ptr [RAX + 0x8]
JZ 0x00167ab5
TEST R13,R13
JZ 0x00167a09
LEA RDI,[RSP + 0x48]
CALL 0x00167c2a
LAB_00167a09:
CMP byte ptr [R15],0x3
JNZ 0x00167a1e
MOV RDI,R15
MOV RSI,R14
MOV EDX,EBP
CALL 0x00167c60
JMP 0x00167a7e
LAB_00167a1e:
MOV RDI,R14
MOV R14,R13
MOV R13,RBX
MOV RBX,RDI
MOV ESI,EBP
CALL 0x00124a90
MOV RBP,RAX
LEA RDI,[RSP + 0x28]
MOV RSI,R15
PUSH -0x1
POP RDX
PUSH 0x20
POP RCX
XOR R8D,R8D
XOR R9D,R9D
CALL 0x0016180a
LAB_00167a4d:
MOV RDI,RBP
MOV EBP,dword ptr [RSP + 0x10]
LEA RSI,[RSP + 0x28]
CALL 0x00124810
MOV RDI,RAX
MOV ESI,EBP
CALL 0x00124a90
LAB_00167a68:
LEA RDI,[RSP + 0x28]
CALL 0x00125288
MOV RAX,RBX
MOV RBX,R13
MOV R13,R14
MOV R14,RAX
LAB_00167a7e:
MOV RDI,R14
MOV RSI,R12
CALL 0x001248e0
LEA RDI,[R15 + 0x10]
MOV EDX,dword ptr [RSP + 0xc]
MOV ECX,dword ptr [RSP + 0x8]
INC ECX
MOV RSI,R14
MOV R8D,dword ptr [RSP + 0x14]
CALL 0x00167892
ADD R15,0x60
MOV RAX,qword ptr [RBX + 0x20]
ADD R13,-0x60
JMP 0x001679f0
LAB_00167ab5:
MOV ESI,dword ptr [RSP + 0x8]
LEA RDI,[RSP + 0x18]
CALL 0x00167bde
LEA RSI,[0x1bc94f]
JMP 0x00167b41
LAB_00167acc:
CMP qword ptr [RBX + 0x30],0x0
JNZ 0x00167b69
MOV AL,byte ptr [RBX + 0x40]
CMP AL,0x4
SETNZ CL
OR CL,R12B
JZ 0x00167b25
ADD RBX,0x40
CMP AL,0x3
SETNZ AL
OR AL,R12B
JZ 0x00167b58
LEA R15,[RSP + 0x28]
PUSH -0x1
POP RDX
PUSH 0x20
POP RCX
MOV RDI,R15
MOV RSI,RBX
XOR R8D,R8D
XOR R9D,R9D
CALL 0x0016180a
LAB_00167b0e:
MOV RDI,R14
MOV RSI,R15
CALL 0x00124810
LAB_00167b19:
LEA RDI,[RSP + 0x28]
CALL 0x00125288
JMP 0x00167b49
LAB_00167b25:
MOV RDI,RBX
CALL 0x0016732c
LEA RCX,[0x1b81a4]
LEA RSI,[0x1b81a9]
TEST AL,AL
CMOVNZ RSI,RCX
LAB_00167b41:
MOV RDI,R14
CALL 0x001248e0
LAB_00167b49:
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00167b58:
MOVSX EDX,BPL
MOV RDI,RBX
MOV RSI,R14
CALL 0x00167c60
JMP 0x00167b49
LAB_00167b69:
PUSH 0x10
POP RDI
CALL 0x00124480
MOV R14,RAX
LAB_00167b74:
LEA RSI,[0x1b8187]
MOV RDI,RAX
CALL 0x00124340
LAB_00167b83:
MOV RSI,qword ptr [0x00202ff0]
MOV RDX,qword ptr [0x00202f58]
MOV RDI,R14
CALL 0x00124fa0
|
/* minja::Value::dump(std::__cxx11::ostringstream&, int, int, bool) const */
void __thiscall
minja::Value::dump(Value *this,ostringstream *param_1,int param_2,int param_3,bool param_4)
{
char cVar1;
int8 *puVar2;
ostream *poVar3;
runtime_error *this_00;
int iVar4;
char *pcVar5;
long lVar6;
int7 in_register_00000081;
long lVar7;
ulong uVar8;
int local_90;
int local_8c;
int local_88;
uint local_84;
int *local_80;
ostringstream *local_78;
string local_70 [32];
ostringstream *local_50;
int *local_48;
int **local_40;
int *local_38;
local_80 = &local_8c;
local_38 = &local_90;
local_40 = &local_80;
local_90 = param_3;
local_8c = param_2;
local_78 = param_1;
local_50 = param_1;
local_48 = local_80;
cVar1 = is_null(this);
if (cVar1 == '\0') {
if (*(long *)(this + 0x10) == 0) {
cVar1 = ((int)CONCAT71(in_register_00000081,param_4) == 0) * '\x05' + '\"';
if (*(long *)(this + 0x20) == 0) {
if (*(long *)(this + 0x30) != 0) {
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00167b74 to 00167b82 has its CatchHandler @ 00167b9b */
std::runtime_error::runtime_error(this_00,"Cannot dump callable to JSON");
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_00202ff0,PTR__runtime_error_00202f58);
}
if (this[0x40] != (Value)0x4 || param_4) {
if (this[0x40] != (Value)0x3 || param_4) {
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::dump(local_70,this + 0x40,0xffffffffffffffff,0x20,0,0);
/* try { // try from 00167b0e to 00167b18 has its CatchHandler @ 00167b99 */
std::operator<<((ostream *)param_1,local_70);
std::__cxx11::string::~string(local_70);
return;
}
dump_string(this + 0x40,param_1,cVar1);
return;
}
cVar1 = to_bool(this);
pcVar5 = "False";
if (cVar1 != '\0') {
pcVar5 = "True";
}
}
else {
std::operator<<((ostream *)param_1,"{");
const::{lambda(int)#1}::operator()((_lambda_int__1_ *)&local_80,local_90 + 1);
puVar2 = *(int8 **)(this + 0x20);
lVar7 = 0;
iVar4 = (int)cVar1;
local_84 = (uint)param_4;
local_88 = iVar4;
for (pcVar5 = (char *)*puVar2; pcVar5 != (char *)puVar2[1]; pcVar5 = pcVar5 + 0x60) {
if (lVar7 != 0) {
const::{lambda()#1}::operator()((_lambda___1_ *)&local_50);
}
if (*pcVar5 == '\x03') {
dump_string(pcVar5,param_1,(char)iVar4);
}
else {
poVar3 = std::operator<<((ostream *)param_1,(char)iVar4);
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>
::dump(local_70,pcVar5,0xffffffffffffffff,0x20,0,0);
iVar4 = local_88;
/* try { // try from 00167a4d to 00167a67 has its CatchHandler @ 00167ba8 */
poVar3 = std::operator<<(poVar3,local_70);
std::operator<<(poVar3,(char)iVar4);
std::__cxx11::string::~string(local_70);
}
std::operator<<((ostream *)param_1,": ");
dump((Value *)(pcVar5 + 0x10),param_1,local_8c,local_90 + 1,SUB41(local_84,0));
puVar2 = *(int8 **)(this + 0x20);
lVar7 = lVar7 + -0x60;
}
const::{lambda(int)#1}::operator()((_lambda_int__1_ *)&local_80,local_90);
pcVar5 = "}";
}
}
else {
std::operator<<((ostream *)param_1,"[");
const::{lambda(int)#1}::operator()((_lambda_int__1_ *)&local_80,local_90 + 1);
lVar7 = 0;
for (uVar8 = 0; lVar6 = **(long **)(this + 0x10),
uVar8 < (ulong)(((*(long **)(this + 0x10))[1] - lVar6) / 0x50); uVar8 = uVar8 + 1) {
if (uVar8 != 0) {
const::{lambda()#1}::operator()((_lambda___1_ *)&local_50);
lVar6 = **(long **)(this + 0x10);
}
dump((Value *)(lVar6 + lVar7),param_1,local_8c,local_90 + 1,param_4);
lVar7 = lVar7 + 0x50;
}
const::{lambda(int)#1}::operator()((_lambda_int__1_ *)&local_80,local_90);
pcVar5 = "]";
}
}
else {
pcVar5 = "null";
}
std::operator<<((ostream *)param_1,pcVar5);
return;
}
| |
53,942 | ma_readinfo | eloqsql/storage/maria/ma_locking.c | int _ma_readinfo(register MARIA_HA *info __attribute__ ((unused)),
int lock_type __attribute__ ((unused)),
int check_keybuffer __attribute__ ((unused)))
{
#ifdef MARIA_EXTERNAL_LOCKING
DBUG_ENTER("_ma_readinfo");
if (info->lock_type == F_UNLCK)
{
MARIA_SHARE *share= info->s;
if (!share->tot_locks)
{
/* should not be done for transactional tables */
if (_ma_state_info_read_dsk(share->kfile.file, &share->state))
{
if (!my_errno)
my_errno= HA_ERR_FILE_TOO_SHORT;
DBUG_RETURN(1);
}
}
if (check_keybuffer)
VOID(_ma_test_if_changed(info));
info->invalidator=share->invalidator;
}
else if (lock_type == F_WRLCK && info->lock_type == F_RDLCK)
{
my_errno=EACCES; /* Not allowed to change */
DBUG_RETURN(-1); /* when have read_lock() */
}
DBUG_RETURN(0);
#else
return 0;
#endif /* defined(MARIA_EXTERNAL_LOCKING) */
} | O0 | c | ma_readinfo:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
xorl %eax, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ma_readinfo:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_10], edx
xor eax, eax
pop rbp
retn
| long long ma_readinfo()
{
return 0LL;
}
| _ma_readinfo:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV dword ptr [RBP + -0x10],EDX
XOR EAX,EAX
POP RBP
RET
|
int8 _ma_readinfo(void)
{
return 0;
}
| |
53,943 | ma_readinfo | eloqsql/storage/maria/ma_locking.c | int _ma_readinfo(register MARIA_HA *info __attribute__ ((unused)),
int lock_type __attribute__ ((unused)),
int check_keybuffer __attribute__ ((unused)))
{
#ifdef MARIA_EXTERNAL_LOCKING
DBUG_ENTER("_ma_readinfo");
if (info->lock_type == F_UNLCK)
{
MARIA_SHARE *share= info->s;
if (!share->tot_locks)
{
/* should not be done for transactional tables */
if (_ma_state_info_read_dsk(share->kfile.file, &share->state))
{
if (!my_errno)
my_errno= HA_ERR_FILE_TOO_SHORT;
DBUG_RETURN(1);
}
}
if (check_keybuffer)
VOID(_ma_test_if_changed(info));
info->invalidator=share->invalidator;
}
else if (lock_type == F_WRLCK && info->lock_type == F_RDLCK)
{
my_errno=EACCES; /* Not allowed to change */
DBUG_RETURN(-1); /* when have read_lock() */
}
DBUG_RETURN(0);
#else
return 0;
#endif /* defined(MARIA_EXTERNAL_LOCKING) */
} | O3 | c | ma_readinfo:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
popq %rbp
retq
| _ma_readinfo:
push rbp
mov rbp, rsp
xor eax, eax
pop rbp
retn
| long long ma_readinfo()
{
return 0LL;
}
| _ma_readinfo:
PUSH RBP
MOV RBP,RSP
XOR EAX,EAX
POP RBP
RET
|
int8 _ma_readinfo(void)
{
return 0;
}
| |
53,944 | 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>::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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>, bool, nlohmann::json_abi_v3_11_3::detail::value_t)::'lambda'(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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>> const&)::operator()(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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>> const&) const | monkey531[P]llama/common/json.hpp | value_type const& operator*() const
{
return value_ref ? *value_ref : owned_value;
} | O2 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>, bool, nlohmann::json_abi_v3_11_3::detail::value_t)::'lambda'(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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>> const&)::operator()(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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>> const&) const:
pushq %rbx
movq 0x10(%rsi), %rdi
testq %rdi, %rdi
cmoveq %rsi, %rdi
cmpb $0x2, (%rdi)
jne 0x941af
movq %rsi, %rbx
callq 0x691e8
cmpq $0x2, %rax
jne 0x941af
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
cmoveq %rbx, %rdi
xorl %esi, %esi
callq 0x941b4
cmpb $0x3, (%rax)
sete %al
jmp 0x941b1
xorl %eax, %eax
popq %rbx
retq
nop
| _ZZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC1ESt16initializer_listINS0_6detail8json_refISD_EEEbNSF_7value_tEENKUlRKSH_E_clESL_:
push rbx
mov rdi, [rsi+10h]
test rdi, rdi
cmovz rdi, rsi
cmp byte ptr [rdi], 2
jnz short loc_941AF
mov rbx, rsi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4sizeEv; 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>::size(void)
cmp rax, 2
jnz short loc_941AF
mov rdi, [rbx+10h]
test rdi, rdi
cmovz rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixEm; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator[](ulong)
cmp byte ptr [rax], 3
setz al
jmp short loc_941B1
loc_941AF:
xor eax, eax
loc_941B1:
pop rbx
retn
| bool 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(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,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>,bool,nlohmann::json_abi_v3_11_3::detail::value_t)::{lambda(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,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> const&)#1}::operator()(
long long a1,
long long a2)
{
unsigned __int8 *v2; // rdi
long long v3; // rdi
v2 = *(unsigned __int8 **)(a2 + 16);
if ( !v2 )
v2 = (unsigned __int8 *)a2;
if ( *v2 != 2
|| 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(v2) != 2 )
{
return 0;
}
v3 = *(_QWORD *)(a2 + 16);
if ( !v3 )
v3 = a2;
return *(_BYTE *)nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator[](
v3,
0LL) == 3;
}
| operator():
PUSH RBX
MOV RDI,qword ptr [RSI + 0x10]
TEST RDI,RDI
CMOVZ RDI,RSI
CMP byte ptr [RDI],0x2
JNZ 0x001941af
MOV RBX,RSI
CALL 0x001691e8
CMP RAX,0x2
JNZ 0x001941af
MOV RDI,qword ptr [RBX + 0x10]
TEST RDI,RDI
CMOVZ RDI,RBX
XOR ESI,ESI
CALL 0x001941b4
CMP byte ptr [RAX],0x3
SETZ AL
JMP 0x001941b1
LAB_001941af:
XOR EAX,EAX
LAB_001941b1:
POP RBX
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>::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::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> > >, bool,
nlohmann::json_abi_v3_11_3::detail::value_t)::{lambda(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::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >
const&)#1}::TEMPNAMEPLACEHOLDERVALUE(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::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> > const&) const */
bool __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>
::
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::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>,bool,nlohmann::json_abi_v3_11_3::detail::value_t)
::
{lambda(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::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>const&)#1}
::operator()(_lambda_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::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>const___1_
*this,json_ref *param_1)
{
long lVar1;
char *pcVar2;
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>
*pbVar3;
pbVar3 = *(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 + 0x10);
if (*(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 + 0x10) ==
(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) {
pbVar3 = (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;
}
if ((*pbVar3 ==
(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) && (lVar1 = size(pbVar3), lVar1 == 2)) {
pbVar3 = *(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 + 0x10);
if (*(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 + 0x10) ==
(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) {
pbVar3 = (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;
}
pcVar2 = (char *)basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator[](pbVar3,0);
return *pcVar2 == '\x03';
}
return false;
}
| |
53,945 | js_math_hypot | bluesky950520[P]quickjs/quickjs.c | static JSValue js_math_hypot(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
double r, a;
int i;
r = 0;
if (argc > 0) {
if (JS_ToFloat64(ctx, &r, argv[0]))
return JS_EXCEPTION;
if (argc == 1) {
r = fabs(r);
} else {
/* use the built-in function to minimize precision loss */
for (i = 1; i < argc; i++) {
if (JS_ToFloat64(ctx, &a, argv[i]))
return JS_EXCEPTION;
r = hypot(r, a);
}
}
}
return js_float64(r);
} | O2 | c | js_math_hypot:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
andq $0x0, (%rsp)
testl %ecx, %ecx
jle 0x69c6a
movq %r8, %r14
movl %ecx, %ebp
movq %rdi, %r15
movq (%r8), %rdx
movq 0x8(%r8), %rcx
movq %rsp, %rsi
callq 0x2127f
pushq $0x6
popq %rbx
testl %eax, %eax
je 0x69c6e
xorl %r12d, %r12d
xorl %eax, %eax
jmp 0x69ce9
xorl %ecx, %ecx
jmp 0x69cd6
movq (%rsp), %xmm0
cmpl $0x1, %ebp
jne 0x69c84
movq %xmm0, %rcx
btrq $0x3f, %rcx
jmp 0x69cd6
movl %ebp, %ebp
shlq $0x4, %rbp
addq $-0x10, %rbp
xorl %r12d, %r12d
xorl %r13d, %r13d
cmpq %r13, %rbp
je 0x69cd1
movq %xmm0, 0x8(%rsp)
movq 0x10(%r14,%r13), %rdx
movq 0x18(%r14,%r13), %rcx
movq %r15, %rdi
leaq 0x10(%rsp), %rsi
callq 0x2127f
testl %eax, %eax
jne 0x69c66
movsd 0x10(%rsp), %xmm1
movq 0x8(%rsp), %xmm0
callq 0xe6e0
addq $0x10, %r13
jmp 0x69c94
movq %xmm0, %rcx
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
andq %rcx, %rax
movl %ecx, %r12d
pushq $0x7
popq %rbx
orq %rax, %r12
movq %r12, %rax
movq %rbx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| js_math_hypot:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
and [rsp+48h+var_48], 0
test ecx, ecx
jle short loc_69C6A
mov r14, r8
mov ebp, ecx
mov r15, rdi
mov rdx, [r8]
mov rcx, [r8+8]
mov rsi, rsp
call JS_ToFloat64
push 6
pop rbx
test eax, eax
jz short loc_69C6E
xor r12d, r12d
loc_69C66:
xor eax, eax
jmp short loc_69CE9
loc_69C6A:
xor ecx, ecx
jmp short loc_69CD6
loc_69C6E:
movq xmm0, [rsp+48h+var_48]
cmp ebp, 1
jnz short loc_69C84
movq rcx, xmm0
btr rcx, 3Fh ; '?'
jmp short loc_69CD6
loc_69C84:
mov ebp, ebp
shl rbp, 4
add rbp, 0FFFFFFFFFFFFFFF0h
xor r12d, r12d
xor r13d, r13d
loc_69C94:
cmp rbp, r13
jz short loc_69CD1
movq [rsp+48h+var_40], xmm0
mov rdx, [r14+r13+10h]
mov rcx, [r14+r13+18h]
mov rdi, r15
lea rsi, [rsp+48h+var_38]
call JS_ToFloat64
test eax, eax
jnz short loc_69C66
movsd xmm1, [rsp+48h+var_38]
movq xmm0, [rsp+48h+var_40]
call _hypot
add r13, 10h
jmp short loc_69C94
loc_69CD1:
movq rcx, xmm0
loc_69CD6:
mov rax, 0FFFFFFFF00000000h
and rax, rcx
mov r12d, ecx
push 7
pop rbx
loc_69CE9:
or r12, rax
mov rax, r12
mov rdx, rbx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| unsigned long long js_math_hypot(long long a1, long long a2, long long a3, int a4, long long a5)
{
long long v7; // r12
unsigned long long v8; // rax
long long v9; // rcx
double v10; // xmm0_8
long long v11; // rbp
long long i; // r13
double v14; // [rsp+0h] [rbp-48h] BYREF
double v15; // [rsp+8h] [rbp-40h]
double v16[7]; // [rsp+10h] [rbp-38h] BYREF
v14 = 0.0;
if ( a4 <= 0 )
{
v9 = 0LL;
LABEL_13:
v8 = v9 & 0xFFFFFFFF00000000LL;
v7 = (unsigned int)v9;
return v8 | v7;
}
if ( !(unsigned int)JS_ToFloat64(a1, (long long)&v14, *(_DWORD **)a5, *(_QWORD *)(a5 + 8)) )
{
v10 = v14;
if ( a4 == 1 )
{
v9 = *(_QWORD *)&v14 & 0x7FFFFFFFFFFFFFFFLL;
}
else
{
v11 = 16LL * (unsigned int)a4 - 16;
v7 = 0LL;
for ( i = 0LL; v11 != i; i += 16LL )
{
v15 = v10;
if ( (unsigned int)JS_ToFloat64(a1, (long long)v16, *(_DWORD **)(a5 + i + 16), *(_QWORD *)(a5 + i + 24)) )
goto LABEL_4;
v10 = v15;
hypot(v15, v16[0]);
}
v9 = *(_QWORD *)&v10;
}
goto LABEL_13;
}
v7 = 0LL;
LABEL_4:
v8 = 0LL;
return v8 | v7;
}
| js_math_hypot:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
AND qword ptr [RSP],0x0
TEST ECX,ECX
JLE 0x00169c6a
MOV R14,R8
MOV EBP,ECX
MOV R15,RDI
MOV RDX,qword ptr [R8]
MOV RCX,qword ptr [R8 + 0x8]
MOV RSI,RSP
CALL 0x0012127f
PUSH 0x6
POP RBX
TEST EAX,EAX
JZ 0x00169c6e
XOR R12D,R12D
LAB_00169c66:
XOR EAX,EAX
JMP 0x00169ce9
LAB_00169c6a:
XOR ECX,ECX
JMP 0x00169cd6
LAB_00169c6e:
MOVQ XMM0,qword ptr [RSP]
CMP EBP,0x1
JNZ 0x00169c84
MOVQ RCX,XMM0
BTR RCX,0x3f
JMP 0x00169cd6
LAB_00169c84:
MOV EBP,EBP
SHL RBP,0x4
ADD RBP,-0x10
XOR R12D,R12D
XOR R13D,R13D
LAB_00169c94:
CMP RBP,R13
JZ 0x00169cd1
MOVQ qword ptr [RSP + 0x8],XMM0
MOV RDX,qword ptr [R14 + R13*0x1 + 0x10]
MOV RCX,qword ptr [R14 + R13*0x1 + 0x18]
MOV RDI,R15
LEA RSI,[RSP + 0x10]
CALL 0x0012127f
TEST EAX,EAX
JNZ 0x00169c66
MOVSD XMM1,qword ptr [RSP + 0x10]
MOVQ XMM0,qword ptr [RSP + 0x8]
CALL 0x0010e6e0
ADD R13,0x10
JMP 0x00169c94
LAB_00169cd1:
MOVQ RCX,XMM0
LAB_00169cd6:
MOV RAX,-0x100000000
AND RAX,RCX
MOV R12D,ECX
PUSH 0x7
POP RBX
LAB_00169ce9:
OR R12,RAX
MOV RAX,R12
MOV RDX,RBX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int1 [16]
js_math_hypot(int8 param_1,int8 param_2,int8 param_3,uint param_4,
int8 *param_5)
{
int iVar1;
ulong uVar2;
int8 uVar3;
ulong uVar4;
long lVar5;
int1 auVar6 [16];
double local_48;
double local_40;
double local_38;
local_48 = 0.0;
if ((int)param_4 < 1) {
local_40 = 0.0;
}
else {
iVar1 = JS_ToFloat64(param_1,&local_48,*param_5,param_5[1]);
uVar3 = 6;
if (iVar1 != 0) {
LAB_00169c66:
uVar4 = 0;
uVar2 = 0;
goto LAB_00169ce9;
}
if (param_4 == 1) {
local_40 = ABS(local_48);
}
else {
local_40 = local_48;
for (lVar5 = 0; (ulong)param_4 * 0x10 + -0x10 != lVar5; lVar5 = lVar5 + 0x10) {
iVar1 = JS_ToFloat64(param_1,&local_38,*(int8 *)((long)param_5 + lVar5 + 0x10),
*(int8 *)((long)param_5 + lVar5 + 0x18));
if (iVar1 != 0) goto LAB_00169c66;
local_40 = hypot(local_40,local_38);
}
}
}
uVar2 = (ulong)local_40 & 0xffffffff00000000;
uVar4 = (ulong)local_40 & 0xffffffff;
uVar3 = 7;
LAB_00169ce9:
auVar6._8_8_ = uVar3;
auVar6._0_8_ = uVar4 | uVar2;
return auVar6;
}
| |
53,946 | minja::Value::Value(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/minja.hpp | Value(const std::string & v) : primitive_(v) {} | O1 | cpp | minja::Value::Value(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x40, %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
callq 0x817ac
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x8cfc9
callq 0x6fa60
movq %rbx, %rdi
callq 0x1cb80
movq %rbx, %rdi
callq 0x8a348
movq %r14, %rdi
callq 0x1c030
nop
| _ZN5minja5ValueC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r14
push rbx
push rax
mov rbx, rdi
add rdi, 40h ; '@'
xorps xmm0, xmm0
movups xmmword ptr [rbx+30h], xmm0
movups xmmword ptr [rbx+20h], xmm0
movups xmmword ptr [rbx+10h], xmm0
movups xmmword ptr [rbx], xmm0
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRKS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SI_EE5valueEiE4typeELi0EEEOT_
add rsp, 8
pop rbx
pop r14
retn
mov r14, rax
mov rdi, [rbx+38h]
test rdi, rdi
jz short loc_8CFC9
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_8CFC9:
mov rdi, rbx
call _ZN5minja5ValueC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE_cold_1; minja::Value::Value(std::string const&) [clone]
mov rdi, rbx
call _ZNSt23enable_shared_from_thisIN5minja5ValueEED2Ev; std::enable_shared_from_this<minja::Value>::~enable_shared_from_this()
mov rdi, r14
call __Unwind_Resume
| _QWORD * minja::Value::Value(long long a1, long long a2)
{
*(_OWORD *)(a1 + 48) = 0LL;
*(_OWORD *)(a1 + 32) = 0LL;
*(_OWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
return ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRKS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SI_EE5valueEiE4typeELi0EEEOT_(
(unsigned __int8 *)(a1 + 64),
a2);
}
| Value:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
ADD RDI,0x40
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x30],XMM0
MOVUPS xmmword ptr [RBX + 0x20],XMM0
MOVUPS xmmword ptr [RBX + 0x10],XMM0
MOVUPS xmmword ptr [RBX],XMM0
LAB_0018cfab:
CALL 0x001817ac
LAB_0018cfb0:
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* minja::Value::Value(std::__cxx11::string const&) */
void __thiscall minja::Value::Value(Value *this,string *param_1)
{
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
/* try { // try from 0018cfab to 0018cfaf has its CatchHandler @ 0018cfb8 */
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRKS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SI_EE5valueEiE4typeELi0EEEOT_
(this + 0x40);
return;
}
| |
53,947 | backtick_string | eloqsql/strings/my_vsnprintf.c | static char *backtick_string(CHARSET_INFO *cs, char *to, const char *end,
char *par, size_t par_len, char quote_char,
my_bool cut)
{
char *last[3]= {0,0,0};
uint char_len;
char *start= to;
char *par_end= par + par_len;
size_t buff_length= (size_t) (end - to);
uint index= 0;
if (buff_length <= par_len)
goto err;
*start++= quote_char;
for ( ; par < par_end; par+= char_len)
{
uchar c= *(uchar *) par;
if (cut)
{
last[index]= start;
index= (index + 1) % 3;
}
char_len= my_ci_charlen_fix(cs, (const uchar *) par, (const uchar *) par_end);
if (char_len == 1 && c == (uchar) quote_char )
{
if (start + 1 >= end)
goto err;
*start++= quote_char;
}
if (start + char_len >= end)
goto err;
start= strnmov(start, par, char_len);
}
if (start + 1 >= end)
goto err;
if (cut)
{
uint dots= 0;
start= NULL;
for (; dots < 3; dots++)
{
if (index == 0)
index= 2;
else
index--;
if (!last[index])
break;
start= last[index];
}
if (start == NULL)
goto err; // there was no characters at all
for (; dots; dots--)
*start++= '.';
}
*start++= quote_char;
return start;
err:
*to='\0';
return to;
} | O0 | c | backtick_string:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %r9b, %al
movb 0x10(%rbp), %r9b
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movb %al, -0x31(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x261c0
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x70(%rbp)
movl $0x0, -0x74(%rbp)
movq -0x70(%rbp), %rax
cmpq -0x30(%rbp), %rax
ja 0xada22
jmp 0xadbba
movb -0x31(%rbp), %cl
movq -0x60(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x60(%rbp)
movb %cl, (%rax)
movq -0x28(%rbp), %rax
cmpq -0x68(%rbp), %rax
jae 0xadafe
movq -0x28(%rbp), %rax
movb (%rax), %al
movb %al, -0x75(%rbp)
cmpb $0x0, 0x10(%rbp)
je 0xada71
movq -0x60(%rbp), %rcx
movl -0x74(%rbp), %eax
movq %rcx, -0x50(%rbp,%rax,8)
movl -0x74(%rbp), %eax
addl $0x1, %eax
movl $0x3, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, -0x74(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x68(%rbp), %rdx
callq 0xadc30
movl %eax, -0x54(%rbp)
cmpl $0x1, -0x54(%rbp)
jne 0xadabe
movzbl -0x75(%rbp), %eax
movzbl -0x31(%rbp), %ecx
cmpl %ecx, %eax
jne 0xadabe
movq -0x60(%rbp), %rax
addq $0x1, %rax
cmpq -0x20(%rbp), %rax
jb 0xadaaa
jmp 0xadbba
movb -0x31(%rbp), %cl
movq -0x60(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x60(%rbp)
movb %cl, (%rax)
movq -0x60(%rbp), %rax
movl -0x54(%rbp), %ecx
addq %rcx, %rax
cmpq -0x20(%rbp), %rax
jb 0xadad3
jmp 0xadbba
movq -0x60(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x54(%rbp), %eax
movl %eax, %edx
callq 0xae130
movq %rax, -0x60(%rbp)
movl -0x54(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0xada36
movq -0x60(%rbp), %rax
addq $0x1, %rax
cmpq -0x20(%rbp), %rax
jb 0xadb11
jmp 0xadbba
cmpb $0x0, 0x10(%rbp)
je 0xadb9c
movl $0x0, -0x7c(%rbp)
movq $0x0, -0x60(%rbp)
cmpl $0x3, -0x7c(%rbp)
jae 0xadb6c
cmpl $0x0, -0x74(%rbp)
jne 0xadb3f
movl $0x2, -0x74(%rbp)
jmp 0xadb48
movl -0x74(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x74(%rbp)
movl -0x74(%rbp), %eax
cmpq $0x0, -0x50(%rbp,%rax,8)
jne 0xadb55
jmp 0xadb6c
movl -0x74(%rbp), %eax
movq -0x50(%rbp,%rax,8), %rax
movq %rax, -0x60(%rbp)
movl -0x7c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x7c(%rbp)
jmp 0xadb2a
cmpq $0x0, -0x60(%rbp)
jne 0xadb75
jmp 0xadbba
jmp 0xadb77
cmpl $0x0, -0x7c(%rbp)
je 0xadb9a
movq -0x60(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x60(%rbp)
movb $0x2e, (%rax)
movl -0x7c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x7c(%rbp)
jmp 0xadb77
jmp 0xadb9c
movb -0x31(%rbp), %cl
movq -0x60(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x60(%rbp)
movb %cl, (%rax)
movq -0x60(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xadbc9
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| backtick_string:
push rbp
mov rbp, rsp
sub rsp, 80h
mov al, r9b
mov r9b, [rbp+arg_0]
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov [rbp+var_31], al
lea rdi, [rbp+var_50]
xor esi, esi
mov edx, 18h
call _memset
mov rax, [rbp+var_18]
mov [rbp+var_60], rax
mov rax, [rbp+var_28]
add rax, [rbp+var_30]
mov [rbp+var_68], rax
mov rax, [rbp+var_20]
mov rcx, [rbp+var_18]
sub rax, rcx
mov [rbp+var_70], rax
mov [rbp+var_74], 0
mov rax, [rbp+var_70]
cmp rax, [rbp+var_30]
ja short loc_ADA22
jmp loc_ADBBA
loc_ADA22:
mov cl, [rbp+var_31]
mov rax, [rbp+var_60]
mov rdx, rax
add rdx, 1
mov [rbp+var_60], rdx
mov [rax], cl
loc_ADA36:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_68]
jnb loc_ADAFE
mov rax, [rbp+var_28]
mov al, [rax]
mov [rbp+var_75], al
cmp [rbp+arg_0], 0
jz short loc_ADA71
mov rcx, [rbp+var_60]
mov eax, [rbp+var_74]
mov [rbp+rax*8+var_50], rcx
mov eax, [rbp+var_74]
add eax, 1
mov ecx, 3
xor edx, edx
div ecx
mov [rbp+var_74], edx
loc_ADA71:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_68]
call my_ci_charlen_fix
mov [rbp+var_54], eax
cmp [rbp+var_54], 1
jnz short loc_ADABE
movzx eax, [rbp+var_75]
movzx ecx, [rbp+var_31]
cmp eax, ecx
jnz short loc_ADABE
mov rax, [rbp+var_60]
add rax, 1
cmp rax, [rbp+var_20]
jb short loc_ADAAA
jmp loc_ADBBA
loc_ADAAA:
mov cl, [rbp+var_31]
mov rax, [rbp+var_60]
mov rdx, rax
add rdx, 1
mov [rbp+var_60], rdx
mov [rax], cl
loc_ADABE:
mov rax, [rbp+var_60]
mov ecx, [rbp+var_54]
add rax, rcx
cmp rax, [rbp+var_20]
jb short loc_ADAD3
jmp loc_ADBBA
loc_ADAD3:
mov rdi, [rbp+var_60]
mov rsi, [rbp+var_28]
mov eax, [rbp+var_54]
mov edx, eax
call strnmov
mov [rbp+var_60], rax
mov ecx, [rbp+var_54]
mov rax, [rbp+var_28]
mov ecx, ecx
add rax, rcx
mov [rbp+var_28], rax
jmp loc_ADA36
loc_ADAFE:
mov rax, [rbp+var_60]
add rax, 1
cmp rax, [rbp+var_20]
jb short loc_ADB11
jmp loc_ADBBA
loc_ADB11:
cmp [rbp+arg_0], 0
jz loc_ADB9C
mov [rbp+var_7C], 0
mov [rbp+var_60], 0
loc_ADB2A:
cmp [rbp+var_7C], 3
jnb short loc_ADB6C
cmp [rbp+var_74], 0
jnz short loc_ADB3F
mov [rbp+var_74], 2
jmp short loc_ADB48
loc_ADB3F:
mov eax, [rbp+var_74]
add eax, 0FFFFFFFFh
mov [rbp+var_74], eax
loc_ADB48:
mov eax, [rbp+var_74]
cmp [rbp+rax*8+var_50], 0
jnz short loc_ADB55
jmp short loc_ADB6C
loc_ADB55:
mov eax, [rbp+var_74]
mov rax, [rbp+rax*8+var_50]
mov [rbp+var_60], rax
mov eax, [rbp+var_7C]
add eax, 1
mov [rbp+var_7C], eax
jmp short loc_ADB2A
loc_ADB6C:
cmp [rbp+var_60], 0
jnz short loc_ADB75
jmp short loc_ADBBA
loc_ADB75:
jmp short $+2
loc_ADB77:
cmp [rbp+var_7C], 0
jz short loc_ADB9A
mov rax, [rbp+var_60]
mov rcx, rax
add rcx, 1
mov [rbp+var_60], rcx
mov byte ptr [rax], 2Eh ; '.'
mov eax, [rbp+var_7C]
add eax, 0FFFFFFFFh
mov [rbp+var_7C], eax
jmp short loc_ADB77
loc_ADB9A:
jmp short $+2
loc_ADB9C:
mov cl, [rbp+var_31]
mov rax, [rbp+var_60]
mov rdx, rax
add rdx, 1
mov [rbp+var_60], rdx
mov [rax], cl
mov rax, [rbp+var_60]
mov [rbp+var_8], rax
jmp short loc_ADBC9
loc_ADBBA:
mov rax, [rbp+var_18]
mov byte ptr [rax], 0
mov rax, [rbp+var_18]
mov [rbp+var_8], rax
loc_ADBC9:
mov rax, [rbp+var_8]
add rsp, 80h
pop rbp
retn
| _BYTE * backtick_string(
long long a1,
_BYTE *a2,
unsigned long long a3,
char *a4,
unsigned long long a5,
char a6,
char a7)
{
_BYTE *v7; // rax
_BYTE *v8; // rax
unsigned int v10; // [rsp+4h] [rbp-7Ch]
char v11; // [rsp+Bh] [rbp-75h]
unsigned int v12; // [rsp+Ch] [rbp-74h]
char *v13; // [rsp+18h] [rbp-68h]
_BYTE *v14; // [rsp+20h] [rbp-60h]
unsigned int v15; // [rsp+2Ch] [rbp-54h]
_QWORD v16[3]; // [rsp+30h] [rbp-50h] BYREF
char v17; // [rsp+4Fh] [rbp-31h]
unsigned long long v18; // [rsp+50h] [rbp-30h]
char *v19; // [rsp+58h] [rbp-28h]
unsigned long long v20; // [rsp+60h] [rbp-20h]
_BYTE *v21; // [rsp+68h] [rbp-18h]
long long v22; // [rsp+70h] [rbp-10h]
v22 = a1;
v21 = a2;
v20 = a3;
v19 = a4;
v18 = a5;
v17 = a6;
memset(v16, 0LL, sizeof(v16));
v13 = &v19[v18];
v12 = 0;
if ( v20 - (unsigned long long)v21 <= v18 )
goto LABEL_25;
v14 = v21 + 1;
*v21 = v17;
while ( v19 < v13 )
{
v11 = *v19;
if ( a7 )
{
v16[v12] = v14;
v12 = (v12 + 1) % 3;
}
v15 = my_ci_charlen_fix(v22, v19, v13);
if ( v15 == 1 && v11 == v17 )
{
if ( (unsigned long long)(v14 + 1) >= v20 )
goto LABEL_25;
v7 = v14++;
*v7 = v17;
}
if ( (unsigned long long)&v14[v15] >= v20 )
goto LABEL_25;
v14 = (_BYTE *)strnmov(v14, v19, v15);
v19 += v15;
}
if ( (unsigned long long)(v14 + 1) >= v20 )
goto LABEL_25;
if ( a7 )
{
v10 = 0;
v14 = 0LL;
while ( v10 < 3 )
{
if ( v12 )
--v12;
else
v12 = 2;
if ( !v16[v12] )
break;
v14 = (_BYTE *)v16[v12];
++v10;
}
if ( v14 )
{
while ( v10 )
{
v8 = v14++;
*v8 = 46;
--v10;
}
goto LABEL_24;
}
LABEL_25:
*v21 = 0;
return v21;
}
LABEL_24:
*v14 = v17;
return v14 + 1;
}
| backtick_string:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV AL,R9B
MOV R9B,byte ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV byte ptr [RBP + -0x31],AL
LEA RDI,[RBP + -0x50]
XOR ESI,ESI
MOV EDX,0x18
CALL 0x001261c0
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x18]
SUB RAX,RCX
MOV qword ptr [RBP + -0x70],RAX
MOV dword ptr [RBP + -0x74],0x0
MOV RAX,qword ptr [RBP + -0x70]
CMP RAX,qword ptr [RBP + -0x30]
JA 0x001ada22
JMP 0x001adbba
LAB_001ada22:
MOV CL,byte ptr [RBP + -0x31]
MOV RAX,qword ptr [RBP + -0x60]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x60],RDX
MOV byte ptr [RAX],CL
LAB_001ada36:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x68]
JNC 0x001adafe
MOV RAX,qword ptr [RBP + -0x28]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x75],AL
CMP byte ptr [RBP + 0x10],0x0
JZ 0x001ada71
MOV RCX,qword ptr [RBP + -0x60]
MOV EAX,dword ptr [RBP + -0x74]
MOV qword ptr [RBP + RAX*0x8 + -0x50],RCX
MOV EAX,dword ptr [RBP + -0x74]
ADD EAX,0x1
MOV ECX,0x3
XOR EDX,EDX
DIV ECX
MOV dword ptr [RBP + -0x74],EDX
LAB_001ada71:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x68]
CALL 0x001adc30
MOV dword ptr [RBP + -0x54],EAX
CMP dword ptr [RBP + -0x54],0x1
JNZ 0x001adabe
MOVZX EAX,byte ptr [RBP + -0x75]
MOVZX ECX,byte ptr [RBP + -0x31]
CMP EAX,ECX
JNZ 0x001adabe
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x1
CMP RAX,qword ptr [RBP + -0x20]
JC 0x001adaaa
JMP 0x001adbba
LAB_001adaaa:
MOV CL,byte ptr [RBP + -0x31]
MOV RAX,qword ptr [RBP + -0x60]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x60],RDX
MOV byte ptr [RAX],CL
LAB_001adabe:
MOV RAX,qword ptr [RBP + -0x60]
MOV ECX,dword ptr [RBP + -0x54]
ADD RAX,RCX
CMP RAX,qword ptr [RBP + -0x20]
JC 0x001adad3
JMP 0x001adbba
LAB_001adad3:
MOV RDI,qword ptr [RBP + -0x60]
MOV RSI,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RBP + -0x54]
MOV EDX,EAX
CALL 0x001ae130
MOV qword ptr [RBP + -0x60],RAX
MOV ECX,dword ptr [RBP + -0x54]
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
JMP 0x001ada36
LAB_001adafe:
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x1
CMP RAX,qword ptr [RBP + -0x20]
JC 0x001adb11
JMP 0x001adbba
LAB_001adb11:
CMP byte ptr [RBP + 0x10],0x0
JZ 0x001adb9c
MOV dword ptr [RBP + -0x7c],0x0
MOV qword ptr [RBP + -0x60],0x0
LAB_001adb2a:
CMP dword ptr [RBP + -0x7c],0x3
JNC 0x001adb6c
CMP dword ptr [RBP + -0x74],0x0
JNZ 0x001adb3f
MOV dword ptr [RBP + -0x74],0x2
JMP 0x001adb48
LAB_001adb3f:
MOV EAX,dword ptr [RBP + -0x74]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x74],EAX
LAB_001adb48:
MOV EAX,dword ptr [RBP + -0x74]
CMP qword ptr [RBP + RAX*0x8 + -0x50],0x0
JNZ 0x001adb55
JMP 0x001adb6c
LAB_001adb55:
MOV EAX,dword ptr [RBP + -0x74]
MOV RAX,qword ptr [RBP + RAX*0x8 + -0x50]
MOV qword ptr [RBP + -0x60],RAX
MOV EAX,dword ptr [RBP + -0x7c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x7c],EAX
JMP 0x001adb2a
LAB_001adb6c:
CMP qword ptr [RBP + -0x60],0x0
JNZ 0x001adb75
JMP 0x001adbba
LAB_001adb75:
JMP 0x001adb77
LAB_001adb77:
CMP dword ptr [RBP + -0x7c],0x0
JZ 0x001adb9a
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x60],RCX
MOV byte ptr [RAX],0x2e
MOV EAX,dword ptr [RBP + -0x7c]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x7c],EAX
JMP 0x001adb77
LAB_001adb9a:
JMP 0x001adb9c
LAB_001adb9c:
MOV CL,byte ptr [RBP + -0x31]
MOV RAX,qword ptr [RBP + -0x60]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x60],RDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001adbc9
LAB_001adbba:
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x8],RAX
LAB_001adbc9:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x80
POP RBP
RET
|
char * backtick_string(int8 param_1,char *param_2,char *param_3,char *param_4,ulong param_5,
char param_6,char param_7)
{
char cVar1;
uint uVar2;
char *pcVar3;
uint local_84;
uint local_7c;
char *local_68;
long local_58 [3];
char local_39;
ulong local_38;
char *local_30;
char *local_28;
char *local_20;
int8 local_18;
local_39 = param_6;
local_38 = param_5;
local_30 = param_4;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
memset(local_58,0,0x18);
pcVar3 = local_30 + local_38;
local_7c = 0;
if (local_38 < (ulong)((long)local_28 - (long)local_20)) {
local_68 = local_20 + 1;
*local_20 = local_39;
for (; local_30 < pcVar3; local_30 = local_30 + uVar2) {
cVar1 = *local_30;
if (param_7 != '\0') {
local_58[local_7c] = (long)local_68;
local_7c = (local_7c + 1) % 3;
}
uVar2 = my_ci_charlen_fix(local_18,local_30,pcVar3);
if ((uVar2 == 1) && (cVar1 == local_39)) {
if (local_28 <= local_68 + 1) goto LAB_001adbba;
*local_68 = local_39;
local_68 = local_68 + 1;
}
if (local_28 <= local_68 + uVar2) goto LAB_001adbba;
local_68 = (char *)strnmov(local_68,local_30,uVar2);
}
if (local_68 + 1 < local_28) {
if (param_7 != '\0') {
local_68 = (char *)0x0;
for (local_84 = 0; local_84 < 3; local_84 = local_84 + 1) {
if (local_7c == 0) {
local_7c = 2;
}
else {
local_7c = local_7c - 1;
}
if (local_58[local_7c] == 0) break;
local_68 = (char *)local_58[local_7c];
}
if (local_68 == (char *)0x0) goto LAB_001adbba;
for (; local_84 != 0; local_84 = local_84 - 1) {
*local_68 = '.';
local_68 = local_68 + 1;
}
}
*local_68 = local_39;
return local_68 + 1;
}
}
LAB_001adbba:
*local_20 = '\0';
return local_20;
}
| |
53,948 | WaitTime | csit-sgu[P]mit-game-2025-team-tyler/Libraries/raylib/src/rcore.c | void WaitTime(double seconds)
{
if (seconds < 0) return; // Security check
#if defined(SUPPORT_BUSY_WAIT_LOOP) || defined(SUPPORT_PARTIALBUSY_WAIT_LOOP)
double destinationTime = GetTime() + seconds;
#endif
#if defined(SUPPORT_BUSY_WAIT_LOOP)
while (GetTime() < destinationTime) { }
#else
#if defined(SUPPORT_PARTIALBUSY_WAIT_LOOP)
double sleepSeconds = seconds - seconds*0.05; // NOTE: We reserve a percentage of the time for busy waiting
#else
double sleepSeconds = seconds;
#endif
// System halt functions
#if defined(_WIN32)
Sleep((unsigned long)(sleepSeconds*1000.0));
#endif
#if defined(__linux__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__EMSCRIPTEN__)
struct timespec req = { 0 };
time_t sec = sleepSeconds;
long nsec = (sleepSeconds - sec)*1000000000L;
req.tv_sec = sec;
req.tv_nsec = nsec;
// NOTE: Use nanosleep() on Unix platforms... usleep() it's deprecated
while (nanosleep(&req, &req) == -1) continue;
#endif
#if defined(__APPLE__)
usleep(sleepSeconds*1000000.0);
#endif
#if defined(SUPPORT_PARTIALBUSY_WAIT_LOOP)
while (GetTime() < destinationTime) { }
#endif
#endif
} | O3 | c | WaitTime:
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x72e86
pushq %rbx
subq $0x20, %rsp
movsd %xmm0, 0x8(%rsp)
callq 0xbe9ca
movsd 0x6ba94(%rip), %xmm1 # 0xde8a8
movsd 0x8(%rsp), %xmm2
mulsd %xmm2, %xmm1
addsd %xmm2, %xmm1
cvttsd2si %xmm1, %rax
xorps %xmm2, %xmm2
cvtsi2sd %rax, %xmm2
subsd %xmm2, %xmm1
mulsd 0x60ef5(%rip), %xmm1 # 0xd3d30
cvttsd2si %xmm1, %rcx
movsd %xmm0, (%rsp)
leaq 0x10(%rsp), %rbx
movq %rax, (%rbx)
movq %rcx, 0x8(%rbx)
movq %rbx, %rdi
movq %rbx, %rsi
callq 0xa180
cmpl $-0x1, %eax
je 0x72e51
movsd (%rsp), %xmm0
addsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rsp)
callq 0xbe9ca
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x72e71
addq $0x20, %rsp
popq %rbx
retq
| WaitTime:
xorpd xmm1, xmm1
ucomisd xmm1, xmm0
ja locret_72E86
push rbx
sub rsp, 20h
movsd [rsp+28h+var_20], xmm0
call glfwGetTime
movsd xmm1, cs:qword_DE8A8
movsd xmm2, [rsp+28h+var_20]
mulsd xmm1, xmm2
addsd xmm1, xmm2
cvttsd2si rax, xmm1
xorps xmm2, xmm2
cvtsi2sd xmm2, rax
subsd xmm1, xmm2
mulsd xmm1, cs:qword_D3D30
cvttsd2si rcx, xmm1
movsd [rsp+28h+var_28], xmm0
lea rbx, [rsp+28h+var_18]
mov [rbx], rax
mov [rbx+8], rcx
loc_72E51:
mov rdi, rbx
mov rsi, rbx
call _nanosleep
cmp eax, 0FFFFFFFFh
jz short loc_72E51
movsd xmm0, [rsp+28h+var_28]
addsd xmm0, [rsp+28h+var_20]
movsd [rsp+28h+var_28], xmm0
loc_72E71:
call glfwGetTime
movsd xmm1, [rsp+28h+var_28]
ucomisd xmm1, xmm0
ja short loc_72E71
add rsp, 20h
pop rbx
locret_72E86:
retn
| void WaitTime(double a1, double a2, double a3, double a4, double a5)
{
double Time; // xmm0_8
double v6; // xmm1_8
long long v7; // rax
double v8; // xmm2_8
double v9; // xmm1_8
double v10; // xmm4_8
double v11; // xmm0_8
double v12; // [rsp+0h] [rbp-28h]
double v13; // [rsp+0h] [rbp-28h]
_QWORD v15[3]; // [rsp+10h] [rbp-18h] BYREF
if ( a1 >= 0.0 )
{
Time = glfwGetTime(a1, 0.0, a3, a4, a5);
v6 = -0.05 * a1 + a1;
v7 = (unsigned int)(int)v6;
v8 = (double)(int)v7;
v9 = (v6 - (double)(int)v7) * 1000000000.0;
v12 = Time;
v15[0] = v7;
v15[1] = (unsigned int)(int)v9;
while ( (unsigned int)nanosleep(v15, v15) == -1 )
;
v11 = Time + a1;
v13 = v12 + a1;
do
{
v11 = glfwGetTime(v11, v9, v8, a4, v10);
v9 = v13;
}
while ( v13 > v11 );
}
}
| WaitTime:
XORPD XMM1,XMM1
UCOMISD XMM1,XMM0
JA 0x00172e86
PUSH RBX
SUB RSP,0x20
MOVSD qword ptr [RSP + 0x8],XMM0
CALL 0x001be9ca
MOVSD XMM1,qword ptr [0x001de8a8]
MOVSD XMM2,qword ptr [RSP + 0x8]
MULSD XMM1,XMM2
ADDSD XMM1,XMM2
CVTTSD2SI RAX,XMM1
XORPS XMM2,XMM2
CVTSI2SD XMM2,RAX
SUBSD XMM1,XMM2
MULSD XMM1,qword ptr [0x001d3d30]
CVTTSD2SI RCX,XMM1
MOVSD qword ptr [RSP],XMM0
LEA RBX,[RSP + 0x10]
MOV qword ptr [RBX],RAX
MOV qword ptr [RBX + 0x8],RCX
LAB_00172e51:
MOV RDI,RBX
MOV RSI,RBX
CALL 0x0010a180
CMP EAX,-0x1
JZ 0x00172e51
MOVSD XMM0,qword ptr [RSP]
ADDSD XMM0,qword ptr [RSP + 0x8]
MOVSD qword ptr [RSP],XMM0
LAB_00172e71:
CALL 0x001be9ca
MOVSD XMM1,qword ptr [RSP]
UCOMISD XMM1,XMM0
JA 0x00172e71
ADD RSP,0x20
POP RBX
LAB_00172e86:
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void WaitTime(double param_1)
{
int iVar1;
double dVar2;
double dVar3;
timespec local_18;
if (0.0 <= param_1) {
dVar2 = (double)glfwGetTime();
dVar3 = DAT_001de8a8 * param_1 + param_1;
local_18.tv_sec = (__time_t)dVar3;
local_18.tv_nsec = (long)((dVar3 - (double)local_18.tv_sec) * _DAT_001d3d30);
do {
iVar1 = nanosleep(&local_18,&local_18);
} while (iVar1 == -1);
do {
dVar3 = (double)glfwGetTime();
} while (dVar3 < dVar2 + param_1);
}
return;
}
| |
53,949 | my_scan_8bit | eloqsql/strings/ctype-simple.c | size_t my_scan_8bit(CHARSET_INFO *cs, const char *str, const char *end, int sq)
{
const char *str0= str;
switch (sq)
{
case MY_SEQ_INTTAIL:
if (*str == '.')
{
for(str++ ; str != end && *str == '0' ; str++);
return (size_t) (str - str0);
}
return 0;
case MY_SEQ_SPACES:
for ( ; str < end ; str++)
{
if (!my_isspace(cs,*str))
break;
}
return (size_t) (str - str0);
case MY_SEQ_NONSPACES:
for ( ; str < end ; str++)
{
if (my_isspace(cs, *str))
break;
}
return (size_t) (str - str0);
default:
return 0;
}
} | O3 | c | my_scan_8bit:
pushq %rbp
movq %rsp, %rbp
movq %rdx, %rax
cmpl $0x1, %ecx
je 0x5aa36
cmpl $0x2, %ecx
je 0x5aa0a
cmpl $0x3, %ecx
jne 0x5aa5b
movq %rsi, %rcx
cmpq %rax, %rsi
jae 0x5aa2e
movq 0x40(%rdi), %rdx
movq %rsi, %rcx
movzbl (%rcx), %edi
testb $0x8, 0x1(%rdx,%rdi)
jne 0x5aa2e
incq %rcx
cmpq %rax, %rcx
jne 0x5a9f6
jmp 0x5aa2b
movq %rsi, %rcx
cmpq %rax, %rsi
jae 0x5aa2e
movq 0x40(%rdi), %rdx
movq %rsi, %rcx
movzbl (%rcx), %edi
testb $0x8, 0x1(%rdx,%rdi)
je 0x5aa2e
incq %rcx
cmpq %rax, %rcx
jne 0x5aa19
movq %rax, %rcx
subq %rsi, %rcx
movq %rcx, %rax
jmp 0x5aa5d
cmpb $0x2e, (%rsi)
jne 0x5aa5b
leaq 0x1(%rsi), %rcx
cmpq %rax, %rcx
je 0x5aa56
leaq 0x1(%rcx), %rdx
cmpb $0x30, (%rcx)
movq %rdx, %rcx
je 0x5aa3f
decq %rdx
movq %rdx, %rax
subq %rsi, %rax
jmp 0x5aa5d
xorl %eax, %eax
popq %rbp
retq
| my_scan_8bit:
push rbp
mov rbp, rsp
mov rax, rdx
cmp ecx, 1
jz short loc_5AA36
cmp ecx, 2
jz short loc_5AA0A
cmp ecx, 3
jnz short loc_5AA5B
mov rcx, rsi
cmp rsi, rax
jnb short loc_5AA2E
mov rdx, [rdi+40h]
mov rcx, rsi
loc_5A9F6:
movzx edi, byte ptr [rcx]
test byte ptr [rdx+rdi+1], 8
jnz short loc_5AA2E
inc rcx
cmp rcx, rax
jnz short loc_5A9F6
jmp short loc_5AA2B
loc_5AA0A:
mov rcx, rsi
cmp rsi, rax
jnb short loc_5AA2E
mov rdx, [rdi+40h]
mov rcx, rsi
loc_5AA19:
movzx edi, byte ptr [rcx]
test byte ptr [rdx+rdi+1], 8
jz short loc_5AA2E
inc rcx
cmp rcx, rax
jnz short loc_5AA19
loc_5AA2B:
mov rcx, rax
loc_5AA2E:
sub rcx, rsi
mov rax, rcx
jmp short loc_5AA5D
loc_5AA36:
cmp byte ptr [rsi], 2Eh ; '.'
jnz short loc_5AA5B
lea rcx, [rsi+1]
loc_5AA3F:
cmp rcx, rax
jz short loc_5AA56
lea rdx, [rcx+1]
cmp byte ptr [rcx], 30h ; '0'
mov rcx, rdx
jz short loc_5AA3F
dec rdx
mov rax, rdx
loc_5AA56:
sub rax, rsi
jmp short loc_5AA5D
loc_5AA5B:
xor eax, eax
loc_5AA5D:
pop rbp
retn
| long long my_scan_8bit(long long a1, unsigned __int8 *a2, unsigned __int8 *a3, int a4)
{
unsigned __int8 *v4; // rax
unsigned __int8 *v5; // rcx
unsigned __int8 *v7; // rcx
_BYTE *v8; // rdx
v4 = a3;
if ( a4 != 1 )
{
if ( a4 == 2 )
{
v5 = a2;
if ( a2 < a3 )
{
v5 = a2;
while ( (*(_BYTE *)(*(_QWORD *)(a1 + 64) + *v5 + 1LL) & 8) != 0 )
{
if ( ++v5 == a3 )
{
LABEL_13:
v5 = a3;
return v5 - a2;
}
}
}
return v5 - a2;
}
if ( a4 == 3 )
{
v5 = a2;
if ( a2 < a3 )
{
v5 = a2;
while ( (*(_BYTE *)(*(_QWORD *)(a1 + 64) + *v5 + 1LL) & 8) == 0 )
{
if ( ++v5 == a3 )
goto LABEL_13;
}
}
return v5 - a2;
}
return 0LL;
}
if ( *a2 != 46 )
return 0LL;
v7 = a2 + 1;
while ( v7 != v4 )
{
v8 = v7 + 1;
if ( *v7++ != 48 )
{
v4 = v8 - 1;
return v4 - a2;
}
}
return v4 - a2;
}
| my_scan_8bit:
PUSH RBP
MOV RBP,RSP
MOV RAX,RDX
CMP ECX,0x1
JZ 0x0015aa36
CMP ECX,0x2
JZ 0x0015aa0a
CMP ECX,0x3
JNZ 0x0015aa5b
MOV RCX,RSI
CMP RSI,RAX
JNC 0x0015aa2e
MOV RDX,qword ptr [RDI + 0x40]
MOV RCX,RSI
LAB_0015a9f6:
MOVZX EDI,byte ptr [RCX]
TEST byte ptr [RDX + RDI*0x1 + 0x1],0x8
JNZ 0x0015aa2e
INC RCX
CMP RCX,RAX
JNZ 0x0015a9f6
JMP 0x0015aa2b
LAB_0015aa0a:
MOV RCX,RSI
CMP RSI,RAX
JNC 0x0015aa2e
MOV RDX,qword ptr [RDI + 0x40]
MOV RCX,RSI
LAB_0015aa19:
MOVZX EDI,byte ptr [RCX]
TEST byte ptr [RDX + RDI*0x1 + 0x1],0x8
JZ 0x0015aa2e
INC RCX
CMP RCX,RAX
JNZ 0x0015aa19
LAB_0015aa2b:
MOV RCX,RAX
LAB_0015aa2e:
SUB RCX,RSI
MOV RAX,RCX
JMP 0x0015aa5d
LAB_0015aa36:
CMP byte ptr [RSI],0x2e
JNZ 0x0015aa5b
LEA RCX,[RSI + 0x1]
LAB_0015aa3f:
CMP RCX,RAX
JZ 0x0015aa56
LEA RDX,[RCX + 0x1]
CMP byte ptr [RCX],0x30
MOV RCX,RDX
JZ 0x0015aa3f
DEC RDX
MOV RAX,RDX
LAB_0015aa56:
SUB RAX,RSI
JMP 0x0015aa5d
LAB_0015aa5b:
XOR EAX,EAX
LAB_0015aa5d:
POP RBP
RET
|
long my_scan_8bit(long param_1,byte *param_2,byte *param_3,int param_4)
{
byte bVar1;
byte *pbVar2;
long lVar3;
byte *pbVar4;
if (param_4 == 1) {
if (*param_2 == 0x2e) {
pbVar4 = param_2 + 1;
do {
pbVar2 = param_3;
if (pbVar4 == param_3) break;
bVar1 = *pbVar4;
pbVar2 = pbVar4;
pbVar4 = pbVar4 + 1;
} while (bVar1 == 0x30);
return (long)pbVar2 - (long)param_2;
}
LAB_0015aa5b:
lVar3 = 0;
}
else {
pbVar4 = param_2;
if (param_4 == 2) {
if (param_2 < param_3) {
pbVar2 = param_2;
do {
pbVar4 = pbVar2;
if ((*(byte *)(*(long *)(param_1 + 0x40) + 1 + (ulong)*pbVar2) & 8) == 0) break;
pbVar2 = pbVar2 + 1;
pbVar4 = param_3;
} while (pbVar2 != param_3);
}
}
else {
if (param_4 != 3) goto LAB_0015aa5b;
if (param_2 < param_3) {
pbVar2 = param_2;
do {
pbVar4 = pbVar2;
if ((*(byte *)(*(long *)(param_1 + 0x40) + 1 + (ulong)*pbVar2) & 8) != 0) break;
pbVar2 = pbVar2 + 1;
pbVar4 = param_3;
} while (pbVar2 != param_3);
}
}
lVar3 = (long)pbVar4 - (long)param_2;
}
return lVar3;
}
| |
53,950 | ma_check_env_str | eloqsql/libmariadb/include/ma_string.h | static inline my_bool ma_check_env_str(const char *env)
{
unsigned int i;
if (!env)
return 1;
for (i=0; i < MAX_ENV_SIZE; i++)
{
if (env[i] == 0)
break;
}
if (i >= MAX_ENV_SIZE)
return 1;
return 0;
} | O0 | c | ma_check_env_str:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x361f5
movb $0x1, -0x1(%rbp)
jmp 0x36237
movl $0x0, -0x14(%rbp)
cmpl $0x400, -0x14(%rbp) # imm = 0x400
jae 0x36224
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x36217
jmp 0x36224
jmp 0x36219
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x361fc
cmpl $0x400, -0x14(%rbp) # imm = 0x400
jb 0x36233
movb $0x1, -0x1(%rbp)
jmp 0x36237
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopl (%rax)
| ma_check_env_str:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
cmp [rbp+var_10], 0
jnz short loc_361F5
mov [rbp+var_1], 1
jmp short loc_36237
loc_361F5:
mov [rbp+var_14], 0
loc_361FC:
cmp [rbp+var_14], 400h
jnb short loc_36224
mov rax, [rbp+var_10]
mov ecx, [rbp+var_14]
movsx eax, byte ptr [rax+rcx]
cmp eax, 0
jnz short loc_36217
jmp short loc_36224
loc_36217:
jmp short $+2
loc_36219:
mov eax, [rbp+var_14]
add eax, 1
mov [rbp+var_14], eax
jmp short loc_361FC
loc_36224:
cmp [rbp+var_14], 400h
jb short loc_36233
mov [rbp+var_1], 1
jmp short loc_36237
loc_36233:
mov [rbp+var_1], 0
loc_36237:
mov al, [rbp+var_1]
pop rbp
retn
| bool ma_check_env_str(long long a1)
{
unsigned int i; // [rsp+0h] [rbp-14h]
if ( !a1 )
return 1;
for ( i = 0; i < 0x400 && *(_BYTE *)(a1 + i); ++i )
;
return i >= 0x400;
}
| ma_check_env_str:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
CMP qword ptr [RBP + -0x10],0x0
JNZ 0x001361f5
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00136237
LAB_001361f5:
MOV dword ptr [RBP + -0x14],0x0
LAB_001361fc:
CMP dword ptr [RBP + -0x14],0x400
JNC 0x00136224
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x14]
MOVSX EAX,byte ptr [RAX + RCX*0x1]
CMP EAX,0x0
JNZ 0x00136217
JMP 0x00136224
LAB_00136217:
JMP 0x00136219
LAB_00136219:
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
JMP 0x001361fc
LAB_00136224:
CMP dword ptr [RBP + -0x14],0x400
JC 0x00136233
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00136237
LAB_00136233:
MOV byte ptr [RBP + -0x1],0x0
LAB_00136237:
MOV AL,byte ptr [RBP + -0x1]
POP RBP
RET
|
int1 ma_check_env_str(long param_1)
{
uint local_1c;
int1 local_9;
if (param_1 == 0) {
local_9 = 1;
}
else {
for (local_1c = 0; (local_1c < 0x400 && (*(char *)(param_1 + (ulong)local_1c) != '\0'));
local_1c = local_1c + 1) {
}
if (local_1c < 0x400) {
local_9 = 0;
}
else {
local_9 = 1;
}
}
return local_9;
}
| |
53,951 | fmt::v10::detail::format_decimal_result<char*> fmt::v10::detail::format_decimal<char, unsigned long>(char*, unsigned long, int) | aimrt_mujoco_sim/_deps/fmt-src/include/fmt/format.h | FMT_CONSTEXPR20 auto format_decimal(Char* out, UInt value, int size)
-> format_decimal_result<Char*> {
FMT_ASSERT(size >= count_digits(value), "invalid digit count");
out += size;
Char* end = out;
while (value >= 100) {
// Integer division is slow so do it for a group of two digits instead
// of for every digit. The idea comes from the talk by Alexandrescu
// "Three Optimization Tips for C++". See speed-test for a comparison.
out -= 2;
copy2(out, digits2(static_cast<size_t>(value % 100)));
value /= 100;
}
if (value < 10) {
*--out = static_cast<Char>('0' + value);
return {out, end};
}
out -= 2;
copy2(out, digits2(static_cast<size_t>(value)));
return {out, end};
} | O0 | c | fmt::v10::detail::format_decimal_result<char*> fmt::v10::detail::format_decimal<char, unsigned long>(char*, unsigned long, int):
subq $0x68, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1ac7a0
movl %eax, %ecx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
setge %al
andb $0x1, %al
movb %al, 0x23(%rsp)
leaq 0x23(%rsp), %rdi
leaq 0x42fd40(%rip), %rsi # 0x5dc531
callq 0x1abfb0
movl 0x24(%rsp), %ecx
movq 0x30(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x64, 0x28(%rsp)
jb 0x1ac880
movq 0x30(%rsp), %rax
addq $-0x2, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movl $0x64, %ecx
xorl %edx, %edx
divq %rcx
movq %rdx, %rdi
callq 0x1abfc0
movq 0x8(%rsp), %rcx
movq %rcx, 0x60(%rsp)
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq 0x58(%rsp), %rcx
movw (%rcx), %cx
movw %cx, (%rax)
movq 0x28(%rsp), %rax
movl $0x64, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, 0x28(%rsp)
jmp 0x1ac814
cmpq $0xa, 0x28(%rsp)
jae 0x1ac8bd
movq 0x28(%rsp), %rax
addq $0x30, %rax
movb %al, %cl
movq 0x30(%rsp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, 0x30(%rsp)
movb %cl, -0x1(%rax)
movq 0x30(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x1ac910
movq 0x30(%rsp), %rax
addq $-0x2, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
callq 0x1abfc0
movq (%rsp), %rcx
movq %rcx, 0x50(%rsp)
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq 0x48(%rsp), %rcx
movw (%rcx), %cx
movw %cx, (%rax)
movq 0x30(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rdx
addq $0x68, %rsp
retq
nop
| _ZN3fmt3v106detail14format_decimalIcmEENS1_21format_decimal_resultIPT_EES5_T0_i:
sub rsp, 68h
mov [rsp+68h+var_38], rdi
mov [rsp+68h+var_40], rsi
mov [rsp+68h+var_44], edx
mov eax, [rsp+68h+var_44]
mov [rsp+68h+var_54], eax
mov rdi, [rsp+68h+var_40]; this
call _ZN3fmt3v106detail12count_digitsEm; fmt::v10::detail::count_digits(ulong)
mov ecx, eax
mov eax, [rsp+68h+var_54]
cmp eax, ecx
setnl al
and al, 1
mov [rsp+68h+var_45], al
lea rdi, [rsp+68h+var_45]
lea rsi, aInvalidDigitCo; "invalid digit count"
call _ZN3fmt3v106detail13ignore_unusedIJbA20_cEEEvDpRKT_; fmt::v10::detail::ignore_unused<bool,char [20]>(bool,char [20] const&)
mov ecx, [rsp+68h+var_44]
mov rax, [rsp+68h+var_38]
movsxd rcx, ecx
add rax, rcx
mov [rsp+68h+var_38], rax
mov rax, [rsp+68h+var_38]
mov [rsp+68h+var_50], rax
loc_1AC814:
cmp [rsp+68h+var_40], 64h ; 'd'
jb short loc_1AC880
mov rax, [rsp+68h+var_38]
add rax, 0FFFFFFFFFFFFFFFEh
mov [rsp+68h+var_38], rax
mov rax, [rsp+68h+var_38]
mov [rsp+68h+var_60], rax
mov rax, [rsp+68h+var_40]
mov ecx, 64h ; 'd'
xor edx, edx
div rcx
mov rdi, rdx; this
call _ZN3fmt3v106detail7digits2Em; fmt::v10::detail::digits2(ulong)
mov rcx, [rsp+68h+var_60]
mov [rsp+68h+var_8], rcx
mov [rsp+68h+var_10], rax
mov rax, [rsp+68h+var_8]
mov rcx, [rsp+68h+var_10]
mov cx, [rcx]
mov [rax], cx
mov rax, [rsp+68h+var_40]
mov ecx, 64h ; 'd'
xor edx, edx
div rcx
mov [rsp+68h+var_40], rax
jmp short loc_1AC814
loc_1AC880:
cmp [rsp+68h+var_40], 0Ah
jnb short loc_1AC8BD
mov rax, [rsp+68h+var_40]
add rax, 30h ; '0'
mov cl, al
mov rax, [rsp+68h+var_38]
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rsp+68h+var_38], rdx
mov [rax-1], cl
mov rax, [rsp+68h+var_38]
mov [rsp+68h+var_30], rax
mov rax, [rsp+68h+var_50]
mov [rsp+68h+var_28], rax
jmp short loc_1AC910
loc_1AC8BD:
mov rax, [rsp+68h+var_38]
add rax, 0FFFFFFFFFFFFFFFEh
mov [rsp+68h+var_38], rax
mov rax, [rsp+68h+var_38]
mov [rsp+68h+var_68], rax
mov rdi, [rsp+68h+var_40]; this
call _ZN3fmt3v106detail7digits2Em; fmt::v10::detail::digits2(ulong)
mov rcx, [rsp+68h+var_68]
mov [rsp+68h+var_18], rcx
mov [rsp+68h+var_20], rax
mov rax, [rsp+68h+var_18]
mov rcx, [rsp+68h+var_20]
mov cx, [rcx]
mov [rax], cx
mov rax, [rsp+68h+var_38]
mov [rsp+68h+var_30], rax
mov rax, [rsp+68h+var_50]
mov [rsp+68h+var_28], rax
loc_1AC910:
mov rax, [rsp+68h+var_30]
mov rdx, [rsp+68h+var_28]
add rsp, 68h
retn
| _WORD * fmt::v10::detail::format_decimal<char,unsigned long>(long long a1, fmt::v10::detail *a2, int a3)
{
unsigned long long v5; // [rsp+28h] [rbp-40h]
_WORD *v6; // [rsp+30h] [rbp-38h]
v5 = (unsigned long long)a2;
fmt::v10::detail::count_digits(a2, (unsigned long long)a2);
fmt::v10::detail::ignore_unused<bool,char [20]>();
v6 = (_WORD *)(a3 + a1);
while ( v5 >= 0x64 )
{
*--v6 = *(_WORD *)fmt::v10::detail::digits2((fmt::v10::detail *)(v5 % 0x64));
v5 /= 0x64uLL;
}
if ( v5 >= 0xA )
{
*(v6 - 1) = *(_WORD *)fmt::v10::detail::digits2((fmt::v10::detail *)v5);
return v6 - 1;
}
else
{
*((_BYTE *)v6 - 1) = v5 + 48;
return (_WORD *)((char *)v6 - 1);
}
}
| |||
53,952 | fmt::v10::detail::format_decimal_result<char*> fmt::v10::detail::format_decimal<char, unsigned long>(char*, unsigned long, int) | aimrt_mujoco_sim/_deps/fmt-src/include/fmt/format.h | FMT_CONSTEXPR20 auto format_decimal(Char* out, UInt value, int size)
-> format_decimal_result<Char*> {
FMT_ASSERT(size >= count_digits(value), "invalid digit count");
out += size;
Char* end = out;
while (value >= 100) {
// Integer division is slow so do it for a group of two digits instead
// of for every digit. The idea comes from the talk by Alexandrescu
// "Three Optimization Tips for C++". See speed-test for a comparison.
out -= 2;
copy2(out, digits2(static_cast<size_t>(value % 100)));
value /= 100;
}
if (value < 10) {
*--out = static_cast<Char>('0' + value);
return {out, end};
}
out -= 2;
copy2(out, digits2(static_cast<size_t>(value)));
return {out, end};
} | O3 | c | fmt::v10::detail::format_decimal_result<char*> fmt::v10::detail::format_decimal<char, unsigned long>(char*, unsigned long, int):
movslq %edx, %rdx
addq %rdi, %rdx
leaq 0x1654e6(%rip), %rcx # 0x1ef599
movq %rdx, %rax
cmpl $0x64, %esi
jb 0x8a0ec
movl %esi, %edi
imulq $0x51eb851f, %rdi, %rdi # imm = 0x51EB851F
shrq $0x25, %rdi
imull $0x64, %edi, %r8d
movl %esi, %r9d
subl %r8d, %r9d
movzwl (%rcx,%r9,2), %r8d
movw %r8w, -0x2(%rax)
addq $-0x2, %rax
cmpl $0x270f, %esi # imm = 0x270F
movl %edi, %esi
ja 0x8a0bb
jmp 0x8a0ee
movl %esi, %edi
cmpl $0x9, %edi
ja 0x8a0ff
orb $0x30, %dil
movb %dil, -0x1(%rax)
decq %rax
retq
movl %edi, %esi
movzwl (%rcx,%rsi,2), %ecx
movw %cx, -0x2(%rax)
addq $-0x2, %rax
retq
| _ZN3fmt3v106detail14format_decimalIcjEENS1_21format_decimal_resultIPT_EES5_T0_i:
movsxd rdx, edx
add rdx, rdi
lea rcx, a00010203040506; "000102030405060708091011121314151617181"...
mov rax, rdx
cmp esi, 64h ; 'd'
jb short loc_8A0EC
loc_8A0BB:
mov edi, esi
imul rdi, 51EB851Fh
shr rdi, 25h
imul r8d, edi, 64h ; 'd'
mov r9d, esi
sub r9d, r8d
movzx r8d, word ptr [rcx+r9*2]
mov [rax-2], r8w
add rax, 0FFFFFFFFFFFFFFFEh
cmp esi, 270Fh
mov esi, edi
ja short loc_8A0BB
jmp short loc_8A0EE
loc_8A0EC:
mov edi, esi
loc_8A0EE:
cmp edi, 9
ja short loc_8A0FF
or dil, 30h
mov [rax-1], dil
dec rax
retn
loc_8A0FF:
mov esi, edi
movzx ecx, word ptr [rcx+rsi*2]
mov [rax-2], cx
add rax, 0FFFFFFFFFFFFFFFEh
retn
| long long fmt::v10::detail::format_decimal<char,unsigned int>(long long a1, unsigned int a2, int a3)
{
long long v3; // rax
unsigned int v4; // edi
bool v5; // cc
v3 = a1 + a3;
if ( a2 < 0x64 )
{
v4 = a2;
}
else
{
do
{
v4 = a2 / 0x64;
*(_WORD *)(v3 - 2) = *(_WORD *)&a00010203040506[2 * (a2 % 0x64)];
v3 -= 2LL;
v5 = a2 <= 0x270F;
a2 /= 0x64u;
}
while ( !v5 );
}
if ( v4 > 9 )
{
*(_WORD *)(v3 - 2) = *(_WORD *)&a00010203040506[2 * v4];
return v3 - 2;
}
else
{
*(_BYTE *)(v3 - 1) = v4 | 0x30;
return v3 - 1;
}
}
| format_decimal<char,unsigned_int>:
MOVSXD RDX,EDX
ADD RDX,RDI
LEA RCX,[0x2ef599]
MOV RAX,RDX
CMP ESI,0x64
JC 0x0018a0ec
LAB_0018a0bb:
MOV EDI,ESI
IMUL RDI,RDI,0x51eb851f
SHR RDI,0x25
IMUL R8D,EDI,0x64
MOV R9D,ESI
SUB R9D,R8D
MOVZX R8D,word ptr [RCX + R9*0x2]
MOV word ptr [RAX + -0x2],R8W
ADD RAX,-0x2
CMP ESI,0x270f
MOV ESI,EDI
JA 0x0018a0bb
JMP 0x0018a0ee
LAB_0018a0ec:
MOV EDI,ESI
LAB_0018a0ee:
CMP EDI,0x9
JA 0x0018a0ff
OR DIL,0x30
MOV byte ptr [RAX + -0x1],DIL
DEC RAX
RET
LAB_0018a0ff:
MOV ESI,EDI
MOVZX ECX,word ptr [RCX + RSI*0x2]
MOV word ptr [RAX + -0x2],CX
ADD RAX,-0x2
RET
|
/* fmt::v10::detail::format_decimal_result<char*> fmt::v10::detail::format_decimal<char, unsigned
int>(char*, unsigned int, int) */
char * fmt::v10::detail::format_decimal<char,unsigned_int>(char *param_1,uint param_2,int param_3)
{
bool bVar1;
char *pcVar2;
uint uVar3;
pcVar2 = param_1 + param_3;
uVar3 = param_2;
if (99 < param_2) {
do {
param_2 = uVar3 / 100;
*(int2 *)(pcVar2 + -2) = *(int2 *)(&DAT_002ef599 + (ulong)(uVar3 % 100) * 2);
pcVar2 = pcVar2 + -2;
bVar1 = 9999 < uVar3;
uVar3 = uVar3 / 100;
} while (bVar1);
}
if (9 < param_2) {
*(int2 *)(pcVar2 + -2) = *(int2 *)(&DAT_002ef599 + (ulong)param_2 * 2);
return pcVar2 + -2;
}
pcVar2[-1] = (byte)param_2 | 0x30;
return pcVar2 + -1;
}
| |
53,953 | my_rw_init | eloqsql/mysys/thr_rwlock.c | int my_rw_init(my_rw_lock_t *rwp)
{
pthread_condattr_t cond_attr;
pthread_mutex_init( &rwp->lock, MY_MUTEX_INIT_FAST);
pthread_condattr_init( &cond_attr );
pthread_cond_init( &rwp->readers, &cond_attr );
pthread_cond_init( &rwp->writers, &cond_attr );
pthread_condattr_destroy(&cond_attr);
rwp->state = 0;
rwp->waiters = 0;
#ifdef SAFE_MUTEX
rwp->write_thread = 0;
#endif
return(0);
} | O0 | c | my_rw_init:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x367a39(%rip), %rsi # 0x3a1880
callq 0x25500
leaq -0xc(%rbp), %rdi
callq 0x25080
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
leaq -0xc(%rbp), %rsi
callq 0x25400
movq -0x8(%rbp), %rdi
addq $0x58, %rdi
leaq -0xc(%rbp), %rsi
callq 0x25400
leaq -0xc(%rbp), %rdi
callq 0x251c0
movq -0x8(%rbp), %rax
movl $0x0, 0x88(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8c(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_rw_init:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]
lea rsi, my_fast_mutexattr
call _pthread_mutex_init
lea rdi, [rbp+var_C]
call _pthread_condattr_init
mov rdi, [rbp+var_8]
add rdi, 28h ; '('
lea rsi, [rbp+var_C]
call _pthread_cond_init
mov rdi, [rbp+var_8]
add rdi, 58h ; 'X'
lea rsi, [rbp+var_C]
call _pthread_cond_init
lea rdi, [rbp+var_C]
call _pthread_condattr_destroy
mov rax, [rbp+var_8]
mov dword ptr [rax+88h], 0
mov rax, [rbp+var_8]
mov dword ptr [rax+8Ch], 0
xor eax, eax
add rsp, 10h
pop rbp
retn
| long long my_rw_init(long long a1)
{
_BYTE v2[4]; // [rsp+4h] [rbp-Ch] BYREF
long long v3; // [rsp+8h] [rbp-8h]
v3 = a1;
pthread_mutex_init(a1, &my_fast_mutexattr);
pthread_condattr_init(v2);
pthread_cond_init(v3 + 40, v2);
pthread_cond_init(v3 + 88, v2);
pthread_condattr_destroy(v2);
*(_DWORD *)(v3 + 136) = 0;
*(_DWORD *)(v3 + 140) = 0;
return 0LL;
}
| my_rw_init:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x4a1880]
CALL 0x00125500
LEA RDI,[RBP + -0xc]
CALL 0x00125080
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x28
LEA RSI,[RBP + -0xc]
CALL 0x00125400
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x58
LEA RSI,[RBP + -0xc]
CALL 0x00125400
LEA RDI,[RBP + -0xc]
CALL 0x001251c0
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x88],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x8c],0x0
XOR EAX,EAX
ADD RSP,0x10
POP RBP
RET
|
int8 my_rw_init(pthread_mutex_t *param_1)
{
pthread_condattr_t local_14;
pthread_mutex_t *local_10;
local_10 = param_1;
pthread_mutex_init(param_1,(pthread_mutexattr_t *)&my_fast_mutexattr);
pthread_condattr_init(&local_14);
pthread_cond_init((pthread_cond_t *)(local_10 + 1),&local_14);
pthread_cond_init((pthread_cond_t *)((long)local_10 + 0x58),&local_14);
pthread_condattr_destroy(&local_14);
*(int4 *)((long)local_10 + 0x88) = 0;
*(int4 *)((long)local_10 + 0x8c) = 0;
return 0;
}
| |
53,954 | my_rw_init | eloqsql/mysys/thr_rwlock.c | int my_rw_init(my_rw_lock_t *rwp)
{
pthread_condattr_t cond_attr;
pthread_mutex_init( &rwp->lock, MY_MUTEX_INIT_FAST);
pthread_condattr_init( &cond_attr );
pthread_cond_init( &rwp->readers, &cond_attr );
pthread_cond_init( &rwp->writers, &cond_attr );
pthread_condattr_destroy(&cond_attr);
rwp->state = 0;
rwp->waiters = 0;
#ifdef SAFE_MUTEX
rwp->write_thread = 0;
#endif
return(0);
} | O3 | c | my_rw_init:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x347deb(%rip), %rsi # 0x379cd0
callq 0x24550
leaq -0x14(%rbp), %r14
movq %r14, %rdi
callq 0x24090
leaq 0x28(%rbx), %rdi
movq %r14, %rsi
callq 0x24460
leaq 0x58(%rbx), %rdi
movq %r14, %rsi
callq 0x24460
movq %r14, %rdi
callq 0x241d0
movq $0x0, 0x88(%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
| my_rw_init:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 10h
mov rbx, rdi
lea rsi, my_fast_mutexattr
call _pthread_mutex_init
lea r14, [rbp+var_14]
mov rdi, r14
call _pthread_condattr_init
lea rdi, [rbx+28h]
mov rsi, r14
call _pthread_cond_init
lea rdi, [rbx+58h]
mov rsi, r14
call _pthread_cond_init
mov rdi, r14
call _pthread_condattr_destroy
mov qword ptr [rbx+88h], 0
xor eax, eax
add rsp, 10h
pop rbx
pop r14
pop rbp
retn
| long long my_rw_init(long long a1)
{
_BYTE v2[20]; // [rsp+Ch] [rbp-14h] BYREF
pthread_mutex_init(a1, &my_fast_mutexattr);
pthread_condattr_init(v2);
pthread_cond_init(a1 + 40, v2);
pthread_cond_init(a1 + 88, v2);
pthread_condattr_destroy(v2);
*(_QWORD *)(a1 + 136) = 0LL;
return 0LL;
}
| my_rw_init:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
LEA RSI,[0x479cd0]
CALL 0x00124550
LEA R14,[RBP + -0x14]
MOV RDI,R14
CALL 0x00124090
LEA RDI,[RBX + 0x28]
MOV RSI,R14
CALL 0x00124460
LEA RDI,[RBX + 0x58]
MOV RSI,R14
CALL 0x00124460
MOV RDI,R14
CALL 0x001241d0
MOV qword ptr [RBX + 0x88],0x0
XOR EAX,EAX
ADD RSP,0x10
POP RBX
POP R14
POP RBP
RET
|
int8 my_rw_init(pthread_mutex_t *param_1)
{
pthread_condattr_t local_1c;
pthread_mutex_init(param_1,(pthread_mutexattr_t *)&my_fast_mutexattr);
pthread_condattr_init(&local_1c);
pthread_cond_init((pthread_cond_t *)(param_1 + 1),&local_1c);
pthread_cond_init((pthread_cond_t *)((long)param_1 + 0x58),&local_1c);
pthread_condattr_destroy(&local_1c);
*(int8 *)((long)param_1 + 0x88) = 0;
return 0;
}
| |
53,955 | PhiloxRNG::philox4_32(std::vector<std::vector<unsigned int, std::allocator<unsigned int>>, std::allocator<std::vector<unsigned int, std::allocator<unsigned int>>>>&, std::vector<std::vector<unsigned int, std::allocator<unsigned int>>, std::allocator<std::vector<unsigned int, std::allocator<unsigned int>>>>&, int) | 7CodeWizard[P]stablediffusion/rng_philox.hpp | std::vector<std::vector<uint32_t>> philox4_32(std::vector<std::vector<uint32_t>>& counter,
std::vector<std::vector<uint32_t>>& key,
int rounds = 10) {
uint32_t N = (uint32_t)counter[0].size();
for (int i = 0; i < rounds - 1; ++i) {
philox4_round(counter, key);
for (uint32_t j = 0; j < N; ++j) {
key[0][j] += philox_w[0];
key[1][j] += philox_w[1];
}
}
philox4_round(counter, key);
return counter;
} | O1 | cpp | PhiloxRNG::philox4_32(std::vector<std::vector<unsigned int, std::allocator<unsigned int>>, std::allocator<std::vector<unsigned int, std::allocator<unsigned int>>>>&, std::vector<std::vector<unsigned int, std::allocator<unsigned int>>, std::allocator<std::vector<unsigned int, std::allocator<unsigned int>>>>&, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdx, 0x8(%rsp)
movq %rsi, %r12
movq %rdi, 0x10(%rsp)
cmpl $0x2, %r8d
jl 0x3c26c
movl %r8d, %ebp
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %r13
subq (%rax), %r13
shrq $0x2, %r13
movl %r13d, %ebx
addl $-0x2, %ebp
xorl %r14d, %r14d
movq %r12, %rdi
movq 0x8(%rsp), %rsi
movq %r15, %rdx
callq 0x3c4e2
testl %r13d, %r13d
je 0x3c260
movq 0x30(%r12), %rax
movq (%r15), %rdx
movq (%rdx), %rcx
movq 0x18(%rdx), %rdx
xorl %esi, %esi
movl (%rax), %edi
addl %edi, (%rcx,%rsi,4)
movl 0x4(%rax), %edi
addl %edi, (%rdx,%rsi,4)
incq %rsi
cmpq %rsi, %rbx
jne 0x3c24d
leal 0x1(%r14), %eax
cmpl %ebp, %r14d
movl %eax, %r14d
jne 0x3c227
movq %r12, %rdi
movq 0x8(%rsp), %r14
movq %r14, %rsi
movq %r15, %rdx
callq 0x3c4e2
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3c602
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| _ZN9PhiloxRNG10philox4_32ERSt6vectorIS0_IjSaIjEESaIS2_EES5_i:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r15, rcx
mov [rsp+48h+var_40], rdx
mov r12, rsi
mov [rsp+48h+var_38], rdi
cmp r8d, 2
jl short loc_3C26C
mov ebp, r8d
mov rax, [rsp+48h+var_40]
mov rax, [rax]
mov r13, [rax+8]
sub r13, [rax]
shr r13, 2
mov ebx, r13d
add ebp, 0FFFFFFFEh
xor r14d, r14d
loc_3C227:
mov rdi, r12
mov rsi, [rsp+48h+var_40]
mov rdx, r15
call _ZN9PhiloxRNG13philox4_roundERSt6vectorIS0_IjSaIjEESaIS2_EERKS4_; PhiloxRNG::philox4_round(std::vector<std::vector<uint>> &,std::vector<std::vector<uint>> const&)
test r13d, r13d
jz short loc_3C260
mov rax, [r12+30h]
mov rdx, [r15]
mov rcx, [rdx]
mov rdx, [rdx+18h]
xor esi, esi
loc_3C24D:
mov edi, [rax]
add [rcx+rsi*4], edi
mov edi, [rax+4]
add [rdx+rsi*4], edi
inc rsi
cmp rbx, rsi
jnz short loc_3C24D
loc_3C260:
lea eax, [r14+1]
cmp r14d, ebp
mov r14d, eax
jnz short loc_3C227
loc_3C26C:
mov rdi, r12
mov r14, [rsp+48h+var_40]
mov rsi, r14
mov rdx, r15
call _ZN9PhiloxRNG13philox4_roundERSt6vectorIS0_IjSaIjEESaIS2_EERKS4_; PhiloxRNG::philox4_round(std::vector<std::vector<uint>> &,std::vector<std::vector<uint>> const&)
mov rbx, [rsp+48h+var_38]
mov rdi, rbx
mov rsi, r14
call _ZNSt6vectorIS_IjSaIjEESaIS1_EEC2ERKS3_; std::vector<std::vector<uint>>::vector(std::vector<std::vector<uint>> const&)
mov rax, rbx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long PhiloxRNG::philox4_32(long long a1, long long a2, long long a3, long long **a4, int a5)
{
long long v7; // r13
int v8; // ebp
int v9; // r14d
_DWORD *v10; // rax
long long v11; // rcx
long long v12; // rdx
long long v13; // rsi
if ( a5 >= 2 )
{
v7 = (*(_QWORD *)(*(_QWORD *)a3 + 8LL) - **(_QWORD **)a3) >> 2;
v8 = a5 - 2;
v9 = 0;
do
{
PhiloxRNG::philox4_round(a2, a3, a4);
if ( (_DWORD)v7 )
{
v10 = *(_DWORD **)(a2 + 48);
v11 = **a4;
v12 = (*a4)[3];
v13 = 0LL;
do
{
*(_DWORD *)(v11 + 4 * v13) += *v10;
*(_DWORD *)(v12 + 4 * v13++) += v10[1];
}
while ( (unsigned int)v7 != v13 );
}
}
while ( v9++ != v8 );
}
PhiloxRNG::philox4_round(a2, a3, a4);
std::vector<std::vector<unsigned int>>::vector(a1, a3);
return a1;
}
| |||
53,956 | PhiloxRNG::philox4_32(std::vector<std::vector<unsigned int, std::allocator<unsigned int>>, std::allocator<std::vector<unsigned int, std::allocator<unsigned int>>>>&, std::vector<std::vector<unsigned int, std::allocator<unsigned int>>, std::allocator<std::vector<unsigned int, std::allocator<unsigned int>>>>&, int) | 7CodeWizard[P]stablediffusion/rng_philox.hpp | std::vector<std::vector<uint32_t>> philox4_32(std::vector<std::vector<uint32_t>>& counter,
std::vector<std::vector<uint32_t>>& key,
int rounds = 10) {
uint32_t N = (uint32_t)counter[0].size();
for (int i = 0; i < rounds - 1; ++i) {
philox4_round(counter, key);
for (uint32_t j = 0; j < N; ++j) {
key[0][j] += philox_w[0];
key[1][j] += philox_w[1];
}
}
philox4_round(counter, key);
return counter;
} | O2 | cpp | PhiloxRNG::philox4_32(std::vector<std::vector<unsigned int, std::allocator<unsigned int>>, std::allocator<std::vector<unsigned int, std::allocator<unsigned int>>>>&, std::vector<std::vector<unsigned int, std::allocator<unsigned int>>, std::allocator<std::vector<unsigned int, std::allocator<unsigned int>>>>&, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq (%rdx), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
shrq $0x2, %rcx
cmpl $0x2, %r8d
pushq $0x1
popq %rbp
cmovgel %r8d, %ebp
movq %rdi, (%rsp)
decl %ebp
movl %ecx, %r13d
xorl %r12d, %r12d
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x259fc
cmpl %ebp, %r12d
je 0x255b0
movq 0x30(%r15), %rax
movq (%r14), %rcx
xorl %edx, %edx
cmpq %rdx, %r13
je 0x255ab
movl (%rax), %esi
movq (%rcx), %rdi
addl %esi, (%rdi,%rdx,4)
movl 0x4(%rax), %esi
movq 0x18(%rcx), %rdi
addl %esi, (%rdi,%rdx,4)
incq %rdx
jmp 0x2558f
incl %r12d
jmp 0x25573
movq (%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x25b00
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| _ZN9PhiloxRNG10philox4_32ERSt6vectorIS0_IjSaIjEESaIS2_EES5_i:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rcx
mov rbx, rdx
mov r15, rsi
mov rax, [rdx]
mov rcx, [rax+8]
sub rcx, [rax]
shr rcx, 2
cmp r8d, 2
push 1
pop rbp
cmovge ebp, r8d
mov qword ptr [rsp+38h+var_38], rdi; char
dec ebp
mov r13d, ecx
xor r12d, r12d
loc_25573:
mov rdi, r15; unsigned __int64
mov rsi, rbx
mov rdx, r14
call _ZN9PhiloxRNG13philox4_roundERSt6vectorIS0_IjSaIjEESaIS2_EERKS4_; PhiloxRNG::philox4_round(std::vector<std::vector<uint>> &,std::vector<std::vector<uint>> const&)
cmp r12d, ebp
jz short loc_255B0
mov rax, [r15+30h]
mov rcx, [r14]
xor edx, edx
loc_2558F:
cmp r13, rdx
jz short loc_255AB
mov esi, [rax]
mov rdi, [rcx]
add [rdi+rdx*4], esi
mov esi, [rax+4]
mov rdi, [rcx+18h]
add [rdi+rdx*4], esi
inc rdx
jmp short loc_2558F
loc_255AB:
inc r12d
jmp short loc_25573
loc_255B0:
mov r14, qword ptr [rsp+38h+var_38]
mov rdi, r14
mov rsi, rbx
call _ZNSt6vectorIS_IjSaIjEESaIS1_EEC2ERKS3_; std::vector<std::vector<uint>>::vector(std::vector<std::vector<uint>> const&)
mov rax, r14
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long PhiloxRNG::philox4_32(char a1, unsigned long long a2, long long a3, _QWORD **a4, int a5)
{
int v7; // ebp
int v8; // ebp
long long v9; // r13
int i; // r12d
_DWORD *v11; // rax
_QWORD *v12; // rcx
long long j; // rdx
char v15[8]; // [rsp+0h] [rbp-38h]
v7 = 1;
if ( a5 >= 2 )
v7 = a5;
v15[0] = a1;
v8 = v7 - 1;
v9 = (unsigned int)((*(_QWORD *)(*(_QWORD *)a3 + 8LL) - **(_QWORD **)a3) >> 2);
for ( i = 0; ; ++i )
{
PhiloxRNG::philox4_round(a2, v15[0]);
if ( i == v8 )
break;
v11 = *(_DWORD **)(a2 + 48);
v12 = *a4;
for ( j = 0LL; v9 != j; ++j )
{
*(_DWORD *)(*v12 + 4 * j) += *v11;
*(_DWORD *)(v12[3] + 4 * j) += v11[1];
}
}
std::vector<std::vector<unsigned int>>::vector(*(_QWORD *)v15, a3);
return *(_QWORD *)v15;
}
| philox4_32:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RCX
MOV RBX,RDX
MOV R15,RSI
MOV RAX,qword ptr [RDX]
MOV RCX,qword ptr [RAX + 0x8]
SUB RCX,qword ptr [RAX]
SHR RCX,0x2
CMP R8D,0x2
PUSH 0x1
POP RBP
CMOVGE EBP,R8D
MOV qword ptr [RSP],RDI
DEC EBP
MOV R13D,ECX
XOR R12D,R12D
LAB_00125573:
MOV RDI,R15
MOV RSI,RBX
MOV RDX,R14
CALL 0x001259fc
CMP R12D,EBP
JZ 0x001255b0
MOV RAX,qword ptr [R15 + 0x30]
MOV RCX,qword ptr [R14]
XOR EDX,EDX
LAB_0012558f:
CMP R13,RDX
JZ 0x001255ab
MOV ESI,dword ptr [RAX]
MOV RDI,qword ptr [RCX]
ADD dword ptr [RDI + RDX*0x4],ESI
MOV ESI,dword ptr [RAX + 0x4]
MOV RDI,qword ptr [RCX + 0x18]
ADD dword ptr [RDI + RDX*0x4],ESI
INC RDX
JMP 0x0012558f
LAB_001255ab:
INC R12D
JMP 0x00125573
LAB_001255b0:
MOV R14,qword ptr [RSP]
MOV RDI,R14
MOV RSI,RBX
CALL 0x00125b00
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* PhiloxRNG::philox4_32(std::vector<std::vector<unsigned int, std::allocator<unsigned int> >,
std::allocator<std::vector<unsigned int, std::allocator<unsigned int> > > >&,
std::vector<std::vector<unsigned int, std::allocator<unsigned int> >,
std::allocator<std::vector<unsigned int, std::allocator<unsigned int> > > >&, int) */
vector * PhiloxRNG::philox4_32(vector *param_1,vector *param_2,int param_3)
{
int *piVar1;
long lVar2;
long lVar3;
int *piVar4;
long *plVar5;
vector *in_RCX;
int4 in_register_00000014;
vector *pvVar6;
ulong uVar7;
int iVar8;
int in_R8D;
int iVar9;
pvVar6 = (vector *)CONCAT44(in_register_00000014,param_3);
lVar2 = (*(long **)pvVar6)[1];
lVar3 = **(long **)pvVar6;
iVar8 = 1;
if (1 < in_R8D) {
iVar8 = in_R8D;
}
iVar9 = 0;
while( true ) {
philox4_round((PhiloxRNG *)param_2,pvVar6,in_RCX);
if (iVar9 == iVar8 + -1) break;
piVar4 = *(int **)(param_2 + 0x30);
plVar5 = *(long **)in_RCX;
for (uVar7 = 0; ((ulong)(lVar2 - lVar3) >> 2 & 0xffffffff) != uVar7; uVar7 = uVar7 + 1) {
piVar1 = (int *)(*plVar5 + uVar7 * 4);
*piVar1 = *piVar1 + *piVar4;
piVar1 = (int *)(plVar5[3] + uVar7 * 4);
*piVar1 = *piVar1 + piVar4[1];
}
iVar9 = iVar9 + 1;
}
std::
vector<std::vector<unsigned_int,std::allocator<unsigned_int>>,std::allocator<std::vector<unsigned_int,std::allocator<unsigned_int>>>>
::vector((vector<std::vector<unsigned_int,std::allocator<unsigned_int>>,std::allocator<std::vector<unsigned_int,std::allocator<unsigned_int>>>>
*)param_1,pvVar6);
return param_1;
}
| |
53,957 | PhiloxRNG::philox4_32(std::vector<std::vector<unsigned int, std::allocator<unsigned int>>, std::allocator<std::vector<unsigned int, std::allocator<unsigned int>>>>&, std::vector<std::vector<unsigned int, std::allocator<unsigned int>>, std::allocator<std::vector<unsigned int, std::allocator<unsigned int>>>>&, int) | 7CodeWizard[P]stablediffusion/rng_philox.hpp | std::vector<std::vector<uint32_t>> philox4_32(std::vector<std::vector<uint32_t>>& counter,
std::vector<std::vector<uint32_t>>& key,
int rounds = 10) {
uint32_t N = (uint32_t)counter[0].size();
for (int i = 0; i < rounds - 1; ++i) {
philox4_round(counter, key);
for (uint32_t j = 0; j < N; ++j) {
key[0][j] += philox_w[0];
key[1][j] += philox_w[1];
}
}
philox4_round(counter, key);
return counter;
} | O3 | cpp | PhiloxRNG::philox4_32(std::vector<std::vector<unsigned int, std::allocator<unsigned int>>, std::allocator<std::vector<unsigned int, std::allocator<unsigned int>>>>&, std::vector<std::vector<unsigned int, std::allocator<unsigned int>>, std::allocator<std::vector<unsigned int, std::allocator<unsigned int>>>>&, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdx, 0x8(%rsp)
movq %rsi, %r12
movq %rdi, 0x10(%rsp)
cmpl $0x2, %r8d
jl 0x3b71c
movl %r8d, %ebp
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %r13
subq (%rax), %r13
shrq $0x2, %r13
movl %r13d, %ebx
addl $-0x2, %ebp
xorl %r14d, %r14d
movq %r12, %rdi
movq 0x8(%rsp), %rsi
movq %r15, %rdx
callq 0x3b99a
testl %r13d, %r13d
je 0x3b710
movq 0x30(%r12), %rax
movq (%r15), %rdx
movq (%rdx), %rcx
movq 0x18(%rdx), %rdx
xorl %esi, %esi
movl (%rax), %edi
addl %edi, (%rcx,%rsi,4)
movl 0x4(%rax), %edi
addl %edi, (%rdx,%rsi,4)
incq %rsi
cmpq %rsi, %rbx
jne 0x3b6fd
leal 0x1(%r14), %eax
cmpl %ebp, %r14d
movl %eax, %r14d
jne 0x3b6d7
movq %r12, %rdi
movq 0x8(%rsp), %r14
movq %r14, %rsi
movq %r15, %rdx
callq 0x3b99a
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3bab2
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| _ZN9PhiloxRNG10philox4_32ERSt6vectorIS0_IjSaIjEESaIS2_EES5_i:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r15, rcx
mov [rsp+48h+var_40], rdx
mov r12, rsi
mov [rsp+48h+var_38], rdi
cmp r8d, 2
jl short loc_3B71C
mov ebp, r8d
mov rax, [rsp+48h+var_40]
mov rax, [rax]
mov r13, [rax+8]
sub r13, [rax]
shr r13, 2
mov ebx, r13d
add ebp, 0FFFFFFFEh
xor r14d, r14d
loc_3B6D7:
mov rdi, r12
mov rsi, [rsp+48h+var_40]
mov rdx, r15
call _ZN9PhiloxRNG13philox4_roundERSt6vectorIS0_IjSaIjEESaIS2_EERKS4_; PhiloxRNG::philox4_round(std::vector<std::vector<uint>> &,std::vector<std::vector<uint>> const&)
test r13d, r13d
jz short loc_3B710
mov rax, [r12+30h]
mov rdx, [r15]
mov rcx, [rdx]
mov rdx, [rdx+18h]
xor esi, esi
loc_3B6FD:
mov edi, [rax]
add [rcx+rsi*4], edi
mov edi, [rax+4]
add [rdx+rsi*4], edi
inc rsi
cmp rbx, rsi
jnz short loc_3B6FD
loc_3B710:
lea eax, [r14+1]
cmp r14d, ebp
mov r14d, eax
jnz short loc_3B6D7
loc_3B71C:
mov rdi, r12
mov r14, [rsp+48h+var_40]
mov rsi, r14
mov rdx, r15
call _ZN9PhiloxRNG13philox4_roundERSt6vectorIS0_IjSaIjEESaIS2_EERKS4_; PhiloxRNG::philox4_round(std::vector<std::vector<uint>> &,std::vector<std::vector<uint>> const&)
mov rbx, [rsp+48h+var_38]
mov rdi, rbx
mov rsi, r14
call _ZNSt6vectorIS_IjSaIjEESaIS1_EEC2ERKS3_; std::vector<std::vector<uint>>::vector(std::vector<std::vector<uint>> const&)
mov rax, rbx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long PhiloxRNG::philox4_32(long long a1, long long a2, long long a3, long long **a4, int a5)
{
long long v7; // r13
int v8; // ebp
int v9; // r14d
_DWORD *v10; // rax
long long v11; // rcx
long long v12; // rdx
long long v13; // rsi
if ( a5 >= 2 )
{
v7 = (*(_QWORD *)(*(_QWORD *)a3 + 8LL) - **(_QWORD **)a3) >> 2;
v8 = a5 - 2;
v9 = 0;
do
{
PhiloxRNG::philox4_round(a2, a3, a4);
if ( (_DWORD)v7 )
{
v10 = *(_DWORD **)(a2 + 48);
v11 = **a4;
v12 = (*a4)[3];
v13 = 0LL;
do
{
*(_DWORD *)(v11 + 4 * v13) += *v10;
*(_DWORD *)(v12 + 4 * v13++) += v10[1];
}
while ( (unsigned int)v7 != v13 );
}
}
while ( v9++ != v8 );
}
PhiloxRNG::philox4_round(a2, a3, a4);
std::vector<std::vector<unsigned int>>::vector(a1, a3);
return a1;
}
| |||
53,958 | ps_fetch_from_1_to_8_bytes | eloqsql/libmariadb/libmariadb/ma_stmt_codec.c | void ps_fetch_from_1_to_8_bytes(MYSQL_BIND *r_param, const MYSQL_FIELD * const field,
unsigned char **row, unsigned int byte_count)
{
my_bool is_unsigned= test(field->flags & UNSIGNED_FLAG);
r_param->buffer_length= byte_count;
switch (byte_count) {
case 1:
*(uchar *)r_param->buffer= **row;
*r_param->error= is_unsigned != r_param->is_unsigned && *(uchar *)r_param->buffer > INT_MAX8;
break;
case 2:
shortstore(r_param->buffer, ((ushort) sint2korr(*row)));
*r_param->error= is_unsigned != r_param->is_unsigned && *(ushort *)r_param->buffer > INT_MAX16;
break;
case 4:
{
longstore(r_param->buffer, ((uint32)sint4korr(*row)));
*r_param->error= is_unsigned != r_param->is_unsigned && *(uint32 *)r_param->buffer > INT_MAX32;
}
break;
case 8:
{
ulonglong val= (ulonglong)sint8korr(*row);
longlongstore(r_param->buffer, val);
*r_param->error= is_unsigned != r_param->is_unsigned && val > LONGLONG_MAX ;
}
break;
default:
r_param->buffer_length= 0;
break;
}
(*row)+= byte_count;
} | O3 | c | ps_fetch_from_1_to_8_bytes:
pushq %rbp
movq %rsp, %rbp
movb 0x64(%rsi), %sil
movl %ecx, %eax
movq %rax, 0x40(%rdi)
decl %ecx
cmpl $0x7, %ecx
ja 0x277ab
shrb $0x5, %sil
andb $0x1, %sil
leaq 0x17020(%rip), %r8 # 0x3e6f0
movslq (%r8,%rcx,4), %rcx
addq %r8, %rcx
jmpq *%rcx
movq (%rdx), %rcx
movb (%rcx), %cl
movq 0x10(%rdi), %r8
movb %cl, (%r8)
cmpb 0x65(%rdi), %sil
je 0x2775e
movq 0x10(%rdi), %rcx
movb (%rcx), %cl
shrb $0x7, %cl
jmp 0x277bf
movq (%rdx), %rcx
movb (%rcx), %cl
movq 0x10(%rdi), %r8
movb %cl, (%r8)
movq (%rdx), %rcx
movb 0x1(%rcx), %cl
movq 0x10(%rdi), %r8
movb %cl, 0x1(%r8)
movq (%rdx), %rcx
movb 0x2(%rcx), %cl
movq 0x10(%rdi), %r8
movb %cl, 0x2(%r8)
movq (%rdx), %rcx
movb 0x3(%rcx), %cl
movq 0x10(%rdi), %r8
movb %cl, 0x3(%r8)
cmpb 0x65(%rdi), %sil
je 0x2775e
movq 0x10(%rdi), %rcx
movl (%rcx), %ecx
shrl $0x1f, %ecx
jmp 0x277bf
movq (%rdx), %rcx
movb (%rcx), %r8b
movb 0x1(%rcx), %cl
movq 0x10(%rdi), %r9
movb %r8b, (%r9)
movq 0x10(%rdi), %r8
movb %cl, 0x1(%r8)
cmpb 0x65(%rdi), %sil
jne 0x277b5
xorl %ecx, %ecx
jmp 0x277bf
movq (%rdx), %rcx
movl (%rcx), %r8d
movzwl 0x4(%rcx), %r9d
shlq $0x20, %r9
orq %r8, %r9
movzbl 0x6(%rcx), %r8d
movzbl 0x7(%rcx), %ecx
shlq $0x38, %rcx
shlq $0x30, %r8
orq %r9, %r8
orq %rcx, %r8
movq 0x10(%rdi), %r9
movq %r8, (%r9)
cmpb 0x65(%rdi), %sil
setne %sil
testq %rcx, %rcx
sets %cl
andb %sil, %cl
movq 0x18(%rdi), %rsi
movb %cl, (%rsi)
jmp 0x277c5
movq $0x0, 0x40(%rdi)
jmp 0x277c5
movq 0x10(%rdi), %rcx
movzwl (%rcx), %ecx
shrl $0xf, %ecx
movq 0x18(%rdi), %rsi
movb %cl, (%rsi)
addq %rax, (%rdx)
popq %rbp
retq
| ps_fetch_from_1_to_8_bytes:
push rbp
mov rbp, rsp
mov sil, [rsi+64h]
mov eax, ecx
mov [rdi+40h], rax
dec ecx; switch 8 cases
cmp ecx, 7
ja def_276D7; jumptable 00000000000276D7 default case, cases 3,5-7
shr sil, 5
and sil, 1
lea r8, jpt_276D7
movsxd rcx, ds:(jpt_276D7 - 3E6F0h)[r8+rcx*4]
add rcx, r8
jmp rcx; switch jump
loc_276D9:
mov rcx, [rdx]; jumptable 00000000000276D7 case 1
mov cl, [rcx]
mov r8, [rdi+10h]
mov [r8], cl
cmp sil, [rdi+65h]
jz short loc_2775E
mov rcx, [rdi+10h]
mov cl, [rcx]
shr cl, 7
jmp loc_277BF
loc_276F9:
mov rcx, [rdx]; jumptable 00000000000276D7 case 4
mov cl, [rcx]
mov r8, [rdi+10h]
mov [r8], cl
mov rcx, [rdx]
mov cl, [rcx+1]
mov r8, [rdi+10h]
mov [r8+1], cl
mov rcx, [rdx]
mov cl, [rcx+2]
mov r8, [rdi+10h]
mov [r8+2], cl
mov rcx, [rdx]
mov cl, [rcx+3]
mov r8, [rdi+10h]
mov [r8+3], cl
cmp sil, [rdi+65h]
jz short loc_2775E
mov rcx, [rdi+10h]
mov ecx, [rcx]
shr ecx, 1Fh
jmp short loc_277BF
loc_27740:
mov rcx, [rdx]; jumptable 00000000000276D7 case 2
mov r8b, [rcx]
mov cl, [rcx+1]
mov r9, [rdi+10h]
mov [r9], r8b
mov r8, [rdi+10h]
mov [r8+1], cl
cmp sil, [rdi+65h]
jnz short loc_277B5
loc_2775E:
xor ecx, ecx
jmp short loc_277BF
loc_27762:
mov rcx, [rdx]; jumptable 00000000000276D7 case 8
mov r8d, [rcx]
movzx r9d, word ptr [rcx+4]
shl r9, 20h
or r9, r8
movzx r8d, byte ptr [rcx+6]
movzx ecx, byte ptr [rcx+7]
shl rcx, 38h
shl r8, 30h
or r8, r9
or r8, rcx
mov r9, [rdi+10h]
mov [r9], r8
cmp sil, [rdi+65h]
setnz sil
test rcx, rcx
sets cl
and cl, sil
mov rsi, [rdi+18h]
mov [rsi], cl
jmp short loc_277C5
def_276D7:
mov qword ptr [rdi+40h], 0; jumptable 00000000000276D7 default case, cases 3,5-7
jmp short loc_277C5
loc_277B5:
mov rcx, [rdi+10h]
movzx ecx, word ptr [rcx]
shr ecx, 0Fh
loc_277BF:
mov rsi, [rdi+18h]
mov [rsi], cl
loc_277C5:
add [rdx], rax
pop rbp
retn
| long long ps_fetch_from_1_to_8_bytes(long long a1, long long a2, _BYTE **a3, unsigned int a4)
{
char v4; // si
long long result; // rax
char v6; // si
int v7; // ecx
char v8; // cl
signed long long v9; // rcx
v4 = *(_BYTE *)(a2 + 100);
result = a4;
*(_QWORD *)(a1 + 64) = a4;
v6 = (v4 & 0x20) != 0;
switch ( a4 )
{
case 1u:
**(_BYTE **)(a1 + 16) = **a3;
if ( v6 == *(_BYTE *)(a1 + 101) )
goto LABEL_7;
LOBYTE(v7) = **(_BYTE **)(a1 + 16) >> 7;
goto LABEL_11;
case 2u:
v8 = (*a3)[1];
**(_BYTE **)(a1 + 16) = **a3;
*(_BYTE *)(*(_QWORD *)(a1 + 16) + 1LL) = v8;
if ( v6 == *(_BYTE *)(a1 + 101) )
goto LABEL_7;
v7 = **(unsigned __int16 **)(a1 + 16) >> 15;
goto LABEL_11;
case 4u:
**(_BYTE **)(a1 + 16) = **a3;
*(_BYTE *)(*(_QWORD *)(a1 + 16) + 1LL) = (*a3)[1];
*(_BYTE *)(*(_QWORD *)(a1 + 16) + 2LL) = (*a3)[2];
*(_BYTE *)(*(_QWORD *)(a1 + 16) + 3LL) = (*a3)[3];
if ( v6 == *(_BYTE *)(a1 + 101) )
LABEL_7:
LOBYTE(v7) = 0;
else
v7 = **(_DWORD **)(a1 + 16) >> 31;
LABEL_11:
**(_BYTE **)(a1 + 24) = v7;
break;
case 8u:
v9 = (unsigned long long)(unsigned __int8)(*a3)[7] << 56;
**(_QWORD **)(a1 + 16) = v9 | *(unsigned int *)*a3 | ((unsigned long long)*((unsigned __int16 *)*a3 + 2) << 32) | ((unsigned long long)(unsigned __int8)(*a3)[6] << 48);
**(_BYTE **)(a1 + 24) = v6 != *(_BYTE *)(a1 + 101) && v9 < 0;
break;
default:
*(_QWORD *)(a1 + 64) = 0LL;
break;
}
*a3 += result;
return result;
}
| ps_fetch_from_1_to_8_bytes:
PUSH RBP
MOV RBP,RSP
MOV SIL,byte ptr [RSI + 0x64]
MOV EAX,ECX
MOV qword ptr [RDI + 0x40],RAX
DEC ECX
CMP ECX,0x7
JA 0x001277ab
SHR SIL,0x5
AND SIL,0x1
LEA R8,[0x13e6f0]
MOVSXD RCX,dword ptr [R8 + RCX*0x4]
ADD RCX,R8
switchD:
JMP RCX
caseD_1:
MOV RCX,qword ptr [RDX]
MOV CL,byte ptr [RCX]
MOV R8,qword ptr [RDI + 0x10]
MOV byte ptr [R8],CL
CMP SIL,byte ptr [RDI + 0x65]
JZ 0x0012775e
MOV RCX,qword ptr [RDI + 0x10]
MOV CL,byte ptr [RCX]
SHR CL,0x7
JMP 0x001277bf
caseD_4:
MOV RCX,qword ptr [RDX]
MOV CL,byte ptr [RCX]
MOV R8,qword ptr [RDI + 0x10]
MOV byte ptr [R8],CL
MOV RCX,qword ptr [RDX]
MOV CL,byte ptr [RCX + 0x1]
MOV R8,qword ptr [RDI + 0x10]
MOV byte ptr [R8 + 0x1],CL
MOV RCX,qword ptr [RDX]
MOV CL,byte ptr [RCX + 0x2]
MOV R8,qword ptr [RDI + 0x10]
MOV byte ptr [R8 + 0x2],CL
MOV RCX,qword ptr [RDX]
MOV CL,byte ptr [RCX + 0x3]
MOV R8,qword ptr [RDI + 0x10]
MOV byte ptr [R8 + 0x3],CL
CMP SIL,byte ptr [RDI + 0x65]
JZ 0x0012775e
MOV RCX,qword ptr [RDI + 0x10]
MOV ECX,dword ptr [RCX]
SHR ECX,0x1f
JMP 0x001277bf
caseD_2:
MOV RCX,qword ptr [RDX]
MOV R8B,byte ptr [RCX]
MOV CL,byte ptr [RCX + 0x1]
MOV R9,qword ptr [RDI + 0x10]
MOV byte ptr [R9],R8B
MOV R8,qword ptr [RDI + 0x10]
MOV byte ptr [R8 + 0x1],CL
CMP SIL,byte ptr [RDI + 0x65]
JNZ 0x001277b5
LAB_0012775e:
XOR ECX,ECX
JMP 0x001277bf
caseD_8:
MOV RCX,qword ptr [RDX]
MOV R8D,dword ptr [RCX]
MOVZX R9D,word ptr [RCX + 0x4]
SHL R9,0x20
OR R9,R8
MOVZX R8D,byte ptr [RCX + 0x6]
MOVZX ECX,byte ptr [RCX + 0x7]
SHL RCX,0x38
SHL R8,0x30
OR R8,R9
OR R8,RCX
MOV R9,qword ptr [RDI + 0x10]
MOV qword ptr [R9],R8
CMP SIL,byte ptr [RDI + 0x65]
SETNZ SIL
TEST RCX,RCX
SETS CL
AND CL,SIL
MOV RSI,qword ptr [RDI + 0x18]
MOV byte ptr [RSI],CL
JMP 0x001277c5
caseD_3:
MOV qword ptr [RDI + 0x40],0x0
JMP 0x001277c5
LAB_001277b5:
MOV RCX,qword ptr [RDI + 0x10]
MOVZX ECX,word ptr [RCX]
SHR ECX,0xf
LAB_001277bf:
MOV RSI,qword ptr [RDI + 0x18]
MOV byte ptr [RSI],CL
LAB_001277c5:
ADD qword ptr [RDX],RAX
POP RBP
RET
|
void ps_fetch_from_1_to_8_bytes(long param_1,long param_2,long *param_3,uint param_4)
{
int1 uVar1;
byte bVar2;
byte bVar3;
bVar3 = *(byte *)(param_2 + 100);
*(ulong *)(param_1 + 0x40) = (ulong)param_4;
if (param_4 - 1 < 8) {
bVar3 = bVar3 >> 5 & 1;
switch(param_4) {
case 1:
**(int1 **)(param_1 + 0x10) = *(int1 *)*param_3;
if (bVar3 == *(byte *)(param_1 + 0x65)) {
LAB_0012775e:
bVar3 = 0;
}
else {
bVar3 = **(byte **)(param_1 + 0x10) >> 7;
}
break;
case 2:
uVar1 = ((int1 *)*param_3)[1];
**(int1 **)(param_1 + 0x10) = *(int1 *)*param_3;
*(int1 *)(*(long *)(param_1 + 0x10) + 1) = uVar1;
if (bVar3 == *(byte *)(param_1 + 0x65)) goto LAB_0012775e;
bVar3 = (byte)((ushort)**(int2 **)(param_1 + 0x10) >> 0xf);
break;
default:
goto switchD_001276d7_caseD_3;
case 4:
**(int1 **)(param_1 + 0x10) = *(int1 *)*param_3;
*(int1 *)(*(long *)(param_1 + 0x10) + 1) = *(int1 *)(*param_3 + 1);
*(int1 *)(*(long *)(param_1 + 0x10) + 2) = *(int1 *)(*param_3 + 2);
*(int1 *)(*(long *)(param_1 + 0x10) + 3) = *(int1 *)(*param_3 + 3);
if (bVar3 == *(byte *)(param_1 + 0x65)) goto LAB_0012775e;
bVar3 = (byte)((uint)**(int4 **)(param_1 + 0x10) >> 0x1f);
break;
case 8:
bVar2 = *(byte *)(*param_3 + 7);
**(int8 **)(param_1 + 0x10) = *(int8 *)*param_3;
*(bool *)*(int8 *)(param_1 + 0x18) =
(long)((ulong)bVar2 << 0x38) < 0 && bVar3 != *(byte *)(param_1 + 0x65);
goto LAB_001277c5;
}
**(byte **)(param_1 + 0x18) = bVar3;
}
else {
switchD_001276d7_caseD_3:
*(int8 *)(param_1 + 0x40) = 0;
}
LAB_001277c5:
*param_3 = *param_3 + (ulong)param_4;
return;
}
| |
53,959 | Bfree | eloqsql/strings/dtoa.c | static void Bfree(Bigint *v, Stack_alloc *alloc)
{
char *gptr= (char*) v; /* generic pointer */
if (gptr < alloc->begin || gptr >= alloc->end)
free(gptr);
else if (v->k <= Kmax)
{
/*
Maintain free lists only for stack objects: this way we don't
have to bother with freeing lists in the end of dtoa;
heap should not be used normally anyway.
*/
v->p.next= alloc->freelist[v->k];
alloc->freelist[v->k]= v;
}
} | O3 | c | Bfree:
pushq %rbp
movq %rsp, %rbp
cmpq %rdi, (%rsi)
ja 0xd52a9
cmpq %rdi, 0x10(%rsi)
jbe 0xd52a9
movslq 0x8(%rdi), %rax
cmpq $0xf, %rax
jg 0xd52a7
movq 0x18(%rsi,%rax,8), %rcx
movq %rcx, (%rdi)
movq %rdi, 0x18(%rsi,%rax,8)
popq %rbp
retq
popq %rbp
jmp 0x29160
| Bfree:
push rbp
mov rbp, rsp
cmp [rsi], rdi
ja short loc_D52A9
cmp [rsi+10h], rdi
jbe short loc_D52A9
movsxd rax, dword ptr [rdi+8]
cmp rax, 0Fh
jg short loc_D52A7
mov rcx, [rsi+rax*8+18h]
mov [rdi], rcx
mov [rsi+rax*8+18h], rdi
loc_D52A7:
pop rbp
retn
loc_D52A9:
pop rbp
jmp _free
| long long Bfree(unsigned long long a1, unsigned long long *a2)
{
long long result; // rax
if ( *a2 > a1 || a2[2] <= a1 )
return free(a1);
result = *(int *)(a1 + 8);
if ( result <= 15 )
{
*(_QWORD *)a1 = a2[result + 3];
a2[result + 3] = a1;
}
return result;
}
| Bfree:
PUSH RBP
MOV RBP,RSP
CMP qword ptr [RSI],RDI
JA 0x001d52a9
CMP qword ptr [RSI + 0x10],RDI
JBE 0x001d52a9
MOVSXD RAX,dword ptr [RDI + 0x8]
CMP RAX,0xf
JG 0x001d52a7
MOV RCX,qword ptr [RSI + RAX*0x8 + 0x18]
MOV qword ptr [RDI],RCX
MOV qword ptr [RSI + RAX*0x8 + 0x18],RDI
LAB_001d52a7:
POP RBP
RET
LAB_001d52a9:
POP RBP
JMP 0x00129160
|
void Bfree(ulong *param_1,ulong *param_2)
{
long lVar1;
if (((ulong *)*param_2 <= param_1) && (param_1 < (ulong *)param_2[2])) {
lVar1 = (long)(int)param_1[1];
if (lVar1 < 0x10) {
*param_1 = param_2[lVar1 + 3];
param_2[lVar1 + 3] = (ulong)param_1;
}
return;
}
free(param_1);
return;
}
| |
53,960 | ggml_set_impl | ngxson[P]ggml-easy/ggml/src/ggml.c | static struct ggml_tensor * ggml_set_impl(
struct ggml_context * ctx,
struct ggml_tensor * a,
struct ggml_tensor * b,
size_t nb1,
size_t nb2,
size_t nb3,
size_t offset,
bool inplace) {
GGML_ASSERT(ggml_nelements(a) >= ggml_nelements(b));
// make a view of the destination
struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);
GGML_ASSERT(offset < (size_t)(1 << 30));
int32_t params[] = { nb1, nb2, nb3, offset, inplace ? 1 : 0 };
ggml_set_op_params(result, params, sizeof(params));
result->op = GGML_OP_SET;
result->src[0] = a;
result->src[1] = b;
return result;
} | O1 | c | ggml_set_impl:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movq %rcx, %r12
movq 0x18(%rsi), %rax
imulq 0x10(%rsi), %rax
imulq 0x20(%rsi), %rax
imulq 0x28(%rsi), %rax
movq 0x18(%rdx), %rcx
imulq 0x10(%rdx), %rcx
imulq 0x20(%rdx), %rcx
imulq 0x28(%rdx), %rcx
cmpq %rcx, %rax
jl 0x1b7dd
movq %r8, %r15
movq %rsi, %rbx
movq %rdx, %r13
movb 0x48(%rsp), %r14b
movq 0x40(%rsp), %rbp
testb %r14b, %r14b
je 0x1b77c
movq %rbx, %rsi
callq 0x16260
jmp 0x1b792
leaq 0x10(%rbx), %rcx
movl (%rbx), %esi
movl $0x4, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x19cd9
cmpq $0x40000000, %rbp # imm = 0x40000000
jae 0x1b7f9
testq %rax, %rax
je 0x1b815
movzbl %r14b, %ecx
movl %r12d, 0x54(%rax)
movl %r15d, 0x58(%rax)
movq (%rsp), %rdx
movl %edx, 0x5c(%rax)
movl %ebp, 0x60(%rax)
movl %ecx, 0x64(%rax)
movl $0x1f, 0x50(%rax)
movq %rbx, 0x98(%rax)
movq %r13, 0xa0(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2ee2b(%rip), %rdi # 0x4a60f
leaq 0x2ee6f(%rip), %rdx # 0x4a65a
leaq 0x31045(%rip), %rcx # 0x4c837
movl $0xb3e, %esi # imm = 0xB3E
jmp 0x1b82f
leaq 0x2ee0f(%rip), %rdi # 0x4a60f
leaq 0x2ee53(%rip), %rdx # 0x4a65a
leaq 0x31050(%rip), %rcx # 0x4c85e
movl $0xb43, %esi # imm = 0xB43
jmp 0x1b82f
leaq 0x30fbc(%rip), %rdi # 0x4c7d8
leaq 0x2ee37(%rip), %rdx # 0x4a65a
leaq 0x30ffe(%rip), %rcx # 0x4c828
movl $0x70, %esi
xorl %eax, %eax
callq 0x17c70
| ggml_set_impl:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov [rsp+38h+var_38], r9
mov r12, rcx
mov rax, [rsi+18h]
imul rax, [rsi+10h]
imul rax, [rsi+20h]
imul rax, [rsi+28h]
mov rcx, [rdx+18h]
imul rcx, [rdx+10h]
imul rcx, [rdx+20h]
imul rcx, [rdx+28h]
cmp rax, rcx
jl loc_1B7DD
mov r15, r8
mov rbx, rsi
mov r13, rdx
mov r14b, [rsp+38h+arg_8]
mov rbp, [rsp+38h+arg_0]
test r14b, r14b
jz short loc_1B77C
mov rsi, rbx
call _ggml_view_tensor
jmp short loc_1B792
loc_1B77C:
lea rcx, [rbx+10h]
mov esi, [rbx]
mov edx, 4
xor r8d, r8d
xor r9d, r9d
call ggml_new_tensor_impl
loc_1B792:
cmp rbp, 40000000h
jnb short loc_1B7F9
test rax, rax
jz short loc_1B815
movzx ecx, r14b
mov [rax+54h], r12d
mov [rax+58h], r15d
mov rdx, [rsp+38h+var_38]
mov [rax+5Ch], edx
mov [rax+60h], ebp
mov [rax+64h], ecx
mov dword ptr [rax+50h], 1Fh
mov [rax+98h], rbx
mov [rax+0A0h], r13
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1B7DD:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlNelementsA; "ggml_nelements(a) >= ggml_nelements(b)"
mov esi, 0B3Eh
jmp short loc_1B82F
loc_1B7F9:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aOffsetSizeT130; "offset < (size_t)(1 << 30)"
mov esi, 0B43h
jmp short loc_1B82F
loc_1B815:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aTensorNull; "tensor != NULL"
mov esi, 70h ; 'p'
loc_1B82F:
xor eax, eax
call _ggml_abort
| long long ggml_set_impl(
long long a1,
long long a2,
_QWORD *a3,
int a4,
int a5,
int a6,
unsigned long long a7,
unsigned __int8 a8)
{
long long result; // rax
const char *v12; // rdi
const char *v13; // rcx
int v14; // esi
if ( *(_QWORD *)(a2 + 40) * *(_QWORD *)(a2 + 32) * *(_QWORD *)(a2 + 16) * *(_QWORD *)(a2 + 24) < a3[5]
* a3[4]
* a3[2]
* a3[3] )
{
v12 = "/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml.c";
v13 = "ggml_nelements(a) >= ggml_nelements(b)";
v14 = 2878;
goto LABEL_11;
}
if ( a8 )
result = ggml_view_tensor(a1, a2);
else
result = ggml_new_tensor_impl(a1, *(_DWORD *)a2, 4, (_QWORD *)(a2 + 16), 0LL, 0LL);
if ( a7 >= 0x40000000 )
{
v12 = "/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml.c";
v13 = "offset < (size_t)(1 << 30)";
v14 = 2883;
goto LABEL_11;
}
if ( !result )
{
v12 = "/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml-impl.h";
v13 = "tensor != NULL";
v14 = 112;
LABEL_11:
ggml_abort((_DWORD)v12, v14, (unsigned int)"GGML_ASSERT(%s) failed", (_DWORD)v13, a5, a6);
}
*(_DWORD *)(result + 84) = a4;
*(_DWORD *)(result + 88) = a5;
*(_DWORD *)(result + 92) = a6;
*(_DWORD *)(result + 96) = a7;
*(_DWORD *)(result + 100) = a8;
*(_DWORD *)(result + 80) = 31;
*(_QWORD *)(result + 152) = a2;
*(_QWORD *)(result + 160) = a3;
return result;
}
| ggml_set_impl:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV qword ptr [RSP],R9
MOV R12,RCX
MOV RAX,qword ptr [RSI + 0x18]
IMUL RAX,qword ptr [RSI + 0x10]
IMUL RAX,qword ptr [RSI + 0x20]
IMUL RAX,qword ptr [RSI + 0x28]
MOV RCX,qword ptr [RDX + 0x18]
IMUL RCX,qword ptr [RDX + 0x10]
IMUL RCX,qword ptr [RDX + 0x20]
IMUL RCX,qword ptr [RDX + 0x28]
CMP RAX,RCX
JL 0x0011b7dd
MOV R15,R8
MOV RBX,RSI
MOV R13,RDX
MOV R14B,byte ptr [RSP + 0x48]
MOV RBP,qword ptr [RSP + 0x40]
TEST R14B,R14B
JZ 0x0011b77c
MOV RSI,RBX
CALL 0x00116260
JMP 0x0011b792
LAB_0011b77c:
LEA RCX,[RBX + 0x10]
MOV ESI,dword ptr [RBX]
MOV EDX,0x4
XOR R8D,R8D
XOR R9D,R9D
CALL 0x00119cd9
LAB_0011b792:
CMP RBP,0x40000000
JNC 0x0011b7f9
TEST RAX,RAX
JZ 0x0011b815
MOVZX ECX,R14B
MOV dword ptr [RAX + 0x54],R12D
MOV dword ptr [RAX + 0x58],R15D
MOV RDX,qword ptr [RSP]
MOV dword ptr [RAX + 0x5c],EDX
MOV dword ptr [RAX + 0x60],EBP
MOV dword ptr [RAX + 0x64],ECX
MOV dword ptr [RAX + 0x50],0x1f
MOV qword ptr [RAX + 0x98],RBX
MOV qword ptr [RAX + 0xa0],R13
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0011b7dd:
LEA RDI,[0x14a60f]
LEA RDX,[0x14a65a]
LEA RCX,[0x14c837]
MOV ESI,0xb3e
JMP 0x0011b82f
LAB_0011b7f9:
LEA RDI,[0x14a60f]
LEA RDX,[0x14a65a]
LEA RCX,[0x14c85e]
MOV ESI,0xb43
JMP 0x0011b82f
LAB_0011b815:
LEA RDI,[0x14c7d8]
LEA RDX,[0x14a65a]
LEA RCX,[0x14c828]
MOV ESI,0x70
LAB_0011b82f:
XOR EAX,EAX
CALL 0x00117c70
|
void ggml_set_impl(int8 param_1,int4 *param_2,long param_3,int4 param_4,
int4 param_5,int4 param_6,ulong param_7,byte param_8)
{
long lVar1;
char *pcVar2;
int8 uVar3;
char *pcVar4;
if (*(long *)(param_2 + 6) * *(long *)(param_2 + 4) * *(long *)(param_2 + 8) *
*(long *)(param_2 + 10) <
*(long *)(param_3 + 0x18) * *(long *)(param_3 + 0x10) * *(long *)(param_3 + 0x20) *
*(long *)(param_3 + 0x28)) {
pcVar4 = "/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml.c";
pcVar2 = "ggml_nelements(a) >= ggml_nelements(b)";
uVar3 = 0xb3e;
}
else {
if (param_8 == 0) {
lVar1 = ggml_new_tensor_impl(param_1,*param_2,4,param_2 + 4,0,0);
}
else {
lVar1 = ggml_view_tensor(param_1,param_2);
}
if (param_7 < 0x40000000) {
if (lVar1 != 0) {
*(int4 *)(lVar1 + 0x54) = param_4;
*(int4 *)(lVar1 + 0x58) = param_5;
*(int4 *)(lVar1 + 0x5c) = param_6;
*(int *)(lVar1 + 0x60) = (int)param_7;
*(uint *)(lVar1 + 100) = (uint)param_8;
*(int4 *)(lVar1 + 0x50) = 0x1f;
*(int4 **)(lVar1 + 0x98) = param_2;
*(long *)(lVar1 + 0xa0) = param_3;
return;
}
pcVar4 = "/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml-impl.h";
pcVar2 = "tensor != NULL";
uVar3 = 0x70;
}
else {
pcVar4 = "/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml.c";
pcVar2 = "offset < (size_t)(1 << 30)";
uVar3 = 0xb43;
}
}
/* WARNING: Subroutine does not return */
ggml_abort(pcVar4,uVar3,"GGML_ASSERT(%s) failed",pcVar2);
}
| |
53,961 | lshift | eloqsql/strings/dtoa.c | static Bigint *lshift(Bigint *b, int k, Stack_alloc *alloc)
{
int i, k1, n, n1;
Bigint *b1;
ULong *x, *x1, *xe, z;
n= k >> 5;
k1= b->k;
n1= n + b->wds + 1;
for (i= b->maxwds; n1 > i; i<<= 1)
k1++;
b1= Balloc(k1, alloc);
x1= b1->p.x;
for (i= 0; i < n; i++)
*x1++= 0;
x= b->p.x;
xe= x + b->wds;
if (k&= 0x1f)
{
k1= 32 - k;
z= 0;
do
{
*x1++= *x << k | z;
z= *x++ >> k1;
}
while (x < xe);
if ((*x1= z))
++n1;
}
else
do
*x1++= *x++;
while (x < xe);
b1->wds= n1 - 1;
Bfree(b, alloc);
return b1;
} | O3 | c | lshift:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r15d
movq %rdi, %r14
movl %esi, %r12d
shrl $0x5, %r12d
movl 0x8(%rdi), %edi
movl 0xc(%r14), %eax
movl 0x14(%r14), %ebx
addl %r12d, %ebx
cmpl %eax, %ebx
jl 0x5fd11
incl %edi
addl %eax, %eax
jmp 0x5fd07
movq %rdx, -0x38(%rbp)
movq %rdx, %rsi
callq 0x5f8b4
movq (%rax), %r13
cmpl $0x20, %r15d
jb 0x5fd48
decl %r12d
leaq 0x4(,%r12,4), %rdx
movq %r13, %rdi
xorl %esi, %esi
movq %rax, -0x30(%rbp)
callq 0x241d0
movq -0x30(%rbp), %rax
leaq 0x4(%r13,%r12,4), %r13
movq (%r14), %rdx
movslq 0x14(%r14), %rcx
leaq (%rdx,%rcx,4), %rsi
andl $0x1f, %r15d
je 0x5fd94
movl $0x20, %r9d
subl %r15d, %r9d
xorl %edi, %edi
movl (%rdx), %r8d
movl %r15d, %ecx
shll %cl, %r8d
orl %edi, %r8d
movl %r8d, (%r13)
addq $0x4, %r13
movl (%rdx), %edi
addq $0x4, %rdx
movl %r9d, %ecx
shrl %cl, %edi
cmpq %rsi, %rdx
jb 0x5fd64
movl %edi, (%r13)
cmpl $0x1, %edi
sbbl $-0x1, %ebx
jmp 0x5fda7
movl (%rdx), %ecx
addq $0x4, %rdx
movl %ecx, (%r13)
addq $0x4, %r13
cmpq %rsi, %rdx
jb 0x5fd94
movl %ebx, 0x14(%rax)
movq %r14, %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rbx
callq 0x5fcad
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| lshift:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r15d, esi
mov r14, rdi
mov r12d, esi
shr r12d, 5
mov edi, [rdi+8]
mov eax, [r14+0Ch]
mov ebx, [r14+14h]
add ebx, r12d
loc_5FD07:
cmp ebx, eax
jl short loc_5FD11
inc edi
add eax, eax
jmp short loc_5FD07
loc_5FD11:
mov [rbp+var_38], rdx
mov rsi, rdx
call Balloc
mov r13, [rax]
cmp r15d, 20h ; ' '
jb short loc_5FD48
dec r12d
lea rdx, ds:4[r12*4]
mov rdi, r13
xor esi, esi
mov [rbp+var_30], rax
call _memset
mov rax, [rbp+var_30]
lea r13, [r13+r12*4+4]
loc_5FD48:
mov rdx, [r14]
movsxd rcx, dword ptr [r14+14h]
lea rsi, [rdx+rcx*4]
and r15d, 1Fh
jz short loc_5FD94
mov r9d, 20h ; ' '
sub r9d, r15d
xor edi, edi
loc_5FD64:
mov r8d, [rdx]
mov ecx, r15d
shl r8d, cl
or r8d, edi
mov [r13+0], r8d
add r13, 4
mov edi, [rdx]
add rdx, 4
mov ecx, r9d
shr edi, cl
cmp rdx, rsi
jb short loc_5FD64
mov [r13+0], edi
cmp edi, 1
sbb ebx, 0FFFFFFFFh
jmp short loc_5FDA7
loc_5FD94:
mov ecx, [rdx]
add rdx, 4
mov [r13+0], ecx
add r13, 4
cmp rdx, rsi
jb short loc_5FD94
loc_5FDA7:
mov [rax+14h], ebx
mov rdi, r14
mov rsi, [rbp+var_38]
mov rbx, rax
call Bfree
mov rax, rbx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long lshift(unsigned long long a1, unsigned int a2, unsigned long long *a3)
{
char v3; // r15
int v5; // edi
int v6; // eax
int v7; // ebx
long long v8; // rax
int *v9; // r13
long long v10; // r12
int *v11; // rdx
unsigned long long v12; // rsi
int v13; // r15d
int v14; // edi
unsigned int v15; // edi
int v16; // ecx
long long v17; // rbx
long long v20; // [rsp+10h] [rbp-30h]
v3 = a2;
v5 = *(_DWORD *)(a1 + 8);
v6 = *(_DWORD *)(a1 + 12);
v7 = (a2 >> 5) + *(_DWORD *)(a1 + 20);
while ( v7 >= v6 )
{
++v5;
v6 *= 2;
}
v8 = Balloc(v5, (long long)a3);
v9 = *(int **)v8;
if ( a2 >= 0x20 )
{
v10 = (a2 >> 5) - 1;
v20 = v8;
memset(*(_QWORD *)v8, 0LL, 4 * v10 + 4);
v8 = v20;
v9 += v10 + 1;
}
v11 = *(int **)a1;
v12 = *(_QWORD *)a1 + 4LL * *(int *)(a1 + 20);
v13 = v3 & 0x1F;
if ( v13 )
{
v14 = 0;
do
{
*v9++ = v14 | (*v11 << v13);
v15 = *v11++;
v14 = v15 >> (32 - v13);
}
while ( (unsigned long long)v11 < v12 );
*v9 = v14;
v7 -= (v14 == 0) - 1;
}
else
{
do
{
v16 = *v11++;
*v9++ = v16;
}
while ( (unsigned long long)v11 < v12 );
}
*(_DWORD *)(v8 + 20) = v7;
v17 = v8;
Bfree(a1, a3);
return v17;
}
| lshift:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R15D,ESI
MOV R14,RDI
MOV R12D,ESI
SHR R12D,0x5
MOV EDI,dword ptr [RDI + 0x8]
MOV EAX,dword ptr [R14 + 0xc]
MOV EBX,dword ptr [R14 + 0x14]
ADD EBX,R12D
LAB_0015fd07:
CMP EBX,EAX
JL 0x0015fd11
INC EDI
ADD EAX,EAX
JMP 0x0015fd07
LAB_0015fd11:
MOV qword ptr [RBP + -0x38],RDX
MOV RSI,RDX
CALL 0x0015f8b4
MOV R13,qword ptr [RAX]
CMP R15D,0x20
JC 0x0015fd48
DEC R12D
LEA RDX,[0x4 + R12*0x4]
MOV RDI,R13
XOR ESI,ESI
MOV qword ptr [RBP + -0x30],RAX
CALL 0x001241d0
MOV RAX,qword ptr [RBP + -0x30]
LEA R13,[R13 + R12*0x4 + 0x4]
LAB_0015fd48:
MOV RDX,qword ptr [R14]
MOVSXD RCX,dword ptr [R14 + 0x14]
LEA RSI,[RDX + RCX*0x4]
AND R15D,0x1f
JZ 0x0015fd94
MOV R9D,0x20
SUB R9D,R15D
XOR EDI,EDI
LAB_0015fd64:
MOV R8D,dword ptr [RDX]
MOV ECX,R15D
SHL R8D,CL
OR R8D,EDI
MOV dword ptr [R13],R8D
ADD R13,0x4
MOV EDI,dword ptr [RDX]
ADD RDX,0x4
MOV ECX,R9D
SHR EDI,CL
CMP RDX,RSI
JC 0x0015fd64
MOV dword ptr [R13],EDI
CMP EDI,0x1
SBB EBX,-0x1
JMP 0x0015fda7
LAB_0015fd94:
MOV ECX,dword ptr [RDX]
ADD RDX,0x4
MOV dword ptr [R13],ECX
ADD R13,0x4
CMP RDX,RSI
JC 0x0015fd94
LAB_0015fda7:
MOV dword ptr [RAX + 0x14],EBX
MOV RDI,R14
MOV RSI,qword ptr [RBP + -0x38]
MOV RBX,RAX
CALL 0x0015fcad
MOV RAX,RBX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 * lshift(int8 *param_1,uint param_2,int8 param_3)
{
uint *puVar1;
sbyte sVar2;
int iVar3;
int8 *puVar4;
uint *puVar5;
int iVar6;
uint uVar7;
ulong uVar8;
uint *__s;
iVar6 = *(int *)((long)param_1 + 0x14) + (param_2 >> 5);
for (iVar3 = *(int *)((long)param_1 + 0xc); iVar3 <= iVar6; iVar3 = iVar3 * 2) {
}
puVar4 = (int8 *)Balloc();
__s = (uint *)*puVar4;
if (0x1f < param_2) {
uVar8 = (ulong)((param_2 >> 5) - 1);
memset(__s,0,uVar8 * 4 + 4);
__s = __s + uVar8 + 1;
}
puVar5 = (uint *)*param_1;
puVar1 = puVar5 + *(int *)((long)param_1 + 0x14);
if ((param_2 & 0x1f) == 0) {
do {
uVar7 = *puVar5;
puVar5 = puVar5 + 1;
*__s = uVar7;
__s = __s + 1;
} while (puVar5 < puVar1);
}
else {
sVar2 = (sbyte)(param_2 & 0x1f);
uVar7 = 0;
do {
*__s = *puVar5 << sVar2 | uVar7;
__s = __s + 1;
uVar7 = *puVar5;
puVar5 = puVar5 + 1;
uVar7 = uVar7 >> (0x20U - sVar2 & 0x1f);
} while (puVar5 < puVar1);
*__s = uVar7;
iVar6 = (iVar6 + 1) - (uint)(uVar7 == 0);
}
*(int *)((long)puVar4 + 0x14) = iVar6;
Bfree(param_1,param_3);
return puVar4;
}
| |
53,962 | my_casedn_8bit | eloqsql/strings/ctype-simple.c | size_t my_casedn_8bit(CHARSET_INFO * cs, const char *src, size_t srclen,
char *dst, size_t dstlen __attribute__((unused)))
{
const char *end= src + srclen;
register const uchar *map=cs->to_lower;
DBUG_ASSERT(srclen <= dstlen);
for ( ; src != end ; src++)
*dst++= (char) map[(uchar) *src];
return srclen;
} | O0 | c | my_casedn_8bit:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0xa6f32
jmp 0xa6f34
movq -0x10(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0xa6f6b
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
movb (%rax,%rcx), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xa6f34
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_casedn_8bit:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_30], rax
mov rax, [rbp+var_8]
mov rax, [rax+48h]
mov [rbp+var_38], rax
jmp short $+2
loc_A6F32:
jmp short $+2
loc_A6F34:
mov rax, [rbp+var_10]
cmp rax, [rbp+var_30]
jz short loc_A6F6B
mov rax, [rbp+var_38]
mov rcx, [rbp+var_10]
movzx ecx, byte ptr [rcx]
mov cl, [rax+rcx]
mov rax, [rbp+var_20]
mov rdx, rax
add rdx, 1
mov [rbp+var_20], rdx
mov [rax], cl
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp short loc_A6F34
loc_A6F6B:
mov rax, [rbp+var_18]
pop rbp
retn
| long long my_casedn_8bit(long long a1, unsigned __int8 *a2, long long a3, _BYTE *a4)
{
_BYTE *v4; // rax
long long v6; // [rsp+0h] [rbp-38h]
unsigned __int8 *v8; // [rsp+28h] [rbp-10h]
v8 = a2;
v6 = *(_QWORD *)(a1 + 72);
while ( v8 != &a2[a3] )
{
v4 = a4++;
*v4 = *(_BYTE *)(v6 + *v8++);
}
return a3;
}
| my_casedn_8bit:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x48]
MOV qword ptr [RBP + -0x38],RAX
JMP 0x001a6f32
LAB_001a6f32:
JMP 0x001a6f34
LAB_001a6f34:
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x30]
JZ 0x001a6f6b
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RCX]
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x20],RDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001a6f34
LAB_001a6f6b:
MOV RAX,qword ptr [RBP + -0x18]
POP RBP
RET
|
long my_casedn_8bit(long param_1,byte *param_2,long param_3,int1 *param_4)
{
long lVar1;
int1 *local_28;
byte *local_18;
lVar1 = *(long *)(param_1 + 0x48);
local_28 = param_4;
for (local_18 = param_2; local_18 != param_2 + param_3; local_18 = local_18 + 1) {
*local_28 = *(int1 *)(lVar1 + (ulong)*local_18);
local_28 = local_28 + 1;
}
return param_3;
}
| |
53,963 | ma_pvio_tls_compare_fp | eloqsql/libmariadb/libmariadb/ma_tls.c | static my_bool ma_pvio_tls_compare_fp(const char *cert_fp,
unsigned int cert_fp_len,
const char *fp, unsigned int fp_len)
{
char *p= (char *)fp,
*c;
/* check length */
if (cert_fp_len != 20)
return 1;
/* We support two formats:
2 digits hex numbers, separated by colons (length=59)
20 * 2 digits hex numbers without separators (length = 40)
*/
if (fp_len != (strchr(fp, ':') ? 59 : 40))
return 1;
for(c= (char *)cert_fp; c < cert_fp + cert_fp_len; c++)
{
signed char d1, d2;
if (*p == ':')
p++;
if (p - fp > (int)fp_len -1)
return 1;
if ((d1 = ma_hex2int(*p)) == - 1 ||
(d2 = ma_hex2int(*(p+1))) == -1 ||
(char)(d1 * 16 + d2) != *c)
return 1;
p+= 2;
}
return 0;
} | O3 | c | ma_pvio_tls_compare_fp:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movb $0x1, %bl
cmpl $0x14, %esi
jne 0x418d7
movl %ecx, %r14d
movq %rdx, %r15
movq %rdi, %r12
movq %rdx, %rdi
movl $0x3a, %esi
callq 0x36500
testq %rax, %rax
movl $0x28, %eax
movl $0x3b, %ecx
cmovel %eax, %ecx
cmpl %r14d, %ecx
jne 0x418d7
decl %r14d
xorl %eax, %eax
movq %r15, %rdx
xorl %ecx, %ecx
cmpb $0x3a, (%rdx)
sete %cl
addq %rdx, %rcx
movq %rcx, %rdx
subq %r15, %rdx
cmpq %r14, %rdx
jg 0x418d7
movb (%rcx), %sil
leal -0x30(%rsi), %edx
cmpb $0xa, %dl
jb 0x4188a
leal -0x41(%rsi), %edx
cmpb $0x5, %dl
ja 0x4187c
addb $-0x37, %sil
jmp 0x41888
leal -0x67(%rsi), %edx
cmpb $-0x6, %dl
jb 0x418d7
addb $-0x57, %sil
movl %esi, %edx
movb 0x1(%rcx), %sil
leal -0x30(%rsi), %edi
cmpb $0xa, %dil
jb 0x418b5
leal -0x41(%rsi), %edi
cmpb $0x5, %dil
ja 0x418a6
addb $-0x37, %sil
jmp 0x418b3
leal -0x67(%rsi), %edi
cmpb $-0x6, %dil
jb 0x418d7
addb $-0x57, %sil
movl %esi, %edi
shlb $0x4, %dl
addb %dil, %dl
cmpb (%r12,%rax), %dl
jne 0x418d7
addq $0x2, %rcx
incq %rax
movq %rcx, %rdx
cmpq $0x14, %rax
jne 0x4184d
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| ma_pvio_tls_compare_fp:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov bl, 1
cmp esi, 14h
jnz loc_418D7
mov r14d, ecx
mov r15, rdx
mov r12, rdi
mov rdi, rdx
mov esi, 3Ah ; ':'
call _strchr
test rax, rax
mov eax, 28h ; '('
mov ecx, 3Bh ; ';'
cmovz ecx, eax
cmp ecx, r14d
jnz loc_418D7
dec r14d
xor eax, eax
mov rdx, r15
loc_4184D:
xor ecx, ecx
cmp byte ptr [rdx], 3Ah ; ':'
setz cl
add rcx, rdx
mov rdx, rcx
sub rdx, r15
cmp rdx, r14
jg short loc_418D7
mov sil, [rcx]
lea edx, [rsi-30h]
cmp dl, 0Ah
jb short loc_4188A
lea edx, [rsi-41h]
cmp dl, 5
ja short loc_4187C
add sil, 0C9h
jmp short loc_41888
loc_4187C:
lea edx, [rsi-67h]
cmp dl, 0FAh
jb short loc_418D7
add sil, 0A9h
loc_41888:
mov edx, esi
loc_4188A:
mov sil, [rcx+1]
lea edi, [rsi-30h]
cmp dil, 0Ah
jb short loc_418B5
lea edi, [rsi-41h]
cmp dil, 5
ja short loc_418A6
add sil, 0C9h
jmp short loc_418B3
loc_418A6:
lea edi, [rsi-67h]
cmp dil, 0FAh
jb short loc_418D7
add sil, 0A9h
loc_418B3:
mov edi, esi
loc_418B5:
shl dl, 4
add dl, dil
cmp dl, [r12+rax]
jnz short loc_418D7
add rcx, 2
inc rax
mov rdx, rcx
cmp rax, 14h
jnz loc_4184D
xor ebx, ebx
loc_418D7:
mov eax, ebx
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long ma_pvio_tls_compare_fp(long long a1, int a2, _BYTE *a3, long long a4)
{
unsigned int v4; // ebx
int v5; // r14d
long long v8; // rax
int v9; // ecx
long long v10; // r14
long long v11; // rax
_BYTE *v12; // rdx
char *v13; // rcx
char v14; // si
unsigned __int8 v15; // dl
unsigned __int8 v16; // si
char v17; // si
char v18; // di
char v19; // si
LOBYTE(v4) = 1;
if ( a2 == 20 )
{
v5 = a4;
v8 = strchr(a3, 58LL, a3, a4);
v9 = 59;
if ( !v8 )
v9 = 40;
if ( v9 == v5 )
{
v10 = (unsigned int)(v5 - 1);
v11 = 0LL;
v12 = a3;
while ( 1 )
{
v13 = &v12[*v12 == 58];
if ( v13 - a3 > v10 )
break;
v14 = *v13;
v15 = *v13 - 48;
if ( v15 >= 0xAu )
{
if ( (unsigned __int8)(v14 - 65) > 5u )
{
if ( (unsigned __int8)(v14 - 103) < 0xFAu )
return v4;
v16 = v14 - 87;
}
else
{
v16 = v14 - 55;
}
v15 = v16;
}
v17 = v13[1];
v18 = v17 - 48;
if ( (unsigned __int8)(v17 - 48) >= 0xAu )
{
if ( (unsigned __int8)(v17 - 65) > 5u )
{
if ( (unsigned __int8)(v17 - 103) < 0xFAu )
return v4;
v19 = v17 - 87;
}
else
{
v19 = v17 - 55;
}
v18 = v19;
}
if ( v18 + 16 * v15 != *(_BYTE *)(a1 + v11) )
break;
++v11;
v12 = v13 + 2;
if ( v11 == 20 )
return 0;
}
}
}
return v4;
}
| ma_pvio_tls_compare_fp:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV BL,0x1
CMP ESI,0x14
JNZ 0x001418d7
MOV R14D,ECX
MOV R15,RDX
MOV R12,RDI
MOV RDI,RDX
MOV ESI,0x3a
CALL 0x00136500
TEST RAX,RAX
MOV EAX,0x28
MOV ECX,0x3b
CMOVZ ECX,EAX
CMP ECX,R14D
JNZ 0x001418d7
DEC R14D
XOR EAX,EAX
MOV RDX,R15
LAB_0014184d:
XOR ECX,ECX
CMP byte ptr [RDX],0x3a
SETZ CL
ADD RCX,RDX
MOV RDX,RCX
SUB RDX,R15
CMP RDX,R14
JG 0x001418d7
MOV SIL,byte ptr [RCX]
LEA EDX,[RSI + -0x30]
CMP DL,0xa
JC 0x0014188a
LEA EDX,[RSI + -0x41]
CMP DL,0x5
JA 0x0014187c
ADD SIL,0xc9
JMP 0x00141888
LAB_0014187c:
LEA EDX,[RSI + -0x67]
CMP DL,0xfa
JC 0x001418d7
ADD SIL,0xa9
LAB_00141888:
MOV EDX,ESI
LAB_0014188a:
MOV SIL,byte ptr [RCX + 0x1]
LEA EDI,[RSI + -0x30]
CMP DIL,0xa
JC 0x001418b5
LEA EDI,[RSI + -0x41]
CMP DIL,0x5
JA 0x001418a6
ADD SIL,0xc9
JMP 0x001418b3
LAB_001418a6:
LEA EDI,[RSI + -0x67]
CMP DIL,0xfa
JC 0x001418d7
ADD SIL,0xa9
LAB_001418b3:
MOV EDI,ESI
LAB_001418b5:
SHL DL,0x4
ADD DL,DIL
CMP DL,byte ptr [R12 + RAX*0x1]
JNZ 0x001418d7
ADD RCX,0x2
INC RAX
MOV RDX,RCX
CMP RAX,0x14
JNZ 0x0014184d
XOR EBX,EBX
LAB_001418d7:
MOV EAX,EBX
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
ulong ma_pvio_tls_compare_fp(long param_1,int param_2,char *param_3,int param_4)
{
char cVar1;
char *pcVar2;
long lVar3;
int iVar4;
int8 unaff_RBX;
ulong uVar5;
byte bVar6;
byte bVar7;
uVar5 = CONCAT71((int7)((ulong)unaff_RBX >> 8),1);
if (param_2 == 0x14) {
pcVar2 = strchr(param_3,0x3a);
iVar4 = 0x3b;
if (pcVar2 == (char *)0x0) {
iVar4 = 0x28;
}
if (iVar4 == param_4) {
lVar3 = 0;
pcVar2 = param_3;
do {
pcVar2 = pcVar2 + (*pcVar2 == ':');
if ((long)(ulong)(param_4 - 1) < (long)pcVar2 - (long)param_3) goto LAB_001418d7;
cVar1 = *pcVar2;
bVar6 = cVar1 - 0x30;
if (9 < bVar6) {
if ((byte)(cVar1 + 0xbfU) < 6) {
bVar6 = cVar1 - 0x37;
}
else {
if ((byte)(cVar1 + 0x99U) < 0xfa) goto LAB_001418d7;
bVar6 = cVar1 + 0xa9;
}
}
cVar1 = pcVar2[1];
bVar7 = cVar1 - 0x30;
if (9 < bVar7) {
if ((byte)(cVar1 + 0xbfU) < 6) {
bVar7 = cVar1 - 0x37;
}
else {
if ((byte)(cVar1 + 0x99U) < 0xfa) goto LAB_001418d7;
bVar7 = cVar1 + 0xa9;
}
}
if ((byte)(bVar6 * '\x10' + bVar7) != *(char *)(param_1 + lVar3)) goto LAB_001418d7;
pcVar2 = pcVar2 + 2;
lVar3 = lVar3 + 1;
} while (lVar3 != 0x14);
uVar5 = 0;
}
}
LAB_001418d7:
return uVar5 & 0xffffffff;
}
| |
53,964 | my_caseup_8bit | eloqsql/strings/ctype-simple.c | size_t my_caseup_8bit(CHARSET_INFO * cs, const char *src, size_t srclen,
char *dst, size_t dstlen __attribute__((unused)))
{
const char *end= src + srclen;
register const uchar *map= cs->to_upper;
DBUG_ASSERT(srclen <= dstlen);
for ( ; src != end ; src++)
*dst++= (char) map[(uchar) *src];
return srclen;
} | O3 | c | my_caseup_8bit:
movq %rdx, %rax
testq %rdx, %rdx
je 0x3715b
pushq %rbp
movq %rsp, %rbp
movq 0x50(%rdi), %rdx
xorl %edi, %edi
movzbl (%rsi,%rdi), %r8d
movb (%rdx,%r8), %r8b
movb %r8b, (%rcx,%rdi)
incq %rdi
cmpq %rdi, %rax
jne 0x37145
popq %rbp
retq
| my_caseup_8bit:
mov rax, rdx
test rdx, rdx
jz short locret_3715B
push rbp
mov rbp, rsp
mov rdx, [rdi+50h]
xor edi, edi
loc_37145:
movzx r8d, byte ptr [rsi+rdi]
mov r8b, [rdx+r8]
mov [rcx+rdi], r8b
inc rdi
cmp rax, rdi
jnz short loc_37145
pop rbp
locret_3715B:
retn
| long long my_caseup_8bit(long long a1, long long a2, long long a3, long long a4)
{
long long result; // rax
long long v5; // rdx
long long v6; // rdi
result = a3;
if ( a3 )
{
v5 = *(_QWORD *)(a1 + 80);
v6 = 0LL;
do
{
*(_BYTE *)(a4 + v6) = *(_BYTE *)(v5 + *(unsigned __int8 *)(a2 + v6));
++v6;
}
while ( result != v6 );
}
return result;
}
| my_caseup_8bit:
MOV RAX,RDX
TEST RDX,RDX
JZ 0x0013715b
PUSH RBP
MOV RBP,RSP
MOV RDX,qword ptr [RDI + 0x50]
XOR EDI,EDI
LAB_00137145:
MOVZX R8D,byte ptr [RSI + RDI*0x1]
MOV R8B,byte ptr [RDX + R8*0x1]
MOV byte ptr [RCX + RDI*0x1],R8B
INC RDI
CMP RAX,RDI
JNZ 0x00137145
POP RBP
LAB_0013715b:
RET
|
void my_caseup_8bit(long param_1,long param_2,long param_3,long param_4)
{
long lVar1;
long lVar2;
if (param_3 != 0) {
lVar1 = *(long *)(param_1 + 0x50);
lVar2 = 0;
do {
*(int1 *)(param_4 + lVar2) = *(int1 *)(lVar1 + (ulong)*(byte *)(param_2 + lVar2));
lVar2 = lVar2 + 1;
} while (param_3 != lVar2);
}
return;
}
| |
53,965 | ELFIO::endianess_convertor::operator()(unsigned int) const | EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/include/elfio/elfio_utils.hpp | uint32_t
operator()( uint32_t value ) const
{
if ( !need_conversion ) {
return value;
}
value =
( ( value & 0x000000FF ) << 24 ) |
( ( value & 0x0000FF00 ) << 8 ) |
( ( value & 0x00FF0000 ) >> 8 ) |
( ( value & 0xFF000000 ) >> 24 );
return value;
} | O0 | cpp | ELFIO::endianess_convertor::operator()(unsigned int) const:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq -0x10(%rsp), %rax
testb $0x1, (%rax)
jne 0x1799d
movl -0x14(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0x179e2
movl -0x14(%rsp), %eax
andl $0xff, %eax
shll $0x18, %eax
movl -0x14(%rsp), %ecx
andl $0xff00, %ecx # imm = 0xFF00
shll $0x8, %ecx
orl %ecx, %eax
movl -0x14(%rsp), %ecx
andl $0xff0000, %ecx # imm = 0xFF0000
shrl $0x8, %ecx
orl %ecx, %eax
movl -0x14(%rsp), %ecx
andl $0xff000000, %ecx # imm = 0xFF000000
shrl $0x18, %ecx
orl %ecx, %eax
movl %eax, -0x14(%rsp)
movl -0x14(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
| _ZNK5ELFIO19endianess_convertorclEj:
mov [rsp+var_10], rdi
mov [rsp+var_14], esi
mov rax, [rsp+var_10]
test byte ptr [rax], 1
jnz short loc_1799D
mov eax, [rsp+var_14]
mov [rsp+var_4], eax
jmp short loc_179E2
loc_1799D:
mov eax, [rsp+var_14]
and eax, 0FFh
shl eax, 18h
mov ecx, [rsp+var_14]
and ecx, 0FF00h
shl ecx, 8
or eax, ecx
mov ecx, [rsp+var_14]
and ecx, 0FF0000h
shr ecx, 8
or eax, ecx
mov ecx, [rsp+var_14]
and ecx, 0FF000000h
shr ecx, 18h
or eax, ecx
mov [rsp+var_14], eax
mov eax, [rsp+var_14]
mov [rsp+var_4], eax
loc_179E2:
mov eax, [rsp+var_4]
retn
| long long ELFIO::endianess_convertor::operator()(_BYTE *a1, unsigned int a2)
{
unsigned int v3; // [rsp+0h] [rbp-14h]
v3 = a2;
if ( (*a1 & 1) != 0 )
return ((a2 & 0xFF000000) >> 24) | ((a2 & 0xFF0000) >> 8) | ((a2 & 0xFF00) << 8) | ((unsigned __int8)a2 << 24);
return v3;
}
| operator():
MOV qword ptr [RSP + -0x10],RDI
MOV dword ptr [RSP + -0x14],ESI
MOV RAX,qword ptr [RSP + -0x10]
TEST byte ptr [RAX],0x1
JNZ 0x0011799d
MOV EAX,dword ptr [RSP + -0x14]
MOV dword ptr [RSP + -0x4],EAX
JMP 0x001179e2
LAB_0011799d:
MOV EAX,dword ptr [RSP + -0x14]
AND EAX,0xff
SHL EAX,0x18
MOV ECX,dword ptr [RSP + -0x14]
AND ECX,0xff00
SHL ECX,0x8
OR EAX,ECX
MOV ECX,dword ptr [RSP + -0x14]
AND ECX,0xff0000
SHR ECX,0x8
OR EAX,ECX
MOV ECX,dword ptr [RSP + -0x14]
AND ECX,0xff000000
SHR ECX,0x18
OR EAX,ECX
MOV dword ptr [RSP + -0x14],EAX
MOV EAX,dword ptr [RSP + -0x14]
MOV dword ptr [RSP + -0x4],EAX
LAB_001179e2:
MOV EAX,dword ptr [RSP + -0x4]
RET
|
/* ELFIO::endianess_convertor::TEMPNAMEPLACEHOLDERVALUE(unsigned int) const */
uint __thiscall ELFIO::endianess_convertor::operator()(endianess_convertor *this,uint param_1)
{
int4 local_4;
local_4 = param_1;
if (((byte)*this & 1) != 0) {
local_4 = param_1 << 0x18 | (param_1 & 0xff00) << 8 | (param_1 & 0xff0000) >> 8 |
param_1 >> 0x18;
}
return local_4;
}
| |
53,966 | common_sampler_init(llama_model const*, common_params_sampling const&) | monkey531[P]llama/common/sampling.cpp | struct common_sampler * common_sampler_init(const struct llama_model * model, const struct common_params_sampling & params) {
const llama_vocab * vocab = llama_model_get_vocab(model);
llama_sampler_chain_params lparams = llama_sampler_chain_default_params();
lparams.no_perf = params.no_perf;
std::vector<const char *> trigger_words;
trigger_words.reserve(params.grammar_trigger_words.size());
for (const auto & str : params.grammar_trigger_words) {
trigger_words.push_back(str.word.c_str());
}
struct llama_sampler * grmr;
if (params.grammar.compare(0, 11, "%llguidance") == 0) {
#ifdef LLAMA_USE_LLGUIDANCE
grmr = llama_sampler_init_llg(vocab, "lark", params.grammar.c_str());
#else
GGML_ABORT("llguidance (cmake -DLLAMA_LLGUIDANCE=ON) is not enabled");
#endif // LLAMA_USE_LLGUIDANCE
} else {
grmr = params.grammar_lazy
? llama_sampler_init_grammar_lazy(vocab, params.grammar.c_str(), "root",
trigger_words.data(), trigger_words.size(),
params.grammar_trigger_tokens.data(), params.grammar_trigger_tokens.size())
: llama_sampler_init_grammar(vocab, params.grammar.c_str(), "root");
}
auto * result = new common_sampler {
/* .params = */ params,
/* .grmr = */ grmr,
/* .chain = */ llama_sampler_chain_init(lparams),
/* .prev = */ ring_buffer<llama_token>(std::max(32, params.n_prev)),
/* .cur = */ {},
/* .cur_p = */ {},
};
llama_sampler_chain_add(result->chain,
llama_sampler_init_logit_bias(
llama_vocab_n_tokens(vocab),
params.logit_bias.size(),
params.logit_bias.data()));
if (params.mirostat == 0) {
for (const auto & cnstr : params.samplers) {
switch (cnstr) {
case COMMON_SAMPLER_TYPE_DRY:
{
std::vector<const char *> c_breakers;
c_breakers.reserve(params.dry_sequence_breakers.size());
for (const auto & str : params.dry_sequence_breakers) {
c_breakers.push_back(str.c_str());
}
llama_sampler_chain_add(result->chain, llama_sampler_init_dry (vocab, llama_model_n_ctx_train(model), params.dry_multiplier, params.dry_base, params.dry_allowed_length, params.dry_penalty_last_n, c_breakers.data(), c_breakers.size()));
}
break;
case COMMON_SAMPLER_TYPE_TOP_K:
llama_sampler_chain_add(result->chain, llama_sampler_init_top_k (params.top_k));
break;
case COMMON_SAMPLER_TYPE_TOP_P:
llama_sampler_chain_add(result->chain, llama_sampler_init_top_p (params.top_p, params.min_keep));
break;
case COMMON_SAMPLER_TYPE_MIN_P:
llama_sampler_chain_add(result->chain, llama_sampler_init_min_p (params.min_p, params.min_keep));
break;
case COMMON_SAMPLER_TYPE_XTC:
llama_sampler_chain_add(result->chain, llama_sampler_init_xtc (params.xtc_probability, params.xtc_threshold, params.min_keep, params.seed));
break;
case COMMON_SAMPLER_TYPE_TYPICAL_P:
llama_sampler_chain_add(result->chain, llama_sampler_init_typical (params.typ_p, params.min_keep));
break;
case COMMON_SAMPLER_TYPE_TEMPERATURE:
llama_sampler_chain_add(result->chain, llama_sampler_init_temp_ext (params.temp, params.dynatemp_range, params.dynatemp_exponent));
break;
case COMMON_SAMPLER_TYPE_INFILL:
llama_sampler_chain_add(result->chain, llama_sampler_init_infill (vocab));
break;
case COMMON_SAMPLER_TYPE_PENALTIES:
llama_sampler_chain_add(result->chain, llama_sampler_init_penalties(params.penalty_last_n, params.penalty_repeat, params.penalty_freq, params.penalty_present));
break;
default:
GGML_ASSERT(false && "unknown sampler type");
}
}
llama_sampler_chain_add(result->chain, llama_sampler_init_dist(params.seed));
} else if (params.mirostat == 1) {
llama_sampler_chain_add(result->chain, llama_sampler_init_temp(params.temp));
llama_sampler_chain_add(result->chain, llama_sampler_init_mirostat(llama_vocab_n_tokens(vocab), params.seed, params.mirostat_tau, params.mirostat_eta, 100));
} else if (params.mirostat == 2) {
llama_sampler_chain_add(result->chain, llama_sampler_init_temp(params.temp));
llama_sampler_chain_add(result->chain, llama_sampler_init_mirostat_v2(params.seed, params.mirostat_tau, params.mirostat_eta));
} else {
GGML_ASSERT(false && "unknown mirostat version");
}
return result;
} | O3 | cpp | common_sampler_init(llama_model const*, common_params_sampling const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, 0x58(%rsp)
callq 0x1c450
movq %rax, 0x8(%rsp)
callq 0x1bf90
movb 0x61(%rbx), %bpl
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0xc8(%rbx), %rax
subq 0xc0(%rbx), %rax
sarq $0x3, %rax
movabsq $-0x3333333333333333, %rsi # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rsi
callq 0xd21a4
movq 0xc0(%rbx), %r15
movq 0xc8(%rbx), %r13
cmpq %r13, %r15
je 0xd0abf
leaq 0x30(%rsp), %r14
leaq 0x10(%rsp), %r12
movq (%r15), %rax
movq %rax, 0x10(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0xd2882
addq $0x28, %r15
cmpq %r13, %r15
jne 0xd0aa3
leaq 0x98(%rbx), %rdi
leaq 0x27b98(%rip), %rcx # 0xf8665
movl $0xb, %edx
xorl %esi, %esi
callq 0x1bd80
testl %eax, %eax
je 0xd0ec7
movq 0x98(%rbx), %rsi
cmpb $0x1, 0xb8(%rbx)
jne 0xd0b2e
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %r8
subq %rcx, %r8
sarq $0x3, %r8
movq 0xd8(%rbx), %r9
movq 0xe0(%rbx), %rax
subq %r9, %rax
sarq $0x2, %rax
movq %rax, (%rsp)
leaq 0x2715d(%rip), %rdx # 0xf7c7f
movq 0x8(%rsp), %rdi
callq 0x1b840
jmp 0xd0b3f
leaq 0x2714a(%rip), %rdx # 0xf7c7f
movq 0x8(%rsp), %rdi
callq 0x1b1c0
movq %rax, %r12
movl $0x1b8, %edi # imm = 0x1B8
callq 0x1ba40
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x58730
movq %r12, 0x138(%r14)
movzbl %bpl, %edi
callq 0x1b580
movq %rax, 0x140(%r14)
movl 0x4(%rbx), %eax
cmpl $0x21, %eax
movl $0x20, %esi
cmovgel %eax, %esi
movq %rsi, 0x148(%r14)
movq %r14, %rdi
addq $0x168, %rdi # imm = 0x168
xorps %xmm0, %xmm0
movups %xmm0, 0x150(%r14)
movq $0x0, 0x160(%r14)
leaq 0x10(%rsp), %rdx
callq 0x7cd16
xorps %xmm0, %xmm0
movups %xmm0, 0x1a0(%r14)
movups %xmm0, 0x190(%r14)
movups %xmm0, 0x180(%r14)
movq $0x0, 0x1b0(%r14)
movq 0x140(%r14), %r12
movq 0x8(%rsp), %rdi
callq 0x1c3d0
movq 0x120(%rbx), %rdx
movq 0x128(%rbx), %rsi
subq %rdx, %rsi
shrq $0x3, %rsi
movl %eax, %edi
callq 0x1c0f0
movq %r12, %rdi
movq %rax, %rsi
callq 0x1bb10
movl 0x54(%rbx), %eax
cmpl $0x2, %eax
je 0xd0e4f
cmpl $0x1, %eax
je 0xd0e08
testl %eax, %eax
jne 0xd0f02
movq 0x80(%rbx), %r15
movq 0x88(%rbx), %rbp
cmpq %rbp, %r15
je 0xd0e85
leaq 0x10(%rsp), %r13
movq %rbp, 0x50(%rsp)
movl (%r15), %eax
decl %eax
cmpl $0x9, %eax
ja 0xd0ee1
leaq 0x2783f(%rip), %rcx # 0xf84a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x70(%rbx), %rsi
subq 0x68(%rbx), %rsi
sarq $0x5, %rsi
movq %r13, %rdi
callq 0xd21a4
movq 0x68(%rbx), %r12
movq 0x70(%rbx), %rbp
cmpq %rbp, %r12
je 0xd0da1
movq (%r12), %rax
movq %rax, 0x60(%rsp)
movq %r13, %rdi
leaq 0x60(%rsp), %rsi
callq 0xd2882
addq $0x20, %r12
jmp 0xd0c97
movq 0x140(%r14), %r12
movl 0x34(%rbx), %edi
movss 0x38(%rbx), %xmm0
movss 0x3c(%rbx), %xmm1
movss 0x40(%rbx), %xmm2
callq 0x1b7f0
jmp 0xd0d84
movq 0x140(%r14), %r12
movss 0x24(%rbx), %xmm0
movslq 0xc(%rbx), %rdi
callq 0x1b7a0
jmp 0xd0d84
movq 0x140(%r14), %r12
movss 0x28(%rbx), %xmm0
movss 0x2c(%rbx), %xmm1
movss 0x30(%rbx), %xmm2
callq 0x1c390
jmp 0xd0d84
movq 0x140(%r14), %r12
movss 0x14(%rbx), %xmm0
movslq 0xc(%rbx), %rdi
callq 0x1b140
jmp 0xd0d84
movq 0x140(%r14), %r12
movq 0x8(%rsp), %rdi
callq 0x1bf30
jmp 0xd0d84
movq 0x140(%r14), %r12
movss 0x18(%rbx), %xmm0
movslq 0xc(%rbx), %rdi
callq 0x1be40
jmp 0xd0d84
movq 0x140(%r14), %r12
movl 0x10(%rbx), %edi
callq 0x1b450
jmp 0xd0d84
movq 0x140(%r14), %r12
movss 0x1c(%rbx), %xmm0
movss 0x20(%rbx), %xmm1
movslq 0xc(%rbx), %rdi
movl (%rbx), %esi
callq 0x1b2f0
movq %r12, %rdi
movq %rax, %rsi
callq 0x1bb10
addq $0x4, %r15
cmpq %rbp, %r15
jne 0xd0c4c
jmp 0xd0e85
movq 0x140(%r14), %r12
movq 0x58(%rsp), %rdi
callq 0x1b9e0
movss 0x44(%rbx), %xmm0
movss 0x48(%rbx), %xmm1
movl 0x4c(%rbx), %edx
movl 0x50(%rbx), %ecx
movq 0x10(%rsp), %r8
movq 0x18(%rsp), %r9
subq %r8, %r9
sarq $0x3, %r9
movq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0x1c120
movq %r12, %rdi
movq %rax, %rsi
callq 0x1bb10
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
movq 0x50(%rsp), %rbp
je 0xd0d8f
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x1ba60
jmp 0xd0d8f
movq 0x140(%r14), %r12
movss 0x28(%rbx), %xmm0
callq 0x1b620
movq %r12, %rdi
movq %rax, %rsi
callq 0x1bb10
movq 0x140(%r14), %r12
movq 0x8(%rsp), %rdi
callq 0x1c3d0
movl (%rbx), %esi
movss 0x58(%rbx), %xmm0
movss 0x5c(%rbx), %xmm1
movl %eax, %edi
movl $0x64, %edx
callq 0x1c440
jmp 0xd0e93
movq 0x140(%r14), %r15
movss 0x28(%rbx), %xmm0
callq 0x1b620
movq %r15, %rdi
movq %rax, %rsi
callq 0x1bb10
movq 0x140(%r14), %r12
movl (%rbx), %edi
movss 0x58(%rbx), %xmm0
movss 0x5c(%rbx), %xmm1
callq 0x1c100
jmp 0xd0e93
movq 0x140(%r14), %r12
movl (%rbx), %edi
callq 0x1bfb0
movq %r12, %rdi
movq %rax, %rsi
callq 0x1bb10
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0xd0eb5
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x1ba60
movq %r14, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x277a3(%rip), %rdi # 0xf8671
leaq 0x277ea(%rip), %rdx # 0xf86bf
movl $0xa5, %esi
xorl %eax, %eax
callq 0x1c130
leaq 0x27789(%rip), %rdi # 0xf8671
leaq 0x1852d(%rip), %rdx # 0xe941c
leaq 0x27801(%rip), %rcx # 0xf86f7
movl $0xe5, %esi
xorl %eax, %eax
callq 0x1c130
leaq 0x27768(%rip), %rdi # 0xf8671
leaq 0x1850c(%rip), %rdx # 0xe941c
leaq 0x27800(%rip), %rcx # 0xf8717
movl $0xf0, %esi
xorl %eax, %eax
callq 0x1c130
jmp 0xd0f67
jmp 0xd0f27
movq %rax, %rbx
movq %r14, %rdi
callq 0x242a8
jmp 0xd0f37
movq %rax, %rbx
movl $0x1b8, %esi # imm = 0x1B8
movq %r14, %rdi
jmp 0xd0f60
jmp 0xd0f67
jmp 0xd0f4b
jmp 0xd0f67
jmp 0xd0f67
jmp 0xd0f67
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xd0f6a
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x1ba60
jmp 0xd0f6a
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0xd0f81
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x1ba60
movq %rbx, %rdi
callq 0x1c250
| _Z19common_sampler_initPK11llama_modelRK22common_params_sampling:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov rbx, rsi
mov [rsp+98h+var_40], rdi
call _llama_model_get_vocab
mov [rsp+98h+var_90], rax
call _llama_sampler_chain_default_params
mov bpl, [rbx+61h]
xorps xmm0, xmm0
lea rdi, [rsp+98h+var_68]
movaps xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
mov rax, [rbx+0C8h]
sub rax, [rbx+0C0h]
sar rax, 3
mov rsi, 0CCCCCCCCCCCCCCCDh
imul rsi, rax
call _ZNSt6vectorIPKcSaIS1_EE7reserveEm; std::vector<char const*>::reserve(ulong)
mov r15, [rbx+0C0h]
mov r13, [rbx+0C8h]
cmp r15, r13
jz short loc_D0ABF
lea r14, [rsp+98h+var_68]
lea r12, [rsp+98h+var_88]
loc_D0AA3:
mov rax, [r15]
mov [rsp+98h+var_88], rax
mov rdi, r14
mov rsi, r12
call _ZNSt6vectorIPKcSaIS1_EE12emplace_backIJS1_EEERS1_DpOT_; std::vector<char const*>::emplace_back<char const*>(char const* &&)
add r15, 28h ; '('
cmp r15, r13
jnz short loc_D0AA3
loc_D0ABF:
lea rdi, [rbx+98h]
lea rcx, aLlguidance; "%llguidance"
mov edx, 0Bh
xor esi, esi
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEmmPKc; std::string::compare(ulong,ulong,char const*)
test eax, eax
jz loc_D0EC7
mov rsi, [rbx+98h]
cmp byte ptr [rbx+0B8h], 1
jnz short loc_D0B2E
mov rcx, [rsp+98h+var_68]
mov r8, [rsp+98h+var_60]
sub r8, rcx
sar r8, 3
mov r9, [rbx+0D8h]
mov rax, [rbx+0E0h]
sub rax, r9
sar rax, 2
mov [rsp+98h+var_98], rax
lea rdx, aRoot; "root"
mov rdi, [rsp+98h+var_90]
call _llama_sampler_init_grammar_lazy
jmp short loc_D0B3F
loc_D0B2E:
lea rdx, aRoot; "root"
mov rdi, [rsp+98h+var_90]
call _llama_sampler_init_grammar
loc_D0B3F:
mov r12, rax
mov edi, 1B8h; unsigned __int64
call __Znwm; operator new(ulong)
mov r14, rax
mov rdi, rax; this
mov rsi, rbx; common_params_sampling *
call _ZN22common_params_samplingC2ERKS_; common_params_sampling::common_params_sampling(common_params_sampling const&)
mov [r14+138h], r12
movzx edi, bpl
call _llama_sampler_chain_init
mov [r14+140h], rax
mov eax, [rbx+4]
cmp eax, 21h ; '!'
mov esi, 20h ; ' '
cmovge esi, eax
mov [r14+148h], rsi
mov rdi, r14
add rdi, 168h
xorps xmm0, xmm0
movups xmmword ptr [r14+150h], xmm0
mov qword ptr [r14+160h], 0
lea rdx, [rsp+98h+var_88]
call _ZNSt6vectorIiSaIiEEC2EmRKS0_; std::vector<int>::vector(ulong,std::allocator<int> const&)
xorps xmm0, xmm0
movups xmmword ptr [r14+1A0h], xmm0
movups xmmword ptr [r14+190h], xmm0
movups xmmword ptr [r14+180h], xmm0
mov qword ptr [r14+1B0h], 0
mov r12, [r14+140h]
mov rdi, [rsp+98h+var_90]
call _llama_vocab_n_tokens
mov rdx, [rbx+120h]
mov rsi, [rbx+128h]
sub rsi, rdx
shr rsi, 3
mov edi, eax
call _llama_sampler_init_logit_bias
mov rdi, r12
mov rsi, rax
call _llama_sampler_chain_add
mov eax, [rbx+54h]
cmp eax, 2
jz loc_D0E4F
cmp eax, 1
jz loc_D0E08
test eax, eax
jnz loc_D0F02
mov r15, [rbx+80h]
mov rbp, [rbx+88h]
cmp r15, rbp
jz loc_D0E85
lea r13, [rsp+98h+var_88]
mov [rsp+98h+var_48], rbp
loc_D0C4C:
mov eax, [r15]
dec eax; switch 10 cases
cmp eax, 9
ja def_D0C68; jumptable 00000000000D0C68 default case, case 5
lea rcx, jpt_D0C68
movsxd rax, ds:(jpt_D0C68 - 0F84A0h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_D0C6A:
xorps xmm0, xmm0; jumptable 00000000000D0C68 case 1
movaps xmmword ptr [rsp+98h+var_88], xmm0
mov [rsp+98h+var_78], 0
mov rsi, [rbx+70h]
sub rsi, [rbx+68h]
sar rsi, 5
mov rdi, r13
call _ZNSt6vectorIPKcSaIS1_EE7reserveEm; std::vector<char const*>::reserve(ulong)
mov r12, [rbx+68h]
mov rbp, [rbx+70h]
loc_D0C97:
cmp r12, rbp
jz loc_D0DA1
mov rax, [r12]
mov [rsp+98h+var_38], rax
mov rdi, r13
lea rsi, [rsp+98h+var_38]
call _ZNSt6vectorIPKcSaIS1_EE12emplace_backIJS1_EEERS1_DpOT_; std::vector<char const*>::emplace_back<char const*>(char const* &&)
add r12, 20h ; ' '
jmp short loc_D0C97
loc_D0CBC:
mov r12, [r14+140h]; jumptable 00000000000D0C68 case 10
mov edi, [rbx+34h]
movss xmm0, dword ptr [rbx+38h]
movss xmm1, dword ptr [rbx+3Ch]
movss xmm2, dword ptr [rbx+40h]
call _llama_sampler_init_penalties
jmp loc_D0D84
loc_D0CDF:
mov r12, [r14+140h]; jumptable 00000000000D0C68 case 6
movss xmm0, dword ptr [rbx+24h]
movsxd rdi, dword ptr [rbx+0Ch]
call _llama_sampler_init_typical
jmp loc_D0D84
loc_D0CF9:
mov r12, [r14+140h]; jumptable 00000000000D0C68 case 7
movss xmm0, dword ptr [rbx+28h]
movss xmm1, dword ptr [rbx+2Ch]
movss xmm2, dword ptr [rbx+30h]
call _llama_sampler_init_temp_ext
jmp short loc_D0D84
loc_D0D16:
mov r12, [r14+140h]; jumptable 00000000000D0C68 case 3
movss xmm0, dword ptr [rbx+14h]
movsxd rdi, dword ptr [rbx+0Ch]
call _llama_sampler_init_top_p
jmp short loc_D0D84
loc_D0D2D:
mov r12, [r14+140h]; jumptable 00000000000D0C68 case 9
mov rdi, [rsp+98h+var_90]
call _llama_sampler_init_infill
jmp short loc_D0D84
loc_D0D40:
mov r12, [r14+140h]; jumptable 00000000000D0C68 case 4
movss xmm0, dword ptr [rbx+18h]
movsxd rdi, dword ptr [rbx+0Ch]
call _llama_sampler_init_min_p
jmp short loc_D0D84
loc_D0D57:
mov r12, [r14+140h]; jumptable 00000000000D0C68 case 2
mov edi, [rbx+10h]
call _llama_sampler_init_top_k
jmp short loc_D0D84
loc_D0D68:
mov r12, [r14+140h]; jumptable 00000000000D0C68 case 8
movss xmm0, dword ptr [rbx+1Ch]
movss xmm1, dword ptr [rbx+20h]
movsxd rdi, dword ptr [rbx+0Ch]
mov esi, [rbx]
call _llama_sampler_init_xtc
loc_D0D84:
mov rdi, r12
mov rsi, rax
call _llama_sampler_chain_add
loc_D0D8F:
add r15, 4
cmp r15, rbp
jnz loc_D0C4C
jmp loc_D0E85
loc_D0DA1:
mov r12, [r14+140h]
mov rdi, [rsp+98h+var_40]
call _llama_model_n_ctx_train
movss xmm0, dword ptr [rbx+44h]
movss xmm1, dword ptr [rbx+48h]
mov edx, [rbx+4Ch]
mov ecx, [rbx+50h]
mov r8, [rsp+98h+var_88]
mov r9, [rsp+98h+var_88+8]
sub r9, r8
sar r9, 3
mov rdi, [rsp+98h+var_90]
mov esi, eax
call _llama_sampler_init_dry
mov rdi, r12
mov rsi, rax
call _llama_sampler_chain_add
mov rdi, [rsp+98h+var_88]; void *
test rdi, rdi
mov rbp, [rsp+98h+var_48]
jz short loc_D0D8F
mov rsi, [rsp+98h+var_78]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_D0D8F
loc_D0E08:
mov r12, [r14+140h]
movss xmm0, dword ptr [rbx+28h]
call _llama_sampler_init_temp
mov rdi, r12
mov rsi, rax
call _llama_sampler_chain_add
mov r12, [r14+140h]
mov rdi, [rsp+98h+var_90]
call _llama_vocab_n_tokens
mov esi, [rbx]
movss xmm0, dword ptr [rbx+58h]
movss xmm1, dword ptr [rbx+5Ch]
mov edi, eax
mov edx, 64h ; 'd'
call _llama_sampler_init_mirostat
jmp short loc_D0E93
loc_D0E4F:
mov r15, [r14+140h]
movss xmm0, dword ptr [rbx+28h]
call _llama_sampler_init_temp
mov rdi, r15
mov rsi, rax
call _llama_sampler_chain_add
mov r12, [r14+140h]
mov edi, [rbx]
movss xmm0, dword ptr [rbx+58h]
movss xmm1, dword ptr [rbx+5Ch]
call _llama_sampler_init_mirostat_v2
jmp short loc_D0E93
loc_D0E85:
mov r12, [r14+140h]
mov edi, [rbx]
call _llama_sampler_init_dist
loc_D0E93:
mov rdi, r12
mov rsi, rax
call _llama_sampler_chain_add
mov rdi, [rsp+98h+var_68]; void *
test rdi, rdi
jz short loc_D0EB5
mov rsi, [rsp+98h+var_58]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_D0EB5:
mov rax, r14
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_D0EC7:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aLlguidanceCmak; "llguidance (cmake -DLLAMA_LLGUIDANCE=ON"...
mov esi, 0A5h
xor eax, eax
call _ggml_abort
def_D0C68:
lea rdi, aWorkspaceLlm4b_5; jumptable 00000000000D0C68 default case, case 5
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aFalseUnknownSa; "false && \"unknown sampler type\""
mov esi, 0E5h
xor eax, eax
call _ggml_abort
loc_D0F02:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aFalseUnknownMi; "false && \"unknown mirostat version\""
mov esi, 0F0h
xor eax, eax
call _ggml_abort
jmp short loc_D0F67
jmp short $+2
loc_D0F27:
mov rbx, rax
mov rdi, r14; this
call _ZN22common_params_samplingD2Ev; common_params_sampling::~common_params_sampling()
jmp short loc_D0F37
mov rbx, rax
loc_D0F37:
mov esi, 1B8h
mov rdi, r14
jmp short loc_D0F60
jmp short loc_D0F67
jmp short loc_D0F4B
jmp short loc_D0F67
jmp short loc_D0F67
jmp short loc_D0F67
loc_D0F4B:
mov rbx, rax
mov rdi, [rsp+98h+var_88]; void *
test rdi, rdi
jz short loc_D0F6A
mov rsi, [rsp+98h+var_78]
sub rsi, rdi; unsigned __int64
loc_D0F60:
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_D0F6A
loc_D0F67:
mov rbx, rax
loc_D0F6A:
mov rdi, [rsp+98h+var_68]; void *
test rdi, rdi
jz short loc_D0F81
mov rsi, [rsp+98h+var_58]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_D0F81:
mov rdi, rbx
call __Unwind_Resume
| long long common_sampler_init(long long a1, unsigned int *a2)
{
unsigned __int8 v3; // bp
void **v4; // r15
void **i; // r13
long long v6; // rsi
long long inited; // rax
long long v8; // r12
long long v9; // r14
int v10; // eax
unsigned long long v11; // rsi
long long v12; // r12
unsigned int v13; // eax
long long v14; // rax
unsigned int v15; // eax
_DWORD *v16; // r15
_DWORD *v17; // rbp
long long *v18; // r12
long long *v19; // rbp
long long v20; // r12
long long v21; // rax
long long v22; // r12
unsigned int v23; // eax
long long v24; // rax
long long v25; // r12
long long v26; // rax
long long v27; // r12
unsigned int v28; // eax
long long v29; // rax
long long v30; // r15
long long v31; // rax
long long v33; // rax
long long v34; // rbx
long long vocab; // [rsp+8h] [rbp-90h]
void *v36[2]; // [rsp+10h] [rbp-88h] BYREF
long long v37; // [rsp+20h] [rbp-78h]
__int128 v38; // [rsp+30h] [rbp-68h] BYREF
long long v39; // [rsp+40h] [rbp-58h]
_DWORD *v40; // [rsp+50h] [rbp-48h]
long long v41; // [rsp+58h] [rbp-40h]
long long v42[7]; // [rsp+60h] [rbp-38h] BYREF
v41 = a1;
vocab = llama_model_get_vocab(a1);
llama_sampler_chain_default_params();
v3 = *((_BYTE *)a2 + 97);
v38 = 0LL;
v39 = 0LL;
std::vector<char const*>::reserve(
&v38,
0xCCCCCCCCCCCCCCCDLL * ((long long)(*((_QWORD *)a2 + 25) - *((_QWORD *)a2 + 24)) >> 3));
v4 = (void **)*((_QWORD *)a2 + 24);
for ( i = (void **)*((_QWORD *)a2 + 25); v4 != i; v4 += 5 )
{
v36[0] = *v4;
std::vector<char const*>::emplace_back<char const*>(&v38, v36);
}
if ( !(unsigned int)std::string::compare(a2 + 38, 0LL, 11LL, "%llguidance") )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/sampling.cpp",
165LL,
"llguidance (cmake -DLLAMA_LLGUIDANCE=ON) is not enabled");
LABEL_38:
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/sampling.cpp",
229LL,
"GGML_ASSERT(%s) failed",
"false && \"unknown sampler type\"");
goto LABEL_39;
}
v6 = *((_QWORD *)a2 + 19);
if ( *((_BYTE *)a2 + 184) == 1 )
inited = llama_sampler_init_grammar_lazy(vocab, v6, "root", v38, (long long)(*((_QWORD *)&v38 + 1) - v38) >> 3);
else
inited = llama_sampler_init_grammar(vocab, v6, "root");
v8 = inited;
v9 = operator new(0x1B8uLL);
common_params_sampling::common_params_sampling((common_params_sampling *)v9, (const common_params_sampling *)a2);
*(_QWORD *)(v9 + 312) = v8;
*(_QWORD *)(v9 + 320) = llama_sampler_chain_init(v3);
v10 = a2[1];
v11 = 32LL;
if ( v10 >= 33 )
v11 = (unsigned int)v10;
*(_QWORD *)(v9 + 328) = v11;
*(_OWORD *)(v9 + 336) = 0LL;
*(_QWORD *)(v9 + 352) = 0LL;
std::vector<int>::vector(v9 + 360, v11);
*(_OWORD *)(v9 + 416) = 0LL;
*(_OWORD *)(v9 + 400) = 0LL;
*(_OWORD *)(v9 + 384) = 0LL;
*(_QWORD *)(v9 + 432) = 0LL;
v12 = *(_QWORD *)(v9 + 320);
v13 = llama_vocab_n_tokens(vocab);
v14 = llama_sampler_init_logit_bias(v13, (*((_QWORD *)a2 + 37) - *((_QWORD *)a2 + 36)) >> 3);
llama_sampler_chain_add(v12, v14);
v15 = a2[21];
if ( v15 == 2 )
{
v30 = *(_QWORD *)(v9 + 320);
v31 = llama_sampler_init_temp(*((float *)a2 + 10));
llama_sampler_chain_add(v30, v31);
v27 = *(_QWORD *)(v9 + 320);
v29 = llama_sampler_init_mirostat_v2(*a2, *((float *)a2 + 22), *((float *)a2 + 23));
goto LABEL_34;
}
if ( v15 == 1 )
{
v25 = *(_QWORD *)(v9 + 320);
v26 = llama_sampler_init_temp(*((float *)a2 + 10));
llama_sampler_chain_add(v25, v26);
v27 = *(_QWORD *)(v9 + 320);
v28 = llama_vocab_n_tokens(vocab);
v29 = llama_sampler_init_mirostat(v28, *a2, 100LL, *((float *)a2 + 22), *((float *)a2 + 23));
goto LABEL_34;
}
if ( v15 )
{
LABEL_39:
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/sampling.cpp",
240LL,
"GGML_ASSERT(%s) failed",
"false && \"unknown mirostat version\"");
v34 = v33;
if ( (_QWORD)v38 )
operator delete((void *)v38, v39 - v38);
_Unwind_Resume(v34);
}
v16 = (_DWORD *)*((_QWORD *)a2 + 16);
v17 = (_DWORD *)*((_QWORD *)a2 + 17);
if ( v16 != v17 )
{
v40 = (_DWORD *)*((_QWORD *)a2 + 17);
while ( 2 )
{
switch ( *v16 )
{
case 1:
*(_OWORD *)v36 = 0LL;
v37 = 0LL;
std::vector<char const*>::reserve(v36, (long long)(*((_QWORD *)a2 + 14) - *((_QWORD *)a2 + 13)) >> 5);
v18 = (long long *)*((_QWORD *)a2 + 13);
v19 = (long long *)*((_QWORD *)a2 + 14);
while ( v18 != v19 )
{
v42[0] = *v18;
std::vector<char const*>::emplace_back<char const*>(v36, v42);
v18 += 4;
}
v22 = *(_QWORD *)(v9 + 320);
v23 = llama_model_n_ctx_train(v41);
v24 = llama_sampler_init_dry(
vocab,
v23,
a2[19],
a2[20],
v36[0],
((char *)v36[1] - (char *)v36[0]) >> 3,
*((float *)a2 + 17),
*((float *)a2 + 18));
llama_sampler_chain_add(v22, v24);
v17 = v40;
if ( v36[0] )
operator delete(v36[0], v37 - (unsigned long long)v36[0]);
goto LABEL_27;
case 2:
v20 = *(_QWORD *)(v9 + 320);
v21 = llama_sampler_init_top_k(a2[4]);
goto LABEL_26;
case 3:
v20 = *(_QWORD *)(v9 + 320);
v21 = llama_sampler_init_top_p((int)a2[3], *((float *)a2 + 5));
goto LABEL_26;
case 4:
v20 = *(_QWORD *)(v9 + 320);
v21 = llama_sampler_init_min_p((int)a2[3], *((float *)a2 + 6));
goto LABEL_26;
case 6:
v20 = *(_QWORD *)(v9 + 320);
v21 = llama_sampler_init_typical((int)a2[3], *((float *)a2 + 9));
goto LABEL_26;
case 7:
v20 = *(_QWORD *)(v9 + 320);
v21 = llama_sampler_init_temp_ext(*((float *)a2 + 10), *((float *)a2 + 11), *((float *)a2 + 12));
goto LABEL_26;
case 8:
v20 = *(_QWORD *)(v9 + 320);
v21 = llama_sampler_init_xtc((int)a2[3], *a2, *((float *)a2 + 7), *((float *)a2 + 8));
goto LABEL_26;
case 9:
v20 = *(_QWORD *)(v9 + 320);
v21 = llama_sampler_init_infill(vocab);
goto LABEL_26;
case 0xA:
v20 = *(_QWORD *)(v9 + 320);
v21 = llama_sampler_init_penalties(a2[13], *((float *)a2 + 14), *((float *)a2 + 15), *((float *)a2 + 16));
LABEL_26:
llama_sampler_chain_add(v20, v21);
LABEL_27:
if ( ++v16 == v17 )
break;
continue;
default:
goto LABEL_38;
}
break;
}
}
v27 = *(_QWORD *)(v9 + 320);
v29 = llama_sampler_init_dist(*a2);
LABEL_34:
llama_sampler_chain_add(v27, v29);
if ( (_QWORD)v38 )
operator delete((void *)v38, v39 - v38);
return v9;
}
| common_sampler_init:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV RBX,RSI
MOV qword ptr [RSP + 0x58],RDI
CALL 0x0011c450
MOV qword ptr [RSP + 0x8],RAX
CALL 0x0011bf90
MOV BPL,byte ptr [RBX + 0x61]
XORPS XMM0,XMM0
LEA RDI,[RSP + 0x30]
MOVAPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
MOV RAX,qword ptr [RBX + 0xc8]
SUB RAX,qword ptr [RBX + 0xc0]
SAR RAX,0x3
MOV RSI,-0x3333333333333333
IMUL RSI,RAX
LAB_001d0a81:
CALL 0x001d21a4
MOV R15,qword ptr [RBX + 0xc0]
MOV R13,qword ptr [RBX + 0xc8]
CMP R15,R13
JZ 0x001d0abf
LEA R14,[RSP + 0x30]
LEA R12,[RSP + 0x10]
LAB_001d0aa3:
MOV RAX,qword ptr [R15]
MOV qword ptr [RSP + 0x10],RAX
LAB_001d0aab:
MOV RDI,R14
MOV RSI,R12
CALL 0x001d2882
ADD R15,0x28
CMP R15,R13
JNZ 0x001d0aa3
LAB_001d0abf:
LEA RDI,[RBX + 0x98]
LAB_001d0ac6:
LEA RCX,[0x1f8665]
MOV EDX,0xb
XOR ESI,ESI
CALL 0x0011bd80
TEST EAX,EAX
JZ 0x001d0ec7
MOV RSI,qword ptr [RBX + 0x98]
CMP byte ptr [RBX + 0xb8],0x1
JNZ 0x001d0b2e
MOV RCX,qword ptr [RSP + 0x30]
MOV R8,qword ptr [RSP + 0x38]
SUB R8,RCX
SAR R8,0x3
MOV R9,qword ptr [RBX + 0xd8]
MOV RAX,qword ptr [RBX + 0xe0]
SUB RAX,R9
SAR RAX,0x2
MOV qword ptr [RSP],RAX
LEA RDX,[0x1f7c7f]
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x0011b840
JMP 0x001d0b3f
LAB_001d0b2e:
LEA RDX,[0x1f7c7f]
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x0011b1c0
LAB_001d0b3f:
MOV R12,RAX
LAB_001d0b42:
MOV EDI,0x1b8
CALL 0x0011ba40
LAB_001d0b4c:
MOV R14,RAX
MOV RDI,RAX
MOV RSI,RBX
CALL 0x00158730
MOV qword ptr [R14 + 0x138],R12
LAB_001d0b61:
MOVZX EDI,BPL
CALL 0x0011b580
MOV qword ptr [R14 + 0x140],RAX
MOV EAX,dword ptr [RBX + 0x4]
CMP EAX,0x21
MOV ESI,0x20
CMOVGE ESI,EAX
MOV qword ptr [R14 + 0x148],RSI
MOV RDI,R14
ADD RDI,0x168
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14 + 0x150],XMM0
MOV qword ptr [R14 + 0x160],0x0
LAB_001d0ba6:
LEA RDX,[RSP + 0x10]
CALL 0x0017cd16
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14 + 0x1a0],XMM0
MOVUPS xmmword ptr [R14 + 0x190],XMM0
MOVUPS xmmword ptr [R14 + 0x180],XMM0
MOV qword ptr [R14 + 0x1b0],0x0
MOV R12,qword ptr [R14 + 0x140]
LAB_001d0bdd:
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x0011c3d0
MOV RDX,qword ptr [RBX + 0x120]
MOV RSI,qword ptr [RBX + 0x128]
SUB RSI,RDX
SHR RSI,0x3
MOV EDI,EAX
CALL 0x0011c0f0
MOV RDI,R12
MOV RSI,RAX
CALL 0x0011bb10
MOV EAX,dword ptr [RBX + 0x54]
CMP EAX,0x2
JZ 0x001d0e4f
CMP EAX,0x1
JZ 0x001d0e08
TEST EAX,EAX
JNZ 0x001d0f02
MOV R15,qword ptr [RBX + 0x80]
MOV RBP,qword ptr [RBX + 0x88]
CMP R15,RBP
JZ 0x001d0e85
LEA R13,[RSP + 0x10]
MOV qword ptr [RSP + 0x50],RBP
LAB_001d0c4c:
MOV EAX,dword ptr [R15]
DEC EAX
CMP EAX,0x9
JA 0x001d0ee1
LEA RCX,[0x1f84a0]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOV qword ptr [RSP + 0x20],0x0
MOV RSI,qword ptr [RBX + 0x70]
SUB RSI,qword ptr [RBX + 0x68]
SAR RSI,0x5
LAB_001d0c87:
MOV RDI,R13
CALL 0x001d21a4
MOV R12,qword ptr [RBX + 0x68]
MOV RBP,qword ptr [RBX + 0x70]
LAB_001d0c97:
CMP R12,RBP
JZ 0x001d0da1
MOV RAX,qword ptr [R12]
MOV qword ptr [RSP + 0x60],RAX
LAB_001d0ca9:
MOV RDI,R13
LEA RSI,[RSP + 0x60]
CALL 0x001d2882
ADD R12,0x20
JMP 0x001d0c97
caseD_a:
MOV R12,qword ptr [R14 + 0x140]
MOV EDI,dword ptr [RBX + 0x34]
MOVSS XMM0,dword ptr [RBX + 0x38]
MOVSS XMM1,dword ptr [RBX + 0x3c]
MOVSS XMM2,dword ptr [RBX + 0x40]
LAB_001d0cd5:
CALL 0x0011b7f0
JMP 0x001d0d84
caseD_6:
MOV R12,qword ptr [R14 + 0x140]
MOVSS XMM0,dword ptr [RBX + 0x24]
MOVSXD RDI,dword ptr [RBX + 0xc]
CALL 0x0011b7a0
JMP 0x001d0d84
caseD_7:
MOV R12,qword ptr [R14 + 0x140]
MOVSS XMM0,dword ptr [RBX + 0x28]
MOVSS XMM1,dword ptr [RBX + 0x2c]
MOVSS XMM2,dword ptr [RBX + 0x30]
CALL 0x0011c390
JMP 0x001d0d84
caseD_3:
MOV R12,qword ptr [R14 + 0x140]
MOVSS XMM0,dword ptr [RBX + 0x14]
MOVSXD RDI,dword ptr [RBX + 0xc]
CALL 0x0011b140
JMP 0x001d0d84
caseD_9:
MOV R12,qword ptr [R14 + 0x140]
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x0011bf30
JMP 0x001d0d84
caseD_4:
MOV R12,qword ptr [R14 + 0x140]
MOVSS XMM0,dword ptr [RBX + 0x18]
MOVSXD RDI,dword ptr [RBX + 0xc]
CALL 0x0011be40
JMP 0x001d0d84
caseD_2:
MOV R12,qword ptr [R14 + 0x140]
MOV EDI,dword ptr [RBX + 0x10]
CALL 0x0011b450
JMP 0x001d0d84
caseD_8:
MOV R12,qword ptr [R14 + 0x140]
MOVSS XMM0,dword ptr [RBX + 0x1c]
MOVSS XMM1,dword ptr [RBX + 0x20]
MOVSXD RDI,dword ptr [RBX + 0xc]
MOV ESI,dword ptr [RBX]
CALL 0x0011b2f0
LAB_001d0d84:
MOV RDI,R12
MOV RSI,RAX
CALL 0x0011bb10
LAB_001d0d8f:
ADD R15,0x4
CMP R15,RBP
JNZ 0x001d0c4c
JMP 0x001d0e85
LAB_001d0da1:
MOV R12,qword ptr [R14 + 0x140]
LAB_001d0da8:
MOV RDI,qword ptr [RSP + 0x58]
CALL 0x0011b9e0
MOVSS XMM0,dword ptr [RBX + 0x44]
MOVSS XMM1,dword ptr [RBX + 0x48]
MOV EDX,dword ptr [RBX + 0x4c]
MOV ECX,dword ptr [RBX + 0x50]
MOV R8,qword ptr [RSP + 0x10]
MOV R9,qword ptr [RSP + 0x18]
SUB R9,R8
SAR R9,0x3
MOV RDI,qword ptr [RSP + 0x8]
MOV ESI,EAX
CALL 0x0011c120
MOV RDI,R12
MOV RSI,RAX
CALL 0x0011bb10
MOV RDI,qword ptr [RSP + 0x10]
TEST RDI,RDI
MOV RBP,qword ptr [RSP + 0x50]
JZ 0x001d0d8f
MOV RSI,qword ptr [RSP + 0x20]
SUB RSI,RDI
CALL 0x0011ba60
JMP 0x001d0d8f
LAB_001d0e08:
MOV R12,qword ptr [R14 + 0x140]
MOVSS XMM0,dword ptr [RBX + 0x28]
LAB_001d0e14:
CALL 0x0011b620
MOV RDI,R12
MOV RSI,RAX
CALL 0x0011bb10
MOV R12,qword ptr [R14 + 0x140]
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x0011c3d0
MOV ESI,dword ptr [RBX]
MOVSS XMM0,dword ptr [RBX + 0x58]
MOVSS XMM1,dword ptr [RBX + 0x5c]
MOV EDI,EAX
MOV EDX,0x64
CALL 0x0011c440
JMP 0x001d0e93
LAB_001d0e4f:
MOV R15,qword ptr [R14 + 0x140]
MOVSS XMM0,dword ptr [RBX + 0x28]
CALL 0x0011b620
MOV RDI,R15
MOV RSI,RAX
CALL 0x0011bb10
MOV R12,qword ptr [R14 + 0x140]
MOV EDI,dword ptr [RBX]
MOVSS XMM0,dword ptr [RBX + 0x58]
MOVSS XMM1,dword ptr [RBX + 0x5c]
CALL 0x0011c100
JMP 0x001d0e93
LAB_001d0e85:
MOV R12,qword ptr [R14 + 0x140]
MOV EDI,dword ptr [RBX]
CALL 0x0011bfb0
LAB_001d0e93:
MOV RDI,R12
MOV RSI,RAX
CALL 0x0011bb10
MOV RDI,qword ptr [RSP + 0x30]
TEST RDI,RDI
JZ 0x001d0eb5
MOV RSI,qword ptr [RSP + 0x40]
SUB RSI,RDI
CALL 0x0011ba60
LAB_001d0eb5:
MOV RAX,R14
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001d0ec7:
LEA RDI,[0x1f8671]
LEA RDX,[0x1f86bf]
MOV ESI,0xa5
XOR EAX,EAX
CALL 0x0011c130
caseD_5:
LEA RDI,[0x1f8671]
LEA RDX,[0x1e941c]
LEA RCX,[0x1f86f7]
MOV ESI,0xe5
XOR EAX,EAX
CALL 0x0011c130
LAB_001d0f02:
LEA RDI,[0x1f8671]
LEA RDX,[0x1e941c]
LEA RCX,[0x1f8717]
MOV ESI,0xf0
XOR EAX,EAX
CALL 0x0011c130
|
/* common_sampler_init(llama_model const*, common_params_sampling const&) */
common_params_sampling * common_sampler_init(llama_model *param_1,common_params_sampling *param_2)
{
common_params_sampling cVar1;
int8 *puVar2;
int iVar3;
int4 uVar4;
int8 uVar5;
int8 uVar6;
common_params_sampling *this;
int8 uVar7;
int4 *puVar8;
allocator *paVar9;
int8 *puVar10;
int4 *puVar11;
char *local_88;
long lStack_80;
long local_78;
void *local_68;
long lStack_60;
long local_58;
int4 *local_48;
llama_model *local_40;
char *local_38;
local_40 = param_1;
uVar5 = llama_model_get_vocab();
llama_sampler_chain_default_params();
cVar1 = param_2[0x61];
local_68 = (void *)0x0;
lStack_60 = 0;
local_58 = 0;
/* try { // try from 001d0a81 to 001d0a85 has its CatchHandler @ 001d0f41 */
std::vector<char_const*,std::allocator<char_const*>>::reserve
((vector<char_const*,std::allocator<char_const*>> *)&local_68,
(*(long *)(param_2 + 200) - *(long *)(param_2 + 0xc0) >> 3) * -0x3333333333333333);
puVar10 = *(int8 **)(param_2 + 0xc0);
puVar2 = *(int8 **)(param_2 + 200);
if (puVar10 != puVar2) {
do {
local_88 = (char *)*puVar10;
/* try { // try from 001d0aab to 001d0ab5 has its CatchHandler @ 001d0f67 */
std::vector<char_const*,std::allocator<char_const*>>::emplace_back<char_const*>
((vector<char_const*,std::allocator<char_const*>> *)&local_68,&local_88);
puVar10 = puVar10 + 5;
} while (puVar10 != puVar2);
}
/* try { // try from 001d0ac6 to 001d0b3e has its CatchHandler @ 001d0f45 */
iVar3 = std::__cxx11::string::compare((ulong)(param_2 + 0x98),0,(char *)0xb);
if (iVar3 == 0) {
/* try { // try from 001d0ec7 to 001d0ee0 has its CatchHandler @ 001d0f45 */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/sampling.cpp",0xa5,
"llguidance (cmake -DLLAMA_LLGUIDANCE=ON) is not enabled");
}
if (param_2[0xb8] == (common_params_sampling)0x1) {
uVar6 = llama_sampler_init_grammar_lazy
(uVar5,*(int8 *)(param_2 + 0x98),&DAT_001f7c7f,local_68,
lStack_60 - (long)local_68 >> 3,*(long *)(param_2 + 0xd8),
*(long *)(param_2 + 0xe0) - *(long *)(param_2 + 0xd8) >> 2);
}
else {
uVar6 = llama_sampler_init_grammar(uVar5,*(int8 *)(param_2 + 0x98),&DAT_001f7c7f);
}
/* try { // try from 001d0b42 to 001d0b4b has its CatchHandler @ 001d0f47 */
this = (common_params_sampling *)operator_new(0x1b8);
/* try { // try from 001d0b4c to 001d0b59 has its CatchHandler @ 001d0f34 */
common_params_sampling::common_params_sampling(this,param_2);
*(int8 *)(this + 0x138) = uVar6;
/* try { // try from 001d0b61 to 001d0b69 has its CatchHandler @ 001d0f27 */
uVar6 = llama_sampler_chain_init(cVar1);
*(int8 *)(this + 0x140) = uVar6;
paVar9 = (allocator *)0x20;
if (0x20 < (int)*(uint *)(param_2 + 4)) {
paVar9 = (allocator *)(ulong)*(uint *)(param_2 + 4);
}
*(allocator **)(this + 0x148) = paVar9;
*(int8 *)(this + 0x150) = 0;
*(int8 *)(this + 0x158) = 0;
*(int8 *)(this + 0x160) = 0;
/* try { // try from 001d0ba6 to 001d0baf has its CatchHandler @ 001d0f25 */
std::vector<int,std::allocator<int>>::vector((ulong)(this + 0x168),paVar9);
*(int8 *)(this + 0x1a0) = 0;
*(int8 *)(this + 0x1a8) = 0;
*(int8 *)(this + 400) = 0;
*(int8 *)(this + 0x198) = 0;
*(int8 *)(this + 0x180) = 0;
*(int8 *)(this + 0x188) = 0;
*(int8 *)(this + 0x1b0) = 0;
uVar6 = *(int8 *)(this + 0x140);
/* try { // try from 001d0bdd to 001d0c0d has its CatchHandler @ 001d0f47 */
uVar4 = llama_vocab_n_tokens(uVar5);
uVar7 = llama_sampler_init_logit_bias
(uVar4,(ulong)(*(long *)(param_2 + 0x128) - *(long *)(param_2 + 0x120)) >> 3);
llama_sampler_chain_add(uVar6,uVar7);
iVar3 = *(int *)(param_2 + 0x54);
if (iVar3 == 2) {
uVar5 = *(int8 *)(this + 0x140);
uVar6 = llama_sampler_init_temp(*(int4 *)(param_2 + 0x28));
llama_sampler_chain_add(uVar5,uVar6);
uVar6 = *(int8 *)(this + 0x140);
uVar5 = llama_sampler_init_mirostat_v2
(*(int4 *)(param_2 + 0x58),*(int4 *)(param_2 + 0x5c),
*(int4 *)param_2);
}
else if (iVar3 == 1) {
uVar6 = *(int8 *)(this + 0x140);
/* try { // try from 001d0e14 to 001d0e9d has its CatchHandler @ 001d0f47 */
uVar7 = llama_sampler_init_temp(*(int4 *)(param_2 + 0x28));
llama_sampler_chain_add(uVar6,uVar7);
uVar6 = *(int8 *)(this + 0x140);
uVar4 = llama_vocab_n_tokens(uVar5);
uVar5 = llama_sampler_init_mirostat
(*(int4 *)(param_2 + 0x58),*(int4 *)(param_2 + 0x5c),uVar4,
*(int4 *)param_2,100);
}
else {
if (iVar3 != 0) {
/* try { // try from 001d0f02 to 001d0f22 has its CatchHandler @ 001d0f47 */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/sampling.cpp",
0xf0,"GGML_ASSERT(%s) failed","false && \"unknown mirostat version\"");
}
puVar11 = *(int4 **)(param_2 + 0x80);
puVar8 = *(int4 **)(param_2 + 0x88);
if (puVar11 != puVar8) {
local_48 = puVar8;
do {
switch(*puVar11) {
case 1:
local_88 = (char *)0x0;
lStack_80 = 0;
local_78 = 0;
/* try { // try from 001d0c87 to 001d0c8e has its CatchHandler @ 001d0f43 */
std::vector<char_const*,std::allocator<char_const*>>::reserve
((vector<char_const*,std::allocator<char_const*>> *)&local_88,
*(long *)(param_2 + 0x70) - *(long *)(param_2 + 0x68) >> 5);
puVar2 = *(int8 **)(param_2 + 0x70);
for (puVar10 = *(int8 **)(param_2 + 0x68); puVar10 != puVar2; puVar10 = puVar10 + 4)
{
local_38 = (char *)*puVar10;
/* try { // try from 001d0ca9 to 001d0cb5 has its CatchHandler @ 001d0f4b */
std::vector<char_const*,std::allocator<char_const*>>::emplace_back<char_const*>
((vector<char_const*,std::allocator<char_const*>> *)&local_88,&local_38);
}
uVar6 = *(int8 *)(this + 0x140);
/* try { // try from 001d0da8 to 001d0de9 has its CatchHandler @ 001d0f43 */
uVar4 = llama_model_n_ctx_train(local_40);
uVar7 = llama_sampler_init_dry
(*(int4 *)(param_2 + 0x44),*(int4 *)(param_2 + 0x48),uVar5,
uVar4,*(int4 *)(param_2 + 0x4c),*(int4 *)(param_2 + 0x50),
local_88,lStack_80 - (long)local_88 >> 3);
llama_sampler_chain_add(uVar6,uVar7);
puVar8 = local_48;
if (local_88 != (char *)0x0) {
operator_delete(local_88,local_78 - (long)local_88);
}
goto LAB_001d0d8f;
case 2:
uVar6 = *(int8 *)(this + 0x140);
uVar7 = llama_sampler_init_top_k(*(int4 *)(param_2 + 0x10));
break;
case 3:
uVar6 = *(int8 *)(this + 0x140);
uVar7 = llama_sampler_init_top_p
(*(int4 *)(param_2 + 0x14),(long)*(int *)(param_2 + 0xc));
break;
case 4:
uVar6 = *(int8 *)(this + 0x140);
uVar7 = llama_sampler_init_min_p
(*(int4 *)(param_2 + 0x18),(long)*(int *)(param_2 + 0xc));
break;
default:
/* try { // try from 001d0ee1 to 001d0f01 has its CatchHandler @ 001d0f23 */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/sampling.cpp"
,0xe5,"GGML_ASSERT(%s) failed","false && \"unknown sampler type\"");
case 6:
uVar6 = *(int8 *)(this + 0x140);
uVar7 = llama_sampler_init_typical
(*(int4 *)(param_2 + 0x24),(long)*(int *)(param_2 + 0xc));
break;
case 7:
uVar6 = *(int8 *)(this + 0x140);
uVar7 = llama_sampler_init_temp_ext
(*(int4 *)(param_2 + 0x28),*(int4 *)(param_2 + 0x2c),
*(int4 *)(param_2 + 0x30));
break;
case 8:
uVar6 = *(int8 *)(this + 0x140);
uVar7 = llama_sampler_init_xtc
(*(int4 *)(param_2 + 0x1c),*(int4 *)(param_2 + 0x20),
(long)*(int *)(param_2 + 0xc),*(int4 *)param_2);
break;
case 9:
uVar6 = *(int8 *)(this + 0x140);
uVar7 = llama_sampler_init_infill(uVar5);
break;
case 10:
uVar6 = *(int8 *)(this + 0x140);
/* try { // try from 001d0cd5 to 001d0d8e has its CatchHandler @ 001d0f49 */
uVar7 = llama_sampler_init_penalties
(*(int4 *)(param_2 + 0x38),*(int4 *)(param_2 + 0x3c),
*(int4 *)(param_2 + 0x40),*(int4 *)(param_2 + 0x34));
}
llama_sampler_chain_add(uVar6,uVar7);
LAB_001d0d8f:
puVar11 = puVar11 + 1;
} while (puVar11 != puVar8);
}
uVar6 = *(int8 *)(this + 0x140);
uVar5 = llama_sampler_init_dist(*(int4 *)param_2);
}
llama_sampler_chain_add(uVar6,uVar5);
if (local_68 != (void *)0x0) {
operator_delete(local_68,local_58 - (long)local_68);
}
return this;
}
| |
53,967 | string_strip(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/common.cpp | std::string string_strip(const std::string & str) {
size_t start = 0;
size_t end = str.size();
while (start < end && std::isspace(str[start])) {
start++;
}
while (end > start && std::isspace(str[end - 1])) {
end--;
}
return str.substr(start, end - start);
} | O0 | cpp | string_strip(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
subq $0x38, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x5a520
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rcx
xorl %eax, %eax
cmpq 0x18(%rsp), %rcx
movb %al, 0x7(%rsp)
jae 0xef8f6
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x5b400
movsbl (%rax), %edi
callq 0x5adb0
cmpl $0x0, %eax
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0xef900
jmp 0xef910
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0xef8c3
jmp 0xef912
movq 0x18(%rsp), %rcx
xorl %eax, %eax
cmpq 0x20(%rsp), %rcx
movb %al, 0x6(%rsp)
jbe 0xef949
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
subq $0x1, %rsi
callq 0x5b400
movsbl (%rax), %edi
callq 0x5adb0
cmpl $0x0, %eax
setne %al
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
testb $0x1, %al
jne 0xef953
jmp 0xef963
movq 0x18(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0xef912
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
subq 0x20(%rsp), %rcx
callq 0x5b1e0
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
| _Z12string_stripRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
sub rsp, 38h
mov [rsp+38h+var_30], rdi
mov rax, rdi
mov [rsp+38h+var_28], rax
mov [rsp+38h+var_8], rdi
mov [rsp+38h+var_10], rsi
mov [rsp+38h+var_18], 0
mov rdi, [rsp+38h+var_10]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4sizeEv; std::string::size(void)
mov [rsp+38h+var_20], rax
loc_EF8C3:
mov rcx, [rsp+38h+var_18]
xor eax, eax
cmp rcx, [rsp+38h+var_20]
mov [rsp+38h+var_31], al
jnb short loc_EF8F6
mov rdi, [rsp+38h+var_10]
mov rsi, [rsp+38h+var_18]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEixEm; std::string::operator[](ulong)
movsx edi, byte ptr [rax]
call _isspace
cmp eax, 0
setnz al
mov [rsp+38h+var_31], al
loc_EF8F6:
mov al, [rsp+38h+var_31]
test al, 1
jnz short loc_EF900
jmp short loc_EF910
loc_EF900:
mov rax, [rsp+38h+var_18]
add rax, 1
mov [rsp+38h+var_18], rax
jmp short loc_EF8C3
loc_EF910:
jmp short $+2
loc_EF912:
mov rcx, [rsp+38h+var_20]
xor eax, eax
cmp rcx, [rsp+38h+var_18]
mov [rsp+38h+var_32], al
jbe short loc_EF949
mov rdi, [rsp+38h+var_10]
mov rsi, [rsp+38h+var_20]
sub rsi, 1
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEixEm; std::string::operator[](ulong)
movsx edi, byte ptr [rax]
call _isspace
cmp eax, 0
setnz al
mov [rsp+38h+var_32], al
loc_EF949:
mov al, [rsp+38h+var_32]
test al, 1
jnz short loc_EF953
jmp short loc_EF963
loc_EF953:
mov rax, [rsp+38h+var_20]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rsp+38h+var_20], rax
jmp short loc_EF912
loc_EF963:
mov rdi, [rsp+38h+var_30]
mov rsi, [rsp+38h+var_10]
mov rdx, [rsp+38h+var_18]
mov rcx, [rsp+38h+var_20]
sub rcx, [rsp+38h+var_18]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
mov rax, [rsp+38h+var_28]
add rsp, 38h
retn
| long long string_strip(long long a1, long long a2)
{
char *v2; // rax
char *v3; // rax
bool v5; // [rsp+6h] [rbp-32h]
bool v6; // [rsp+7h] [rbp-31h]
unsigned long long v7; // [rsp+18h] [rbp-20h]
unsigned long long v8; // [rsp+20h] [rbp-18h]
v8 = 0LL;
v7 = std::string::size(a2);
while ( 1 )
{
v6 = 0;
if ( v8 < v7 )
{
v2 = (char *)std::string::operator[](a2, v8);
v6 = (unsigned int)isspace((unsigned int)*v2) != 0;
}
if ( !v6 )
break;
++v8;
}
while ( 1 )
{
v5 = 0;
if ( v7 > v8 )
{
v3 = (char *)std::string::operator[](a2, v7 - 1);
v5 = (unsigned int)isspace((unsigned int)*v3) != 0;
}
if ( !v5 )
break;
--v7;
}
std::string::substr(a1, a2, v8, v7 - v8);
return a1;
}
| string_strip:
SUB RSP,0x38
MOV qword ptr [RSP + 0x8],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x30],RDI
MOV qword ptr [RSP + 0x28],RSI
MOV qword ptr [RSP + 0x20],0x0
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x0015a520
MOV qword ptr [RSP + 0x18],RAX
LAB_001ef8c3:
MOV RCX,qword ptr [RSP + 0x20]
XOR EAX,EAX
CMP RCX,qword ptr [RSP + 0x18]
MOV byte ptr [RSP + 0x7],AL
JNC 0x001ef8f6
MOV RDI,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RSP + 0x20]
CALL 0x0015b400
MOVSX EDI,byte ptr [RAX]
CALL 0x0015adb0
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RSP + 0x7],AL
LAB_001ef8f6:
MOV AL,byte ptr [RSP + 0x7]
TEST AL,0x1
JNZ 0x001ef900
JMP 0x001ef910
LAB_001ef900:
MOV RAX,qword ptr [RSP + 0x20]
ADD RAX,0x1
MOV qword ptr [RSP + 0x20],RAX
JMP 0x001ef8c3
LAB_001ef910:
JMP 0x001ef912
LAB_001ef912:
MOV RCX,qword ptr [RSP + 0x18]
XOR EAX,EAX
CMP RCX,qword ptr [RSP + 0x20]
MOV byte ptr [RSP + 0x6],AL
JBE 0x001ef949
MOV RDI,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RSP + 0x18]
SUB RSI,0x1
CALL 0x0015b400
MOVSX EDI,byte ptr [RAX]
CALL 0x0015adb0
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RSP + 0x6],AL
LAB_001ef949:
MOV AL,byte ptr [RSP + 0x6]
TEST AL,0x1
JNZ 0x001ef953
JMP 0x001ef963
LAB_001ef953:
MOV RAX,qword ptr [RSP + 0x18]
ADD RAX,-0x1
MOV qword ptr [RSP + 0x18],RAX
JMP 0x001ef912
LAB_001ef963:
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [RSP + 0x18]
SUB RCX,qword ptr [RSP + 0x20]
CALL 0x0015b1e0
MOV RAX,qword ptr [RSP + 0x10]
ADD RSP,0x38
RET
|
/* string_strip(std::__cxx11::string const&) */
string * string_strip(string *param_1)
{
int iVar1;
char *pcVar2;
ulong in_RSI;
bool bVar3;
int8 local_20;
int8 local_18;
local_18 = 0;
local_20 = std::__cxx11::string::size();
while( true ) {
bVar3 = false;
if (local_18 < local_20) {
pcVar2 = (char *)std::__cxx11::string::operator[](in_RSI);
iVar1 = isspace((int)*pcVar2);
bVar3 = iVar1 != 0;
}
if (!bVar3) break;
local_18 = local_18 + 1;
}
while( true ) {
bVar3 = false;
if (local_18 < local_20) {
pcVar2 = (char *)std::__cxx11::string::operator[](in_RSI);
iVar1 = isspace((int)*pcVar2);
bVar3 = iVar1 != 0;
}
if (!bVar3) break;
local_20 = local_20 - 1;
}
std::__cxx11::string::substr((ulong)param_1,in_RSI);
return param_1;
}
| |
53,968 | JS_ConcatString | bluesky950520[P]quickjs/quickjs.c | static JSValue JS_ConcatString(JSContext *ctx, JSValue op1, JSValue op2)
{
JSValue ret;
JSString *p1, *p2;
if (unlikely(JS_VALUE_GET_TAG(op1) != JS_TAG_STRING)) {
op1 = JS_ToStringFree(ctx, op1);
if (JS_IsException(op1)) {
JS_FreeValue(ctx, op2);
return JS_EXCEPTION;
}
}
if (unlikely(JS_VALUE_GET_TAG(op2) != JS_TAG_STRING)) {
op2 = JS_ToStringFree(ctx, op2);
if (JS_IsException(op2)) {
JS_FreeValue(ctx, op1);
return JS_EXCEPTION;
}
}
p1 = JS_VALUE_GET_STRING(op1);
p2 = JS_VALUE_GET_STRING(op2);
/* XXX: could also check if p1 is empty */
if (p2->len == 0) {
goto ret_op1;
}
if (p1->header.ref_count == 1 && p1->is_wide_char == p2->is_wide_char
&& js_malloc_usable_size(ctx, p1) >= sizeof(*p1) + ((p1->len + p2->len) << p2->is_wide_char) + 1 - p1->is_wide_char) {
/* Concatenate in place in available space at the end of p1 */
if (p1->is_wide_char) {
memcpy(p1->u.str16 + p1->len, p2->u.str16, p2->len << 1);
p1->len += p2->len;
} else {
memcpy(p1->u.str8 + p1->len, p2->u.str8, p2->len);
p1->len += p2->len;
p1->u.str8[p1->len] = '\0';
}
ret_op1:
JS_FreeValue(ctx, op2);
return op1;
}
ret = JS_ConcatString1(ctx, p1, p2);
JS_FreeValue(ctx, op1);
JS_FreeValue(ctx, op2);
return ret;
} | O2 | c | JS_ConcatString:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbp
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
cmpl $-0x7, %ebx
jne 0x387b8
movl $0xfffffff9, %eax # imm = 0xFFFFFFF9
cmpl %eax, %ebp
jne 0x387d9
movq 0x4(%r15), %rdx
testl $0x7fffffff, %edx # imm = 0x7FFFFFFF
je 0x38795
cmpl $0x1, (%r14)
movq 0x4(%r14), %r13
jne 0x385f3
movl %r13d, %eax
xorl %edx, %eax
js 0x385f3
movq 0x18(%r12), %rax
movq %r14, %rdi
callq *0x20(%rax)
movq 0x4(%r14), %r13
movl $0x7fffffff, %r8d # imm = 0x7FFFFFFF
movslq %r13d, %rsi
movl %r13d, %edi
andl %r8d, %edi
movq 0x4(%r15), %rdx
andl %edx, %r8d
addl %r8d, %edi
movl %edx, %ecx
shrl $0x1f, %ecx
shll %cl, %edi
movslq %edi, %rcx
sarq $0x1f, %rsi
addq %rsi, %rcx
addq $0x19, %rcx
cmpq %rcx, %rax
jae 0x386b6
movq %r15, (%rsp)
movl $0x7fffffff, %r15d # imm = 0x7FFFFFFF
movl %r13d, %eax
andl %r15d, %eax
andl %edx, %r15d
addq %rax, %r15
cmpl $0x40000000, %r15d # imm = 0x40000000
jb 0x38632
leaq 0x4d2a5(%rip), %rsi # 0x858be
movq %r12, %r13
xorl %r12d, %r12d
movq %r13, %rdi
xorl %eax, %eax
callq 0x1acb3
pushq $0x6
popq %r15
jmp 0x38744
orl %edx, %r13d
movl %r13d, %edx
shrl $0x1f, %edx
movq %r12, 0x8(%rsp)
movq %r12, %rdi
movl %r15d, %esi
callq 0x1ad45
testq %rax, %rax
je 0x386aa
movq %rax, %r12
movq %rbp, 0x10(%rsp)
movq %rax, %rbp
addq $0x18, %rbp
testl %r13d, %r13d
js 0x38705
leaq 0x18(%r14), %rsi
movl $0x7fffffff, %r13d # imm = 0x7FFFFFFF
movq 0x4(%r14), %rdx
andq %r13, %rdx
movq %rbp, %rdi
callq 0xe5c0
movq 0x4(%r14), %rdi
andq %r13, %rdi
addq %rbp, %rdi
movq (%rsp), %rax
leaq 0x18(%rax), %rsi
andq 0x4(%rax), %r13
movq %r13, %rdx
callq 0xe5c0
movb $0x0, (%rbp,%r15)
jmp 0x38736
pushq $0x6
popq %r15
xorl %r12d, %r12d
jmp 0x3873f
leaq 0x18(%r14), %rdi
movl %r13d, %eax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
leaq 0x18(%r15), %rsi
testl %r13d, %r13d
js 0x38769
addq %rax, %rdi
andl $0x7fffffff, %edx # imm = 0x7FFFFFFF
callq 0xe5c0
movq 0x4(%r14), %rax
movl 0x4(%r15), %ecx
addl %eax, %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
andq $-0x80000000, %rax # imm = 0x80000000
orq %rcx, %rax
movq %rax, 0x4(%r14)
movb $0x0, 0x18(%r14,%rcx)
jmp 0x38795
movl $0x7fffffff, %r15d # imm = 0x7FFFFFFF
movl 0x4(%r14), %edx
andl %r15d, %edx
movq %rbp, %rdi
movq %r14, %rsi
callq 0x3a875
movl 0x4(%r14), %edi
addl %edi, %edi
addq %rbp, %rdi
movq (%rsp), %rsi
andl 0x4(%rsi), %r15d
movl %r15d, %edx
callq 0x3a875
pushq $-0x7
popq %r15
movq 0x10(%rsp), %rbp
movq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1801e
movq %r13, %rdi
movq (%rsp), %rsi
movq %rbp, %rdx
callq 0x1801e
movq %r12, %r14
movq %r15, %rbx
jmp 0x387a3
leaq (%rdi,%rax,2), %rdi
addl %r8d, %r8d
movslq %r8d, %rdx
callq 0xe5c0
movq 0x4(%r14), %rax
movl 0x4(%r15), %ecx
addl %eax, %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
andq $-0x80000000, %rax # imm = 0x80000000
orq %rcx, %rax
movq %rax, 0x4(%r14)
movq %r12, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x1801e
movq %r14, %rax
movq %rbx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2e049
movq %rdx, %rbx
cmpl $0x6, %ebx
jne 0x38805
movq %r12, %rdi
movq %r15, %rsi
movq %rbp, %rdx
jmp 0x387f8
movq %r12, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x2e049
movq %rdx, %rbp
cmpl $0x6, %ebp
jne 0x3880d
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1801e
pushq $0x6
popq %rbx
xorl %r14d, %r14d
jmp 0x387a3
movq %rax, %r14
jmp 0x3857f
movq %rax, %r15
jmp 0x3858c
| JS_ConcatString:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbp, r8
mov r15, rcx
mov rbx, rdx
mov r14, rsi
mov r12, rdi
cmp ebx, 0FFFFFFF9h
jnz loc_387B8
loc_3857F:
mov eax, 0FFFFFFF9h
cmp ebp, eax
jnz loc_387D9
loc_3858C:
mov rdx, [r15+4]
test edx, 7FFFFFFFh
jz loc_38795
cmp dword ptr [r14], 1
mov r13, [r14+4]
jnz short loc_385F3
mov eax, r13d
xor eax, edx
js short loc_385F3
mov rax, [r12+18h]
mov rdi, r14
call qword ptr [rax+20h]
mov r13, [r14+4]
mov r8d, 7FFFFFFFh
movsxd rsi, r13d
mov edi, r13d
and edi, r8d
mov rdx, [r15+4]
and r8d, edx
add edi, r8d
mov ecx, edx
shr ecx, 1Fh
shl edi, cl
movsxd rcx, edi
sar rsi, 1Fh
add rcx, rsi
add rcx, 19h
cmp rax, rcx
jnb loc_386B6
loc_385F3:
mov [rsp+48h+var_48], r15
mov r15d, 7FFFFFFFh
mov eax, r13d
and eax, r15d
and r15d, edx
add r15, rax
cmp r15d, 40000000h
jb short loc_38632
lea rsi, aInvalidStringL; "invalid string length"
mov r13, r12
xor r12d, r12d
mov rdi, r13
xor eax, eax
call JS_ThrowRangeError
push 6
pop r15
jmp loc_38744
loc_38632:
or r13d, edx
mov edx, r13d
shr edx, 1Fh
mov [rsp+48h+var_40], r12
mov rdi, r12
mov esi, r15d
call js_alloc_string
test rax, rax
jz short loc_386AA
mov r12, rax
mov [rsp+48h+var_38], rbp
mov rbp, rax
add rbp, 18h
test r13d, r13d
js loc_38705
lea rsi, [r14+18h]
mov r13d, 7FFFFFFFh
mov rdx, [r14+4]
and rdx, r13
mov rdi, rbp
call _memcpy
mov rdi, [r14+4]
and rdi, r13
add rdi, rbp
mov rax, [rsp+48h+var_48]
lea rsi, [rax+18h]
and r13, [rax+4]
mov rdx, r13
call _memcpy
mov byte ptr [rbp+r15+0], 0
jmp loc_38736
loc_386AA:
push 6
pop r15
xor r12d, r12d
jmp loc_3873F
loc_386B6:
lea rdi, [r14+18h]
mov eax, r13d
and eax, 7FFFFFFFh
lea rsi, [r15+18h]
test r13d, r13d
js loc_38769
add rdi, rax
and edx, 7FFFFFFFh
call _memcpy
mov rax, [r14+4]
mov ecx, [r15+4]
add ecx, eax
and ecx, 7FFFFFFFh
and rax, 0FFFFFFFF80000000h
or rax, rcx
mov [r14+4], rax
mov byte ptr [r14+rcx+18h], 0
jmp loc_38795
loc_38705:
mov r15d, 7FFFFFFFh
mov edx, [r14+4]
and edx, r15d
mov rdi, rbp
mov rsi, r14
call copy_str16
mov edi, [r14+4]
add edi, edi
add rdi, rbp
mov rsi, [rsp+48h+var_48]
and r15d, [rsi+4]
mov edx, r15d
call copy_str16
loc_38736:
push 0FFFFFFFFFFFFFFF9h
pop r15
mov rbp, [rsp+48h+var_38]
loc_3873F:
mov r13, [rsp+48h+var_40]
loc_38744:
mov rdi, r13
mov rsi, r14
mov rdx, rbx
call JS_FreeValue
mov rdi, r13
mov rsi, [rsp+48h+var_48]
mov rdx, rbp
call JS_FreeValue
mov r14, r12
mov rbx, r15
jmp short loc_387A3
loc_38769:
lea rdi, [rdi+rax*2]
add r8d, r8d
movsxd rdx, r8d
call _memcpy
mov rax, [r14+4]
mov ecx, [r15+4]
add ecx, eax
and ecx, 7FFFFFFFh
and rax, 0FFFFFFFF80000000h
or rax, rcx
mov [r14+4], rax
loc_38795:
mov rdi, r12
mov rsi, r15
mov rdx, rbp
call JS_FreeValue
loc_387A3:
mov rax, r14
mov rdx, rbx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_387B8:
mov rdi, r12
mov rsi, r14
mov rdx, rbx
call JS_ToStringFree
mov rbx, rdx
cmp ebx, 6
jnz short loc_38805
mov rdi, r12
mov rsi, r15
mov rdx, rbp
jmp short loc_387F8
loc_387D9:
mov rdi, r12
mov rsi, r15
mov rdx, rbp
call JS_ToStringFree
mov rbp, rdx
cmp ebp, 6
jnz short loc_3880D
mov rdi, r12
mov rsi, r14
mov rdx, rbx
loc_387F8:
call JS_FreeValue
push 6
pop rbx
xor r14d, r14d
jmp short loc_387A3
loc_38805:
mov r14, rax
jmp loc_3857F
loc_3880D:
mov r15, rax
jmp loc_3858C
| long long JS_ConcatString(
long long a1,
long long a2,
long long a3,
unsigned 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; // rbp
long long v15; // r15
long long v16; // rbx
long long v17; // r14
long long v19; // rdx
long long v20; // r13
unsigned long long v21; // rax
long long v22; // r15
long long v23; // r13
long long v24; // r12
int v25; // r13d
long long v26; // rax
long long v27; // rbp
long long v28; // rdi
long long v29; // rax
long long v30; // rsi
long long v31; // rax
long long v32; // rcx
long long v34; // rax
long long v35; // rdx
long long v36; // rsi
long long v37; // rdx
long long v38; // rax
long long v39; // rdx
long long v40; // [rsp+0h] [rbp-48h]
long long v41; // [rsp+10h] [rbp-38h]
v14 = a5;
v15 = a4;
v16 = a3;
v17 = a2;
if ( (_DWORD)a3 != -7 )
{
v34 = JS_ToStringFree(a1, a2, a3);
v16 = v35;
if ( (_DWORD)v35 == 6 )
{
v36 = v15;
v37 = v14;
LABEL_26:
JS_FreeValue(a1, v36, v37);
return 0LL;
}
v17 = v34;
}
if ( (_DWORD)v14 == -7 )
goto LABEL_3;
v38 = JS_ToStringFree(a1, v15, v14);
v14 = v39;
if ( (_DWORD)v39 == 6 )
{
v36 = v17;
v37 = v16;
goto LABEL_26;
}
v15 = v38;
LABEL_3:
v19 = *(_QWORD *)(v15 + 4);
if ( (v19 & 0x7FFFFFFF) == 0 )
{
LABEL_20:
JS_FreeValue(a1, v15, v14);
return v17;
}
v20 = *(_QWORD *)(v17 + 4);
if ( *(_DWORD *)v17 == 1 && (int)(v19 ^ v20) >= 0 )
{
v21 = (*(long long ( **)(long long))(*(_QWORD *)(a1 + 24) + 32LL))(v17);
v20 = *(_QWORD *)(v17 + 4);
v19 = *(_QWORD *)(v15 + 4);
a5 = v19 & 0x7FFFFFFF;
a4 = ((long long)(int)v20 >> 31) + (int)(((v19 & 0x7FFFFFFF) + (v20 & 0x7FFFFFFF)) << ((int)v19 < 0)) + 25;
if ( v21 >= a4 )
{
v28 = v17 + 24;
v29 = v20 & 0x7FFFFFFF;
v30 = v15 + 24;
if ( (int)v20 < 0 )
{
memcpy(v28 + 2 * v29, v30, 2 * (int)v19);
*(_QWORD *)(v17 + 4) = ((unsigned int)*(_QWORD *)(v17 + 4) + *(_DWORD *)(v15 + 4)) & 0x7FFFFFFF | *(_QWORD *)(v17 + 4) & 0xFFFFFFFF80000000LL;
}
else
{
memcpy(v29 + v28, v30, v19 & 0x7FFFFFFF);
v31 = *(_QWORD *)(v17 + 4);
v32 = ((_DWORD)v31 + *(_DWORD *)(v15 + 4)) & 0x7FFFFFFF;
*(_QWORD *)(v17 + 4) = v32 | v31 & 0xFFFFFFFF80000000LL;
*(_BYTE *)(v17 + v32 + 24) = 0;
}
goto LABEL_20;
}
}
v40 = v15;
v22 = (v20 & 0x7FFFFFFF) + (v19 & 0x7FFFFFFF);
if ( (unsigned int)v22 < 0x40000000 )
{
v25 = v19 | v20;
v26 = js_alloc_string(a1, (unsigned int)v22, (unsigned int)v25 >> 31);
if ( v26 )
{
v24 = v26;
v41 = v14;
v27 = v26 + 24;
if ( v25 < 0 )
{
copy_str16(v26 + 24, v17, *(_DWORD *)(v17 + 4) & 0x7FFFFFFF);
copy_str16(v27 + (unsigned int)(2 * *(_DWORD *)(v17 + 4)), v40, *(_DWORD *)(v40 + 4) & 0x7FFFFFFF);
}
else
{
memcpy(v26 + 24, v17 + 24, *(_QWORD *)(v17 + 4) & 0x7FFFFFFFLL);
memcpy(v27 + (*(_QWORD *)(v17 + 4) & 0x7FFFFFFFLL), v40 + 24, *(_QWORD *)(v40 + 4) & 0x7FFFFFFFLL);
*(_BYTE *)(v27 + v22) = 0;
}
v14 = v41;
}
else
{
v24 = 0LL;
}
v23 = a1;
}
else
{
v23 = a1;
v24 = 0LL;
JS_ThrowRangeError(a1, (long long)"invalid string length", v19, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v40);
}
JS_FreeValue(v23, v17, v16);
JS_FreeValue(v23, v40, v14);
return v24;
}
| JS_ConcatString:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBP,R8
MOV R15,RCX
MOV RBX,RDX
MOV R14,RSI
MOV R12,RDI
CMP EBX,-0x7
JNZ 0x001387b8
LAB_0013857f:
MOV EAX,0xfffffff9
CMP EBP,EAX
JNZ 0x001387d9
LAB_0013858c:
MOV RDX,qword ptr [R15 + 0x4]
TEST EDX,0x7fffffff
JZ 0x00138795
CMP dword ptr [R14],0x1
MOV R13,qword ptr [R14 + 0x4]
JNZ 0x001385f3
MOV EAX,R13D
XOR EAX,EDX
JS 0x001385f3
MOV RAX,qword ptr [R12 + 0x18]
MOV RDI,R14
CALL qword ptr [RAX + 0x20]
MOV R13,qword ptr [R14 + 0x4]
MOV R8D,0x7fffffff
MOVSXD RSI,R13D
MOV EDI,R13D
AND EDI,R8D
MOV RDX,qword ptr [R15 + 0x4]
AND R8D,EDX
ADD EDI,R8D
MOV ECX,EDX
SHR ECX,0x1f
SHL EDI,CL
MOVSXD RCX,EDI
SAR RSI,0x1f
ADD RCX,RSI
ADD RCX,0x19
CMP RAX,RCX
JNC 0x001386b6
LAB_001385f3:
MOV qword ptr [RSP],R15
MOV R15D,0x7fffffff
MOV EAX,R13D
AND EAX,R15D
AND R15D,EDX
ADD R15,RAX
CMP R15D,0x40000000
JC 0x00138632
LEA RSI,[0x1858be]
MOV R13,R12
XOR R12D,R12D
MOV RDI,R13
XOR EAX,EAX
CALL 0x0011acb3
PUSH 0x6
POP R15
JMP 0x00138744
LAB_00138632:
OR R13D,EDX
MOV EDX,R13D
SHR EDX,0x1f
MOV qword ptr [RSP + 0x8],R12
MOV RDI,R12
MOV ESI,R15D
CALL 0x0011ad45
TEST RAX,RAX
JZ 0x001386aa
MOV R12,RAX
MOV qword ptr [RSP + 0x10],RBP
MOV RBP,RAX
ADD RBP,0x18
TEST R13D,R13D
JS 0x00138705
LEA RSI,[R14 + 0x18]
MOV R13D,0x7fffffff
MOV RDX,qword ptr [R14 + 0x4]
AND RDX,R13
MOV RDI,RBP
CALL 0x0010e5c0
MOV RDI,qword ptr [R14 + 0x4]
AND RDI,R13
ADD RDI,RBP
MOV RAX,qword ptr [RSP]
LEA RSI,[RAX + 0x18]
AND R13,qword ptr [RAX + 0x4]
MOV RDX,R13
CALL 0x0010e5c0
MOV byte ptr [RBP + R15*0x1],0x0
JMP 0x00138736
LAB_001386aa:
PUSH 0x6
POP R15
XOR R12D,R12D
JMP 0x0013873f
LAB_001386b6:
LEA RDI,[R14 + 0x18]
MOV EAX,R13D
AND EAX,0x7fffffff
LEA RSI,[R15 + 0x18]
TEST R13D,R13D
JS 0x00138769
ADD RDI,RAX
AND EDX,0x7fffffff
CALL 0x0010e5c0
MOV RAX,qword ptr [R14 + 0x4]
MOV ECX,dword ptr [R15 + 0x4]
ADD ECX,EAX
AND ECX,0x7fffffff
AND RAX,-0x80000000
OR RAX,RCX
MOV qword ptr [R14 + 0x4],RAX
MOV byte ptr [R14 + RCX*0x1 + 0x18],0x0
JMP 0x00138795
LAB_00138705:
MOV R15D,0x7fffffff
MOV EDX,dword ptr [R14 + 0x4]
AND EDX,R15D
MOV RDI,RBP
MOV RSI,R14
CALL 0x0013a875
MOV EDI,dword ptr [R14 + 0x4]
ADD EDI,EDI
ADD RDI,RBP
MOV RSI,qword ptr [RSP]
AND R15D,dword ptr [RSI + 0x4]
MOV EDX,R15D
CALL 0x0013a875
LAB_00138736:
PUSH -0x7
POP R15
MOV RBP,qword ptr [RSP + 0x10]
LAB_0013873f:
MOV R13,qword ptr [RSP + 0x8]
LAB_00138744:
MOV RDI,R13
MOV RSI,R14
MOV RDX,RBX
CALL 0x0011801e
MOV RDI,R13
MOV RSI,qword ptr [RSP]
MOV RDX,RBP
CALL 0x0011801e
MOV R14,R12
MOV RBX,R15
JMP 0x001387a3
LAB_00138769:
LEA RDI,[RDI + RAX*0x2]
ADD R8D,R8D
MOVSXD RDX,R8D
CALL 0x0010e5c0
MOV RAX,qword ptr [R14 + 0x4]
MOV ECX,dword ptr [R15 + 0x4]
ADD ECX,EAX
AND ECX,0x7fffffff
AND RAX,-0x80000000
OR RAX,RCX
MOV qword ptr [R14 + 0x4],RAX
LAB_00138795:
MOV RDI,R12
MOV RSI,R15
MOV RDX,RBP
CALL 0x0011801e
LAB_001387a3:
MOV RAX,R14
MOV RDX,RBX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001387b8:
MOV RDI,R12
MOV RSI,R14
MOV RDX,RBX
CALL 0x0012e049
MOV RBX,RDX
CMP EBX,0x6
JNZ 0x00138805
MOV RDI,R12
MOV RSI,R15
MOV RDX,RBP
JMP 0x001387f8
LAB_001387d9:
MOV RDI,R12
MOV RSI,R15
MOV RDX,RBP
CALL 0x0012e049
MOV RBP,RDX
CMP EBP,0x6
JNZ 0x0013880d
MOV RDI,R12
MOV RSI,R14
MOV RDX,RBX
LAB_001387f8:
CALL 0x0011801e
PUSH 0x6
POP RBX
XOR R14D,R14D
JMP 0x001387a3
LAB_00138805:
MOV R14,RAX
JMP 0x0013857f
LAB_0013880d:
MOV R15,RAX
JMP 0x0013858c
|
int1 [16]
JS_ConcatString(long param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5)
{
int1 auVar1 [16];
ulong uVar2;
long lVar3;
uint uVar4;
void *__dest;
uint uVar5;
int *piVar6;
long lVar7;
long lVar8;
int8 uVar9;
int1 auVar10 [16];
int1 auVar11 [16];
auVar11._8_8_ = param_5;
auVar11._0_8_ = param_4;
auVar10._8_8_ = param_3;
auVar10._0_8_ = param_2;
if (((int)param_3 == -7) ||
(auVar10 = JS_ToStringFree(param_1,param_2,param_3), auVar1 = auVar11, auVar10._8_4_ != 6)) {
piVar6 = auVar10._0_8_;
if (((int)param_5 == -7) ||
(auVar11 = JS_ToStringFree(param_1,param_4,param_5), auVar1 = auVar10, auVar11._8_4_ != 6)) {
lVar7 = auVar11._0_8_;
uVar4 = (uint)*(ulong *)(lVar7 + 4);
if ((*(ulong *)(lVar7 + 4) & 0x7fffffff) == 0) {
LAB_00138795:
JS_FreeValue(param_1,lVar7,auVar11._8_8_);
return auVar10;
}
uVar5 = (uint)*(int8 *)(piVar6 + 1);
if ((*piVar6 == 1) && (-1 < (int)(uVar5 ^ uVar4))) {
uVar2 = (**(code **)(*(long *)(param_1 + 0x18) + 0x20))(piVar6);
uVar5 = (uint)*(int8 *)(piVar6 + 1);
uVar4 = (uint)*(ulong *)(lVar7 + 4);
if ((long)(int)((uVar5 & 0x7fffffff) + (uVar4 & 0x7fffffff) <<
((byte)(*(ulong *)(lVar7 + 4) >> 0x1f) & 1)) + ((long)(int)uVar5 >> 0x1f) +
0x19U <= uVar2) {
if ((int)uVar5 < 0) {
memcpy((void *)((long)piVar6 + (ulong)(uVar5 & 0x7fffffff) * 2 + 0x18),
(void *)(lVar7 + 0x18),(long)(int)((uVar4 & 0x7fffffff) * 2));
*(ulong *)(piVar6 + 1) =
*(ulong *)(piVar6 + 1) & 0xffffffff80000000 |
(ulong)(*(int *)(lVar7 + 4) + (int)*(ulong *)(piVar6 + 1) & 0x7fffffff);
}
else {
memcpy((void *)((long)piVar6 + (ulong)(uVar5 & 0x7fffffff) + 0x18),
(void *)(lVar7 + 0x18),(ulong)(uVar4 & 0x7fffffff));
uVar2 = (ulong)(*(int *)(lVar7 + 4) + (int)*(ulong *)(piVar6 + 1) & 0x7fffffff);
*(ulong *)(piVar6 + 1) = *(ulong *)(piVar6 + 1) & 0xffffffff80000000 | uVar2;
*(int1 *)((long)piVar6 + uVar2 + 0x18) = 0;
}
goto LAB_00138795;
}
}
lVar8 = (ulong)(uVar4 & 0x7fffffff) + (ulong)(uVar5 & 0x7fffffff);
if ((uint)lVar8 < 0x40000000) {
lVar3 = js_alloc_string(param_1,lVar8,(uVar5 | uVar4) >> 0x1f);
if (lVar3 == 0) {
uVar9 = 6;
lVar3 = 0;
}
else {
__dest = (void *)(lVar3 + 0x18);
if ((int)(uVar5 | uVar4) < 0) {
copy_str16(__dest,piVar6,piVar6[1] & 0x7fffffff);
copy_str16((ulong)(uint)(piVar6[1] * 2) + (long)__dest,lVar7,
*(uint *)(lVar7 + 4) & 0x7fffffff);
}
else {
memcpy(__dest,piVar6 + 6,*(ulong *)(piVar6 + 1) & 0x7fffffff);
memcpy((void *)((*(ulong *)(piVar6 + 1) & 0x7fffffff) + (long)__dest),
(void *)(lVar7 + 0x18),*(ulong *)(lVar7 + 4) & 0x7fffffff);
*(int1 *)((long)__dest + lVar8) = 0;
}
uVar9 = 0xfffffffffffffff9;
}
}
else {
lVar3 = 0;
JS_ThrowRangeError(param_1,"invalid string length");
uVar9 = 6;
}
auVar1._8_8_ = uVar9;
auVar1._0_8_ = lVar3;
JS_FreeValue(param_1,piVar6,auVar10._8_8_);
JS_FreeValue(param_1,lVar7,auVar11._8_8_);
return auVar1;
}
}
JS_FreeValue(param_1,auVar1._0_8_,auVar1._8_8_);
return ZEXT816(6) << 0x40;
}
| |
53,969 | end_server | eloqsql/libmariadb/libmariadb/mariadb_lib.c | static void
end_server(MYSQL *mysql)
{
/* if net->error 2 and reconnect is activated, we need to inform
connection handler */
if (mysql->net.pvio != 0)
{
ma_pvio_close(mysql->net.pvio);
mysql->net.pvio= 0; /* Marker */
}
ma_net_end(&mysql->net);
free_old_query(mysql);
return;
} | O0 | c | end_server:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x39e7d
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x47a40
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x69980
movq -0x8(%rbp), %rdi
callq 0x42040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| end_server:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
cmp qword ptr [rax], 0
jz short loc_39E7D
mov rax, [rbp+var_8]
mov rdi, [rax]
call ma_pvio_close
mov rax, [rbp+var_8]
mov qword ptr [rax], 0
loc_39E7D:
mov rdi, [rbp+var_8]
call ma_net_end
mov rdi, [rbp+var_8]
call free_old_query
add rsp, 10h
pop rbp
retn
| long long end_server(_QWORD *a1)
{
if ( *a1 )
{
ma_pvio_close(*a1);
*a1 = 0LL;
}
ma_net_end(a1);
return free_old_query(a1);
}
| end_server:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX],0x0
JZ 0x00139e7d
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX]
CALL 0x00147a40
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],0x0
LAB_00139e7d:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00169980
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00142040
ADD RSP,0x10
POP RBP
RET
|
void end_server(long *param_1)
{
if (*param_1 != 0) {
ma_pvio_close(*param_1);
*param_1 = 0;
}
ma_net_end(param_1);
free_old_query(param_1);
return;
}
| |
53,970 | string_format[abi:cxx11](char const*, ...) | llama.cpp/examples/llava/clip-impl.h | static std::string string_format(const char * fmt, ...) {
va_list ap;
va_list ap2;
va_start(ap, fmt);
va_copy(ap2, ap);
int size = vsnprintf(NULL, 0, fmt, ap);
GGML_ASSERT(size >= 0 && size < INT_MAX); // NOLINT
std::vector<char> buf(size + 1);
int size2 = vsnprintf(buf.data(), size + 1, fmt, ap2);
GGML_ASSERT(size2 == size);
va_end(ap2);
va_end(ap);
return std::string(buf.data(), buf.size());
} | O3 | c | string_format[abi:cxx11](char const*, ...):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x60(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x28f2d
movaps %xmm0, 0x90(%rsp)
movaps %xmm1, 0xa0(%rsp)
movaps %xmm2, 0xb0(%rsp)
movaps %xmm3, 0xc0(%rsp)
movaps %xmm4, 0xd0(%rsp)
movaps %xmm5, 0xe0(%rsp)
movaps %xmm6, 0xf0(%rsp)
movaps %xmm7, 0x100(%rsp)
movabsq $0x3000000010, %rax # imm = 0x3000000010
leaq 0x40(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x140(%rsp), %rax
movq %rax, 0x8(%rcx)
movq %rsi, 0x10(%rcx)
movq %rsi, 0x30(%rsp)
movq (%rcx), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%rcx), %rax
movq %rax, 0x28(%rsp)
xorl %edi, %edi
xorl %esi, %esi
movq %r14, %rdx
callq 0x1cc50
cmpl $0x7fffffff, %eax # imm = 0x7FFFFFFF
jae 0x28ff2
movl %eax, %r15d
leal 0x1(%r15), %r12d
leaq 0x8(%rsp), %r13
leaq 0x7(%rsp), %rdx
movq %r13, %rdi
movq %r12, %rsi
callq 0x1cdd0
movq (%r13), %rdi
leaq 0x20(%rsp), %rcx
movq %r12, %rsi
movq %r14, %rdx
callq 0x1cc50
cmpl %r15d, %eax
jne 0x29013
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
subq %rsi, %rdx
leaq 0x7(%rsp), %rcx
movq %rbx, %rdi
callq 0x1d660
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x28fde
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x1d480
movq %rbx, %rax
addq $0x110, %rsp # imm = 0x110
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x252cb(%rip), %rdi # 0x4e2c4
leaq 0x25112(%rip), %rdx # 0x4e112
leaq 0x25303(%rip), %rcx # 0x4e30a
movl $0xe9, %esi
xorl %eax, %eax
callq 0x1e350
leaq 0x252aa(%rip), %rdi # 0x4e2c4
leaq 0x250f1(%rip), %rdx # 0x4e112
leaq 0x252fe(%rip), %rcx # 0x4e326
movl $0xec, %esi
xorl %eax, %eax
callq 0x1e350
jmp 0x29036
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x29050
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x1d480
movq %rbx, %rdi
callq 0x1e530
| _ZL13string_formatB5cxx11PKcz_0:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 110h
mov r14, rsi
mov rbx, rdi
lea rsi, [rsp+138h+var_D8]
mov [rsi+10h], rdx
mov [rsi+18h], rcx
mov [rsi+20h], r8
mov [rsi+28h], r9
test al, al
jz short loc_28F2D
movaps [rsp+138h+var_A8], xmm0
movaps [rsp+138h+var_98], xmm1
movaps [rsp+138h+var_88], xmm2
movaps [rsp+138h+var_78], xmm3
movaps [rsp+138h+var_68], xmm4
movaps [rsp+138h+var_58], xmm5
movaps [rsp+138h+var_48], xmm6
movaps [rsp+138h+var_38], xmm7
loc_28F2D:
mov rax, 3000000010h
lea rcx, [rsp+138h+var_F8]
mov [rcx], rax
lea rax, [rsp+138h+arg_0]
mov [rcx+8], rax
mov [rcx+10h], rsi
mov [rsp+138h+var_108], rsi
mov rax, [rcx]
mov [rsp+138h+var_118], rax
mov rax, [rcx+8]
mov [rsp+138h+var_110], rax
xor edi, edi
xor esi, esi
mov rdx, r14
call _vsnprintf
cmp eax, 7FFFFFFFh
jnb short loc_28FF2
mov r15d, eax
lea r12d, [r15+1]
lea r13, [rsp+138h+var_130]
lea rdx, [rsp+138h+var_131]
mov rdi, r13
mov rsi, r12
call __ZNSt6vectorIcSaIcEEC2EmRKS0_; std::vector<char>::vector(ulong,std::allocator<char> const&)
mov rdi, [r13+0]
lea rcx, [rsp+138h+var_118]
mov rsi, r12
mov rdx, r14
call _vsnprintf
cmp eax, r15d
jnz short loc_29013
mov rsi, [rsp+138h+var_130]
mov rdx, [rsp+138h+var_128]
sub rdx, rsi
lea rcx, [rsp+138h+var_131]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2EPKcmRKS3_; std::string::basic_string(char const*,ulong,std::allocator<char> const&)
mov rdi, [rsp+138h+var_130]; void *
test rdi, rdi
jz short loc_28FDE
mov rsi, [rsp+138h+var_120]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_28FDE:
mov rax, rbx
add rsp, 110h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
loc_28FF2:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aSize0SizeIntMa; "size >= 0 && size < INT_MAX"
mov esi, 0E9h
xor eax, eax
call _ggml_abort
loc_29013:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aSize2Size; "size2 == size"
mov esi, 0ECh
xor eax, eax
call _ggml_abort
jmp short $+2
loc_29036:
mov rbx, rax
mov rdi, [rsp+138h+var_130]; void *
test rdi, rdi
jz short loc_29050
mov rsi, [rsp+138h+var_120]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_29050:
mov rdi, rbx
call __Unwind_Resume
| long long string_format[abi:cxx11](
long long a1,
const char *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)
{
unsigned int v15; // eax
unsigned int v16; // r15d
long long v17; // r12
long long v19; // rbx
char v20; // [rsp+7h] [rbp-131h] BYREF
void *v21[2]; // [rsp+8h] [rbp-130h] BYREF
long long v22; // [rsp+18h] [rbp-120h]
_QWORD v23[4]; // [rsp+20h] [rbp-118h] BYREF
_QWORD v24[4]; // [rsp+40h] [rbp-F8h] BYREF
_BYTE v25[16]; // [rsp+60h] [rbp-D8h] BYREF
long long v26; // [rsp+70h] [rbp-C8h]
long long v27; // [rsp+78h] [rbp-C0h]
long long v28; // [rsp+80h] [rbp-B8h]
long long v29; // [rsp+88h] [rbp-B0h]
__m128 v30; // [rsp+90h] [rbp-A8h]
__m128 v31; // [rsp+A0h] [rbp-98h]
__m128 v32; // [rsp+B0h] [rbp-88h]
__m128 v33; // [rsp+C0h] [rbp-78h]
__m128 v34; // [rsp+D0h] [rbp-68h]
__m128 v35; // [rsp+E0h] [rbp-58h]
__m128 v36; // [rsp+F0h] [rbp-48h]
__m128 v37; // [rsp+100h] [rbp-38h]
v30 = a7;
v31 = a8;
v32 = a9;
v33 = a10;
v34 = a11;
v35 = a12;
v36 = a13;
v37 = a14;
v26 = a3;
v27 = a4;
v28 = a5;
v29 = a6;
v24[0] = 0x3000000010LL;
v24[1] = &a15;
v24[2] = v25;
v23[2] = v25;
v23[0] = 0x3000000010LL;
v23[1] = &a15;
v15 = vsnprintf(0LL, 0LL, a2, v24);
if ( v15 >= 0x7FFFFFFF )
{
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/examples/llava/clip-impl.h",
233LL,
"GGML_ASSERT(%s) failed",
"size >= 0 && size < INT_MAX");
LABEL_7:
v19 = ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/examples/llava/clip-impl.h",
236LL,
"GGML_ASSERT(%s) failed",
"size2 == size");
if ( v21[0] )
operator delete(v21[0], v22 - (unsigned long long)v21[0]);
_Unwind_Resume(v19);
}
v16 = v15;
v17 = v15 + 1;
std::vector<char>::vector(v21, v17, &v20);
if ( (unsigned int)vsnprintf(v21[0], v17, a2, v23) != v16 )
goto LABEL_7;
std::string::basic_string(a1, v21[0], (char *)v21[1] - (char *)v21[0], &v20);
if ( v21[0] )
operator delete(v21[0], v22 - (unsigned long long)v21[0]);
return a1;
}
| string_format[abi:cxx11]:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x110
MOV R14,RSI
MOV RBX,RDI
LEA RSI,[RSP + 0x60]
MOV qword ptr [RSI + 0x10],RDX
MOV qword ptr [RSI + 0x18],RCX
MOV qword ptr [RSI + 0x20],R8
MOV qword ptr [RSI + 0x28],R9
TEST AL,AL
JZ 0x00128f2d
MOVAPS xmmword ptr [RSP + 0x90],XMM0
MOVAPS xmmword ptr [RSP + 0xa0],XMM1
MOVAPS xmmword ptr [RSP + 0xb0],XMM2
MOVAPS xmmword ptr [RSP + 0xc0],XMM3
MOVAPS xmmword ptr [RSP + 0xd0],XMM4
MOVAPS xmmword ptr [RSP + 0xe0],XMM5
MOVAPS xmmword ptr [RSP + 0xf0],XMM6
MOVAPS xmmword ptr [RSP + 0x100],XMM7
LAB_00128f2d:
MOV RAX,0x3000000010
LEA RCX,[RSP + 0x40]
MOV qword ptr [RCX],RAX
LEA RAX,[RSP + 0x140]
MOV qword ptr [RCX + 0x8],RAX
MOV qword ptr [RCX + 0x10],RSI
MOV qword ptr [RSP + 0x30],RSI
MOV RAX,qword ptr [RCX]
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [RCX + 0x8]
MOV qword ptr [RSP + 0x28],RAX
XOR EDI,EDI
XOR ESI,ESI
MOV RDX,R14
CALL 0x0011cc50
CMP EAX,0x7fffffff
JNC 0x00128ff2
MOV R15D,EAX
LEA R12D,[R15 + 0x1]
LEA R13,[RSP + 0x8]
LEA RDX,[RSP + 0x7]
MOV RDI,R13
MOV RSI,R12
CALL 0x0011cdd0
MOV RDI,qword ptr [R13]
LEA RCX,[RSP + 0x20]
MOV RSI,R12
MOV RDX,R14
CALL 0x0011cc50
CMP EAX,R15D
JNZ 0x00129013
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
SUB RDX,RSI
LAB_00128fba:
LEA RCX,[RSP + 0x7]
MOV RDI,RBX
CALL 0x0011d660
LAB_00128fc7:
MOV RDI,qword ptr [RSP + 0x8]
TEST RDI,RDI
JZ 0x00128fde
MOV RSI,qword ptr [RSP + 0x18]
SUB RSI,RDI
CALL 0x0011d480
LAB_00128fde:
MOV RAX,RBX
ADD RSP,0x110
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
LAB_00128ff2:
LEA RDI,[0x14e2c4]
LEA RDX,[0x14e112]
LEA RCX,[0x14e30a]
MOV ESI,0xe9
XOR EAX,EAX
CALL 0x0011e350
LAB_00129013:
LEA RDI,[0x14e2c4]
LEA RDX,[0x14e112]
LEA RCX,[0x14e326]
MOV ESI,0xec
XOR EAX,EAX
CALL 0x0011e350
LAB_00129034:
JMP 0x00129036
LAB_00129036:
MOV RBX,RAX
MOV RDI,qword ptr [RSP + 0x8]
TEST RDI,RDI
JZ 0x00129050
MOV RSI,qword ptr [RSP + 0x18]
SUB RSI,RDI
CALL 0x0011d480
LAB_00129050:
MOV RDI,RBX
CALL 0x0011e530
|
/* string_format[abi:cxx11](char const*, ...) */
char * string_format_abi_cxx11_(char *param_1,...)
{
char in_AL;
uint uVar1;
uint uVar2;
int8 uVar3;
int8 in_RCX;
int8 in_RDX;
char *in_RSI;
int8 in_R8;
int8 in_R9;
int8 in_XMM0_Qa;
int8 in_XMM1_Qa;
int8 in_XMM2_Qa;
int8 in_XMM3_Qa;
int8 in_XMM4_Qa;
int8 in_XMM5_Qa;
int8 in_XMM6_Qa;
int8 in_XMM7_Qa;
allocator local_131;
char *local_130;
long local_128;
long local_120;
int8 local_118;
int1 *local_110;
int1 *local_108;
int8 local_f8;
int1 *local_f0;
int1 *local_e8;
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;
local_108 = local_d8;
if (in_AL != '\0') {
local_a8 = in_XMM0_Qa;
local_98 = in_XMM1_Qa;
local_88 = in_XMM2_Qa;
local_78 = in_XMM3_Qa;
local_68 = in_XMM4_Qa;
local_58 = in_XMM5_Qa;
local_48 = in_XMM6_Qa;
local_38 = in_XMM7_Qa;
}
local_f8 = 0x3000000010;
local_110 = &stack0x00000008;
local_118 = 0x3000000010;
local_f0 = local_110;
local_e8 = local_108;
local_c8 = in_RDX;
local_c0 = in_RCX;
local_b8 = in_R8;
local_b0 = in_R9;
uVar1 = vsnprintf((char *)0x0,0,in_RSI,&local_f8);
if (uVar1 < 0x7fffffff) {
std::vector<char,std::allocator<char>>::vector
((ulong)&local_130,(allocator *)(ulong)(uVar1 + 1));
uVar2 = vsnprintf(local_130,(size_t)(ulong)(uVar1 + 1),in_RSI,&local_118);
if (uVar2 == uVar1) {
/* try { // try from 00128fba to 00128fc6 has its CatchHandler @ 00129034 */
std::__cxx11::string::string
((string *)param_1,local_130,local_128 - (long)local_130,&local_131);
if (local_130 != (char *)0x0) {
operator_delete(local_130,local_120 - (long)local_130);
}
return param_1;
}
}
else {
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/examples/llava/clip-impl.h",0xe9,
"GGML_ASSERT(%s) failed","size >= 0 && size < INT_MAX");
}
/* try { // try from 00129013 to 00129033 has its CatchHandler @ 00129036 */
uVar3 = ggml_abort("/workspace/llm4binary/github2025/llama.cpp/examples/llava/clip-impl.h",0xec,
"GGML_ASSERT(%s) failed","size2 == size");
/* catch() { ... } // from try @ 00128fba with catch @ 00129034 */
/* catch() { ... } // from try @ 00129013 with catch @ 00129036 */
if (local_130 != (char *)0x0) {
operator_delete(local_130,local_120 - (long)local_130);
}
/* WARNING: Subroutine does not return */
_Unwind_Resume(uVar3);
}
| |
53,971 | minja::Parser::parseLogicalAnd() | monkey531[P]llama/common/minja.hpp | std::shared_ptr<Expression> parseLogicalAnd() {
auto left = parseLogicalNot();
if (!left) throw std::runtime_error("Expected left side of 'logical and' expression");
static std::regex and_tok(R"(and\b)");
auto location = get_location();
while (!consumeToken(and_tok).empty()) {
auto right = parseLogicalNot();
if (!right) throw std::runtime_error("Expected right side of 'and' expression");
left = std::make_shared<BinaryOpExpr>(location, std::move(left), std::move(right), BinaryOpExpr::Op::And);
}
return left;
} | O2 | cpp | minja::Parser::parseLogicalAnd():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x66b44
cmpq $0x0, (%rbx)
je 0x66a31
leaq 0x9e784(%rip), %rax # 0x1050c8
movb (%rax), %al
testb %al, %al
je 0x66a61
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x64e64
leaq 0x28(%rsp), %rbp
leaq 0x48(%rsp), %r12
leaq 0xc(%rsp), %r13
movq %rbp, %rdi
movq %r14, %rsi
leaq 0x9e731(%rip), %rdx # 0x1050a8
pushq $0x1
popq %rcx
callq 0x65288
movq 0x30(%rsp), %r15
movq %rbp, %rdi
callq 0x25258
testq %r15, %r15
je 0x669e3
movq %rbp, %rdi
movq %r14, %rsi
callq 0x66b44
cmpq $0x0, 0x28(%rsp)
je 0x669ff
movl $0xe, 0xc(%rsp)
movq %r12, %rdi
leaq 0x10(%rsp), %rsi
movq %rbx, %rdx
movq %rbp, %rcx
movq %r13, %r8
callq 0x66b1c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x75c5a
leaq 0x50(%rsp), %rdi
callq 0x37354
leaq 0x30(%rsp), %rdi
callq 0x37354
jmp 0x6696a
leaq 0x18(%rsp), %rdi
callq 0x37354
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x24470
movq %rax, %r15
leaq 0x522b1(%rip), %rsi # 0xb8cc2
movq %rax, %rdi
callq 0x24330
movq 0x9d5d0(%rip), %rsi # 0x103ff0
movq 0x9d531(%rip), %rdx # 0x103f58
movq %r15, %rdi
callq 0x24f50
jmp 0x66a61
pushq $0x10
popq %rdi
callq 0x24470
movq %rax, %r15
leaq 0x5224a(%rip), %rsi # 0xb8c8d
movq %rax, %rdi
callq 0x24330
movq 0x9d59e(%rip), %rsi # 0x103ff0
movq 0x9d4ff(%rip), %rdx # 0x103f58
movq %r15, %rdi
callq 0x24f50
leaq 0x9e660(%rip), %rdi # 0x1050c8
callq 0x25060
testl %eax, %eax
je 0x6694e
leaq 0x9e62c(%rip), %rdi # 0x1050a8
leaq 0x52239(%rip), %rsi # 0xb8cbc
pushq $0x10
popq %rdx
callq 0x2b33e
leaq -0x3b69e(%rip), %rdi # 0x2b3f4
leaq 0x9e60f(%rip), %rsi # 0x1050a8
leaq 0x9de98(%rip), %rdx # 0x104938
callq 0x24800
leaq 0x9e61c(%rip), %rdi # 0x1050c8
callq 0x245f0
jmp 0x6694e
movq %rax, %r14
leaq 0x9e608(%rip), %rdi # 0x1050c8
callq 0x245e0
jmp 0x66b08
jmp 0x66ad6
movq %rax, %r14
movq %r15, %rdi
callq 0x246b0
jmp 0x66b08
movq %rax, %r14
jmp 0x66b08
jmp 0x66aec
movq %rax, %r14
movq %r15, %rdi
callq 0x246b0
jmp 0x66aef
jmp 0x66afb
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x37354
jmp 0x66afe
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x37354
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x37354
movq %r14, %rdi
callq 0x24fe0
| _ZN5minja6Parser15parseLogicalAndEv:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov r14, rsi
mov rbx, rdi
call _ZN5minja6Parser15parseLogicalNotEv; minja::Parser::parseLogicalNot(void)
cmp qword ptr [rbx], 0
jz loc_66A31
lea rax, _ZGVZN5minja6Parser15parseLogicalAndEvE7and_tokB5cxx11; `guard variable for'minja::Parser::parseLogicalAnd(void)::and_tok
mov al, [rax]
test al, al
jz loc_66A61
loc_6694E:
lea rdi, [rsp+88h+var_78]; this
mov rsi, r14
call _ZNK5minja6Parser12get_locationEv; minja::Parser::get_location(void)
lea rbp, [rsp+88h+var_60]
lea r12, [rsp+88h+var_40]
lea r13, [rsp+88h+var_7C]
loc_6696A:
mov rdi, rbp
mov rsi, r14
lea rdx, _ZZN5minja6Parser15parseLogicalAndEvE7and_tokB5cxx11; minja::Parser::parseLogicalAnd(void)::and_tok
push 1
pop rcx
call _ZN5minja6Parser12consumeTokenERKNSt7__cxx1111basic_regexIcNS1_12regex_traitsIcEEEENS_13SpaceHandlingE; minja::Parser::consumeToken(std::basic_regex<char,std::regex_traits<char>> const&,minja::SpaceHandling)
mov r15, [rsp+88h+var_58]
mov rdi, rbp; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test r15, r15
jz short loc_669E3
mov rdi, rbp; this
mov rsi, r14
call _ZN5minja6Parser15parseLogicalNotEv; minja::Parser::parseLogicalNot(void)
cmp [rsp+88h+var_60], 0
jz short loc_669FF
mov [rsp+88h+var_7C], 0Eh
mov rdi, r12
lea rsi, [rsp+88h+var_78]
mov rdx, rbx
mov rcx, rbp
mov r8, r13
call _ZSt11make_sharedIN5minja12BinaryOpExprEJRNS0_8LocationESt10shared_ptrINS0_10ExpressionEES6_NS1_2OpEEES4_IT_EDpOT0_; std::make_shared<minja::BinaryOpExpr,minja::Location &,std::shared_ptr<minja::Expression>,std::shared_ptr<minja::Expression>,minja::BinaryOpExpr::Op>(minja::Location &,std::shared_ptr<minja::Expression>,std::shared_ptr<minja::Expression>,minja::BinaryOpExpr::Op &&)
mov rdi, rbx
mov rsi, r12
call _ZNSt12__shared_ptrIN5minja10ExpressionELN9__gnu_cxx12_Lock_policyE2EEaSINS0_12BinaryOpExprEEENSt9enable_ifIXsr20__sp_compatible_withIPT_PS1_EE5valueERS4_E4typeEOS_IS8_LS3_2EE
lea rdi, [rsp+88h+var_38]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea rdi, [rsp+88h+var_58]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
jmp short loc_6696A
loc_669E3:
lea rdi, [rsp+88h+var_70]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rax, rbx
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_669FF:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r15, rax
lea rsi, aExpectedRightS_0; "Expected right side of 'and' expression"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r15; void *
call ___cxa_throw
jmp short loc_66A61
loc_66A31:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r15, rax
lea rsi, aExpectedLeftSi_0; "Expected left side of 'logical and' exp"...
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r15; void *
call ___cxa_throw
loc_66A61:
lea rdi, _ZGVZN5minja6Parser15parseLogicalAndEvE7and_tokB5cxx11; __guard *
call ___cxa_guard_acquire
test eax, eax
jz loc_6694E
lea rdi, _ZZN5minja6Parser15parseLogicalAndEvE7and_tokB5cxx11; minja::Parser::parseLogicalAnd(void)::and_tok
lea rsi, aAndB; "and\\b"
push 10h
pop rdx
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEEC2EPKcNSt15regex_constants18syntax_option_typeE; std::basic_regex<char,std::regex_traits<char>>::basic_regex(char const*,std::regex_constants::syntax_option_type)
lea rdi, _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; lpfunc
lea rsi, _ZZN5minja6Parser15parseLogicalAndEvE7and_tokB5cxx11; obj
lea rdx, __dso_handle; lpdso_handle
call ___cxa_atexit
lea rdi, _ZGVZN5minja6Parser15parseLogicalAndEvE7and_tokB5cxx11; __guard *
call ___cxa_guard_release
jmp loc_6694E
mov r14, rax
lea rdi, _ZGVZN5minja6Parser15parseLogicalAndEvE7and_tokB5cxx11; __guard *
call ___cxa_guard_abort
jmp short loc_66B08
jmp short loc_66AD6
mov r14, rax
mov rdi, r15; void *
call ___cxa_free_exception
jmp short loc_66B08
loc_66AD6:
mov r14, rax
jmp short loc_66B08
jmp short loc_66AEC
mov r14, rax
mov rdi, r15; void *
call ___cxa_free_exception
jmp short loc_66AEF
jmp short loc_66AFB
loc_66AEC:
mov r14, rax
loc_66AEF:
lea rdi, [rsp+arg_28]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
jmp short loc_66AFE
loc_66AFB:
mov r14, rax
loc_66AFE:
lea rdi, [rsp+arg_10]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
loc_66B08:
add rbx, 8
mov rdi, rbx
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rdi, r14
call __Unwind_Resume
| minja::Parser * minja::Parser::parseLogicalAnd(minja::Parser *this, _QWORD *a2)
{
long long v2; // r15
std::runtime_error *v4; // r15
std::runtime_error *exception; // r15
int v6; // [rsp+Ch] [rbp-7Ch] BYREF
_BYTE v7[8]; // [rsp+10h] [rbp-78h] BYREF
long long v8; // [rsp+18h] [rbp-70h] BYREF
long long v9; // [rsp+28h] [rbp-60h] BYREF
_QWORD v10[3]; // [rsp+30h] [rbp-58h] BYREF
_BYTE v11[8]; // [rsp+48h] [rbp-40h] BYREF
_QWORD v12[7]; // [rsp+50h] [rbp-38h] BYREF
minja::Parser::parseLogicalNot(this);
if ( !*(_QWORD *)this )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Expected left side of 'logical and' expression");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( !(_BYTE)`guard variable for'minja::Parser::parseLogicalAnd(void)::and_tok[abi:cxx11]
&& __cxa_guard_acquire(&`guard variable for'minja::Parser::parseLogicalAnd(void)::and_tok[abi:cxx11]) )
{
std::basic_regex<char,std::regex_traits<char>>::basic_regex(
(long long)&minja::Parser::parseLogicalAnd(void)::and_tok[abi:cxx11],
(long long)"and\\b",
0x10u);
__cxa_atexit(
(void (*)(void *))std::basic_regex<char,std::regex_traits<char>>::~basic_regex,
&minja::Parser::parseLogicalAnd(void)::and_tok[abi:cxx11],
&_dso_handle);
__cxa_guard_release(&`guard variable for'minja::Parser::parseLogicalAnd(void)::and_tok[abi:cxx11]);
}
minja::Parser::get_location((minja::Parser *)v7, a2);
while ( 1 )
{
minja::Parser::consumeToken(
&v9,
(long long)a2,
(long long)&minja::Parser::parseLogicalAnd(void)::and_tok[abi:cxx11],
1u);
v2 = v10[0];
std::string::~string(&v9);
if ( !v2 )
break;
minja::Parser::parseLogicalNot((minja::Parser *)&v9);
if ( !v9 )
{
v4 = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(v4, "Expected right side of 'and' expression");
__cxa_throw(
v4,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v6 = 14;
std::make_shared<minja::BinaryOpExpr,minja::Location &,std::shared_ptr<minja::Expression>,std::shared_ptr<minja::Expression>,minja::BinaryOpExpr::Op>(
v11,
v7,
this,
&v9,
&v6);
std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator=<minja::BinaryOpExpr>(this, v11);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(v12);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(v10);
}
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v8);
return this;
}
| parseLogicalAnd:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV R14,RSI
MOV RBX,RDI
CALL 0x00166b44
CMP qword ptr [RBX],0x0
JZ 0x00166a31
LEA RAX,[0x2050c8]
MOV AL,byte ptr [RAX]
TEST AL,AL
JZ 0x00166a61
LAB_0016694e:
LEA RDI,[RSP + 0x10]
MOV RSI,R14
CALL 0x00164e64
LEA RBP,[RSP + 0x28]
LEA R12,[RSP + 0x48]
LEA R13,[RSP + 0xc]
LAB_0016696a:
MOV RDI,RBP
MOV RSI,R14
LEA RDX,[0x2050a8]
PUSH 0x1
POP RCX
CALL 0x00165288
MOV R15,qword ptr [RSP + 0x30]
MOV RDI,RBP
CALL 0x00125258
TEST R15,R15
JZ 0x001669e3
LAB_00166991:
MOV RDI,RBP
MOV RSI,R14
CALL 0x00166b44
CMP qword ptr [RSP + 0x28],0x0
JZ 0x001669ff
MOV dword ptr [RSP + 0xc],0xe
LAB_001669ac:
MOV RDI,R12
LEA RSI,[RSP + 0x10]
MOV RDX,RBX
MOV RCX,RBP
MOV R8,R13
CALL 0x00166b1c
LAB_001669c2:
MOV RDI,RBX
MOV RSI,R12
CALL 0x00175c5a
LEA RDI,[RSP + 0x50]
CALL 0x00137354
LEA RDI,[RSP + 0x30]
CALL 0x00137354
JMP 0x0016696a
LAB_001669e3:
LEA RDI,[RSP + 0x18]
CALL 0x00137354
MOV RAX,RBX
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001669ff:
PUSH 0x10
POP RDI
CALL 0x00124470
MOV R15,RAX
LAB_00166a0a:
LEA RSI,[0x1b8cc2]
MOV RDI,RAX
CALL 0x00124330
LAB_00166a19:
MOV RSI,qword ptr [0x00203ff0]
MOV RDX,qword ptr [0x00203f58]
MOV RDI,R15
CALL 0x00124f50
LAB_00166a31:
PUSH 0x10
POP RDI
CALL 0x00124470
MOV R15,RAX
LAB_00166a3c:
LEA RSI,[0x1b8c8d]
MOV RDI,RAX
CALL 0x00124330
LAB_00166a4b:
MOV RSI,qword ptr [0x00203ff0]
MOV RDX,qword ptr [0x00203f58]
MOV RDI,R15
CALL 0x00124f50
LAB_00166a61:
LEA RDI,[0x2050c8]
CALL 0x00125060
TEST EAX,EAX
JZ 0x0016694e
LAB_00166a75:
LEA RDI,[0x2050a8]
LEA RSI,[0x1b8cbc]
PUSH 0x10
POP RDX
CALL 0x0012b33e
LAB_00166a8b:
LEA RDI,[0x12b3f4]
LEA RSI,[0x2050a8]
LEA RDX,[0x204938]
CALL 0x00124800
LEA RDI,[0x2050c8]
CALL 0x001245f0
JMP 0x0016694e
|
/* minja::Parser::parseLogicalAnd() */
void minja::Parser::parseLogicalAnd(void)
{
long lVar1;
int iVar2;
runtime_error *prVar3;
__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2> *in_RDI;
shared_ptr local_78 [8];
__shared_count<(__gnu_cxx::_Lock_policy)2> local_70 [16];
long local_60;
long local_58 [3];
Location local_40 [8];
__shared_count<(__gnu_cxx::_Lock_policy)2> local_38 [8];
parseLogicalNot();
if (*(long *)in_RDI == 0) {
prVar3 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00166a3c to 00166a4a has its CatchHandler @ 00166ac9 */
std::runtime_error::runtime_error(prVar3,"Expected left side of \'logical and\' expression");
/* try { // try from 00166a4b to 00166a60 has its CatchHandler @ 00166ac7 */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar3,PTR_typeinfo_00203ff0,PTR__runtime_error_00203f58);
}
if (parseLogicalAnd()::and_tok_abi_cxx11_ == '\0') {
iVar2 = __cxa_guard_acquire(&parseLogicalAnd()::and_tok_abi_cxx11_);
if (iVar2 != 0) {
/* try { // try from 00166a75 to 00166a8a has its CatchHandler @ 00166ab6 */
std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::basic_regex
((basic_regex<char,std::__cxx11::regex_traits<char>> *)
parseLogicalAnd()::and_tok_abi_cxx11_,"and\\b",0x10);
__cxa_atexit(std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::~basic_regex,
parseLogicalAnd()::and_tok_abi_cxx11_,&__dso_handle);
__cxa_guard_release(&parseLogicalAnd()::and_tok_abi_cxx11_);
}
}
/* try { // try from 0016694e to 0016695a has its CatchHandler @ 00166ad6 */
get_location();
while( true ) {
/* try { // try from 0016696a to 0016697e has its CatchHandler @ 00166afb */
consumeToken((string *)&local_60);
lVar1 = local_58[0];
std::__cxx11::string::~string((string *)&local_60);
if (lVar1 == 0) {
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_70);
return;
}
/* try { // try from 00166991 to 0016699b has its CatchHandler @ 00166aea */
parseLogicalNot();
if (local_60 == 0) break;
/* try { // try from 001669ac to 001669c1 has its CatchHandler @ 00166aec */
std::
make_shared<minja::BinaryOpExpr,minja::Location&,std::shared_ptr<minja::Expression>,std::shared_ptr<minja::Expression>,minja::BinaryOpExpr::Op>
(local_40,local_78,in_RDI,(Op *)&local_60);
std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator=
(in_RDI,(__shared_ptr *)local_40);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_38);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)local_58);
}
prVar3 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00166a0a to 00166a18 has its CatchHandler @ 00166add */
std::runtime_error::runtime_error(prVar3,"Expected right side of \'and\' expression");
/* try { // try from 00166a19 to 00166a2e has its CatchHandler @ 00166adb */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar3,PTR_typeinfo_00203ff0,PTR__runtime_error_00203f58);
}
| |
53,972 | AffiliateBar::addAffiliateBarChild(ObjectScreen*, glm::vec<2, float, (glm::qualifier)0>, Anchor) | GhostEscape/src/affiliate/affiliate_bar.cpp | AffiliateBar *AffiliateBar::addAffiliateBarChild(ObjectScreen *parent, glm::vec2 size, Anchor anchor)
{
auto bar = new AffiliateBar();
bar->init();
bar->setAnchor(anchor);
bar->setSize(size);
if (parent){
bar->setParent(parent);
parent->addChild(bar);
}
return bar;
} | O0 | cpp | AffiliateBar::addAffiliateBarChild(ObjectScreen*, glm::vec<2, float, (glm::qualifier)0>, Anchor):
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movlpd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0xa0, %edi
callq 0x6460
movq %rax, %rdi
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movaps %xmm0, 0x90(%rdi)
movaps %xmm0, 0x80(%rdi)
movaps %xmm0, 0x70(%rdi)
movaps %xmm0, 0x60(%rdi)
movaps %xmm0, 0x50(%rdi)
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
callq 0x1b6c0
jmp 0x1b527
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1ab50
movq -0x20(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x11be0
cmpq $0x0, -0x10(%rbp)
je 0x1b592
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1ab70
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq (%rdi), %rax
callq *0x38(%rax)
jmp 0x1b592
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0xa0, %esi
callq 0x6480
jmp 0x1b59c
movq -0x20(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x6750
nopw %cs:(%rax,%rax)
| _ZN12AffiliateBar20addAffiliateBarChildEP12ObjectScreenN3glm3vecILi2EfLNS2_9qualifierE0EEE6Anchor:
push rbp
mov rbp, rsp
sub rsp, 50h
movlpd [rbp+var_8], xmm0
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov edi, 0A0h; unsigned __int64
call __Znwm; operator new(ulong)
mov rdi, rax; this
mov [rbp+var_50], rdi
mov rax, rdi
mov [rbp+var_48], rax
xorps xmm0, xmm0
movaps [rbp+var_40], xmm0
movaps xmmword ptr [rdi+90h], xmm0
movaps xmmword ptr [rdi+80h], xmm0
movaps xmmword ptr [rdi+70h], xmm0
movaps xmmword ptr [rdi+60h], xmm0
movaps xmmword ptr [rdi+50h], xmm0
movaps xmmword ptr [rdi+40h], xmm0
movaps xmmword ptr [rdi+30h], xmm0
movaps xmmword ptr [rdi+20h], xmm0
movaps xmmword ptr [rdi+10h], xmm0
movaps xmmword ptr [rdi], xmm0
call _ZN12AffiliateBarC2Ev; AffiliateBar::AffiliateBar(void)
jmp short $+2
loc_1B527:
mov rax, [rbp+var_48]
mov [rbp+var_20], rax
mov rdi, [rbp+var_20]
mov rax, [rdi]
call qword ptr [rax+10h]
mov rdi, [rbp+var_20]
mov esi, [rbp+var_14]
call _ZN15ObjectAffiliate9setAnchorE6Anchor; ObjectAffiliate::setAnchor(Anchor)
mov rdi, [rbp+var_20]
lea rsi, [rbp+var_8]
call _ZN15ObjectAffiliate7setSizeERKN3glm3vecILi2EfLNS0_9qualifierE0EEE; ObjectAffiliate::setSize(glm::vec<2,float,(glm::qualifier)0> const&)
cmp [rbp+var_10], 0
jz short loc_1B592
mov rdi, [rbp+var_20]; this
mov rsi, [rbp+var_10]; ObjectScreen *
call _ZN15ObjectAffiliate9setParentEP12ObjectScreen; ObjectAffiliate::setParent(ObjectScreen *)
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
mov rax, [rdi]
call qword ptr [rax+38h]
jmp short loc_1B592
mov rdi, [rbp+var_48]; void *
mov rcx, rax
mov eax, edx
mov [rbp+var_28], rcx
mov [rbp+var_2C], eax
mov esi, 0A0h; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_1B59C
loc_1B592:
mov rax, [rbp+var_20]
add rsp, 50h
pop rbp
retn
loc_1B59C:
mov rdi, [rbp+var_28]
call __Unwind_Resume
| AffiliateBar * AffiliateBar::addAffiliateBarChild(ObjectScreen *a1, int a2, double a3)
{
AffiliateBar *v4; // [rsp+8h] [rbp-48h]
double v5; // [rsp+48h] [rbp-8h] BYREF
v5 = a3;
v4 = (AffiliateBar *)operator new(0xA0uLL);
*((_OWORD *)v4 + 9) = 0LL;
*((_OWORD *)v4 + 8) = 0LL;
*((_OWORD *)v4 + 7) = 0LL;
*((_OWORD *)v4 + 6) = 0LL;
*((_OWORD *)v4 + 5) = 0LL;
*((_OWORD *)v4 + 4) = 0LL;
*((_OWORD *)v4 + 3) = 0LL;
*((_OWORD *)v4 + 2) = 0LL;
*((_OWORD *)v4 + 1) = 0LL;
*(_OWORD *)v4 = 0LL;
AffiliateBar::AffiliateBar(v4);
(*(void ( **)(AffiliateBar *))(*(_QWORD *)v4 + 16LL))(v4);
ObjectAffiliate::setAnchor((long long)v4, a2);
ObjectAffiliate::setSize((long long)v4, &v5);
if ( a1 )
{
ObjectAffiliate::setParent(v4, a1);
(*(void ( **)(ObjectScreen *, AffiliateBar *))(*(_QWORD *)a1 + 56LL))(a1, v4);
}
return v4;
}
| addAffiliateBarChild:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOVLPD qword ptr [RBP + -0x8],XMM0
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV EDI,0xa0
CALL 0x00106460
MOV RDI,RAX
MOV qword ptr [RBP + -0x50],RDI
MOV RAX,RDI
MOV qword ptr [RBP + -0x48],RAX
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RBP + -0x40],XMM0
MOVAPS xmmword ptr [RDI + 0x90],XMM0
MOVAPS xmmword ptr [RDI + 0x80],XMM0
MOVAPS xmmword ptr [RDI + 0x70],XMM0
MOVAPS xmmword ptr [RDI + 0x60],XMM0
MOVAPS xmmword ptr [RDI + 0x50],XMM0
MOVAPS xmmword ptr [RDI + 0x40],XMM0
MOVAPS xmmword ptr [RDI + 0x30],XMM0
MOVAPS xmmword ptr [RDI + 0x20],XMM0
MOVAPS xmmword ptr [RDI + 0x10],XMM0
MOVAPS xmmword ptr [RDI],XMM0
LAB_0011b520:
CALL 0x0011b6c0
LAB_0011b525:
JMP 0x0011b527
LAB_0011b527:
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x10]
MOV RDI,qword ptr [RBP + -0x20]
MOV ESI,dword ptr [RBP + -0x14]
CALL 0x0011ab50
MOV RDI,qword ptr [RBP + -0x20]
LEA RSI,[RBP + -0x8]
CALL 0x00111be0
CMP qword ptr [RBP + -0x10],0x0
JZ 0x0011b592
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x0011ab70
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x38]
JMP 0x0011b592
LAB_0011b592:
MOV RAX,qword ptr [RBP + -0x20]
ADD RSP,0x50
POP RBP
RET
|
/* AffiliateBar::addAffiliateBarChild(ObjectScreen*, glm::vec<2, float, (glm::qualifier)0>, Anchor)
*/
AffiliateBar *
AffiliateBar::addAffiliateBarChild(int8 param_1_00,ObjectScreen *param_1,int4 param_3)
{
AffiliateBar *this;
int8 local_10;
local_10 = param_1_00;
this = (AffiliateBar *)operator_new(0xa0);
*(int8 *)(this + 0x90) = 0;
*(int8 *)(this + 0x98) = 0;
*(int8 *)(this + 0x80) = 0;
*(int8 *)(this + 0x88) = 0;
*(int8 *)(this + 0x70) = 0;
*(int8 *)(this + 0x78) = 0;
*(int8 *)(this + 0x60) = 0;
*(int8 *)(this + 0x68) = 0;
*(int8 *)(this + 0x50) = 0;
*(int8 *)(this + 0x58) = 0;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
/* try { // try from 0011b520 to 0011b524 has its CatchHandler @ 0011b576 */
AffiliateBar(this);
(**(code **)(*(long *)this + 0x10))();
ObjectAffiliate::setAnchor((ObjectAffiliate *)this,param_3);
ObjectAffiliate::setSize((ObjectAffiliate *)this,(vec *)&local_10);
if (param_1 != (ObjectScreen *)0x0) {
ObjectAffiliate::setParent((ObjectAffiliate *)this,param_1);
(**(code **)(*(long *)param_1 + 0x38))(param_1,this);
}
return this;
}
| |
53,973 | testing::internal::UnitTestImpl::ConfigureXmlOutput() | giladroyz[P]FindPeaks/build_O1/_deps/googletest-src/googletest/src/gtest.cc | void UnitTestImpl::ConfigureXmlOutput() {
const std::string& output_format = UnitTestOptions::GetOutputFormat();
#if GTEST_HAS_FILE_SYSTEM
if (output_format == "xml") {
listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter(
UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
} else if (output_format == "json") {
listeners()->SetDefaultXmlGenerator(new JsonUnitTestResultPrinter(
UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
} else if (!output_format.empty()) {
GTEST_LOG_(WARNING) << "WARNING: unrecognized output format \""
<< output_format << "\" ignored.";
}
#else
if (!output_format.empty()) {
GTEST_LOG_(ERROR) << "ERROR: alternative output formats require "
<< "GTEST_HAS_FILE_SYSTEM to be enabled";
}
#endif // GTEST_HAS_FILE_SYSTEM
} | O1 | cpp | testing::internal::UnitTestImpl::ConfigureXmlOutput():
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x1acb8
leaq 0x128ff(%rip), %rsi # 0x40e3c
movq %r14, %rdi
callq 0x8160
testl %eax, %eax
je 0x2e5da
leaq 0x152ce(%rip), %rsi # 0x43822
leaq 0x20(%rsp), %rdi
callq 0x8160
testl %eax, %eax
je 0x2e614
cmpq $0x0, 0x28(%rsp)
je 0x2e667
leaq 0x14194(%rip), %rdx # 0x4270d
movq %rsp, %rdi
movl $0x1, %esi
movl $0x1669, %ecx # imm = 0x1669
callq 0x16e72
movq 0x2aa56(%rip), %rdi # 0x58fe8
leaq 0x1528e(%rip), %rsi # 0x43827
movl $0x25, %edx
callq 0x85b0
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x2aa34(%rip), %rdi # 0x58fe8
callq 0x85b0
leaq 0x1528d(%rip), %rsi # 0x4384d
movl $0xa, %edx
movq %rax, %rdi
callq 0x85b0
movq %rsp, %rdi
callq 0x16fb4
jmp 0x2e667
movl $0x28, %edi
callq 0x84b0
movq %rax, %r14
movq %rsp, %rdi
callq 0x1ad7e
movb $0x1, %bpl
movq (%rsp), %rsi
movq %r14, %rdi
callq 0x2437e
addq $0x268, %rbx # imm = 0x268
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2d386
jmp 0x2e64c
movl $0x28, %edi
callq 0x84b0
movq %rax, %r14
movq %rsp, %rdi
callq 0x1ad7e
movb $0x1, %bpl
movq (%rsp), %rsi
movq %r14, %rdi
callq 0x28906
addq $0x268, %rbx # imm = 0x268
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2d386
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e667
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84e0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e682
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x84e0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x2e68f
jmp 0x2e699
movq %rax, %rbx
movb $0x1, %bpl
jmp 0x2e6c9
jmp 0x2e6ab
movq %rax, %rbx
jmp 0x2e6db
movq %rax, %rbx
movq %rsp, %rdi
callq 0x16fb4
jmp 0x2e6db
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e6c9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84e0
testb %bpl, %bpl
je 0x2e6db
movl $0x28, %esi
movq %r14, %rdi
callq 0x84e0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e6f6
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x84e0
movq %rbx, %rdi
callq 0x8990
| _ZN7testing8internal12UnitTestImpl18ConfigureXmlOutputEv:
push rbp; __int64
push r14; int
push rbx; void *
sub rsp, 40h
mov rbx, rdi
lea r14, [rsp+58h+var_38]
mov rdi, r14; int
call _ZN7testing8internal15UnitTestOptions15GetOutputFormatB5cxx11Ev; testing::internal::UnitTestOptions::GetOutputFormat(void)
lea rsi, aXml_0; "xml"
mov rdi, r14
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz loc_2E5DA
lea rsi, aJson; "json"
lea rdi, [rsp+58h+var_38]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz loc_2E614
cmp [rsp+58h+var_30], 0
jz loc_2E667
lea rdx, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
mov rdi, rsp
mov esi, 1
mov ecx, 1669h
call _ZN7testing8internal8GTestLogC2ENS0_16GTestLogSeverityEPKci; testing::internal::GTestLog::GTestLog(testing::internal::GTestLogSeverity,char const*,int)
mov rdi, cs:_ZSt4cerr_ptr
lea rsi, aWarningUnrecog; "WARNING: unrecognized output format \""
mov edx, 25h ; '%'
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, qword ptr [rsp+58h+var_38]
mov rdx, [rsp+58h+var_30]
mov rdi, cs:_ZSt4cerr_ptr
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, aIgnored; "\" ignored."
mov edx, 0Ah
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 rdi, rsp; this
call _ZN7testing8internal8GTestLogD2Ev; testing::internal::GTestLog::~GTestLog()
jmp loc_2E667
loc_2E5DA:
mov edi, 28h ; '('; unsigned __int64
call __Znwm; operator new(ulong)
mov r14, rax
mov rdi, rsp; int
call _ZN7testing8internal15UnitTestOptions27GetAbsolutePathToOutputFileB5cxx11Ev; testing::internal::UnitTestOptions::GetAbsolutePathToOutputFile(void)
mov bpl, 1
mov rsi, [rsp+58h+var_58]; char *
mov rdi, r14; this
call _ZN7testing8internal24XmlUnitTestResultPrinterC2EPKc; testing::internal::XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(char const*)
add rbx, 268h
xor ebp, ebp
mov rdi, rbx; this
mov rsi, r14; testing::TestEventListener *
call _ZN7testing18TestEventListeners22SetDefaultXmlGeneratorEPNS_17TestEventListenerE; testing::TestEventListeners::SetDefaultXmlGenerator(testing::TestEventListener *)
jmp short loc_2E64C
loc_2E614:
mov edi, 28h ; '('; unsigned __int64
call __Znwm; operator new(ulong)
mov r14, rax
mov rdi, rsp; int
call _ZN7testing8internal15UnitTestOptions27GetAbsolutePathToOutputFileB5cxx11Ev; testing::internal::UnitTestOptions::GetAbsolutePathToOutputFile(void)
mov bpl, 1
mov rsi, [rsp+58h+var_58]; char *
mov rdi, r14; this
call _ZN7testing8internal25JsonUnitTestResultPrinterC2EPKc; testing::internal::JsonUnitTestResultPrinter::JsonUnitTestResultPrinter(char const*)
add rbx, 268h
xor ebp, ebp
mov rdi, rbx; this
mov rsi, r14; testing::TestEventListener *
call _ZN7testing18TestEventListeners22SetDefaultXmlGeneratorEPNS_17TestEventListenerE; testing::TestEventListeners::SetDefaultXmlGenerator(testing::TestEventListener *)
loc_2E64C:
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_2E667
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2E667:
lea rax, [rsp+58h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_2E682
mov rsi, [rsp+58h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2E682:
add rsp, 40h
pop rbx
pop r14
pop rbp
retn
jmp short loc_2E68F
jmp short loc_2E699
loc_2E68F:
mov rbx, rax
mov bpl, 1
jmp short loc_2E6C9
jmp short loc_2E6AB
loc_2E699:
mov rbx, rax
jmp short loc_2E6DB
mov rbx, rax
mov rdi, rsp; this
call _ZN7testing8internal8GTestLogD2Ev; testing::internal::GTestLog::~GTestLog()
jmp short loc_2E6DB
loc_2E6AB:
mov rbx, rax
lea rax, [rsp+arg_8]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_2E6C9
mov rsi, [rsp+arg_8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2E6C9:
test bpl, bpl
jz short loc_2E6DB
mov esi, 28h ; '('; unsigned __int64
mov rdi, r14; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_2E6DB:
lea rax, [rsp+arg_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_2E6F6
mov rsi, [rsp+arg_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2E6F6:
mov rdi, rbx
call __Unwind_Resume
| void testing::internal::UnitTestImpl::ConfigureXmlOutput(testing::internal::UnitTestImpl *this)
{
long long v1; // rax
long long v2; // rdx
long long v3; // rcx
testing::internal::XmlUnitTestResultPrinter *v4; // r14
testing::internal::JsonUnitTestResultPrinter *v5; // r14
char *v6[2]; // [rsp+0h] [rbp-58h] BYREF
long long v7; // [rsp+10h] [rbp-48h] BYREF
int v8[2]; // [rsp+20h] [rbp-38h] BYREF
long long v9; // [rsp+28h] [rbp-30h]
long long v10; // [rsp+30h] [rbp-28h] BYREF
testing::internal::UnitTestOptions::GetOutputFormat[abi:cxx11](v8);
if ( !(unsigned int)std::string::compare(v8, "xml") )
{
v4 = (testing::internal::XmlUnitTestResultPrinter *)operator new(0x28uLL);
testing::internal::UnitTestOptions::GetAbsolutePathToOutputFile[abi:cxx11](v6);
testing::internal::XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(v4, v6[0]);
testing::TestEventListeners::SetDefaultXmlGenerator((testing::internal::UnitTestImpl *)((char *)this + 616), v4);
}
else
{
if ( (unsigned int)std::string::compare(v8, "json") )
{
if ( v9 )
{
testing::internal::GTestLog::GTestLog(
v6,
1,
"/workspace/llm4binary/github/2025_star3/giladroyz[P]FindPeaks/build_O1/_deps/googletest-src/googletest/src/gtest.cc",
5737);
std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, "WARNING: unrecognized output format \"", 37LL);
v1 = std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, *(_QWORD *)v8, v9);
std::__ostream_insert<char,std::char_traits<char>>(v1, "\" ignored.", 10LL);
testing::internal::GTestLog::~GTestLog((testing::internal::GTestLog *)v6, (long long)"\" ignored.", v2, v3);
}
goto LABEL_9;
}
v5 = (testing::internal::JsonUnitTestResultPrinter *)operator new(0x28uLL);
testing::internal::UnitTestOptions::GetAbsolutePathToOutputFile[abi:cxx11](v6);
testing::internal::JsonUnitTestResultPrinter::JsonUnitTestResultPrinter(v5, v6[0]);
testing::TestEventListeners::SetDefaultXmlGenerator((testing::internal::UnitTestImpl *)((char *)this + 616), v5);
}
if ( (long long *)v6[0] != &v7 )
operator delete(v6[0], v7 + 1);
LABEL_9:
if ( *(long long **)v8 != &v10 )
operator delete(*(void **)v8, v10 + 1);
}
| ConfigureXmlOutput:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV RBX,RDI
LEA R14,[RSP + 0x20]
MOV RDI,R14
CALL 0x0011acb8
LEA RSI,[0x140e3c]
MOV RDI,R14
CALL 0x00108160
TEST EAX,EAX
JZ 0x0012e5da
LEA RSI,[0x143822]
LEA RDI,[RSP + 0x20]
CALL 0x00108160
TEST EAX,EAX
JZ 0x0012e614
CMP qword ptr [RSP + 0x28],0x0
JZ 0x0012e667
LAB_0012e572:
LEA RDX,[0x14270d]
MOV RDI,RSP
MOV ESI,0x1
MOV ECX,0x1669
CALL 0x00116e72
LAB_0012e58b:
MOV RDI,qword ptr [0x00158fe8]
LEA RSI,[0x143827]
MOV EDX,0x25
CALL 0x001085b0
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
MOV RDI,qword ptr [0x00158fe8]
CALL 0x001085b0
LEA RSI,[0x14384d]
MOV EDX,0xa
MOV RDI,RAX
CALL 0x001085b0
MOV RDI,RSP
CALL 0x00116fb4
JMP 0x0012e667
LAB_0012e5da:
MOV EDI,0x28
CALL 0x001084b0
LAB_0012e5e4:
MOV R14,RAX
MOV RDI,RSP
CALL 0x0011ad7e
MOV BPL,0x1
MOV RSI,qword ptr [RSP]
LAB_0012e5f6:
MOV RDI,R14
CALL 0x0012437e
ADD RBX,0x268
XOR EBP,EBP
MOV RDI,RBX
MOV RSI,R14
CALL 0x0012d386
JMP 0x0012e64c
LAB_0012e614:
MOV EDI,0x28
CALL 0x001084b0
LAB_0012e61e:
MOV R14,RAX
MOV RDI,RSP
CALL 0x0011ad7e
MOV BPL,0x1
MOV RSI,qword ptr [RSP]
LAB_0012e630:
MOV RDI,R14
CALL 0x00128906
ADD RBX,0x268
XOR EBP,EBP
MOV RDI,RBX
MOV RSI,R14
CALL 0x0012d386
LAB_0012e64c:
LEA RAX,[RSP + 0x10]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0012e667
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x001084e0
LAB_0012e667:
LEA RAX,[RSP + 0x30]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0012e682
MOV RSI,qword ptr [RSP + 0x30]
INC RSI
CALL 0x001084e0
LAB_0012e682:
ADD RSP,0x40
POP RBX
POP R14
POP RBP
RET
|
/* testing::internal::UnitTestImpl::ConfigureXmlOutput() */
void __thiscall testing::internal::UnitTestImpl::ConfigureXmlOutput(UnitTestImpl *this)
{
int iVar1;
ostream *poVar2;
XmlUnitTestResultPrinter *this_00;
JsonUnitTestResultPrinter *this_01;
long *local_58 [2];
long local_48 [2];
long *local_38;
long local_30;
long local_28 [2];
UnitTestOptions::GetOutputFormat_abi_cxx11_((UnitTestOptions *)&local_38);
iVar1 = std::__cxx11::string::compare((char *)&local_38);
if (iVar1 == 0) {
/* try { // try from 0012e5da to 0012e5e3 has its CatchHandler @ 0012e699 */
this_00 = (XmlUnitTestResultPrinter *)operator_new(0x28);
/* try { // try from 0012e5e4 to 0012e5ee has its CatchHandler @ 0012e68f */
UnitTestOptions::GetAbsolutePathToOutputFile_abi_cxx11_((UnitTestOptions *)local_58);
/* try { // try from 0012e5f6 to 0012e611 has its CatchHandler @ 0012e6ab */
XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(this_00,(char *)local_58[0]);
TestEventListeners::SetDefaultXmlGenerator
((TestEventListeners *)(this + 0x268),(TestEventListener *)this_00);
}
else {
iVar1 = std::__cxx11::string::compare((char *)&local_38);
if (iVar1 != 0) {
if (local_30 != 0) {
/* try { // try from 0012e572 to 0012e58a has its CatchHandler @ 0012e68d */
GTestLog::GTestLog((GTestLog *)local_58,1,
"/workspace/llm4binary/github/2025_star3/giladroyz[P]FindPeaks/build_O1/_deps/googletest-src/googletest/src/gtest.cc"
,0x1669);
/* try { // try from 0012e58b to 0012e5cc has its CatchHandler @ 0012e69e */
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cerr_00158fe8,"WARNING: unrecognized output format \"",0x25);
poVar2 = std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cerr_00158fe8,(char *)local_38,local_30);
std::__ostream_insert<char,std::char_traits<char>>(poVar2,"\" ignored.",10);
GTestLog::~GTestLog((GTestLog *)local_58);
}
goto LAB_0012e667;
}
/* try { // try from 0012e614 to 0012e61d has its CatchHandler @ 0012e699 */
this_01 = (JsonUnitTestResultPrinter *)operator_new(0x28);
/* try { // try from 0012e61e to 0012e628 has its CatchHandler @ 0012e68b */
UnitTestOptions::GetAbsolutePathToOutputFile_abi_cxx11_((UnitTestOptions *)local_58);
/* try { // try from 0012e630 to 0012e64b has its CatchHandler @ 0012e697 */
JsonUnitTestResultPrinter::JsonUnitTestResultPrinter(this_01,(char *)local_58[0]);
TestEventListeners::SetDefaultXmlGenerator
((TestEventListeners *)(this + 0x268),(TestEventListener *)this_01);
}
if (local_58[0] != local_48) {
operator_delete(local_58[0],local_48[0] + 1);
}
LAB_0012e667:
if (local_38 != local_28) {
operator_delete(local_38,local_28[0] + 1);
}
return;
}
| |
53,974 | bc_get_u32 | bluesky950520[P]quickjs/quickjs.c | static __maybe_unused int bc_get_u32(BCReaderState *s, uint32_t *pval)
{
uint32_t v;
if (unlikely(s->buf_end - s->ptr < 4)) {
*pval = 0; /* avoid warning */
return bc_read_error_end(s);
}
v = get_u32(s->ptr);
if (is_be())
v = bswap32(v);
*pval = v;
s->ptr += 4;
return 0;
} | O0 | c | bc_get_u32:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rsp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
cmpq $0x4, %rax
setl %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x7a2b6
movq 0x10(%rsp), %rax
movl $0x0, (%rax)
movq 0x18(%rsp), %rdi
callq 0x7a490
movl %eax, 0x24(%rsp)
jmp 0x7a302
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x5f1b0
movl %eax, 0xc(%rsp)
callq 0x2cc60
cmpb $0x0, %al
je 0x7a2de
movl 0xc(%rsp), %edi
callq 0x79e30
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x4, %rcx
movq %rcx, 0x10(%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
| bc_get_u32:
sub rsp, 28h
mov [rsp+28h+var_10], rdi
mov [rsp+28h+var_18], rsi
mov rax, [rsp+28h+var_10]
mov rax, [rax+18h]
mov rcx, [rsp+28h+var_10]
mov rcx, [rcx+10h]
sub rax, rcx
cmp rax, 4
setl al
xor al, 0FFh
xor al, 0FFh
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_7A2B6
mov rax, [rsp+28h+var_18]
mov dword ptr [rax], 0
mov rdi, [rsp+28h+var_10]
call bc_read_error_end
mov [rsp+28h+var_4], eax
jmp short loc_7A302
loc_7A2B6:
mov rax, [rsp+28h+var_10]
mov rdi, [rax+10h]
call get_u32
mov [rsp+28h+var_1C], eax
call is_be_0
cmp al, 0
jz short loc_7A2DE
mov edi, [rsp+28h+var_1C]
call bswap32
mov [rsp+28h+var_1C], eax
loc_7A2DE:
mov ecx, [rsp+28h+var_1C]
mov rax, [rsp+28h+var_18]
mov [rax], ecx
mov rax, [rsp+28h+var_10]
mov rcx, [rax+10h]
add rcx, 4
mov [rax+10h], rcx
mov [rsp+28h+var_4], 0
loc_7A302:
mov eax, [rsp+28h+var_4]
add rsp, 28h
retn
| long long bc_get_u32(long long a1, int *a2)
{
int u32; // [rsp+Ch] [rbp-1Ch]
if ( (long long)(*(_QWORD *)(a1 + 24) - *(_QWORD *)(a1 + 16)) >= 4 )
{
u32 = get_u32(*(unsigned int **)(a1 + 16));
if ( is_be_0() )
u32 = bswap32(u32);
*a2 = u32;
*(_QWORD *)(a1 + 16) += 4LL;
return 0;
}
else
{
*a2 = 0;
return (unsigned int)bc_read_error_end(a1);
}
}
| bc_get_u32:
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RDI
MOV qword ptr [RSP + 0x10],RSI
MOV RAX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RAX + 0x18]
MOV RCX,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RCX + 0x10]
SUB RAX,RCX
CMP RAX,0x4
SETL AL
XOR AL,0xff
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x0017a2b6
MOV RAX,qword ptr [RSP + 0x10]
MOV dword ptr [RAX],0x0
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x0017a490
MOV dword ptr [RSP + 0x24],EAX
JMP 0x0017a302
LAB_0017a2b6:
MOV RAX,qword ptr [RSP + 0x18]
MOV RDI,qword ptr [RAX + 0x10]
CALL 0x0015f1b0
MOV dword ptr [RSP + 0xc],EAX
CALL 0x0012cc60
CMP AL,0x0
JZ 0x0017a2de
MOV EDI,dword ptr [RSP + 0xc]
CALL 0x00179e30
MOV dword ptr [RSP + 0xc],EAX
LAB_0017a2de:
MOV ECX,dword ptr [RSP + 0xc]
MOV RAX,qword ptr [RSP + 0x10]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RAX + 0x10]
ADD RCX,0x4
MOV qword ptr [RAX + 0x10],RCX
MOV dword ptr [RSP + 0x24],0x0
LAB_0017a302:
MOV EAX,dword ptr [RSP + 0x24]
ADD RSP,0x28
RET
|
int4 bc_get_u32(long param_1,int4 *param_2)
{
char cVar1;
int4 local_1c;
int4 local_4;
if (*(long *)(param_1 + 0x18) - *(long *)(param_1 + 0x10) < 4) {
*param_2 = 0;
local_4 = bc_read_error_end(param_1);
}
else {
local_1c = get_u32(*(int8 *)(param_1 + 0x10));
cVar1 = is_be();
if (cVar1 != '\0') {
local_1c = bswap32(local_1c);
}
*param_2 = local_1c;
*(long *)(param_1 + 0x10) = *(long *)(param_1 + 0x10) + 4;
local_4 = 0;
}
return local_4;
}
| |
53,975 | dual_vector_from_constant | tsotchke[P]eshkol/src/core/utils/autodiff.c | DualVector* dual_vector_from_constant(Arena* arena, VectorF* value) {
assert(arena != NULL);
assert(value != NULL);
// Create a zero derivative vector
VectorF* derivative = vector_f_create(arena, value->dim);
if (!derivative) return NULL;
// Initialize to zero
for (size_t i = 0; i < value->dim; i++) {
derivative->data[i] = 0.0f;
}
return dual_vector_create(arena, value, derivative);
} | O0 | c | dual_vector_from_constant:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x8b09
jmp 0x8b28
leaq 0x396a(%rip), %rdi # 0xc47a
leaq 0x55c5(%rip), %rsi # 0xe0dc
movl $0x9b, %edx
leaq 0x5669(%rip), %rcx # 0xe18c
callq 0x10b0
cmpq $0x0, -0x18(%rbp)
je 0x8b31
jmp 0x8b50
leaq 0x3979(%rip), %rdi # 0xc4b1
leaq 0x559d(%rip), %rsi # 0xe0dc
movl $0x9c, %edx
leaq 0x5641(%rip), %rcx # 0xe18c
callq 0x10b0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x3ea0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x8b76
movq $0x0, -0x8(%rbp)
jmp 0x8bbf
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x8baa
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x8b7e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x89e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| dual_vector_from_constant:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
cmp [rbp+var_10], 0
jz short loc_8B09
jmp short loc_8B28
loc_8B09:
lea rdi, aArenaNull; "arena != NULL"
lea rsi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
mov edx, 9Bh
lea rcx, aDualvectorDual_0; "DualVector *dual_vector_from_constant(A"...
call ___assert_fail
loc_8B28:
cmp [rbp+var_18], 0
jz short loc_8B31
jmp short loc_8B50
loc_8B31:
lea rdi, aAValueNull+2; "value != NULL"
lea rsi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
mov edx, 9Ch
lea rcx, aDualvectorDual_0; "DualVector *dual_vector_from_constant(A"...
call ___assert_fail
loc_8B50:
mov rdi, [rbp+var_10]
mov rax, [rbp+var_18]
mov rsi, [rax+10h]
call vector_f_create
mov [rbp+var_20], rax
cmp [rbp+var_20], 0
jnz short loc_8B76
mov [rbp+var_8], 0
jmp short loc_8BBF
loc_8B76:
mov [rbp+var_28], 0
loc_8B7E:
mov rax, [rbp+var_28]
mov rcx, [rbp+var_18]
cmp rax, [rcx+10h]
jnb short loc_8BAA
mov rax, [rbp+var_20]
mov rcx, [rbp+var_28]
xorps xmm0, xmm0
movss dword ptr [rax+rcx*4], xmm0
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
jmp short loc_8B7E
loc_8BAA:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
call dual_vector_create
mov [rbp+var_8], rax
loc_8BBF:
mov rax, [rbp+var_8]
add rsp, 30h
pop rbp
retn
| _QWORD * dual_vector_from_constant(_QWORD *a1, long long a2)
{
unsigned long long i; // [rsp+8h] [rbp-28h]
long long v4; // [rsp+10h] [rbp-20h]
if ( !a1 )
__assert_fail(
"arena != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/core/utils/autodiff.c",
155LL,
"DualVector *dual_vector_from_constant(Arena *, VectorF *)");
if ( !a2 )
__assert_fail(
"value != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/core/utils/autodiff.c",
156LL,
"DualVector *dual_vector_from_constant(Arena *, VectorF *)");
v4 = vector_f_create(a1, *(_QWORD *)(a2 + 16));
if ( !v4 )
return 0LL;
for ( i = 0LL; i < *(_QWORD *)(a2 + 16); ++i )
*(_DWORD *)(v4 + 4 * i) = 0;
return dual_vector_create((long long)a1, a2, v4);
}
| dual_vector_from_constant:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
CMP qword ptr [RBP + -0x10],0x0
JZ 0x00108b09
JMP 0x00108b28
LAB_00108b09:
LEA RDI,[0x10c468]
LEA RSI,[0x10e0ac]
MOV EDX,0x9b
LEA RCX,[0x10e14a]
CALL 0x001010b0
LAB_00108b28:
CMP qword ptr [RBP + -0x18],0x0
JZ 0x00108b31
JMP 0x00108b50
LAB_00108b31:
LEA RDI,[0x10c49f]
LEA RSI,[0x10e0ac]
MOV EDX,0x9c
LEA RCX,[0x10e14a]
CALL 0x001010b0
LAB_00108b50:
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RAX + 0x10]
CALL 0x00103ea0
MOV qword ptr [RBP + -0x20],RAX
CMP qword ptr [RBP + -0x20],0x0
JNZ 0x00108b76
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00108bbf
LAB_00108b76:
MOV qword ptr [RBP + -0x28],0x0
LAB_00108b7e:
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RCX + 0x10]
JNC 0x00108baa
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x28]
XORPS XMM0,XMM0
MOVSS dword ptr [RAX + RCX*0x4],XMM0
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00108b7e
LAB_00108baa:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x001089e0
MOV qword ptr [RBP + -0x8],RAX
LAB_00108bbf:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
int8 dual_vector_from_constant(long param_1,long param_2)
{
long lVar1;
ulong local_30;
int8 local_10;
if (param_1 == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("arena != NULL",
"/workspace/llm4binary/github2025/eshkol/src/core/utils/autodiff.c",0x9b,
"DualVector *dual_vector_from_constant(Arena *, VectorF *)");
}
if (param_2 != 0) {
lVar1 = vector_f_create(param_1,*(int8 *)(param_2 + 0x10));
if (lVar1 == 0) {
local_10 = 0;
}
else {
for (local_30 = 0; local_30 < *(ulong *)(param_2 + 0x10); local_30 = local_30 + 1) {
*(int4 *)(lVar1 + local_30 * 4) = 0;
}
local_10 = dual_vector_create(param_1,param_2,lVar1);
}
return local_10;
}
/* WARNING: Subroutine does not return */
__assert_fail("value != NULL","/workspace/llm4binary/github2025/eshkol/src/core/utils/autodiff.c",
0x9c,"DualVector *dual_vector_from_constant(Arena *, VectorF *)");
}
| |
53,976 | dual_vector_from_constant | tsotchke[P]eshkol/src/core/utils/autodiff.c | DualVector* dual_vector_from_constant(Arena* arena, VectorF* value) {
assert(arena != NULL);
assert(value != NULL);
// Create a zero derivative vector
VectorF* derivative = vector_f_create(arena, value->dim);
if (!derivative) return NULL;
// Initialize to zero
for (size_t i = 0; i < value->dim; i++) {
derivative->data[i] = 0.0f;
}
return dual_vector_create(arena, value, derivative);
} | O3 | c | dual_vector_from_constant:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x60e1
movq %rsi, %rbx
testq %rsi, %rsi
je 0x6100
movq %rdi, %r14
movq 0x10(%rbx), %rsi
callq 0x31fc
testq %rax, %rax
je 0x60d9
movq %rax, %r15
movq 0x10(%rbx), %rdx
testq %rdx, %rdx
je 0x60c6
shlq $0x2, %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x10d0
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x5fcc
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x337f(%rip), %rdi # 0x9467
leaq 0x515d(%rip), %rsi # 0xb24c
leaq 0x5206(%rip), %rcx # 0xb2fc
movl $0x9b, %edx
callq 0x10b0
leaq 0x3397(%rip), %rdi # 0x949e
leaq 0x513e(%rip), %rsi # 0xb24c
leaq 0x51e7(%rip), %rcx # 0xb2fc
movl $0x9c, %edx
callq 0x10b0
| dual_vector_from_constant:
push r15
push r14
push rbx
test rdi, rdi
jz short loc_60E1
mov rbx, rsi
test rsi, rsi
jz short loc_6100
mov r14, rdi
mov rsi, [rbx+10h]
call vector_f_create
test rax, rax
jz short loc_60D9
mov r15, rax
mov rdx, [rbx+10h]
test rdx, rdx
jz short loc_60C6
shl rdx, 2
mov rdi, r15
xor esi, esi
call _memset
loc_60C6:
mov rdi, r14
mov rsi, rbx
mov rdx, r15
pop rbx
pop r14
pop r15
jmp dual_vector_create
loc_60D9:
xor eax, eax
pop rbx
pop r14
pop r15
retn
loc_60E1:
lea rdi, aArenaNull; "arena != NULL"
lea rsi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aDualvectorDual_0; "DualVector *dual_vector_from_constant(A"...
mov edx, 9Bh
call ___assert_fail
loc_6100:
lea rdi, aAValueNull+2; "value != NULL"
lea rsi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aDualvectorDual_0; "DualVector *dual_vector_from_constant(A"...
mov edx, 9Ch
call ___assert_fail
| _QWORD * dual_vector_from_constant(_QWORD *a1, long long a2)
{
long long v2; // rax
long long v3; // r15
long long v4; // rdx
if ( !a1 )
__assert_fail(
"arena != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/core/utils/autodiff.c",
155LL,
"DualVector *dual_vector_from_constant(Arena *, VectorF *)");
if ( !a2 )
__assert_fail(
"value != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/core/utils/autodiff.c",
156LL,
"DualVector *dual_vector_from_constant(Arena *, VectorF *)");
v2 = vector_f_create(a1, *(_QWORD *)(a2 + 16));
if ( !v2 )
return 0LL;
v3 = v2;
v4 = *(_QWORD *)(a2 + 16);
if ( v4 )
memset(v2, 0LL, 4 * v4);
return dual_vector_create((long long)a1, a2, v3);
}
| |||
53,977 | HMAC_init | corpus-core[P]colibri-stateless/build_O0/_deps/blst-src/src/keygen.c | static void HMAC_init(HMAC_SHA256_CTX *ctx, const void *K, size_t K_len)
{
size_t i;
if (K == NULL) { /* reuse h_ipad and h_opad */
sha256_hcopy(ctx->ctx.h, ctx->h_ipad);
ctx->ctx.N = 64;
vec_zero(ctx->ctx.buf, sizeof(ctx->ctx.buf));
ctx->ctx.off = 0;
return;
}
vec_zero(ctx->tail.c, sizeof(ctx->tail));
if (K_len > 64) {
sha256_init(&ctx->ctx);
sha256_update(&ctx->ctx, K, K_len);
sha256_final(ctx->tail.c, &ctx->ctx);
} else {
sha256_bcopy(ctx->tail.c, K, K_len);
}
for (i = 0; i < 64/sizeof(limb_t); i++)
ctx->tail.l[i] ^= (limb_t)0x3636363636363636;
sha256_init(&ctx->ctx);
sha256_update(&ctx->ctx, ctx->tail.c, 64);
sha256_hcopy(ctx->h_ipad, ctx->ctx.h);
for (i = 0; i < 64/sizeof(limb_t); i++)
ctx->tail.l[i] ^= (limb_t)(0x3636363636363636 ^ 0x5c5c5c5c5c5c5c5c);
sha256_init_h(ctx->h_opad);
sha256_block_data_order(ctx->h_opad, ctx->tail.c, 1);
vec_zero(ctx->tail.c, sizeof(ctx->tail));
ctx->tail.c[32] = 0x80;
ctx->tail.c[62] = 3; /* (64+32)*8 in big endian */
ctx->tail.c[63] = 0;
} | O0 | c | HMAC_init:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x32adb
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x70, %rsi
callq 0x3e3d0
movq -0x8(%rbp), %rax
movq $0x40, 0x20(%rax)
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl $0x40, %esi
callq 0x23310
movq -0x8(%rbp), %rax
movq $0x0, 0x68(%rax)
jmp 0x32c56
movq -0x8(%rbp), %rdi
addq $0xb0, %rdi
movl $0x40, %esi
callq 0x23310
cmpq $0x40, -0x18(%rbp)
jbe 0x32b27
movq -0x8(%rbp), %rdi
callq 0x31c90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x31ce0
movq -0x8(%rbp), %rdi
addq $0xb0, %rdi
movq -0x8(%rbp), %rsi
callq 0x31e70
jmp 0x32b3f
movq -0x8(%rbp), %rdi
addq $0xb0, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3e3b0
movq $0x0, -0x20(%rbp)
cmpq $0x8, -0x20(%rbp)
jae 0x32b7e
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movabsq $0x3636363636363636, %rdx # imm = 0x3636363636363636
xorq 0xb0(%rax,%rcx,8), %rdx
movq %rdx, 0xb0(%rax,%rcx,8)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x32b47
movq -0x8(%rbp), %rdi
callq 0x31c90
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0xb0, %rsi
movl $0x40, %edx
callq 0x31ce0
movq -0x8(%rbp), %rdi
addq $0x70, %rdi
movq -0x8(%rbp), %rsi
callq 0x3e3d0
movq $0x0, -0x20(%rbp)
cmpq $0x8, -0x20(%rbp)
jae 0x32bf0
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movabsq $0x6a6a6a6a6a6a6a6a, %rdx # imm = 0x6A6A6A6A6A6A6A6A
xorq 0xb0(%rax,%rcx,8), %rdx
movq %rdx, 0xb0(%rax,%rcx,8)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x32bb9
movq -0x8(%rbp), %rdi
addq $0x90, %rdi
callq 0x32d00
movq -0x8(%rbp), %rdi
addq $0x90, %rdi
movq -0x8(%rbp), %rsi
addq $0xb0, %rsi
movl $0x1, %edx
callq 0x3c000
movq -0x8(%rbp), %rdi
addq $0xb0, %rdi
movl $0x40, %esi
callq 0x23310
movq -0x8(%rbp), %rax
movb $-0x80, 0xd0(%rax)
movq -0x8(%rbp), %rax
movb $0x3, 0xee(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0xef(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| HMAC_init:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
cmp [rbp+var_10], 0
jnz short loc_32ADB
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_8]
add rsi, 70h ; 'p'
call blst_sha256_hcopy
mov rax, [rbp+var_8]
mov qword ptr [rax+20h], 40h ; '@'
mov rdi, [rbp+var_8]
add rdi, 28h ; '('
mov esi, 40h ; '@'
call vec_zero
mov rax, [rbp+var_8]
mov qword ptr [rax+68h], 0
jmp loc_32C56
loc_32ADB:
mov rdi, [rbp+var_8]
add rdi, 0B0h
mov esi, 40h ; '@'
call vec_zero
cmp [rbp+var_18], 40h ; '@'
jbe short loc_32B27
mov rdi, [rbp+var_8]
call sha256_init
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
call sha256_update
mov rdi, [rbp+var_8]
add rdi, 0B0h
mov rsi, [rbp+var_8]
call sha256_final
jmp short loc_32B3F
loc_32B27:
mov rdi, [rbp+var_8]
add rdi, 0B0h
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
call blst_sha256_bcopy
loc_32B3F:
mov [rbp+var_20], 0
loc_32B47:
cmp [rbp+var_20], 8
jnb short loc_32B7E
mov rax, [rbp+var_8]
mov rcx, [rbp+var_20]
mov rdx, 3636363636363636h
xor rdx, [rax+rcx*8+0B0h]
mov [rax+rcx*8+0B0h], rdx
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_20], rax
jmp short loc_32B47
loc_32B7E:
mov rdi, [rbp+var_8]
call sha256_init
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_8]
add rsi, 0B0h
mov edx, 40h ; '@'
call sha256_update
mov rdi, [rbp+var_8]
add rdi, 70h ; 'p'
mov rsi, [rbp+var_8]
call blst_sha256_hcopy
mov [rbp+var_20], 0
loc_32BB9:
cmp [rbp+var_20], 8
jnb short loc_32BF0
mov rax, [rbp+var_8]
mov rcx, [rbp+var_20]
mov rdx, 6A6A6A6A6A6A6A6Ah
xor rdx, [rax+rcx*8+0B0h]
mov [rax+rcx*8+0B0h], rdx
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_20], rax
jmp short loc_32BB9
loc_32BF0:
mov rdi, [rbp+var_8]
add rdi, 90h
call sha256_init_h
mov rdi, [rbp+var_8]
add rdi, 90h
mov rsi, [rbp+var_8]
add rsi, 0B0h
mov edx, 1
call blst_sha256_block_data_order
mov rdi, [rbp+var_8]
add rdi, 0B0h
mov esi, 40h ; '@'
call vec_zero
mov rax, [rbp+var_8]
mov byte ptr [rax+0D0h], 80h
mov rax, [rbp+var_8]
mov byte ptr [rax+0EEh], 3
mov rax, [rbp+var_8]
mov byte ptr [rax+0EFh], 0
loc_32C56:
add rsp, 20h
pop rbp
retn
| HMAC_init:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
CMP qword ptr [RBP + -0x10],0x0
JNZ 0x00132adb
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x8]
ADD RSI,0x70
CALL 0x0013e3d0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x20],0x40
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x28
MOV ESI,0x40
CALL 0x00123310
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x68],0x0
JMP 0x00132c56
LAB_00132adb:
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xb0
MOV ESI,0x40
CALL 0x00123310
CMP qword ptr [RBP + -0x18],0x40
JBE 0x00132b27
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00131c90
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x00131ce0
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xb0
MOV RSI,qword ptr [RBP + -0x8]
CALL 0x00131e70
JMP 0x00132b3f
LAB_00132b27:
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xb0
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x0013e3b0
LAB_00132b3f:
MOV qword ptr [RBP + -0x20],0x0
LAB_00132b47:
CMP qword ptr [RBP + -0x20],0x8
JNC 0x00132b7e
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x20]
MOV RDX,0x3636363636363636
XOR RDX,qword ptr [RAX + RCX*0x8 + 0xb0]
MOV qword ptr [RAX + RCX*0x8 + 0xb0],RDX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
JMP 0x00132b47
LAB_00132b7e:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00131c90
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x8]
ADD RSI,0xb0
MOV EDX,0x40
CALL 0x00131ce0
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x70
MOV RSI,qword ptr [RBP + -0x8]
CALL 0x0013e3d0
MOV qword ptr [RBP + -0x20],0x0
LAB_00132bb9:
CMP qword ptr [RBP + -0x20],0x8
JNC 0x00132bf0
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x20]
MOV RDX,0x6a6a6a6a6a6a6a6a
XOR RDX,qword ptr [RAX + RCX*0x8 + 0xb0]
MOV qword ptr [RAX + RCX*0x8 + 0xb0],RDX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
JMP 0x00132bb9
LAB_00132bf0:
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x90
CALL 0x00132d00
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x90
MOV RSI,qword ptr [RBP + -0x8]
ADD RSI,0xb0
MOV EDX,0x1
CALL 0x0013c000
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xb0
MOV ESI,0x40
CALL 0x00123310
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0xd0],0x80
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0xee],0x3
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0xef],0x0
LAB_00132c56:
ADD RSP,0x20
POP RBP
RET
|
void HMAC_init(long param_1,long param_2,ulong param_3)
{
int8 local_28;
if (param_2 == 0) {
blst_sha256_hcopy(param_1,param_1 + 0x70);
*(int8 *)(param_1 + 0x20) = 0x40;
vec_zero(param_1 + 0x28,0x40);
*(int8 *)(param_1 + 0x68) = 0;
}
else {
vec_zero(param_1 + 0xb0,0x40);
if (param_3 < 0x41) {
blst_sha256_bcopy(param_1 + 0xb0,param_2,param_3);
}
else {
sha256_init(param_1);
sha256_update(param_1,param_2,param_3);
sha256_final(param_1 + 0xb0,param_1);
}
for (local_28 = 0; local_28 < 8; local_28 = local_28 + 1) {
*(ulong *)(param_1 + 0xb0 + local_28 * 8) =
*(ulong *)(param_1 + 0xb0 + local_28 * 8) ^ 0x3636363636363636;
}
sha256_init(param_1);
sha256_update(param_1,param_1 + 0xb0,0x40);
blst_sha256_hcopy(param_1 + 0x70,param_1);
for (local_28 = 0; local_28 < 8; local_28 = local_28 + 1) {
*(ulong *)(param_1 + 0xb0 + local_28 * 8) =
*(ulong *)(param_1 + 0xb0 + local_28 * 8) ^ 0x6a6a6a6a6a6a6a6a;
}
sha256_init_h(param_1 + 0x90);
blst_sha256_block_data_order(param_1 + 0x90,param_1 + 0xb0,1);
vec_zero(param_1 + 0xb0,0x40);
*(int1 *)(param_1 + 0xd0) = 0x80;
*(int1 *)(param_1 + 0xee) = 3;
*(int1 *)(param_1 + 0xef) = 0;
}
return;
}
| ||
53,978 | my_wc_mb_gb2312 | eloqsql/strings/ctype-gb2312.c | static int
my_wc_mb_gb2312(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
int code;
if (s >= e)
return MY_CS_TOOSMALL;
if ((uint) wc < 0x80)
{
s[0]= (uchar) wc;
return 1;
}
if (!(code=func_uni_gb2312_onechar(wc)))
return MY_CS_ILUNI;
if (s+2>e)
return MY_CS_TOOSMALL2;
code|=0x8080;
s[0]=code>>8;
s[1]=code&0xFF;
return 2;
} | O0 | c | my_wc_mb_gb2312:
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
cmpq -0x28(%rbp), %rax
jb 0x9b57e
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0x9b602
movq -0x18(%rbp), %rax
cmpl $0x80, %eax
jae 0x9b59e
movq -0x18(%rbp), %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x9b602
movq -0x18(%rbp), %rax
movl %eax, %edi
callq 0x9b8f0
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jne 0x9b5ba
movl $0x0, -0x4(%rbp)
jmp 0x9b602
movq -0x20(%rbp), %rax
addq $0x2, %rax
cmpq -0x28(%rbp), %rax
jbe 0x9b5d1
movl $0xffffff9a, -0x4(%rbp) # imm = 0xFFFFFF9A
jmp 0x9b602
movl -0x2c(%rbp), %eax
orl $0x8080, %eax # imm = 0x8080
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
sarl $0x8, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl -0x2c(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x1(%rax)
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| my_wc_mb_gb2312:
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]
cmp rax, [rbp+var_28]
jb short loc_9B57E
mov [rbp+var_4], 0FFFFFF9Bh
jmp loc_9B602
loc_9B57E:
mov rax, [rbp+var_18]
cmp eax, 80h
jnb short loc_9B59E
mov rax, [rbp+var_18]
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov [rbp+var_4], 1
jmp short loc_9B602
loc_9B59E:
mov rax, [rbp+var_18]
mov edi, eax
call func_uni_gb2312_onechar
mov [rbp+var_2C], eax
cmp eax, 0
jnz short loc_9B5BA
mov [rbp+var_4], 0
jmp short loc_9B602
loc_9B5BA:
mov rax, [rbp+var_20]
add rax, 2
cmp rax, [rbp+var_28]
jbe short loc_9B5D1
mov [rbp+var_4], 0FFFFFF9Ah
jmp short loc_9B602
loc_9B5D1:
mov eax, [rbp+var_2C]
or eax, 8080h
mov [rbp+var_2C], eax
mov eax, [rbp+var_2C]
sar eax, 8
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov eax, [rbp+var_2C]
and eax, 0FFh
mov cl, al
mov rax, [rbp+var_20]
mov [rax+1], cl
mov [rbp+var_4], 2
loc_9B602:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long my_wc_mb_gb2312(long long a1, unsigned int a2, _BYTE *a3, unsigned long long a4)
{
int v5; // [rsp+4h] [rbp-2Ch]
__int16 v6; // [rsp+4h] [rbp-2Ch]
if ( (unsigned long long)a3 < a4 )
{
if ( a2 >= 0x80 )
{
v5 = func_uni_gb2312_onechar(a2);
if ( v5 )
{
if ( (unsigned long long)(a3 + 2) <= a4 )
{
v6 = v5 | 0x8080;
*a3 = HIBYTE(v6);
a3[1] = v6;
return 2;
}
else
{
return (unsigned int)-102;
}
}
else
{
return 0;
}
}
else
{
*a3 = a2;
return 1;
}
}
else
{
return (unsigned int)-101;
}
}
| my_wc_mb_gb2312:
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]
CMP RAX,qword ptr [RBP + -0x28]
JC 0x0019b57e
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x0019b602
LAB_0019b57e:
MOV RAX,qword ptr [RBP + -0x18]
CMP EAX,0x80
JNC 0x0019b59e
MOV RAX,qword ptr [RBP + -0x18]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],CL
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0019b602
LAB_0019b59e:
MOV RAX,qword ptr [RBP + -0x18]
MOV EDI,EAX
CALL 0x0019b8f0
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x0
JNZ 0x0019b5ba
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0019b602
LAB_0019b5ba:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x0019b5d1
MOV dword ptr [RBP + -0x4],0xffffff9a
JMP 0x0019b602
LAB_0019b5d1:
MOV EAX,dword ptr [RBP + -0x2c]
OR EAX,0x8080
MOV dword ptr [RBP + -0x2c],EAX
MOV EAX,dword ptr [RBP + -0x2c]
SAR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],CL
MOV EAX,dword ptr [RBP + -0x2c]
AND EAX,0xff
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x1],CL
MOV dword ptr [RBP + -0x4],0x2
LAB_0019b602:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 my_wc_mb_gb2312(int8 param_1,uint param_2,int1 *param_3,int1 *param_4)
{
uint uVar1;
int4 local_c;
if (param_3 < param_4) {
if (param_2 < 0x80) {
*param_3 = (char)param_2;
local_c = 1;
}
else {
uVar1 = func_uni_gb2312_onechar(param_2);
if (uVar1 == 0) {
local_c = 0;
}
else if (param_4 < param_3 + 2) {
local_c = 0xffffff9a;
}
else {
*param_3 = (char)((uVar1 | 0x8080) >> 8);
param_3[1] = (char)(uVar1 | 0x8080);
local_c = 2;
}
}
}
else {
local_c = 0xffffff9b;
}
return local_c;
}
| |
53,979 | pvio_socket_is_alive | eloqsql/libmariadb/plugins/pvio/pvio_socket.c | my_bool pvio_socket_is_alive(MARIADB_PVIO *pvio)
{
struct st_pvio_socket *csock= NULL;
#ifndef _WIN32
struct pollfd poll_fd;
#else
FD_SET sfds;
struct timeval tv= {0,0};
#endif
int res;
if (!pvio || !pvio->data)
return 0;
csock= (struct st_pvio_socket *)pvio->data;
#ifndef _WIN32
memset(&poll_fd, 0, sizeof(struct pollfd));
poll_fd.events= POLLPRI | POLLIN;
poll_fd.fd= csock->socket;
res= poll(&poll_fd, 1, 0);
if (res <= 0) /* timeout or error */
return FALSE;
if (!(poll_fd.revents & (POLLIN | POLLPRI)))
return FALSE;
return TRUE;
#else
/* We can't use the WSAPoll function, it's broken :-(
(see Windows 8 Bugs 309411 - WSAPoll does not report failed connections)
Instead we need to use select function:
If TIMEVAL is initialized to {0, 0}, select will return immediately;
this is used to poll the state of the selected sockets.
*/
FD_ZERO(&sfds);
FD_SET(csock->socket, &sfds);
res= select((int)csock->socket + 1, &sfds, NULL, NULL, &tv);
if (res > 0 && FD_ISSET(csock->socket, &sfds))
return TRUE;
return FALSE;
#endif
} | O3 | c | pvio_socket_is_alive:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x33da9
movq (%rdi), %rax
testq %rax, %rax
je 0x33da9
movabsq $0x300000000, %rcx # imm = 0x300000000
leaq -0x10(%rbp), %rdi
movq %rcx, (%rdi)
movl (%rax), %eax
movl %eax, (%rdi)
xorl %ebx, %ebx
movl $0x1, %esi
xorl %edx, %edx
callq 0x13700
testl %eax, %eax
jle 0x33dab
testb $0x3, -0xa(%rbp)
setne %bl
jmp 0x33dab
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| pvio_socket_is_alive:
push rbp
mov rbp, rsp
push rbx
push rax
test rdi, rdi
jz short loc_33DA9
mov rax, [rdi]
test rax, rax
jz short loc_33DA9
mov rcx, 300000000h
lea rdi, [rbp+var_10]
mov [rdi], rcx
mov eax, [rax]
mov [rdi], eax
xor ebx, ebx
mov esi, 1
xor edx, edx
call _poll
test eax, eax
jle short loc_33DAB
test [rbp+var_A], 3
setnz bl
jmp short loc_33DAB
loc_33DA9:
xor ebx, ebx
loc_33DAB:
mov eax, ebx
add rsp, 8
pop rbx
pop rbp
retn
| long long pvio_socket_is_alive(_DWORD **a1)
{
long long v1; // rax
_DWORD *v2; // rax
unsigned int v3; // ebx
long long v5; // [rsp+0h] [rbp-10h] BYREF
v5 = v1;
if ( a1 && (v2 = *a1) != 0LL )
{
v5 = 0x300000000LL;
LODWORD(v5) = *v2;
v3 = 0;
if ( (int)poll(&v5, 1LL, 0LL) > 0 )
LOBYTE(v3) = (v5 & 0x3000000000000LL) != 0;
}
else
{
return 0;
}
return v3;
}
| pvio_socket_is_alive:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
TEST RDI,RDI
JZ 0x00133da9
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x00133da9
MOV RCX,0x300000000
LEA RDI,[RBP + -0x10]
MOV qword ptr [RDI],RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDI],EAX
XOR EBX,EBX
MOV ESI,0x1
XOR EDX,EDX
CALL 0x00113700
TEST EAX,EAX
JLE 0x00133dab
TEST byte ptr [RBP + -0xa],0x3
SETNZ BL
JMP 0x00133dab
LAB_00133da9:
XOR EBX,EBX
LAB_00133dab:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP RBP
RET
|
bool pvio_socket_is_alive(int8 *param_1)
{
int iVar1;
bool bVar2;
pollfd local_18;
if ((param_1 == (int8 *)0x0) || ((int *)*param_1 == (int *)0x0)) {
bVar2 = false;
}
else {
local_18.events = 3;
local_18.revents = 0;
local_18.fd = *(int *)*param_1;
bVar2 = false;
iVar1 = poll(&local_18,1,0);
if (0 < iVar1) {
bVar2 = ((ulong)local_18 & 0x3000000000000) != 0;
}
}
return bVar2;
}
| |
53,980 | void bi_visitor_base::do_pins_func<_binary_info_pins_with_func>(_binary_info_pins_with_func) | msxemulator/build_O3/_deps/picotool-src/main.cpp | void do_pins_func(T value) {
uint8_t bpp = 5u; // bits per pin
uint8_t pm = 0x1fu; // pin mask
uint8_t fp = 7u; // first pin
uint8_t max_pins = 5;
if (std::is_same<T, binary_info_pins64_with_func_t>::value) {
bpp = 8u;
pm = 0xffu;
fp = 8u;
max_pins = 7;
}
unsigned int type = value.pin_encoding & 7u;
unsigned int func = (value.pin_encoding >> 3u) & 0xfu;
if (type == BI_PINS_ENCODING_RANGE) {
uint64_t mask = 0;
uint8_t plo = (value.pin_encoding >> fp) & pm;
uint8_t phi = (value.pin_encoding >> (fp + bpp)) & pm;
for(int i=plo;i<=phi;i++) { // range includes end
mask |= 1ull << i;
}
pins(mask, func, "");
} else if (type == BI_PINS_ENCODING_MULTI) {
uint64_t mask = 0;
int last = -1;
uint64_t work = value.pin_encoding >> fp;
for(int i=0;i<max_pins;i++) {
int cur = (int) (work & pm);
mask |= 1ull << cur;
if (cur == last) break;
last = cur;
work >>= bpp;
}
pins(mask, func, "");
}
} | O3 | cpp | void bi_visitor_base::do_pins_func<_binary_info_pins_with_func>(_binary_info_pins_with_func):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq 0x74(%rsp), %rax
movl %eax, %ecx
andl $0x7, %ecx
movl %eax, %ebp
shrl $0x3, %ebp
andl $0xf, %ebp
cmpl $0x1, %ecx
je 0x53842
cmpl $0x2, %ecx
jne 0x53986
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
movl $0x6, %ecx
xorl %r14d, %r14d
movl %edx, %edi
shrq $0x8, %rax
movzbl %al, %edx
btsq %rax, %r14
subl $0x1, %ecx
setb %sil
cmpl %edi, %edx
je 0x53809
testb %sil, %sil
je 0x537ec
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x5eb51(%rip), %rdx # 0xb236b
movq %rsp, %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x5c00c
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
movq %r15, %rcx
callq *0x30(%rax)
movq (%rsp), %rdi
jmp 0x53975
movl %eax, %edx
shrl $0x8, %edx
shrl $0x10, %eax
movl $0xff, %ecx
andl %ecx, %edx
andl %ecx, %eax
cmpl %eax, %edx
jbe 0x5385f
xorl %r14d, %r14d
jmp 0x5393e
incq %rax
subq %rdx, %rax
leaq 0x1(%rax), %rcx
andq $-0x2, %rcx
decq %rax
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm3 # xmm3 = xmm0[0,1,0,1]
paddq 0x4ffde(%rip), %xmm3 # 0xa3860
movq %rax, %xmm0
pshufd $0x44, %xmm0, %xmm2 # xmm2 = xmm0[0,1,0,1]
xorpd %xmm1, %xmm1
movl $0x2, %eax
movdqa 0x4ffe3(%rip), %xmm4 # 0xa3880
movdqa 0x4ffeb(%rip), %xmm5 # 0xa3890
movapd %xmm1, %xmm0
movdqa %xmm4, %xmm6
psllq %xmm3, %xmm6
pshufd $0xee, %xmm3, %xmm7 # xmm7 = xmm3[2,3,2,3]
movdqa %xmm4, %xmm1
psllq %xmm7, %xmm1
movsd %xmm6, %xmm1 # xmm1 = xmm6[0],xmm1[1]
orpd %xmm0, %xmm1
paddq %xmm5, %xmm3
leaq (%rcx,%rax), %rdx
addq $-0x2, %rdx
addq $-0x2, %rax
cmpq $0x2, %rdx
jne 0x538a5
negq %rax
movq %rax, %xmm3
pshufd $0x44, %xmm3, %xmm3 # xmm3 = xmm3[0,1,0,1]
por 0x4ff6f(%rip), %xmm3 # 0xa3860
movdqa 0x4ff77(%rip), %xmm4 # 0xa3870
pxor %xmm4, %xmm2
pxor %xmm4, %xmm3
movdqa %xmm3, %xmm4
pcmpgtd %xmm2, %xmm4
pshufd $0xa0, %xmm4, %xmm5 # xmm5 = xmm4[0,0,2,2]
pcmpeqd %xmm2, %xmm3
pshufd $0xf5, %xmm3, %xmm2 # xmm2 = xmm3[1,1,3,3]
pand %xmm5, %xmm2
pshufd $0xf5, %xmm4, %xmm3 # xmm3 = xmm4[1,1,3,3]
por %xmm2, %xmm3
pand %xmm3, %xmm0
pandn %xmm1, %xmm3
por %xmm0, %xmm3
pshufd $0xee, %xmm3, %xmm0 # xmm0 = xmm3[2,3,2,3]
por %xmm3, %xmm0
movq %xmm0, %r14
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x5ea1c(%rip), %rdx # 0xb236b
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x5c00c
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
movq %r15, %rcx
callq *0x30(%rax)
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x53986
movq (%r12), %rsi
incq %rsi
callq 0xf470
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
jmp 0x539a4
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x539b5
movq (%r12), %rsi
incq %rsi
callq 0xf470
movq %rbx, %rdi
callq 0xf7d0
nop
| _ZN15bi_visitor_base12do_pins_funcI29_binary_info_pins64_with_funcEEvT_:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 40h
mov rbx, rdi
mov rax, [rsp+68h+arg_4]
mov ecx, eax
and ecx, 7
mov ebp, eax
shr ebp, 3
and ebp, 0Fh
cmp ecx, 1
jz short loc_53842
cmp ecx, 2
jnz loc_53986
mov edx, 0FFFFFFFFh
mov ecx, 6
xor r14d, r14d
loc_537EC:
mov edi, edx
shr rax, 8
movzx edx, al
bts r14, rax
sub ecx, 1
setb sil
cmp edx, edi
jz short loc_53809
test sil, sil
jz short loc_537EC
loc_53809:
lea r12, [rsp+68h+var_58]
mov [r12-10h], r12
lea rdx, unk_B236B
mov r15, rsp
mov rdi, r15
mov rsi, rdx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rax, [rbx]
mov rdi, rbx
mov rsi, r14
mov edx, ebp
mov rcx, r15
call qword ptr [rax+30h]
mov rdi, [rsp+68h+var_68]
jmp loc_53975
loc_53842:
mov edx, eax
shr edx, 8
shr eax, 10h
mov ecx, 0FFh
and edx, ecx
and eax, ecx
cmp edx, eax
jbe short loc_5385F
xor r14d, r14d
jmp loc_5393E
loc_5385F:
inc rax
sub rax, rdx
lea rcx, [rax+1]
and rcx, 0FFFFFFFFFFFFFFFEh
dec rax
movq xmm0, rdx
pshufd xmm3, xmm0, 44h ; 'D'
paddq xmm3, cs:xmmword_A3860
movq xmm0, rax
pshufd xmm2, xmm0, 44h ; 'D'
xorpd xmm1, xmm1
mov eax, 2
movdqa xmm4, cs:xmmword_A3880
movdqa xmm5, cs:xmmword_A3890
loc_538A5:
movapd xmm0, xmm1
movdqa xmm6, xmm4
psllq xmm6, xmm3
pshufd xmm7, xmm3, 0EEh
movdqa xmm1, xmm4
psllq xmm1, xmm7
movsd xmm1, xmm6
orpd xmm1, xmm0
paddq xmm3, xmm5
lea rdx, [rcx+rax]
add rdx, 0FFFFFFFFFFFFFFFEh
add rax, 0FFFFFFFFFFFFFFFEh
cmp rdx, 2
jnz short loc_538A5
neg rax
movq xmm3, rax
pshufd xmm3, xmm3, 44h ; 'D'
por xmm3, cs:xmmword_A3860
movdqa xmm4, cs:xmmword_A3870
pxor xmm2, xmm4
pxor xmm3, xmm4
movdqa xmm4, xmm3
pcmpgtd xmm4, xmm2
pshufd xmm5, xmm4, 0A0h
pcmpeqd xmm3, xmm2
pshufd xmm2, xmm3, 0F5h
pand xmm2, xmm5
pshufd xmm3, xmm4, 0F5h
por xmm3, xmm2
pand xmm0, xmm3
pandn xmm3, xmm1
por xmm3, xmm0
pshufd xmm0, xmm3, 0EEh
por xmm0, xmm3
movq r14, xmm0
loc_5393E:
lea r12, [rsp+68h+var_38]
mov [r12-10h], r12
lea rdx, unk_B236B
lea r15, [rsp+68h+var_48]
mov rdi, r15
mov rsi, rdx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rax, [rbx]
mov rdi, rbx
mov rsi, r14
mov edx, ebp
mov rcx, r15
call qword ptr [rax+30h]
mov rdi, [rsp+68h+var_48]; void *
loc_53975:
cmp rdi, r12
jz short loc_53986
mov rsi, [r12]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_53986:
add rsp, 40h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov rdi, [rsp+arg_18]
jmp short loc_539A4
mov rbx, rax
mov rdi, [rsp+0]; void *
loc_539A4:
cmp rdi, r12
jz short loc_539B5
mov rsi, [r12]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_539B5:
mov rdi, rbx
call __Unwind_Resume
| void bi_visitor_base::do_pins_func<_binary_info_pins64_with_func>(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__int128 a7)
{
unsigned long long v8; // rax
int v9; // ecx
unsigned int v10; // ebp
int v11; // edx
int v12; // ecx
long long v13; // r14
int v14; // edi
bool v15; // cf
_BYTE *v16; // r12
_BYTE *v17; // rdi
unsigned long long v18; // r14
__m128i v19; // xmm3
__m128i v20; // xmm2
__m128i v21; // xmm1
long long v22; // rax
__m128i si128; // xmm4
__m128i v24; // xmm5
__m128d v25; // xmm0
__m128d v26; // xmm1
unsigned long long v27; // rdx
__m128i v28; // xmm4
__m128i v29; // xmm2
__m128i v30; // xmm3
__m128i v31; // xmm4
__m128i v32; // xmm3
__m128i v33; // xmm3
_QWORD v34[2]; // [rsp+0h] [rbp-68h] BYREF
_BYTE v35[16]; // [rsp+10h] [rbp-58h] BYREF
void *v36[2]; // [rsp+20h] [rbp-48h] BYREF
_BYTE v37[56]; // [rsp+30h] [rbp-38h] BYREF
v8 = *(_QWORD *)((char *)&a7 + 4);
v9 = BYTE4(a7) & 7;
v10 = (DWORD1(a7) >> 3) & 0xF;
if ( v9 == 1 )
{
if ( BYTE5(a7) <= (unsigned int)BYTE6(a7) )
{
v19 = _mm_add_epi64(_mm_shuffle_epi32((__m128i)BYTE5(a7), 68), (__m128i)xmmword_A3860);
v20 = _mm_shuffle_epi32((__m128i)(BYTE6(a7) - (unsigned long long)BYTE5(a7)), 68);
v21 = 0LL;
v22 = 2LL;
si128 = _mm_load_si128((const __m128i *)&xmmword_A3880);
v24 = _mm_load_si128((const __m128i *)&xmmword_A3890);
do
{
v25 = (__m128d)v21;
v26 = (__m128d)_mm_sll_epi64(si128, _mm_shuffle_epi32(v19, 238));
*(_QWORD *)&v26.m128d_f64[0] = si128.m128i_i64[0] << v19.m128i_i8[0];
v21 = (__m128i)_mm_or_pd(v26, v25);
v19 = _mm_add_epi64(v19, v24);
v27 = ((BYTE6(a7) + 1LL - BYTE5(a7) + 1) & 0xFFFFFFFFFFFFFFFELL) + v22 - 2;
v22 -= 2LL;
}
while ( v27 != 2 );
v28 = _mm_load_si128((const __m128i *)&xmmword_A3870);
v29 = _mm_xor_si128(v20, v28);
v30 = _mm_xor_si128(
_mm_or_si128(_mm_shuffle_epi32((__m128i)(unsigned long long)-v22, 68), (__m128i)xmmword_A3860),
v28);
v31 = _mm_cmpgt_epi32(v30, v29);
v32 = _mm_or_si128(
_mm_shuffle_epi32(v31, 245),
_mm_and_si128(_mm_shuffle_epi32(_mm_cmpeq_epi32(v30, v29), 245), _mm_shuffle_epi32(v31, 160)));
v33 = _mm_or_si128(_mm_andnot_si128(v32, v21), _mm_and_si128((__m128i)v25, v32));
v18 = _mm_or_si128(_mm_shuffle_epi32(v33, 238), v33).m128i_u64[0];
}
else
{
v18 = 0LL;
}
v16 = v37;
v36[0] = v37;
std::string::_M_construct<char const*>(v36, &unk_B236B, &unk_B236B);
(*(void ( **)(long long, unsigned long long, _QWORD, void **))(*(_QWORD *)a1 + 48LL))(a1, v18, v10, v36);
v17 = v36[0];
}
else
{
if ( v9 != 2 )
return;
v11 = -1;
v12 = 6;
v13 = 0LL;
do
{
v14 = v11;
v8 >>= 8;
v11 = (unsigned __int8)v8;
v13 |= 1LL << v8;
v15 = v12-- == 0;
}
while ( (unsigned __int8)v8 != v14 && !v15 );
v16 = v35;
v34[0] = v35;
std::string::_M_construct<char const*>(v34, &unk_B236B, &unk_B236B);
(*(void ( **)(long long, long long, _QWORD, _QWORD *))(*(_QWORD *)a1 + 48LL))(a1, v13, v10, v34);
v17 = (_BYTE *)v34[0];
}
if ( v17 != v16 )
operator delete(v17, *(_QWORD *)v16 + 1LL);
}
| do_pins_func<_binary_info_pins64_with_func>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x40
MOV RBX,RDI
MOV RAX,qword ptr [RSP + 0x74]
MOV ECX,EAX
AND ECX,0x7
MOV EBP,EAX
SHR EBP,0x3
AND EBP,0xf
CMP ECX,0x1
JZ 0x00153842
CMP ECX,0x2
JNZ 0x00153986
MOV EDX,0xffffffff
MOV ECX,0x6
XOR R14D,R14D
LAB_001537ec:
MOV EDI,EDX
SHR RAX,0x8
MOVZX EDX,AL
BTS R14,RAX
SUB ECX,0x1
SETC SIL
CMP EDX,EDI
JZ 0x00153809
TEST SIL,SIL
JZ 0x001537ec
LAB_00153809:
LEA R12,[RSP + 0x10]
MOV qword ptr [R12 + -0x10],R12
LEA RDX,[0x1b236b]
MOV R15,RSP
MOV RDI,R15
MOV RSI,RDX
CALL 0x0015c00c
MOV RAX,qword ptr [RBX]
LAB_0015382b:
MOV RDI,RBX
MOV RSI,R14
MOV EDX,EBP
MOV RCX,R15
CALL qword ptr [RAX + 0x30]
LAB_00153839:
MOV RDI,qword ptr [RSP]
JMP 0x00153975
LAB_00153842:
MOV EDX,EAX
SHR EDX,0x8
SHR EAX,0x10
MOV ECX,0xff
AND EDX,ECX
AND EAX,ECX
CMP EDX,EAX
JBE 0x0015385f
XOR R14D,R14D
JMP 0x0015393e
LAB_0015385f:
INC RAX
SUB RAX,RDX
LEA RCX,[RAX + 0x1]
AND RCX,-0x2
DEC RAX
MOVQ XMM0,RDX
PSHUFD XMM3,XMM0,0x44
PADDQ XMM3,xmmword ptr [0x001a3860]
MOVQ XMM0,RAX
PSHUFD XMM2,XMM0,0x44
XORPD XMM1,XMM1
MOV EAX,0x2
MOVDQA XMM4,xmmword ptr [0x001a3880]
MOVDQA XMM5,xmmword ptr [0x001a3890]
LAB_001538a5:
MOVAPD XMM0,XMM1
MOVDQA XMM6,XMM4
PSLLQ XMM6,XMM3
PSHUFD XMM7,XMM3,0xee
MOVDQA XMM1,XMM4
PSLLQ XMM1,XMM7
MOVSD XMM1,XMM6
ORPD XMM1,XMM0
PADDQ XMM3,XMM5
LEA RDX,[RCX + RAX*0x1]
ADD RDX,-0x2
ADD RAX,-0x2
CMP RDX,0x2
JNZ 0x001538a5
NEG RAX
MOVQ XMM3,RAX
PSHUFD XMM3,XMM3,0x44
POR XMM3,xmmword ptr [0x001a3860]
MOVDQA XMM4,xmmword ptr [0x001a3870]
PXOR XMM2,XMM4
PXOR XMM3,XMM4
MOVDQA XMM4,XMM3
PCMPGTD XMM4,XMM2
PSHUFD XMM5,XMM4,0xa0
PCMPEQD XMM3,XMM2
PSHUFD XMM2,XMM3,0xf5
PAND XMM2,XMM5
PSHUFD XMM3,XMM4,0xf5
POR XMM3,XMM2
PAND XMM0,XMM3
PANDN XMM3,XMM1
POR XMM3,XMM0
PSHUFD XMM0,XMM3,0xee
POR XMM0,XMM3
MOVQ R14,XMM0
LAB_0015393e:
LEA R12,[RSP + 0x30]
MOV qword ptr [R12 + -0x10],R12
LEA RDX,[0x1b236b]
LEA R15,[RSP + 0x20]
MOV RDI,R15
MOV RSI,RDX
CALL 0x0015c00c
MOV RAX,qword ptr [RBX]
LAB_00153962:
MOV RDI,RBX
MOV RSI,R14
MOV EDX,EBP
MOV RCX,R15
CALL qword ptr [RAX + 0x30]
LAB_00153970:
MOV RDI,qword ptr [RSP + 0x20]
LAB_00153975:
CMP RDI,R12
JZ 0x00153986
MOV RSI,qword ptr [R12]
INC RSI
CALL 0x0010f470
LAB_00153986:
ADD RSP,0x40
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* void bi_visitor_base::do_pins_func<_binary_info_pins64_with_func>(_binary_info_pins64_with_func)
*/
void bi_visitor_base::do_pins_func<_binary_info_pins64_with_func>(long *param_1)
{
long lVar1;
long lVar2;
long lVar3;
uint uVar4;
int iVar5;
uint uVar6;
uint uVar7;
long *plVar8;
long *plVar9;
ulong uVar10;
bool bVar11;
int1 auVar12 [16];
int1 auVar13 [16];
int1 auVar14 [16];
int1 auVar15 [16];
long lVar16;
long lVar20;
int1 auVar17 [16];
int1 auVar18 [16];
int1 auVar19 [16];
int iVar21;
int iVar22;
int iVar23;
int1 auVar24 [16];
int1 in_stack_00000008 [16];
long *local_68 [2];
long local_58 [2];
long *local_48 [2];
long local_38 [2];
uVar4 = in_stack_00000008._4_4_ & 7;
uVar7 = (uint)((ulong)in_stack_00000008._4_8_ >> 3) & 0xf;
if (uVar4 == 1) {
uVar6 = in_stack_00000008._5_4_ & 0xff;
uVar4 = in_stack_00000008._4_4_ >> 0x10 & 0xff;
if (uVar4 < uVar6) {
uVar10 = 0;
}
else {
lVar2 = ((ulong)uVar4 + 1) - (ulong)uVar6;
lVar3 = lVar2 + -1;
lVar16 = (ulong)uVar6 + _DAT_001a3860;
lVar20 = (ulong)uVar6 + _UNK_001a3868;
auVar14._8_4_ = (int)lVar3;
auVar14._0_8_ = lVar3;
auVar14._12_4_ = (int)((ulong)lVar3 >> 0x20);
lVar3 = 2;
auVar13 = ZEXT816(0);
do {
auVar12 = auVar13;
auVar13._8_8_ = _UNK_001a3888 << lVar20;
auVar13._0_8_ = _DAT_001a3880 << lVar16;
auVar13 = auVar13 | auVar12;
lVar16 = lVar16 + _DAT_001a3890;
lVar20 = lVar20 + _UNK_001a3898;
lVar1 = (lVar2 + 1U & 0xfffffffffffffffe) + lVar3;
lVar3 = lVar3 + -2;
} while (lVar1 != 4);
lVar3 = -lVar3;
auVar17._8_4_ = (int)lVar3;
auVar17._0_8_ = lVar3;
auVar17._12_4_ = (int)((ulong)lVar3 >> 0x20);
auVar18._8_8_ = _UNK_001a3868;
auVar18._0_8_ = _DAT_001a3860;
auVar14 = auVar14 ^ _DAT_001a3870;
auVar18 = (auVar17 | auVar18) ^ _DAT_001a3870;
iVar5 = -(uint)(auVar14._0_4_ < auVar18._0_4_);
iVar21 = -(uint)(auVar14._4_4_ < auVar18._4_4_);
iVar22 = -(uint)(auVar14._8_4_ < auVar18._8_4_);
iVar23 = -(uint)(auVar14._12_4_ < auVar18._12_4_);
auVar24._4_4_ = iVar5;
auVar24._0_4_ = iVar5;
auVar24._8_4_ = iVar22;
auVar24._12_4_ = iVar22;
iVar5 = -(uint)(auVar18._4_4_ == auVar14._4_4_);
iVar22 = -(uint)(auVar18._12_4_ == auVar14._12_4_);
auVar15._4_4_ = iVar5;
auVar15._0_4_ = iVar5;
auVar15._8_4_ = iVar22;
auVar15._12_4_ = iVar22;
auVar19._4_4_ = iVar21;
auVar19._0_4_ = iVar21;
auVar19._8_4_ = iVar23;
auVar19._12_4_ = iVar23;
auVar19 = auVar19 | auVar15 & auVar24;
auVar13 = ~auVar19 & auVar13 | auVar12 & auVar19;
uVar10 = auVar13._8_8_ | auVar13._0_8_;
}
plVar9 = local_38;
local_48[0] = plVar9;
std::__cxx11::string::_M_construct<char_const*>((string *)local_48,&DAT_001b236b);
/* try { // try from 00153962 to 0015396f has its CatchHandler @ 00153993 */
(**(code **)(*param_1 + 0x30))(param_1,uVar10,uVar7,(string *)local_48);
plVar8 = local_48[0];
}
else {
if (uVar4 != 2) {
return;
}
iVar5 = 6;
uVar10 = 0;
uVar4 = 0xffffffff;
do {
uVar6 = (uint)(byte)((ulong)in_stack_00000008._4_8_ >> 8);
uVar10 = uVar10 | 1L << ((ulong)in_stack_00000008._4_8_ >> 8 & 0x3f);
bVar11 = iVar5 != 0;
iVar5 = iVar5 + -1;
if (uVar6 == uVar4) break;
in_stack_00000008._4_8_ = (ulong)in_stack_00000008._4_8_ >> 8;
uVar4 = uVar6;
} while (bVar11);
plVar9 = local_58;
local_68[0] = plVar9;
std::__cxx11::string::_M_construct<char_const*>((string *)local_68,&DAT_001b236b);
/* try { // try from 0015382b to 00153838 has its CatchHandler @ 0015399d */
(**(code **)(*param_1 + 0x30))(param_1,uVar10,uVar7,local_68);
plVar8 = local_68[0];
}
if (plVar8 != plVar9) {
operator_delete(plVar8,*plVar9 + 1);
}
return;
}
| |
53,981 | my_snprintf_utf32 | eloqsql/strings/ctype-ucs2.c | static size_t
my_snprintf_utf32(CHARSET_INFO *cs __attribute__((unused)),
char* to, size_t n, const char* fmt, ...)
{
size_t ret;
va_list args;
va_start(args,fmt);
ret= my_vsnprintf_utf32(to, n, fmt, args);
va_end(args);
return ret;
} | O3 | c | my_snprintf_utf32:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r12
leaq -0x120(%rbp), %rcx
movq %r8, 0x20(%rcx)
movq %r9, 0x28(%rcx)
testb %al, %al
je 0x8020b
movaps %xmm0, -0xf0(%rbp)
movaps %xmm1, -0xe0(%rbp)
movaps %xmm2, -0xd0(%rbp)
movaps %xmm3, -0xc0(%rbp)
movaps %xmm4, -0xb0(%rbp)
movaps %xmm5, -0xa0(%rbp)
movaps %xmm6, -0x90(%rbp)
movaps %xmm7, -0x80(%rbp)
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq %rcx, -0x50(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movabsq $0x3000000020, %rax # imm = 0x3000000020
movq %rax, -0x60(%rbp)
addq %rsi, %rbx
leaq -0x40(%rbp), %r14
movq %rsi, -0x68(%rbp)
movzbl (%r15), %eax
cmpl $0x25, %eax
je 0x80275
testl %eax, %eax
je 0x803f6
cmpq %rbx, %r12
jae 0x803f6
movw $0x0, (%r12)
movb $0x0, 0x2(%r12)
movb (%r15), %al
movb %al, 0x3(%r12)
addq $0x4, %r12
incq %r15
jmp 0x8023d
addq $0x2, %r15
movb -0x1(%r15), %al
leal -0x30(%rax), %ecx
cmpb $0xa, %cl
jb 0x80290
movzbl %al, %ecx
leal -0x2d(%rcx), %edx
cmpl $0x2, %edx
jae 0x80295
incq %r15
jmp 0x80279
cmpl $0x6c, %ecx
jne 0x8029f
movb (%r15), %al
jmp 0x802a2
decq %r15
cmpb $0x64, %al
je 0x802d2
movzbl %al, %eax
cmpl $0x75, %eax
je 0x802d2
cmpl $0x73, %eax
jne 0x802fa
movl -0x60(%rbp), %ecx
cmpq $0x28, %rcx
ja 0x80373
movq %rcx, %rax
addq -0x50(%rbp), %rax
addl $0x8, %ecx
movl %ecx, -0x60(%rbp)
jmp 0x8037f
movq %rbx, %rax
subq %r12, %rax
cmpq $0x3f, %rax
jbe 0x803f6
movl -0x60(%rbp), %ecx
cmpq $0x28, %rcx
ja 0x80310
movq %rcx, %rax
addq -0x50(%rbp), %rax
addl $0x8, %ecx
movl %ecx, -0x60(%rbp)
jmp 0x8031c
cmpq %rbx, %r12
je 0x803f3
movl $0x25000000, (%r12) # imm = 0x25000000
jmp 0x8026c
movq -0x58(%rbp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x58(%rbp)
movslq (%rax), %rdi
cmpb $0x64, (%r15)
jne 0x8032f
movq %r14, %rsi
movl $0xfffffff6, %edx # imm = 0xFFFFFFF6
jmp 0x80339
movl %edi, %edi
movq %r14, %rsi
movl $0xa, %edx
callq 0x90f3a
cmpb $0x0, -0x40(%rbp)
je 0x80270
leaq -0x3f(%rbp), %rax
movw $0x0, (%r12)
movb $0x0, 0x2(%r12)
movb -0x1(%rax), %cl
movb %cl, 0x3(%r12)
addq $0x4, %r12
cmpb $0x0, (%rax)
leaq 0x1(%rax), %rax
jne 0x8034c
jmp 0x80270
movq -0x58(%rbp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x58(%rbp)
movq (%rax), %r13
movq %rbx, %r14
subq %r12, %r14
testq %r13, %r13
leaq 0x1ab88(%rip), %rax # 0x9af1a
cmoveq %rax, %r13
movq %r13, %rdi
callq 0x36410
leaq (,%rax,4), %rdx
movq %r14, %rcx
shrq $0x2, %rcx
decq %rcx
cmpq %rdx, %r14
cmovaq %rax, %rcx
testq %rcx, %rcx
je 0x803ea
xorl %eax, %eax
leaq -0x40(%rbp), %r14
movw $0x0, (%r12)
movb $0x0, 0x2(%r12)
movb (%r13,%rax), %dl
movb %dl, 0x3(%r12)
addq $0x4, %r12
incq %rax
cmpq %rax, %rcx
jne 0x803c2
jmp 0x80270
leaq -0x40(%rbp), %r14
jmp 0x80270
movq %rbx, %r12
movl $0x0, (%r12)
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x80426
subq -0x68(%rbp), %r12
movq %r12, %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x362b0
| my_snprintf_utf32:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0F8h
mov r15, rcx
mov rbx, rdx
mov r12, rsi
lea rcx, [rbp+var_120]
mov [rcx+20h], r8
mov [rcx+28h], r9
test al, al
jz short loc_8020B
movaps [rbp+var_F0], xmm0
movaps [rbp+var_E0], xmm1
movaps [rbp+var_D0], xmm2
movaps [rbp+var_C0], xmm3
movaps [rbp+var_B0], xmm4
movaps [rbp+var_A0], xmm5
movaps [rbp+var_90], xmm6
movaps [rbp+var_80], xmm7
loc_8020B:
mov rax, fs:28h
mov [rbp+var_30], rax
mov [rbp+var_50], rcx
lea rax, [rbp+arg_0]
mov [rbp+var_58], rax
mov rax, 3000000020h
mov [rbp+var_60], rax
add rbx, rsi
lea r14, [rbp+var_40]
mov [rbp+var_68], rsi
loc_8023D:
movzx eax, byte ptr [r15]
cmp eax, 25h ; '%'
jz short loc_80275
test eax, eax
jz loc_803F6
cmp r12, rbx
jnb loc_803F6
mov word ptr [r12], 0
mov byte ptr [r12+2], 0
mov al, [r15]
mov [r12+3], al
loc_8026C:
add r12, 4
loc_80270:
inc r15
jmp short loc_8023D
loc_80275:
add r15, 2
loc_80279:
mov al, [r15-1]
lea ecx, [rax-30h]
cmp cl, 0Ah
jb short loc_80290
movzx ecx, al
lea edx, [rcx-2Dh]
cmp edx, 2
jnb short loc_80295
loc_80290:
inc r15
jmp short loc_80279
loc_80295:
cmp ecx, 6Ch ; 'l'
jnz short loc_8029F
mov al, [r15]
jmp short loc_802A2
loc_8029F:
dec r15
loc_802A2:
cmp al, 64h ; 'd'
jz short loc_802D2
movzx eax, al
cmp eax, 75h ; 'u'
jz short loc_802D2
cmp eax, 73h ; 's'
jnz short loc_802FA
mov ecx, dword ptr [rbp+var_60]
cmp rcx, 28h ; '('
ja loc_80373
mov rax, rcx
add rax, [rbp+var_50]
add ecx, 8
mov dword ptr [rbp+var_60], ecx
jmp loc_8037F
loc_802D2:
mov rax, rbx
sub rax, r12
cmp rax, 3Fh ; '?'
jbe loc_803F6
mov ecx, dword ptr [rbp+var_60]
cmp rcx, 28h ; '('
ja short loc_80310
mov rax, rcx
add rax, [rbp+var_50]
add ecx, 8
mov dword ptr [rbp+var_60], ecx
jmp short loc_8031C
loc_802FA:
cmp r12, rbx
jz loc_803F3
mov dword ptr [r12], 25000000h
jmp loc_8026C
loc_80310:
mov rax, [rbp+var_58]
lea rcx, [rax+8]
mov [rbp+var_58], rcx
loc_8031C:
movsxd rdi, dword ptr [rax]
cmp byte ptr [r15], 64h ; 'd'
jnz short loc_8032F
mov rsi, r14
mov edx, 0FFFFFFF6h
jmp short loc_80339
loc_8032F:
mov edi, edi
mov rsi, r14
mov edx, 0Ah
loc_80339:
call int10_to_str
cmp [rbp+var_40], 0
jz loc_80270
lea rax, [rbp+var_3F]
loc_8034C:
mov word ptr [r12], 0
mov byte ptr [r12+2], 0
mov cl, [rax-1]
mov [r12+3], cl
add r12, 4
cmp byte ptr [rax], 0
lea rax, [rax+1]
jnz short loc_8034C
jmp loc_80270
loc_80373:
mov rax, [rbp+var_58]
lea rcx, [rax+8]
mov [rbp+var_58], rcx
loc_8037F:
mov r13, [rax]
mov r14, rbx
sub r14, r12
test r13, r13
lea rax, aNull_0; "(null)"
cmovz r13, rax
mov rdi, r13
call _strlen
lea rdx, ds:0[rax*4]
mov rcx, r14
shr rcx, 2
dec rcx
cmp r14, rdx
cmova rcx, rax
test rcx, rcx
jz short loc_803EA
xor eax, eax
lea r14, [rbp+var_40]
loc_803C2:
mov word ptr [r12], 0
mov byte ptr [r12+2], 0
mov dl, [r13+rax+0]
mov [r12+3], dl
add r12, 4
inc rax
cmp rcx, rax
jnz short loc_803C2
jmp loc_80270
loc_803EA:
lea r14, [rbp+var_40]
jmp loc_80270
loc_803F3:
mov r12, rbx
loc_803F6:
mov dword ptr [r12], 0
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_80426
sub r12, [rbp+var_68]
mov rax, r12
add rsp, 0F8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_80426:
call ___stack_chk_fail
| unsigned long long my_snprintf_utf32(
__m128 a1,
__m128 a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
long long a9,
unsigned long long a10,
long long a11,
unsigned __int8 *a12,
long long a13,
long long a14,
char a15)
{
unsigned long long v16; // r12
unsigned long long v17; // rbx
unsigned __int8 v18; // al
const char **v19; // rax
char *v20; // rax
long long v21; // rdi
long long v22; // rdx
char *v23; // rax
const char *v25; // r13
unsigned long long v26; // r14
long long v27; // rax
long long v28; // rcx
long long i; // rax
char v31; // [rsp+0h] [rbp-120h] BYREF
long long v32; // [rsp+20h] [rbp-100h]
long long v33; // [rsp+28h] [rbp-F8h]
__m128 v34; // [rsp+30h] [rbp-F0h]
__m128 v35; // [rsp+40h] [rbp-E0h]
__m128 v36; // [rsp+50h] [rbp-D0h]
__m128 v37; // [rsp+60h] [rbp-C0h]
__m128 v38; // [rsp+70h] [rbp-B0h]
__m128 v39; // [rsp+80h] [rbp-A0h]
__m128 v40; // [rsp+90h] [rbp-90h]
__m128 v41; // [rsp+A0h] [rbp-80h]
unsigned long long v42; // [rsp+B8h] [rbp-68h]
long long v43; // [rsp+C0h] [rbp-60h]
char *v44; // [rsp+C8h] [rbp-58h]
char *v45; // [rsp+D0h] [rbp-50h]
char v46; // [rsp+E0h] [rbp-40h] BYREF
char v47; // [rsp+E1h] [rbp-3Fh] BYREF
unsigned long long v48; // [rsp+F0h] [rbp-30h]
v34 = a1;
v35 = a2;
v36 = a3;
v37 = a4;
v38 = a5;
v39 = a6;
v40 = a7;
v41 = a8;
v16 = a10;
v32 = a13;
v33 = a14;
v48 = __readfsqword(0x28u);
v45 = &v31;
v44 = &a15;
v43 = 0x3000000020LL;
v17 = a10 + a11;
v42 = a10;
while ( 1 )
{
if ( *a12 != 37 )
{
if ( !*a12 || v16 >= v17 )
goto LABEL_44;
*(_WORD *)v16 = 0;
*(_BYTE *)(v16 + 2) = 0;
*(_BYTE *)(v16 + 3) = *a12;
goto LABEL_6;
}
for ( a12 += 2; ; ++a12 )
{
v18 = *(a12 - 1);
if ( (unsigned __int8)(v18 - 48) >= 0xAu && (unsigned int)v18 - 45 >= 2 )
break;
}
if ( v18 == 108 )
v18 = *a12;
else
--a12;
if ( v18 != 100 && v18 != 117 )
break;
if ( v17 - v16 <= 0x3F )
goto LABEL_44;
if ( (unsigned int)v43 > 0x28uLL )
{
v20 = v44;
v44 += 8;
}
else
{
v20 = &v45[(unsigned int)v43];
LODWORD(v43) = v43 + 8;
}
v21 = *(int *)v20;
if ( *a12 == 100 )
{
v22 = 4294967286LL;
}
else
{
v21 = (unsigned int)v21;
v22 = 10LL;
}
int10_to_str(v21, &v46, v22);
if ( v46 )
{
v23 = &v47;
do
{
*(_WORD *)v16 = 0;
*(_BYTE *)(v16 + 2) = 0;
*(_BYTE *)(v16 + 3) = *(v23 - 1);
v16 += 4LL;
}
while ( *v23++ != 0 );
}
LABEL_7:
++a12;
}
if ( v18 == 115 )
{
if ( (unsigned int)v43 > 0x28uLL )
{
v19 = (const char **)v44;
v44 += 8;
}
else
{
v19 = (const char **)&v45[(unsigned int)v43];
LODWORD(v43) = v43 + 8;
}
v25 = *v19;
v26 = v17 - v16;
if ( !*v19 )
v25 = "(null)";
v27 = strlen(v25);
v28 = (v26 >> 2) - 1;
if ( v26 > 4 * v27 )
v28 = v27;
if ( v28 )
{
for ( i = 0LL; i != v28; ++i )
{
*(_WORD *)v16 = 0;
*(_BYTE *)(v16 + 2) = 0;
*(_BYTE *)(v16 + 3) = v25[i];
v16 += 4LL;
}
}
goto LABEL_7;
}
if ( v16 != v17 )
{
*(_DWORD *)v16 = 620756992;
LABEL_6:
v16 += 4LL;
goto LABEL_7;
}
v16 = v17;
LABEL_44:
*(_DWORD *)v16 = 0;
return v16 - v42;
}
| my_snprintf_utf32:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xf8
MOV R15,RCX
MOV RBX,RDX
MOV R12,RSI
LEA RCX,[RBP + -0x120]
MOV qword ptr [RCX + 0x20],R8
MOV qword ptr [RCX + 0x28],R9
TEST AL,AL
JZ 0x0018020b
MOVAPS xmmword ptr [RBP + -0xf0],XMM0
MOVAPS xmmword ptr [RBP + -0xe0],XMM1
MOVAPS xmmword ptr [RBP + -0xd0],XMM2
MOVAPS xmmword ptr [RBP + -0xc0],XMM3
MOVAPS xmmword ptr [RBP + -0xb0],XMM4
MOVAPS xmmword ptr [RBP + -0xa0],XMM5
MOVAPS xmmword ptr [RBP + -0x90],XMM6
MOVAPS xmmword ptr [RBP + -0x80],XMM7
LAB_0018020b:
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV qword ptr [RBP + -0x50],RCX
LEA RAX,[RBP + 0x10]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,0x3000000020
MOV qword ptr [RBP + -0x60],RAX
ADD RBX,RSI
LEA R14,[RBP + -0x40]
MOV qword ptr [RBP + -0x68],RSI
LAB_0018023d:
MOVZX EAX,byte ptr [R15]
CMP EAX,0x25
JZ 0x00180275
TEST EAX,EAX
JZ 0x001803f6
CMP R12,RBX
JNC 0x001803f6
MOV word ptr [R12],0x0
MOV byte ptr [R12 + 0x2],0x0
MOV AL,byte ptr [R15]
MOV byte ptr [R12 + 0x3],AL
LAB_0018026c:
ADD R12,0x4
LAB_00180270:
INC R15
JMP 0x0018023d
LAB_00180275:
ADD R15,0x2
LAB_00180279:
MOV AL,byte ptr [R15 + -0x1]
LEA ECX,[RAX + -0x30]
CMP CL,0xa
JC 0x00180290
MOVZX ECX,AL
LEA EDX,[RCX + -0x2d]
CMP EDX,0x2
JNC 0x00180295
LAB_00180290:
INC R15
JMP 0x00180279
LAB_00180295:
CMP ECX,0x6c
JNZ 0x0018029f
MOV AL,byte ptr [R15]
JMP 0x001802a2
LAB_0018029f:
DEC R15
LAB_001802a2:
CMP AL,0x64
JZ 0x001802d2
MOVZX EAX,AL
CMP EAX,0x75
JZ 0x001802d2
CMP EAX,0x73
JNZ 0x001802fa
MOV ECX,dword ptr [RBP + -0x60]
CMP RCX,0x28
JA 0x00180373
MOV RAX,RCX
ADD RAX,qword ptr [RBP + -0x50]
ADD ECX,0x8
MOV dword ptr [RBP + -0x60],ECX
JMP 0x0018037f
LAB_001802d2:
MOV RAX,RBX
SUB RAX,R12
CMP RAX,0x3f
JBE 0x001803f6
MOV ECX,dword ptr [RBP + -0x60]
CMP RCX,0x28
JA 0x00180310
MOV RAX,RCX
ADD RAX,qword ptr [RBP + -0x50]
ADD ECX,0x8
MOV dword ptr [RBP + -0x60],ECX
JMP 0x0018031c
LAB_001802fa:
CMP R12,RBX
JZ 0x001803f3
MOV dword ptr [R12],0x25000000
JMP 0x0018026c
LAB_00180310:
MOV RAX,qword ptr [RBP + -0x58]
LEA RCX,[RAX + 0x8]
MOV qword ptr [RBP + -0x58],RCX
LAB_0018031c:
MOVSXD RDI,dword ptr [RAX]
CMP byte ptr [R15],0x64
JNZ 0x0018032f
MOV RSI,R14
MOV EDX,0xfffffff6
JMP 0x00180339
LAB_0018032f:
MOV EDI,EDI
MOV RSI,R14
MOV EDX,0xa
LAB_00180339:
CALL 0x00190f3a
CMP byte ptr [RBP + -0x40],0x0
JZ 0x00180270
LEA RAX,[RBP + -0x3f]
LAB_0018034c:
MOV word ptr [R12],0x0
MOV byte ptr [R12 + 0x2],0x0
MOV CL,byte ptr [RAX + -0x1]
MOV byte ptr [R12 + 0x3],CL
ADD R12,0x4
CMP byte ptr [RAX],0x0
LEA RAX,[RAX + 0x1]
JNZ 0x0018034c
JMP 0x00180270
LAB_00180373:
MOV RAX,qword ptr [RBP + -0x58]
LEA RCX,[RAX + 0x8]
MOV qword ptr [RBP + -0x58],RCX
LAB_0018037f:
MOV R13,qword ptr [RAX]
MOV R14,RBX
SUB R14,R12
TEST R13,R13
LEA RAX,[0x19af1a]
CMOVZ R13,RAX
MOV RDI,R13
CALL 0x00136410
LEA RDX,[RAX*0x4]
MOV RCX,R14
SHR RCX,0x2
DEC RCX
CMP R14,RDX
CMOVA RCX,RAX
TEST RCX,RCX
JZ 0x001803ea
XOR EAX,EAX
LEA R14,[RBP + -0x40]
LAB_001803c2:
MOV word ptr [R12],0x0
MOV byte ptr [R12 + 0x2],0x0
MOV DL,byte ptr [R13 + RAX*0x1]
MOV byte ptr [R12 + 0x3],DL
ADD R12,0x4
INC RAX
CMP RCX,RAX
JNZ 0x001803c2
JMP 0x00180270
LAB_001803ea:
LEA R14,[RBP + -0x40]
JMP 0x00180270
LAB_001803f3:
MOV R12,RBX
LAB_001803f6:
MOV dword ptr [R12],0x0
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00180426
SUB R12,qword ptr [RBP + -0x68]
MOV RAX,R12
ADD RSP,0xf8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00180426:
CALL 0x001362b0
|
long my_snprintf_utf32(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
int8 param_9,int4 *param_10,long param_11,byte *param_12,
int8 param_13,int8 param_14)
{
char in_AL;
byte bVar1;
uint *puVar2;
size_t sVar3;
size_t sVar4;
int8 uVar5;
int4 *puVar6;
ulong uVar7;
int4 *puVar8;
char *pcVar9;
long in_FS_OFFSET;
int1 local_128 [32];
int8 local_108;
int8 local_100;
int8 local_f8;
int8 local_e8;
int8 local_d8;
int8 local_c8;
int8 local_b8;
int8 local_a8;
int8 local_98;
int8 local_88;
int4 *local_70;
ulong local_68;
uint *local_60;
int1 *local_58;
char local_48 [16];
long local_38;
local_58 = local_128;
if (in_AL != '\0') {
local_f8 = param_1;
local_e8 = param_2;
local_d8 = param_3;
local_c8 = param_4;
local_b8 = param_5;
local_a8 = param_6;
local_98 = param_7;
local_88 = param_8;
}
local_38 = *(long *)(in_FS_OFFSET + 0x28);
local_60 = (uint *)&stack0x00000008;
local_68 = 0x3000000020;
puVar6 = (int4 *)(param_11 + (long)param_10);
local_108 = param_13;
local_100 = param_14;
local_70 = param_10;
do {
puVar8 = param_10;
if (*param_12 == 0x25) {
param_12 = param_12 + 2;
while ((bVar1 = param_12[-1], (byte)(bVar1 - 0x30) < 10 || (bVar1 - 0x2d < 2))) {
param_12 = param_12 + 1;
}
if (bVar1 == 0x6c) {
bVar1 = *param_12;
}
else {
param_12 = param_12 + -1;
}
if ((bVar1 == 100) || (bVar1 == 0x75)) {
if ((ulong)((long)puVar6 - (long)param_10) < 0x40) {
LAB_001803f6:
*puVar8 = 0;
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return (long)puVar8 - (long)local_70;
}
uVar7 = local_68 & 0xffffffff;
if (uVar7 < 0x29) {
local_68 = CONCAT44(local_68._4_4_,(int)local_68 + 8);
puVar2 = (uint *)(local_58 + uVar7);
}
else {
puVar2 = local_60;
local_60 = local_60 + 2;
}
uVar7 = (ulong)(int)*puVar2;
if (*param_12 == 100) {
uVar5 = 0xfffffff6;
}
else {
uVar7 = (ulong)*puVar2;
uVar5 = 10;
}
int10_to_str(uVar7,local_48,uVar5);
if (local_48[0] != '\0') {
pcVar9 = local_48;
do {
pcVar9 = pcVar9 + 1;
*(int2 *)param_10 = 0;
*(int1 *)((long)param_10 + 2) = 0;
*(char *)((long)param_10 + 3) = pcVar9[-1];
param_10 = param_10 + 1;
} while (*pcVar9 != '\0');
}
}
else {
if (bVar1 != 0x73) {
puVar8 = puVar6;
if (param_10 != puVar6) {
*param_10 = 0x25000000;
goto LAB_0018026c;
}
goto LAB_001803f6;
}
uVar7 = local_68 & 0xffffffff;
if (uVar7 < 0x29) {
local_68 = CONCAT44(local_68._4_4_,(int)local_68 + 8);
puVar2 = (uint *)(local_58 + uVar7);
}
else {
puVar2 = local_60;
local_60 = local_60 + 2;
}
pcVar9 = *(char **)puVar2;
if (pcVar9 == (char *)0x0) {
pcVar9 = "(null)";
}
sVar3 = strlen(pcVar9);
sVar4 = ((ulong)((long)puVar6 - (long)param_10) >> 2) - 1;
if (sVar3 * 4 < (ulong)((long)puVar6 - (long)param_10)) {
sVar4 = sVar3;
}
if (sVar4 != 0) {
sVar3 = 0;
do {
*(int2 *)param_10 = 0;
*(int1 *)((long)param_10 + 2) = 0;
*(char *)((long)param_10 + 3) = pcVar9[sVar3];
param_10 = param_10 + 1;
sVar3 = sVar3 + 1;
} while (sVar4 != sVar3);
}
}
}
else {
if ((*param_12 == 0) || (puVar6 <= param_10)) goto LAB_001803f6;
*(int2 *)param_10 = 0;
*(int1 *)((long)param_10 + 2) = 0;
*(byte *)((long)param_10 + 3) = *param_12;
LAB_0018026c:
param_10 = param_10 + 1;
}
param_12 = param_12 + 1;
} while( true );
}
| |
53,982 | ggml_map_custom2_impl | 7CodeWizard[P]stablediffusion/ggml/src/ggml.c | static struct ggml_tensor * ggml_map_custom2_impl(
struct ggml_context * ctx,
struct ggml_tensor * a,
struct ggml_tensor * b,
const ggml_custom2_op_t fun,
int n_tasks,
void * userdata,
bool inplace) {
GGML_ASSERT(n_tasks == GGML_N_TASKS_MAX || n_tasks > 0);
bool is_node = false;
if (!inplace && (a->grad || b->grad)) {
is_node = true;
}
struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);
struct ggml_map_custom2_op_params params = {
/*.fun =*/ fun,
/*.n_tasks =*/ n_tasks,
/*.userdata =*/ userdata
};
ggml_set_op_params(result, (const void *) ¶ms, sizeof(params));
result->op = GGML_OP_MAP_CUSTOM2;
result->grad = is_node ? ggml_dup_tensor(ctx, result) : NULL;
result->src[0] = a;
result->src[1] = b;
return result;
} | O0 | c | ggml_map_custom2_impl:
subq $0x68, %rsp
movb 0x70(%rsp), %al
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movl %r8d, 0x44(%rsp)
movq %r9, 0x38(%rsp)
andb $0x1, %al
movb %al, 0x37(%rsp)
cmpl $-0x1, 0x44(%rsp)
je 0x1288ee
cmpl $0x0, 0x44(%rsp)
jg 0x1288ee
movq 0xaf677(%rip), %rax # 0x1d7f28
movq (%rax), %rdi
callq 0xb8e0
movq 0xaf6e8(%rip), %rax # 0x1d7fa8
movq (%rax), %rdi
leaq 0x57350(%rip), %rsi # 0x17fc1a
leaq 0x60d9d(%rip), %rdx # 0x18966e
movl $0x1850, %ecx # imm = 0x1850
leaq 0x62d1a(%rip), %r8 # 0x18b5f7
movb $0x0, %al
callq 0xbae0
callq 0x11a4f0
callq 0xb3a0
jmp 0x1288f0
movb $0x0, 0x36(%rsp)
testb $0x1, 0x37(%rsp)
jne 0x12891f
movq 0x58(%rsp), %rax
cmpq $0x0, 0x98(%rax)
jne 0x12891a
movq 0x50(%rsp), %rax
cmpq $0x0, 0x98(%rax)
je 0x12891f
movb $0x1, 0x36(%rsp)
testb $0x1, 0x37(%rsp)
je 0x12893c
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x11e7e0
movq %rax, 0x8(%rsp)
jmp 0x128950
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x11cfc0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x44(%rsp), %eax
movl %eax, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0x18, %edx
callq 0x120a30
movq 0x28(%rsp), %rax
movl $0x44, 0x50(%rax)
testb $0x1, 0x36(%rsp)
je 0x1289b2
movq 0x60(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x11cfc0
movq %rax, (%rsp)
jmp 0x1289ba
xorl %eax, %eax
movq %rax, (%rsp)
jmp 0x1289ba
movq (%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x98(%rax)
movq 0x58(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0xa0(%rax)
movq 0x50(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0xa8(%rax)
movq 0x28(%rsp), %rax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
| ggml_map_custom2_impl:
sub rsp, 68h
mov al, [rsp+68h+arg_0]
mov [rsp+68h+var_8], rdi
mov [rsp+68h+var_10], rsi
mov [rsp+68h+var_18], rdx
mov [rsp+68h+var_20], rcx
mov [rsp+68h+var_24], r8d
mov [rsp+68h+var_30], r9
and al, 1
mov [rsp+68h+var_31], al
cmp [rsp+68h+var_24], 0FFFFFFFFh
jz short loc_1288EE
cmp [rsp+68h+var_24], 0
jg short loc_1288EE
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aGgmlAssertSDS; "GGML_ASSERT: %s:%d: %s\n"
lea rdx, aWorkspaceLlm4b_7; "/workspace/llm4binary/github/2025_star3"...
mov ecx, 1850h
lea r8, aNTasksGgmlNTas; "n_tasks == GGML_N_TASKS_MAX || n_tasks "...
mov al, 0
call _fprintf
call ggml_print_backtrace
call _abort
loc_1288EE:
jmp short $+2
loc_1288F0:
mov [rsp+68h+var_32], 0
test [rsp+68h+var_31], 1
jnz short loc_12891F
mov rax, [rsp+68h+var_10]
cmp qword ptr [rax+98h], 0
jnz short loc_12891A
mov rax, [rsp+68h+var_18]
cmp qword ptr [rax+98h], 0
jz short loc_12891F
loc_12891A:
mov [rsp+68h+var_32], 1
loc_12891F:
test [rsp+68h+var_31], 1
jz short loc_12893C
mov rdi, [rsp+68h+var_8]
mov rsi, [rsp+68h+var_10]
call ggml_view_tensor
mov [rsp+68h+var_60], rax
jmp short loc_128950
loc_12893C:
mov rdi, [rsp+68h+var_8]
mov rsi, [rsp+68h+var_10]
call ggml_dup_tensor
mov [rsp+68h+var_60], rax
loc_128950:
mov rax, [rsp+68h+var_60]
mov [rsp+68h+var_40], rax
mov rax, [rsp+68h+var_20]
mov [rsp+68h+var_58], rax
mov eax, [rsp+68h+var_24]
mov [rsp+68h+var_50], eax
mov rax, [rsp+68h+var_30]
mov [rsp+68h+var_48], rax
mov rdi, [rsp+68h+var_40]
lea rsi, [rsp+68h+var_58]
mov edx, 18h
call ggml_set_op_params
mov rax, [rsp+68h+var_40]
mov dword ptr [rax+50h], 44h ; 'D'
test [rsp+68h+var_32], 1
jz short loc_1289B2
mov rdi, [rsp+68h+var_8]
mov rsi, [rsp+68h+var_40]
call ggml_dup_tensor
mov [rsp+68h+var_68], rax
jmp short loc_1289BA
loc_1289B2:
xor eax, eax
mov [rsp+68h+var_68], rax
jmp short $+2
loc_1289BA:
mov rcx, [rsp+68h+var_68]
mov rax, [rsp+68h+var_40]
mov [rax+98h], rcx
mov rcx, [rsp+68h+var_10]
mov rax, [rsp+68h+var_40]
mov [rax+0A0h], rcx
mov rcx, [rsp+68h+var_18]
mov rax, [rsp+68h+var_40]
mov [rax+0A8h], rcx
mov rax, [rsp+68h+var_40]
add rsp, 68h
retn
| unsigned int * ggml_map_custom2_impl(
long long a1,
unsigned int *a2,
long long a3,
long long a4,
int a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
double a11,
double a12,
__m128 a13,
__m128 a14,
char a15)
{
long long v15; // rdi
long long v17; // [rsp+0h] [rbp-68h]
unsigned int *v18; // [rsp+8h] [rbp-60h]
long long v19; // [rsp+10h] [rbp-58h] BYREF
int v20; // [rsp+18h] [rbp-50h]
long long v21; // [rsp+20h] [rbp-48h]
unsigned int *v22; // [rsp+28h] [rbp-40h]
char v23; // [rsp+36h] [rbp-32h]
char v24; // [rsp+37h] [rbp-31h]
long long v25; // [rsp+38h] [rbp-30h]
int v26; // [rsp+44h] [rbp-24h]
long long v27; // [rsp+48h] [rbp-20h]
long long v28; // [rsp+50h] [rbp-18h]
unsigned int *v29; // [rsp+58h] [rbp-10h]
long long v30; // [rsp+60h] [rbp-8h]
v30 = a1;
v29 = a2;
v28 = a3;
v27 = a4;
v26 = a5;
v25 = a6;
v24 = a15 & 1;
if ( a5 != -1 && v26 <= 0 )
{
fflush(stdout);
v15 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
6224,
"n_tasks == GGML_N_TASKS_MAX || n_tasks > 0");
ggml_print_backtrace();
abort(v15);
}
v23 = 0;
if ( (v24 & 1) == 0 && (*((_QWORD *)v29 + 19) || *(_QWORD *)(v28 + 152)) )
v23 = 1;
if ( (v24 & 1) != 0 )
v18 = (unsigned int *)ggml_view_tensor(v30, (long long)v29, a7, a8, a9, a10, a11, a12, a13, a14);
else
v18 = (unsigned int *)ggml_dup_tensor(v30, v29);
v22 = v18;
v19 = v27;
v20 = v26;
v21 = v25;
ggml_set_op_params((long long)v18, (long long)&v19, 24LL);
v22[20] = 68;
if ( (v23 & 1) != 0 )
v17 = ggml_dup_tensor(v30, v22);
else
v17 = 0LL;
*((_QWORD *)v22 + 19) = v17;
*((_QWORD *)v22 + 20) = v29;
*((_QWORD *)v22 + 21) = v28;
return v22;
}
| |||
53,983 | ggml_map_custom2_impl | 7CodeWizard[P]stablediffusion/ggml/src/ggml.c | static struct ggml_tensor * ggml_map_custom2_impl(
struct ggml_context * ctx,
struct ggml_tensor * a,
struct ggml_tensor * b,
const ggml_custom2_op_t fun,
int n_tasks,
void * userdata,
bool inplace) {
GGML_ASSERT(n_tasks == GGML_N_TASKS_MAX || n_tasks > 0);
bool is_node = false;
if (!inplace && (a->grad || b->grad)) {
is_node = true;
}
struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);
struct ggml_map_custom2_op_params params = {
/*.fun =*/ fun,
/*.n_tasks =*/ n_tasks,
/*.userdata =*/ userdata
};
ggml_set_op_params(result, (const void *) ¶ms, sizeof(params));
result->op = GGML_OP_MAP_CUSTOM2;
result->grad = is_node ? ggml_dup_tensor(ctx, result) : NULL;
result->src[0] = a;
result->src[1] = b;
return result;
} | O1 | c | ggml_map_custom2_impl:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
cmpl $-0x1, %r8d
sete %al
testl %r8d, %r8d
setg %sil
orb %al, %sil
je 0x95aef
movl %r8d, %ebp
movb 0x60(%rsp), %al
testb %al, %al
je 0x95a2f
xorl %r12d, %r12d
jmp 0x95a46
cmpq $0x0, 0x98(%r14)
jne 0x95a43
cmpq $0x0, 0x98(%rdx)
je 0x95a2a
movb $0x1, %r12b
movq %rcx, %r15
movq %r9, %r13
movq %rdx, (%rsp)
testb %al, %al
movq %rdi, 0x8(%rsp)
je 0x95a63
movq %r14, %rsi
callq 0x90b1a
jmp 0x95a7a
movl (%r14), %esi
leaq 0x10(%r14), %rcx
movl $0x4, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x8e8b7
movq %rax, %rbx
leaq 0x10(%rsp), %rsi
movq %r15, (%rsi)
movl %ebp, 0x8(%rsi)
movq %r13, 0x10(%rsi)
movl $0x18, %edx
movq %rax, %rdi
callq 0x91e91
movl $0x44, 0x50(%rbx)
testb %r12b, %r12b
je 0x95ac2
movl (%rbx), %esi
leaq 0x10(%rbx), %rcx
movq 0x8(%rsp), %rdi
movl $0x4, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x8e8b7
jmp 0x95ac4
xorl %eax, %eax
movq (%rsp), %r13
movq %rax, 0x98(%rbx)
movq %r14, 0xa0(%rbx)
movq %r13, 0xa8(%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xeee2
| ggml_map_custom2_impl:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r14, rsi
cmp r8d, 0FFFFFFFFh
setz al
test r8d, r8d
setnle sil
or sil, al
jz loc_95AEF
mov ebp, r8d
mov al, [rsp+58h+arg_0]
test al, al
jz short loc_95A2F
loc_95A2A:
xor r12d, r12d
jmp short loc_95A46
loc_95A2F:
cmp qword ptr [r14+98h], 0
jnz short loc_95A43
cmp qword ptr [rdx+98h], 0
jz short loc_95A2A
loc_95A43:
mov r12b, 1
loc_95A46:
mov r15, rcx
mov r13, r9
mov [rsp+58h+var_58], rdx
test al, al
mov [rsp+58h+var_50], rdi
jz short loc_95A63
mov rsi, r14
call ggml_view_tensor
jmp short loc_95A7A
loc_95A63:
mov esi, [r14]
lea rcx, [r14+10h]
mov edx, 4
xor r8d, r8d
xor r9d, r9d
call ggml_new_tensor_impl
loc_95A7A:
mov rbx, rax
lea rsi, [rsp+58h+var_48]
mov [rsi], r15
mov [rsi+8], ebp
mov [rsi+10h], r13
mov edx, 18h
mov rdi, rax
call ggml_set_op_params
mov dword ptr [rbx+50h], 44h ; 'D'
test r12b, r12b
jz short loc_95AC2
mov esi, [rbx]
lea rcx, [rbx+10h]
mov rdi, [rsp+58h+var_50]
mov edx, 4
xor r8d, r8d
xor r9d, r9d
call ggml_new_tensor_impl
jmp short loc_95AC4
loc_95AC2:
xor eax, eax
loc_95AC4:
mov r13, [rsp+58h+var_58]
mov [rbx+98h], rax
mov [rbx+0A0h], r14
mov [rbx+0A8h], r13
mov rax, rbx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_95AEF:
call ggml_map_custom2_impl_cold_1
| long long ggml_map_custom2_impl(
long long a1,
long long a2,
long long a3,
long long a4,
int a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
double a11,
double a12,
__m128 a13,
__m128 a14,
char a15)
{
bool v16; // r12
long long v19; // rax
long long v20; // rbx
long long v21; // rax
long long v24; // [rsp+10h] [rbp-48h] BYREF
int v25; // [rsp+18h] [rbp-40h]
long long v26; // [rsp+20h] [rbp-38h]
if ( a5 != -1 && a5 <= 0 )
ggml_map_custom2_impl_cold_1();
v16 = !a15 && (*(_QWORD *)(a2 + 152) || *(_QWORD *)(a3 + 152));
if ( a15 )
v19 = ggml_view_tensor(a1, a2, a7, a8, a9, a10, a11, a12, a13, a14);
else
v19 = ggml_new_tensor_impl(a1, *(_DWORD *)a2, 4, (_QWORD *)(a2 + 16), 0LL, 0LL, a7, a8);
v20 = v19;
v24 = a4;
v25 = a5;
v26 = a6;
ggml_set_op_params(v19, (long long)&v24, 24LL);
*(_DWORD *)(v20 + 80) = 68;
if ( v16 )
v21 = ggml_new_tensor_impl(a1, *(_DWORD *)v20, 4, (_QWORD *)(v20 + 16), 0LL, 0LL, a7, a8);
else
v21 = 0LL;
*(_QWORD *)(v20 + 152) = v21;
*(_QWORD *)(v20 + 160) = a2;
*(_QWORD *)(v20 + 168) = a3;
return v20;
}
| |||
53,984 | ggml_map_custom2_impl | 7CodeWizard[P]stablediffusion/ggml/src/ggml.c | static struct ggml_tensor * ggml_map_custom2_impl(
struct ggml_context * ctx,
struct ggml_tensor * a,
struct ggml_tensor * b,
const ggml_custom2_op_t fun,
int n_tasks,
void * userdata,
bool inplace) {
GGML_ASSERT(n_tasks == GGML_N_TASKS_MAX || n_tasks > 0);
bool is_node = false;
if (!inplace && (a->grad || b->grad)) {
is_node = true;
}
struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);
struct ggml_map_custom2_op_params params = {
/*.fun =*/ fun,
/*.n_tasks =*/ n_tasks,
/*.userdata =*/ userdata
};
ggml_set_op_params(result, (const void *) ¶ms, sizeof(params));
result->op = GGML_OP_MAP_CUSTOM2;
result->grad = is_node ? ggml_dup_tensor(ctx, result) : NULL;
result->src[0] = a;
result->src[1] = b;
return result;
} | O2 | c | ggml_map_custom2_impl:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
cmpl $-0x1, %r8d
sete %al
testl %r8d, %r8d
setg %sil
orb %al, %sil
je 0x6f468
movl %r8d, %ebp
cmpb $0x0, 0x60(%rsp)
movq %rdx, (%rsp)
movq %rdi, 0x8(%rsp)
je 0x6f3d3
movq %rcx, %r15
movq %r9, %r13
movq %r14, %rsi
callq 0x69922
movq %rax, %rbx
xorl %r12d, %r12d
jmp 0x6f3fb
cmpq $0x0, 0x98(%r14)
jne 0x6f3e7
cmpq $0x0, 0x98(%rdx)
je 0x6f45d
movq %rcx, %r15
movq %r9, %r13
movb $0x1, %r12b
movq %r14, %rsi
callq 0x68a65
movq %rax, %rbx
leaq 0x10(%rsp), %rsi
movq %r15, (%rsi)
movl %ebp, 0x8(%rsi)
movq %r13, 0x10(%rsi)
pushq $0x18
popq %rdx
movq %rbx, %rdi
callq 0x6ab3d
movl $0x44, 0x50(%rbx)
testb %r12b, %r12b
je 0x6f430
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x68a65
jmp 0x6f432
xorl %eax, %eax
movq (%rsp), %rcx
movq %rax, 0x98(%rbx)
movq %r14, 0xa0(%rbx)
movq %rcx, 0xa8(%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rcx, %r15
movq %r9, %r13
xorl %r12d, %r12d
jmp 0x6f3f0
movq 0x66ad9(%rip), %rax # 0xd5f48
movq (%rax), %rdi
callq 0xa6f0
movq 0x66b2a(%rip), %rax # 0xd5fa8
movq (%rax), %rdi
leaq 0x2ad96(%rip), %rsi # 0x9a21e
leaq 0x323ef(%rip), %rdx # 0xa187e
leaq 0x34234(%rip), %r8 # 0xa36ca
movl $0x1850, %ecx # imm = 0x1850
xorl %eax, %eax
callq 0xa8b0
callq 0x67550
callq 0xa300
| ggml_map_custom2_impl:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r14, rsi
cmp r8d, 0FFFFFFFFh
setz al
test r8d, r8d
setnle sil
or sil, al
jz loc_6F468
mov ebp, r8d
cmp [rsp+58h+arg_0], 0
mov [rsp+58h+var_58], rdx
mov [rsp+58h+var_50], rdi
jz short loc_6F3D3
mov r15, rcx
mov r13, r9
mov rsi, r14
call ggml_view_tensor
mov rbx, rax
xor r12d, r12d
jmp short loc_6F3FB
loc_6F3D3:
cmp qword ptr [r14+98h], 0
jnz short loc_6F3E7
cmp qword ptr [rdx+98h], 0
jz short loc_6F45D
loc_6F3E7:
mov r15, rcx
mov r13, r9
mov r12b, 1
loc_6F3F0:
mov rsi, r14
call ggml_dup_tensor
mov rbx, rax
loc_6F3FB:
lea rsi, [rsp+58h+var_48]
mov [rsi], r15
mov [rsi+8], ebp
mov [rsi+10h], r13
push 18h
pop rdx
mov rdi, rbx
call ggml_set_op_params
mov dword ptr [rbx+50h], 44h ; 'D'
test r12b, r12b
jz short loc_6F430
mov rdi, [rsp+58h+var_50]
mov rsi, rbx
call ggml_dup_tensor
jmp short loc_6F432
loc_6F430:
xor eax, eax
loc_6F432:
mov rcx, [rsp+58h+var_58]
mov [rbx+98h], rax
mov [rbx+0A0h], r14
mov [rbx+0A8h], rcx
mov rax, rbx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_6F45D:
mov r15, rcx
mov r13, r9
xor r12d, r12d
jmp short loc_6F3F0
loc_6F468:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aGgmlAssertSDS; "GGML_ASSERT: %s:%d: %s\n"
lea rdx, aWorkspaceLlm4b_7; "/workspace/llm4binary/github/2025_star3"...
lea r8, aNTasksGgmlNTas; "n_tasks == GGML_N_TASKS_MAX || n_tasks "...
mov ecx, 1850h
xor eax, eax
call _fprintf
call ggml_print_backtrace
call _abort
| long long ggml_map_custom2_impl(
long long a1,
long long a2,
long long a3,
long long a4,
int a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
double a11,
double a12,
__m128 a13,
__m128 a14,
char a15)
{
long long v16; // r15
long long v17; // r13
long long v18; // rbx
char v19; // r12
long long v20; // rax
long long v22; // rdi
long long v24; // [rsp+10h] [rbp-48h] BYREF
int v25; // [rsp+18h] [rbp-40h]
long long v26; // [rsp+20h] [rbp-38h]
if ( a5 != -1 && a5 <= 0 )
{
fflush(stdout);
v22 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
6224,
"n_tasks == GGML_N_TASKS_MAX || n_tasks > 0");
ggml_print_backtrace();
abort(v22);
}
if ( a15 )
{
v16 = a4;
v17 = a6;
v18 = ggml_view_tensor(a1, a2, a7, a8, a9, a10, a11, a12, a13, a14);
v19 = 0;
}
else
{
if ( *(_QWORD *)(a2 + 152) || *(_QWORD *)(a3 + 152) )
{
v16 = a4;
v17 = a6;
v19 = 1;
}
else
{
v16 = a4;
v17 = a6;
v19 = 0;
}
v18 = ggml_dup_tensor(a1, (unsigned int *)a2);
}
v24 = v16;
v25 = a5;
v26 = v17;
ggml_set_op_params(v18, (long long)&v24, 24LL);
*(_DWORD *)(v18 + 80) = 68;
if ( v19 )
v20 = ggml_dup_tensor(a1, (unsigned int *)v18);
else
v20 = 0LL;
*(_QWORD *)(v18 + 152) = v20;
*(_QWORD *)(v18 + 160) = a2;
*(_QWORD *)(v18 + 168) = a3;
return v18;
}
| ggml_map_custom2_impl:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R14,RSI
CMP R8D,-0x1
SETZ AL
TEST R8D,R8D
SETG SIL
OR SIL,AL
JZ 0x0016f468
MOV EBP,R8D
CMP byte ptr [RSP + 0x60],0x0
MOV qword ptr [RSP],RDX
MOV qword ptr [RSP + 0x8],RDI
JZ 0x0016f3d3
MOV R15,RCX
MOV R13,R9
MOV RSI,R14
CALL 0x00169922
MOV RBX,RAX
XOR R12D,R12D
JMP 0x0016f3fb
LAB_0016f3d3:
CMP qword ptr [R14 + 0x98],0x0
JNZ 0x0016f3e7
CMP qword ptr [RDX + 0x98],0x0
JZ 0x0016f45d
LAB_0016f3e7:
MOV R15,RCX
MOV R13,R9
MOV R12B,0x1
LAB_0016f3f0:
MOV RSI,R14
CALL 0x00168a65
MOV RBX,RAX
LAB_0016f3fb:
LEA RSI,[RSP + 0x10]
MOV qword ptr [RSI],R15
MOV dword ptr [RSI + 0x8],EBP
MOV qword ptr [RSI + 0x10],R13
PUSH 0x18
POP RDX
MOV RDI,RBX
CALL 0x0016ab3d
MOV dword ptr [RBX + 0x50],0x44
TEST R12B,R12B
JZ 0x0016f430
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,RBX
CALL 0x00168a65
JMP 0x0016f432
LAB_0016f430:
XOR EAX,EAX
LAB_0016f432:
MOV RCX,qword ptr [RSP]
MOV qword ptr [RBX + 0x98],RAX
MOV qword ptr [RBX + 0xa0],R14
MOV qword ptr [RBX + 0xa8],RCX
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0016f45d:
MOV R15,RCX
MOV R13,R9
XOR R12D,R12D
JMP 0x0016f3f0
LAB_0016f468:
MOV RAX,qword ptr [0x001d5f48]
MOV RDI,qword ptr [RAX]
CALL 0x0010a6f0
MOV RAX,qword ptr [0x001d5fa8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x19a21e]
LEA RDX,[0x1a187e]
LEA R8,[0x1a36ca]
MOV ECX,0x1850
XOR EAX,EAX
CALL 0x0010a8b0
CALL 0x00167550
CALL 0x0010a300
|
long ggml_map_custom2_impl
(int8 param_1,long param_2,long param_3,int8 param_4,int param_5,
int8 param_6,char param_7)
{
bool bVar1;
long lVar2;
int8 uVar3;
int8 local_48;
int local_40;
int8 local_38;
if (0 < param_5 || param_5 == -1) {
if (param_7 == '\0') {
if ((*(long *)(param_2 + 0x98) == 0) && (*(long *)(param_3 + 0x98) == 0)) {
bVar1 = false;
}
else {
bVar1 = true;
}
lVar2 = ggml_dup_tensor(param_1,param_2);
}
else {
lVar2 = ggml_view_tensor(param_1,param_2);
bVar1 = false;
}
local_48 = param_4;
local_40 = param_5;
local_38 = param_6;
ggml_set_op_params(lVar2,&local_48,0x18);
*(int4 *)(lVar2 + 0x50) = 0x44;
if (bVar1) {
uVar3 = ggml_dup_tensor(param_1,lVar2);
}
else {
uVar3 = 0;
}
*(int8 *)(lVar2 + 0x98) = uVar3;
*(long *)(lVar2 + 0xa0) = param_2;
*(long *)(lVar2 + 0xa8) = param_3;
return lVar2;
}
fflush(*(FILE **)PTR_stdout_001d5f48);
fprintf(*(FILE **)PTR_stderr_001d5fa8,"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
0x1850,"n_tasks == GGML_N_TASKS_MAX || n_tasks > 0");
ggml_print_backtrace();
/* WARNING: Subroutine does not return */
abort();
}
| |
53,985 | minja::Value::operator/(minja::Value const&) const | monkey531[P]llama/common/minja.hpp | Value operator/(const Value& rhs) const {
if (is_number_integer() && rhs.is_number_integer())
return get<int64_t>() / rhs.get<int64_t>();
else
return get<double>() / rhs.get<double>();
} | O2 | cpp | minja::Value::operator/(minja::Value const&) const:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movb 0x40(%rsi), %al
addb $-0x5, %al
cmpb $0x1, %al
ja 0x70ac4
movb 0x40(%r14), %al
addb $-0x5, %al
cmpb $0x1, %al
ja 0x70ac4
movq %rsi, %rdi
callq 0x63168
movq %rax, %r15
movq %r14, %rdi
callq 0x63168
movq %rax, %rcx
movq %r15, %rax
cqto
idivq %rcx
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x6321e
jmp 0x70af3
movq %rsi, %rdi
callq 0x6323c
movsd %xmm0, (%rsp)
movq %r14, %rdi
callq 0x6323c
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
leaq 0x8(%rsp), %rsi
movsd %xmm1, (%rsi)
movq %rbx, %rdi
callq 0x632f2
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
| _ZNK5minja5ValuedvERKS0_:
push r15
push r14
push rbx
sub rsp, 10h
mov r14, rdx
mov rbx, rdi
mov al, [rsi+40h]
add al, 0FBh
cmp al, 1
ja short loc_70AC4
mov al, [r14+40h]
add al, 0FBh
cmp al, 1
ja short loc_70AC4
mov rdi, rsi
call _ZNK5minja5Value3getIlEET_v; minja::Value::get<long>(void)
mov r15, rax
mov rdi, r14
call _ZNK5minja5Value3getIlEET_v; minja::Value::get<long>(void)
mov rcx, rax
mov rax, r15
cqo
idiv rcx
lea rsi, [rsp+28h+var_20]; __int64 *
mov [rsi], rax
mov rdi, rbx; this
call _ZN5minja5ValueC2ERKl; minja::Value::Value(long const&)
jmp short loc_70AF3
loc_70AC4:
mov rdi, rsi
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
movsd [rsp+28h+var_28], xmm0
mov rdi, r14
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
movsd xmm1, [rsp+28h+var_28]
divsd xmm1, xmm0
lea rsi, [rsp+28h+var_20]; double *
movsd qword ptr [rsi], xmm1
mov rdi, rbx; this
call _ZN5minja5ValueC2ERKd; minja::Value::Value(double const&)
loc_70AF3:
mov rax, rbx
add rsp, 10h
pop rbx
pop r14
pop r15
retn
| minja::Value * minja::Value::operator/(minja::Value *this, minja::Value *a2, minja::Value *a3, double a4)
{
long long v5; // r15
long long v7[4]; // [rsp+8h] [rbp-20h] BYREF
if ( (unsigned __int8)(*((_BYTE *)a2 + 64) - 5) > 1u || (unsigned __int8)(*((_BYTE *)a3 + 64) - 5) > 1u )
{
minja::Value::get<double>(a2);
minja::Value::get<double>(a3);
*(double *)v7 = a4 / a4;
minja::Value::Value(this, (const double *)v7);
}
else
{
v5 = minja::Value::get<long>(a2);
v7[0] = v5 / minja::Value::get<long>(a3);
minja::Value::Value(this, v7);
}
return this;
}
| operator/:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV R14,RDX
MOV RBX,RDI
MOV AL,byte ptr [RSI + 0x40]
ADD AL,0xfb
CMP AL,0x1
JA 0x00170ac4
MOV AL,byte ptr [R14 + 0x40]
ADD AL,0xfb
CMP AL,0x1
JA 0x00170ac4
MOV RDI,RSI
CALL 0x00163168
MOV R15,RAX
MOV RDI,R14
CALL 0x00163168
MOV RCX,RAX
MOV RAX,R15
CQO
IDIV RCX
LEA RSI,[RSP + 0x8]
MOV qword ptr [RSI],RAX
MOV RDI,RBX
CALL 0x0016321e
JMP 0x00170af3
LAB_00170ac4:
MOV RDI,RSI
CALL 0x0016323c
MOVSD qword ptr [RSP],XMM0
MOV RDI,R14
CALL 0x0016323c
MOVSD XMM1,qword ptr [RSP]
DIVSD XMM1,XMM0
LEA RSI,[RSP + 0x8]
MOVSD qword ptr [RSI],XMM1
MOV RDI,RBX
CALL 0x001632f2
LAB_00170af3:
MOV RAX,RBX
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
|
/* minja::Value::TEMPNAMEPLACEHOLDERVALUE(minja::Value const&) const */
Value * __thiscall minja::Value::operator/(Value *this,Value *param_1)
{
long lVar1;
long lVar2;
Value *in_RDX;
double dVar3;
double local_20;
if (((byte)((char)param_1[0x40] - 5U) < 2) && ((byte)((char)in_RDX[0x40] - 5U) < 2)) {
lVar1 = get<long>(param_1);
lVar2 = get<long>(in_RDX);
local_20 = (double)(lVar1 / lVar2);
Value(this,(long *)&local_20);
}
else {
dVar3 = get<double>(param_1);
local_20 = get<double>(in_RDX);
local_20 = dVar3 / local_20;
Value(this,&local_20);
}
return this;
}
| |
53,986 | minja::Value::at(unsigned long) | monkey531[P]llama/common/minja.hpp | Value& at(size_t index) {
if (is_null())
throw std::runtime_error("Undefined value or reference");
if (is_array()) return array_->at(index);
if (is_object()) return object_->at(index);
throw std::runtime_error("Value is not an array or object: " + dump());
} | O2 | cpp | minja::Value::at(unsigned long):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, 0x8(%rsp)
callq 0x6390a
testb %al, %al
jne 0x6b217
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x6b1fb
movq %rbx, %rsi
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x6b41c
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0x6b247
leaq 0x8(%rsp), %rsi
callq 0x6b43a
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x24460
movq %rax, %rbx
leaq 0x4a8d1(%rip), %rsi # 0xb5afa
movq %rax, %rdi
callq 0x24320
movq 0x94db8(%rip), %rsi # 0xffff0
movq 0x94d11(%rip), %rdx # 0xfff50
movq %rbx, %rdi
callq 0x24ee0
pushq $0x10
popq %rdi
callq 0x24460
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
pushq $-0x1
popq %rdx
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x63320
leaq 0x4afdf(%rip), %rsi # 0xb624a
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x58a46
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x24e10
xorl %ebp, %ebp
movq 0x94d5d(%rip), %rsi # 0xffff0
movq 0x94cb6(%rip), %rdx # 0xfff50
movq %rbx, %rdi
callq 0x24ee0
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x251b8
jmp 0x6b2b7
movq %rax, %r14
movb $0x1, %bpl
leaq 0x10(%rsp), %rdi
callq 0x251b8
testb %bpl, %bpl
jne 0x6b2cd
jmp 0x6b2d5
jmp 0x6b2ca
movq %rax, %r14
movq %rbx, %rdi
callq 0x24670
movq %r14, %rdi
callq 0x24f60
nop
| _ZN5minja5Value2atEm:
push rbp
push r14
push rbx
sub rsp, 50h
mov rbx, rsi
mov r14, rdi
mov [rsp+68h+var_60], rsi
call _ZNK5minja5Value7is_nullEv; minja::Value::is_null(void)
test al, al
jnz short loc_6B217
mov rdi, [r14+10h]
test rdi, rdi
jz short loc_6B1FB
mov rsi, rbx
add rsp, 50h
pop rbx
pop r14
pop rbp
jmp _ZNSt6vectorIN5minja5ValueESaIS1_EE2atEm; std::vector<minja::Value>::at(ulong)
loc_6B1FB:
mov rdi, [r14+20h]
test rdi, rdi
jz short loc_6B247
lea rsi, [rsp+68h+var_60]
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE2atIRmTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEERSF_OSS_
add rsp, 50h
pop rbx
pop r14
pop rbp
retn
loc_6B217:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aUndefinedValue; "Undefined value or reference"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_6B247:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+68h+var_58]
push 0FFFFFFFFFFFFFFFFh
pop rdx
mov rsi, r14
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aValueIsNotAnAr_0; "Value is not an array or object: "
lea rdi, [rsp+68h+var_38]
lea rdx, [rsp+68h+var_58]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+68h+var_38]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rdi, [rsp+68h+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_6B2B7
mov r14, rax
mov bpl, 1
loc_6B2B7:
lea rdi, [rsp+68h+var_58]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_6B2CD
jmp short loc_6B2D5
jmp short $+2
loc_6B2CA:
mov r14, rax
loc_6B2CD:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_6B2D5:
mov rdi, r14
call __Unwind_Resume
| long long minja::Value::at(minja::Value *this, long long a2)
{
long long v3; // rdi
long long v5; // rdi
std::runtime_error *exception; // rbx
void *v7; // rbx
long long v8; // [rsp+8h] [rbp-60h] BYREF
_BYTE v9[32]; // [rsp+10h] [rbp-58h] BYREF
_BYTE v10[56]; // [rsp+30h] [rbp-38h] BYREF
v8 = a2;
if ( minja::Value::is_null(this) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Undefined value or reference");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v3 = *((_QWORD *)this + 2);
if ( v3 )
return std::vector<minja::Value>::at(v3, a2);
v5 = *((_QWORD *)this + 4);
if ( !v5 )
{
v7 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v9, (long long)this, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v10, (long long)"Value is not an array or object: ", (long long)v9);
std::runtime_error::runtime_error(v7, v10);
__cxa_throw(
v7,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
return ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE2atIRmTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEERSF_OSS_(
v5,
&v8);
}
| at:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x50
MOV RBX,RSI
MOV R14,RDI
MOV qword ptr [RSP + 0x8],RSI
CALL 0x0016390a
TEST AL,AL
JNZ 0x0016b217
MOV RDI,qword ptr [R14 + 0x10]
TEST RDI,RDI
JZ 0x0016b1fb
MOV RSI,RBX
ADD RSP,0x50
POP RBX
POP R14
POP RBP
JMP 0x0016b41c
LAB_0016b1fb:
MOV RDI,qword ptr [R14 + 0x20]
TEST RDI,RDI
JZ 0x0016b247
LEA RSI,[RSP + 0x8]
CALL 0x0016b43a
ADD RSP,0x50
POP RBX
POP R14
POP RBP
RET
LAB_0016b217:
PUSH 0x10
POP RDI
CALL 0x00124460
MOV RBX,RAX
LAB_0016b222:
LEA RSI,[0x1b5afa]
MOV RDI,RAX
CALL 0x00124320
LAB_0016b231:
MOV RSI,qword ptr [0x001ffff0]
MOV RDX,qword ptr [0x001fff50]
MOV RDI,RBX
CALL 0x00124ee0
LAB_0016b247:
PUSH 0x10
POP RDI
CALL 0x00124460
MOV RBX,RAX
LAB_0016b252:
LEA RDI,[RSP + 0x10]
PUSH -0x1
POP RDX
MOV RSI,R14
XOR ECX,ECX
CALL 0x00163320
LAB_0016b264:
LEA RSI,[0x1b624a]
LEA RDI,[RSP + 0x30]
LEA RDX,[RSP + 0x10]
CALL 0x00158a46
MOV BPL,0x1
LAB_0016b27d:
LEA RSI,[RSP + 0x30]
MOV RDI,RBX
CALL 0x00124e10
XOR EBP,EBP
MOV RSI,qword ptr [0x001ffff0]
MOV RDX,qword ptr [0x001fff50]
MOV RDI,RBX
CALL 0x00124ee0
|
/* minja::Value::at(unsigned long) */
void __thiscall minja::Value::at(Value *this,ulong param_1)
{
char cVar1;
runtime_error *prVar2;
ulong local_60;
int1 local_58 [32];
string local_38 [32];
local_60 = param_1;
cVar1 = is_null(this);
if (cVar1 != '\0') {
prVar2 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0016b222 to 0016b230 has its CatchHandler @ 0016b2ca */
std::runtime_error::runtime_error(prVar2,"Undefined value or reference");
/* WARNING: Subroutine does not return */
__cxa_throw(prVar2,PTR_typeinfo_001ffff0,PTR__runtime_error_001fff50);
}
if (*(vector<minja::Value,std::allocator<minja::Value>> **)(this + 0x10) !=
(vector<minja::Value,std::allocator<minja::Value>> *)0x0) {
std::vector<minja::Value,std::allocator<minja::Value>>::at
(*(vector<minja::Value,std::allocator<minja::Value>> **)(this + 0x10),param_1);
return;
}
if (*(long *)(this + 0x20) != 0) {
_ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE2atIRmTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEERSF_OSS_
(*(long *)(this + 0x20),&local_60);
return;
}
prVar2 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0016b252 to 0016b263 has its CatchHandler @ 0016b2c8 */
dump_abi_cxx11_((int)local_58,SUB81(this,0));
/* try { // try from 0016b264 to 0016b279 has its CatchHandler @ 0016b2b1 */
std::operator+((char *)local_38,(string *)"Value is not an array or object: ");
/* try { // try from 0016b27d to 0016b2a1 has its CatchHandler @ 0016b2a2 */
std::runtime_error::runtime_error(prVar2,local_38);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar2,PTR_typeinfo_001ffff0,PTR__runtime_error_001fff50);
}
| |
53,987 | minja::Value::operator/(minja::Value const&) const | monkey531[P]llama/common/minja.hpp | Value operator/(const Value& rhs) const {
if (is_number_integer() && rhs.is_number_integer())
return get<int64_t>() / rhs.get<int64_t>();
else
return get<double>() / rhs.get<double>();
} | O2 | cpp | minja::Value::operator/(minja::Value const&) const:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movb 0x40(%rsi), %al
addb $-0x5, %al
cmpb $0x1, %al
ja 0x73322
movb 0x40(%r14), %al
addb $-0x5, %al
cmpb $0x1, %al
ja 0x73322
movq %rsi, %rdi
callq 0x659c6
movq %rax, %r15
movq %r14, %rdi
callq 0x659c6
movq %rax, %rcx
movq %r15, %rax
cqto
idivq %rcx
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x65a7c
jmp 0x73351
movq %rsi, %rdi
callq 0x65a9a
movsd %xmm0, (%rsp)
movq %r14, %rdi
callq 0x65a9a
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
leaq 0x8(%rsp), %rsi
movsd %xmm1, (%rsi)
movq %rbx, %rdi
callq 0x65b50
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
| _ZNK5minja5ValuedvERKS0_:
push r15
push r14
push rbx
sub rsp, 10h
mov r14, rdx
mov rbx, rdi
mov al, [rsi+40h]
add al, 0FBh
cmp al, 1
ja short loc_73322
mov al, [r14+40h]
add al, 0FBh
cmp al, 1
ja short loc_73322
mov rdi, rsi
call _ZNK5minja5Value3getIlEET_v; minja::Value::get<long>(void)
mov r15, rax
mov rdi, r14
call _ZNK5minja5Value3getIlEET_v; minja::Value::get<long>(void)
mov rcx, rax
mov rax, r15
cqo
idiv rcx
lea rsi, [rsp+28h+var_20]; __int64 *
mov [rsi], rax
mov rdi, rbx; this
call _ZN5minja5ValueC2ERKl; minja::Value::Value(long const&)
jmp short loc_73351
loc_73322:
mov rdi, rsi
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
movsd [rsp+28h+var_28], xmm0
mov rdi, r14
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
movsd xmm1, [rsp+28h+var_28]
divsd xmm1, xmm0
lea rsi, [rsp+28h+var_20]; double *
movsd qword ptr [rsi], xmm1
mov rdi, rbx; this
call _ZN5minja5ValueC2ERKd; minja::Value::Value(double const&)
loc_73351:
mov rax, rbx
add rsp, 10h
pop rbx
pop r14
pop r15
retn
| minja::Value * minja::Value::operator/(minja::Value *this, minja::Value *a2, minja::Value *a3, double a4)
{
long long v5; // r15
long long v7[4]; // [rsp+8h] [rbp-20h] BYREF
if ( (unsigned __int8)(*((_BYTE *)a2 + 64) - 5) > 1u || (unsigned __int8)(*((_BYTE *)a3 + 64) - 5) > 1u )
{
minja::Value::get<double>(a2);
minja::Value::get<double>(a3);
*(double *)v7 = a4 / a4;
minja::Value::Value(this, (const double *)v7);
}
else
{
v5 = minja::Value::get<long>(a2);
v7[0] = v5 / minja::Value::get<long>(a3);
minja::Value::Value(this, v7);
}
return this;
}
| operator/:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV R14,RDX
MOV RBX,RDI
MOV AL,byte ptr [RSI + 0x40]
ADD AL,0xfb
CMP AL,0x1
JA 0x00173322
MOV AL,byte ptr [R14 + 0x40]
ADD AL,0xfb
CMP AL,0x1
JA 0x00173322
MOV RDI,RSI
CALL 0x001659c6
MOV R15,RAX
MOV RDI,R14
CALL 0x001659c6
MOV RCX,RAX
MOV RAX,R15
CQO
IDIV RCX
LEA RSI,[RSP + 0x8]
MOV qword ptr [RSI],RAX
MOV RDI,RBX
CALL 0x00165a7c
JMP 0x00173351
LAB_00173322:
MOV RDI,RSI
CALL 0x00165a9a
MOVSD qword ptr [RSP],XMM0
MOV RDI,R14
CALL 0x00165a9a
MOVSD XMM1,qword ptr [RSP]
DIVSD XMM1,XMM0
LEA RSI,[RSP + 0x8]
MOVSD qword ptr [RSI],XMM1
MOV RDI,RBX
CALL 0x00165b50
LAB_00173351:
MOV RAX,RBX
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
|
/* minja::Value::TEMPNAMEPLACEHOLDERVALUE(minja::Value const&) const */
Value * __thiscall minja::Value::operator/(Value *this,Value *param_1)
{
long lVar1;
long lVar2;
Value *in_RDX;
double dVar3;
double local_20;
if (((byte)((char)param_1[0x40] - 5U) < 2) && ((byte)((char)in_RDX[0x40] - 5U) < 2)) {
lVar1 = get<long>(param_1);
lVar2 = get<long>(in_RDX);
local_20 = (double)(lVar1 / lVar2);
Value(this,(long *)&local_20);
}
else {
dVar3 = get<double>(param_1);
local_20 = get<double>(in_RDX);
local_20 = dVar3 / local_20;
Value(this,&local_20);
}
return this;
}
| |
53,988 | pow5mult | eloqsql/libmariadb/libmariadb/ma_dtoa.c | static Bigint *pow5mult(Bigint *b, int k, Stack_alloc *alloc)
{
Bigint *b1, *p5, *p51=NULL;
int i;
static int p05[3]= { 5, 25, 125 };
my_bool overflow= FALSE;
if ((i= k & 3))
b= multadd(b, p05[i-1], 0, alloc);
if (!(k>>= 2))
return b;
p5= p5_a;
for (;;)
{
if (k & 1)
{
b1= mult(b, p5, alloc);
Bfree(b, alloc);
b= b1;
}
if (!(k>>= 1))
break;
/* Calculate next power of 5 */
if (overflow)
{
p51= mult(p5, p5, alloc);
Bfree(p5, alloc);
p5= p51;
}
else if (p5 < p5_a + P5A_MAX)
++p5;
else if (p5 == p5_a + P5A_MAX)
{
p5= mult(p5, p5, alloc);
overflow= TRUE;
}
}
if (p51)
Bfree(p51, alloc);
return b;
} | O0 | c | pow5mult:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x38(%rbp)
movb $0x0, -0x3d(%rbp)
movl -0x14(%rbp), %eax
andl $0x3, %eax
movl %eax, -0x3c(%rbp)
cmpl $0x0, %eax
je 0x66323
movq -0x10(%rbp), %rdi
movl -0x3c(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x1e244f(%rip), %rax # 0x248760
movl (%rax,%rcx,4), %esi
movq -0x20(%rbp), %rcx
xorl %edx, %edx
callq 0x66a60
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
sarl $0x2, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jne 0x6633e
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x66434
leaq 0x1e242b(%rip), %rax # 0x248770
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x6637e
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x66440
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x66690
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
sarl %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jne 0x66390
jmp 0x66418
cmpb $0x0, -0x3d(%rbp)
je 0x663c2
movq -0x30(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x66440
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x66690
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x66413
leaq 0x1e23a7(%rip), %rax # 0x248770
addq $0x90, %rax
cmpq %rax, -0x30(%rbp)
jae 0x663e3
movq -0x30(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x30(%rbp)
jmp 0x66411
leaq 0x1e2386(%rip), %rax # 0x248770
addq $0x90, %rax
cmpq %rax, -0x30(%rbp)
jne 0x6640f
movq -0x30(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x66440
movq %rax, -0x30(%rbp)
movb $0x1, -0x3d(%rbp)
jmp 0x66411
jmp 0x66413
jmp 0x66349
cmpq $0x0, -0x38(%rbp)
je 0x6642c
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x66690
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
| pow5mult:
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_38], 0
mov [rbp+var_3D], 0
mov eax, [rbp+var_14]
and eax, 3
mov [rbp+var_3C], eax
cmp eax, 0
jz short loc_66323
mov rdi, [rbp+var_10]
mov eax, [rbp+var_3C]
sub eax, 1
movsxd rcx, eax
lea rax, pow5mult_p05
mov esi, [rax+rcx*4]
mov rcx, [rbp+var_20]
xor edx, edx
call multadd
mov [rbp+var_10], rax
loc_66323:
mov eax, [rbp+var_14]
sar eax, 2
mov [rbp+var_14], eax
cmp eax, 0
jnz short loc_6633E
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
jmp loc_66434
loc_6633E:
lea rax, p5_a
mov [rbp+var_30], rax
loc_66349:
mov eax, [rbp+var_14]
and eax, 1
cmp eax, 0
jz short loc_6637E
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_20]
call mult
mov [rbp+var_28], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
call Bfree
mov rax, [rbp+var_28]
mov [rbp+var_10], rax
loc_6637E:
mov eax, [rbp+var_14]
sar eax, 1
mov [rbp+var_14], eax
cmp eax, 0
jnz short loc_66390
jmp loc_66418
loc_66390:
cmp [rbp+var_3D], 0
jz short loc_663C2
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_20]
call mult
mov [rbp+var_38], rax
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_20]
call Bfree
mov rax, [rbp+var_38]
mov [rbp+var_30], rax
jmp short loc_66413
loc_663C2:
lea rax, p5_a
add rax, 90h
cmp [rbp+var_30], rax
jnb short loc_663E3
mov rax, [rbp+var_30]
add rax, 18h
mov [rbp+var_30], rax
jmp short loc_66411
loc_663E3:
lea rax, p5_a
add rax, 90h
cmp [rbp+var_30], rax
jnz short loc_6640F
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_20]
call mult
mov [rbp+var_30], rax
mov [rbp+var_3D], 1
loc_6640F:
jmp short $+2
loc_66411:
jmp short $+2
loc_66413:
jmp loc_66349
loc_66418:
cmp [rbp+var_38], 0
jz short loc_6642C
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_20]
call Bfree
loc_6642C:
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
loc_66434:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
| long long pow5mult(long long a1, int a2, long long a3)
{
char v4; // [rsp+3h] [rbp-3Dh]
_BYTE v5[12]; // [rsp+4h] [rbp-3Ch]
_UNKNOWN **v6; // [rsp+10h] [rbp-30h]
long long v7; // [rsp+18h] [rbp-28h]
int v9; // [rsp+2Ch] [rbp-14h]
long long v10; // [rsp+30h] [rbp-10h]
v10 = a1;
*(_DWORD *)&v5[8] = 0;
v4 = 0;
*(_QWORD *)v5 = a2 & 3;
if ( (a2 & 3) != 0 )
v10 = multadd(a1, pow5mult_p05[*(_DWORD *)v5 - 1], 0LL, a3);
v9 = a2 >> 2;
if ( !(a2 >> 2) )
return v10;
v6 = &p5_a;
while ( 1 )
{
if ( (v9 & 1) != 0 )
{
v7 = mult(v10, v6, a3);
Bfree(v10, a3);
v10 = v7;
}
v9 >>= 1;
if ( !v9 )
break;
if ( v4 )
{
*(_QWORD *)&v5[4] = mult(v6, v6, a3);
Bfree(v6, a3);
v6 = *(_UNKNOWN ***)&v5[4];
}
else if ( v6 >= &p5_a + 18 )
{
if ( v6 == &p5_a + 18 )
{
v6 = (_UNKNOWN **)mult(v6, v6, a3);
v4 = 1;
}
}
else
{
v6 += 3;
}
}
if ( *(_QWORD *)&v5[4] )
Bfree(*(_QWORD *)&v5[4], a3);
return v10;
}
| pow5mult:
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 + -0x38],0x0
MOV byte ptr [RBP + -0x3d],0x0
MOV EAX,dword ptr [RBP + -0x14]
AND EAX,0x3
MOV dword ptr [RBP + -0x3c],EAX
CMP EAX,0x0
JZ 0x00166323
MOV RDI,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x3c]
SUB EAX,0x1
MOVSXD RCX,EAX
LEA RAX,[0x348760]
MOV ESI,dword ptr [RAX + RCX*0x4]
MOV RCX,qword ptr [RBP + -0x20]
XOR EDX,EDX
CALL 0x00166a60
MOV qword ptr [RBP + -0x10],RAX
LAB_00166323:
MOV EAX,dword ptr [RBP + -0x14]
SAR EAX,0x2
MOV dword ptr [RBP + -0x14],EAX
CMP EAX,0x0
JNZ 0x0016633e
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00166434
LAB_0016633e:
LEA RAX,[0x348770]
MOV qword ptr [RBP + -0x30],RAX
LAB_00166349:
MOV EAX,dword ptr [RBP + -0x14]
AND EAX,0x1
CMP EAX,0x0
JZ 0x0016637e
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x00166440
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x00166690
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x10],RAX
LAB_0016637e:
MOV EAX,dword ptr [RBP + -0x14]
SAR EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
CMP EAX,0x0
JNZ 0x00166390
JMP 0x00166418
LAB_00166390:
CMP byte ptr [RBP + -0x3d],0x0
JZ 0x001663c2
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x00166440
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x00166690
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x30],RAX
JMP 0x00166413
LAB_001663c2:
LEA RAX,[0x348770]
ADD RAX,0x90
CMP qword ptr [RBP + -0x30],RAX
JNC 0x001663e3
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x18
MOV qword ptr [RBP + -0x30],RAX
JMP 0x00166411
LAB_001663e3:
LEA RAX,[0x348770]
ADD RAX,0x90
CMP qword ptr [RBP + -0x30],RAX
JNZ 0x0016640f
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x00166440
MOV qword ptr [RBP + -0x30],RAX
MOV byte ptr [RBP + -0x3d],0x1
LAB_0016640f:
JMP 0x00166411
LAB_00166411:
JMP 0x00166413
LAB_00166413:
JMP 0x00166349
LAB_00166418:
CMP qword ptr [RBP + -0x38],0x0
JZ 0x0016642c
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x00166690
LAB_0016642c:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
LAB_00166434:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
int8 pow5mult(int8 param_1,uint param_2,int8 param_3)
{
bool bVar1;
int8 uVar2;
int1 *local_40;
int1 *local_38;
uint local_1c;
int8 local_18;
int8 local_10;
local_40 = (int1 *)0x0;
bVar1 = false;
local_18 = param_1;
if ((param_2 & 3) != 0) {
local_18 = multadd(param_1,*(int4 *)(pow5mult_p05 + (long)(int)((param_2 & 3) - 1) * 4),0,
param_3);
}
local_1c = (int)param_2 >> 2;
if (local_1c == 0) {
local_10 = local_18;
}
else {
local_38 = p5_a;
while( true ) {
if ((local_1c & 1) != 0) {
uVar2 = mult(local_18,local_38,param_3);
Bfree(local_18,param_3);
local_18 = uVar2;
}
local_1c = (int)local_1c >> 1;
if (local_1c == 0) break;
if (bVar1) {
local_40 = (int1 *)mult(local_38,local_38,param_3);
Bfree(local_38,param_3);
local_38 = local_40;
}
else if (local_38 < (int1 *)0x348800) {
local_38 = local_38 + 0x18;
}
else if (local_38 == (int1 *)0x348800) {
local_38 = (int1 *)mult(0x348800,0x348800,param_3);
bVar1 = true;
}
}
if (local_40 != (int1 *)0x0) {
Bfree(local_40,param_3);
}
local_10 = local_18;
}
return local_10;
}
| |
53,989 | skip | eloqsql/unittest/mytap/tap.c | void
skip(int how_many, char const * const fmt, ...)
{
char reason[80];
if (fmt && *fmt)
{
va_list ap;
va_start(ap, fmt);
vsnprintf(reason, sizeof(reason), fmt, ap);
va_end(ap);
}
else
reason[0] = '\0';
while (how_many-- > 0)
{
va_list ap;
memset((char*) &ap, 0, sizeof(ap)); /* Keep compiler happy */
vemit_tap(1, NULL, ap);
emit_dir("skip", reason);
emit_endl();
}
} | O0 | c | skip:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
testb %al, %al
je 0x25647
movaps %xmm0, -0x130(%rbp)
movaps %xmm1, -0x120(%rbp)
movaps %xmm2, -0x110(%rbp)
movaps %xmm3, -0x100(%rbp)
movaps %xmm4, -0xf0(%rbp)
movaps %xmm5, -0xe0(%rbp)
movaps %xmm6, -0xd0(%rbp)
movaps %xmm7, -0xc0(%rbp)
movq %r9, -0x138(%rbp)
movq %r8, -0x140(%rbp)
movq %rcx, -0x148(%rbp)
movq %rdx, -0x150(%rbp)
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movl %edi, -0x64(%rbp)
movq %rsi, -0x70(%rbp)
cmpq $0x0, -0x70(%rbp)
je 0x256d3
movq -0x70(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x256d3
leaq -0x90(%rbp), %rax
leaq -0x160(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
leaq -0x60(%rbp), %rdi
movq -0x70(%rbp), %rdx
leaq -0x90(%rbp), %rcx
movl $0x50, %esi
callq 0x241c0
leaq -0x90(%rbp), %rax
jmp 0x256d7
movb $0x0, -0x60(%rbp)
jmp 0x256d9
movl -0x64(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x64(%rbp)
cmpl $0x0, %eax
jle 0x25728
leaq -0xb0(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x24180
leaq -0xb0(%rbp), %rdx
movl $0x1, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x25450
leaq -0x60(%rbp), %rsi
leaq 0x547f8(%rip), %rdi # 0x79f14
callq 0x25530
callq 0x25990
jmp 0x256d9
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x25743
addq $0x160, %rsp # imm = 0x160
popq %rbp
retq
callq 0x242d0
nopl (%rax,%rax)
| skip:
push rbp
mov rbp, rsp
sub rsp, 160h
test al, al
jz short loc_25647
movaps [rbp+var_130], xmm0
movaps [rbp+var_120], xmm1
movaps [rbp+var_110], xmm2
movaps [rbp+var_100], xmm3
movaps [rbp+var_F0], xmm4
movaps [rbp+var_E0], xmm5
movaps [rbp+var_D0], xmm6
movaps [rbp+var_C0], xmm7
loc_25647:
mov [rbp+var_138], r9
mov [rbp+var_140], r8
mov [rbp+var_148], rcx
mov [rbp+var_150], rdx
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_64], edi
mov [rbp+var_70], rsi
cmp [rbp+var_70], 0
jz short loc_256D3
mov rax, [rbp+var_70]
movsx eax, byte ptr [rax]
cmp eax, 0
jz short loc_256D3
lea rax, [rbp+var_90]
lea rcx, [rbp+var_160]
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 rdi, [rbp+var_60]
mov rdx, [rbp+var_70]
lea rcx, [rbp+var_90]
mov esi, 50h ; 'P'
call _vsnprintf
lea rax, [rbp+var_90]
jmp short loc_256D7
loc_256D3:
mov [rbp+var_60], 0
loc_256D7:
jmp short $+2
loc_256D9:
mov eax, [rbp+var_64]
mov ecx, eax
add ecx, 0FFFFFFFFh
mov [rbp+var_64], ecx
cmp eax, 0
jle short loc_25728
lea rdi, [rbp+var_B0]
xor esi, esi
mov edx, 18h
call _memset
lea rdx, [rbp+var_B0]
mov edi, 1
xor eax, eax
mov esi, eax
call vemit_tap
lea rsi, [rbp+var_60]
lea rdi, aSkip; "skip"
call emit_dir
call emit_endl
jmp short loc_256D9
loc_25728:
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_25743
add rsp, 160h
pop rbp
retn
loc_25743:
call ___stack_chk_fail
| unsigned long long skip(int a1, _BYTE *a2, ...)
{
int v2; // eax
_BYTE v4[32]; // [rsp+B0h] [rbp-B0h] BYREF
va_list va; // [rsp+D0h] [rbp-90h] BYREF
_BYTE *v6; // [rsp+F0h] [rbp-70h]
int v7; // [rsp+FCh] [rbp-64h]
char v8[88]; // [rsp+100h] [rbp-60h] BYREF
unsigned long long v9; // [rsp+158h] [rbp-8h]
v9 = __readfsqword(0x28u);
v7 = a1;
v6 = a2;
if ( a2 && *v6 )
{
va_start(va, a2);
vsnprintf(v8, 80LL, v6, va);
}
else
{
v8[0] = 0;
}
while ( 1 )
{
v2 = v7--;
if ( v2 <= 0 )
break;
memset(v4, 0LL, 24LL);
vemit_tap(1, 0LL, (long long)v4);
emit_dir("skip", v8);
emit_endl();
}
return __readfsqword(0x28u);
}
| skip:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x160
TEST AL,AL
JZ 0x00125647
MOVAPS xmmword ptr [RBP + -0x130],XMM0
MOVAPS xmmword ptr [RBP + -0x120],XMM1
MOVAPS xmmword ptr [RBP + -0x110],XMM2
MOVAPS xmmword ptr [RBP + -0x100],XMM3
MOVAPS xmmword ptr [RBP + -0xf0],XMM4
MOVAPS xmmword ptr [RBP + -0xe0],XMM5
MOVAPS xmmword ptr [RBP + -0xd0],XMM6
MOVAPS xmmword ptr [RBP + -0xc0],XMM7
LAB_00125647:
MOV qword ptr [RBP + -0x138],R9
MOV qword ptr [RBP + -0x140],R8
MOV qword ptr [RBP + -0x148],RCX
MOV qword ptr [RBP + -0x150],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x64],EDI
MOV qword ptr [RBP + -0x70],RSI
CMP qword ptr [RBP + -0x70],0x0
JZ 0x001256d3
MOV RAX,qword ptr [RBP + -0x70]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JZ 0x001256d3
LEA RAX,[RBP + -0x90]
LEA RCX,[RBP + -0x160]
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 RDI,[RBP + -0x60]
MOV RDX,qword ptr [RBP + -0x70]
LEA RCX,[RBP + -0x90]
MOV ESI,0x50
CALL 0x001241c0
LEA RAX,[RBP + -0x90]
JMP 0x001256d7
LAB_001256d3:
MOV byte ptr [RBP + -0x60],0x0
LAB_001256d7:
JMP 0x001256d9
LAB_001256d9:
MOV EAX,dword ptr [RBP + -0x64]
MOV ECX,EAX
ADD ECX,-0x1
MOV dword ptr [RBP + -0x64],ECX
CMP EAX,0x0
JLE 0x00125728
LEA RDI,[RBP + -0xb0]
XOR ESI,ESI
MOV EDX,0x18
CALL 0x00124180
LEA RDX,[RBP + -0xb0]
MOV EDI,0x1
XOR EAX,EAX
MOV ESI,EAX
CALL 0x00125450
LEA RSI,[RBP + -0x60]
LEA RDI,[0x179f14]
CALL 0x00125530
CALL 0x00125990
JMP 0x001256d9
LAB_00125728:
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00125743
ADD RSP,0x160
POP RBP
RET
LAB_00125743:
CALL 0x001242d0
|
void skip(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,int param_9,
char *param_10,int8 param_11,int8 param_12,int8 param_13,
int8 param_14)
{
char in_AL;
long in_FS_OFFSET;
int1 local_168 [16];
int8 local_158;
int8 local_150;
int8 local_148;
int8 local_140;
int8 local_138;
int8 local_128;
int8 local_118;
int8 local_108;
int8 local_f8;
int8 local_e8;
int8 local_d8;
int8 local_c8;
int1 local_b8 [32];
int4 local_98;
int4 local_94;
int1 *local_90;
int1 *local_88;
char *local_78;
int local_6c;
char local_68 [88];
long local_10;
if (in_AL != '\0') {
local_138 = param_1;
local_128 = param_2;
local_118 = param_3;
local_108 = param_4;
local_f8 = param_5;
local_e8 = param_6;
local_d8 = param_7;
local_c8 = param_8;
}
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_158 = param_11;
local_150 = param_12;
local_148 = param_13;
local_140 = param_14;
local_78 = param_10;
local_6c = param_9;
if ((param_10 == (char *)0x0) || (*param_10 == '\0')) {
local_68[0] = '\0';
}
else {
local_88 = local_168;
local_90 = &stack0x00000008;
local_94 = 0x30;
local_98 = 0x10;
vsnprintf(local_68,0x50,param_10,&local_98);
}
while (0 < local_6c) {
local_6c = local_6c + -1;
memset(local_b8,0,0x18);
vemit_tap(1,0,local_b8);
emit_dir(&DAT_00179f14);
emit_endl();
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
local_6c = local_6c + -1;
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return;
}
| |
53,990 | mz_deflate | 7CodeWizard[P]stablediffusion/thirdparty/miniz.h | int mz_deflate(mz_streamp pStream, int flush) {
size_t in_bytes, out_bytes;
mz_ulong orig_total_in, orig_total_out;
int mz_status = MZ_OK;
if ((!pStream) || (!pStream->state) || (flush < 0) || (flush > MZ_FINISH) ||
(!pStream->next_out))
return MZ_STREAM_ERROR;
if (!pStream->avail_out)
return MZ_BUF_ERROR;
if (flush == MZ_PARTIAL_FLUSH)
flush = MZ_SYNC_FLUSH;
if (((tdefl_compressor *)pStream->state)->m_prev_return_status ==
TDEFL_STATUS_DONE)
return (flush == MZ_FINISH) ? MZ_STREAM_END : MZ_BUF_ERROR;
orig_total_in = pStream->total_in;
orig_total_out = pStream->total_out;
for (;;) {
tdefl_status defl_status;
in_bytes = pStream->avail_in;
out_bytes = pStream->avail_out;
defl_status = tdefl_compress((tdefl_compressor *)pStream->state,
pStream->next_in, &in_bytes, pStream->next_out,
&out_bytes, (tdefl_flush)flush);
pStream->next_in += (mz_uint)in_bytes;
pStream->avail_in -= (mz_uint)in_bytes;
pStream->total_in += (mz_uint)in_bytes;
pStream->adler = tdefl_get_adler32((tdefl_compressor *)pStream->state);
pStream->next_out += (mz_uint)out_bytes;
pStream->avail_out -= (mz_uint)out_bytes;
pStream->total_out += (mz_uint)out_bytes;
if (defl_status < 0) {
mz_status = MZ_STREAM_ERROR;
break;
} else if (defl_status == TDEFL_STATUS_DONE) {
mz_status = MZ_STREAM_END;
break;
} else if (!pStream->avail_out)
break;
else if ((!pStream->avail_in) && (flush != MZ_FINISH)) {
if ((flush) || (pStream->total_in != orig_total_in) ||
(pStream->total_out != orig_total_out))
break;
return MZ_BUF_ERROR; /* Can't make forward progress without some input.
*/
}
}
return mz_status;
} | O1 | c | mz_deflate:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl $0xfffffffe, %ebx # imm = 0xFFFFFFFE
testq %rdi, %rdi
je 0x7f033
movq %rdi, %r14
movq 0x38(%rdi), %rax
testq %rax, %rax
sete %cl
cmpl $0x5, %esi
setae %dl
orb %cl, %dl
jne 0x7f033
cmpq $0x0, 0x18(%r14)
je 0x7f033
movl $0xfffffffb, %ebx # imm = 0xFFFFFFFB
cmpl $0x0, 0x20(%r14)
je 0x7f033
cmpl $0x1, %esi
movl $0x2, %ebp
cmovnel %esi, %ebp
cmpl $0x1, 0x84(%rax)
jne 0x7ef44
cmpl $0x4, %ebp
movl $0x1, %eax
cmovel %eax, %ebx
jmp 0x7f033
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%r14), %r13
leaq 0x8(%rsp), %r15
movq %rsp, %r12
xorl %ebx, %ebx
movl 0x8(%r14), %eax
movq %rax, 0x8(%rsp)
movl 0x20(%r14), %eax
movq %rax, (%rsp)
movq 0x38(%r14), %rdi
movq (%r14), %rsi
movq 0x18(%r14), %rcx
movq %r15, %rdx
movq %r12, %r8
movl %ebp, %r9d
callq 0x7f044
movq 0x8(%rsp), %rdi
movl %edi, %ecx
addq %rcx, (%r14)
movl 0x8(%r14), %r8d
movl 0x20(%r14), %r9d
movl %r8d, %edx
subl %edi, %edx
movl %edx, 0x8(%r14)
addq 0x10(%r14), %rcx
movq %rcx, 0x10(%r14)
movq 0x38(%r14), %rdx
movl 0x20(%rdx), %edx
movq %rdx, 0x60(%r14)
movq (%rsp), %r10
movl %r10d, %esi
addq %rsi, 0x18(%r14)
movl %r9d, %edx
subl %r10d, %edx
movl %edx, 0x20(%r14)
addq 0x28(%r14), %rsi
movq %rsi, 0x28(%r14)
movl $0x2, %edx
testl %eax, %eax
js 0x7efe5
cmpl $0x1, %eax
jne 0x7efec
movl $0x1, %ebx
jmp 0x7f021
movl $0xfffffffe, %ebx # imm = 0xFFFFFFFE
jmp 0x7f021
cmpl %r10d, %r9d
je 0x7f021
movl %r8d, %eax
xorl %edi, %eax
xorl %edx, %edx
cmpl %edi, %r8d
sete %dl
addl %edx, %edx
cmpl $0x4, %ebp
movl $0x0, %edi
cmovel %edi, %edx
orl %ebp, %eax
jne 0x7f021
xorq 0x10(%rsp), %rcx
xorq %r13, %rsi
xorl %edx, %edx
orq %rcx, %rsi
setne %dl
incl %edx
testl %edx, %edx
je 0x7ef5b
cmpl $0x2, %edx
je 0x7f033
movl $0xfffffffb, %ebx # imm = 0xFFFFFFFB
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| mz_deflate:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov ebx, 0FFFFFFFEh
test rdi, rdi
jz loc_7F033
mov r14, rdi
mov rax, [rdi+38h]
test rax, rax
setz cl
cmp esi, 5
setnb dl
or dl, cl
jnz loc_7F033
cmp qword ptr [r14+18h], 0
jz loc_7F033
mov ebx, 0FFFFFFFBh
cmp dword ptr [r14+20h], 0
jz loc_7F033
cmp esi, 1
mov ebp, 2
cmovnz ebp, esi
cmp dword ptr [rax+84h], 1
jnz short loc_7EF44
cmp ebp, 4
mov eax, 1
cmovz ebx, eax
jmp loc_7F033
loc_7EF44:
mov rax, [r14+10h]
mov [rsp+48h+var_38], rax
mov r13, [r14+28h]
lea r15, [rsp+48h+var_40]
mov r12, rsp
xor ebx, ebx
loc_7EF5B:
mov eax, [r14+8]
mov [rsp+48h+var_40], rax
mov eax, [r14+20h]
mov [rsp+48h+var_48], rax
mov rdi, [r14+38h]
mov rsi, [r14]
mov rcx, [r14+18h]
mov rdx, r15
mov r8, r12
mov r9d, ebp
call tdefl_compress
mov rdi, [rsp+48h+var_40]
mov ecx, edi
add [r14], rcx
mov r8d, [r14+8]
mov r9d, [r14+20h]
mov edx, r8d
sub edx, edi
mov [r14+8], edx
add rcx, [r14+10h]
mov [r14+10h], rcx
mov rdx, [r14+38h]
mov edx, [rdx+20h]
mov [r14+60h], rdx
mov r10, [rsp+48h+var_48]
mov esi, r10d
add [r14+18h], rsi
mov edx, r9d
sub edx, r10d
mov [r14+20h], edx
add rsi, [r14+28h]
mov [r14+28h], rsi
mov edx, 2
test eax, eax
js short loc_7EFE5
cmp eax, 1
jnz short loc_7EFEC
mov ebx, 1
jmp short loc_7F021
loc_7EFE5:
mov ebx, 0FFFFFFFEh
jmp short loc_7F021
loc_7EFEC:
cmp r9d, r10d
jz short loc_7F021
mov eax, r8d
xor eax, edi
xor edx, edx
cmp r8d, edi
setz dl
add edx, edx
cmp ebp, 4
mov edi, 0
cmovz edx, edi
or eax, ebp
jnz short loc_7F021
xor rcx, [rsp+48h+var_38]
xor rsi, r13
xor edx, edx
or rsi, rcx
setnz dl
inc edx
loc_7F021:
test edx, edx
jz loc_7EF5B
cmp edx, 2
jz short loc_7F033
mov ebx, 0FFFFFFFBh
loc_7F033:
mov eax, ebx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long mz_deflate(long long a1, unsigned int a2)
{
unsigned int v2; // ebx
long long v4; // rax
unsigned int v5; // ebp
long long v6; // r13
int v7; // eax
int v8; // edi
long long v9; // rcx
int v10; // r8d
int v11; // r9d
long long v12; // rcx
int v13; // r10d
long long v14; // rsi
long long v15; // rsi
int v16; // edx
long long v18; // [rsp+0h] [rbp-48h] BYREF
long long v19; // [rsp+8h] [rbp-40h] BYREF
long long v20; // [rsp+10h] [rbp-38h]
v2 = -2;
if ( a1 )
{
v4 = *(_QWORD *)(a1 + 56);
if ( v4 != 0 && a2 < 5 )
{
if ( *(_QWORD *)(a1 + 24) )
{
v2 = -5;
if ( *(_DWORD *)(a1 + 32) )
{
v5 = 2;
if ( a2 != 1 )
v5 = a2;
if ( *(_DWORD *)(v4 + 132) == 1 )
{
if ( v5 == 4 )
return 1;
}
else
{
v20 = *(_QWORD *)(a1 + 16);
v6 = *(_QWORD *)(a1 + 40);
v2 = 0;
do
{
v19 = *(unsigned int *)(a1 + 8);
v18 = *(unsigned int *)(a1 + 32);
v7 = tdefl_compress(*(_QWORD *)(a1 + 56), *(_QWORD *)a1, &v19, *(_QWORD *)(a1 + 24), &v18, v5);
v8 = v19;
v9 = (unsigned int)v19;
*(_QWORD *)a1 += (unsigned int)v19;
v10 = *(_DWORD *)(a1 + 8);
v11 = *(_DWORD *)(a1 + 32);
*(_DWORD *)(a1 + 8) = v10 - v9;
v12 = *(_QWORD *)(a1 + 16) + v9;
*(_QWORD *)(a1 + 16) = v12;
*(_QWORD *)(a1 + 96) = *(unsigned int *)(*(_QWORD *)(a1 + 56) + 32LL);
v13 = v18;
v14 = (unsigned int)v18;
*(_QWORD *)(a1 + 24) += (unsigned int)v18;
*(_DWORD *)(a1 + 32) = v11 - v14;
v15 = *(_QWORD *)(a1 + 40) + v14;
*(_QWORD *)(a1 + 40) = v15;
v16 = 2;
if ( v7 < 0 )
{
v2 = -2;
}
else if ( v7 == 1 )
{
v2 = 1;
}
else if ( v11 != v13 )
{
v16 = 2 * (v10 == v8);
if ( v5 == 4 )
v16 = 0;
if ( !(v5 | v8 ^ v10) )
v16 = ((v20 ^ v12 | v6 ^ v15) != 0) + 1;
}
}
while ( !v16 );
if ( v16 != 2 )
return (unsigned int)-5;
}
}
}
}
}
return v2;
}
| |||
53,991 | mz_deflate | 7CodeWizard[P]stablediffusion/thirdparty/miniz.h | int mz_deflate(mz_streamp pStream, int flush) {
size_t in_bytes, out_bytes;
mz_ulong orig_total_in, orig_total_out;
int mz_status = MZ_OK;
if ((!pStream) || (!pStream->state) || (flush < 0) || (flush > MZ_FINISH) ||
(!pStream->next_out))
return MZ_STREAM_ERROR;
if (!pStream->avail_out)
return MZ_BUF_ERROR;
if (flush == MZ_PARTIAL_FLUSH)
flush = MZ_SYNC_FLUSH;
if (((tdefl_compressor *)pStream->state)->m_prev_return_status ==
TDEFL_STATUS_DONE)
return (flush == MZ_FINISH) ? MZ_STREAM_END : MZ_BUF_ERROR;
orig_total_in = pStream->total_in;
orig_total_out = pStream->total_out;
for (;;) {
tdefl_status defl_status;
in_bytes = pStream->avail_in;
out_bytes = pStream->avail_out;
defl_status = tdefl_compress((tdefl_compressor *)pStream->state,
pStream->next_in, &in_bytes, pStream->next_out,
&out_bytes, (tdefl_flush)flush);
pStream->next_in += (mz_uint)in_bytes;
pStream->avail_in -= (mz_uint)in_bytes;
pStream->total_in += (mz_uint)in_bytes;
pStream->adler = tdefl_get_adler32((tdefl_compressor *)pStream->state);
pStream->next_out += (mz_uint)out_bytes;
pStream->avail_out -= (mz_uint)out_bytes;
pStream->total_out += (mz_uint)out_bytes;
if (defl_status < 0) {
mz_status = MZ_STREAM_ERROR;
break;
} else if (defl_status == TDEFL_STATUS_DONE) {
mz_status = MZ_STREAM_END;
break;
} else if (!pStream->avail_out)
break;
else if ((!pStream->avail_in) && (flush != MZ_FINISH)) {
if ((flush) || (pStream->total_in != orig_total_in) ||
(pStream->total_out != orig_total_out))
break;
return MZ_BUF_ERROR; /* Can't make forward progress without some input.
*/
}
}
return mz_status;
} | O2 | c | mz_deflate:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
pushq $-0x2
popq %r12
testq %rdi, %rdi
je 0x59c28
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
sete %al
cmpl $0x5, %esi
setae %cl
orb %al, %cl
jne 0x59c28
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
je 0x59c28
movl 0x20(%rbx), %r9d
testl %r9d, %r9d
je 0x59b45
cmpl $0x1, %esi
pushq $0x2
popq %rbp
cmovnel %esi, %ebp
cmpl $0x1, 0x84(%rdi)
jne 0x59b4d
cmpl $0x4, %ebp
pushq $0x1
popq %rcx
pushq $-0x5
popq %rax
cmovel %ecx, %eax
jmp 0x59c2b
pushq $-0x5
popq %rax
jmp 0x59c2b
movq 0x10(%rbx), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rbx), %rax
movq %rax, 0x20(%rsp)
movl 0x8(%rbx), %r8d
movq (%rbx), %rsi
movl %r8d, %eax
movq %rax, 0x10(%rsp)
movl %r9d, %eax
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %r8
movl %ebp, %r9d
callq 0x59c41
movq 0x10(%rsp), %r11
movl %r11d, %edx
movq (%rbx), %rsi
addq %rdx, %rsi
movq %rsi, (%rbx)
movl 0x8(%rbx), %r13d
movl 0x20(%rbx), %r14d
movl %r13d, %r8d
subl %r11d, %r8d
movl %r8d, 0x8(%rbx)
addq 0x10(%rbx), %rdx
movq %rdx, 0x10(%rbx)
movq 0x38(%rbx), %rdi
movl 0x20(%rdi), %ecx
movq %rcx, 0x60(%rbx)
movq 0x8(%rsp), %r15
movl %r15d, %r10d
movq 0x18(%rbx), %rcx
addq %r10, %rcx
movq %rcx, 0x18(%rbx)
movl %r14d, %r9d
subl %r15d, %r9d
movl %r9d, 0x20(%rbx)
addq 0x28(%rbx), %r10
movq %r10, 0x28(%rbx)
testl %eax, %eax
js 0x59c28
cmpl $0x1, %eax
je 0x59c3a
xorl %eax, %eax
cmpl %r15d, %r14d
je 0x59c2b
cmpl $0x4, %ebp
sete %r14b
cmpl %r11d, %r13d
setne %r11b
orb %r14b, %r11b
jne 0x59b66
testl %ebp, %ebp
jne 0x59c2b
xorq 0x18(%rsp), %rdx
xorq 0x20(%rsp), %r10
xorl %eax, %eax
orq %rdx, %r10
setne %al
leal (%rax,%rax,4), %eax
addl $-0x5, %eax
jmp 0x59c2b
movl %r12d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
jmp 0x59b47
| mz_deflate:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
push 0FFFFFFFFFFFFFFFEh
pop r12
test rdi, rdi
jz loc_59C28
mov rbx, rdi
mov rdi, [rdi+38h]
test rdi, rdi
setz al
cmp esi, 5
setnb cl
or cl, al
jnz loc_59C28
mov rcx, [rbx+18h]
test rcx, rcx
jz loc_59C28
mov r9d, [rbx+20h]
test r9d, r9d
jz short loc_59B45
cmp esi, 1
push 2
pop rbp
cmovnz ebp, esi
cmp dword ptr [rdi+84h], 1
jnz short loc_59B4D
cmp ebp, 4
push 1
pop rcx
push 0FFFFFFFFFFFFFFFBh
pop rax
cmovz eax, ecx
jmp loc_59C2B
loc_59B45:
push 0FFFFFFFFFFFFFFFBh
loc_59B47:
pop rax
jmp loc_59C2B
loc_59B4D:
mov rax, [rbx+10h]
mov [rsp+58h+var_40], rax
mov rax, [rbx+28h]
mov [rsp+58h+var_38], rax
mov r8d, [rbx+8]
mov rsi, [rbx]
loc_59B66:
mov eax, r8d
mov [rsp+58h+var_48], rax
mov eax, r9d
mov [rsp+58h+var_50], rax
lea rdx, [rsp+58h+var_48]
lea r8, [rsp+58h+var_50]
mov r9d, ebp
call tdefl_compress
mov r11, [rsp+58h+var_48]
mov edx, r11d
mov rsi, [rbx]
add rsi, rdx
mov [rbx], rsi
mov r13d, [rbx+8]
mov r14d, [rbx+20h]
mov r8d, r13d
sub r8d, r11d
mov [rbx+8], r8d
add rdx, [rbx+10h]
mov [rbx+10h], rdx
mov rdi, [rbx+38h]
mov ecx, [rdi+20h]
mov [rbx+60h], rcx
mov r15, [rsp+58h+var_50]
mov r10d, r15d
mov rcx, [rbx+18h]
add rcx, r10
mov [rbx+18h], rcx
mov r9d, r14d
sub r9d, r15d
mov [rbx+20h], r9d
add r10, [rbx+28h]
mov [rbx+28h], r10
test eax, eax
js short loc_59C28
cmp eax, 1
jz short loc_59C3A
xor eax, eax
cmp r14d, r15d
jz short loc_59C2B
cmp ebp, 4
setz r14b
cmp r13d, r11d
setnz r11b
or r11b, r14b
jnz loc_59B66
test ebp, ebp
jnz short loc_59C2B
xor rdx, [rsp+58h+var_40]
xor r10, [rsp+58h+var_38]
xor eax, eax
or r10, rdx
setnz al
lea eax, [rax+rax*4]
add eax, 0FFFFFFFBh
jmp short loc_59C2B
loc_59C28:
mov eax, r12d
loc_59C2B:
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_59C3A:
push 1
jmp loc_59B47
| long long mz_deflate(long long *a1, unsigned int a2)
{
long long v3; // rdi
long long v4; // rcx
unsigned int v5; // r9d
unsigned int v6; // ebp
long long result; // rax
unsigned int v8; // r8d
long long v9; // rsi
int v10; // eax
int v11; // r11d
long long v12; // rdx
int v13; // r13d
int v14; // r14d
long long v15; // rdx
int v16; // r15d
long long v17; // r10
long long v18; // r10
long long v20; // [rsp+8h] [rbp-50h] BYREF
long long v21; // [rsp+10h] [rbp-48h] BYREF
long long v22; // [rsp+18h] [rbp-40h]
long long v23; // [rsp+20h] [rbp-38h]
if ( !a1 )
return 4294967294LL;
v3 = a1[7];
if ( v3 == 0 || a2 >= 5 )
return 4294967294LL;
v4 = a1[3];
if ( !v4 )
return 4294967294LL;
v5 = *((_DWORD *)a1 + 8);
if ( v5 )
{
v6 = 2;
if ( a2 != 1 )
v6 = a2;
if ( *(_DWORD *)(v3 + 132) == 1 )
{
result = -5LL;
if ( v6 == 4 )
return 1LL;
return result;
}
v22 = a1[2];
v23 = a1[5];
v8 = *((_DWORD *)a1 + 2);
v9 = *a1;
while ( 1 )
{
v21 = v8;
v20 = v5;
v10 = tdefl_compress(v3, v9, &v21, v4, &v20, v6);
v11 = v21;
v12 = (unsigned int)v21;
v9 = (unsigned int)v21 + *a1;
*a1 = v9;
v13 = *((_DWORD *)a1 + 2);
v14 = *((_DWORD *)a1 + 8);
v8 = v13 - v12;
*((_DWORD *)a1 + 2) = v13 - v12;
v15 = a1[2] + v12;
a1[2] = v15;
v3 = a1[7];
a1[12] = *(unsigned int *)(v3 + 32);
v16 = v20;
v17 = (unsigned int)v20;
v4 = (unsigned int)v20 + a1[3];
a1[3] = v4;
v5 = v14 - v17;
*((_DWORD *)a1 + 8) = v14 - v17;
v18 = a1[5] + v17;
a1[5] = v18;
if ( v10 < 0 )
break;
if ( v10 == 1 )
return 1LL;
result = 0LL;
if ( v14 == v16 )
return result;
if ( v6 != 4 && v13 == v11 )
{
if ( !v6 )
return 5 * (unsigned int)((v22 ^ v15 | v23 ^ v18) != 0) - 5;
return result;
}
}
return 4294967294LL;
}
return -5LL;
}
| mz_deflate:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
PUSH -0x2
POP R12
TEST RDI,RDI
JZ 0x00159c28
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x38]
TEST RDI,RDI
SETZ AL
CMP ESI,0x5
SETNC CL
OR CL,AL
JNZ 0x00159c28
MOV RCX,qword ptr [RBX + 0x18]
TEST RCX,RCX
JZ 0x00159c28
MOV R9D,dword ptr [RBX + 0x20]
TEST R9D,R9D
JZ 0x00159b45
CMP ESI,0x1
PUSH 0x2
POP RBP
CMOVNZ EBP,ESI
CMP dword ptr [RDI + 0x84],0x1
JNZ 0x00159b4d
CMP EBP,0x4
PUSH 0x1
POP RCX
PUSH -0x5
POP RAX
CMOVZ EAX,ECX
JMP 0x00159c2b
LAB_00159b45:
PUSH -0x5
LAB_00159b47:
POP RAX
JMP 0x00159c2b
LAB_00159b4d:
MOV RAX,qword ptr [RBX + 0x10]
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [RBX + 0x28]
MOV qword ptr [RSP + 0x20],RAX
MOV R8D,dword ptr [RBX + 0x8]
MOV RSI,qword ptr [RBX]
LAB_00159b66:
MOV EAX,R8D
MOV qword ptr [RSP + 0x10],RAX
MOV EAX,R9D
MOV qword ptr [RSP + 0x8],RAX
LEA RDX,[RSP + 0x10]
LEA R8,[RSP + 0x8]
MOV R9D,EBP
CALL 0x00159c41
MOV R11,qword ptr [RSP + 0x10]
MOV EDX,R11D
MOV RSI,qword ptr [RBX]
ADD RSI,RDX
MOV qword ptr [RBX],RSI
MOV R13D,dword ptr [RBX + 0x8]
MOV R14D,dword ptr [RBX + 0x20]
MOV R8D,R13D
SUB R8D,R11D
MOV dword ptr [RBX + 0x8],R8D
ADD RDX,qword ptr [RBX + 0x10]
MOV qword ptr [RBX + 0x10],RDX
MOV RDI,qword ptr [RBX + 0x38]
MOV ECX,dword ptr [RDI + 0x20]
MOV qword ptr [RBX + 0x60],RCX
MOV R15,qword ptr [RSP + 0x8]
MOV R10D,R15D
MOV RCX,qword ptr [RBX + 0x18]
ADD RCX,R10
MOV qword ptr [RBX + 0x18],RCX
MOV R9D,R14D
SUB R9D,R15D
MOV dword ptr [RBX + 0x20],R9D
ADD R10,qword ptr [RBX + 0x28]
MOV qword ptr [RBX + 0x28],R10
TEST EAX,EAX
JS 0x00159c28
CMP EAX,0x1
JZ 0x00159c3a
XOR EAX,EAX
CMP R14D,R15D
JZ 0x00159c2b
CMP EBP,0x4
SETZ R14B
CMP R13D,R11D
SETNZ R11B
OR R11B,R14B
JNZ 0x00159b66
TEST EBP,EBP
JNZ 0x00159c2b
XOR RDX,qword ptr [RSP + 0x18]
XOR R10,qword ptr [RSP + 0x20]
XOR EAX,EAX
OR R10,RDX
SETNZ AL
LEA EAX,[RAX + RAX*0x4]
ADD EAX,-0x5
JMP 0x00159c2b
LAB_00159c28:
MOV EAX,R12D
LAB_00159c2b:
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00159c3a:
PUSH 0x1
JMP 0x00159b47
|
ulong mz_deflate(long *param_1,uint param_2)
{
long lVar1;
long lVar2;
int iVar3;
long lVar4;
long lVar5;
uint uVar6;
long lVar7;
long lVar8;
uint uVar9;
uint uVar10;
long lVar11;
ulong uStack_60;
ulong local_50;
ulong local_48;
long local_40;
long local_38;
if (((param_1 == (long *)0x0) || (lVar8 = param_1[7], 4 < param_2 || lVar8 == 0)) ||
(lVar4 = param_1[3], lVar4 == 0)) {
LAB_00159c28:
uStack_60 = 0xfffffffe;
}
else {
uVar10 = *(uint *)(param_1 + 4);
if (uVar10 == 0) {
uStack_60 = 0xfffffffffffffffb;
}
else {
uVar6 = 2;
if (param_2 != 1) {
uVar6 = param_2;
}
if (*(int *)(lVar8 + 0x84) == 1) {
uStack_60 = 0xfffffffffffffffb;
if (uVar6 == 4) {
uStack_60 = 1;
}
uStack_60 = uStack_60 & 0xffffffff;
}
else {
local_40 = param_1[2];
local_38 = param_1[5];
uVar9 = *(uint *)(param_1 + 1);
lVar7 = *param_1;
do {
local_48 = (ulong)uVar9;
local_50 = (ulong)uVar10;
iVar3 = tdefl_compress(lVar8,lVar7,&local_48,lVar4,&local_50,uVar6);
lVar7 = *param_1 + (local_48 & 0xffffffff);
*param_1 = lVar7;
lVar1 = param_1[1];
lVar2 = param_1[4];
uVar9 = (int)lVar1 - (int)local_48;
*(uint *)(param_1 + 1) = uVar9;
lVar5 = (local_48 & 0xffffffff) + param_1[2];
param_1[2] = lVar5;
lVar8 = param_1[7];
param_1[0xc] = (ulong)*(uint *)(lVar8 + 0x20);
lVar4 = param_1[3] + (local_50 & 0xffffffff);
param_1[3] = lVar4;
uVar10 = (int)lVar2 - (int)local_50;
*(uint *)(param_1 + 4) = uVar10;
lVar11 = (local_50 & 0xffffffff) + param_1[5];
param_1[5] = lVar11;
if (iVar3 < 0) goto LAB_00159c28;
if (iVar3 == 1) {
return 1;
}
uStack_60 = 0;
if ((int)lVar2 == (int)local_50) {
return 0;
}
} while ((int)lVar1 != (int)local_48 || uVar6 == 4);
if (uVar6 == 0) {
uStack_60 = (ulong)((uint)(lVar11 != local_38 || lVar5 != local_40) * 5 - 5);
}
}
}
}
return uStack_60;
}
| |
53,992 | mz_deflate | 7CodeWizard[P]stablediffusion/thirdparty/miniz.h | int mz_deflate(mz_streamp pStream, int flush) {
size_t in_bytes, out_bytes;
mz_ulong orig_total_in, orig_total_out;
int mz_status = MZ_OK;
if ((!pStream) || (!pStream->state) || (flush < 0) || (flush > MZ_FINISH) ||
(!pStream->next_out))
return MZ_STREAM_ERROR;
if (!pStream->avail_out)
return MZ_BUF_ERROR;
if (flush == MZ_PARTIAL_FLUSH)
flush = MZ_SYNC_FLUSH;
if (((tdefl_compressor *)pStream->state)->m_prev_return_status ==
TDEFL_STATUS_DONE)
return (flush == MZ_FINISH) ? MZ_STREAM_END : MZ_BUF_ERROR;
orig_total_in = pStream->total_in;
orig_total_out = pStream->total_out;
for (;;) {
tdefl_status defl_status;
in_bytes = pStream->avail_in;
out_bytes = pStream->avail_out;
defl_status = tdefl_compress((tdefl_compressor *)pStream->state,
pStream->next_in, &in_bytes, pStream->next_out,
&out_bytes, (tdefl_flush)flush);
pStream->next_in += (mz_uint)in_bytes;
pStream->avail_in -= (mz_uint)in_bytes;
pStream->total_in += (mz_uint)in_bytes;
pStream->adler = tdefl_get_adler32((tdefl_compressor *)pStream->state);
pStream->next_out += (mz_uint)out_bytes;
pStream->avail_out -= (mz_uint)out_bytes;
pStream->total_out += (mz_uint)out_bytes;
if (defl_status < 0) {
mz_status = MZ_STREAM_ERROR;
break;
} else if (defl_status == TDEFL_STATUS_DONE) {
mz_status = MZ_STREAM_END;
break;
} else if (!pStream->avail_out)
break;
else if ((!pStream->avail_in) && (flush != MZ_FINISH)) {
if ((flush) || (pStream->total_in != orig_total_in) ||
(pStream->total_out != orig_total_out))
break;
return MZ_BUF_ERROR; /* Can't make forward progress without some input.
*/
}
}
return mz_status;
} | O3 | c | mz_deflate:
testq %rdi, %rdi
je 0x7dec1
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
sete %al
cmpl $0x5, %esi
setae %cl
orb %al, %cl
jne 0x7dfaf
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
je 0x7dfaf
movl 0x20(%rbx), %r9d
testl %r9d, %r9d
je 0x7dec7
cmpl $0x1, %esi
movl $0x2, %ebp
cmovnel %esi, %ebp
cmpl $0x1, 0x84(%rdi)
jne 0x7ded1
cmpl $0x4, %ebp
movl $0x1, %ecx
movl $0xfffffffb, %eax # imm = 0xFFFFFFFB
cmovel %ecx, %eax
jmp 0x7dfb4
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
retq
movl $0xfffffffb, %eax # imm = 0xFFFFFFFB
jmp 0x7dfb4
movq 0x10(%rbx), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rbx), %rax
movq %rax, 0x20(%rsp)
movl 0x8(%rbx), %r8d
movq (%rbx), %rsi
leaq 0x8(%rsp), %r15
movl %r8d, %eax
movq %rax, 0x10(%rsp)
movl %r9d, %eax
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdx
movq %r15, %r8
movl %ebp, %r9d
callq 0x7dfca
movq 0x10(%rsp), %r11
movl %r11d, %edx
movq (%rbx), %rsi
addq %rdx, %rsi
movq %rsi, (%rbx)
movl 0x8(%rbx), %r12d
movl 0x20(%rbx), %r13d
movl %r12d, %r8d
subl %r11d, %r8d
movl %r8d, 0x8(%rbx)
addq 0x10(%rbx), %rdx
movq %rdx, 0x10(%rbx)
movq 0x38(%rbx), %rdi
movl 0x20(%rdi), %ecx
movq %rcx, 0x60(%rbx)
movq 0x8(%rsp), %r14
movl %r14d, %r10d
movq 0x18(%rbx), %rcx
addq %r10, %rcx
movq %rcx, 0x18(%rbx)
movl %r13d, %r9d
subl %r14d, %r9d
movl %r9d, 0x20(%rbx)
addq 0x28(%rbx), %r10
movq %r10, 0x28(%rbx)
testl %eax, %eax
js 0x7dfaf
cmpl $0x1, %eax
je 0x7dfc3
xorl %eax, %eax
cmpl %r14d, %r13d
je 0x7dfb4
cmpl $0x4, %ebp
sete %r14b
cmpl %r11d, %r12d
setne %r11b
orb %r14b, %r11b
jne 0x7deef
testl %ebp, %ebp
jne 0x7dfb4
xorq 0x18(%rsp), %rdx
xorq 0x20(%rsp), %r10
xorl %eax, %eax
orq %rdx, %r10
setne %al
leal (%rax,%rax,4), %eax
addl $-0x5, %eax
jmp 0x7dfb4
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %eax
jmp 0x7dfb4
| mz_deflate:
test rdi, rdi
jz short loc_7DEC1
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rbx, rdi
mov rdi, [rdi+38h]
test rdi, rdi
setz al
cmp esi, 5
setnb cl
or cl, al
jnz loc_7DFAF
mov rcx, [rbx+18h]
test rcx, rcx
jz loc_7DFAF
mov r9d, [rbx+20h]
test r9d, r9d
jz short loc_7DEC7
cmp esi, 1
mov ebp, 2
cmovnz ebp, esi
cmp dword ptr [rdi+84h], 1
jnz short loc_7DED1
cmp ebp, 4
mov ecx, 1
mov eax, 0FFFFFFFBh
cmovz eax, ecx
jmp loc_7DFB4
loc_7DEC1:
mov eax, 0FFFFFFFEh
retn
loc_7DEC7:
mov eax, 0FFFFFFFBh
jmp loc_7DFB4
loc_7DED1:
mov rax, [rbx+10h]
mov [rsp+58h+var_40], rax
mov rax, [rbx+28h]
mov [rsp+58h+var_38], rax
mov r8d, [rbx+8]
mov rsi, [rbx]
lea r15, [rsp+58h+var_50]
loc_7DEEF:
mov eax, r8d
mov [rsp+58h+var_48], rax
mov eax, r9d
mov [rsp+58h+var_50], rax
lea rdx, [rsp+58h+var_48]
mov r8, r15
mov r9d, ebp
call tdefl_compress
mov r11, [rsp+58h+var_48]
mov edx, r11d
mov rsi, [rbx]
add rsi, rdx
mov [rbx], rsi
mov r12d, [rbx+8]
mov r13d, [rbx+20h]
mov r8d, r12d
sub r8d, r11d
mov [rbx+8], r8d
add rdx, [rbx+10h]
mov [rbx+10h], rdx
mov rdi, [rbx+38h]
mov ecx, [rdi+20h]
mov [rbx+60h], rcx
mov r14, [rsp+58h+var_50]
mov r10d, r14d
mov rcx, [rbx+18h]
add rcx, r10
mov [rbx+18h], rcx
mov r9d, r13d
sub r9d, r14d
mov [rbx+20h], r9d
add r10, [rbx+28h]
mov [rbx+28h], r10
test eax, eax
js short loc_7DFAF
cmp eax, 1
jz short loc_7DFC3
xor eax, eax
cmp r13d, r14d
jz short loc_7DFB4
cmp ebp, 4
setz r14b
cmp r12d, r11d
setnz r11b
or r11b, r14b
jnz loc_7DEEF
test ebp, ebp
jnz short loc_7DFB4
xor rdx, [rsp+58h+var_40]
xor r10, [rsp+58h+var_38]
xor eax, eax
or r10, rdx
setnz al
lea eax, [rax+rax*4]
add eax, 0FFFFFFFBh
jmp short loc_7DFB4
loc_7DFAF:
mov eax, 0FFFFFFFEh
loc_7DFB4:
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_7DFC3:
mov eax, 1
jmp short loc_7DFB4
| long long mz_deflate(long long *a1, unsigned int a2)
{
long long v3; // rdi
long long v4; // rcx
unsigned int v5; // r9d
unsigned int v6; // ebp
long long result; // rax
unsigned int v8; // r8d
long long v9; // rsi
int v10; // eax
int v11; // r11d
long long v12; // rdx
int v13; // r12d
int v14; // r13d
long long v15; // rdx
int v16; // r14d
long long v17; // r10
long long v18; // r10
long long v19; // [rsp+0h] [rbp-50h] BYREF
long long v20; // [rsp+8h] [rbp-48h] BYREF
long long v21; // [rsp+10h] [rbp-40h]
long long v22; // [rsp+18h] [rbp-38h]
if ( !a1 )
return 4294967294LL;
v3 = a1[7];
if ( v3 == 0 || a2 >= 5 )
return 4294967294LL;
v4 = a1[3];
if ( !v4 )
return 4294967294LL;
v5 = *((_DWORD *)a1 + 8);
if ( !v5 )
return 4294967291LL;
v6 = 2;
if ( a2 != 1 )
v6 = a2;
if ( *(_DWORD *)(v3 + 132) != 1 )
{
v21 = a1[2];
v22 = a1[5];
v8 = *((_DWORD *)a1 + 2);
v9 = *a1;
while ( 1 )
{
v20 = v8;
v19 = v5;
v10 = tdefl_compress(v3, v9, &v20, v4, &v19, v6);
v11 = v20;
v12 = (unsigned int)v20;
v9 = (unsigned int)v20 + *a1;
*a1 = v9;
v13 = *((_DWORD *)a1 + 2);
v14 = *((_DWORD *)a1 + 8);
v8 = v13 - v12;
*((_DWORD *)a1 + 2) = v13 - v12;
v15 = a1[2] + v12;
a1[2] = v15;
v3 = a1[7];
a1[12] = *(unsigned int *)(v3 + 32);
v16 = v19;
v17 = (unsigned int)v19;
v4 = (unsigned int)v19 + a1[3];
a1[3] = v4;
v5 = v14 - v17;
*((_DWORD *)a1 + 8) = v14 - v17;
v18 = a1[5] + v17;
a1[5] = v18;
if ( v10 < 0 )
break;
if ( v10 == 1 )
return 1LL;
result = 0LL;
if ( v14 == v16 )
return result;
if ( v6 != 4 && v13 == v11 )
{
if ( !v6 )
return 5 * (unsigned int)((v21 ^ v15 | v22 ^ v18) != 0) - 5;
return result;
}
}
return 4294967294LL;
}
result = 4294967291LL;
if ( v6 == 4 )
return 1LL;
return result;
}
| |||
53,993 | ggml_quantize_free | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c | void ggml_quantize_free(void) {
ggml_critical_section_start();
iq2xs_free_impl(GGML_TYPE_IQ2_XXS);
iq2xs_free_impl(GGML_TYPE_IQ2_XS);
iq2xs_free_impl(GGML_TYPE_IQ1_S);
iq3xs_free_impl(256);
ggml_critical_section_end();
} | O1 | c | ggml_quantize_free:
pushq %rax
callq 0x18e20
movl $0x10, %edi
callq 0x18460
movl $0x11, %edi
callq 0x18460
movl $0x13, %edi
callq 0x18460
movl $0x100, %edi # imm = 0x100
callq 0x18060
popq %rax
jmp 0x18c10
| ggml_quantize_free:
push rax
call _ggml_critical_section_start
mov edi, 10h
call _iq2xs_free_impl
mov edi, 11h
call _iq2xs_free_impl
mov edi, 13h
call _iq2xs_free_impl
mov edi, 100h
call _iq3xs_free_impl
pop rax
jmp _ggml_critical_section_end
| long long ggml_quantize_free(long long a1)
{
ggml_critical_section_start(a1);
iq2xs_free_impl(16LL);
iq2xs_free_impl(17LL);
iq2xs_free_impl(19LL);
iq3xs_free_impl(256LL);
return ggml_critical_section_end();
}
| ggml_quantize_free:
PUSH RAX
CALL 0x00118e20
MOV EDI,0x10
CALL 0x00118460
MOV EDI,0x11
CALL 0x00118460
MOV EDI,0x13
CALL 0x00118460
MOV EDI,0x100
CALL 0x00118060
POP RAX
JMP 0x00118c10
|
void ggml_quantize_free(void)
{
ggml_critical_section_start();
iq2xs_free_impl(0x10);
iq2xs_free_impl(0x11);
iq2xs_free_impl(0x13);
iq3xs_free_impl(0x100);
ggml_critical_section_end();
return;
}
| |
53,994 | ggml_quantize_free | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c | void ggml_quantize_free(void) {
ggml_critical_section_start();
iq2xs_free_impl(GGML_TYPE_IQ2_XXS);
iq2xs_free_impl(GGML_TYPE_IQ2_XS);
iq2xs_free_impl(GGML_TYPE_IQ1_S);
iq3xs_free_impl(256);
ggml_critical_section_end();
} | O3 | c | ggml_quantize_free:
pushq %rax
callq 0x17e10
movl $0x10, %edi
callq 0x17450
movl $0x11, %edi
callq 0x17450
movl $0x13, %edi
callq 0x17450
movl $0x100, %edi # imm = 0x100
callq 0x17050
popq %rax
jmp 0x17c00
| ggml_quantize_free:
push rax
call _ggml_critical_section_start
mov edi, 10h
call _iq2xs_free_impl
mov edi, 11h
call _iq2xs_free_impl
mov edi, 13h
call _iq2xs_free_impl
mov edi, 100h
call _iq3xs_free_impl
pop rax
jmp _ggml_critical_section_end
| long long ggml_quantize_free(long long a1)
{
ggml_critical_section_start(a1);
iq2xs_free_impl(16LL);
iq2xs_free_impl(17LL);
iq2xs_free_impl(19LL);
iq3xs_free_impl(256LL);
return ggml_critical_section_end();
}
| ggml_quantize_free:
PUSH RAX
CALL 0x00117e10
MOV EDI,0x10
CALL 0x00117450
MOV EDI,0x11
CALL 0x00117450
MOV EDI,0x13
CALL 0x00117450
MOV EDI,0x100
CALL 0x00117050
POP RAX
JMP 0x00117c00
|
void ggml_quantize_free(void)
{
ggml_critical_section_start();
iq2xs_free_impl(0x10);
iq2xs_free_impl(0x11);
iq2xs_free_impl(0x13);
iq3xs_free_impl(0x100);
ggml_critical_section_end();
return;
}
| |
53,995 | GAParameter8051Addr11::match(GAParserOperand*, int) | goodasm/galang8051.cpp | int GAParameter8051Addr11::match(GAParserOperand *op, int len){
int64_t val=op->uint64(false); //False on a match.
if(op->prefix!=prefix || op->suffix!=suffix)
return 0;
//Reject values that don't fit.
if(((val)&0xF800) != ((2+op->goodasm->address())&0xf800)){
op->goodasm->error("8051 ADDR11 is out of range.");
return 0;
}
return 1;
} | O0 | cpp | GAParameter8051Addr11::match(GAParserOperand*, int):
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x360a0
movq -0x58(%rbp), %rsi
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
addq $0x8, %rsi
callq 0x53180
testb $0x1, %al
jne 0x841da
movq -0x58(%rbp), %rsi
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
addq $0x20, %rsi
callq 0x53180
testb $0x1, %al
jne 0x841da
jmp 0x841e6
movl $0x0, -0x4(%rbp)
jmp 0x84277
movq -0x28(%rbp), %rax
andq $0xf800, %rax # imm = 0xF800
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x16cd0
movq %rax, %rcx
movq -0x60(%rbp), %rax
addq $0x2, %rcx
andq $0xf800, %rcx # imm = 0xF800
cmpq %rcx, %rax
je 0x84270
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x70(%rbp)
leaq 0x93048(%rip), %rsi # 0x117273
leaq -0x40(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xe710
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x13870
jmp 0x84247
leaq -0x40(%rbp), %rdi
callq 0xe770
movl $0x0, -0x4(%rbp)
jmp 0x84277
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xe770
jmp 0x84280
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x7210
nopl (%rax)
| _ZN21GAParameter8051Addr115matchEP15GAParserOperandi:
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov rax, [rbp+var_10]
mov [rbp+var_58], rax
mov rdi, [rbp+var_18]; this
xor esi, esi; bool
call _ZN15GAParserOperand6uint64Eb; GAParserOperand::uint64(bool)
mov rsi, [rbp+var_58]
mov [rbp+var_28], rax
mov rdi, [rbp+var_18]
add rsi, 8
call _ZneRK7QStringS1_; operator!=(QString const&,QString const&)
test al, 1
jnz short loc_841DA
mov rsi, [rbp+var_58]
mov rdi, [rbp+var_18]
add rdi, 30h ; '0'
add rsi, 20h ; ' '
call _ZneRK7QStringS1_; operator!=(QString const&,QString const&)
test al, 1
jnz short loc_841DA
jmp short loc_841E6
loc_841DA:
mov [rbp+var_4], 0
jmp loc_84277
loc_841E6:
mov rax, [rbp+var_28]
and rax, 0F800h
mov [rbp+var_60], rax
mov rax, [rbp+var_18]
mov rdi, [rax+48h]; this
call _ZN7GoodASM7addressEv; GoodASM::address(void)
mov rcx, rax
mov rax, [rbp+var_60]
add rcx, 2
and rcx, 0F800h
cmp rax, rcx
jz short loc_84270
mov rax, [rbp+var_18]
mov rax, [rax+48h]
mov [rbp+var_70], rax
lea rsi, a8051Addr11IsOu; "8051 ADDR11 is out of range."
lea rdi, [rbp+var_40]; this
mov [rbp+var_68], rdi
call _ZN7QStringC2EPKc; QString::QString(char const*)
mov rdi, [rbp+var_70]
mov rsi, [rbp+var_68]
call _ZN7GoodASM5errorE7QString; GoodASM::error(QString)
jmp short $+2
loc_84247:
lea rdi, [rbp+var_40]; this
call _ZN7QStringD2Ev; QString::~QString()
mov [rbp+var_4], 0
jmp short loc_84277
mov rcx, rax
mov eax, edx
mov [rbp+var_48], rcx
mov [rbp+var_4C], eax
lea rdi, [rbp+var_40]; this
call _ZN7QStringD2Ev; QString::~QString()
jmp short loc_84280
loc_84270:
mov [rbp+var_4], 1
loc_84277:
mov eax, [rbp+var_4]
add rsp, 70h
pop rbp
retn
loc_84280:
mov rdi, [rbp+var_48]
call __Unwind_Resume
| long long GAParameter8051Addr11::match(GAParameter8051Addr11 *this, GAParserOperand *a2, int a3)
{
long long v4; // [rsp+0h] [rbp-70h]
_BYTE v5[24]; // [rsp+30h] [rbp-40h] BYREF
long long v6; // [rsp+48h] [rbp-28h]
int v7; // [rsp+54h] [rbp-1Ch]
GAParserOperand *v8; // [rsp+58h] [rbp-18h]
GAParameter8051Addr11 *v9; // [rsp+60h] [rbp-10h]
v9 = this;
v8 = a2;
v7 = a3;
v6 = GAParserOperand::uint64(a2, 0);
if ( operator!=(a2, (GAParameter8051Addr11 *)((char *)this + 8))
|| operator!=((GAParserOperand *)((char *)v8 + 48), (GAParameter8051Addr11 *)((char *)this + 32)) )
{
return 0;
}
else if ( (v6 & 0xF800) == (((unsigned __int16)GoodASM::address(*((GoodASM **)v8 + 9)) + 2) & 0xF800) )
{
return 1;
}
else
{
v4 = *((_QWORD *)v8 + 9);
QString::QString((QString *)v5, "8051 ADDR11 is out of range.");
GoodASM::error(v4, (long long)v5);
QString::~QString((QString *)v5);
return 0;
}
}
| match:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x58],RAX
MOV RDI,qword ptr [RBP + -0x18]
XOR ESI,ESI
CALL 0x001360a0
MOV RSI,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x18]
ADD RSI,0x8
CALL 0x00153180
TEST AL,0x1
JNZ 0x001841da
MOV RSI,qword ptr [RBP + -0x58]
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x30
ADD RSI,0x20
CALL 0x00153180
TEST AL,0x1
JNZ 0x001841da
JMP 0x001841e6
LAB_001841da:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00184277
LAB_001841e6:
MOV RAX,qword ptr [RBP + -0x28]
AND RAX,0xf800
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x48]
CALL 0x00116cd0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x60]
ADD RCX,0x2
AND RCX,0xf800
CMP RAX,RCX
JZ 0x00184270
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x48]
MOV qword ptr [RBP + -0x70],RAX
LEA RSI,[0x217273]
LEA RDI,[RBP + -0x40]
MOV qword ptr [RBP + -0x68],RDI
CALL 0x0010e710
MOV RDI,qword ptr [RBP + -0x70]
MOV RSI,qword ptr [RBP + -0x68]
LAB_00184240:
CALL 0x00113870
LAB_00184245:
JMP 0x00184247
LAB_00184247:
LEA RDI,[RBP + -0x40]
CALL 0x0010e770
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00184277
LAB_00184270:
MOV dword ptr [RBP + -0x4],0x1
LAB_00184277:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x70
POP RBP
RET
|
/* GAParameter8051Addr11::match(GAParserOperand*, int) */
int4 __thiscall
GAParameter8051Addr11::match(GAParameter8051Addr11 *this,GAParserOperand *param_1,int param_2)
{
GoodASM *pGVar1;
ulong uVar2;
long lVar3;
QString local_48 [24];
ulong local_30;
int local_24;
QString *local_20;
GAParameter8051Addr11 *local_18;
local_24 = param_2;
local_20 = (QString *)param_1;
local_18 = this;
local_30 = GAParserOperand::uint64(param_1,false);
uVar2 = ::operator!=(local_20,(QString *)(this + 8));
if (((uVar2 & 1) == 0) &&
(uVar2 = ::operator!=(local_20 + 0x30,(QString *)(this + 0x20)), (uVar2 & 1) == 0)) {
uVar2 = local_30 & 0xf800;
lVar3 = GoodASM::address(*(GoodASM **)(local_20 + 0x48));
if (uVar2 != (lVar3 + 2U & 0xf800)) {
pGVar1 = *(GoodASM **)(local_20 + 0x48);
QString::QString(local_48,"8051 ADDR11 is out of range.");
/* try { // try from 00184240 to 00184244 has its CatchHandler @ 00184259 */
GoodASM::error(pGVar1,local_48);
QString::~QString(local_48);
return 0;
}
return 1;
}
return 0;
}
| |
53,996 | mi_ft_erase | eloqsql/storage/myisam/ft_update.c | static int _mi_ft_erase(MI_INFO *info, uint keynr, uchar *keybuf,
FT_WORD *wlist, my_off_t filepos)
{
uint key_length, err=0;
DBUG_ENTER("_mi_ft_erase");
for (; wlist->pos; wlist++)
{
key_length=_ft_make_key(info,keynr,keybuf,wlist,filepos);
if (_mi_ck_delete(info,keynr,(uchar*) keybuf,key_length))
err=1;
}
DBUG_RETURN(err);
} | O3 | c | mi_ft_erase:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpq $0x0, (%rcx)
je 0x73ff6
movq %rcx, %r15
movq %rdi, -0x48(%rbp)
movl %esi, -0x2c(%rbp)
movq %rdx, -0x38(%rbp)
xorl %r13d, %r13d
movq %r8, -0x40(%rbp)
movq -0x48(%rbp), %r12
movl -0x2c(%rbp), %ebx
movq -0x38(%rbp), %r14
movq %r12, %rdi
movl %ebx, %esi
movq %r14, %rdx
movq %r15, %rcx
movq -0x40(%rbp), %r8
callq 0x73ee9
movq %r12, %rdi
movl %ebx, %esi
movq %r14, %rdx
movl %eax, %ecx
callq 0x74641
testl %eax, %eax
movl $0x1, %eax
cmovnel %eax, %r13d
cmpq $0x0, 0x18(%r15)
leaq 0x18(%r15), %r15
jne 0x73fbb
jmp 0x73ff9
xorl %r13d, %r13d
movl %r13d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _mi_ft_erase:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
cmp qword ptr [rcx], 0
jz short loc_73FF6
mov r15, rcx
mov [rbp+var_48], rdi
mov [rbp+var_2C], esi
mov [rbp+var_38], rdx
xor r13d, r13d
mov [rbp+var_40], r8
mov r12, [rbp+var_48]
mov ebx, [rbp+var_2C]
mov r14, [rbp+var_38]
loc_73FBB:
mov rdi, r12
mov esi, ebx
mov rdx, r14
mov rcx, r15
mov r8, [rbp+var_40]
call _ft_make_key
mov rdi, r12
mov esi, ebx
mov rdx, r14
mov ecx, eax
call _mi_ck_delete
test eax, eax
mov eax, 1
cmovnz r13d, eax
cmp qword ptr [r15+18h], 0
lea r15, [r15+18h]
jnz short loc_73FBB
jmp short loc_73FF9
loc_73FF6:
xor r13d, r13d
loc_73FF9:
mov eax, r13d
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long mi_ft_erase(long long a1, unsigned int a2, long long a3, _QWORD *a4, long long a5, __m128i a6)
{
long long v6; // r15
unsigned int v7; // r13d
unsigned int key; // eax
bool v10; // zf
if ( *a4 )
{
v6 = (long long)a4;
v7 = 0;
do
{
key = ft_make_key(a1, a2, a3, v6, a5, a6);
if ( (unsigned int)mi_ck_delete(a1, a2, a3, key) )
v7 = 1;
v10 = *(_QWORD *)(v6 + 24) == 0LL;
v6 += 24LL;
}
while ( !v10 );
}
else
{
return 0;
}
return v7;
}
| _mi_ft_erase:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
CMP qword ptr [RCX],0x0
JZ 0x00173ff6
MOV R15,RCX
MOV qword ptr [RBP + -0x48],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV qword ptr [RBP + -0x38],RDX
XOR R13D,R13D
MOV qword ptr [RBP + -0x40],R8
MOV R12,qword ptr [RBP + -0x48]
MOV EBX,dword ptr [RBP + -0x2c]
MOV R14,qword ptr [RBP + -0x38]
LAB_00173fbb:
MOV RDI,R12
MOV ESI,EBX
MOV RDX,R14
MOV RCX,R15
MOV R8,qword ptr [RBP + -0x40]
CALL 0x00173ee9
MOV RDI,R12
MOV ESI,EBX
MOV RDX,R14
MOV ECX,EAX
CALL 0x00174641
TEST EAX,EAX
MOV EAX,0x1
CMOVNZ R13D,EAX
CMP qword ptr [R15 + 0x18],0x0
LEA R15,[R15 + 0x18]
JNZ 0x00173fbb
JMP 0x00173ff9
LAB_00173ff6:
XOR R13D,R13D
LAB_00173ff9:
MOV EAX,R13D
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int4
_mi_ft_erase(int8 param_1,int4 param_2,int8 param_3,long *param_4,
int8 param_5)
{
long *plVar1;
int4 uVar2;
int iVar3;
int4 uVar4;
if (*param_4 == 0) {
uVar4 = 0;
}
else {
uVar4 = 0;
do {
uVar2 = _ft_make_key(param_1,param_2,param_3,param_4,param_5);
iVar3 = _mi_ck_delete(param_1,param_2,param_3,uVar2);
if (iVar3 != 0) {
uVar4 = 1;
}
plVar1 = param_4 + 3;
param_4 = param_4 + 3;
} while (*plVar1 != 0);
}
return uVar4;
}
| |
53,997 | task_process(Task*) | untodesu[P]voxelius/game/shared/threading.cc | static void task_process(Task *task)
{
task->set_status(task_status::PROCESSING);
task->process();
if(task->get_status() == task_status::PROCESSING) {
// If the task status is still PROCESSING
// it can be deduced it hasn't been cancelled
task->set_status(task_status::COMPLETED);
}
} | O0 | cpp | task_process(Task*):
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x16c3b0
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x8(%rbp), %rdi
callq 0x16c390
cmpl $0x1, %eax
jne 0x16c9a0
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x16c3b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZL12task_processP4Task:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]
mov esi, 1
call _ZN4Task10set_statusE11task_status; Task::set_status(task_status)
mov rdi, [rbp+var_8]
mov rax, [rdi]
call qword ptr [rax+10h]
mov rdi, [rbp+var_8]; this
call _ZNK4Task10get_statusEv; Task::get_status(void)
cmp eax, 1
jnz short loc_16C9A0
mov rdi, [rbp+var_8]
mov esi, 2
call _ZN4Task10set_statusE11task_status; Task::set_status(task_status)
loc_16C9A0:
add rsp, 10h
pop rbp
retn
| long long task_process(Task *a1)
{
long long result; // rax
Task::set_status((long long)a1, 1u);
(*(void ( **)(Task *))(*(_QWORD *)a1 + 16LL))(a1);
result = Task::get_status(a1);
if ( (_DWORD)result == 1 )
return Task::set_status((long long)a1, 2u);
return result;
}
| |||
53,998 | task_process(Task*) | untodesu[P]voxelius/game/shared/threading.cc | static void task_process(Task *task)
{
task->set_status(task_status::PROCESSING);
task->process();
if(task->get_status() == task_status::PROCESSING) {
// If the task status is still PROCESSING
// it can be deduced it hasn't been cancelled
task->set_status(task_status::COMPLETED);
}
} | O1 | cpp | task_process(Task*):
pushq %rbx
movq %rdi, %rbx
movl $0x1, %eax
xchgl %eax, 0x8(%rdi)
movq (%rdi), %rax
callq *0x10(%rax)
movl 0x8(%rbx), %eax
cmpl $0x1, %eax
jne 0x7f3b3
movl $0x2, %eax
xchgl %eax, 0x8(%rbx)
popq %rbx
retq
nop
| _ZL12task_processP4Task:
push rbx
mov rbx, rdi
mov eax, 1
xchg eax, [rdi+8]
mov rax, [rdi]
call qword ptr [rax+10h]
mov eax, [rbx+8]
cmp eax, 1
jnz short loc_7F3B3
mov eax, 2
xchg eax, [rbx+8]
loc_7F3B3:
pop rbx
retn
| long long task_process(Task *a1)
{
long long result; // rax
_InterlockedExchange((volatile __int32 *)a1 + 2, 1);
(*(void ( **)(Task *))(*(_QWORD *)a1 + 16LL))(a1);
result = *((unsigned int *)a1 + 2);
if ( (_DWORD)result == 1 )
return (unsigned int)_InterlockedExchange((volatile __int32 *)a1 + 2, 2);
return result;
}
| task_process:
PUSH RBX
MOV RBX,RDI
MOV EAX,0x1
XCHG dword ptr [RDI + 0x8],EAX
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x10]
MOV EAX,dword ptr [RBX + 0x8]
CMP EAX,0x1
JNZ 0x0017f3b3
MOV EAX,0x2
XCHG dword ptr [RBX + 0x8],EAX
LAB_0017f3b3:
POP RBX
RET
|
/* task_process(Task*) */
int task_process(Task *param_1)
{
int iVar1;
LOCK();
*(int4 *)(param_1 + 8) = 1;
UNLOCK();
(**(code **)(*(long *)param_1 + 0x10))();
iVar1 = *(int *)(param_1 + 8);
if (iVar1 == 1) {
LOCK();
iVar1 = *(int *)(param_1 + 8);
*(int *)(param_1 + 8) = 2;
UNLOCK();
}
return iVar1;
}
| |
53,999 | mi_update_status | eloqsql/storage/myisam/mi_locking.c | void mi_update_status(void* param)
{
MI_INFO *info=(MI_INFO*) param;
DBUG_ENTER("mi_update_status");
/*
Because someone may have closed the table we point at, we only
update the state if its our own state. This isn't a problem as
we are always pointing at our own lock or at a read lock.
(This is enforced by thr_multi_lock.c)
*/
if (info->state == &info->save_state)
{
DBUG_PRINT("info",
("updating status: key_file: %lu data_file: %lu rows: %lu",
(ulong) info->state->key_file_length,
(ulong) info->state->data_file_length,
(ulong) info->state->records));
if (info->state->key_file_length < info->s->state.state.key_file_length ||
info->state->data_file_length < info->s->state.state.data_file_length)
DBUG_PRINT("warning",("old info: key_file: %ld data_file: %ld",
(long) info->s->state.state.key_file_length,
(long) info->s->state.state.data_file_length));
info->s->state.state= *info->state;
#ifdef HAVE_QUERY_CACHE
DBUG_PRINT("info", ("invalidator... '%s' (status update)",
info->filename));
DBUG_ASSERT(info->s->chst_invalidator != NULL);
(*info->s->chst_invalidator)((const char *)info->filename);
#endif
}
info->state= &info->s->state.state;
info->append_insert_at_end= 0;
/*
We have to flush the write cache here as other threads may start
reading the table before mi_lock_database() is called
*/
if (info->opt_flag & WRITE_CACHE_USED)
{
if (end_io_cache(&info->rec_cache))
{
mi_print_error(info->s, HA_ERR_CRASHED);
mi_mark_crashed(info);
}
info->opt_flag&= ~WRITE_CACHE_USED;
}
DBUG_VOID_RETURN;
} | O3 | c | mi_update_status:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
leaq 0x10(%rdi), %rcx
cmpq %rcx, %rax
jne 0x7c72e
movq (%rbx), %rcx
movq 0x30(%rax), %rdx
movq %rdx, 0x48(%rcx)
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups %xmm2, 0x38(%rcx)
movups %xmm1, 0x28(%rcx)
movups %xmm0, 0x18(%rcx)
movq (%rbx), %rax
movq 0xf8(%rbx), %rdi
callq *0x2f8(%rax)
movq (%rbx), %rax
addq $0x18, %rax
movq %rax, 0x8(%rbx)
movb $0x0, 0x33a(%rbx)
testb $0x10, 0x1c8(%rbx)
je 0x7c794
leaq 0x220(%rbx), %rdi
callq 0x964df
testl %eax, %eax
je 0x7c78d
movq (%rbx), %rax
movq 0x268(%rax), %rsi
movl $0x7e, %edi
callq 0x7af26
movq (%rbx), %rax
orb $0x2, 0xf0(%rax)
leaq 0x5f4f5(%rip), %rdx # 0xdbc73
movq %rbx, %rdi
xorl %esi, %esi
movl $0x164, %ecx # imm = 0x164
callq 0x30c4b
andb $-0x11, 0x1c8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| mi_update_status:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
mov rax, [rdi+8]
lea rcx, [rdi+10h]
cmp rax, rcx
jnz short loc_7C72E
mov rcx, [rbx]
mov rdx, [rax+30h]
mov [rcx+48h], rdx
movups xmm0, xmmword ptr [rax]
movups xmm1, xmmword ptr [rax+10h]
movups xmm2, xmmword ptr [rax+20h]
movups xmmword ptr [rcx+38h], xmm2
movups xmmword ptr [rcx+28h], xmm1
movups xmmword ptr [rcx+18h], xmm0
mov rax, [rbx]
mov rdi, [rbx+0F8h]
call qword ptr [rax+2F8h]
loc_7C72E:
mov rax, [rbx]
add rax, 18h
mov [rbx+8], rax
mov byte ptr [rbx+33Ah], 0
test byte ptr [rbx+1C8h], 10h
jz short loc_7C794
lea rdi, [rbx+220h]
call end_io_cache
test eax, eax
jz short loc_7C78D
mov rax, [rbx]
mov rsi, [rax+268h]
mov edi, 7Eh ; '~'
call mi_report_error
mov rax, [rbx]
or byte ptr [rax+0F0h], 2
lea rdx, aWorkspaceLlm4b_15; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, rbx
xor esi, esi
mov ecx, 164h
call _mi_report_crashed
loc_7C78D:
and byte ptr [rbx+1C8h], 0EFh
loc_7C794:
add rsp, 8
pop rbx
pop rbp
retn
| void mi_update_status(_BYTE *a1)
{
__int128 *v1; // rax
long long v2; // rcx
__int128 v3; // xmm0
__int128 v4; // xmm1
v1 = (__int128 *)*((_QWORD *)a1 + 1);
if ( v1 == (__int128 *)(a1 + 16) )
{
v2 = *(_QWORD *)a1;
*(_QWORD *)(v2 + 72) = *((_QWORD *)v1 + 6);
v3 = *v1;
v4 = v1[1];
*(_OWORD *)(v2 + 56) = v1[2];
*(_OWORD *)(v2 + 40) = v4;
*(_OWORD *)(v2 + 24) = v3;
(*(void ( **)(_QWORD))(*(_QWORD *)a1 + 760LL))(*((_QWORD *)a1 + 31));
}
*((_QWORD *)a1 + 1) = *(_QWORD *)a1 + 24LL;
a1[826] = 0;
if ( (a1[456] & 0x10) != 0 )
{
if ( (unsigned int)end_io_cache(a1 + 544) )
{
mi_report_error(126, *(_QWORD *)(*(_QWORD *)a1 + 616LL));
*(_BYTE *)(*(_QWORD *)a1 + 240LL) |= 2u;
mi_report_crashed();
}
a1[456] &= ~0x10u;
}
}
| mi_update_status:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x8]
LEA RCX,[RDI + 0x10]
CMP RAX,RCX
JNZ 0x0017c72e
MOV RCX,qword ptr [RBX]
MOV RDX,qword ptr [RAX + 0x30]
MOV qword ptr [RCX + 0x48],RDX
MOVUPS XMM0,xmmword ptr [RAX]
MOVUPS XMM1,xmmword ptr [RAX + 0x10]
MOVUPS XMM2,xmmword ptr [RAX + 0x20]
MOVUPS xmmword ptr [RCX + 0x38],XMM2
MOVUPS xmmword ptr [RCX + 0x28],XMM1
MOVUPS xmmword ptr [RCX + 0x18],XMM0
MOV RAX,qword ptr [RBX]
MOV RDI,qword ptr [RBX + 0xf8]
CALL qword ptr [RAX + 0x2f8]
LAB_0017c72e:
MOV RAX,qword ptr [RBX]
ADD RAX,0x18
MOV qword ptr [RBX + 0x8],RAX
MOV byte ptr [RBX + 0x33a],0x0
TEST byte ptr [RBX + 0x1c8],0x10
JZ 0x0017c794
LEA RDI,[RBX + 0x220]
CALL 0x001964df
TEST EAX,EAX
JZ 0x0017c78d
MOV RAX,qword ptr [RBX]
MOV RSI,qword ptr [RAX + 0x268]
MOV EDI,0x7e
CALL 0x0017af26
MOV RAX,qword ptr [RBX]
OR byte ptr [RAX + 0xf0],0x2
LEA RDX,[0x1dbc73]
MOV RDI,RBX
XOR ESI,ESI
MOV ECX,0x164
CALL 0x00130c4b
LAB_0017c78d:
AND byte ptr [RBX + 0x1c8],0xef
LAB_0017c794:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void mi_update_status(long *param_1)
{
long *plVar1;
long lVar2;
int4 uVar3;
int4 uVar4;
int4 uVar5;
int4 uVar6;
int4 uVar7;
int4 uVar8;
long lVar9;
long lVar10;
long lVar11;
long lVar12;
long lVar13;
int iVar14;
plVar1 = (long *)param_1[1];
if (plVar1 == param_1 + 2) {
lVar2 = *param_1;
*(long *)(lVar2 + 0x48) = plVar1[6];
lVar9 = *plVar1;
uVar3 = *(int4 *)((long)plVar1 + 4);
lVar10 = plVar1[1];
uVar4 = *(int4 *)((long)plVar1 + 0xc);
lVar11 = plVar1[2];
uVar5 = *(int4 *)((long)plVar1 + 0x14);
lVar12 = plVar1[3];
uVar6 = *(int4 *)((long)plVar1 + 0x1c);
uVar7 = *(int4 *)((long)plVar1 + 0x24);
lVar13 = plVar1[5];
uVar8 = *(int4 *)((long)plVar1 + 0x2c);
*(int *)(lVar2 + 0x38) = (int)plVar1[4];
*(int4 *)(lVar2 + 0x3c) = uVar7;
*(int *)(lVar2 + 0x40) = (int)lVar13;
*(int4 *)(lVar2 + 0x44) = uVar8;
*(int *)(lVar2 + 0x28) = (int)lVar11;
*(int4 *)(lVar2 + 0x2c) = uVar5;
*(int *)(lVar2 + 0x30) = (int)lVar12;
*(int4 *)(lVar2 + 0x34) = uVar6;
*(int *)(lVar2 + 0x18) = (int)lVar9;
*(int4 *)(lVar2 + 0x1c) = uVar3;
*(int *)(lVar2 + 0x20) = (int)lVar10;
*(int4 *)(lVar2 + 0x24) = uVar4;
(**(code **)(*param_1 + 0x2f8))(param_1[0x1f]);
}
param_1[1] = *param_1 + 0x18;
*(int1 *)((long)param_1 + 0x33a) = 0;
if ((*(byte *)(param_1 + 0x39) & 0x10) != 0) {
iVar14 = end_io_cache(param_1 + 0x44);
if (iVar14 != 0) {
mi_report_error(0x7e,*(int8 *)(*param_1 + 0x268));
*(byte *)(*param_1 + 0xf0) = *(byte *)(*param_1 + 0xf0) | 2;
_mi_report_crashed(param_1,0,
"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_locking.c",
0x164);
}
*(byte *)(param_1 + 0x39) = *(byte *)(param_1 + 0x39) & 0xef;
}
return;
}
|
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.