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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
52,900 | re_parse_disjunction | bluesky950520[P]quickjs/libregexp.c | static int re_parse_disjunction(REParseState *s, BOOL is_backward_dir)
{
int start, len, pos;
if (lre_check_stack_overflow(s->opaque, 0))
return re_parse_error(s, "stack overflow");
start = s->byte_code.size;
if (re_parse_alternative(s, is_backward_dir))
return -1;
while (*s->buf_ptr == '|') {
s->buf_ptr++;
len = s->byte_code.size - start;
/* insert a split before the first alternative */
if (dbuf_insert(&s->byte_code, start, 5)) {
return re_parse_out_of_memory(s);
}
s->byte_code.buf[start] = REOP_split_next_first;
put_u32(s->byte_code.buf + start + 1, len + 5);
pos = re_emit_op_u32(s, REOP_goto, 0);
if (re_parse_alternative(s, is_backward_dir))
return -1;
/* patch the goto */
len = s->byte_code.size - (pos + 4);
put_u32(s->byte_code.buf + pos, len);
}
return 0;
} | O0 | c | re_parse_disjunction:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq 0x68(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x53fa0
cmpl $0x0, %eax
je 0x103bb0
movq 0x18(%rsp), %rdi
leaq 0x14f33(%rip), %rsi # 0x118ad3
movb $0x0, %al
callq 0x103d00
movl %eax, 0x24(%rsp)
jmp 0x103ce8
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x1065b0
cmpl $0x0, %eax
je 0x103bdd
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x103ce8
jmp 0x103bdf
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rax
movzbl (%rax), %eax
cmpl $0x7c, %eax
jne 0x103ce0
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rax)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x10(%rsp), %rcx
subq %rcx, %rax
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movl 0x10(%rsp), %esi
movl $0x5, %edx
callq 0x1066f0
cmpl $0x0, %eax
je 0x103c45
movq 0x18(%rsp), %rdi
callq 0x103de0
movl %eax, 0x24(%rsp)
jmp 0x103ce8
movq 0x18(%rsp), %rax
movq (%rax), %rax
movslq 0x10(%rsp), %rcx
movb $0xa, (%rax,%rcx)
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movslq 0x10(%rsp), %rax
addq %rax, %rdi
addq $0x1, %rdi
movl 0xc(%rsp), %esi
addl $0x5, %esi
callq 0x103f60
movq 0x18(%rsp), %rdi
movl $0x8, %esi
xorl %edx, %edx
callq 0x103ab0
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x1065b0
cmpl $0x0, %eax
je 0x103ca8
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x103ce8
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rsp), %ecx
addl $0x4, %ecx
movslq %ecx, %rcx
subq %rcx, %rax
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movslq 0x8(%rsp), %rax
addq %rax, %rdi
movl 0xc(%rsp), %esi
callq 0x103f60
jmp 0x103bdf
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
| re_parse_disjunction:
sub rsp, 28h
mov [rsp+28h+var_10], rdi
mov [rsp+28h+var_14], esi
mov rax, [rsp+28h+var_10]
mov rdi, [rax+68h]
xor eax, eax
mov esi, eax
call lre_check_stack_overflow
cmp eax, 0
jz short loc_103BB0
mov rdi, [rsp+28h+var_10]
lea rsi, aStackOverflow; "stack overflow"
mov al, 0
call re_parse_error
mov [rsp+28h+var_4], eax
jmp loc_103CE8
loc_103BB0:
mov rax, [rsp+28h+var_10]
mov rax, [rax+8]
mov [rsp+28h+var_18], eax
mov rdi, [rsp+28h+var_10]
mov esi, [rsp+28h+var_14]
call re_parse_alternative
cmp eax, 0
jz short loc_103BDD
mov [rsp+28h+var_4], 0FFFFFFFFh
jmp loc_103CE8
loc_103BDD:
jmp short $+2
loc_103BDF:
mov rax, [rsp+28h+var_10]
mov rax, [rax+30h]
movzx eax, byte ptr [rax]
cmp eax, 7Ch ; '|'
jnz loc_103CE0
mov rax, [rsp+28h+var_10]
mov rcx, [rax+30h]
add rcx, 1
mov [rax+30h], rcx
mov rax, [rsp+28h+var_10]
mov rax, [rax+8]
movsxd rcx, [rsp+28h+var_18]
sub rax, rcx
mov [rsp+28h+var_1C], eax
mov rdi, [rsp+28h+var_10]
mov esi, [rsp+28h+var_18]
mov edx, 5
call dbuf_insert
cmp eax, 0
jz short loc_103C45
mov rdi, [rsp+28h+var_10]
call re_parse_out_of_memory
mov [rsp+28h+var_4], eax
jmp loc_103CE8
loc_103C45:
mov rax, [rsp+28h+var_10]
mov rax, [rax]
movsxd rcx, [rsp+28h+var_18]
mov byte ptr [rax+rcx], 0Ah
mov rax, [rsp+28h+var_10]
mov rdi, [rax]
movsxd rax, [rsp+28h+var_18]
add rdi, rax
add rdi, 1
mov esi, [rsp+28h+var_1C]
add esi, 5
call put_u32_0
mov rdi, [rsp+28h+var_10]
mov esi, 8
xor edx, edx
call re_emit_op_u32
mov [rsp+28h+var_20], eax
mov rdi, [rsp+28h+var_10]
mov esi, [rsp+28h+var_14]
call re_parse_alternative
cmp eax, 0
jz short loc_103CA8
mov [rsp+28h+var_4], 0FFFFFFFFh
jmp short loc_103CE8
loc_103CA8:
mov rax, [rsp+28h+var_10]
mov rax, [rax+8]
mov ecx, [rsp+28h+var_20]
add ecx, 4
movsxd rcx, ecx
sub rax, rcx
mov [rsp+28h+var_1C], eax
mov rax, [rsp+28h+var_10]
mov rdi, [rax]
movsxd rax, [rsp+28h+var_20]
add rdi, rax
mov esi, [rsp+28h+var_1C]
call put_u32_0
jmp loc_103BDF
loc_103CE0:
mov [rsp+28h+var_4], 0
loc_103CE8:
mov eax, [rsp+28h+var_4]
add rsp, 28h
retn
| long long re_parse_disjunction(_QWORD *a1, unsigned int a2)
{
int v2; // edx
int v3; // ecx
int v4; // r8d
int v5; // r9d
int v7; // [rsp+8h] [rbp-20h]
int v8; // [rsp+Ch] [rbp-1Ch]
unsigned int v9; // [rsp+10h] [rbp-18h]
if ( (unsigned int)lre_check_stack_overflow(a1[13], 0LL) )
{
return (unsigned int)re_parse_error((_DWORD)a1, (unsigned int)"stack overflow", v2, v3, v4, v5);
}
else
{
v9 = a1[1];
if ( (unsigned int)re_parse_alternative(a1, a2) )
{
return (unsigned int)-1;
}
else
{
while ( *(_BYTE *)a1[6] == 124 )
{
++a1[6];
v8 = a1[1] - v9;
if ( (unsigned int)dbuf_insert(a1, v9, 5LL) )
return (unsigned int)re_parse_out_of_memory(a1);
*(_BYTE *)(*a1 + (int)v9) = 10;
put_u32_0((int)v9 + *a1 + 1LL, (unsigned int)(v8 + 5));
v7 = re_emit_op_u32(a1, 8, 0);
if ( (unsigned int)re_parse_alternative(a1, a2) )
return (unsigned int)-1;
put_u32_0(v7 + *a1, (unsigned int)a1[1] - (v7 + 4));
}
return 0;
}
}
}
| |||
52,901 | re_parse_disjunction | bluesky950520[P]quickjs/libregexp.c | static int re_parse_disjunction(REParseState *s, BOOL is_backward_dir)
{
int start, len, pos;
if (lre_check_stack_overflow(s->opaque, 0))
return re_parse_error(s, "stack overflow");
start = s->byte_code.size;
if (re_parse_alternative(s, is_backward_dir))
return -1;
while (*s->buf_ptr == '|') {
s->buf_ptr++;
len = s->byte_code.size - start;
/* insert a split before the first alternative */
if (dbuf_insert(&s->byte_code, start, 5)) {
return re_parse_out_of_memory(s);
}
s->byte_code.buf[start] = REOP_split_next_first;
put_u32(s->byte_code.buf + start + 1, len + 5);
pos = re_emit_op_u32(s, REOP_goto, 0);
if (re_parse_alternative(s, is_backward_dir))
return -1;
/* patch the goto */
len = s->byte_code.size - (pos + 4);
put_u32(s->byte_code.buf + pos, len);
}
return 0;
} | O3 | c | re_parse_disjunction:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
movq 0x68(%rdi), %rdi
xorl %esi, %esi
callq 0x38387
testl %eax, %eax
je 0x9b69a
leaq 0xefdb(%rip), %rsi # 0xaa661
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9b77b
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
jmp 0x9b76a
movq 0x8(%rbx), %r15
movq %rbx, %rdi
movl %r14d, %esi
callq 0x9c949
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x9b76a
movq 0x30(%rbx), %rax
cmpb $0x7c, (%rax)
jne 0x9b755
movslq %r15d, %r13
incq %rax
movq %rax, 0x30(%rbx)
movq 0x8(%rbx), %r12
movq %rbx, %rdi
movl %r15d, %esi
movl $0x5, %edx
callq 0x9dcf9
testl %eax, %eax
jne 0x9b759
subl %r15d, %r12d
movq (%rbx), %rax
movb $0xa, (%rax,%r13)
movq (%rbx), %rax
addl $0x5, %r12d
movl %r12d, 0x1(%rax,%r13)
movq %rbx, %rdi
movl $0x8, %esi
callq 0x1fe0d
movq 0x8(%rbx), %r12
movl $0x0, 0x4(%rsp)
movl $0x4, %edx
movq %rbx, %rdi
leaq 0x4(%rsp), %rsi
callq 0x1fd5e
movq %rbx, %rdi
movl %r14d, %esi
callq 0x9c949
testl %eax, %eax
jne 0x9b76a
movl 0x8(%rbx), %eax
subl %r12d, %eax
addl $-0x4, %eax
movq (%rbx), %rcx
movslq %r12d, %rdx
movl %eax, (%rcx,%rdx)
movq 0x30(%rbx), %rax
cmpb $0x7c, (%rax)
je 0x9b6c6
xorl %ebp, %ebp
jmp 0x9b76a
leaq 0xa728(%rip), %rsi # 0xa5e88
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9b77b
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| re_parse_disjunction:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14d, esi
mov rbx, rdi
mov rdi, [rdi+68h]
xor esi, esi
call lre_check_stack_overflow
test eax, eax
jz short loc_9B69A
lea rsi, aStackOverflow; "stack overflow"
mov rdi, rbx
xor eax, eax
call re_parse_error
mov ebp, 0FFFFFFFFh
jmp loc_9B76A
loc_9B69A:
mov r15, [rbx+8]
mov rdi, rbx
mov esi, r14d
call re_parse_alternative
mov ebp, 0FFFFFFFFh
test eax, eax
jnz loc_9B76A
mov rax, [rbx+30h]
cmp byte ptr [rax], 7Ch ; '|'
jnz loc_9B755
movsxd r13, r15d
loc_9B6C6:
inc rax
mov [rbx+30h], rax
mov r12, [rbx+8]
mov rdi, rbx
mov esi, r15d
mov edx, 5
call dbuf_insert
test eax, eax
jnz short loc_9B759
sub r12d, r15d
mov rax, [rbx]
mov byte ptr [rax+r13], 0Ah
mov rax, [rbx]
add r12d, 5
mov [rax+r13+1], r12d
mov rdi, rbx
mov esi, 8
call dbuf_putc
mov r12, [rbx+8]
mov [rsp+38h+var_34], 0
mov edx, 4
mov rdi, rbx
lea rsi, [rsp+38h+var_34]
call dbuf_put
mov rdi, rbx
mov esi, r14d
call re_parse_alternative
test eax, eax
jnz short loc_9B76A
mov eax, [rbx+8]
sub eax, r12d
add eax, 0FFFFFFFCh
mov rcx, [rbx]
movsxd rdx, r12d
mov [rcx+rdx], eax
mov rax, [rbx+30h]
cmp byte ptr [rax], 7Ch ; '|'
jz loc_9B6C6
loc_9B755:
xor ebp, ebp
jmp short loc_9B76A
loc_9B759:
lea rsi, aOutOfMemory; "out of memory"
mov rdi, rbx
xor eax, eax
call re_parse_error
loc_9B76A:
mov eax, ebp
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long re_parse_disjunction(_QWORD *a1, unsigned int a2)
{
long long v2; // rax
int v3; // edx
int v4; // ecx
int v5; // r8d
int v6; // r9d
unsigned int v7; // ebp
long long v8; // r15
_BYTE *v9; // rax
long long v10; // r12
int v11; // edx
int v12; // ecx
int v13; // r8d
int v14; // r9d
long long v15; // r12
_DWORD v17[13]; // [rsp+0h] [rbp-34h] BYREF
v17[0] = HIDWORD(v2);
if ( lre_check_stack_overflow(a1[13], 0LL) )
{
re_parse_error((_DWORD)a1, (unsigned int)"stack overflow", v3, v4, v5, v6);
return (unsigned int)-1;
}
else
{
v8 = a1[1];
v7 = -1;
if ( !(unsigned int)re_parse_alternative(a1, a2) )
{
v9 = (_BYTE *)a1[6];
if ( *v9 == 124 )
{
while ( 1 )
{
a1[6] = v9 + 1;
v10 = a1[1];
if ( (unsigned int)dbuf_insert(a1, (unsigned int)v8, 5LL) )
break;
*(_BYTE *)(*a1 + (int)v8) = 10;
*(_DWORD *)(*a1 + (int)v8 + 1LL) = v10 - v8 + 5;
dbuf_putc(a1, 8);
v15 = a1[1];
v17[0] = 0;
dbuf_put(a1, (long long)v17, 4LL);
if ( (unsigned int)re_parse_alternative(a1, a2) )
return v7;
*(_DWORD *)(*a1 + (int)v15) = *((_DWORD *)a1 + 2) - v15 - 4;
v9 = (_BYTE *)a1[6];
if ( *v9 != 124 )
return 0;
}
re_parse_error((_DWORD)a1, (unsigned int)"out of memory", v11, v12, v13, v14);
}
else
{
return 0;
}
}
}
return v7;
}
| re_parse_disjunction:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14D,ESI
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x68]
XOR ESI,ESI
CALL 0x00138387
TEST EAX,EAX
JZ 0x0019b69a
LEA RSI,[0x1aa661]
MOV RDI,RBX
XOR EAX,EAX
CALL 0x0019b77b
MOV EBP,0xffffffff
JMP 0x0019b76a
LAB_0019b69a:
MOV R15,qword ptr [RBX + 0x8]
MOV RDI,RBX
MOV ESI,R14D
CALL 0x0019c949
MOV EBP,0xffffffff
TEST EAX,EAX
JNZ 0x0019b76a
MOV RAX,qword ptr [RBX + 0x30]
CMP byte ptr [RAX],0x7c
JNZ 0x0019b755
MOVSXD R13,R15D
LAB_0019b6c6:
INC RAX
MOV qword ptr [RBX + 0x30],RAX
MOV R12,qword ptr [RBX + 0x8]
MOV RDI,RBX
MOV ESI,R15D
MOV EDX,0x5
CALL 0x0019dcf9
TEST EAX,EAX
JNZ 0x0019b759
SUB R12D,R15D
MOV RAX,qword ptr [RBX]
MOV byte ptr [RAX + R13*0x1],0xa
MOV RAX,qword ptr [RBX]
ADD R12D,0x5
MOV dword ptr [RAX + R13*0x1 + 0x1],R12D
MOV RDI,RBX
MOV ESI,0x8
CALL 0x0011fe0d
MOV R12,qword ptr [RBX + 0x8]
MOV dword ptr [RSP + 0x4],0x0
MOV EDX,0x4
MOV RDI,RBX
LEA RSI,[RSP + 0x4]
CALL 0x0011fd5e
MOV RDI,RBX
MOV ESI,R14D
CALL 0x0019c949
TEST EAX,EAX
JNZ 0x0019b76a
MOV EAX,dword ptr [RBX + 0x8]
SUB EAX,R12D
ADD EAX,-0x4
MOV RCX,qword ptr [RBX]
MOVSXD RDX,R12D
MOV dword ptr [RCX + RDX*0x1],EAX
MOV RAX,qword ptr [RBX + 0x30]
CMP byte ptr [RAX],0x7c
JZ 0x0019b6c6
LAB_0019b755:
XOR EBP,EBP
JMP 0x0019b76a
LAB_0019b759:
LEA RSI,[0x1a5e88]
MOV RDI,RBX
XOR EAX,EAX
CALL 0x0019b77b
LAB_0019b76a:
MOV EAX,EBP
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 re_parse_disjunction(long *param_1,int4 param_2)
{
ulong uVar1;
long lVar2;
int iVar3;
int iVar4;
ulong in_RAX;
char *pcVar5;
int8 uVar6;
int8 uStack_38;
uStack_38 = in_RAX;
iVar3 = lre_check_stack_overflow(param_1[0xd],0);
if (iVar3 == 0) {
uVar1 = param_1[1];
iVar3 = re_parse_alternative(param_1,param_2);
uVar6 = 0xffffffff;
if (iVar3 == 0) {
pcVar5 = (char *)param_1[6];
if (*pcVar5 == '|') {
iVar3 = (int)uVar1;
do {
param_1[6] = (long)(pcVar5 + 1);
lVar2 = param_1[1];
iVar4 = dbuf_insert(param_1,uVar1 & 0xffffffff,5);
if (iVar4 != 0) {
re_parse_error(param_1,"out of memory");
return 0xffffffff;
}
*(int1 *)(*param_1 + (long)iVar3) = 10;
*(int *)(*param_1 + 1 + (long)iVar3) = ((int)lVar2 - iVar3) + 5;
dbuf_putc(param_1,8);
lVar2 = param_1[1];
uStack_38 = uStack_38 & 0xffffffff;
dbuf_put(param_1,(long)&uStack_38 + 4,4);
iVar4 = re_parse_alternative(param_1,param_2);
if (iVar4 != 0) {
return 0xffffffff;
}
*(int *)(*param_1 + (long)(int)lVar2) = ((int)param_1[1] - (int)lVar2) + -4;
pcVar5 = (char *)param_1[6];
} while (*pcVar5 == '|');
}
uVar6 = 0;
}
}
else {
re_parse_error(param_1,"stack overflow");
uVar6 = 0xffffffff;
}
return uVar6;
}
| |
52,902 | ma_reset_state | eloqsql/storage/maria/ma_state.c | void _ma_reset_state(MARIA_HA *info)
{
MARIA_SHARE *share= info->s;
MARIA_STATE_HISTORY *history= share->state_history;
DBUG_ENTER("_ma_reset_state");
/* Always true if share->now_transactional is set */
if (history && share->have_versioning)
{
MARIA_STATE_HISTORY *next;
DBUG_PRINT("info", ("resetting history"));
/* Set the current history to current state */
share->state_history->state= share->state.state;
/* Set current table handler to point to new history state */
info->state= info->state_start= &share->state_history->state;
for (history= history->next ; history ; history= next)
{
next= history->next;
my_free(history);
}
share->state_history->next= 0;
share->state_history->trid= 0; /* Visible for all */
}
DBUG_VOID_RETURN;
} | O3 | c | ma_reset_state:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq (%rdi), %rbx
movq 0x450(%rbx), %rax
testq %rax, %rax
je 0x45f6d
cmpb $0x0, 0x7e8(%rbx)
je 0x45f6d
movq 0x48(%rbx), %rcx
movq %rcx, 0x40(%rax)
movups 0x18(%rbx), %xmm0
movups 0x28(%rbx), %xmm1
movups 0x38(%rbx), %xmm2
movups %xmm2, 0x30(%rax)
movups %xmm1, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movq 0x450(%rbx), %rcx
addq $0x10, %rcx
movq %rcx, 0x60(%rdi)
movq %rcx, 0x20(%rdi)
movq (%rax), %rdi
testq %rdi, %rdi
je 0x45f56
movq (%rdi), %r14
callq 0xa6612
movq %r14, %rdi
testq %r14, %r14
jne 0x45f46
movq 0x450(%rbx), %rax
xorl %ecx, %ecx
movq %rcx, (%rax)
movq 0x450(%rbx), %rax
movq %rcx, 0x8(%rax)
popq %rbx
popq %r14
popq %rbp
retq
| _ma_reset_state:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, [rdi]
mov rax, [rbx+450h]
test rax, rax
jz short loc_45F6D
cmp byte ptr [rbx+7E8h], 0
jz short loc_45F6D
mov rcx, [rbx+48h]
mov [rax+40h], rcx
movups xmm0, xmmword ptr [rbx+18h]
movups xmm1, xmmword ptr [rbx+28h]
movups xmm2, xmmword ptr [rbx+38h]
movups xmmword ptr [rax+30h], xmm2
movups xmmword ptr [rax+20h], xmm1
movups xmmword ptr [rax+10h], xmm0
mov rcx, [rbx+450h]
add rcx, 10h
mov [rdi+60h], rcx
mov [rdi+20h], rcx
mov rdi, [rax]
test rdi, rdi
jz short loc_45F56
loc_45F46:
mov r14, [rdi]
call my_free
mov rdi, r14
test r14, r14
jnz short loc_45F46
loc_45F56:
mov rax, [rbx+450h]
xor ecx, ecx
mov [rax], rcx
mov rax, [rbx+450h]
mov [rax+8], rcx
loc_45F6D:
pop rbx
pop r14
pop rbp
retn
| long long ma_reset_state(_QWORD *a1)
{
long long v1; // rbx
long long result; // rax
__int128 v3; // xmm0
__int128 v4; // xmm1
long long v5; // rcx
_QWORD *v6; // rdi
_QWORD *v7; // r14
v1 = *a1;
result = *(_QWORD *)(*a1 + 1104LL);
if ( result && *(_BYTE *)(v1 + 2024) )
{
*(_QWORD *)(result + 64) = *(_QWORD *)(v1 + 72);
v3 = *(_OWORD *)(v1 + 24);
v4 = *(_OWORD *)(v1 + 40);
*(_OWORD *)(result + 48) = *(_OWORD *)(v1 + 56);
*(_OWORD *)(result + 32) = v4;
*(_OWORD *)(result + 16) = v3;
v5 = *(_QWORD *)(v1 + 1104) + 16LL;
a1[12] = v5;
a1[4] = v5;
v6 = *(_QWORD **)result;
if ( *(_QWORD *)result )
{
do
{
v7 = (_QWORD *)*v6;
my_free(v6);
v6 = v7;
}
while ( v7 );
}
**(_QWORD **)(v1 + 1104) = 0LL;
result = *(_QWORD *)(v1 + 1104);
*(_QWORD *)(result + 8) = 0LL;
}
return result;
}
| _ma_reset_state:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,qword ptr [RDI]
MOV RAX,qword ptr [RBX + 0x450]
TEST RAX,RAX
JZ 0x00145f6d
CMP byte ptr [RBX + 0x7e8],0x0
JZ 0x00145f6d
MOV RCX,qword ptr [RBX + 0x48]
MOV qword ptr [RAX + 0x40],RCX
MOVUPS XMM0,xmmword ptr [RBX + 0x18]
MOVUPS XMM1,xmmword ptr [RBX + 0x28]
MOVUPS XMM2,xmmword ptr [RBX + 0x38]
MOVUPS xmmword ptr [RAX + 0x30],XMM2
MOVUPS xmmword ptr [RAX + 0x20],XMM1
MOVUPS xmmword ptr [RAX + 0x10],XMM0
MOV RCX,qword ptr [RBX + 0x450]
ADD RCX,0x10
MOV qword ptr [RDI + 0x60],RCX
MOV qword ptr [RDI + 0x20],RCX
MOV RDI,qword ptr [RAX]
TEST RDI,RDI
JZ 0x00145f56
LAB_00145f46:
MOV R14,qword ptr [RDI]
CALL 0x001a6612
MOV RDI,R14
TEST R14,R14
JNZ 0x00145f46
LAB_00145f56:
MOV RAX,qword ptr [RBX + 0x450]
XOR ECX,ECX
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBX + 0x450]
MOV qword ptr [RAX + 0x8],RCX
LAB_00145f6d:
POP RBX
POP R14
POP RBP
RET
|
void _ma_reset_state(long *param_1)
{
long lVar1;
int8 *puVar2;
int4 uVar3;
int4 uVar4;
int4 uVar5;
int4 uVar6;
int8 uVar7;
int8 uVar8;
int8 uVar9;
long lVar10;
lVar1 = *param_1;
puVar2 = *(int8 **)(lVar1 + 0x450);
if ((puVar2 != (int8 *)0x0) && (*(char *)(lVar1 + 0x7e8) != '\0')) {
puVar2[8] = *(int8 *)(lVar1 + 0x48);
uVar3 = *(int4 *)(lVar1 + 0x18);
uVar4 = *(int4 *)(lVar1 + 0x1c);
uVar5 = *(int4 *)(lVar1 + 0x20);
uVar6 = *(int4 *)(lVar1 + 0x24);
uVar7 = *(int8 *)(lVar1 + 0x28);
uVar8 = *(int8 *)(lVar1 + 0x30);
uVar9 = *(int8 *)(lVar1 + 0x40);
puVar2[6] = *(int8 *)(lVar1 + 0x38);
puVar2[7] = uVar9;
puVar2[4] = uVar7;
puVar2[5] = uVar8;
*(int4 *)(puVar2 + 2) = uVar3;
*(int4 *)((long)puVar2 + 0x14) = uVar4;
*(int4 *)(puVar2 + 3) = uVar5;
*(int4 *)((long)puVar2 + 0x1c) = uVar6;
lVar10 = *(long *)(lVar1 + 0x450) + 0x10;
param_1[0xc] = lVar10;
param_1[4] = lVar10;
puVar2 = (int8 *)*puVar2;
while (puVar2 != (int8 *)0x0) {
puVar2 = (int8 *)*puVar2;
my_free();
}
**(int8 **)(lVar1 + 0x450) = 0;
*(int8 *)(*(long *)(lVar1 + 0x450) + 8) = 0;
}
return;
}
| |
52,903 | lunasvg::handleTextChunk(__gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment*, std::vector<lunasvg::SVGTextFragment, std::allocator<lunasvg::SVGTextFragment>>>, __gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment*, std::vector<lunasvg::SVGTextFragment, std::allocator<lunasvg::SVGTextFragment>>>) | dmazzella[P]pylunasvg/lunasvg/source/svgtextelement.cpp | static void handleTextChunk(SVGTextFragmentIterator begin, SVGTextFragmentIterator end)
{
const SVGTextFragment& firstFragment = *begin;
if(firstFragment.element->hasAttribute(PropertyID::TextLength)) {
float chunkWidth = 0;
size_t numCharacters = 0;
const SVGTextFragment* lastFragment = nullptr;
for(auto it = begin; it != end; ++it) {
const SVGTextFragment& fragment = *it;
numCharacters += fragment.length;
chunkWidth += fragment.width;
if(lastFragment)
chunkWidth += fragment.x - (lastFragment->x + lastFragment->width);
lastFragment = &fragment;
}
LengthContext lengthContext(firstFragment.element);
auto textLength = lengthContext.valueForLength(firstFragment.element->textLength());
if(textLength > 0.f && chunkWidth > 0.f) {
if(firstFragment.element->lengthAdjust() == LengthAdjust::SpacingAndGlyphs) {
auto textLengthScale = textLength / chunkWidth;
auto lengthAdjustTransform = Transform::translated(firstFragment.x, firstFragment.y);
lengthAdjustTransform.scale(textLengthScale, 1.f);
lengthAdjustTransform.translate(-firstFragment.x, -firstFragment.y);
for(auto it = begin; it != end; ++it) {
SVGTextFragment& fragment = *it;
fragment.lengthAdjustTransform = lengthAdjustTransform;
}
} else if(numCharacters > 1) {
assert(firstFragment.element->lengthAdjust() == LengthAdjust::Spacing);
size_t characterOffset = 0;
auto textLengthShift = (textLength - chunkWidth) / (numCharacters - 1);
for(auto it = begin; it != end; ++it) {
SVGTextFragment& fragment = *it;
fragment.x += textLengthShift * characterOffset;
characterOffset += fragment.length;
}
}
}
}
if(needsTextAnchorAdjustment(firstFragment.element)) {
float chunkWidth = 0;
const SVGTextFragment* lastFragment = nullptr;
for(auto it = begin; it != end; ++it) {
const SVGTextFragment& fragment = *it;
chunkWidth += fragment.width;
if(lastFragment)
chunkWidth += fragment.x - (lastFragment->x + lastFragment->width);
lastFragment = &fragment;
}
auto chunkOffset = calculateTextAnchorOffset(firstFragment.element, chunkWidth);
for(auto it = begin; it != end; ++it) {
SVGTextFragment& fragment = *it;
fragment.x += chunkOffset;
}
}
} | O0 | cpp | lunasvg::handleTextChunk(__gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment*, std::vector<lunasvg::SVGTextFragment, std::allocator<lunasvg::SVGTextFragment>>>, __gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment*, std::vector<lunasvg::SVGTextFragment, std::allocator<lunasvg::SVGTextFragment>>>):
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x4fab0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x44, %esi
callq 0x18940
testb $0x1, %al
jne 0x4ddea
jmp 0x4e16c
xorps %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x4fa70
testb $0x1, %al
jne 0x4de1d
jmp 0x4de93
leaq -0x38(%rbp), %rdi
callq 0x4fab0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq 0x28(%rax), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rax
movss 0x3c(%rax), %xmm0
addss -0x1c(%rbp), %xmm0
movss %xmm0, -0x1c(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x4de7d
movq -0x40(%rbp), %rax
movss 0x30(%rax), %xmm0
movq -0x30(%rbp), %rax
movss 0x30(%rax), %xmm1
movq -0x30(%rbp), %rax
addss 0x3c(%rax), %xmm1
subss %xmm1, %xmm0
addss -0x1c(%rbp), %xmm0
movss %xmm0, -0x1c(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4fa50
jmp 0x4de0a
movq -0x18(%rbp), %rax
movq (%rax), %rsi
leaq -0x50(%rbp), %rdi
xorl %edx, %edx
callq 0x20050
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x51130
movq %rax, %rsi
leaq -0x50(%rbp), %rdi
callq 0x20080
movss %xmm0, -0x54(%rbp)
movss -0x54(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x4e16a
movss -0x1c(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x4e16a
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x4f760
cmpb $0x1, %al
jne 0x4dfc1
movss -0x54(%rbp), %xmm0
divss -0x1c(%rbp), %xmm0
movss %xmm0, -0x58(%rbp)
movq -0x18(%rbp), %rax
movss 0x30(%rax), %xmm0
movq -0x18(%rbp), %rax
movss 0x34(%rax), %xmm1
leaq -0x70(%rbp), %rdi
callq 0x11960
movss -0x58(%rbp), %xmm0
leaq -0x70(%rbp), %rdi
movss 0x3e195(%rip), %xmm1 # 0x8c0c8
callq 0x119b0
movq -0x18(%rbp), %rax
movss 0x30(%rax), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax # imm = 0x80000000
movd %eax, %xmm0
movq -0x18(%rbp), %rax
movss 0x34(%rax), %xmm1
movd %xmm1, %eax
xorl $0x80000000, %eax # imm = 0x80000000
movd %eax, %xmm1
leaq -0x70(%rbp), %rdi
callq 0x11910
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x4fa70
testb $0x1, %al
jne 0x4df88
jmp 0x4dfbc
leaq -0x78(%rbp), %rdi
callq 0x4fab0
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq -0x70(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x68(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x60(%rbp), %rcx
movq %rcx, 0x18(%rax)
leaq -0x78(%rbp), %rdi
callq 0x4fa50
jmp 0x4df75
jmp 0x4e168
cmpq $0x1, -0x28(%rbp)
jbe 0x4e166
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x4f760
cmpb $0x0, %al
jne 0x4dfde
jmp 0x4dffd
leaq 0x3f74b(%rip), %rdi # 0x8d730
leaq 0x3f5b6(%rip), %rsi # 0x8d5a2
movl $0xa5, %edx
leaq 0x3f777(%rip), %rcx # 0x8d76f
callq 0xb210
movq $0x0, -0x88(%rbp)
movss -0x54(%rbp), %xmm0
movss -0x1c(%rbp), %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0xe4(%rbp)
movq -0x28(%rbp), %rax
decq %rax
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, -0xe0(%rbp)
testq %rax, %rax
movss %xmm0, -0xdc(%rbp)
js 0x4e066
movss -0xe0(%rbp), %xmm0
movss %xmm0, -0xdc(%rbp)
movss -0xe4(%rbp), %xmm0
movss -0xdc(%rbp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x8c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x98(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x4fa70
testb $0x1, %al
jne 0x4e0a6
jmp 0x4e164
leaq -0x98(%rbp), %rdi
callq 0x4fab0
movq %rax, -0xa0(%rbp)
movss -0x8c(%rbp), %xmm0
movss %xmm0, -0xf0(%rbp)
movq -0x88(%rbp), %rax
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, -0xec(%rbp)
testq %rax, %rax
movss %xmm0, -0xe8(%rbp)
js 0x4e111
movss -0xec(%rbp), %xmm0
movss %xmm0, -0xe8(%rbp)
movss -0xf0(%rbp), %xmm0
movss -0xe8(%rbp), %xmm2
movq -0xa0(%rbp), %rax
movss 0x30(%rax), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x30(%rax)
movq -0xa0(%rbp), %rax
movq 0x28(%rax), %rax
addq -0x88(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x4fa50
jmp 0x4e08d
jmp 0x4e166
jmp 0x4e168
jmp 0x4e16a
jmp 0x4e16c
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x4f350
testb $0x1, %al
jne 0x4e181
jmp 0x4e2c4
xorps %xmm0, %xmm0
movss %xmm0, -0xa4(%rbp)
movq $0x0, -0xb0(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
leaq -0xb8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x4fa70
testb $0x1, %al
jne 0x4e1bb
jmp 0x4e24b
leaq -0xb8(%rbp), %rdi
callq 0x4fab0
movq %rax, -0xc0(%rbp)
movq -0xc0(%rbp), %rax
movss 0x3c(%rax), %xmm0
addss -0xa4(%rbp), %xmm0
movss %xmm0, -0xa4(%rbp)
cmpq $0x0, -0xb0(%rbp)
je 0x4e22c
movq -0xc0(%rbp), %rax
movss 0x30(%rax), %xmm0
movq -0xb0(%rbp), %rax
movss 0x30(%rax), %xmm1
movq -0xb0(%rbp), %rax
addss 0x3c(%rax), %xmm1
subss %xmm1, %xmm0
addss -0xa4(%rbp), %xmm0
movss %xmm0, -0xa4(%rbp)
movq -0xc0(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x4fa50
jmp 0x4e1a2
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movss -0xa4(%rbp), %xmm0
callq 0x4f3e0
movss %xmm0, -0xc4(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0xd0(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x4fa70
testb $0x1, %al
jne 0x4e288
jmp 0x4e2c2
leaq -0xd0(%rbp), %rdi
callq 0x4fab0
movq %rax, -0xd8(%rbp)
movss -0xc4(%rbp), %xmm0
movq -0xd8(%rbp), %rax
addss 0x30(%rax), %xmm0
movss %xmm0, 0x30(%rax)
leaq -0xd0(%rbp), %rdi
callq 0x4fa50
jmp 0x4e272
jmp 0x4e2c4
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax)
| _ZN7lunasvgL15handleTextChunkEN9__gnu_cxx17__normal_iteratorIPNS_15SVGTextFragmentESt6vectorIS2_SaIS2_EEEES7_:
push rbp
mov rbp, rsp
sub rsp, 0F0h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
lea rdi, [rbp+var_8]
call _ZNK9__gnu_cxx17__normal_iteratorIPN7lunasvg15SVGTextFragmentESt6vectorIS2_SaIS2_EEEdeEv; __gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment *,std::vector<lunasvg::SVGTextFragment>>::operator*(void)
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov rdi, [rax]
mov esi, offset dword_44; lunasvg::SVGTextPositioningElement *
call _ZNK7lunasvg10SVGElement12hasAttributeENS_10PropertyIDE; lunasvg::SVGElement::hasAttribute(lunasvg::PropertyID)
test al, 1
jnz short loc_4DDEA
jmp loc_4E16C
loc_4DDEA:
xorps xmm0, xmm0
movss [rbp+var_1C], xmm0
mov [rbp+var_28], 0
mov [rbp+var_30], 0
mov rax, [rbp+var_8]
mov [rbp+var_38], rax
loc_4DE0A:
lea rdi, [rbp+var_38]
lea rsi, [rbp+var_10]
call _ZN9__gnu_cxxneIPN7lunasvg15SVGTextFragmentESt6vectorIS2_SaIS2_EEEEbRKNS_17__normal_iteratorIT_T0_EESC_; __gnu_cxx::operator!=<lunasvg::SVGTextFragment *,std::vector<lunasvg::SVGTextFragment>>(__gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment *,std::vector<lunasvg::SVGTextFragment>> const&,__gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment *,std::vector<lunasvg::SVGTextFragment>> const&)
test al, 1
jnz short loc_4DE1D
jmp short loc_4DE93
loc_4DE1D:
lea rdi, [rbp+var_38]
call _ZNK9__gnu_cxx17__normal_iteratorIPN7lunasvg15SVGTextFragmentESt6vectorIS2_SaIS2_EEEdeEv; __gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment *,std::vector<lunasvg::SVGTextFragment>>::operator*(void)
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
mov rax, [rax+28h]
add rax, [rbp+var_28]
mov [rbp+var_28], rax
mov rax, [rbp+var_40]
movss xmm0, dword ptr [rax+3Ch]
addss xmm0, [rbp+var_1C]
movss [rbp+var_1C], xmm0
cmp [rbp+var_30], 0
jz short loc_4DE7D
mov rax, [rbp+var_40]
movss xmm0, dword ptr [rax+30h]
mov rax, [rbp+var_30]
movss xmm1, dword ptr [rax+30h]
mov rax, [rbp+var_30]
addss xmm1, dword ptr [rax+3Ch]
subss xmm0, xmm1
addss xmm0, [rbp+var_1C]
movss [rbp+var_1C], xmm0
loc_4DE7D:
mov rax, [rbp+var_40]
mov [rbp+var_30], rax
lea rdi, [rbp+var_38]
call _ZN9__gnu_cxx17__normal_iteratorIPN7lunasvg15SVGTextFragmentESt6vectorIS2_SaIS2_EEEppEv; __gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment *,std::vector<lunasvg::SVGTextFragment>>::operator++(void)
jmp loc_4DE0A
loc_4DE93:
mov rax, [rbp+var_18]
mov rsi, [rax]
lea rdi, [rbp+var_50]
xor edx, edx
call _ZN7lunasvg13LengthContextC2EPKNS_10SVGElementENS_5UnitsE; lunasvg::LengthContext::LengthContext(lunasvg::SVGElement const*,lunasvg::Units)
mov rax, [rbp+var_18]
mov rdi, [rax]; this
call _ZNK7lunasvg25SVGTextPositioningElement10textLengthEv; lunasvg::SVGTextPositioningElement::textLength(void)
mov rsi, rax; lunasvg::SVGLength *
lea rdi, [rbp+var_50]; this
call _ZNK7lunasvg13LengthContext14valueForLengthERKNS_9SVGLengthE; lunasvg::LengthContext::valueForLength(lunasvg::SVGLength const&)
movss [rbp+var_54], xmm0
movss xmm0, [rbp+var_54]
xorps xmm1, xmm1
ucomiss xmm0, xmm1
jbe loc_4E16A
movss xmm0, [rbp+var_1C]
xorps xmm1, xmm1
ucomiss xmm0, xmm1
jbe loc_4E16A
mov rax, [rbp+var_18]
mov rdi, [rax]; this
call _ZNK7lunasvg25SVGTextPositioningElement12lengthAdjustEv; lunasvg::SVGTextPositioningElement::lengthAdjust(void)
cmp al, 1
jnz loc_4DFC1
movss xmm0, [rbp+var_54]
divss xmm0, [rbp+var_1C]
movss [rbp+var_58], xmm0
mov rax, [rbp+var_18]
movss xmm0, dword ptr [rax+30h]; float
mov rax, [rbp+var_18]
movss xmm1, dword ptr [rax+34h]; float
lea rdi, [rbp+var_70]; this
call _ZN7lunasvg9Transform10translatedEff; lunasvg::Transform::translated(float,float)
movss xmm0, [rbp+var_58]; float
lea rdi, [rbp+var_70]; this
movss xmm1, cs:flt_8C0C8; float
call _ZN7lunasvg9Transform5scaleEff; lunasvg::Transform::scale(float,float)
mov rax, [rbp+var_18]
movss xmm0, dword ptr [rax+30h]
movd eax, xmm0
xor eax, 80000000h
movd xmm0, eax; float
mov rax, [rbp+var_18]
movss xmm1, dword ptr [rax+34h]
movd eax, xmm1
xor eax, 80000000h
movd xmm1, eax; float
lea rdi, [rbp+var_70]; this
call _ZN7lunasvg9Transform9translateEff; lunasvg::Transform::translate(float,float)
mov rax, [rbp+var_8]
mov [rbp+var_78], rax
loc_4DF75:
lea rdi, [rbp+var_78]
lea rsi, [rbp+var_10]
call _ZN9__gnu_cxxneIPN7lunasvg15SVGTextFragmentESt6vectorIS2_SaIS2_EEEEbRKNS_17__normal_iteratorIT_T0_EESC_; __gnu_cxx::operator!=<lunasvg::SVGTextFragment *,std::vector<lunasvg::SVGTextFragment>>(__gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment *,std::vector<lunasvg::SVGTextFragment>> const&,__gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment *,std::vector<lunasvg::SVGTextFragment>> const&)
test al, 1
jnz short loc_4DF88
jmp short loc_4DFBC
loc_4DF88:
lea rdi, [rbp+var_78]
call _ZNK9__gnu_cxx17__normal_iteratorIPN7lunasvg15SVGTextFragmentESt6vectorIS2_SaIS2_EEEdeEv; __gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment *,std::vector<lunasvg::SVGTextFragment>>::operator*(void)
mov [rbp+var_80], rax
mov rax, [rbp+var_80]
mov rcx, [rbp+var_70]
mov [rax+8], rcx
mov rcx, [rbp+var_68]
mov [rax+10h], rcx
mov rcx, [rbp+var_60]
mov [rax+18h], rcx
lea rdi, [rbp+var_78]
call _ZN9__gnu_cxx17__normal_iteratorIPN7lunasvg15SVGTextFragmentESt6vectorIS2_SaIS2_EEEppEv; __gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment *,std::vector<lunasvg::SVGTextFragment>>::operator++(void)
jmp short loc_4DF75
loc_4DFBC:
jmp loc_4E168
loc_4DFC1:
cmp [rbp+var_28], 1
jbe loc_4E166
mov rax, [rbp+var_18]
mov rdi, [rax]; this
call _ZNK7lunasvg25SVGTextPositioningElement12lengthAdjustEv; lunasvg::SVGTextPositioningElement::lengthAdjust(void)
cmp al, 0
jnz short loc_4DFDE
jmp short loc_4DFFD
loc_4DFDE:
lea rdi, aFirstfragmentE; "firstFragment.element->lengthAdjust() ="...
lea rsi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
mov edx, 0A5h
lea rcx, aVoidLunasvgHan; "void lunasvg::handleTextChunk(SVGTextFr"...
call ___assert_fail
loc_4DFFD:
mov [rbp+var_88], 0
movss xmm0, [rbp+var_54]
movss xmm1, [rbp+var_1C]
subss xmm0, xmm1
movss [rbp+var_E4], xmm0
mov rax, [rbp+var_28]
dec rax
mov rdx, rax
shr rdx, 1
mov ecx, eax
and ecx, 1
or rcx, rdx
cvtsi2ss xmm0, rcx
addss xmm0, xmm0
cvtsi2ss xmm1, rax
movss [rbp+var_E0], xmm1
test rax, rax
movss [rbp+var_DC], xmm0
js short loc_4E066
movss xmm0, [rbp+var_E0]
movss [rbp+var_DC], xmm0
loc_4E066:
movss xmm0, [rbp+var_E4]
movss xmm1, [rbp+var_DC]
divss xmm0, xmm1
movss [rbp+var_8C], xmm0
mov rax, [rbp+var_8]
mov [rbp+var_98], rax
loc_4E08D:
lea rdi, [rbp+var_98]
lea rsi, [rbp+var_10]
call _ZN9__gnu_cxxneIPN7lunasvg15SVGTextFragmentESt6vectorIS2_SaIS2_EEEEbRKNS_17__normal_iteratorIT_T0_EESC_; __gnu_cxx::operator!=<lunasvg::SVGTextFragment *,std::vector<lunasvg::SVGTextFragment>>(__gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment *,std::vector<lunasvg::SVGTextFragment>> const&,__gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment *,std::vector<lunasvg::SVGTextFragment>> const&)
test al, 1
jnz short loc_4E0A6
jmp loc_4E164
loc_4E0A6:
lea rdi, [rbp+var_98]
call _ZNK9__gnu_cxx17__normal_iteratorIPN7lunasvg15SVGTextFragmentESt6vectorIS2_SaIS2_EEEdeEv; __gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment *,std::vector<lunasvg::SVGTextFragment>>::operator*(void)
mov [rbp+var_A0], rax
movss xmm0, [rbp+var_8C]
movss [rbp+var_F0], xmm0
mov rax, [rbp+var_88]
mov rdx, rax
shr rdx, 1
mov ecx, eax
and ecx, 1
or rcx, rdx
cvtsi2ss xmm0, rcx
addss xmm0, xmm0
cvtsi2ss xmm1, rax
movss [rbp+var_EC], xmm1
test rax, rax
movss [rbp+var_E8], xmm0
js short loc_4E111
movss xmm0, [rbp+var_EC]
movss [rbp+var_E8], xmm0
loc_4E111:
movss xmm0, [rbp+var_F0]
movss xmm2, [rbp+var_E8]
mov rax, [rbp+var_A0]
movss xmm1, dword ptr [rax+30h]
mulss xmm0, xmm2
addss xmm0, xmm1
movss dword ptr [rax+30h], xmm0
mov rax, [rbp+var_A0]
mov rax, [rax+28h]
add rax, [rbp+var_88]
mov [rbp+var_88], rax
lea rdi, [rbp+var_98]
call _ZN9__gnu_cxx17__normal_iteratorIPN7lunasvg15SVGTextFragmentESt6vectorIS2_SaIS2_EEEppEv; __gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment *,std::vector<lunasvg::SVGTextFragment>>::operator++(void)
jmp loc_4E08D
loc_4E164:
jmp short $+2
loc_4E166:
jmp short $+2
loc_4E168:
jmp short $+2
loc_4E16A:
jmp short $+2
loc_4E16C:
mov rax, [rbp+var_18]
mov rdi, [rax]; this
call _ZN7lunasvgL25needsTextAnchorAdjustmentEPKNS_25SVGTextPositioningElementE; lunasvg::needsTextAnchorAdjustment(lunasvg::SVGTextPositioningElement const*)
test al, 1
jnz short loc_4E181
jmp loc_4E2C4
loc_4E181:
xorps xmm0, xmm0
movss [rbp+var_A4], xmm0
mov [rbp+var_B0], 0
mov rax, [rbp+var_8]
mov [rbp+var_B8], rax
loc_4E1A2:
lea rdi, [rbp+var_B8]
lea rsi, [rbp+var_10]; lunasvg::SVGTextPositioningElement *
call _ZN9__gnu_cxxneIPN7lunasvg15SVGTextFragmentESt6vectorIS2_SaIS2_EEEEbRKNS_17__normal_iteratorIT_T0_EESC_; __gnu_cxx::operator!=<lunasvg::SVGTextFragment *,std::vector<lunasvg::SVGTextFragment>>(__gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment *,std::vector<lunasvg::SVGTextFragment>> const&,__gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment *,std::vector<lunasvg::SVGTextFragment>> const&)
test al, 1
jnz short loc_4E1BB
jmp loc_4E24B
loc_4E1BB:
lea rdi, [rbp+var_B8]
call _ZNK9__gnu_cxx17__normal_iteratorIPN7lunasvg15SVGTextFragmentESt6vectorIS2_SaIS2_EEEdeEv; __gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment *,std::vector<lunasvg::SVGTextFragment>>::operator*(void)
mov [rbp+var_C0], rax
mov rax, [rbp+var_C0]
movss xmm0, dword ptr [rax+3Ch]
addss xmm0, [rbp+var_A4]
movss [rbp+var_A4], xmm0
cmp [rbp+var_B0], 0
jz short loc_4E22C
mov rax, [rbp+var_C0]
movss xmm0, dword ptr [rax+30h]
mov rax, [rbp+var_B0]
movss xmm1, dword ptr [rax+30h]
mov rax, [rbp+var_B0]
addss xmm1, dword ptr [rax+3Ch]
subss xmm0, xmm1
addss xmm0, [rbp+var_A4]
movss [rbp+var_A4], xmm0
loc_4E22C:
mov rax, [rbp+var_C0]
mov [rbp+var_B0], rax
lea rdi, [rbp+var_B8]
call _ZN9__gnu_cxx17__normal_iteratorIPN7lunasvg15SVGTextFragmentESt6vectorIS2_SaIS2_EEEppEv; __gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment *,std::vector<lunasvg::SVGTextFragment>>::operator++(void)
jmp loc_4E1A2
loc_4E24B:
mov rax, [rbp+var_18]
mov rdi, [rax]; this
movss xmm0, [rbp+var_A4]; float
call _ZN7lunasvgL25calculateTextAnchorOffsetEPKNS_25SVGTextPositioningElementEf; lunasvg::calculateTextAnchorOffset(lunasvg::SVGTextPositioningElement const*,float)
movss [rbp+var_C4], xmm0
mov rax, [rbp+var_8]
mov [rbp+var_D0], rax
loc_4E272:
lea rdi, [rbp+var_D0]
lea rsi, [rbp+var_10]
call _ZN9__gnu_cxxneIPN7lunasvg15SVGTextFragmentESt6vectorIS2_SaIS2_EEEEbRKNS_17__normal_iteratorIT_T0_EESC_; __gnu_cxx::operator!=<lunasvg::SVGTextFragment *,std::vector<lunasvg::SVGTextFragment>>(__gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment *,std::vector<lunasvg::SVGTextFragment>> const&,__gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment *,std::vector<lunasvg::SVGTextFragment>> const&)
test al, 1
jnz short loc_4E288
jmp short loc_4E2C2
loc_4E288:
lea rdi, [rbp+var_D0]
call _ZNK9__gnu_cxx17__normal_iteratorIPN7lunasvg15SVGTextFragmentESt6vectorIS2_SaIS2_EEEdeEv; __gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment *,std::vector<lunasvg::SVGTextFragment>>::operator*(void)
mov [rbp+var_D8], rax
movss xmm0, [rbp+var_C4]
mov rax, [rbp+var_D8]
addss xmm0, dword ptr [rax+30h]
movss dword ptr [rax+30h], xmm0
lea rdi, [rbp+var_D0]
call _ZN9__gnu_cxx17__normal_iteratorIPN7lunasvg15SVGTextFragmentESt6vectorIS2_SaIS2_EEEppEv; __gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment *,std::vector<lunasvg::SVGTextFragment>>::operator++(void)
jmp short loc_4E272
loc_4E2C2:
jmp short $+2
loc_4E2C4:
add rsp, 0F0h
pop rbp
retn
| long long lunasvg::handleTextChunk(long long a1, long long a2)
{
const lunasvg::SVGLength *v2; // rsi
_QWORD *v3; // rax
unsigned long long v4; // rcx
long long result; // rax
float v6; // xmm0_4
float v7; // [rsp+8h] [rbp-E8h]
float v8; // [rsp+14h] [rbp-DCh]
long long v9; // [rsp+18h] [rbp-D8h]
long long n; // [rsp+20h] [rbp-D0h] BYREF
float v11; // [rsp+2Ch] [rbp-C4h]
long long v12; // [rsp+30h] [rbp-C0h]
long long m; // [rsp+38h] [rbp-B8h] BYREF
long long v14; // [rsp+40h] [rbp-B0h]
float v15; // [rsp+4Ch] [rbp-A4h]
long long v16; // [rsp+50h] [rbp-A0h]
long long k; // [rsp+58h] [rbp-98h] BYREF
float v18; // [rsp+64h] [rbp-8Ch]
long long v19; // [rsp+68h] [rbp-88h]
_QWORD *v20; // [rsp+70h] [rbp-80h]
long long j; // [rsp+78h] [rbp-78h] BYREF
_QWORD v22[3]; // [rsp+80h] [rbp-70h] BYREF
float v23; // [rsp+98h] [rbp-58h]
float v24; // [rsp+9Ch] [rbp-54h]
_BYTE v25[16]; // [rsp+A0h] [rbp-50h] BYREF
long long v26; // [rsp+B0h] [rbp-40h]
long long i; // [rsp+B8h] [rbp-38h] BYREF
long long v28; // [rsp+C0h] [rbp-30h]
unsigned long long v29; // [rsp+C8h] [rbp-28h]
float v30; // [rsp+D4h] [rbp-1Ch]
long long v31; // [rsp+D8h] [rbp-18h]
long long v32; // [rsp+E0h] [rbp-10h] BYREF
long long v33; // [rsp+E8h] [rbp-8h] BYREF
v33 = a1;
v32 = a2;
v31 = __gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment *,std::vector<lunasvg::SVGTextFragment>>::operator*(&v33);
v2 = (const lunasvg::SVGLength *)&dword_44;
if ( (lunasvg::SVGElement::hasAttribute(*(_QWORD *)v31, (char)&dword_44) & 1) != 0 )
{
v30 = 0.0;
v29 = 0LL;
v28 = 0LL;
for ( i = v33;
(__gnu_cxx::operator!=<lunasvg::SVGTextFragment *,std::vector<lunasvg::SVGTextFragment>>(&i, &v32) & 1) != 0;
__gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment *,std::vector<lunasvg::SVGTextFragment>>::operator++(&i) )
{
v26 = __gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment *,std::vector<lunasvg::SVGTextFragment>>::operator*(&i);
v29 += *(_QWORD *)(v26 + 40);
v30 = *(float *)(v26 + 60) + v30;
if ( v28 )
v30 = (float)(*(float *)(v26 + 48) - (float)(*(float *)(v28 + 48) + *(float *)(v28 + 60))) + v30;
v28 = v26;
}
lunasvg::LengthContext::LengthContext((long long)v25, *(_QWORD *)v31, 0);
v2 = (const lunasvg::SVGLength *)lunasvg::SVGTextPositioningElement::textLength(*(lunasvg::SVGTextPositioningElement **)v31);
v24 = lunasvg::LengthContext::valueForLength((lunasvg::LengthContext *)v25, v2);
if ( v24 > 0.0 && v30 > 0.0 )
{
if ( (unsigned __int8)lunasvg::SVGTextPositioningElement::lengthAdjust(*(lunasvg::SVGTextPositioningElement **)v31) == 1 )
{
v23 = v24 / v30;
lunasvg::Transform::translated((lunasvg::Transform *)v22, *(float *)(v31 + 48), *(float *)(v31 + 52));
lunasvg::Transform::scale((lunasvg::Transform *)v22, v23, 1.0);
lunasvg::Transform::translate(
(lunasvg::Transform *)v22,
COERCE_FLOAT(_mm_cvtsi128_si32((__m128i)*(unsigned int *)(v31 + 48)) ^ 0x80000000),
COERCE_FLOAT(_mm_cvtsi128_si32((__m128i)*(unsigned int *)(v31 + 52)) ^ 0x80000000));
for ( j = v33;
;
__gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment *,std::vector<lunasvg::SVGTextFragment>>::operator++(&j) )
{
v2 = (const lunasvg::SVGLength *)&v32;
if ( (__gnu_cxx::operator!=<lunasvg::SVGTextFragment *,std::vector<lunasvg::SVGTextFragment>>(&j, &v32) & 1) == 0 )
break;
v3 = (_QWORD *)__gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment *,std::vector<lunasvg::SVGTextFragment>>::operator*(&j);
v20 = v3;
v3[1] = v22[0];
v3[2] = v22[1];
v3[3] = v22[2];
}
}
else if ( v29 > 1 )
{
if ( (unsigned __int8)lunasvg::SVGTextPositioningElement::lengthAdjust(*(lunasvg::SVGTextPositioningElement **)v31) )
__assert_fail(
"firstFragment.element->lengthAdjust() == LengthAdjust::Spacing",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/source/svgtextelement.cpp",
165LL,
"void lunasvg::handleTextChunk(SVGTextFragmentIterator, SVGTextFragmentIterator)");
v19 = 0LL;
v4 = ((v29 - 1) >> 1) | ((_BYTE)v29 - 1) & 1;
v8 = (float)(int)v4 + (float)(int)v4;
if ( (long long)(v29 - 1) >= 0 )
v8 = (float)((int)v29 - 1);
v18 = (float)(v24 - v30) / v8;
for ( k = v33;
;
__gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment *,std::vector<lunasvg::SVGTextFragment>>::operator++(&k) )
{
v2 = (const lunasvg::SVGLength *)&v32;
if ( (__gnu_cxx::operator!=<lunasvg::SVGTextFragment *,std::vector<lunasvg::SVGTextFragment>>(&k, &v32) & 1) == 0 )
break;
v16 = __gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment *,std::vector<lunasvg::SVGTextFragment>>::operator*(&k);
v7 = (float)(int)(((unsigned long long)v19 >> 1) | v19 & 1)
+ (float)(int)(((unsigned long long)v19 >> 1) | v19 & 1);
if ( v19 >= 0 )
v7 = (float)(int)v19;
*(float *)(v16 + 48) = (float)(v18 * v7) + *(float *)(v16 + 48);
v19 += *(_QWORD *)(v16 + 40);
}
}
}
}
result = lunasvg::needsTextAnchorAdjustment(*(lunasvg **)v31, v2);
if ( (result & 1) != 0 )
{
v15 = 0.0;
v14 = 0LL;
for ( m = v33;
(__gnu_cxx::operator!=<lunasvg::SVGTextFragment *,std::vector<lunasvg::SVGTextFragment>>(&m, &v32) & 1) != 0;
__gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment *,std::vector<lunasvg::SVGTextFragment>>::operator++(&m) )
{
v12 = __gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment *,std::vector<lunasvg::SVGTextFragment>>::operator*(&m);
v15 = *(float *)(v12 + 60) + v15;
if ( v14 )
v15 = (float)(*(float *)(v12 + 48) - (float)(*(float *)(v14 + 48) + *(float *)(v14 + 60))) + v15;
v14 = v12;
}
v6 = v15;
lunasvg::calculateTextAnchorOffset(*(lunasvg **)v31, (const lunasvg::SVGTextPositioningElement *)&v32, v15);
v11 = v6;
for ( n = v33;
;
__gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment *,std::vector<lunasvg::SVGTextFragment>>::operator++(&n) )
{
result = __gnu_cxx::operator!=<lunasvg::SVGTextFragment *,std::vector<lunasvg::SVGTextFragment>>(&n, &v32);
if ( (result & 1) == 0 )
break;
v9 = __gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment *,std::vector<lunasvg::SVGTextFragment>>::operator*(&n);
*(float *)(v9 + 48) = v11 + *(float *)(v9 + 48);
}
}
return result;
}
| handleTextChunk:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xf0
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
LEA RDI,[RBP + -0x8]
CALL 0x0014fab0
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX]
MOV ESI,0x44
CALL 0x00118940
TEST AL,0x1
JNZ 0x0014ddea
JMP 0x0014e16c
LAB_0014ddea:
XORPS XMM0,XMM0
MOVSS dword ptr [RBP + -0x1c],XMM0
MOV qword ptr [RBP + -0x28],0x0
MOV qword ptr [RBP + -0x30],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x38],RAX
LAB_0014de0a:
LEA RDI,[RBP + -0x38]
LEA RSI,[RBP + -0x10]
CALL 0x0014fa70
TEST AL,0x1
JNZ 0x0014de1d
JMP 0x0014de93
LAB_0014de1d:
LEA RDI,[RBP + -0x38]
CALL 0x0014fab0
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RAX + 0x28]
ADD RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOVSS XMM0,dword ptr [RAX + 0x3c]
ADDSS XMM0,dword ptr [RBP + -0x1c]
MOVSS dword ptr [RBP + -0x1c],XMM0
CMP qword ptr [RBP + -0x30],0x0
JZ 0x0014de7d
MOV RAX,qword ptr [RBP + -0x40]
MOVSS XMM0,dword ptr [RAX + 0x30]
MOV RAX,qword ptr [RBP + -0x30]
MOVSS XMM1,dword ptr [RAX + 0x30]
MOV RAX,qword ptr [RBP + -0x30]
ADDSS XMM1,dword ptr [RAX + 0x3c]
SUBSS XMM0,XMM1
ADDSS XMM0,dword ptr [RBP + -0x1c]
MOVSS dword ptr [RBP + -0x1c],XMM0
LAB_0014de7d:
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x30],RAX
LEA RDI,[RBP + -0x38]
CALL 0x0014fa50
JMP 0x0014de0a
LAB_0014de93:
MOV RAX,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RAX]
LEA RDI,[RBP + -0x50]
XOR EDX,EDX
CALL 0x00120050
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX]
CALL 0x00151130
MOV RSI,RAX
LEA RDI,[RBP + -0x50]
CALL 0x00120080
MOVSS dword ptr [RBP + -0x54],XMM0
MOVSS XMM0,dword ptr [RBP + -0x54]
XORPS XMM1,XMM1
UCOMISS XMM0,XMM1
JBE 0x0014e16a
MOVSS XMM0,dword ptr [RBP + -0x1c]
XORPS XMM1,XMM1
UCOMISS XMM0,XMM1
JBE 0x0014e16a
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX]
CALL 0x0014f760
CMP AL,0x1
JNZ 0x0014dfc1
MOVSS XMM0,dword ptr [RBP + -0x54]
DIVSS XMM0,dword ptr [RBP + -0x1c]
MOVSS dword ptr [RBP + -0x58],XMM0
MOV RAX,qword ptr [RBP + -0x18]
MOVSS XMM0,dword ptr [RAX + 0x30]
MOV RAX,qword ptr [RBP + -0x18]
MOVSS XMM1,dword ptr [RAX + 0x34]
LEA RDI,[RBP + -0x70]
CALL 0x00111960
MOVSS XMM0,dword ptr [RBP + -0x58]
LEA RDI,[RBP + -0x70]
MOVSS XMM1,dword ptr [0x0018c0c8]
CALL 0x001119b0
MOV RAX,qword ptr [RBP + -0x18]
MOVSS XMM0,dword ptr [RAX + 0x30]
MOVD EAX,XMM0
XOR EAX,0x80000000
MOVD XMM0,EAX
MOV RAX,qword ptr [RBP + -0x18]
MOVSS XMM1,dword ptr [RAX + 0x34]
MOVD EAX,XMM1
XOR EAX,0x80000000
MOVD XMM1,EAX
LEA RDI,[RBP + -0x70]
CALL 0x00111910
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x78],RAX
LAB_0014df75:
LEA RDI,[RBP + -0x78]
LEA RSI,[RBP + -0x10]
CALL 0x0014fa70
TEST AL,0x1
JNZ 0x0014df88
JMP 0x0014dfbc
LAB_0014df88:
LEA RDI,[RBP + -0x78]
CALL 0x0014fab0
MOV qword ptr [RBP + -0x80],RAX
MOV RAX,qword ptr [RBP + -0x80]
MOV RCX,qword ptr [RBP + -0x70]
MOV qword ptr [RAX + 0x8],RCX
MOV RCX,qword ptr [RBP + -0x68]
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,qword ptr [RBP + -0x60]
MOV qword ptr [RAX + 0x18],RCX
LEA RDI,[RBP + -0x78]
CALL 0x0014fa50
JMP 0x0014df75
LAB_0014dfbc:
JMP 0x0014e168
LAB_0014dfc1:
CMP qword ptr [RBP + -0x28],0x1
JBE 0x0014e166
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX]
CALL 0x0014f760
CMP AL,0x0
JNZ 0x0014dfde
JMP 0x0014dffd
LAB_0014dfde:
LEA RDI,[0x18d730]
LEA RSI,[0x18d5a2]
MOV EDX,0xa5
LEA RCX,[0x18d76f]
CALL 0x0010b210
LAB_0014dffd:
MOV qword ptr [RBP + -0x88],0x0
MOVSS XMM0,dword ptr [RBP + -0x54]
MOVSS XMM1,dword ptr [RBP + -0x1c]
SUBSS XMM0,XMM1
MOVSS dword ptr [RBP + -0xe4],XMM0
MOV RAX,qword ptr [RBP + -0x28]
DEC RAX
MOV RDX,RAX
SHR RDX,0x1
MOV ECX,EAX
AND ECX,0x1
OR RCX,RDX
CVTSI2SS XMM0,RCX
ADDSS XMM0,XMM0
CVTSI2SS XMM1,RAX
MOVSS dword ptr [RBP + -0xe0],XMM1
TEST RAX,RAX
MOVSS dword ptr [RBP + -0xdc],XMM0
JS 0x0014e066
MOVSS XMM0,dword ptr [RBP + -0xe0]
MOVSS dword ptr [RBP + -0xdc],XMM0
LAB_0014e066:
MOVSS XMM0,dword ptr [RBP + -0xe4]
MOVSS XMM1,dword ptr [RBP + -0xdc]
DIVSS XMM0,XMM1
MOVSS dword ptr [RBP + -0x8c],XMM0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x98],RAX
LAB_0014e08d:
LEA RDI,[RBP + -0x98]
LEA RSI,[RBP + -0x10]
CALL 0x0014fa70
TEST AL,0x1
JNZ 0x0014e0a6
JMP 0x0014e164
LAB_0014e0a6:
LEA RDI,[RBP + -0x98]
CALL 0x0014fab0
MOV qword ptr [RBP + -0xa0],RAX
MOVSS XMM0,dword ptr [RBP + -0x8c]
MOVSS dword ptr [RBP + -0xf0],XMM0
MOV RAX,qword ptr [RBP + -0x88]
MOV RDX,RAX
SHR RDX,0x1
MOV ECX,EAX
AND ECX,0x1
OR RCX,RDX
CVTSI2SS XMM0,RCX
ADDSS XMM0,XMM0
CVTSI2SS XMM1,RAX
MOVSS dword ptr [RBP + -0xec],XMM1
TEST RAX,RAX
MOVSS dword ptr [RBP + -0xe8],XMM0
JS 0x0014e111
MOVSS XMM0,dword ptr [RBP + -0xec]
MOVSS dword ptr [RBP + -0xe8],XMM0
LAB_0014e111:
MOVSS XMM0,dword ptr [RBP + -0xf0]
MOVSS XMM2,dword ptr [RBP + -0xe8]
MOV RAX,qword ptr [RBP + -0xa0]
MOVSS XMM1,dword ptr [RAX + 0x30]
MULSS XMM0,XMM2
ADDSS XMM0,XMM1
MOVSS dword ptr [RAX + 0x30],XMM0
MOV RAX,qword ptr [RBP + -0xa0]
MOV RAX,qword ptr [RAX + 0x28]
ADD RAX,qword ptr [RBP + -0x88]
MOV qword ptr [RBP + -0x88],RAX
LEA RDI,[RBP + -0x98]
CALL 0x0014fa50
JMP 0x0014e08d
LAB_0014e164:
JMP 0x0014e166
LAB_0014e166:
JMP 0x0014e168
LAB_0014e168:
JMP 0x0014e16a
LAB_0014e16a:
JMP 0x0014e16c
LAB_0014e16c:
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX]
CALL 0x0014f350
TEST AL,0x1
JNZ 0x0014e181
JMP 0x0014e2c4
LAB_0014e181:
XORPS XMM0,XMM0
MOVSS dword ptr [RBP + -0xa4],XMM0
MOV qword ptr [RBP + -0xb0],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0xb8],RAX
LAB_0014e1a2:
LEA RDI,[RBP + -0xb8]
LEA RSI,[RBP + -0x10]
CALL 0x0014fa70
TEST AL,0x1
JNZ 0x0014e1bb
JMP 0x0014e24b
LAB_0014e1bb:
LEA RDI,[RBP + -0xb8]
CALL 0x0014fab0
MOV qword ptr [RBP + -0xc0],RAX
MOV RAX,qword ptr [RBP + -0xc0]
MOVSS XMM0,dword ptr [RAX + 0x3c]
ADDSS XMM0,dword ptr [RBP + -0xa4]
MOVSS dword ptr [RBP + -0xa4],XMM0
CMP qword ptr [RBP + -0xb0],0x0
JZ 0x0014e22c
MOV RAX,qword ptr [RBP + -0xc0]
MOVSS XMM0,dword ptr [RAX + 0x30]
MOV RAX,qword ptr [RBP + -0xb0]
MOVSS XMM1,dword ptr [RAX + 0x30]
MOV RAX,qword ptr [RBP + -0xb0]
ADDSS XMM1,dword ptr [RAX + 0x3c]
SUBSS XMM0,XMM1
ADDSS XMM0,dword ptr [RBP + -0xa4]
MOVSS dword ptr [RBP + -0xa4],XMM0
LAB_0014e22c:
MOV RAX,qword ptr [RBP + -0xc0]
MOV qword ptr [RBP + -0xb0],RAX
LEA RDI,[RBP + -0xb8]
CALL 0x0014fa50
JMP 0x0014e1a2
LAB_0014e24b:
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX]
MOVSS XMM0,dword ptr [RBP + -0xa4]
CALL 0x0014f3e0
MOVSS dword ptr [RBP + -0xc4],XMM0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0xd0],RAX
LAB_0014e272:
LEA RDI,[RBP + -0xd0]
LEA RSI,[RBP + -0x10]
CALL 0x0014fa70
TEST AL,0x1
JNZ 0x0014e288
JMP 0x0014e2c2
LAB_0014e288:
LEA RDI,[RBP + -0xd0]
CALL 0x0014fab0
MOV qword ptr [RBP + -0xd8],RAX
MOVSS XMM0,dword ptr [RBP + -0xc4]
MOV RAX,qword ptr [RBP + -0xd8]
ADDSS XMM0,dword ptr [RAX + 0x30]
MOVSS dword ptr [RAX + 0x30],XMM0
LEA RDI,[RBP + -0xd0]
CALL 0x0014fa50
JMP 0x0014e272
LAB_0014e2c2:
JMP 0x0014e2c4
LAB_0014e2c4:
ADD RSP,0xf0
POP RBP
RET
|
/* lunasvg::handleTextChunk(__gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment*,
std::vector<lunasvg::SVGTextFragment, std::allocator<lunasvg::SVGTextFragment> > >,
__gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment*, std::vector<lunasvg::SVGTextFragment,
std::allocator<lunasvg::SVGTextFragment> > >) */
void lunasvg::handleTextChunk(int8 param_1,int8 param_2)
{
char cVar1;
bool bVar2;
ulong uVar3;
SVGLength *pSVar4;
long lVar5;
float local_f0;
float local_e4;
int8 local_d8;
float local_cc;
long local_c8;
int8 local_c0;
long local_b8;
float local_ac;
long local_a8;
int8 local_a0;
float local_94;
ulong local_90;
long local_88;
int8 local_80;
int8 local_78;
int8 local_70;
int8 local_68;
float local_60;
float local_5c;
LengthContext local_58 [16];
long local_48;
int8 local_40;
long local_38;
ulong local_30;
float local_24;
int8 *local_20;
int8 local_18;
int8 local_10;
local_18 = param_2;
local_10 = param_1;
local_20 = (int8 *)
__gnu_cxx::
__normal_iterator<lunasvg::SVGTextFragment*,std::vector<lunasvg::SVGTextFragment,std::allocator<lunasvg::SVGTextFragment>>>
::operator*((__normal_iterator<lunasvg::SVGTextFragment*,std::vector<lunasvg::SVGTextFragment,std::allocator<lunasvg::SVGTextFragment>>>
*)&local_10);
uVar3 = SVGElement::hasAttribute((SVGElement *)*local_20,0x44);
if ((uVar3 & 1) != 0) {
local_24 = 0.0;
local_30 = 0;
local_38 = 0;
local_40 = local_10;
while (bVar2 = __gnu_cxx::operator!=
((__normal_iterator *)&local_40,(__normal_iterator *)&local_18), bVar2)
{
local_48 = __gnu_cxx::
__normal_iterator<lunasvg::SVGTextFragment*,std::vector<lunasvg::SVGTextFragment,std::allocator<lunasvg::SVGTextFragment>>>
::operator*((__normal_iterator<lunasvg::SVGTextFragment*,std::vector<lunasvg::SVGTextFragment,std::allocator<lunasvg::SVGTextFragment>>>
*)&local_40);
local_30 = *(long *)(local_48 + 0x28) + local_30;
local_24 = *(float *)(local_48 + 0x3c) + local_24;
if (local_38 != 0) {
local_24 = (*(float *)(local_48 + 0x30) -
(*(float *)(local_38 + 0x30) + *(float *)(local_38 + 0x3c))) + local_24;
}
local_38 = local_48;
__gnu_cxx::
__normal_iterator<lunasvg::SVGTextFragment*,std::vector<lunasvg::SVGTextFragment,std::allocator<lunasvg::SVGTextFragment>>>
::operator++((__normal_iterator<lunasvg::SVGTextFragment*,std::vector<lunasvg::SVGTextFragment,std::allocator<lunasvg::SVGTextFragment>>>
*)&local_40);
}
LengthContext::LengthContext(local_58,*local_20,0);
pSVar4 = (SVGLength *)
SVGTextPositioningElement::textLength((SVGTextPositioningElement *)*local_20);
local_5c = (float)LengthContext::valueForLength(local_58,pSVar4);
if ((0.0 < local_5c) && (0.0 < local_24)) {
cVar1 = SVGTextPositioningElement::lengthAdjust((SVGTextPositioningElement *)*local_20);
if (cVar1 == '\x01') {
local_60 = local_5c / local_24;
Transform::translated
((Transform *)&local_78,*(float *)(local_20 + 6),*(float *)((long)local_20 + 0x34)
);
Transform::scale((Transform *)&local_78,local_60,DAT_0018c0c8);
Transform::translate
((Transform *)&local_78,-*(float *)(local_20 + 6),
-*(float *)((long)local_20 + 0x34));
local_80 = local_10;
while (bVar2 = __gnu_cxx::operator!=
((__normal_iterator *)&local_80,(__normal_iterator *)&local_18),
bVar2) {
local_88 = __gnu_cxx::
__normal_iterator<lunasvg::SVGTextFragment*,std::vector<lunasvg::SVGTextFragment,std::allocator<lunasvg::SVGTextFragment>>>
::operator*((__normal_iterator<lunasvg::SVGTextFragment*,std::vector<lunasvg::SVGTextFragment,std::allocator<lunasvg::SVGTextFragment>>>
*)&local_80);
*(int8 *)(local_88 + 8) = local_78;
*(int8 *)(local_88 + 0x10) = local_70;
*(int8 *)(local_88 + 0x18) = local_68;
__gnu_cxx::
__normal_iterator<lunasvg::SVGTextFragment*,std::vector<lunasvg::SVGTextFragment,std::allocator<lunasvg::SVGTextFragment>>>
::operator++((__normal_iterator<lunasvg::SVGTextFragment*,std::vector<lunasvg::SVGTextFragment,std::allocator<lunasvg::SVGTextFragment>>>
*)&local_80);
}
}
else if (1 < local_30) {
cVar1 = SVGTextPositioningElement::lengthAdjust((SVGTextPositioningElement *)*local_20);
if (cVar1 != '\0') {
/* WARNING: Subroutine does not return */
__assert_fail("firstFragment.element->lengthAdjust() == LengthAdjust::Spacing",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/source/svgtextelement.cpp"
,0xa5,
"void lunasvg::handleTextChunk(SVGTextFragmentIterator, SVGTextFragmentIterator)"
);
}
local_90 = 0;
local_e4 = (float)(local_30 - 1);
local_94 = (local_5c - local_24) / local_e4;
local_a0 = local_10;
while (bVar2 = __gnu_cxx::operator!=
((__normal_iterator *)&local_a0,(__normal_iterator *)&local_18),
bVar2) {
local_a8 = __gnu_cxx::
__normal_iterator<lunasvg::SVGTextFragment*,std::vector<lunasvg::SVGTextFragment,std::allocator<lunasvg::SVGTextFragment>>>
::operator*((__normal_iterator<lunasvg::SVGTextFragment*,std::vector<lunasvg::SVGTextFragment,std::allocator<lunasvg::SVGTextFragment>>>
*)&local_a0);
local_f0 = (float)local_90;
*(float *)(local_a8 + 0x30) = local_94 * local_f0 + *(float *)(local_a8 + 0x30);
local_90 = *(long *)(local_a8 + 0x28) + local_90;
__gnu_cxx::
__normal_iterator<lunasvg::SVGTextFragment*,std::vector<lunasvg::SVGTextFragment,std::allocator<lunasvg::SVGTextFragment>>>
::operator++((__normal_iterator<lunasvg::SVGTextFragment*,std::vector<lunasvg::SVGTextFragment,std::allocator<lunasvg::SVGTextFragment>>>
*)&local_a0);
}
}
}
}
uVar3 = needsTextAnchorAdjustment((SVGTextPositioningElement *)*local_20);
if ((uVar3 & 1) != 0) {
local_ac = 0.0;
local_b8 = 0;
local_c0 = local_10;
while (bVar2 = __gnu_cxx::operator!=
((__normal_iterator *)&local_c0,(__normal_iterator *)&local_18), bVar2)
{
local_c8 = __gnu_cxx::
__normal_iterator<lunasvg::SVGTextFragment*,std::vector<lunasvg::SVGTextFragment,std::allocator<lunasvg::SVGTextFragment>>>
::operator*((__normal_iterator<lunasvg::SVGTextFragment*,std::vector<lunasvg::SVGTextFragment,std::allocator<lunasvg::SVGTextFragment>>>
*)&local_c0);
local_ac = *(float *)(local_c8 + 0x3c) + local_ac;
if (local_b8 != 0) {
local_ac = (*(float *)(local_c8 + 0x30) -
(*(float *)(local_b8 + 0x30) + *(float *)(local_b8 + 0x3c))) + local_ac;
}
local_b8 = local_c8;
__gnu_cxx::
__normal_iterator<lunasvg::SVGTextFragment*,std::vector<lunasvg::SVGTextFragment,std::allocator<lunasvg::SVGTextFragment>>>
::operator++((__normal_iterator<lunasvg::SVGTextFragment*,std::vector<lunasvg::SVGTextFragment,std::allocator<lunasvg::SVGTextFragment>>>
*)&local_c0);
}
local_cc = (float)calculateTextAnchorOffset((SVGTextPositioningElement *)*local_20,local_ac);
local_d8 = local_10;
while (bVar2 = __gnu_cxx::operator!=
((__normal_iterator *)&local_d8,(__normal_iterator *)&local_18), bVar2)
{
lVar5 = __gnu_cxx::
__normal_iterator<lunasvg::SVGTextFragment*,std::vector<lunasvg::SVGTextFragment,std::allocator<lunasvg::SVGTextFragment>>>
::operator*((__normal_iterator<lunasvg::SVGTextFragment*,std::vector<lunasvg::SVGTextFragment,std::allocator<lunasvg::SVGTextFragment>>>
*)&local_d8);
*(float *)(lVar5 + 0x30) = local_cc + *(float *)(lVar5 + 0x30);
__gnu_cxx::
__normal_iterator<lunasvg::SVGTextFragment*,std::vector<lunasvg::SVGTextFragment,std::allocator<lunasvg::SVGTextFragment>>>
::operator++((__normal_iterator<lunasvg::SVGTextFragment*,std::vector<lunasvg::SVGTextFragment,std::allocator<lunasvg::SVGTextFragment>>>
*)&local_d8);
}
}
return;
}
| |
52,904 | lunasvg::handleTextChunk(__gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment*, std::vector<lunasvg::SVGTextFragment, std::allocator<lunasvg::SVGTextFragment>>>, __gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment*, std::vector<lunasvg::SVGTextFragment, std::allocator<lunasvg::SVGTextFragment>>>) | dmazzella[P]pylunasvg/lunasvg/source/svgtextelement.cpp | static void handleTextChunk(SVGTextFragmentIterator begin, SVGTextFragmentIterator end)
{
const SVGTextFragment& firstFragment = *begin;
if(firstFragment.element->hasAttribute(PropertyID::TextLength)) {
float chunkWidth = 0;
size_t numCharacters = 0;
const SVGTextFragment* lastFragment = nullptr;
for(auto it = begin; it != end; ++it) {
const SVGTextFragment& fragment = *it;
numCharacters += fragment.length;
chunkWidth += fragment.width;
if(lastFragment)
chunkWidth += fragment.x - (lastFragment->x + lastFragment->width);
lastFragment = &fragment;
}
LengthContext lengthContext(firstFragment.element);
auto textLength = lengthContext.valueForLength(firstFragment.element->textLength());
if(textLength > 0.f && chunkWidth > 0.f) {
if(firstFragment.element->lengthAdjust() == LengthAdjust::SpacingAndGlyphs) {
auto textLengthScale = textLength / chunkWidth;
auto lengthAdjustTransform = Transform::translated(firstFragment.x, firstFragment.y);
lengthAdjustTransform.scale(textLengthScale, 1.f);
lengthAdjustTransform.translate(-firstFragment.x, -firstFragment.y);
for(auto it = begin; it != end; ++it) {
SVGTextFragment& fragment = *it;
fragment.lengthAdjustTransform = lengthAdjustTransform;
}
} else if(numCharacters > 1) {
assert(firstFragment.element->lengthAdjust() == LengthAdjust::Spacing);
size_t characterOffset = 0;
auto textLengthShift = (textLength - chunkWidth) / (numCharacters - 1);
for(auto it = begin; it != end; ++it) {
SVGTextFragment& fragment = *it;
fragment.x += textLengthShift * characterOffset;
characterOffset += fragment.length;
}
}
}
}
if(needsTextAnchorAdjustment(firstFragment.element)) {
float chunkWidth = 0;
const SVGTextFragment* lastFragment = nullptr;
for(auto it = begin; it != end; ++it) {
const SVGTextFragment& fragment = *it;
chunkWidth += fragment.width;
if(lastFragment)
chunkWidth += fragment.x - (lastFragment->x + lastFragment->width);
lastFragment = &fragment;
}
auto chunkOffset = calculateTextAnchorOffset(firstFragment.element, chunkWidth);
for(auto it = begin; it != end; ++it) {
SVGTextFragment& fragment = *it;
fragment.x += chunkOffset;
}
}
} | O1 | cpp | lunasvg::handleTextChunk(__gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment*, std::vector<lunasvg::SVGTextFragment, std::allocator<lunasvg::SVGTextFragment>>>, __gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment*, std::vector<lunasvg::SVGTextFragment, std::allocator<lunasvg::SVGTextFragment>>>):
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movl $0x44, %esi
callq 0xf1c8
testb %al, %al
je 0x21b34
cmpq %rbx, %r14
je 0x219c0
xorps %xmm2, %xmm2
xorl %r15d, %r15d
xorl %ecx, %ecx
movq %r14, %rax
addss 0x3c(%rax), %xmm2
testq %rcx, %rcx
je 0x219ab
movss 0x30(%rax), %xmm0
movss 0x30(%rcx), %xmm1
addss 0x3c(%rcx), %xmm1
subss %xmm1, %xmm0
addss %xmm0, %xmm2
addq 0x28(%rax), %r15
movq %rax, %rcx
leaq 0x48(%rax), %rdx
movq %rdx, %rax
cmpq %rbx, %rdx
jne 0x2198a
jmp 0x219c6
xorl %r15d, %r15d
xorps %xmm2, %xmm2
movss %xmm2, 0x4(%rsp)
movq (%r14), %rsi
leaq 0x20(%rsp), %rdi
movq %rsi, (%rdi)
movb $0x0, 0x8(%rdi)
movzbl 0x169(%rsi), %edx
addq $0x16c, %rsi # imm = 0x16C
callq 0x1f7ea
movss 0x4(%rsp), %xmm1
ucomiss 0x21b31(%rip), %xmm0 # 0x4352c
jbe 0x21b34
xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm1
jbe 0x21b34
movq (%r14), %rax
movb 0x181(%rax), %al
cmpb $0x1, %al
jne 0x21aa4
divss %xmm1, %xmm0
movss %xmm0, 0x4(%rsp)
movss 0x30(%r14), %xmm0
movss 0x34(%r14), %xmm1
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xc9dc
movss 0x216ab(%rip), %xmm1 # 0x430f4
movq %r15, %rdi
movss 0x4(%rsp), %xmm0
callq 0xc9ea
movss 0x30(%r14), %xmm0
movss 0x34(%r14), %xmm1
movaps 0x21696(%rip), %xmm2 # 0x43100
xorps %xmm2, %xmm0
xorps %xmm2, %xmm1
movq %r15, %rdi
callq 0xc996
cmpq %rbx, %r14
je 0x21b34
movq %r14, %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x18(%rax)
movups 0x8(%rsp), %xmm0
movups %xmm0, 0x8(%rax)
addq $0x48, %rax
cmpq %rbx, %rax
jne 0x21a84
jmp 0x21b34
cmpq $0x2, %r15
jb 0x21b34
testb %al, %al
jne 0x21c36
decq %r15
js 0x21ac5
xorps %xmm2, %xmm2
cvtsi2ss %r15, %xmm2
jmp 0x21ade
movq %r15, %rax
shrq %rax
andl $0x1, %r15d
orq %rax, %r15
xorps %xmm2, %xmm2
cvtsi2ss %r15, %xmm2
addss %xmm2, %xmm2
cmpq %rbx, %r14
je 0x21b34
subss %xmm1, %xmm0
divss %xmm2, %xmm0
xorl %eax, %eax
movq %r14, %rcx
testq %rax, %rax
js 0x21aff
xorps %xmm1, %xmm1
cvtsi2ss %rax, %xmm1
jmp 0x21b19
movq %rax, %rdx
shrq %rdx
movl %eax, %esi
andl $0x1, %esi
orq %rdx, %rsi
xorps %xmm1, %xmm1
cvtsi2ss %rsi, %xmm1
addss %xmm1, %xmm1
mulss %xmm0, %xmm1
addss 0x30(%rcx), %xmm1
movss %xmm1, 0x30(%rcx)
addq 0x28(%rcx), %rax
addq $0x48, %rcx
cmpq %rbx, %rcx
jne 0x21af0
movq (%r14), %rcx
movb 0x1c4(%rcx), %al
movzbl 0x1c2(%rcx), %ecx
testl %ecx, %ecx
je 0x21b5a
cmpl $0x1, %ecx
je 0x21b64
cmpl $0x2, %ecx
jne 0x21bf8
xorl %edx, %edx
jmp 0x21b5c
movb $0x1, %dl
cmpb %dl, %al
jne 0x21bee
xorps %xmm0, %xmm0
cmpq %rbx, %r14
je 0x21ba1
xorl %esi, %esi
movq %r14, %rdx
addss 0x3c(%rdx), %xmm0
testq %rsi, %rsi
je 0x21b92
movss 0x30(%rdx), %xmm1
movss 0x30(%rsi), %xmm2
addss 0x3c(%rsi), %xmm2
subss %xmm2, %xmm1
addss %xmm1, %xmm0
movq %rdx, %rsi
leaq 0x48(%rdx), %rdi
movq %rdi, %rdx
cmpq %rbx, %rdi
jne 0x21b71
cmpl $0x2, %ecx
je 0x21bc2
cmpl $0x1, %ecx
je 0x21bb8
testl %ecx, %ecx
jne 0x21c17
testb %al, %al
jne 0x21bc9
xorps %xmm1, %xmm1
jmp 0x21be9
mulss 0x22970(%rip), %xmm0 # 0x44530
jmp 0x21bd0
xorps %xmm1, %xmm1
testb %al, %al
jne 0x21be9
xorps 0x21530(%rip), %xmm0 # 0x43100
movaps %xmm0, %xmm1
jmp 0x21be9
movss 0x30(%r14), %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x30(%r14)
addq $0x48, %r14
cmpq %rbx, %r14
jne 0x21bd5
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x219ea(%rip), %rdi # 0x435e9
leaq 0x229c0(%rip), %rsi # 0x445c6
leaq 0x22bd6(%rip), %rcx # 0x447e3
movl $0x6b, %edx
callq 0xa200
leaq 0x219cb(%rip), %rdi # 0x435e9
leaq 0x229a1(%rip), %rsi # 0x445c6
leaq 0x22c02(%rip), %rcx # 0x4482e
movl $0x80, %edx
callq 0xa200
leaq 0x22b17(%rip), %rdi # 0x44754
leaq 0x22982(%rip), %rsi # 0x445c6
leaq 0x22b48(%rip), %rcx # 0x44793
movl $0xa5, %edx
callq 0xa200
nop
| _ZN7lunasvgL15handleTextChunkEN9__gnu_cxx17__normal_iteratorIPNS_15SVGTextFragmentESt6vectorIS2_SaIS2_EEEES7_:
push r15
push r14
push rbx
sub rsp, 30h
mov rbx, rsi
mov r14, rdi
mov rdi, [rdi]
mov esi, 44h ; 'D'
call _ZNK7lunasvg10SVGElement12hasAttributeENS_10PropertyIDE; lunasvg::SVGElement::hasAttribute(lunasvg::PropertyID)
test al, al
jz loc_21B34
cmp r14, rbx
jz short loc_219C0
xorps xmm2, xmm2
xor r15d, r15d
xor ecx, ecx
mov rax, r14
loc_2198A:
addss xmm2, dword ptr [rax+3Ch]
test rcx, rcx
jz short loc_219AB
movss xmm0, dword ptr [rax+30h]
movss xmm1, dword ptr [rcx+30h]
addss xmm1, dword ptr [rcx+3Ch]
subss xmm0, xmm1
addss xmm2, xmm0
loc_219AB:
add r15, [rax+28h]
mov rcx, rax
lea rdx, [rax+48h]
mov rax, rdx
cmp rdx, rbx
jnz short loc_2198A
jmp short loc_219C6
loc_219C0:
xor r15d, r15d
xorps xmm2, xmm2
loc_219C6:
movss [rsp+48h+var_44], xmm2
mov rsi, [r14]
lea rdi, [rsp+48h+var_28]
mov [rdi], rsi
mov byte ptr [rdi+8], 0
movzx edx, byte ptr [rsi+169h]
add rsi, 16Ch
call _ZNK7lunasvg13LengthContext14valueForLengthERKNS_6LengthENS_15LengthDirectionE; lunasvg::LengthContext::valueForLength(lunasvg::Length const&,lunasvg::LengthDirection)
movss xmm1, [rsp+48h+var_44]
ucomiss xmm0, cs:dword_4352C
jbe loc_21B34
xorps xmm2, xmm2
ucomiss xmm1, xmm2
jbe loc_21B34
mov rax, [r14]
mov al, [rax+181h]
cmp al, 1
jnz loc_21AA4
divss xmm0, xmm1
movss [rsp+48h+var_44], xmm0
movss xmm0, dword ptr [r14+30h]; float
movss xmm1, dword ptr [r14+34h]; float
lea r15, [rsp+48h+var_40]
mov rdi, r15; this
call _ZN7lunasvg9Transform10translatedEff; lunasvg::Transform::translated(float,float)
movss xmm1, cs:flt_430F4; float
mov rdi, r15; this
movss xmm0, [rsp+48h+var_44]; float
call _ZN7lunasvg9Transform5scaleEff; lunasvg::Transform::scale(float,float)
movss xmm0, dword ptr [r14+30h]
movss xmm1, dword ptr [r14+34h]
movaps xmm2, cs:xmmword_43100
xorps xmm0, xmm2; float
xorps xmm1, xmm2; float
mov rdi, r15; this
call _ZN7lunasvg9Transform9translateEff; lunasvg::Transform::translate(float,float)
cmp r14, rbx
jz loc_21B34
mov rax, r14
loc_21A84:
mov rcx, [rsp+48h+var_30]
mov [rax+18h], rcx
movups xmm0, [rsp+48h+var_40]
movups xmmword ptr [rax+8], xmm0
add rax, 48h ; 'H'
cmp rax, rbx
jnz short loc_21A84
jmp loc_21B34
loc_21AA4:
cmp r15, 2
jb loc_21B34
test al, al
jnz loc_21C36
dec r15
js short loc_21AC5
xorps xmm2, xmm2
cvtsi2ss xmm2, r15
jmp short loc_21ADE
loc_21AC5:
mov rax, r15
shr rax, 1
and r15d, 1
or r15, rax
xorps xmm2, xmm2
cvtsi2ss xmm2, r15
addss xmm2, xmm2
loc_21ADE:
cmp r14, rbx
jz short loc_21B34
subss xmm0, xmm1
divss xmm0, xmm2
xor eax, eax
mov rcx, r14
loc_21AF0:
test rax, rax
js short loc_21AFF
xorps xmm1, xmm1
cvtsi2ss xmm1, rax
jmp short loc_21B19
loc_21AFF:
mov rdx, rax
shr rdx, 1
mov esi, eax
and esi, 1
or rsi, rdx
xorps xmm1, xmm1
cvtsi2ss xmm1, rsi
addss xmm1, xmm1
loc_21B19:
mulss xmm1, xmm0
addss xmm1, dword ptr [rcx+30h]
movss dword ptr [rcx+30h], xmm1
add rax, [rcx+28h]
add rcx, 48h ; 'H'
cmp rcx, rbx
jnz short loc_21AF0
loc_21B34:
mov rcx, [r14]
mov al, [rcx+1C4h]
movzx ecx, byte ptr [rcx+1C2h]
test ecx, ecx
jz short loc_21B5A
cmp ecx, 1
jz short loc_21B64
cmp ecx, 2
jnz loc_21BF8
xor edx, edx
jmp short loc_21B5C
loc_21B5A:
mov dl, 1
loc_21B5C:
cmp al, dl
jnz loc_21BEE
loc_21B64:
xorps xmm0, xmm0
cmp r14, rbx
jz short loc_21BA1
xor esi, esi
mov rdx, r14
loc_21B71:
addss xmm0, dword ptr [rdx+3Ch]
test rsi, rsi
jz short loc_21B92
movss xmm1, dword ptr [rdx+30h]
movss xmm2, dword ptr [rsi+30h]
addss xmm2, dword ptr [rsi+3Ch]
subss xmm1, xmm2
addss xmm0, xmm1
loc_21B92:
mov rsi, rdx
lea rdi, [rdx+48h]
mov rdx, rdi
cmp rdi, rbx
jnz short loc_21B71
loc_21BA1:
cmp ecx, 2
jz short loc_21BC2
cmp ecx, 1
jz short loc_21BB8
test ecx, ecx
jnz short loc_21C17
test al, al
jnz short loc_21BC9
xorps xmm1, xmm1
jmp short loc_21BE9
loc_21BB8:
mulss xmm0, cs:dword_44530
jmp short loc_21BD0
loc_21BC2:
xorps xmm1, xmm1
test al, al
jnz short loc_21BE9
loc_21BC9:
xorps xmm0, cs:xmmword_43100
loc_21BD0:
movaps xmm1, xmm0
jmp short loc_21BE9
loc_21BD5:
movss xmm0, dword ptr [r14+30h]
addss xmm0, xmm1
movss dword ptr [r14+30h], xmm0
add r14, 48h ; 'H'
loc_21BE9:
cmp r14, rbx
jnz short loc_21BD5
loc_21BEE:
add rsp, 30h
pop rbx
pop r14
pop r15
retn
loc_21BF8:
lea rdi, aFalse; "false"
lea rsi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aBoolLunasvgNee; "bool lunasvg::needsTextAnchorAdjustment"...
mov edx, 6Bh ; 'k'
call ___assert_fail
loc_21C17:
lea rdi, aFalse; "false"
lea rsi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aFloatLunasvgCa; "float lunasvg::calculateTextAnchorOffse"...
mov edx, 80h
call ___assert_fail
loc_21C36:
lea rdi, aFirstfragmentE; "firstFragment.element->lengthAdjust() ="...
lea rsi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidLunasvgHan; "void lunasvg::handleTextChunk(SVGTextFr"...
mov edx, 0A5h
call ___assert_fail
| char lunasvg::handleTextChunk(float *a1, float *a2)
{
float *v3; // r14
float v4; // xmm2_4
unsigned long long v5; // r15
float *v6; // rcx
float *v7; // rax
float v8; // xmm0_4
float v9; // xmm1_4
char v10; // al
float *v11; // rax
long long v12; // r15
float v13; // xmm2_4
float v14; // xmm0_4
long long v15; // rax
float *v16; // rcx
float v17; // xmm1_4
char result; // al
int v19; // ecx
char v20; // dl
float v21; // xmm0_4
float *v22; // rsi
float *v23; // rdx
float v24; // xmm1_4
float v25; // xmm0_4
__int128 v26; // [rsp+8h] [rbp-40h] BYREF
long long v27; // [rsp+18h] [rbp-30h]
long long v28; // [rsp+20h] [rbp-28h] BYREF
char v29; // [rsp+28h] [rbp-20h]
v3 = a1;
if ( lunasvg::SVGElement::hasAttribute(*(_QWORD *)a1, 68) )
{
if ( a1 == a2 )
{
v5 = 0LL;
v4 = 0.0;
}
else
{
v4 = 0.0;
v5 = 0LL;
v6 = 0LL;
v7 = a1;
do
{
v4 = v4 + v7[15];
if ( v6 )
v4 = v4 + (float)(v7[12] - (float)(v6[12] + v6[15]));
v5 += *((_QWORD *)v7 + 5);
v6 = v7;
v7 += 18;
}
while ( v7 != a2 );
}
v28 = *(_QWORD *)a1;
v29 = 0;
v8 = lunasvg::LengthContext::valueForLength(&v28, (unsigned __int8 *)(v28 + 364), *(_BYTE *)(v28 + 361));
v9 = v4;
if ( v8 > 0.0 && v4 > 0.0 )
{
v10 = *(_BYTE *)(*(_QWORD *)a1 + 385LL);
if ( v10 == 1 )
{
lunasvg::Transform::translated((lunasvg::Transform *)&v26, a1[12], a1[13]);
lunasvg::Transform::scale((lunasvg::Transform *)&v26, v8 / v4, 1.0);
lunasvg::Transform::translate((lunasvg::Transform *)&v26, -a1[12], -a1[13]);
if ( a1 != a2 )
{
v11 = a1;
do
{
*((_QWORD *)v11 + 3) = v27;
*(_OWORD *)(v11 + 2) = v26;
v11 += 18;
}
while ( v11 != a2 );
}
}
else if ( v5 >= 2 )
{
if ( v10 )
__assert_fail(
"firstFragment.element->lengthAdjust() == LengthAdjust::Spacing",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/source/svgtextelement.cpp",
165LL,
"void lunasvg::handleTextChunk(SVGTextFragmentIterator, SVGTextFragmentIterator)");
v12 = v5 - 1;
if ( v12 < 0 )
v13 = (float)(int)(((unsigned long long)v12 >> 1) | v12 & 1)
+ (float)(int)(((unsigned long long)v12 >> 1) | v12 & 1);
else
v13 = (float)(int)v12;
if ( a1 != a2 )
{
v14 = (float)(v8 - v9) / v13;
v15 = 0LL;
v16 = a1;
do
{
if ( v15 < 0 )
v17 = (float)(int)(((unsigned long long)v15 >> 1) | v15 & 1)
+ (float)(int)(((unsigned long long)v15 >> 1) | v15 & 1);
else
v17 = (float)(int)v15;
v16[12] = (float)(v17 * v14) + v16[12];
v15 += *((_QWORD *)v16 + 5);
v16 += 18;
}
while ( v16 != a2 );
}
}
}
}
result = *(_BYTE *)(*(_QWORD *)a1 + 452LL);
v19 = *(unsigned __int8 *)(*(_QWORD *)a1 + 450LL);
if ( *(_BYTE *)(*(_QWORD *)a1 + 450LL) )
{
if ( v19 == 1 )
goto LABEL_33;
if ( v19 != 2 )
__assert_fail(
"false",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/source/svgtextelement.cpp",
107LL,
"bool lunasvg::needsTextAnchorAdjustment(const SVGTextPositioningElement *)");
v20 = 0;
}
else
{
v20 = 1;
}
if ( result != v20 )
return result;
LABEL_33:
v21 = 0.0;
if ( a1 != a2 )
{
v22 = 0LL;
v23 = a1;
do
{
v21 = v21 + v23[15];
if ( v22 )
v21 = v21 + (float)(v23[12] - (float)(v22[12] + v22[15]));
v22 = v23;
v23 += 18;
}
while ( v23 != a2 );
}
if ( v19 == 2 )
{
v24 = 0.0;
if ( result )
goto LABEL_48;
goto LABEL_45;
}
if ( v19 != 1 )
{
if ( *(_BYTE *)(*(_QWORD *)a1 + 450LL) )
__assert_fail(
"false",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/source/svgtextelement.cpp",
128LL,
"float lunasvg::calculateTextAnchorOffset(const SVGTextPositioningElement *, float)");
if ( !result )
{
v24 = 0.0;
goto LABEL_48;
}
LABEL_45:
v25 = -v21;
goto LABEL_46;
}
v25 = v21 * -0.5;
LABEL_46:
v24 = v25;
LABEL_48:
while ( v3 != a2 )
{
v3[12] = v3[12] + v24;
v3 += 18;
}
return result;
}
| handleTextChunk:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV RBX,RSI
MOV R14,RDI
MOV RDI,qword ptr [RDI]
MOV ESI,0x44
CALL 0x0010f1c8
TEST AL,AL
JZ 0x00121b34
CMP R14,RBX
JZ 0x001219c0
XORPS XMM2,XMM2
XOR R15D,R15D
XOR ECX,ECX
MOV RAX,R14
LAB_0012198a:
ADDSS XMM2,dword ptr [RAX + 0x3c]
TEST RCX,RCX
JZ 0x001219ab
MOVSS XMM0,dword ptr [RAX + 0x30]
MOVSS XMM1,dword ptr [RCX + 0x30]
ADDSS XMM1,dword ptr [RCX + 0x3c]
SUBSS XMM0,XMM1
ADDSS XMM2,XMM0
LAB_001219ab:
ADD R15,qword ptr [RAX + 0x28]
MOV RCX,RAX
LEA RDX,[RAX + 0x48]
MOV RAX,RDX
CMP RDX,RBX
JNZ 0x0012198a
JMP 0x001219c6
LAB_001219c0:
XOR R15D,R15D
XORPS XMM2,XMM2
LAB_001219c6:
MOVSS dword ptr [RSP + 0x4],XMM2
MOV RSI,qword ptr [R14]
LEA RDI,[RSP + 0x20]
MOV qword ptr [RDI],RSI
MOV byte ptr [RDI + 0x8],0x0
MOVZX EDX,byte ptr [RSI + 0x169]
ADD RSI,0x16c
CALL 0x0011f7ea
MOVSS XMM1,dword ptr [RSP + 0x4]
UCOMISS XMM0,dword ptr [0x0014352c]
JBE 0x00121b34
XORPS XMM2,XMM2
UCOMISS XMM1,XMM2
JBE 0x00121b34
MOV RAX,qword ptr [R14]
MOV AL,byte ptr [RAX + 0x181]
CMP AL,0x1
JNZ 0x00121aa4
DIVSS XMM0,XMM1
MOVSS dword ptr [RSP + 0x4],XMM0
MOVSS XMM0,dword ptr [R14 + 0x30]
MOVSS XMM1,dword ptr [R14 + 0x34]
LEA R15,[RSP + 0x8]
MOV RDI,R15
CALL 0x0010c9dc
MOVSS XMM1,dword ptr [0x001430f4]
MOV RDI,R15
MOVSS XMM0,dword ptr [RSP + 0x4]
CALL 0x0010c9ea
MOVSS XMM0,dword ptr [R14 + 0x30]
MOVSS XMM1,dword ptr [R14 + 0x34]
MOVAPS XMM2,xmmword ptr [0x00143100]
XORPS XMM0,XMM2
XORPS XMM1,XMM2
MOV RDI,R15
CALL 0x0010c996
CMP R14,RBX
JZ 0x00121b34
MOV RAX,R14
LAB_00121a84:
MOV RCX,qword ptr [RSP + 0x18]
MOV qword ptr [RAX + 0x18],RCX
MOVUPS XMM0,xmmword ptr [RSP + 0x8]
MOVUPS xmmword ptr [RAX + 0x8],XMM0
ADD RAX,0x48
CMP RAX,RBX
JNZ 0x00121a84
JMP 0x00121b34
LAB_00121aa4:
CMP R15,0x2
JC 0x00121b34
TEST AL,AL
JNZ 0x00121c36
DEC R15
JS 0x00121ac5
XORPS XMM2,XMM2
CVTSI2SS XMM2,R15
JMP 0x00121ade
LAB_00121ac5:
MOV RAX,R15
SHR RAX,0x1
AND R15D,0x1
OR R15,RAX
XORPS XMM2,XMM2
CVTSI2SS XMM2,R15
ADDSS XMM2,XMM2
LAB_00121ade:
CMP R14,RBX
JZ 0x00121b34
SUBSS XMM0,XMM1
DIVSS XMM0,XMM2
XOR EAX,EAX
MOV RCX,R14
LAB_00121af0:
TEST RAX,RAX
JS 0x00121aff
XORPS XMM1,XMM1
CVTSI2SS XMM1,RAX
JMP 0x00121b19
LAB_00121aff:
MOV RDX,RAX
SHR RDX,0x1
MOV ESI,EAX
AND ESI,0x1
OR RSI,RDX
XORPS XMM1,XMM1
CVTSI2SS XMM1,RSI
ADDSS XMM1,XMM1
LAB_00121b19:
MULSS XMM1,XMM0
ADDSS XMM1,dword ptr [RCX + 0x30]
MOVSS dword ptr [RCX + 0x30],XMM1
ADD RAX,qword ptr [RCX + 0x28]
ADD RCX,0x48
CMP RCX,RBX
JNZ 0x00121af0
LAB_00121b34:
MOV RCX,qword ptr [R14]
MOV AL,byte ptr [RCX + 0x1c4]
MOVZX ECX,byte ptr [RCX + 0x1c2]
TEST ECX,ECX
JZ 0x00121b5a
CMP ECX,0x1
JZ 0x00121b64
CMP ECX,0x2
JNZ 0x00121bf8
XOR EDX,EDX
JMP 0x00121b5c
LAB_00121b5a:
MOV DL,0x1
LAB_00121b5c:
CMP AL,DL
JNZ 0x00121bee
LAB_00121b64:
XORPS XMM0,XMM0
CMP R14,RBX
JZ 0x00121ba1
XOR ESI,ESI
MOV RDX,R14
LAB_00121b71:
ADDSS XMM0,dword ptr [RDX + 0x3c]
TEST RSI,RSI
JZ 0x00121b92
MOVSS XMM1,dword ptr [RDX + 0x30]
MOVSS XMM2,dword ptr [RSI + 0x30]
ADDSS XMM2,dword ptr [RSI + 0x3c]
SUBSS XMM1,XMM2
ADDSS XMM0,XMM1
LAB_00121b92:
MOV RSI,RDX
LEA RDI,[RDX + 0x48]
MOV RDX,RDI
CMP RDI,RBX
JNZ 0x00121b71
LAB_00121ba1:
CMP ECX,0x2
JZ 0x00121bc2
CMP ECX,0x1
JZ 0x00121bb8
TEST ECX,ECX
JNZ 0x00121c17
TEST AL,AL
JNZ 0x00121bc9
XORPS XMM1,XMM1
JMP 0x00121be9
LAB_00121bb8:
MULSS XMM0,dword ptr [0x00144530]
JMP 0x00121bd0
LAB_00121bc2:
XORPS XMM1,XMM1
TEST AL,AL
JNZ 0x00121be9
LAB_00121bc9:
XORPS XMM0,xmmword ptr [0x00143100]
LAB_00121bd0:
MOVAPS XMM1,XMM0
JMP 0x00121be9
LAB_00121bd5:
MOVSS XMM0,dword ptr [R14 + 0x30]
ADDSS XMM0,XMM1
MOVSS dword ptr [R14 + 0x30],XMM0
ADD R14,0x48
LAB_00121be9:
CMP R14,RBX
JNZ 0x00121bd5
LAB_00121bee:
ADD RSP,0x30
POP RBX
POP R14
POP R15
RET
LAB_00121bf8:
LEA RDI,[0x1435e9]
LEA RSI,[0x1445c6]
LEA RCX,[0x1447e3]
MOV EDX,0x6b
CALL 0x0010a200
LAB_00121c17:
LEA RDI,[0x1435e9]
LEA RSI,[0x1445c6]
LEA RCX,[0x14482e]
MOV EDX,0x80
CALL 0x0010a200
LAB_00121c36:
LEA RDI,[0x144754]
LEA RSI,[0x1445c6]
LEA RCX,[0x144793]
MOV EDX,0xa5
CALL 0x0010a200
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* lunasvg::handleTextChunk(__gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment*,
std::vector<lunasvg::SVGTextFragment, std::allocator<lunasvg::SVGTextFragment> > >,
__gnu_cxx::__normal_iterator<lunasvg::SVGTextFragment*, std::vector<lunasvg::SVGTextFragment,
std::allocator<lunasvg::SVGTextFragment> > >) */
void lunasvg::handleTextChunk(long *param_1,long *param_2)
{
char cVar1;
char cVar2;
long *plVar3;
long *plVar4;
ulong uVar5;
long *plVar6;
char cVar7;
ulong uVar8;
float fVar9;
float fVar10;
long local_40;
long lStack_38;
long local_30;
long local_28;
int1 local_20;
cVar2 = SVGElement::hasAttribute((SVGElement *)*param_1);
if (cVar2 != '\0') {
if (param_1 == param_2) {
uVar8 = 0;
fVar10 = 0.0;
}
else {
fVar10 = 0.0;
uVar8 = 0;
plVar4 = param_1;
plVar6 = (long *)0x0;
do {
plVar3 = plVar4;
fVar10 = fVar10 + *(float *)((long)plVar3 + 0x3c);
if (plVar6 != (long *)0x0) {
fVar10 = fVar10 + (*(float *)(plVar3 + 6) -
(*(float *)(plVar6 + 6) + *(float *)((long)plVar6 + 0x3c)));
}
uVar8 = uVar8 + plVar3[5];
plVar4 = plVar3 + 9;
plVar6 = plVar3;
} while (plVar3 + 9 != param_2);
}
local_28 = *param_1;
local_20 = 0;
fVar9 = (float)LengthContext::valueForLength
((LengthContext *)&local_28,local_28 + 0x16c,
*(int1 *)(local_28 + 0x169));
if ((DAT_0014352c < fVar9) && (0.0 < fVar10)) {
if (*(char *)(*param_1 + 0x181) == '\x01') {
Transform::translated(*(float *)(param_1 + 6),*(float *)((long)param_1 + 0x34));
Transform::scale(fVar9 / fVar10,DAT_001430f4);
Transform::translate
((float)(*(uint *)(param_1 + 6) ^ _DAT_00143100),
(float)(*(uint *)((long)param_1 + 0x34) ^ _DAT_00143100));
plVar4 = param_1;
if (param_1 != param_2) {
do {
plVar4[3] = local_30;
plVar4[1] = local_40;
plVar4[2] = lStack_38;
plVar4 = plVar4 + 9;
} while (plVar4 != param_2);
}
}
else if (1 < uVar8) {
if (*(char *)(*param_1 + 0x181) != '\0') {
/* WARNING: Subroutine does not return */
__assert_fail("firstFragment.element->lengthAdjust() == LengthAdjust::Spacing",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/source/svgtextelement.cpp"
,0xa5,
"void lunasvg::handleTextChunk(SVGTextFragmentIterator, SVGTextFragmentIterator)"
);
}
if (param_1 != param_2) {
uVar5 = 0;
plVar4 = param_1;
do {
*(float *)(plVar4 + 6) =
(float)uVar5 * ((fVar9 - fVar10) / (float)(uVar8 - 1)) + *(float *)(plVar4 + 6);
uVar5 = uVar5 + plVar4[5];
plVar4 = plVar4 + 9;
} while (plVar4 != param_2);
}
}
}
}
cVar2 = *(char *)(*param_1 + 0x1c4);
cVar1 = *(char *)(*param_1 + 0x1c2);
if (cVar1 == '\0') {
cVar7 = '\x01';
LAB_00121b5c:
if (cVar2 != cVar7) {
return;
}
}
else if (cVar1 != '\x01') {
if (cVar1 != '\x02') {
/* WARNING: Subroutine does not return */
__assert_fail("false",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/source/svgtextelement.cpp"
,0x6b,
"bool lunasvg::needsTextAnchorAdjustment(const SVGTextPositioningElement *)");
}
cVar7 = '\0';
goto LAB_00121b5c;
}
fVar10 = 0.0;
if (param_1 != param_2) {
plVar4 = param_1;
plVar6 = (long *)0x0;
do {
plVar3 = plVar4;
fVar10 = fVar10 + *(float *)((long)plVar3 + 0x3c);
if (plVar6 != (long *)0x0) {
fVar10 = fVar10 + (*(float *)(plVar3 + 6) -
(*(float *)(plVar6 + 6) + *(float *)((long)plVar6 + 0x3c)));
}
plVar4 = plVar3 + 9;
plVar6 = plVar3;
} while (plVar3 + 9 != param_2);
}
if (cVar1 == '\x02') {
fVar9 = 0.0;
if (cVar2 != '\0') goto LAB_00121be9;
}
else {
if (cVar1 == '\x01') {
fVar9 = fVar10 * _DAT_00144530;
goto LAB_00121be9;
}
if (cVar1 != '\0') {
/* WARNING: Subroutine does not return */
__assert_fail("false",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/source/svgtextelement.cpp"
,0x80,
"float lunasvg::calculateTextAnchorOffset(const SVGTextPositioningElement *, float)"
);
}
if (cVar2 == '\0') {
fVar9 = 0.0;
goto LAB_00121be9;
}
}
fVar9 = (float)((uint)fVar10 ^ _DAT_00143100);
LAB_00121be9:
for (; param_1 != param_2; param_1 = param_1 + 9) {
*(float *)(param_1 + 6) = *(float *)(param_1 + 6) + fVar9;
}
return;
}
| |
52,905 | testing::internal::(anonymous namespace)::SplitEscapedString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | giladroyz[P]FindPeaks/build_O1/_deps/googletest-src/googletest/src/gtest.cc | std::vector<std::string> SplitEscapedString(const std::string& str) {
std::vector<std::string> lines;
size_t start = 0, end = str.size();
if (end > 2 && str[0] == '"' && str[end - 1] == '"') {
++start;
--end;
}
bool escaped = false;
for (size_t i = start; i + 1 < end; ++i) {
if (escaped) {
escaped = false;
if (str[i] == 'n') {
lines.push_back(str.substr(start, i - start - 1));
start = i + 1;
}
} else {
escaped = str[i] == '\\';
}
}
lines.push_back(str.substr(start, end - start));
return lines;
} | O1 | cpp | testing::internal::(anonymous namespace)::SplitEscapedString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %r15
cmpq $0x3, %r15
jb 0x1e0fd
movq (%r14), %rax
cmpb $0x22, (%rax)
jne 0x1e0fd
xorl %edx, %edx
cmpb $0x22, -0x1(%rax,%r15)
leaq -0x1(%r15), %rax
sete %dl
cmoveq %rax, %r15
jmp 0x1e0ff
xorl %edx, %edx
leaq 0x1(%rdx), %rbp
cmpq %r15, %rbp
jae 0x1e174
leaq 0x18(%rsp), %r13
xorl %eax, %eax
leaq 0x8(%rsp), %r12
movq (%r14), %rcx
movb -0x1(%rcx,%rbp), %cl
testb $0x1, %al
je 0x1e162
cmpb $0x6e, %cl
jne 0x1e16a
movq %rbp, %rcx
subq %rdx, %rcx
addq $-0x2, %rcx
movq %r12, %rdi
movq %r14, %rsi
callq 0x8510
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3a1ee
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1e15b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84e0
xorl %eax, %eax
movq %rbp, %rdx
jmp 0x1e16c
cmpb $0x5c, %cl
sete %al
jmp 0x1e16c
xorl %eax, %eax
incq %rbp
cmpq %rbp, %r15
jne 0x1e114
subq %rdx, %r15
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x8510
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3a1ee
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1e1af
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84e0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x1e1e3
jmp 0x1e1f5
jmp 0x1e1f2
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1e1f5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84e0
jmp 0x1e1f5
movq %rax, %r14
movq %rbx, %rdi
callq 0x3244c
movq %r14, %rdi
callq 0x8990
| _ZN7testing8internal12_GLOBAL__N_118SplitEscapedStringERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r14, rsi
mov rbx, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
mov r15, [rsi+8]
cmp r15, 3
jb short loc_1E0FD
mov rax, [r14]
cmp byte ptr [rax], 22h ; '"'
jnz short loc_1E0FD
xor edx, edx
cmp byte ptr [rax+r15-1], 22h ; '"'
lea rax, [r15-1]
setz dl
cmovz r15, rax
jmp short loc_1E0FF
loc_1E0FD:
xor edx, edx
loc_1E0FF:
lea rbp, [rdx+1]
cmp rbp, r15
jnb short loc_1E174
lea r13, [rsp+58h+var_40]
xor eax, eax
lea r12, [rsp+58h+var_50]
loc_1E114:
mov rcx, [r14]
mov cl, [rcx+rbp-1]
test al, 1
jz short loc_1E162
cmp cl, 6Eh ; 'n'
jnz short loc_1E16A
mov rcx, rbp
sub rcx, rdx
add rcx, 0FFFFFFFFFFFFFFFEh
mov rdi, r12
mov rsi, r14
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
mov rdi, rbx
mov rsi, r12
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE12emplace_backIJS5_EEEvDpOT_; std::vector<std::string>::emplace_back<std::string>(std::string &&)
mov rdi, [rsp+58h+var_50]; void *
cmp rdi, r13
jz short loc_1E15B
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1E15B:
xor eax, eax
mov rdx, rbp
jmp short loc_1E16C
loc_1E162:
cmp cl, 5Ch ; '\'
setz al
jmp short loc_1E16C
loc_1E16A:
xor eax, eax
loc_1E16C:
inc rbp
cmp r15, rbp
jnz short loc_1E114
loc_1E174:
sub r15, rdx
lea rdi, [rsp+58h+var_50]
mov rsi, r14
mov rcx, r15
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
lea rsi, [rsp+58h+var_50]
mov rdi, rbx
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE12emplace_backIJS5_EEEvDpOT_; std::vector<std::string>::emplace_back<std::string>(std::string &&)
lea rax, [rsp+58h+var_40]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_1E1AF
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1E1AF:
mov rax, rbx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov r14, rax
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]
cmp rdi, rax
jnz short loc_1E1E3
jmp short loc_1E1F5
jmp short loc_1E1F2
mov r14, rax
mov rdi, [rsp+arg_0]; void *
cmp rdi, r13
jz short loc_1E1F5
loc_1E1E3:
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_1E1F5
loc_1E1F2:
mov r14, rax
loc_1E1F5:
mov rdi, rbx; void *
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rdi, r14
call __Unwind_Resume
| long long testing::internal::`anonymous namespace'::SplitEscapedString(long long a1, _QWORD *a2)
{
unsigned long long v2; // r15
_BYTE *v3; // rax
_BOOL8 v4; // rdx
long long v5; // rbp
bool v6; // al
char v7; // cl
void *v9[2]; // [rsp+8h] [rbp-50h] BYREF
_QWORD v10[8]; // [rsp+18h] [rbp-40h] BYREF
*(_OWORD *)a1 = 0LL;
*(_QWORD *)(a1 + 16) = 0LL;
v2 = a2[1];
if ( v2 >= 3 && (v3 = (_BYTE *)*a2, *(_BYTE *)*a2 == 34) )
{
v4 = v3[v2 - 1] == 34;
if ( v3[v2 - 1] == 34 )
--v2;
}
else
{
v4 = 0LL;
}
v5 = v4 + 1;
if ( v4 + 1 < v2 )
{
v6 = 0;
do
{
v7 = *(_BYTE *)(*a2 + v5 - 1);
if ( v6 )
{
if ( v7 == 110 )
{
std::string::substr(v9, a2, v4, v5 - v4 - 2);
std::vector<std::string>::emplace_back<std::string>(a1, v9);
if ( v9[0] != v10 )
operator delete(v9[0], v10[0] + 1LL);
v6 = 0;
v4 = v5;
}
else
{
v6 = 0;
}
}
else
{
v6 = v7 == 92;
}
++v5;
}
while ( v2 != v5 );
}
std::string::substr(v9, a2, v4, v2 - v4);
std::vector<std::string>::emplace_back<std::string>(a1, v9);
if ( v9[0] != v10 )
operator delete(v9[0], v10[0] + 1LL);
return a1;
}
| SplitEscapedString:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R14,RSI
MOV RBX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
MOV R15,qword ptr [RSI + 0x8]
CMP R15,0x3
JC 0x0011e0fd
MOV RAX,qword ptr [R14]
CMP byte ptr [RAX],0x22
JNZ 0x0011e0fd
XOR EDX,EDX
CMP byte ptr [RAX + R15*0x1 + -0x1],0x22
LEA RAX,[R15 + -0x1]
SETZ DL
CMOVZ R15,RAX
JMP 0x0011e0ff
LAB_0011e0fd:
XOR EDX,EDX
LAB_0011e0ff:
LEA RBP,[RDX + 0x1]
CMP RBP,R15
JNC 0x0011e174
LEA R13,[RSP + 0x18]
XOR EAX,EAX
LEA R12,[RSP + 0x8]
LAB_0011e114:
MOV RCX,qword ptr [R14]
MOV CL,byte ptr [RCX + RBP*0x1 + -0x1]
TEST AL,0x1
JZ 0x0011e162
CMP CL,0x6e
JNZ 0x0011e16a
MOV RCX,RBP
SUB RCX,RDX
ADD RCX,-0x2
LAB_0011e12e:
MOV RDI,R12
MOV RSI,R14
CALL 0x00108510
LAB_0011e139:
MOV RDI,RBX
MOV RSI,R12
CALL 0x0013a1ee
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R13
JZ 0x0011e15b
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001084e0
LAB_0011e15b:
XOR EAX,EAX
MOV RDX,RBP
JMP 0x0011e16c
LAB_0011e162:
CMP CL,0x5c
SETZ AL
JMP 0x0011e16c
LAB_0011e16a:
XOR EAX,EAX
LAB_0011e16c:
INC RBP
CMP R15,RBP
JNZ 0x0011e114
LAB_0011e174:
SUB R15,RDX
LAB_0011e177:
LEA RDI,[RSP + 0x8]
MOV RSI,R14
MOV RCX,R15
CALL 0x00108510
LAB_0011e187:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x0013a1ee
LAB_0011e194:
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0011e1af
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001084e0
LAB_0011e1af:
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* testing::internal::(anonymous namespace)::SplitEscapedString(std::__cxx11::string const&) */
_anonymous_namespace_ * __thiscall
testing::internal::(anonymous_namespace)::SplitEscapedString
(_anonymous_namespace_ *this,string *param_1)
{
char cVar1;
ulong uVar2;
ulong uVar3;
bool bVar4;
long *local_50 [2];
long local_40 [2];
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
uVar3 = *(ulong *)(param_1 + 8);
if ((uVar3 < 3) || (**(char **)param_1 != '\"')) {
uVar2 = 0;
}
else {
bVar4 = (*(char **)param_1)[uVar3 - 1] == '\"';
uVar2 = (ulong)bVar4;
if (bVar4) {
uVar3 = uVar3 - 1;
}
}
uVar2 = uVar2 + 1;
if (uVar2 < uVar3) {
bVar4 = false;
do {
cVar1 = *(char *)(*(long *)param_1 + -1 + uVar2);
if (bVar4) {
if (cVar1 == 'n') {
/* try { // try from 0011e12e to 0011e138 has its CatchHandler @ 0011e1f2 */
std::__cxx11::string::substr((ulong)local_50,(ulong)param_1);
/* try { // try from 0011e139 to 0011e143 has its CatchHandler @ 0011e1d6 */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::
emplace_back<std::__cxx11::string>
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)this,
(string *)local_50);
if (local_50[0] != local_40) {
operator_delete(local_50[0],local_40[0] + 1);
}
bVar4 = false;
}
else {
bVar4 = false;
}
}
else {
bVar4 = cVar1 == '\\';
}
uVar2 = uVar2 + 1;
} while (uVar3 != uVar2);
}
/* try { // try from 0011e177 to 0011e186 has its CatchHandler @ 0011e1d4 */
std::__cxx11::string::substr((ulong)local_50,(ulong)param_1);
/* try { // try from 0011e187 to 0011e193 has its CatchHandler @ 0011e1c1 */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::
emplace_back<std::__cxx11::string>
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)this,
(string *)local_50);
if (local_50[0] != local_40) {
operator_delete(local_50[0],local_40[0] + 1);
}
return this;
}
| |
52,906 | my_rnd_init | eloqsql/mysys/my_rnd.c | void my_rnd_init(struct my_rnd_struct *rand_st, ulong seed1, ulong seed2)
{
#ifdef HAVE_valgrind
bzero((char*) rand_st,sizeof(*rand_st)); /* Avoid UMC varnings */
#endif
rand_st->max_value= 0x3FFFFFFFL;
rand_st->max_value_dbl=(double) rand_st->max_value;
rand_st->seed1=seed1%rand_st->max_value ;
rand_st->seed2=seed2%rand_st->max_value;
} | O3 | c | my_rnd_init:
pushq %rbp
movq %rsp, %rbp
movq %rdx, %rcx
movq $0x3fffffff, 0x10(%rdi) # imm = 0x3FFFFFFF
movabsq $0x41cfffffff800000, %rax # imm = 0x41CFFFFFFF800000
movq %rax, 0x18(%rdi)
movabsq $0x400000011, %r8 # imm = 0x400000011
movq %rsi, %rax
mulq %r8
movq %rsi, %r9
subq %rdx, %r9
shrq %r9
addq %rdx, %r9
shrq $0x1d, %r9
movq %r9, %rax
shlq $0x1e, %rax
subq %rax, %r9
addq %rsi, %r9
movq %rcx, %rax
mulq %r8
movq %r9, (%rdi)
movq %rcx, %rax
subq %rdx, %rax
shrq %rax
addq %rdx, %rax
shrq $0x1d, %rax
movq %rax, %rdx
shlq $0x1e, %rdx
subq %rdx, %rax
addq %rcx, %rax
movq %rax, 0x8(%rdi)
popq %rbp
retq
| my_rnd_init:
push rbp
mov rbp, rsp
mov rcx, rdx
mov qword ptr [rdi+10h], 3FFFFFFFh
mov rax, 41CFFFFFFF800000h
mov [rdi+18h], rax
mov r8, 400000011h
mov rax, rsi
mul r8
mov r9, rsi
sub r9, rdx
shr r9, 1
add r9, rdx
shr r9, 1Dh
mov rax, r9
shl rax, 1Eh
sub r9, rax
add r9, rsi
mov rax, rcx
mul r8
mov [rdi], r9
mov rax, rcx
sub rax, rdx
shr rax, 1
add rax, rdx
shr rax, 1Dh
mov rdx, rax
shl rdx, 1Eh
sub rax, rdx
add rax, rcx
mov [rdi+8], rax
pop rbp
retn
| unsigned long long my_rnd_init(unsigned long long *a1, unsigned long long a2, unsigned long long a3)
{
unsigned long long result; // rax
a1[2] = 0x3FFFFFFFLL;
a1[3] = 0x41CFFFFFFF800000LL;
*a1 = a2 % 0x3FFFFFFF;
result = a3 % 0x3FFFFFFF;
a1[1] = a3 % 0x3FFFFFFF;
return result;
}
| my_rnd_init:
PUSH RBP
MOV RBP,RSP
MOV RCX,RDX
MOV qword ptr [RDI + 0x10],0x3fffffff
MOV RAX,0x41cfffffff800000
MOV qword ptr [RDI + 0x18],RAX
MOV R8,0x400000011
MOV RAX,RSI
MUL R8
MOV R9,RSI
SUB R9,RDX
SHR R9,0x1
ADD R9,RDX
SHR R9,0x1d
MOV RAX,R9
SHL RAX,0x1e
SUB R9,RAX
ADD R9,RSI
MOV RAX,RCX
MUL R8
MOV qword ptr [RDI],R9
MOV RAX,RCX
SUB RAX,RDX
SHR RAX,0x1
ADD RAX,RDX
SHR RAX,0x1d
MOV RDX,RAX
SHL RDX,0x1e
SUB RAX,RDX
ADD RAX,RCX
MOV qword ptr [RDI + 0x8],RAX
POP RBP
RET
|
void my_rnd_init(ulong *param_1,ulong param_2,ulong param_3)
{
param_1[2] = 0x3fffffff;
param_1[3] = 0x41cfffffff800000;
*param_1 = param_2 % 0x3fffffff;
param_1[1] = param_3 % 0x3fffffff;
return;
}
| |
52,907 | inline_mysql_start_table_lock_wait | eloqsql/include/mysql/psi/mysql_table.h | static inline struct PSI_table_locker *
inline_mysql_start_table_lock_wait(PSI_table_locker_state *state,
struct PSI_table *psi,
enum PSI_table_lock_operation op,
ulong flags, const char *src_file, uint src_line)
{
if (psi_likely(psi != NULL))
{
struct PSI_table_locker *locker;
locker= PSI_TABLE_CALL(start_table_lock_wait)
(state, psi, op, flags, src_file, src_line);
return locker;
}
return NULL;
} | O0 | c | inline_mysql_start_table_lock_wait:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
cmpq $0x0, -0x18(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xf9d07
leaq 0x1c63e2(%rip), %rax # 0x2c00b8
movq (%rax), %rax
movq 0x1e0(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movl -0x34(%rbp), %r9d
callq *%rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xf9d0f
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
| inline_mysql_start_table_lock_wait:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov [rbp+var_34], r9d
cmp [rbp+var_18], 0
setnz al
and al, 1
movzx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_F9D07
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1E0h]
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov edx, [rbp+var_1C]
mov rcx, [rbp+var_28]
mov r8, [rbp+var_30]
mov r9d, [rbp+var_34]
call rax
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
mov [rbp+var_8], rax
jmp short loc_F9D0F
loc_F9D07:
mov [rbp+var_8], 0
loc_F9D0F:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
| long long inline_mysql_start_table_lock_wait(
long long a1,
long long a2,
unsigned int a3,
long long a4,
long long a5,
unsigned int a6)
{
if ( a2 )
return ((long long ( *)(long long, long long, _QWORD, long long, long long, _QWORD))PSI_server[60])(
a1,
a2,
a3,
a4,
a5,
a6);
else
return 0LL;
}
| inline_mysql_start_table_lock_wait:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV dword ptr [RBP + -0x34],R9D
CMP qword ptr [RBP + -0x18],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x001f9d07
LEA RAX,[0x3c00b8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1e0]
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x1c]
MOV RCX,qword ptr [RBP + -0x28]
MOV R8,qword ptr [RBP + -0x30]
MOV R9D,dword ptr [RBP + -0x34]
CALL RAX
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001f9d0f
LAB_001f9d07:
MOV qword ptr [RBP + -0x8],0x0
LAB_001f9d0f:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
int8
inline_mysql_start_table_lock_wait
(int8 param_1,long param_2,int4 param_3,int8 param_4,int8 param_5,
int4 param_6)
{
int8 local_10;
if (param_2 == 0) {
local_10 = 0;
}
else {
local_10 = (**(code **)(PSI_server + 0x1e0))(param_1,param_2,param_3,param_4,param_5,param_6);
}
return local_10;
}
| |
52,908 | el::Loggers::defaultTypedConfigurations() | opengl-water/src/easylogging++.cc | base::TypedConfigurations Loggers::defaultTypedConfigurations(void) {
return base::TypedConfigurations(
ELPP->registeredLoggers()->defaultConfigurations(),
ELPP->registeredLoggers()->logStreamsReference());
} | O3 | cpp | el::Loggers::defaultTypedConfigurations():
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x2cb8b(%rip), %rax # 0x5f510
movq (%rax), %rax
movq 0x18(%rax), %rax
leaq 0x58(%rax), %rsi
movq 0xa8(%rax), %rcx
movq %rcx, -0x18(%rbp)
movq 0xb0(%rax), %rax
movq %rax, -0x10(%rbp)
testq %rax, %rax
je 0x329c0
movq 0x2c5b6(%rip), %rcx # 0x5ef68
cmpb $0x0, (%rcx)
je 0x329bc
incl 0x8(%rax)
jmp 0x329c0
lock
incl 0x8(%rax)
leaq -0x18(%rbp), %rdx
movq %rbx, %rdi
callq 0x2d5c8
movq -0x10(%rbp), %rdi
testq %rdi, %rdi
je 0x329da
callq 0x35058
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq -0x10(%rbp), %rdi
testq %rdi, %rdi
je 0x329f5
callq 0x35058
movq %rbx, %rdi
callq 0x234d0
nop
| _ZN2el7Loggers26defaultTypedConfigurationsEv:
push rbp
mov rbp, rsp
push rbx
sub rsp, 18h
mov rbx, rdi
lea rax, _ZN2el4base9elStorageE; el::base::elStorage
mov rax, [rax]
mov rax, [rax+18h]
lea rsi, [rax+58h]
mov rcx, [rax+0A8h]
mov [rbp+var_18], rcx
mov rax, [rax+0B0h]
mov [rbp+var_10], rax
test rax, rax
jz short loc_329C0
mov rcx, cs:__libc_single_threaded_ptr
cmp byte ptr [rcx], 0
jz short loc_329BC
inc dword ptr [rax+8]
jmp short loc_329C0
loc_329BC:
lock inc dword ptr [rax+8]
loc_329C0:
lea rdx, [rbp+var_18]
mov rdi, rbx; this
call _ZN2el4base19TypedConfigurationsC2EPNS_14ConfigurationsESt10shared_ptrISt13unordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_ISt13basic_fstreamIcS9_EESt4hashISB_ESt8equal_toISB_ESaISt4pairIKSB_SE_EEEE; el::base::TypedConfigurations::TypedConfigurations(el::Configurations *,std::shared_ptr<std::unordered_map<std::string,std::shared_ptr<std::fstream>>>)
mov rdi, [rbp+var_10]
test rdi, rdi
jz short loc_329DA
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_329DA:
mov rax, rbx
add rsp, 18h
pop rbx
pop rbp
retn
mov rbx, rax
mov rdi, [rbp+var_10]
test rdi, rdi
jz short loc_329F5
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_329F5:
mov rdi, rbx
call __Unwind_Resume
| el::Loggers * el::Loggers::defaultTypedConfigurations(el::Loggers *this)
{
long long v1; // rax
long long v2; // rsi
long long v3; // rax
long long v5; // [rsp+8h] [rbp-18h] BYREF
long long v6; // [rsp+10h] [rbp-10h]
v1 = *((_QWORD *)el::base::elStorage + 3);
v2 = v1 + 88;
v5 = *(_QWORD *)(v1 + 168);
v3 = *(_QWORD *)(v1 + 176);
v6 = v3;
if ( v3 )
{
if ( _libc_single_threaded )
++*(_DWORD *)(v3 + 8);
else
_InterlockedIncrement((volatile signed __int32 *)(v3 + 8));
}
el::base::TypedConfigurations::TypedConfigurations(this, v2, &v5);
if ( v6 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v6, v2);
return this;
}
| defaultTypedConfigurations:
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
LEA RAX,[0x15f510]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x18]
LEA RSI,[RAX + 0x58]
MOV RCX,qword ptr [RAX + 0xa8]
MOV qword ptr [RBP + -0x18],RCX
MOV RAX,qword ptr [RAX + 0xb0]
MOV qword ptr [RBP + -0x10],RAX
TEST RAX,RAX
JZ 0x001329c0
MOV RCX,qword ptr [0x0015ef68]
CMP byte ptr [RCX],0x0
JZ 0x001329bc
INC dword ptr [RAX + 0x8]
JMP 0x001329c0
LAB_001329bc:
INC.LOCK dword ptr [RAX + 0x8]
LAB_001329c0:
LEA RDX,[RBP + -0x18]
MOV RDI,RBX
CALL 0x0012d5c8
LAB_001329cc:
MOV RDI,qword ptr [RBP + -0x10]
TEST RDI,RDI
JZ 0x001329da
CALL 0x00135058
LAB_001329da:
MOV RAX,RBX
ADD RSP,0x18
POP RBX
POP RBP
RET
|
/* el::Loggers::defaultTypedConfigurations() */
Loggers * __thiscall el::Loggers::defaultTypedConfigurations(Loggers *this)
{
long lVar1;
int8 local_20;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_18;
lVar1 = *(long *)(base::elStorage + 0x18);
local_20 = *(int8 *)(lVar1 + 0xa8);
local_18 = *(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(lVar1 + 0xb0);
if (local_18 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
if (*PTR___libc_single_threaded_0015ef68 == '\0') {
LOCK();
*(int *)(local_18 + 8) = *(int *)(local_18 + 8) + 1;
UNLOCK();
}
else {
*(int *)(local_18 + 8) = *(int *)(local_18 + 8) + 1;
}
}
/* try { // try from 001329c0 to 001329cb has its CatchHandler @ 001329e4 */
base::TypedConfigurations::TypedConfigurations((TypedConfigurations *)this,lVar1 + 0x58,&local_20)
;
if (local_18 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_18);
}
return this;
}
| |
52,909 | nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::parse<std::basic_ifstream<char, std::char_traits<char>>&>(std::basic_ifstream<char, std::char_traits<char>>&, std::function<bool (int, nlohmann::json_abi_v3_11_3::detail::parse_event_t, nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&)>, bool, bool) | msxemulator/build_O0/_deps/picotool-src/lib/nlohmann_json/single_include/nlohmann/json.hpp | JSON_HEDLEY_WARN_UNUSED_RESULT
static basic_json parse(InputType&& i,
const parser_callback_t cb = nullptr,
const bool allow_exceptions = true,
const bool ignore_comments = false)
{
basic_json result;
parser(detail::input_adapter(std::forward<InputType>(i)), cb, allow_exceptions, ignore_comments).parse(true, result);
return result;
} | O0 | cpp | nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::parse<std::basic_ifstream<char, std::char_traits<char>>&>(std::basic_ifstream<char, std::char_traits<char>>&, std::function<bool (int, nlohmann::json_abi_v3_11_3::detail::parse_event_t, nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&)>, bool, bool):
subq $0x148, %rsp # imm = 0x148
movq %rdx, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
movb %r8b, %al
movq %rdi, %r8
movq %r8, 0x18(%rsp)
movq %rdi, 0x140(%rsp)
movq %rsi, 0x138(%rsp)
movq %rdx, 0x130(%rsp)
andb $0x1, %cl
movb %cl, 0x12f(%rsp)
andb $0x1, %al
movb %al, 0x12e(%rsp)
movb $0x0, 0x12d(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0x60320
movq 0x138(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0xd12c0
jmp 0x603cc
movq 0x8(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0xd12f0
jmp 0x603dd
movzbl 0x12e(%rsp), %r8d
movzbl 0x12f(%rsp), %ecx
andl $0x1, %ecx
andl $0x1, %r8d
leaq 0x60(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0xd1210
jmp 0x6040b
movq 0x10(%rsp), %rdx
leaq 0x60(%rsp), %rdi
movl $0x1, %esi
callq 0xd13a0
jmp 0x60421
leaq 0x60(%rsp), %rdi
callq 0xd1a80
leaq 0x20(%rsp), %rdi
callq 0x605d0
leaq 0x50(%rsp), %rdi
callq 0xd1ab0
movb $0x1, 0x12d(%rsp)
testb $0x1, 0x12d(%rsp)
jne 0x604bb
jmp 0x604b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x604c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x604a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x6049b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x60(%rsp), %rdi
callq 0xd1a80
leaq 0x20(%rsp), %rdi
callq 0x605d0
leaq 0x50(%rsp), %rdi
callq 0xd1ab0
jmp 0x604c8
movq 0x10(%rsp), %rdi
callq 0x605a0
movq 0x18(%rsp), %rax
addq $0x148, %rsp # imm = 0x148
retq
movq 0x10(%rsp), %rdi
callq 0x605a0
movq 0x48(%rsp), %rdi
callq 0xf9e0
nopl (%rax)
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5parseIRSt14basic_ifstreamIcS7_EEESD_OT_St8functionIFbiNS0_6detail13parse_event_tERSD_EEbb:
sub rsp, 148h
mov [rsp+148h+var_140], rdx
mov [rsp+148h+var_138], rdi
mov al, r8b
mov r8, rdi
mov [rsp+148h+var_130], r8
mov [rsp+148h+var_8], rdi
mov [rsp+148h+var_10], rsi
mov [rsp+148h+var_18], rdx
and cl, 1
mov [rsp+148h+var_19], cl
and al, 1
mov [rsp+148h+var_1A], al
mov [rsp+148h+var_1B], 0
xor eax, eax
mov esi, eax
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2EDn; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(decltype(nullptr))
mov rsi, [rsp+148h+var_10]; std::istream *
lea rdi, [rsp+148h+var_F8]; this
call _ZN8nlohmann16json_abi_v3_11_36detail13input_adapterERSi; nlohmann::json_abi_v3_11_3::detail::input_adapter(std::istream &)
jmp short $+2
loc_603CC:
mov rsi, [rsp+148h+var_140]
lea rdi, [rsp+148h+var_128]
call _ZNSt8functionIFbiN8nlohmann16json_abi_v3_11_36detail13parse_event_tERNS1_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEEC2ERKSJ_; std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)>::function(std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)> const&)
jmp short $+2
loc_603DD:
movzx r8d, [rsp+148h+var_1A]
movzx ecx, [rsp+148h+var_19]
and ecx, 1
and r8d, 1
lea rdi, [rsp+148h+var_E8]
lea rsi, [rsp+148h+var_F8]
lea rdx, [rsp+148h+var_128]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6parserINS0_6detail20input_stream_adapterEEENSF_6parserISD_T_EESI_St8functionIFbiNSF_13parse_event_tERSD_EEbb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::parser<nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>(nlohmann::json_abi_v3_11_3::detail::input_stream_adapter,std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&)>,bool,bool)
jmp short $+2
loc_6040B:
mov rdx, [rsp+148h+var_138]
lea rdi, [rsp+148h+var_E8]
mov esi, 1
call _ZN8nlohmann16json_abi_v3_11_36detail6parserINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_20input_stream_adapterEE5parseEbRSF_; nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::parse(bool,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&)
jmp short $+2
loc_60421:
lea rdi, [rsp+148h+var_E8]
call _ZN8nlohmann16json_abi_v3_11_36detail6parserINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_20input_stream_adapterEED2Ev; nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::~parser()
lea rdi, [rsp+148h+var_128]
call _ZNSt8functionIFbiN8nlohmann16json_abi_v3_11_36detail13parse_event_tERNS1_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEED2Ev; std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)>::~function()
lea rdi, [rsp+148h+var_F8]; this
call _ZN8nlohmann16json_abi_v3_11_36detail20input_stream_adapterD2Ev; nlohmann::json_abi_v3_11_3::detail::input_stream_adapter::~input_stream_adapter()
mov [rsp+148h+var_1B], 1
test [rsp+148h+var_1B], 1
jnz short loc_604BB
jmp short loc_604B1
mov rcx, rax
mov eax, edx
mov [rsp+arg_40], rcx
mov [rsp+arg_3C], eax
jmp short loc_604C8
mov rcx, rax
mov eax, edx
mov [rsp+arg_40], rcx
mov [rsp+arg_3C], eax
jmp short loc_604A5
mov rcx, rax
mov eax, edx
mov [rsp+arg_40], rcx
mov [rsp+arg_3C], eax
jmp short loc_6049B
mov rcx, rax
mov eax, edx
mov [rsp+arg_40], rcx
mov [rsp+arg_3C], eax
lea rdi, [rsp+arg_58]
call _ZN8nlohmann16json_abi_v3_11_36detail6parserINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_20input_stream_adapterEED2Ev; nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::~parser()
loc_6049B:
lea rdi, [rsp+arg_18]
call _ZNSt8functionIFbiN8nlohmann16json_abi_v3_11_36detail13parse_event_tERNS1_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEED2Ev; std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)>::~function()
loc_604A5:
lea rdi, [rsp+arg_48]; this
call _ZN8nlohmann16json_abi_v3_11_36detail20input_stream_adapterD2Ev; nlohmann::json_abi_v3_11_3::detail::input_stream_adapter::~input_stream_adapter()
jmp short loc_604C8
loc_604B1:
mov rdi, [rsp+148h+var_138]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
loc_604BB:
mov rax, [rsp+148h+var_130]
add rsp, 148h
retn
loc_604C8:
mov rdi, [rsp+arg_8]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
mov rdi, [rsp+arg_40]
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::parse<std::ifstream &>(
long long a1,
std::istream *a2,
long long a3,
char a4,
char a5)
{
int v5; // edx
int v6; // ecx
int v7; // r8d
int v8; // r9d
int v9; // r9d
int v11; // [rsp+8h] [rbp-140h]
_BYTE v12[48]; // [rsp+20h] [rbp-128h] BYREF
_BYTE v13[16]; // [rsp+50h] [rbp-F8h] BYREF
_BYTE v14[206]; // [rsp+60h] [rbp-E8h] BYREF
char v15; // [rsp+12Eh] [rbp-1Ah]
char v16; // [rsp+12Fh] [rbp-19h]
long long v17; // [rsp+130h] [rbp-18h]
std::istream *v18; // [rsp+138h] [rbp-10h]
long long v19; // [rsp+140h] [rbp-8h]
v11 = a3;
v19 = a1;
v18 = a2;
v17 = a3;
v16 = a4 & 1;
v15 = a5 & 1;
v14[205] = 0;
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(a1);
nlohmann::json_abi_v3_11_3::detail::input_adapter((nlohmann::json_abi_v3_11_3::detail *)v13, a2);
std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> &)>::function(
(unsigned int)v12,
v11,
v5,
v6,
v7,
v8);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::parser<nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>(
(unsigned int)v14,
(unsigned int)v13,
(unsigned int)v12,
v16 & 1,
v15 & 1,
v9);
nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::parse(
v14,
1LL,
a1);
nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::~parser(v14);
std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> &)>::~function(v12);
nlohmann::json_abi_v3_11_3::detail::input_stream_adapter::~input_stream_adapter((nlohmann::json_abi_v3_11_3::detail::input_stream_adapter *)v13);
return a1;
}
| parse<std::ifstream&>:
SUB RSP,0x148
MOV qword ptr [RSP + 0x8],RDX
MOV qword ptr [RSP + 0x10],RDI
MOV AL,R8B
MOV R8,RDI
MOV qword ptr [RSP + 0x18],R8
MOV qword ptr [RSP + 0x140],RDI
MOV qword ptr [RSP + 0x138],RSI
MOV qword ptr [RSP + 0x130],RDX
AND CL,0x1
MOV byte ptr [RSP + 0x12f],CL
AND AL,0x1
MOV byte ptr [RSP + 0x12e],AL
MOV byte ptr [RSP + 0x12d],0x0
XOR EAX,EAX
MOV ESI,EAX
CALL 0x00160320
MOV RSI,qword ptr [RSP + 0x138]
LAB_001603c0:
LEA RDI,[RSP + 0x50]
CALL 0x001d12c0
JMP 0x001603cc
LAB_001603cc:
MOV RSI,qword ptr [RSP + 0x8]
LEA RDI,[RSP + 0x20]
CALL 0x001d12f0
JMP 0x001603dd
LAB_001603dd:
MOVZX R8D,byte ptr [RSP + 0x12e]
MOVZX ECX,byte ptr [RSP + 0x12f]
LAB_001603ee:
AND ECX,0x1
AND R8D,0x1
LEA RDI,[RSP + 0x60]
LEA RSI,[RSP + 0x50]
LEA RDX,[RSP + 0x20]
CALL 0x001d1210
JMP 0x0016040b
LAB_0016040b:
MOV RDX,qword ptr [RSP + 0x10]
LEA RDI,[RSP + 0x60]
MOV ESI,0x1
CALL 0x001d13a0
LAB_0016041f:
JMP 0x00160421
LAB_00160421:
LEA RDI,[RSP + 0x60]
CALL 0x001d1a80
LEA RDI,[RSP + 0x20]
CALL 0x001605d0
LEA RDI,[RSP + 0x50]
CALL 0x001d1ab0
MOV byte ptr [RSP + 0x12d],0x1
TEST byte ptr [RSP + 0x12d],0x1
JNZ 0x001604bb
JMP 0x001604b1
LAB_001604b1:
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x001605a0
LAB_001604bb:
MOV RAX,qword ptr [RSP + 0x18]
ADD RSP,0x148
RET
|
/* WARNING: Removing unreachable block (ram,0x00160451) */
/* nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::string, bool, long,
unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer,
std::vector<unsigned char, std::allocator<unsigned char> >, void>
nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::string, bool, long,
unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer,
std::vector<unsigned char, std::allocator<unsigned char> >,
void>::parse<std::ifstream&>(std::ifstream&, std::function<bool (int,
nlohmann::json_abi_v3_11_3::detail::parse_event_t,
nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::string, bool, long,
unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer,
std::vector<unsigned char, std::allocator<unsigned char> >, void>&)>, bool, bool) */
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
* __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::parse<std::ifstream&>
(basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this,istream *param_1,function *param_3,byte param_4,byte param_5)
{
function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)>
local_128 [48];
detail local_f8 [16];
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
local_e8 [205];
int1 local_1b;
byte local_1a;
byte local_19;
function *local_18;
istream *local_10;
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*local_8;
local_19 = param_4 & 1;
local_1a = param_5 & 1;
local_1b = 0;
local_18 = param_3;
local_10 = param_1;
local_8 = this;
basic_json((_func_decltype_nullptr *)this);
/* try { // try from 001603c0 to 001603c9 has its CatchHandler @ 00160453 */
detail::input_adapter(local_f8,local_10);
/* try { // try from 001603cc to 001603da has its CatchHandler @ 00160463 */
std::
function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)>
::function(local_128,param_3);
/* try { // try from 001603ee to 00160408 has its CatchHandler @ 00160473 */
parser<nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>
(local_e8,local_f8,local_128,local_19 & 1,local_1a & 1);
/* try { // try from 0016040b to 0016041e has its CatchHandler @ 00160483 */
detail::
parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>
::parse((parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>
*)local_e8,true,this);
detail::
parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>
::~parser((parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>
*)local_e8);
std::
function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)>
::~function(local_128);
detail::input_stream_adapter::~input_stream_adapter((input_stream_adapter *)local_f8);
return this;
}
| |
52,910 | plutovg_canvas_clip_extents | dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-canvas.c | void plutovg_canvas_clip_extents(const plutovg_canvas_t* canvas, plutovg_rect_t* extents)
{
if(canvas->state->clipping) {
plutovg_span_buffer_extents(&canvas->state->clip_spans, extents);
} else {
extents->x = canvas->clip_rect.x;
extents->y = canvas->clip_rect.y;
extents->w = canvas->clip_rect.w;
extents->h = canvas->clip_rect.h;
}
} | O1 | c | plutovg_canvas_clip_extents:
movq 0x18(%rdi), %rax
cmpb $0x1, 0x90(%rax)
jne 0x23e26
addq $0x60, %rax
movq %rax, %rdi
jmp 0x2cdce
movss 0x28(%rdi), %xmm0
movss %xmm0, (%rsi)
movss 0x2c(%rdi), %xmm0
movss %xmm0, 0x4(%rsi)
movss 0x30(%rdi), %xmm0
movss %xmm0, 0x8(%rsi)
movss 0x34(%rdi), %xmm0
movss %xmm0, 0xc(%rsi)
retq
| plutovg_canvas_clip_extents:
mov rax, [rdi+18h]
cmp byte ptr [rax+90h], 1
jnz short loc_23E26
add rax, 60h ; '`'
mov rdi, rax
jmp plutovg_span_buffer_extents
loc_23E26:
movss xmm0, dword ptr [rdi+28h]
movss dword ptr [rsi], xmm0
movss xmm0, dword ptr [rdi+2Ch]
movss dword ptr [rsi+4], xmm0
movss xmm0, dword ptr [rdi+30h]
movss dword ptr [rsi+8], xmm0
movss xmm0, dword ptr [rdi+34h]
movss dword ptr [rsi+0Ch], xmm0
retn
| long long plutovg_canvas_clip_extents(long long a1, _DWORD *a2)
{
long long result; // rax
result = *(_QWORD *)(a1 + 24);
if ( *(_BYTE *)(result + 144) == 1 )
return plutovg_span_buffer_extents(result + 96);
*a2 = *(_DWORD *)(a1 + 40);
a2[1] = *(_DWORD *)(a1 + 44);
a2[2] = *(_DWORD *)(a1 + 48);
a2[3] = *(_DWORD *)(a1 + 52);
return result;
}
| plutovg_canvas_clip_extents:
MOV RAX,qword ptr [RDI + 0x18]
CMP byte ptr [RAX + 0x90],0x1
JNZ 0x00123e26
ADD RAX,0x60
MOV RDI,RAX
JMP 0x0012cdce
LAB_00123e26:
MOVSS XMM0,dword ptr [RDI + 0x28]
MOVSS dword ptr [RSI],XMM0
MOVSS XMM0,dword ptr [RDI + 0x2c]
MOVSS dword ptr [RSI + 0x4],XMM0
MOVSS XMM0,dword ptr [RDI + 0x30]
MOVSS dword ptr [RSI + 0x8],XMM0
MOVSS XMM0,dword ptr [RDI + 0x34]
MOVSS dword ptr [RSI + 0xc],XMM0
RET
|
void plutovg_canvas_clip_extents(long param_1,int4 *param_2)
{
if (*(char *)(*(long *)(param_1 + 0x18) + 0x90) == '\x01') {
plutovg_span_buffer_extents(*(long *)(param_1 + 0x18) + 0x60);
return;
}
*param_2 = *(int4 *)(param_1 + 0x28);
param_2[1] = *(int4 *)(param_1 + 0x2c);
param_2[2] = *(int4 *)(param_1 + 0x30);
param_2[3] = *(int4 *)(param_1 + 0x34);
return;
}
| |
52,911 | Json::Value::Value(Json::Value const&) | aimrt_mujoco_sim/_deps/jsoncpp-src/src/lib_json/json_value.cpp | Value::Value(const Value& other) {
dupPayload(other);
dupMeta(other);
} | O3 | cpp | Json::Value::Value(Json::Value const&):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x10(%rdi), %rbx
movq $0x0, 0x10(%rdi)
callq 0x76b6e
leaq 0x10(%r15), %rsi
movq %rbx, %rdi
callq 0x786d8
movups 0x18(%r15), %xmm0
movups %xmm0, 0x18(%r14)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x76b5f
movq %rbx, %rdi
callq 0x1f740
movq $0x0, (%rbx)
movq %r14, %rdi
callq 0x1ffd0
| _ZN4Json5ValueC2ERKS0_:
push r15
push r14
push rbx
mov r15, rsi
mov r14, rdi
lea rbx, [rdi+10h]
mov qword ptr [rdi+10h], 0
call _ZN4Json5Value10dupPayloadERKS0_; Json::Value::dupPayload(Json::Value const&)
lea rsi, [r15+10h]
mov rdi, rbx
call _ZN4Json5Value8CommentsaSERKS1_; Json::Value::Comments::operator=(Json::Value::Comments const&)
movups xmm0, xmmword ptr [r15+18h]
movups xmmword ptr [r14+18h], xmm0
pop rbx
pop r14
pop r15
retn
mov r14, rax
mov rsi, [rbx]
test rsi, rsi
jz short loc_76B5F
mov rdi, rbx
call __ZNKSt14default_deleteISt5arrayINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEELm3EEEclEPS7_; std::default_delete<std::array<std::string,3ul>>::operator()(std::array<std::string,3ul>*)
loc_76B5F:
mov qword ptr [rbx], 0
mov rdi, r14
call __Unwind_Resume
| long long Json::Value::Value(Json::Value *this, const Json::Value *a2)
{
long long result; // rax
*((_QWORD *)this + 2) = 0LL;
Json::Value::dupPayload(this, a2);
result = Json::Value::Comments::operator=((char *)this + 16, (char *)a2 + 16);
*(_OWORD *)((char *)this + 24) = *(_OWORD *)((char *)a2 + 24);
return result;
}
| Value:
PUSH R15
PUSH R14
PUSH RBX
MOV R15,RSI
MOV R14,RDI
LEA RBX,[RDI + 0x10]
MOV qword ptr [RDI + 0x10],0x0
LAB_00176b2b:
CALL 0x00176b6e
LEA RSI,[R15 + 0x10]
MOV RDI,RBX
CALL 0x001786d8
LAB_00176b3c:
MOVUPS XMM0,xmmword ptr [R15 + 0x18]
MOVUPS xmmword ptr [R14 + 0x18],XMM0
POP RBX
POP R14
POP R15
RET
|
/* Json::Value::Value(Json::Value const&) */
void __thiscall Json::Value::Value(Value *this,Value *param_1)
{
int8 uVar1;
*(int8 *)(this + 0x10) = 0;
/* try { // try from 00176b2b to 00176b3b has its CatchHandler @ 00176b4c */
dupPayload(this,param_1);
Comments::operator=((Comments *)(this + 0x10),(Comments *)(param_1 + 0x10));
uVar1 = *(int8 *)(param_1 + 0x20);
*(int8 *)(this + 0x18) = *(int8 *)(param_1 + 0x18);
*(int8 *)(this + 0x20) = uVar1;
return;
}
| |
52,912 | LefDefParser::lefwLayerRoutingShrinkage(double) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefwWriter.cpp | int
lefwLayerRoutingShrinkage(double shrinkage)
{
if (!lefwFile)
return LEFW_UNINITIALIZED;
if (lefwState != LEFW_LAYERROUTING_START &&
lefwState != LEFW_LAYERROUTING)
return LEFW_BAD_ORDER;
if (!lefwIsRouting)
return LEFW_BAD_DATA; // only routing calls this func
if (prtSemiColon) {
// the previous statement hasn't written the ; yet
if (lefwWriteEncrypt)
encPrint(lefwFile, (char*) ";\n");
else
fprintf(lefwFile, ";\n");
prtSemiColon = 0;
}
if (lefwWriteEncrypt)
encPrint(lefwFile, (char*) " SHRINKAGE %.11g ;\n", shrinkage);
else
fprintf(lefwFile, " SHRINKAGE %.11g ;\n", shrinkage);
lefwLines++;
return LEFW_OK;
} | O3 | cpp | LefDefParser::lefwLayerRoutingShrinkage(double):
pushq %rbx
subq $0x10, %rsp
leaq 0x1a7a0(%rip), %rbx # 0x24e00
movq (%rbx), %rcx
testq %rcx, %rcx
je 0xa6bb
leaq 0x1a9e1(%rip), %rax # 0x25050
movl (%rax), %edx
cmpl $0x1f, %edx
je 0xa684
movl $0x2, %eax
cmpl $0x7, %edx
jne 0xa721
leaq 0x1aa39(%rip), %rax # 0x250c4
cmpl $0x0, (%rax)
je 0xa6c2
cmpb $0x1, 0x1aa5d(%rip) # 0x250f4
jne 0xa6ec
movsd %xmm0, 0x8(%rsp)
cmpb $0x1, 0x1aa46(%rip) # 0x250ec
jne 0xa6c9
leaq 0xfb61(%rip), %rsi # 0x1a210
movq %rcx, %rdi
xorl %eax, %eax
callq 0x18c35
jmp 0xa6df
movl $0x1, %eax
jmp 0xa721
movl $0x3, %eax
jmp 0xa721
leaq 0xfb40(%rip), %rdi # 0x1a210
movl $0x2, %esi
movl $0x1, %edx
callq 0x1110
movb $0x0, 0x1aa0e(%rip) # 0x250f4
movsd 0x8(%rsp), %xmm0
movq (%rbx), %rdi
cmpb $0x1, 0x1a9f6(%rip) # 0x250ec
jne 0xa708
leaq 0x103ac(%rip), %rsi # 0x1aaab
movb $0x1, %al
callq 0x18c35
jmp 0xa716
leaq 0x1039c(%rip), %rsi # 0x1aaab
movb $0x1, %al
callq 0x10f0
leaq 0x1a92f(%rip), %rax # 0x2504c
incl (%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
| _ZN12LefDefParser25lefwLayerRoutingShrinkageEd:
push rbx
sub rsp, 10h
lea rbx, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rcx, [rbx]
test rcx, rcx
jz short loc_A6BB
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
mov edx, [rax]
cmp edx, 1Fh
jz short loc_A684
mov eax, 2
cmp edx, 7
jnz loc_A721
loc_A684:
lea rax, _ZN12LefDefParser13lefwIsRoutingE; LefDefParser::lefwIsRouting
cmp dword ptr [rax], 0
jz short loc_A6C2
cmp cs:_ZN12LefDefParserL12prtSemiColonE, 1; LefDefParser::prtSemiColon
jnz short loc_A6EC
movsd [rsp+18h+var_10], xmm0
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 1; LefDefParser::lefwWriteEncrypt
jnz short loc_A6C9
lea rsi, aDividercharS+11h; ";\n"
mov rdi, rcx
xor eax, eax
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp short loc_A6DF
loc_A6BB:
mov eax, 1
jmp short loc_A721
loc_A6C2:
mov eax, 3
jmp short loc_A721
loc_A6C9:
lea rdi, aDividercharS+11h; ";\n"
mov esi, 2
mov edx, 1
call _fwrite
loc_A6DF:
mov cs:_ZN12LefDefParserL12prtSemiColonE, 0; LefDefParser::prtSemiColon
movsd xmm0, [rsp+18h+var_10]
loc_A6EC:
mov rdi, [rbx]
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 1; LefDefParser::lefwWriteEncrypt
jnz short loc_A708
lea rsi, aShrinkage11g; " SHRINKAGE %.11g ;\n"
mov al, 1
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp short loc_A716
loc_A708:
lea rsi, aShrinkage11g; " SHRINKAGE %.11g ;\n"
mov al, 1
call _fprintf
loc_A716:
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
inc dword ptr [rax]
xor eax, eax
loc_A721:
add rsp, 10h
pop rbx
retn
| long long LefDefParser::lefwLayerRoutingShrinkage(
LefDefParser *this,
double a2,
long long a3,
long long a4,
long long a5,
int a6,
int a7)
{
int v7; // ecx
unsigned int v8; // edx
long long result; // rax
v7 = LefDefParser::lefwFile;
if ( !*(_QWORD *)&LefDefParser::lefwFile )
return 1LL;
v8 = LefDefParser::lefwState;
if ( LefDefParser::lefwState == 31 || (result = 2LL, LefDefParser::lefwState == 7) )
{
if ( LefDefParser::lefwIsRouting )
{
if ( LefDefParser::prtSemiColon == 1 )
{
if ( LefDefParser::lefwWriteEncrypt == 1 )
LefDefParser::encPrint(
LefDefParser::lefwFile,
(unsigned int)";\n",
LefDefParser::lefwState,
LefDefParser::lefwFile,
a6,
a7);
else
fwrite(";\n", 2LL, 1LL, *(_QWORD *)&LefDefParser::lefwFile);
LefDefParser::prtSemiColon = 0;
}
if ( LefDefParser::lefwWriteEncrypt == 1 )
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)" SHRINKAGE %.11g ;\n", v8, v7, a6, a7);
else
fprintf(*(_QWORD *)&LefDefParser::lefwFile, " SHRINKAGE %.11g ;\n", a2);
++LefDefParser::lefwLines;
return 0LL;
}
else
{
return 3LL;
}
}
return result;
}
| lefwLayerRoutingShrinkage:
PUSH RBX
SUB RSP,0x10
LEA RBX,[0x124e00]
MOV RCX,qword ptr [RBX]
TEST RCX,RCX
JZ 0x0010a6bb
LEA RAX,[0x125050]
MOV EDX,dword ptr [RAX]
CMP EDX,0x1f
JZ 0x0010a684
MOV EAX,0x2
CMP EDX,0x7
JNZ 0x0010a721
LAB_0010a684:
LEA RAX,[0x1250c4]
CMP dword ptr [RAX],0x0
JZ 0x0010a6c2
CMP byte ptr [0x001250f4],0x1
JNZ 0x0010a6ec
MOVSD qword ptr [RSP + 0x8],XMM0
CMP byte ptr [0x001250ec],0x1
JNZ 0x0010a6c9
LEA RSI,[0x11a210]
MOV RDI,RCX
XOR EAX,EAX
CALL 0x00118c35
JMP 0x0010a6df
LAB_0010a6bb:
MOV EAX,0x1
JMP 0x0010a721
LAB_0010a6c2:
MOV EAX,0x3
JMP 0x0010a721
LAB_0010a6c9:
LEA RDI,[0x11a210]
MOV ESI,0x2
MOV EDX,0x1
CALL 0x00101110
LAB_0010a6df:
MOV byte ptr [0x001250f4],0x0
MOVSD XMM0,qword ptr [RSP + 0x8]
LAB_0010a6ec:
MOV RDI,qword ptr [RBX]
CMP byte ptr [0x001250ec],0x1
JNZ 0x0010a708
LEA RSI,[0x11aaab]
MOV AL,0x1
CALL 0x00118c35
JMP 0x0010a716
LAB_0010a708:
LEA RSI,[0x11aaab]
MOV AL,0x1
CALL 0x001010f0
LAB_0010a716:
LEA RAX,[0x12504c]
INC dword ptr [RAX]
XOR EAX,EAX
LAB_0010a721:
ADD RSP,0x10
POP RBX
RET
|
/* LefDefParser::lefwLayerRoutingShrinkage(double) */
int8 LefDefParser::lefwLayerRoutingShrinkage(double param_1)
{
int8 uVar1;
if (lefwFile == (_IO_FILE *)0x0) {
uVar1 = 1;
}
else if ((lefwState == 0x1f) || (uVar1 = 2, lefwState == 7)) {
if (lefwIsRouting == 0) {
uVar1 = 3;
}
else {
if (prtSemiColon == '\x01') {
if (lefwWriteEncrypt == '\x01') {
encPrint(lefwFile,";\n");
}
else {
fwrite(";\n",2,1,lefwFile);
}
prtSemiColon = '\0';
}
if (lefwWriteEncrypt == '\x01') {
encPrint(lefwFile," SHRINKAGE %.11g ;\n");
}
else {
fprintf(lefwFile," SHRINKAGE %.11g ;\n",param_1);
}
lefwLines = lefwLines + 1;
uVar1 = 0;
}
}
return uVar1;
}
| |
52,913 | ma_bitmap_flush | eloqsql/storage/maria/ma_bitmap.c | my_bool _ma_bitmap_flush(MARIA_SHARE *share)
{
my_bool res= 0;
DBUG_ENTER("_ma_bitmap_flush");
if (share->bitmap.changed)
{
mysql_mutex_lock(&share->bitmap.bitmap_lock);
if (share->bitmap.changed)
{
/*
We have to mark the file changed here, as otherwise the following
write to pagecache may force a page out from this file, which would
cause _ma_mark_file_changed() to be called with bitmaplock hold!
*/
_ma_bitmap_mark_file_changed(share, 1);
res= write_changed_bitmap(share, &share->bitmap);
share->bitmap.changed= 0;
}
mysql_mutex_unlock(&share->bitmap.bitmap_lock);
}
DBUG_RETURN(res);
} | O0 | c | ma_bitmap_flush:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, 0xa30(%rax)
je 0x5e534
movq -0x8(%rbp), %rdi
addq $0xa10, %rdi # imm = 0xA10
addq $0x88, %rdi
leaq 0xfc405(%rip), %rsi # 0x15a8db
movl $0x1a9, %edx # imm = 0x1A9
callq 0x5e610
movq -0x8(%rbp), %rax
cmpb $0x0, 0xa30(%rax)
je 0x5e51d
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x5e680
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0xa10, %rsi # imm = 0xA10
callq 0x5e750
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, 0xa30(%rax)
movq -0x8(%rbp), %rdi
addq $0xa10, %rdi # imm = 0xA10
addq $0x88, %rdi
callq 0x5e8c0
jmp 0x5e536
movb -0x9(%rbp), %al
movb %al, -0xa(%rbp)
movb -0xa(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ma_bitmap_flush:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov [rbp+var_9], 0
mov rax, [rbp+var_8]
cmp byte ptr [rax+0A30h], 0
jz short loc_5E534
mov rdi, [rbp+var_8]
add rdi, 0A10h
add rdi, 88h
lea rsi, aWorkspaceLlm4b_11; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 1A9h
call inline_mysql_mutex_lock_7
mov rax, [rbp+var_8]
cmp byte ptr [rax+0A30h], 0
jz short loc_5E51D
mov rdi, [rbp+var_8]
mov esi, 1
call _ma_bitmap_mark_file_changed
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_8]
add rsi, 0A10h
call write_changed_bitmap
mov [rbp+var_9], al
mov rax, [rbp+var_8]
mov byte ptr [rax+0A30h], 0
loc_5E51D:
mov rdi, [rbp+var_8]
add rdi, 0A10h
add rdi, 88h
call inline_mysql_mutex_unlock_7
loc_5E534:
jmp short $+2
loc_5E536:
mov al, [rbp+var_9]
mov [rbp+var_A], al
mov al, [rbp+var_A]
add rsp, 10h
pop rbp
retn
| char ma_bitmap_flush(long long a1)
{
char v2; // [rsp+7h] [rbp-9h]
v2 = 0;
if ( *(_BYTE *)(a1 + 2608) )
{
inline_mysql_mutex_lock_7(a1 + 2712, "/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_bitmap.c", 425LL);
if ( *(_BYTE *)(a1 + 2608) )
{
ma_bitmap_mark_file_changed(a1, 1LL);
v2 = write_changed_bitmap(a1, a1 + 2576);
*(_BYTE *)(a1 + 2608) = 0;
}
inline_mysql_mutex_unlock_7(a1 + 2712);
}
return v2;
}
| _ma_bitmap_flush:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV byte ptr [RBP + -0x9],0x0
MOV RAX,qword ptr [RBP + -0x8]
CMP byte ptr [RAX + 0xa30],0x0
JZ 0x0015e534
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xa10
ADD RDI,0x88
LEA RSI,[0x25a8db]
MOV EDX,0x1a9
CALL 0x0015e610
MOV RAX,qword ptr [RBP + -0x8]
CMP byte ptr [RAX + 0xa30],0x0
JZ 0x0015e51d
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,0x1
CALL 0x0015e680
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x8]
ADD RSI,0xa10
CALL 0x0015e750
MOV byte ptr [RBP + -0x9],AL
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0xa30],0x0
LAB_0015e51d:
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xa10
ADD RDI,0x88
CALL 0x0015e8c0
LAB_0015e534:
JMP 0x0015e536
LAB_0015e536:
MOV AL,byte ptr [RBP + -0x9]
MOV byte ptr [RBP + -0xa],AL
MOV AL,byte ptr [RBP + -0xa]
ADD RSP,0x10
POP RBP
RET
|
int1 _ma_bitmap_flush(long param_1)
{
int1 local_11;
local_11 = 0;
if (*(char *)(param_1 + 0xa30) != '\0') {
inline_mysql_mutex_lock
(param_1 + 0xa98,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_bitmap.c",
0x1a9);
if (*(char *)(param_1 + 0xa30) != '\0') {
_ma_bitmap_mark_file_changed(param_1,1);
local_11 = write_changed_bitmap(param_1,param_1 + 0xa10);
*(int1 *)(param_1 + 0xa30) = 0;
}
inline_mysql_mutex_unlock(param_1 + 0xa98);
}
return local_11;
}
| |
52,914 | store_extent_info | eloqsql/storage/maria/ma_blockrec.c | static void store_extent_info(uchar *to,
uchar *row_extents_second_part,
MARIA_BITMAP_BLOCK *first_block,
uint count)
{
MARIA_BITMAP_BLOCK *block, *end_block;
uint copy_length;
my_bool first_found= 0;
DBUG_ENTER("store_extent_info");
DBUG_PRINT("enter", ("count: %u", count));
for (block= first_block, end_block= first_block+count ;
block < end_block; block++)
{
/* The following is only false for marker (unused) blocks */
if (likely(block->used & BLOCKUSED_USED))
{
uint page_count= block->page_count;
DBUG_ASSERT(page_count != 0);
page_store(to, block->page);
if (block->sub_blocks)
{
/*
Set a bit so that we later know that this was the first block
for a blob
*/
page_count|= START_EXTENT_BIT;
}
pagerange_store(to + PAGE_STORE_SIZE, page_count);
DBUG_DUMP("extent", to, ROW_EXTENT_SIZE);
to+= ROW_EXTENT_SIZE;
if (!first_found)
{
first_found= 1;
to= row_extents_second_part;
}
}
}
copy_length= (count - 1) * ROW_EXTENT_SIZE;
/*
In some unlikely cases we have allocated to many blocks. Clear this
data.
*/
bzero(to, (size_t) (row_extents_second_part + copy_length - to));
DBUG_VOID_RETURN;
} | O3 | c | store_extent_info:
movq %rdx, %rax
movq %rsi, %rdx
testl %ecx, %ecx
je 0x51c39
pushq %rbp
movq %rsp, %rbp
movl %ecx, %esi
leaq (%rsi,%rsi,2), %rsi
leaq (%rax,%rsi,8), %rsi
xorl %r8d, %r8d
testb $0x1, 0x14(%rax)
je 0x51c2f
movl (%rax), %r9d
movl 0x8(%rax), %r10d
movl %r9d, (%rdi)
movb 0x4(%rax), %r9b
movb %r9b, 0x4(%rdi)
movl %r10d, %r9d
orl $0x4000, %r9d # imm = 0x4000
cmpl $0x0, 0x10(%rax)
cmovel %r10d, %r9d
movw %r9w, 0x5(%rdi)
addq $0x7, %rdi
testb %r8b, %r8b
cmoveq %rdx, %rdi
movb $0x1, %r8b
addq $0x18, %rax
cmpq %rsi, %rax
jb 0x51bf2
popq %rbp
leal (,%rcx,8), %eax
subl %ecx, %eax
addl $-0x7, %eax
addq %rax, %rdx
subq %rdi, %rdx
xorl %esi, %esi
jmp 0x292a0
| store_extent_info:
mov rax, rdx
mov rdx, rsi
test ecx, ecx
jz short loc_51C39
push rbp
mov rbp, rsp
mov esi, ecx
lea rsi, [rsi+rsi*2]
lea rsi, [rax+rsi*8]
xor r8d, r8d
loc_51BF2:
test byte ptr [rax+14h], 1
jz short loc_51C2F
mov r9d, [rax]
mov r10d, [rax+8]
mov [rdi], r9d
mov r9b, [rax+4]
mov [rdi+4], r9b
mov r9d, r10d
or r9d, 4000h
cmp dword ptr [rax+10h], 0
cmovz r9d, r10d
mov [rdi+5], r9w
add rdi, 7
test r8b, r8b
cmovz rdi, rdx
mov r8b, 1
loc_51C2F:
add rax, 18h
cmp rax, rsi
jb short loc_51BF2
pop rbp
loc_51C39:
lea eax, ds:0[rcx*8]
sub eax, ecx
add eax, 0FFFFFFF9h
add rdx, rax
sub rdx, rdi
xor esi, esi
jmp _memset
| long long store_extent_info(long long a1, long long a2, unsigned long long a3, unsigned int a4)
{
unsigned long long v6; // rsi
char v7; // r8
int v8; // r10d
__int16 v9; // r9
if ( a4 )
{
v6 = a3 + 24LL * a4;
v7 = 0;
do
{
if ( (*(_BYTE *)(a3 + 20) & 1) != 0 )
{
v8 = *(_DWORD *)(a3 + 8);
*(_DWORD *)a1 = *(_DWORD *)a3;
*(_BYTE *)(a1 + 4) = *(_BYTE *)(a3 + 4);
v9 = v8 | 0x4000;
if ( !*(_DWORD *)(a3 + 16) )
v9 = v8;
*(_WORD *)(a1 + 5) = v9;
a1 += 7LL;
if ( !v7 )
a1 = a2;
v7 = 1;
}
a3 += 24LL;
}
while ( a3 < v6 );
}
return memset(a1, 0LL, 7 * a4 - 7 + a2 - a1);
}
| store_extent_info:
MOV RAX,RDX
MOV RDX,RSI
TEST ECX,ECX
JZ 0x00151c39
PUSH RBP
MOV RBP,RSP
MOV ESI,ECX
LEA RSI,[RSI + RSI*0x2]
LEA RSI,[RAX + RSI*0x8]
XOR R8D,R8D
LAB_00151bf2:
TEST byte ptr [RAX + 0x14],0x1
JZ 0x00151c2f
MOV R9D,dword ptr [RAX]
MOV R10D,dword ptr [RAX + 0x8]
MOV dword ptr [RDI],R9D
MOV R9B,byte ptr [RAX + 0x4]
MOV byte ptr [RDI + 0x4],R9B
MOV R9D,R10D
OR R9D,0x4000
CMP dword ptr [RAX + 0x10],0x0
CMOVZ R9D,R10D
MOV word ptr [RDI + 0x5],R9W
ADD RDI,0x7
TEST R8B,R8B
CMOVZ RDI,RDX
MOV R8B,0x1
LAB_00151c2f:
ADD RAX,0x18
CMP RAX,RSI
JC 0x00151bf2
POP RBP
LAB_00151c39:
LEA EAX,[RCX*0x8]
SUB EAX,ECX
ADD EAX,-0x7
ADD RDX,RAX
SUB RDX,RDI
XOR ESI,ESI
JMP 0x001292a0
|
void store_extent_info(int4 *param_1,int4 *param_2,int4 *param_3,uint param_4)
{
int4 *puVar1;
int4 uVar2;
bool bVar3;
ushort uVar4;
if (param_4 != 0) {
puVar1 = param_3 + (ulong)param_4 * 6;
bVar3 = false;
do {
if ((*(byte *)(param_3 + 5) & 1) != 0) {
uVar2 = param_3[2];
*param_1 = *param_3;
*(int1 *)(param_1 + 1) = *(int1 *)(param_3 + 1);
uVar4 = (ushort)uVar2 | 0x4000;
if (param_3[4] == 0) {
uVar4 = (ushort)uVar2;
}
*(ushort *)((long)param_1 + 5) = uVar4;
param_1 = (int4 *)((long)param_1 + 7);
if (!bVar3) {
param_1 = param_2;
}
bVar3 = true;
}
param_3 = param_3 + 6;
} while (param_3 < puVar1);
}
memset(param_1,0,(long)param_2 + ((ulong)(param_4 * 7 - 7) - (long)param_1));
return;
}
| |
52,915 | ggml_compute_forward_soft_max_f32 | 7CodeWizard[P]stablediffusion/ggml/src/ggml.c | static void ggml_compute_forward_soft_max_f32(
const struct ggml_compute_params * params,
const struct ggml_tensor * src0,
const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
assert(ggml_is_contiguous(dst));
assert(ggml_are_same_shape(src0, dst));
if (params->type == GGML_TASK_INIT || params->type == GGML_TASK_FINALIZE) {
return;
}
float scale = 1.0f;
memcpy(&scale, (float *) dst->op_params + 0, sizeof(float));
// TODO: handle transposed/permuted matrices
const int ith = params->ith;
const int nth = params->nth;
const int64_t ne11 = src1 ? src1->ne[1] : 1;
const int nc = src0->ne[0];
const int nr = ggml_nrows(src0);
// rows per thread
const int dr = (nr + nth - 1)/nth;
// row range for this thread
const int ir0 = dr*ith;
const int ir1 = MIN(ir0 + dr, nr);
float * wp = (float *) params->wdata + (nc + CACHE_LINE_SIZE_F32) * ith;
for (int i1 = ir0; i1 < ir1; i1++) {
float * sp = (float *)((char *) src0->data + i1*src0->nb[1]);
float * dp = (float *)((char *) dst->data + i1*dst->nb[1]);
// broadcast the mask across rows
float * mp = src1 ? (float *)((char *) src1->data + (i1%ne11)*src1->nb[1]) : NULL;
ggml_vec_cpy_f32 (nc, wp, sp);
ggml_vec_scale_f32(nc, wp, scale);
if (mp) {
ggml_vec_acc_f32(nc, wp, mp);
}
#ifndef NDEBUG
for (int i = 0; i < nc; ++i) {
//printf("p[%d] = %f\n", i, p[i]);
assert(!isnan(wp[i]));
}
#endif
float max = -INFINITY;
ggml_vec_max_f32(nc, &max, wp);
ggml_float sum = 0.0;
uint16_t scvt;
for (int i = 0; i < nc; i++) {
if (wp[i] == -INFINITY) {
dp[i] = 0.0f;
} else {
// const float val = (wp[i] == -INFINITY) ? 0.0 : exp(wp[i] - max);
ggml_fp16_t s = GGML_FP32_TO_FP16(wp[i] - max);
memcpy(&scvt, &s, sizeof(scvt));
const float val = GGML_FP16_TO_FP32(ggml_table_exp_f16[scvt]);
sum += (ggml_float)val;
dp[i] = val;
}
}
assert(sum > 0.0);
sum = 1.0/sum;
ggml_vec_scale_f32(nc, dp, sum);
#ifndef NDEBUG
for (int i = 0; i < nc; ++i) {
assert(!isnan(dp[i]));
assert(!isinf(dp[i]));
}
#endif
}
} | O0 | c | ggml_compute_forward_soft_max_f32:
subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq %rdx, 0xc0(%rsp)
movq %rcx, 0xb8(%rsp)
movq 0xd0(%rsp), %rax
cmpl $0x0, (%rax)
je 0x155691
movq 0xd0(%rsp), %rax
cmpl $0x2, (%rax)
jne 0x155696
jmp 0x155a79
vmovss 0x27966(%rip), %xmm0 # 0x17d004
vmovss %xmm0, 0xb4(%rsp)
movq 0xb8(%rsp), %rax
movl 0x54(%rax), %eax
movl %eax, 0xb4(%rsp)
movq 0xd0(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0xb0(%rsp)
movq 0xd0(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0xac(%rsp)
cmpq $0x0, 0xc0(%rsp)
je 0x1556fb
movq 0xc0(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x155707
movl $0x1, %eax
movq %rax, 0x20(%rsp)
jmp 0x155707
movq 0x20(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq 0xc8(%rsp), %rax
movq 0x10(%rax), %rax
movl %eax, 0x9c(%rsp)
movq 0xc8(%rsp), %rdi
callq 0x11ae60
movl %eax, 0x98(%rsp)
movl 0x98(%rsp), %eax
addl 0xac(%rsp), %eax
subl $0x1, %eax
cltd
idivl 0xac(%rsp)
movl %eax, 0x94(%rsp)
movl 0x94(%rsp), %eax
imull 0xb0(%rsp), %eax
movl %eax, 0x90(%rsp)
movl 0x90(%rsp), %eax
addl 0x94(%rsp), %eax
cmpl 0x98(%rsp), %eax
jge 0x15579c
movl 0x90(%rsp), %eax
addl 0x94(%rsp), %eax
movl %eax, 0x1c(%rsp)
jmp 0x1557a7
movl 0x98(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x8c(%rsp)
movq 0xd0(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x9c(%rsp), %rcx
addq $0x10, %rcx
movslq 0xb0(%rsp), %rdx
imulq %rdx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x80(%rsp)
movl 0x90(%rsp), %eax
movl %eax, 0x7c(%rsp)
movl 0x7c(%rsp), %eax
cmpl 0x8c(%rsp), %eax
jge 0x155a79
movq 0xc8(%rsp), %rax
movq 0x118(%rax), %rax
movslq 0x7c(%rsp), %rcx
movq 0xc8(%rsp), %rdx
imulq 0x38(%rdx), %rcx
addq %rcx, %rax
movq %rax, 0x70(%rsp)
movq 0xb8(%rsp), %rax
movq 0x118(%rax), %rax
movslq 0x7c(%rsp), %rcx
movq 0xb8(%rsp), %rdx
imulq 0x38(%rdx), %rcx
addq %rcx, %rax
movq %rax, 0x68(%rsp)
cmpq $0x0, 0xc0(%rsp)
je 0x15589d
movq 0xc0(%rsp), %rax
movq 0x118(%rax), %rax
movq %rax, 0x8(%rsp)
movslq 0x7c(%rsp), %rax
cqto
idivq 0xa0(%rsp)
movq 0x8(%rsp), %rax
movq 0xc0(%rsp), %rcx
imulq 0x38(%rcx), %rdx
addq %rdx, %rax
movq %rax, 0x10(%rsp)
jmp 0x1558a6
xorl %eax, %eax
movq %rax, 0x10(%rsp)
jmp 0x1558a6
movq 0x10(%rsp), %rax
movq %rax, 0x60(%rsp)
movl 0x9c(%rsp), %edi
movq 0x80(%rsp), %rsi
movq 0x70(%rsp), %rdx
callq 0x14eb60
movl 0x9c(%rsp), %edi
movq 0x80(%rsp), %rsi
vmovss 0xb4(%rsp), %xmm0
callq 0x1501b0
cmpq $0x0, 0x60(%rsp)
je 0x155907
movl 0x9c(%rsp), %edi
movq 0x80(%rsp), %rsi
movq 0x60(%rsp), %rdx
callq 0x149340
vmovss 0x33cbd(%rip), %xmm0 # 0x1895cc
vmovss %xmm0, 0x5c(%rsp)
movl 0x9c(%rsp), %edi
movq 0x80(%rsp), %rdx
leaq 0x5c(%rsp), %rsi
callq 0x155a90
vxorps %xmm0, %xmm0, %xmm0
vmovsd %xmm0, 0x50(%rsp)
movl $0x0, 0x48(%rsp)
movl 0x48(%rsp), %eax
cmpl 0x9c(%rsp), %eax
jge 0x155a3a
movq 0x80(%rsp), %rax
movslq 0x48(%rsp), %rcx
vmovss (%rax,%rcx,4), %xmm0
vmovss 0x33c61(%rip), %xmm1 # 0x1895cc
vucomiss %xmm1, %xmm0
jne 0x15598b
jp 0x15598b
movq 0x68(%rsp), %rax
movslq 0x48(%rsp), %rcx
vxorps %xmm0, %xmm0, %xmm0
vmovss %xmm0, (%rax,%rcx,4)
jmp 0x155a28
movq 0x80(%rsp), %rax
movslq 0x48(%rsp), %rcx
vmovss (%rax,%rcx,4), %xmm0
vmovss 0x5c(%rsp), %xmm1
vsubss %xmm1, %xmm0, %xmm1
vxorps %xmm0, %xmm0, %xmm0
vblendps $0x1, %xmm1, %xmm0, %xmm0 # xmm0 = xmm1[0],xmm0[1,2,3]
vmovaps %xmm0, 0x30(%rsp)
vmovaps 0x30(%rsp), %xmm0
vcvtps2ph $0x0, %xmm0, %xmm0
vmovd %xmm0, %eax
movw %ax, 0x44(%rsp)
movw 0x44(%rsp), %ax
movw %ax, 0x46(%rsp)
movw 0x46(%rsp), %ax
movw %ax, 0x4e(%rsp)
movzwl 0x4e(%rsp), %eax
movl %eax, %ecx
leaq 0x1aa5c2(%rip), %rax # 0x2fffb0
movzwl (%rax,%rcx,2), %edi
callq 0x11a5e0
vmovss %xmm0, 0x2c(%rsp)
vmovss 0x2c(%rsp), %xmm1
vcvtss2sd %xmm1, %xmm0, %xmm0
vaddsd 0x50(%rsp), %xmm0, %xmm0
vmovsd %xmm0, 0x50(%rsp)
vmovss 0x2c(%rsp), %xmm0
movq 0x68(%rsp), %rax
movslq 0x48(%rsp), %rcx
vmovss %xmm0, (%rax,%rcx,4)
jmp 0x155a2a
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x155940
vmovsd 0x29816(%rip), %xmm0 # 0x17f258
vdivsd 0x50(%rsp), %xmm0, %xmm0
vmovsd %xmm0, 0x50(%rsp)
movl 0x9c(%rsp), %edi
movq 0x68(%rsp), %rsi
vmovsd 0x50(%rsp), %xmm1
vcvtsd2ss %xmm1, %xmm0, %xmm0
callq 0x1501b0
movl 0x7c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x7c(%rsp)
jmp 0x1557f0
addq $0xd8, %rsp
retq
nopw %cs:(%rax,%rax)
| ggml_compute_forward_soft_max_f32:
sub rsp, 0D8h
mov [rsp+0D8h+var_8], rdi
mov [rsp+0D8h+var_10], rsi
mov [rsp+0D8h+var_18], rdx
mov [rsp+0D8h+var_20], rcx
mov rax, [rsp+0D8h+var_8]
cmp dword ptr [rax], 0
jz short loc_155691
mov rax, [rsp+0D8h+var_8]
cmp dword ptr [rax], 2
jnz short loc_155696
loc_155691:
jmp loc_155A79
loc_155696:
vmovss xmm0, cs:flt_17D004
vmovss [rsp+0D8h+var_24], xmm0
mov rax, [rsp+0D8h+var_20]
mov eax, [rax+54h]
mov [rsp+0D8h+var_24], eax
mov rax, [rsp+0D8h+var_8]
mov eax, [rax+4]
mov [rsp+0D8h+var_28], eax
mov rax, [rsp+0D8h+var_8]
mov eax, [rax+8]
mov [rsp+0D8h+var_2C], eax
cmp [rsp+0D8h+var_18], 0
jz short loc_1556FB
mov rax, [rsp+0D8h+var_18]
mov rax, [rax+18h]
mov [rsp+0D8h+var_B8], rax
jmp short loc_155707
loc_1556FB:
mov eax, 1
mov [rsp+0D8h+var_B8], rax
jmp short $+2
loc_155707:
mov rax, [rsp+0D8h+var_B8]
mov [rsp+0D8h+var_38], rax
mov rax, [rsp+0D8h+var_10]
mov rax, [rax+10h]
mov [rsp+0D8h+var_3C], eax
mov rdi, [rsp+0D8h+var_10]
call ggml_nrows
mov [rsp+0D8h+var_40], eax
mov eax, [rsp+0D8h+var_40]
add eax, [rsp+0D8h+var_2C]
sub eax, 1
cdq
idiv [rsp+0D8h+var_2C]
mov [rsp+0D8h+var_44], eax
mov eax, [rsp+0D8h+var_44]
imul eax, [rsp+0D8h+var_28]
mov [rsp+0D8h+var_48], eax
mov eax, [rsp+0D8h+var_48]
add eax, [rsp+0D8h+var_44]
cmp eax, [rsp+0D8h+var_40]
jge short loc_15579C
mov eax, [rsp+0D8h+var_48]
add eax, [rsp+0D8h+var_44]
mov [rsp+0D8h+var_BC], eax
jmp short loc_1557A7
loc_15579C:
mov eax, [rsp+0D8h+var_40]
mov [rsp+0D8h+var_BC], eax
loc_1557A7:
mov eax, [rsp+0D8h+var_BC]
mov [rsp+0D8h+var_4C], eax
mov rax, [rsp+0D8h+var_8]
mov rax, [rax+18h]
movsxd rcx, [rsp+0D8h+var_3C]
add rcx, 10h
movsxd rdx, [rsp+0D8h+var_28]
imul rcx, rdx
shl rcx, 2
add rax, rcx
mov [rsp+0D8h+var_58], rax
mov eax, [rsp+0D8h+var_48]
mov [rsp+0D8h+var_5C], eax
loc_1557F0:
mov eax, [rsp+0D8h+var_5C]
cmp eax, [rsp+0D8h+var_4C]
jge loc_155A79
mov rax, [rsp+0D8h+var_10]
mov rax, [rax+118h]
movsxd rcx, [rsp+0D8h+var_5C]
mov rdx, [rsp+0D8h+var_10]
imul rcx, [rdx+38h]
add rax, rcx
mov [rsp+0D8h+var_68], rax
mov rax, [rsp+0D8h+var_20]
mov rax, [rax+118h]
movsxd rcx, [rsp+0D8h+var_5C]
mov rdx, [rsp+0D8h+var_20]
imul rcx, [rdx+38h]
add rax, rcx
mov [rsp+0D8h+var_70], rax
cmp [rsp+0D8h+var_18], 0
jz short loc_15589D
mov rax, [rsp+0D8h+var_18]
mov rax, [rax+118h]
mov [rsp+0D8h+var_D0], rax
movsxd rax, [rsp+0D8h+var_5C]
cqo
idiv [rsp+0D8h+var_38]
mov rax, [rsp+0D8h+var_D0]
mov rcx, [rsp+0D8h+var_18]
imul rdx, [rcx+38h]
add rax, rdx
mov [rsp+0D8h+var_C8], rax
jmp short loc_1558A6
loc_15589D:
xor eax, eax
mov [rsp+0D8h+var_C8], rax
jmp short $+2
loc_1558A6:
mov rax, [rsp+0D8h+var_C8]
mov [rsp+0D8h+var_78], rax
mov edi, [rsp+0D8h+var_3C]
mov rsi, [rsp+0D8h+var_58]
mov rdx, [rsp+0D8h+var_68]
call ggml_vec_cpy_f32
mov edi, [rsp+0D8h+var_3C]
mov rsi, [rsp+0D8h+var_58]
vmovss xmm0, [rsp+0D8h+var_24]
call ggml_vec_scale_f32
cmp [rsp+0D8h+var_78], 0
jz short loc_155907
mov edi, [rsp+0D8h+var_3C]
mov rsi, [rsp+0D8h+var_58]
mov rdx, [rsp+0D8h+var_78]
call ggml_vec_acc_f32
loc_155907:
vmovss xmm0, cs:dword_1895CC
vmovss [rsp+0D8h+var_7C], xmm0
mov edi, [rsp+0D8h+var_3C]
mov rdx, [rsp+0D8h+var_58]
lea rsi, [rsp+0D8h+var_7C]
call ggml_vec_max_f32
vxorps xmm0, xmm0, xmm0
vmovsd [rsp+0D8h+var_88], xmm0
mov [rsp+0D8h+var_90], 0
loc_155940:
mov eax, [rsp+0D8h+var_90]
cmp eax, [rsp+0D8h+var_3C]
jge loc_155A3A
mov rax, [rsp+0D8h+var_58]
movsxd rcx, [rsp+0D8h+var_90]
vmovss xmm0, dword ptr [rax+rcx*4]
vmovss xmm1, cs:dword_1895CC
vucomiss xmm0, xmm1
jnz short loc_15598B
jp short loc_15598B
mov rax, [rsp+0D8h+var_70]
movsxd rcx, [rsp+0D8h+var_90]
vxorps xmm0, xmm0, xmm0
vmovss dword ptr [rax+rcx*4], xmm0
jmp loc_155A28
loc_15598B:
mov rax, [rsp+0D8h+var_58]
movsxd rcx, [rsp+0D8h+var_90]
vmovss xmm0, dword ptr [rax+rcx*4]
vmovss xmm1, [rsp+0D8h+var_7C]
vsubss xmm1, xmm0, xmm1
vxorps xmm0, xmm0, xmm0
vblendps xmm0, xmm0, xmm1, 1
vmovaps [rsp+0D8h+var_A8], xmm0
vmovaps xmm0, [rsp+0D8h+var_A8]
vcvtps2ph xmm0, xmm0, 0
vmovd eax, xmm0
mov [rsp+0D8h+var_94], ax
mov ax, [rsp+0D8h+var_94]
mov [rsp+0D8h+var_92], ax
mov ax, [rsp+0D8h+var_92]
mov [rsp+0D8h+var_8A], ax
movzx eax, [rsp+0D8h+var_8A]
mov ecx, eax
lea rax, ggml_table_exp_f16
movzx edi, word ptr [rax+rcx*2]
call ggml_lookup_fp16_to_fp32
vmovss [rsp+0D8h+var_AC], xmm0
vmovss xmm1, [rsp+0D8h+var_AC]
vcvtss2sd xmm0, xmm0, xmm1
vaddsd xmm0, xmm0, [rsp+0D8h+var_88]
vmovsd [rsp+0D8h+var_88], xmm0
vmovss xmm0, [rsp+0D8h+var_AC]
mov rax, [rsp+0D8h+var_70]
movsxd rcx, [rsp+0D8h+var_90]
vmovss dword ptr [rax+rcx*4], xmm0
loc_155A28:
jmp short $+2
loc_155A2A:
mov eax, [rsp+0D8h+var_90]
add eax, 1
mov [rsp+0D8h+var_90], eax
jmp loc_155940
loc_155A3A:
vmovsd xmm0, cs:qword_17F258
vdivsd xmm0, xmm0, [rsp+0D8h+var_88]
vmovsd [rsp+0D8h+var_88], xmm0
mov edi, [rsp+0D8h+var_3C]
mov rsi, [rsp+0D8h+var_70]
vmovsd xmm1, [rsp+0D8h+var_88]
vcvtsd2ss xmm0, xmm0, xmm1
call ggml_vec_scale_f32
mov eax, [rsp+0D8h+var_5C]
add eax, 1
mov [rsp+0D8h+var_5C], eax
jmp loc_1557F0
loc_155A79:
add rsp, 0D8h
retn
| unsigned long long ggml_compute_forward_soft_max_f32(_DWORD *a1, _QWORD *a2, _QWORD *a3, long long a4)
{
unsigned long long result; // rax
long long v36; // [rsp+10h] [rbp-C8h]
int v37; // [rsp+1Ch] [rbp-BCh]
long long v38; // [rsp+20h] [rbp-B8h]
int j; // [rsp+48h] [rbp-90h]
int v45; // [rsp+5Ch] [rbp-7Ch] BYREF
long long v46; // [rsp+60h] [rbp-78h]
long long v47; // [rsp+68h] [rbp-70h]
long long v48; // [rsp+70h] [rbp-68h]
int i; // [rsp+7Ch] [rbp-5Ch]
long long v50; // [rsp+80h] [rbp-58h]
int v51; // [rsp+8Ch] [rbp-4Ch]
int v52; // [rsp+90h] [rbp-48h]
int v53; // [rsp+94h] [rbp-44h]
int v54; // [rsp+98h] [rbp-40h]
int v55; // [rsp+9Ch] [rbp-3Ch]
long long v56; // [rsp+A0h] [rbp-38h]
int v57; // [rsp+ACh] [rbp-2Ch]
int v58; // [rsp+B0h] [rbp-28h]
int v59; // [rsp+B4h] [rbp-24h]
long long v60; // [rsp+B8h] [rbp-20h]
_QWORD *v61; // [rsp+C0h] [rbp-18h]
_QWORD *v62; // [rsp+C8h] [rbp-10h]
_DWORD *v63; // [rsp+D0h] [rbp-8h]
v63 = a1;
v62 = a2;
v61 = a3;
v60 = a4;
result = (unsigned long long)a1;
if ( *a1 )
{
result = (unsigned long long)v63;
if ( *v63 != 2 )
{
__asm
{
vmovss xmm0, cs:flt_17D004
vmovss [rsp+0D8h+var_24], xmm0
}
v59 = *(_DWORD *)(v60 + 84);
v58 = v63[1];
v57 = v63[2];
if ( v61 )
v38 = v61[3];
else
v38 = 1LL;
v56 = v38;
v55 = v62[2];
v54 = ggml_nrows(v62);
v53 = (v57 + v54 - 1) / v57;
v52 = v58 * v53;
if ( v53 + v58 * v53 >= v54 )
v37 = v54;
else
v37 = v53 + v52;
v51 = v37;
v50 = 4 * v58 * (v55 + 16LL) + *((_QWORD *)v63 + 3);
for ( i = v52; ; ++i )
{
result = (unsigned int)i;
if ( i >= v51 )
break;
v48 = v62[7] * i + v62[35];
v47 = *(_QWORD *)(v60 + 56) * i + *(_QWORD *)(v60 + 280);
if ( v61 )
v36 = v61[7] * (i % v56) + v61[35];
else
v36 = 0LL;
v46 = v36;
ggml_vec_cpy_f32(v55, v50, v48);
__asm { vmovss xmm0, [rsp+0D8h+var_24] }
ggml_vec_scale_f32(v55, v50, _XMM0);
if ( v46 )
ggml_vec_acc_f32(v55, v50, v46);
__asm
{
vmovss xmm0, cs:dword_1895CC
vmovss [rsp+0D8h+var_7C], xmm0
}
*(double *)&_XMM0 = ggml_vec_max_f32((unsigned int)v55, &v45, v50);
__asm
{
vxorps xmm0, xmm0, xmm0
vmovsd [rsp+0D8h+var_88], xmm0
}
for ( j = 0; j < v55; ++j )
{
_RAX = v50;
_RCX = j;
__asm
{
vmovss xmm0, dword ptr [rax+rcx*4]
vmovss xmm1, cs:dword_1895CC
vucomiss xmm0, xmm1
}
if ( j != v55 || __SETP__(j, v55) )
{
_RAX = v50;
_RCX = j;
__asm
{
vmovss xmm0, dword ptr [rax+rcx*4]
vmovss xmm1, [rsp+0D8h+var_7C]
vsubss xmm1, xmm0, xmm1
vxorps xmm0, xmm0, xmm0
vblendps xmm0, xmm0, xmm1, 1
vmovaps [rsp+0D8h+var_A8], xmm0
vmovaps xmm0, [rsp+0D8h+var_A8]
vcvtps2ph xmm0, xmm0, 0
vmovd eax, xmm0
}
_XMM0 = ggml_lookup_fp16_to_fp32(ggml_table_exp_f16[(unsigned __int16)_RAX]);
__asm
{
vmovss [rsp+0D8h+var_AC], xmm0
vmovss xmm1, [rsp+0D8h+var_AC]
vcvtss2sd xmm0, xmm0, xmm1
vaddsd xmm0, xmm0, [rsp+0D8h+var_88]
vmovsd [rsp+0D8h+var_88], xmm0
vmovss xmm0, [rsp+0D8h+var_AC]
}
_RAX = v47;
_RCX = j;
__asm { vmovss dword ptr [rax+rcx*4], xmm0 }
}
else
{
_RAX = v47;
_RCX = j;
__asm
{
vxorps xmm0, xmm0, xmm0
vmovss dword ptr [rax+rcx*4], xmm0
}
}
}
__asm
{
vmovsd xmm0, cs:qword_17F258
vdivsd xmm0, xmm0, [rsp+0D8h+var_88]
vmovsd [rsp+0D8h+var_88], xmm0
vmovsd xmm1, [rsp+0D8h+var_88]
vcvtsd2ss xmm0, xmm0, xmm1
}
ggml_vec_scale_f32(v55, v47, _XMM0);
}
}
}
return result;
}
| insert<std::pair<std::__cxx11::string_const,ggml_tensor*>&>:
SUB RSP,0x38
MOV qword ptr [RSP + 0x20],RDI
MOV qword ptr [RSP + 0x18],RSI
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x18]
CALL 0x00165320
MOV byte ptr [RSP + 0x10],DL
MOV qword ptr [RSP + 0x8],RAX
MOV AL,byte ptr [RSP + 0x10]
MOV byte ptr [RSP + 0x30],AL
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x28],RAX
MOV RAX,qword ptr [RSP + 0x28]
MOV DL,byte ptr [RSP + 0x30]
ADD RSP,0x38
RET
|
/* std::enable_if<is_constructible<std::pair<std::__cxx11::string const, ggml_tensor*>,
std::pair<std::__cxx11::string const, ggml_tensor*>&>::value,
std::pair<std::_Rb_tree_iterator<std::pair<std::__cxx11::string const, ggml_tensor*> >, bool>
>::type std::map<std::__cxx11::string, ggml_tensor*, std::less<std::__cxx11::string >,
std::allocator<std::pair<std::__cxx11::string const, ggml_tensor*> >
>::insert<std::pair<std::__cxx11::string const, ggml_tensor*>&>(std::pair<std::__cxx11::string
const, ggml_tensor*>&) */
unkbyte9 __thiscall
std::
map<std::__cxx11::string,ggml_tensor*,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,ggml_tensor*>>>
::insert<std::pair<std::__cxx11::string_const,ggml_tensor*>&>
(map<std::__cxx11::string,ggml_tensor*,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,ggml_tensor*>>>
*this,pair *param_1)
{
int8 uVar1;
int1 extraout_DL;
uVar1 = _Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,ggml_tensor*>,std::_Select1st<std::pair<std::__cxx11::string_const,ggml_tensor*>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,ggml_tensor*>>>
::_M_emplace_unique<std::pair<std::__cxx11::string_const,ggml_tensor*>&>
((_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,ggml_tensor*>,std::_Select1st<std::pair<std::__cxx11::string_const,ggml_tensor*>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,ggml_tensor*>>>
*)this,param_1);
return CONCAT18(extraout_DL,uVar1);
}
| |
52,916 | cxxopts::values::parser_tool::IsTrueText(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | zkingston[P]unknot/build_O0/_deps/cxxopts-src/include/cxxopts.hpp | inline bool IsTrueText(const std::string &text)
{
static const std::basic_regex<char> truthy_matcher(truthy_pattern);
std::smatch result;
std::regex_match(text, result, truthy_matcher);
return !result.empty();
} | O0 | cpp | cxxopts::values::parser_tool::IsTrueText(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
cmpb $0x0, 0x61fa70(%rip) # 0x68f5d0
jne 0x6fbb3
leaq 0x61fa67(%rip), %rdi # 0x68f5d0
callq 0x135c0
cmpl $0x0, %eax
je 0x6fbb3
leaq 0x61fa36(%rip), %rdi # 0x68f5b0
leaq 0x55de3c(%rip), %rsi # 0x5cd9bd
movl $0x10, %edx
callq 0x1ca70
jmp 0x6fb8d
leaq -0x53074(%rip), %rdi # 0x1cb20
leaq 0x61fa15(%rip), %rsi # 0x68f5b0
leaq 0x61e016(%rip), %rdx # 0x68dbb8
callq 0x12ad0
leaq 0x61fa22(%rip), %rdi # 0x68f5d0
callq 0x127f0
leaq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x45a10
movq 0x8(%rsp), %rsi
movq 0x40(%rsp), %rdi
leaq 0x61f9dd(%rip), %rdx # 0x68f5b0
xorl %ecx, %ecx
callq 0x6fda0
jmp 0x6fbdc
leaq 0x10(%rsp), %rdi
callq 0x4de80
xorb $-0x1, %al
movb %al, 0x7(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x45b60
movb 0x7(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x61f9ba(%rip), %rdi # 0x68f5d0
callq 0x127d0
jmp 0x6fc35
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x45b60
movq 0x38(%rsp), %rdi
callq 0x13540
nop
| _ZN7cxxopts6values11parser_tool10IsTrueTextERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
sub rsp, 48h
mov [rsp+48h+var_8], rdi
cmp cs:_ZGVZN7cxxopts6values11parser_tool10IsTrueTextERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE14truthy_matcherB5cxx11, 0; `guard variable for'cxxopts::values::parser_tool::IsTrueText(std::string const&)::truthy_matcher
jnz short loc_6FBB3
lea rdi, _ZGVZN7cxxopts6values11parser_tool10IsTrueTextERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE14truthy_matcherB5cxx11; __guard *
call ___cxa_guard_acquire
cmp eax, 0
jz short loc_6FBB3
lea rdi, _ZZN7cxxopts6values11parser_tool10IsTrueTextERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE14truthy_matcherB5cxx11; cxxopts::values::parser_tool::IsTrueText(std::string const&)::truthy_matcher
lea rsi, aTTRue1; "(t|T)(rue)?|1"
mov edx, 10h
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)
jmp short $+2
loc_6FB8D:
lea rdi, _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; lpfunc
lea rsi, _ZZN7cxxopts6values11parser_tool10IsTrueTextERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE14truthy_matcherB5cxx11; obj
lea rdx, __dso_handle; lpdso_handle
call ___cxa_atexit
lea rdi, _ZGVZN7cxxopts6values11parser_tool10IsTrueTextERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE14truthy_matcherB5cxx11; __guard *
call ___cxa_guard_release
loc_6FBB3:
lea rdi, [rsp+48h+var_38]
mov [rsp+48h+var_40], rdi
call _ZNSt7__cxx1113match_resultsIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEESaINS_9sub_matchISA_EEEEC2Ev; std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>>::match_results(void)
mov rsi, [rsp+48h+var_40]
mov rdi, [rsp+48h+var_8]
lea rdx, _ZZN7cxxopts6values11parser_tool10IsTrueTextERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE14truthy_matcherB5cxx11; cxxopts::values::parser_tool::IsTrueText(std::string const&)::truthy_matcher
xor ecx, ecx
call _ZSt11regex_matchISt11char_traitsIcESaIcESaINSt7__cxx119sub_matchIN9__gnu_cxx17__normal_iteratorIPKcNS3_12basic_stringIcS1_S2_EEEEEEEcNS3_12regex_traitsIcEEEbRKNS9_IT2_T_T0_EERNS3_13match_resultsINSJ_14const_iteratorET1_EERKNS3_11basic_regexISG_T3_EENSt15regex_constants15match_flag_typeE; std::regex_match<std::char_traits<char>,std::allocator<char>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>>(std::string const&,std::match_results<std::string::const_iterator> &,std::basic_regex<char,std::regex_traits<char>> const&,std::regex_constants::match_flag_type)
jmp short $+2
loc_6FBDC:
lea rdi, [rsp+48h+var_38]
call _ZNKSt7__cxx1113match_resultsIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEESaINS_9sub_matchISA_EEEE5emptyEv; std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>>::empty(void)
xor al, 0FFh
mov [rsp+48h+var_41], al
lea rdi, [rsp+48h+var_38]
call _ZNSt7__cxx1113match_resultsIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEESaINS_9sub_matchISA_EEEED2Ev; std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>>::~match_results()
mov al, [rsp+48h+var_41]
and al, 1
add rsp, 48h
retn
mov rcx, rax
mov eax, edx
mov [rsp+arg_30], rcx
mov [rsp+arg_2C], eax
lea rdi, _ZGVZN7cxxopts6values11parser_tool10IsTrueTextERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE14truthy_matcherB5cxx11; __guard *
call ___cxa_guard_abort
jmp short loc_6FC35
mov rcx, rax
mov eax, edx
mov [rsp+arg_30], rcx
mov [rsp+arg_2C], eax
lea rdi, [rsp+arg_8]
call _ZNSt7__cxx1113match_resultsIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEESaINS_9sub_matchISA_EEEED2Ev; std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>>::~match_results()
loc_6FC35:
mov rdi, [rsp+arg_30]
call __Unwind_Resume
| char cxxopts::values::parser_tool::IsTrueText(long long a1)
{
char v2; // [rsp+7h] [rbp-41h]
_QWORD v3[6]; // [rsp+10h] [rbp-38h] BYREF
long long v4; // [rsp+40h] [rbp-8h]
v4 = a1;
if ( !(_BYTE)`guard variable for'cxxopts::values::parser_tool::IsTrueText(std::string const&)::truthy_matcher[abi:cxx11]
&& __cxa_guard_acquire(&`guard variable for'cxxopts::values::parser_tool::IsTrueText(std::string const&)::truthy_matcher[abi:cxx11]) )
{
std::basic_regex<char,std::regex_traits<char>>::basic_regex(
(long long)&cxxopts::values::parser_tool::IsTrueText(std::string const&)::truthy_matcher[abi:cxx11],
(long long)"(t|T)(rue)?|1",
0x10u);
__cxa_atexit(
(void (*)(void *))std::basic_regex<char,std::regex_traits<char>>::~basic_regex,
&cxxopts::values::parser_tool::IsTrueText(std::string const&)::truthy_matcher[abi:cxx11],
&_dso_handle);
__cxa_guard_release(&`guard variable for'cxxopts::values::parser_tool::IsTrueText(std::string const&)::truthy_matcher[abi:cxx11]);
}
std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>>::match_results((long long)v3);
std::regex_match<std::char_traits<char>,std::allocator<char>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>>(
v4,
v3,
&cxxopts::values::parser_tool::IsTrueText(std::string const&)::truthy_matcher[abi:cxx11],
0LL);
v2 = ~std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>>::empty(v3);
std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>>::~match_results((long long)v3);
return v2 & 1;
}
| IsTrueText:
SUB RSP,0x48
MOV qword ptr [RSP + 0x40],RDI
CMP byte ptr [0x0078f5d0],0x0
JNZ 0x0016fbb3
LEA RDI,[0x78f5d0]
CALL 0x001135c0
CMP EAX,0x0
JZ 0x0016fbb3
LAB_0016fb73:
LEA RDI,[0x78f5b0]
LEA RSI,[0x6cd9bd]
MOV EDX,0x10
CALL 0x0011ca70
JMP 0x0016fb8d
LAB_0016fb8d:
LEA RDI,[0x11cb20]
LEA RSI,[0x78f5b0]
LEA RDX,[0x78dbb8]
CALL 0x00112ad0
LEA RDI,[0x78f5d0]
CALL 0x001127f0
LAB_0016fbb3:
LEA RDI,[RSP + 0x10]
MOV qword ptr [RSP + 0x8],RDI
CALL 0x00145a10
MOV RSI,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RSP + 0x40]
LAB_0016fbcc:
LEA RDX,[0x78f5b0]
XOR ECX,ECX
CALL 0x0016fda0
LAB_0016fbda:
JMP 0x0016fbdc
LAB_0016fbdc:
LEA RDI,[RSP + 0x10]
CALL 0x0014de80
XOR AL,0xff
MOV byte ptr [RSP + 0x7],AL
LEA RDI,[RSP + 0x10]
CALL 0x00145b60
MOV AL,byte ptr [RSP + 0x7]
AND AL,0x1
ADD RSP,0x48
RET
|
/* cxxopts::values::parser_tool::IsTrueText(std::__cxx11::string const&) */
uint cxxopts::values::parser_tool::IsTrueText(string *param_1)
{
int1 uVar1;
int iVar2;
int4 uVar3;
match_results<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>>
local_38 [48];
string *local_8;
local_8 = param_1;
if (IsTrueText(std::__cxx11::string_const&)::truthy_matcher_abi_cxx11_ == '\0') {
iVar2 = __cxa_guard_acquire(&IsTrueText(std::__cxx11::string_const&)::truthy_matcher_abi_cxx11_)
;
if (iVar2 != 0) {
/* try { // try from 0016fb73 to 0016fb8a has its CatchHandler @ 0016fc01 */
std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::basic_regex
(IsTrueText(std::__cxx11::string_const&)::truthy_matcher_abi_cxx11_,"(t|T)(rue)?|1",
0x10);
__cxa_atexit(std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::~basic_regex,
IsTrueText(std::__cxx11::string_const&)::truthy_matcher_abi_cxx11_,&__dso_handle)
;
__cxa_guard_release(&IsTrueText(std::__cxx11::string_const&)::truthy_matcher_abi_cxx11_);
}
}
std::__cxx11::
match_results<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>>
::match_results(local_38);
/* try { // try from 0016fbcc to 0016fbd9 has its CatchHandler @ 0016fc1d */
std::
regex_match<std::char_traits<char>,std::allocator<char>,std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>,char,std::__cxx11::regex_traits<char>>
(local_8,local_38,IsTrueText(std::__cxx11::string_const&)::truthy_matcher_abi_cxx11_,0);
uVar1 = std::__cxx11::
match_results<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>>
::empty(local_38);
uVar3 = std::__cxx11::
match_results<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>>
::~match_results(local_38);
return (CONCAT31((int3)((uint)uVar3 >> 8),uVar1) ^ 0xff) & 0xffffff01;
}
| |
52,917 | hexlo | eloqsql/strings/ctype-utf8.c | static int hexlo(int x)
{
static const char hex_lo_digit[256]=
{
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* ................ */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* ................ */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* !"#$%&'()*+,-./ */
0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-1,-1,-1,-1,-1,-1, /* 0123456789:;<=>? */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* @ABCDEFGHIJKLMNO */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* PQRSTUVWXYZ[\]^_ */
-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* `abcdefghijklmno */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* pqrstuvwxyz{|}~. */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* ................ */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* ................ */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* ................ */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* ................ */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* ................ */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* ................ */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* ................ */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* ................ */
};
return hex_lo_digit[(unsigned int) x];
} | O0 | c | hexlo:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x15014d(%rip), %rax # 0x223320
movsbl (%rax,%rcx), %eax
popq %rbp
retq
nopl (%rax)
| hexlo:
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov eax, [rbp+var_4]
mov ecx, eax
lea rax, hexlo_hex_lo_digit
movsx eax, byte ptr [rax+rcx]
pop rbp
retn
| long long hexlo(int a1)
{
return (unsigned int)hexlo_hex_lo_digit[a1];
}
| hexlo:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV EAX,dword ptr [RBP + -0x4]
MOV ECX,EAX
LEA RAX,[0x323320]
MOVSX EAX,byte ptr [RAX + RCX*0x1]
POP RBP
RET
|
int hexlo(uint param_1)
{
return (int)(char)hexlo_hex_lo_digit[param_1];
}
| |
52,918 | LefDefParser::lefwLayerRoutingMinimumcutLengthWithin(double, double) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefwWriter.cpp | int
lefwLayerRoutingMinimumcutLengthWithin(double length,
double distance)
{
if (!lefwFile)
return LEFW_UNINITIALIZED;
if (!lefwIsRoutingMinCut || lefwIsRoutingMinCutLen)
return LEFW_BAD_ORDER;
// lefwLayerRoutingMinimumcut has not being called or
// lefwLayerRoutingMinimumcutLengthWithin has already called
if (lefwWriteEncrypt)
encPrint(lefwFile, (char*) "\n LENGTH %.11g WITHIN %.11g ",
length, distance);
else
fprintf(lefwFile, "\n LEGNTH %.11g WITHIN %.11g ", length, distance);
lefwLines++;
prtSemiColon = 1;
lefwIsRoutingMinCutLen = 1;
if (lefwIsRoutingMinCutDist) // both distance & length within has defined
lefwIsRoutingMinCut = 0;
return LEFW_OK;
} | O0 | cpp | LefDefParser::lefwLayerRoutingMinimumcutLengthWithin(double, double):
subq $0x18, %rsp
movsd %xmm0, 0x8(%rsp)
movsd %xmm1, (%rsp)
leaq 0xa8bfa(%rip), %rax # 0xc5250
cmpq $0x0, (%rax)
jne 0x1c669
movl $0x1, 0x14(%rsp)
jmp 0x1c72c
leaq 0xa8ea8(%rip), %rax # 0xc5518
cmpl $0x0, (%rax)
je 0x1c681
leaq 0xa8ea4(%rip), %rax # 0xc5520
cmpl $0x0, (%rax)
je 0x1c68e
movl $0x2, 0x14(%rsp)
jmp 0x1c72c
cmpl $0x0, 0xa8ea7(%rip) # 0xc553c
je 0x1c6bc
leaq 0xa8bb2(%rip), %rax # 0xc5250
movq (%rax), %rdi
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
leaq 0x76686(%rip), %rsi # 0x92d39
movb $0x2, %al
callq 0x8bf50
jmp 0x1c6df
leaq 0xa8b8d(%rip), %rax # 0xc5250
movq (%rax), %rdi
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
leaq 0x76682(%rip), %rsi # 0x92d5a
movb $0x2, %al
callq 0x2370
leaq 0xa8db6(%rip), %rax # 0xc549c
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0xa8daa(%rip), %rax # 0xc549c
movl %ecx, (%rax)
movl $0x1, 0xa8e46(%rip) # 0xc5544
leaq 0xa8e1b(%rip), %rax # 0xc5520
movl $0x1, (%rax)
leaq 0xa8e0a(%rip), %rax # 0xc551c
cmpl $0x0, (%rax)
je 0x1c724
leaq 0xa8dfa(%rip), %rax # 0xc5518
movl $0x0, (%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| _ZN12LefDefParser38lefwLayerRoutingMinimumcutLengthWithinEdd:
sub rsp, 18h
movsd [rsp+18h+var_10], xmm0
movsd [rsp+18h+var_18], xmm1
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
cmp qword ptr [rax], 0
jnz short loc_1C669
mov [rsp+18h+var_4], 1
jmp loc_1C72C
loc_1C669:
lea rax, _ZN12LefDefParser19lefwIsRoutingMinCutE; LefDefParser::lefwIsRoutingMinCut
cmp dword ptr [rax], 0
jz short loc_1C681
lea rax, _ZN12LefDefParser22lefwIsRoutingMinCutLenE; LefDefParser::lefwIsRoutingMinCutLen
cmp dword ptr [rax], 0
jz short loc_1C68E
loc_1C681:
mov [rsp+18h+var_4], 2
jmp loc_1C72C
loc_1C68E:
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 0; LefDefParser::lefwWriteEncrypt
jz short loc_1C6BC
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
movsd xmm0, [rsp+18h+var_10]
movsd xmm1, [rsp+18h+var_18]
lea rsi, aLength11gWithi; "\n LENGTH %.11g WITHIN %.11g "
mov al, 2
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp short loc_1C6DF
loc_1C6BC:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
movsd xmm0, [rsp+18h+var_10]
movsd xmm1, [rsp+18h+var_18]
lea rsi, aLegnth11gWithi; "\n LEGNTH %.11g WITHIN %.11g "
mov al, 2
call _fprintf
loc_1C6DF:
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov ecx, [rax]
add ecx, 1
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov [rax], ecx
mov cs:_ZN12LefDefParserL12prtSemiColonE, 1; LefDefParser::prtSemiColon
lea rax, _ZN12LefDefParser22lefwIsRoutingMinCutLenE; LefDefParser::lefwIsRoutingMinCutLen
mov dword ptr [rax], 1
lea rax, _ZN12LefDefParser23lefwIsRoutingMinCutDistE; LefDefParser::lefwIsRoutingMinCutDist
cmp dword ptr [rax], 0
jz short loc_1C724
lea rax, _ZN12LefDefParser19lefwIsRoutingMinCutE; LefDefParser::lefwIsRoutingMinCut
mov dword ptr [rax], 0
loc_1C724:
mov [rsp+18h+var_4], 0
loc_1C72C:
mov eax, [rsp+18h+var_4]
add rsp, 18h
retn
| long long LefDefParser::lefwLayerRoutingMinimumcutLengthWithin(
LefDefParser *this,
double a2,
double a3,
long long a4,
int a5,
int a6,
int a7,
int a8)
{
if ( *(_QWORD *)&LefDefParser::lefwFile )
{
if ( LefDefParser::lefwIsRoutingMinCut && !LefDefParser::lefwIsRoutingMinCutLen )
{
if ( LefDefParser::lefwWriteEncrypt )
LefDefParser::encPrint(
LefDefParser::lefwFile,
(unsigned int)"\n LENGTH %.11g WITHIN %.11g ",
a5,
a6,
a7,
a8);
else
fprintf(*(_QWORD *)&LefDefParser::lefwFile, "\n LEGNTH %.11g WITHIN %.11g ", a2, a3);
++LefDefParser::lefwLines;
LefDefParser::prtSemiColon = 1;
LefDefParser::lefwIsRoutingMinCutLen = 1;
if ( LefDefParser::lefwIsRoutingMinCutDist )
LefDefParser::lefwIsRoutingMinCut = 0;
return 0;
}
else
{
return 2;
}
}
else
{
return 1;
}
}
| lefwLayerRoutingMinimumcutLengthWithin:
SUB RSP,0x18
MOVSD qword ptr [RSP + 0x8],XMM0
MOVSD qword ptr [RSP],XMM1
LEA RAX,[0x1c5250]
CMP qword ptr [RAX],0x0
JNZ 0x0011c669
MOV dword ptr [RSP + 0x14],0x1
JMP 0x0011c72c
LAB_0011c669:
LEA RAX,[0x1c5518]
CMP dword ptr [RAX],0x0
JZ 0x0011c681
LEA RAX,[0x1c5520]
CMP dword ptr [RAX],0x0
JZ 0x0011c68e
LAB_0011c681:
MOV dword ptr [RSP + 0x14],0x2
JMP 0x0011c72c
LAB_0011c68e:
CMP dword ptr [0x001c553c],0x0
JZ 0x0011c6bc
LEA RAX,[0x1c5250]
MOV RDI,qword ptr [RAX]
MOVSD XMM0,qword ptr [RSP + 0x8]
MOVSD XMM1,qword ptr [RSP]
LEA RSI,[0x192d39]
MOV AL,0x2
CALL 0x0018bf50
JMP 0x0011c6df
LAB_0011c6bc:
LEA RAX,[0x1c5250]
MOV RDI,qword ptr [RAX]
MOVSD XMM0,qword ptr [RSP + 0x8]
MOVSD XMM1,qword ptr [RSP]
LEA RSI,[0x192d5a]
MOV AL,0x2
CALL 0x00102370
LAB_0011c6df:
LEA RAX,[0x1c549c]
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
LEA RAX,[0x1c549c]
MOV dword ptr [RAX],ECX
MOV dword ptr [0x001c5544],0x1
LEA RAX,[0x1c5520]
MOV dword ptr [RAX],0x1
LEA RAX,[0x1c551c]
CMP dword ptr [RAX],0x0
JZ 0x0011c724
LEA RAX,[0x1c5518]
MOV dword ptr [RAX],0x0
LAB_0011c724:
MOV dword ptr [RSP + 0x14],0x0
LAB_0011c72c:
MOV EAX,dword ptr [RSP + 0x14]
ADD RSP,0x18
RET
|
/* LefDefParser::lefwLayerRoutingMinimumcutLengthWithin(double, double) */
int4 LefDefParser::lefwLayerRoutingMinimumcutLengthWithin(double param_1,double param_2)
{
int4 local_4;
if (lefwFile == (_IO_FILE *)0x0) {
local_4 = 1;
}
else if ((lefwIsRoutingMinCut == 0) || (lefwIsRoutingMinCutLen != 0)) {
local_4 = 2;
}
else {
if (lefwWriteEncrypt == 0) {
fprintf(lefwFile,"\n LEGNTH %.11g WITHIN %.11g ",param_1,param_2);
}
else {
encPrint(lefwFile,"\n LENGTH %.11g WITHIN %.11g ",param_1,param_2);
}
lefwLines = lefwLines + 1;
prtSemiColon = 1;
lefwIsRoutingMinCutLen = 1;
if (lefwIsRoutingMinCutDist != 0) {
lefwIsRoutingMinCut = 0;
}
local_4 = 0;
}
return local_4;
}
| |
52,919 | my_instr_mb | eloqsql/strings/ctype-mb.c | uint my_instr_mb(CHARSET_INFO *cs,
const char *b, size_t b_length,
const char *s, size_t s_length,
my_match_t *match, uint nmatch)
{
register const char *end, *b0;
int res= 0;
if (s_length <= b_length)
{
if (!s_length)
{
if (nmatch)
{
match->beg= 0;
match->end= 0;
match->mb_len= 0;
}
return 1; /* Empty string is always found */
}
b0= b;
end= b+b_length-s_length+1;
while (b < end)
{
int mb_len;
if (!my_ci_strnncoll(cs, (const uchar *) b, s_length,
(const uchar *) s, s_length, 0))
{
if (nmatch)
{
match[0].beg= 0;
match[0].end= (uint) (b-b0);
match[0].mb_len= res;
if (nmatch > 1)
{
match[1].beg= match[0].end;
match[1].end= (uint)(match[0].end+s_length);
match[1].mb_len= 0; /* Not computed */
}
}
return 2;
}
mb_len= (mb_len= my_ismbchar(cs, b, end)) ? mb_len : 1;
b+= mb_len;
b_length-= mb_len;
res++;
}
}
return 0;
} | O0 | c | my_instr_mb:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movl $0x0, -0x4c(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
ja 0x5554e
cmpq $0x0, -0x30(%rbp)
jne 0x55431
cmpl $0x0, 0x10(%rbp)
je 0x55425
movq -0x38(%rbp), %rax
movl $0x0, (%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0x8(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x55555
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
xorl %ecx, %ecx
subq -0x30(%rbp), %rcx
addq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x5554c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
xorl %r9d, %r9d
callq 0x55560
cmpl $0x0, %eax
jne 0x554ed
cmpl $0x0, 0x10(%rbp)
je 0x554e4
movq -0x38(%rbp), %rax
movl $0x0, (%rax)
movq -0x18(%rbp), %rax
movq -0x48(%rbp), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x4c(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x8(%rax)
cmpl $0x1, 0x10(%rbp)
jbe 0x554e2
movq -0x38(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x38(%rbp), %rax
movl 0x4(%rax), %eax
addq -0x30(%rbp), %rax
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0x14(%rax)
jmp 0x554e4
movl $0x2, -0x4(%rbp)
jmp 0x55555
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x544f0
movl %eax, -0x50(%rbp)
cmpl $0x0, %eax
je 0x5550e
movl -0x50(%rbp), %eax
movl %eax, -0x54(%rbp)
jmp 0x55518
movl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x55518
movl -0x54(%rbp), %eax
movl %eax, -0x50(%rbp)
movl -0x50(%rbp), %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movslq -0x50(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x55452
jmp 0x5554e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nop
| my_instr_mb:
push rbp
mov rbp, rsp
sub rsp, 60h
mov eax, [rbp+arg_0]
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov [rbp+var_38], r9
mov [rbp+var_4C], 0
mov rax, [rbp+var_30]
cmp rax, [rbp+var_20]
ja loc_5554E
cmp [rbp+var_30], 0
jnz short loc_55431
cmp [rbp+arg_0], 0
jz short loc_55425
mov rax, [rbp+var_38]
mov dword ptr [rax], 0
mov rax, [rbp+var_38]
mov dword ptr [rax+4], 0
mov rax, [rbp+var_38]
mov dword ptr [rax+8], 0
loc_55425:
mov [rbp+var_4], 1
jmp loc_55555
loc_55431:
mov rax, [rbp+var_18]
mov [rbp+var_48], rax
mov rax, [rbp+var_18]
add rax, [rbp+var_20]
xor ecx, ecx
sub rcx, [rbp+var_30]
add rax, rcx
add rax, 1
mov [rbp+var_40], rax
loc_55452:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_40]
jnb loc_5554C
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_30]
mov rcx, [rbp+var_28]
mov r8, [rbp+var_30]
xor r9d, r9d
call my_ci_strnncoll
cmp eax, 0
jnz short loc_554ED
cmp [rbp+arg_0], 0
jz short loc_554E4
mov rax, [rbp+var_38]
mov dword ptr [rax], 0
mov rax, [rbp+var_18]
mov rcx, [rbp+var_48]
sub rax, rcx
mov ecx, eax
mov rax, [rbp+var_38]
mov [rax+4], ecx
mov ecx, [rbp+var_4C]
mov rax, [rbp+var_38]
mov [rax+8], ecx
cmp [rbp+arg_0], 1
jbe short loc_554E2
mov rax, [rbp+var_38]
mov ecx, [rax+4]
mov rax, [rbp+var_38]
mov [rax+0Ch], ecx
mov rax, [rbp+var_38]
mov eax, [rax+4]
add rax, [rbp+var_30]
mov ecx, eax
mov rax, [rbp+var_38]
mov [rax+10h], ecx
mov rax, [rbp+var_38]
mov dword ptr [rax+14h], 0
loc_554E2:
jmp short $+2
loc_554E4:
mov [rbp+var_4], 2
jmp short loc_55555
loc_554ED:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_40]
call my_ismbchar_0
mov [rbp+var_50], eax
cmp eax, 0
jz short loc_5550E
mov eax, [rbp+var_50]
mov [rbp+var_54], eax
jmp short loc_55518
loc_5550E:
mov eax, 1
mov [rbp+var_54], eax
jmp short $+2
loc_55518:
mov eax, [rbp+var_54]
mov [rbp+var_50], eax
mov ecx, [rbp+var_50]
mov rax, [rbp+var_18]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_18], rax
movsxd rcx, [rbp+var_50]
mov rax, [rbp+var_20]
sub rax, rcx
mov [rbp+var_20], rax
mov eax, [rbp+var_4C]
add eax, 1
mov [rbp+var_4C], eax
jmp loc_55452
loc_5554C:
jmp short $+2
loc_5554E:
mov [rbp+var_4], 0
loc_55555:
mov eax, [rbp+var_4]
add rsp, 60h
pop rbp
retn
| long long my_instr_mb(
long long a1,
unsigned long long a2,
unsigned long long a3,
long long a4,
unsigned long long a5,
_DWORD *a6,
unsigned int a7)
{
int v8; // [rsp+Ch] [rbp-54h]
int v9; // [rsp+10h] [rbp-50h]
int v10; // [rsp+14h] [rbp-4Ch]
unsigned long long v11; // [rsp+20h] [rbp-40h]
unsigned long long v15; // [rsp+40h] [rbp-20h]
unsigned long long v16; // [rsp+48h] [rbp-18h]
v16 = a2;
v15 = a3;
v10 = 0;
if ( a5 > a3 )
return 0;
if ( a5 )
{
v11 = a3 + a2 - a5 + 1;
while ( v16 < v11 )
{
if ( !(unsigned int)my_ci_strnncoll(a1, v16, a5, a4, a5, 0LL) )
{
if ( a7 )
{
*a6 = 0;
a6[1] = v16 - a2;
a6[2] = v10;
if ( a7 > 1 )
{
a6[3] = a6[1];
a6[4] = a5 + a6[1];
a6[5] = 0;
}
}
return 2;
}
v9 = my_ismbchar_0(a1, v16, v11);
if ( v9 )
v8 = v9;
else
v8 = 1;
v16 += v8;
v15 -= v8;
++v10;
}
return 0;
}
if ( a7 )
{
*a6 = 0;
a6[1] = 0;
a6[2] = 0;
}
return 1;
}
| my_instr_mb:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV EAX,dword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV qword ptr [RBP + -0x38],R9
MOV dword ptr [RBP + -0x4c],0x0
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x20]
JA 0x0015554e
CMP qword ptr [RBP + -0x30],0x0
JNZ 0x00155431
CMP dword ptr [RBP + 0x10],0x0
JZ 0x00155425
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x4],0x0
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x8],0x0
LAB_00155425:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00155555
LAB_00155431:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,qword ptr [RBP + -0x20]
XOR ECX,ECX
SUB RCX,qword ptr [RBP + -0x30]
ADD RAX,RCX
ADD RAX,0x1
MOV qword ptr [RBP + -0x40],RAX
LAB_00155452:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x40]
JNC 0x0015554c
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x28]
MOV R8,qword ptr [RBP + -0x30]
XOR R9D,R9D
CALL 0x00155560
CMP EAX,0x0
JNZ 0x001554ed
CMP dword ptr [RBP + 0x10],0x0
JZ 0x001554e4
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x48]
SUB RAX,RCX
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x4],ECX
MOV ECX,dword ptr [RBP + -0x4c]
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x8],ECX
CMP dword ptr [RBP + 0x10],0x1
JBE 0x001554e2
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RAX + 0x4]
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0xc],ECX
MOV RAX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RAX + 0x4]
ADD RAX,qword ptr [RBP + -0x30]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x14],0x0
LAB_001554e2:
JMP 0x001554e4
LAB_001554e4:
MOV dword ptr [RBP + -0x4],0x2
JMP 0x00155555
LAB_001554ed:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x40]
CALL 0x001544f0
MOV dword ptr [RBP + -0x50],EAX
CMP EAX,0x0
JZ 0x0015550e
MOV EAX,dword ptr [RBP + -0x50]
MOV dword ptr [RBP + -0x54],EAX
JMP 0x00155518
LAB_0015550e:
MOV EAX,0x1
MOV dword ptr [RBP + -0x54],EAX
JMP 0x00155518
LAB_00155518:
MOV EAX,dword ptr [RBP + -0x54]
MOV dword ptr [RBP + -0x50],EAX
MOV ECX,dword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x18]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
MOVSXD RCX,dword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x20]
SUB RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV EAX,dword ptr [RBP + -0x4c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x4c],EAX
JMP 0x00155452
LAB_0015554c:
JMP 0x0015554e
LAB_0015554e:
MOV dword ptr [RBP + -0x4],0x0
LAB_00155555:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x60
POP RBP
RET
|
int4
my_instr_mb(int8 param_1,ulong param_2,ulong param_3,int8 param_4,ulong param_5,
int4 *param_6,uint param_7)
{
int iVar1;
ulong uVar2;
int local_5c;
int local_54;
ulong local_20;
local_54 = 0;
if (param_5 <= param_3) {
if (param_5 == 0) {
if (param_7 != 0) {
*param_6 = 0;
param_6[1] = 0;
param_6[2] = 0;
}
return 1;
}
uVar2 = ((param_2 + param_3) - param_5) + 1;
for (local_20 = param_2; local_20 < uVar2; local_20 = local_20 + (long)local_5c) {
iVar1 = my_ci_strnncoll(param_1,local_20,param_5,param_4,param_5,0);
if (iVar1 == 0) {
if (param_7 != 0) {
*param_6 = 0;
param_6[1] = (int)local_20 - (int)param_2;
param_6[2] = local_54;
if (1 < param_7) {
param_6[3] = param_6[1];
param_6[4] = param_6[1] + (int)param_5;
param_6[5] = 0;
}
}
return 2;
}
local_5c = my_ismbchar(param_1,local_20,uVar2);
if (local_5c == 0) {
local_5c = 1;
}
local_54 = local_54 + 1;
}
}
return 0;
}
| |
52,920 | my_vfprintf | eloqsql/strings/my_vsnprintf.c | int my_vfprintf(FILE *stream, const char* format, va_list args)
{
char cvtbuf[1024];
int alloc= 0;
char *p= cvtbuf;
size_t cur_len= sizeof(cvtbuf), actual;
int ret;
/*
We do not know how much buffer we need.
So start with a reasonably-sized stack-allocated buffer, and increase
it exponentially until it is big enough.
*/
for (;;)
{
size_t new_len;
actual= my_vsnprintf(p, cur_len, format, args);
if (actual < cur_len - 1)
break;
/*
Not enough space (or just enough with nothing to spare - but we cannot
distinguish this case from the return value). Allocate a bigger buffer
and try again.
*/
if (alloc)
my_free(p);
else
alloc= 1;
new_len= cur_len*2;
if (new_len < cur_len)
return 0; /* Overflow */
cur_len= new_len;
p= my_malloc(PSI_INSTRUMENT_ME, cur_len, MYF(MY_FAE));
if (!p)
return 0;
}
ret= (int) actual;
if (fputs(p, stream) < 0)
ret= -1;
if (alloc)
my_free(p);
return ret;
} | O3 | c | my_vfprintf:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x418, %rsp # imm = 0x418
movq %rdx, -0x440(%rbp)
movq %rsi, %r12
movq %rdi, -0x438(%rbp)
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movb $0x1, %bl
movl $0x400, %r13d # imm = 0x400
leaq -0x430(%rbp), %r14
leaq 0x2bbe28(%rip), %rdi # 0x319a10
movq %r14, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq -0x440(%rbp), %r8
callq 0x5c938
movq %rax, %r15
leaq -0x1(%r13), %rax
cmpq %rax, %r15
jb 0x5dc39
testb $0x1, %bl
jne 0x5dc16
movq %r14, %rdi
callq 0x284b6
testq %r13, %r13
js 0x5dc66
addq %r13, %r13
xorl %ebx, %ebx
movl $0x8, %edx
xorl %edi, %edi
movq %r13, %rsi
callq 0x28289
movq %rax, %r14
testq %rax, %rax
jne 0x5dbe1
jmp 0x5dc68
movq %r14, %rdi
movq -0x438(%rbp), %rsi
callq 0x24390
testl %eax, %eax
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
cmovnsl %r15d, %r12d
testb $0x1, %bl
jne 0x5dc61
movq %r14, %rdi
callq 0x284b6
movl %r12d, %ebx
jmp 0x5dc68
xorl %ebx, %ebx
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x5dc8b
movl %ebx, %eax
addq $0x418, %rsp # imm = 0x418
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x24370
| my_vfprintf:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 418h
mov [rbp+var_440], rdx
mov r12, rsi
mov [rbp+var_438], rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov bl, 1
mov r13d, 400h
lea r14, [rbp+var_430]
loc_5DBE1:
lea rdi, my_charset_latin1
mov rsi, r14
mov rdx, r13
mov rcx, r12
mov r8, [rbp+var_440]
call my_vsnprintf_ex
mov r15, rax
lea rax, [r13-1]
cmp r15, rax
jb short loc_5DC39
test bl, 1
jnz short loc_5DC16
mov rdi, r14
call my_free
loc_5DC16:
test r13, r13
js short loc_5DC66
add r13, r13
xor ebx, ebx
mov edx, 8
xor edi, edi
mov rsi, r13
call my_malloc
mov r14, rax
test rax, rax
jnz short loc_5DBE1
jmp short loc_5DC68
loc_5DC39:
mov rdi, r14
mov rsi, [rbp+var_438]
call _fputs
test eax, eax
mov r12d, 0FFFFFFFFh
cmovns r12d, r15d
test bl, 1
jnz short loc_5DC61
mov rdi, r14
call my_free
loc_5DC61:
mov ebx, r12d
jmp short loc_5DC68
loc_5DC66:
xor ebx, ebx
loc_5DC68:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_5DC8B
mov eax, ebx
add rsp, 418h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_5DC8B:
call ___stack_chk_fail
| long long my_vfprintf(long long a1, unsigned __int8 *a2, unsigned int *a3)
{
unsigned int v3; // ebx
long long v4; // r13
char *v5; // r14
unsigned long long v6; // r15
unsigned int v7; // r12d
char v10; // [rsp+10h] [rbp-430h] BYREF
unsigned long long v11; // [rsp+410h] [rbp-30h]
v11 = __readfsqword(0x28u);
LOBYTE(v3) = 1;
v4 = 1024LL;
v5 = &v10;
while ( 1 )
{
v6 = my_vsnprintf_ex((long long)my_charset_latin1, (unsigned long long)v5, v4, a2, a3);
if ( v6 < v4 - 1 )
break;
if ( (v3 & 1) == 0 )
my_free((long long)v5);
if ( v4 < 0 )
return 0;
v4 *= 2LL;
v3 = 0;
v5 = (char *)my_malloc(0, v4, 8);
if ( !v5 )
return v3;
}
v7 = -1;
if ( (int)fputs(v5, a1) >= 0 )
v7 = v6;
if ( (v3 & 1) == 0 )
my_free((long long)v5);
return v7;
}
| my_vfprintf:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x418
MOV qword ptr [RBP + -0x440],RDX
MOV R12,RSI
MOV qword ptr [RBP + -0x438],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV BL,0x1
MOV R13D,0x400
LEA R14,[RBP + -0x430]
LAB_0015dbe1:
LEA RDI,[0x419a10]
MOV RSI,R14
MOV RDX,R13
MOV RCX,R12
MOV R8,qword ptr [RBP + -0x440]
CALL 0x0015c938
MOV R15,RAX
LEA RAX,[R13 + -0x1]
CMP R15,RAX
JC 0x0015dc39
TEST BL,0x1
JNZ 0x0015dc16
MOV RDI,R14
CALL 0x001284b6
LAB_0015dc16:
TEST R13,R13
JS 0x0015dc66
ADD R13,R13
XOR EBX,EBX
MOV EDX,0x8
XOR EDI,EDI
MOV RSI,R13
CALL 0x00128289
MOV R14,RAX
TEST RAX,RAX
JNZ 0x0015dbe1
JMP 0x0015dc68
LAB_0015dc39:
MOV RDI,R14
MOV RSI,qword ptr [RBP + -0x438]
CALL 0x00124390
TEST EAX,EAX
MOV R12D,0xffffffff
CMOVNS R12D,R15D
TEST BL,0x1
JNZ 0x0015dc61
MOV RDI,R14
CALL 0x001284b6
LAB_0015dc61:
MOV EBX,R12D
JMP 0x0015dc68
LAB_0015dc66:
XOR EBX,EBX
LAB_0015dc68:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0015dc8b
MOV EAX,EBX
ADD RSP,0x418
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0015dc8b:
CALL 0x00124370
|
ulong my_vfprintf(FILE *param_1,int8 param_2,int8 param_3)
{
int iVar1;
ulong uVar2;
char *__s;
ulong uVar3;
ulong uVar4;
long lVar5;
long in_FS_OFFSET;
char local_438 [1024];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
lVar5 = 0x400;
__s = local_438;
uVar3 = 1;
do {
uVar2 = my_vsnprintf_ex(&my_charset_latin1,__s,lVar5,param_2,param_3);
if (uVar2 < lVar5 - 1U) {
iVar1 = fputs(__s,param_1);
uVar4 = 0xffffffff;
if (-1 < iVar1) {
uVar4 = uVar2 & 0xffffffff;
}
if (uVar3 == 0) {
my_free(__s);
}
break;
}
if ((char)uVar3 == '\0') {
my_free(__s);
}
if (lVar5 < 0) {
uVar4 = 0;
break;
}
lVar5 = lVar5 * 2;
uVar4 = 0;
__s = (char *)my_malloc(0,lVar5,8);
uVar3 = uVar4;
} while (__s != (char *)0x0);
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar4;
}
| |
52,921 | free_rw_handler | bluesky950520[P]quickjs/quickjs-libc.c | static void free_rw_handler(JSRuntime *rt, JSOSRWHandler *rh)
{
int i;
list_del(&rh->link);
for(i = 0; i < 2; i++) {
JS_FreeValueRT(rt, rh->rw_func[i]);
}
js_free_rt(rt, rh);
} | O1 | c | free_rw_handler:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
movl $0x20, %r15d
movq -0x8(%rbx,%r15), %rsi
movq (%rbx,%r15), %rdx
movq %r14, %rdi
callq 0x1d8c6
addq $0x10, %r15
cmpq $0x30, %r15
je 0x15332
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1ca84
| free_rw_handler:
push r15
push r14
push rbx
mov rbx, rsi
mov r14, rdi
mov rax, [rsi]
mov rcx, [rsi+8]
mov [rax+8], rcx
mov [rcx], rax
xorps xmm0, xmm0
movups xmmword ptr [rsi], xmm0
mov r15d, 20h ; ' '
loc_15332:
mov rsi, [rbx+r15-8]
mov rdx, [rbx+r15]
mov rdi, r14
call JS_FreeValueRT
add r15, 10h
cmp r15, 30h ; '0'
jz short loc_15332
mov rdi, r14
mov rsi, rbx
pop rbx
pop r14
pop r15
jmp js_free_rt
| long long free_rw_handler(long long a1, long long *a2)
{
long long v2; // rax
_QWORD *v3; // rcx
long long v4; // r15
v2 = *a2;
v3 = (_QWORD *)a2[1];
*(_QWORD *)(v2 + 8) = v3;
*v3 = v2;
*(_OWORD *)a2 = 0LL;
v4 = 4LL;
do
{
JS_FreeValueRT(a1, a2[v4 - 1]);
v4 += 2LL;
}
while ( v4 == 6 );
return js_free_rt(a1, a2);
}
| |||
52,922 | free_rw_handler | bluesky950520[P]quickjs/quickjs-libc.c | static void free_rw_handler(JSRuntime *rt, JSOSRWHandler *rh)
{
int i;
list_del(&rh->link);
for(i = 0; i < 2; i++) {
JS_FreeValueRT(rt, rh->rw_func[i]);
}
js_free_rt(rt, rh);
} | O2 | c | free_rw_handler:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
pushq $0x20
popq %r15
cmpq $0x40, %r15
je 0x102d6
movq -0x8(%rbx,%r15), %rsi
movq (%rbx,%r15), %rdx
movq %r14, %rdi
callq 0x18031
addq $0x10, %r15
jmp 0x102b9
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x170cb
| free_rw_handler:
push r15
push r14
push rbx
mov rbx, rsi
mov r14, rdi
mov rax, [rsi]
mov rcx, [rsi+8]
mov [rax+8], rcx
mov [rcx], rax
xorps xmm0, xmm0
movups xmmword ptr [rsi], xmm0
push 20h ; ' '
pop r15
loc_102B9:
cmp r15, 40h ; '@'
jz short loc_102D6
mov rsi, [rbx+r15-8]
mov rdx, [rbx+r15]
mov rdi, r14
call JS_FreeValueRT
add r15, 10h
jmp short loc_102B9
loc_102D6:
mov rdi, r14
mov rsi, rbx
pop rbx
pop r14
pop r15
jmp js_free_rt
| long long free_rw_handler(long long a1, long long *a2)
{
long long v2; // rax
_QWORD *v3; // rcx
long long i; // r15
v2 = *a2;
v3 = (_QWORD *)a2[1];
*(_QWORD *)(v2 + 8) = v3;
*v3 = v2;
*(_OWORD *)a2 = 0LL;
for ( i = 4LL; i != 8; i += 2LL )
JS_FreeValueRT(a1, a2[i - 1], a2[i]);
return js_free_rt(a1, a2);
}
| free_rw_handler:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R14,RDI
MOV RAX,qword ptr [RSI]
MOV RCX,qword ptr [RSI + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV qword ptr [RCX],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSI],XMM0
PUSH 0x20
POP R15
LAB_001102b9:
CMP R15,0x40
JZ 0x001102d6
MOV RSI,qword ptr [RBX + R15*0x1 + -0x8]
MOV RDX,qword ptr [RBX + R15*0x1]
MOV RDI,R14
CALL 0x00118031
ADD R15,0x10
JMP 0x001102b9
LAB_001102d6:
MOV RDI,R14
MOV RSI,RBX
POP RBX
POP R14
POP R15
JMP 0x001170cb
|
void free_rw_handler(int8 param_1,long *param_2)
{
long *plVar1;
long lVar2;
lVar2 = *param_2;
plVar1 = (long *)param_2[1];
*(long **)(lVar2 + 8) = plVar1;
*plVar1 = lVar2;
*param_2 = 0;
param_2[1] = 0;
for (lVar2 = 0x20; lVar2 != 0x40; lVar2 = lVar2 + 0x10) {
JS_FreeValueRT(param_1,*(int8 *)((long)param_2 + lVar2 + -8),
*(int8 *)((long)param_2 + lVar2));
}
js_free_rt(param_1,param_2);
return;
}
| |
52,923 | 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>>>>>::get_codepoint() | monkey531[P]llama/common/json.hpp | int get_codepoint()
{
// this function only makes sense after reading `\u`
JSON_ASSERT(current == 'u');
int codepoint = 0;
const auto factors = { 12u, 8u, 4u, 0u };
for (const auto factor : factors)
{
get();
if (current >= '0' && current <= '9')
{
codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x30u) << factor);
}
else if (current >= 'A' && current <= 'F')
{
codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x37u) << factor);
}
else if (current >= 'a' && current <= 'f')
{
codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x57u) << factor);
}
else
{
return -1;
}
}
JSON_ASSERT(0x0000 <= codepoint && codepoint <= 0xFFFF);
return codepoint;
} | 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>>>>>::get_codepoint():
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
cmpl $0x75, 0x14(%rdi)
jne 0x42c67
movq %rdi, %rbx
movaps 0x498c6(%rip), %xmm0 # 0x8c4c0
movaps %xmm0, (%rsp)
xorl %r15d, %r15d
pushq $-0x1
popq %r12
xorl %ebp, %ebp
cmpq $0x10, %r15
je 0x42c4b
movl (%rsp,%r15), %r14d
movq %rbx, %rdi
callq 0x42ac8
movl 0x14(%rbx), %eax
leal -0x30(%rax), %edx
cmpl $0xa, %edx
jb 0x42c3e
leal -0x41(%rax), %ecx
cmpl $0x5, %ecx
ja 0x42c31
addl $-0x37, %eax
jmp 0x42c3c
leal -0x61(%rax), %ecx
cmpl $0x5, %ecx
ja 0x42c62
addl $-0x57, %eax
movl %eax, %edx
movl %r14d, %ecx
shll %cl, %edx
addl %edx, %ebp
addq $0x4, %r15
jmp 0x42c07
cmpl $0x10000, %ebp # imm = 0x10000
jae 0x42c83
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %r12d, %ebp
jmp 0x42c53
leaq 0x4ba59(%rip), %rdi # 0x8e6c7
leaq 0x4a20c(%rip), %rdx # 0x8ce81
leaq 0x4cc8a(%rip), %rcx # 0x8f906
movl $0x1d79, %esi # imm = 0x1D79
jmp 0x42c9d
leaq 0x4ba3d(%rip), %rdi # 0x8e6c7
leaq 0x4a1f0(%rip), %rdx # 0x8ce81
leaq 0x4cc7d(%rip), %rcx # 0x8f915
movl $0x1d93, %esi # imm = 0x1D93
xorl %eax, %eax
callq 0x20af0
| _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE13get_codepointEv:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 10h
cmp dword ptr [rdi+14h], 75h ; 'u'
jnz short loc_42C67
mov rbx, rdi
movaps xmm0, cs:xmmword_8C4C0
movaps [rsp+38h+var_38], xmm0
xor r15d, r15d
push 0FFFFFFFFFFFFFFFFh
pop r12
xor ebp, ebp
loc_42C07:
cmp r15, 10h
jz short loc_42C4B
mov r14d, dword ptr [rsp+r15+38h+var_38]
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(void)
mov eax, [rbx+14h]
lea edx, [rax-30h]
cmp edx, 0Ah
jb short loc_42C3E
lea ecx, [rax-41h]
cmp ecx, 5
ja short loc_42C31
add eax, 0FFFFFFC9h
jmp short loc_42C3C
loc_42C31:
lea ecx, [rax-61h]
cmp ecx, 5
ja short loc_42C62
add eax, 0FFFFFFA9h
loc_42C3C:
mov edx, eax
loc_42C3E:
mov ecx, r14d
shl edx, cl
add ebp, edx
add r15, 4
jmp short loc_42C07
loc_42C4B:
cmp ebp, 10000h
jnb short loc_42C83
loc_42C53:
mov eax, ebp
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_42C62:
mov ebp, r12d
jmp short loc_42C53
loc_42C67:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aCurrentU; "current == 'u'"
mov esi, 1D79h
jmp short loc_42C9D
loc_42C83:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, a0x0000Codepoin; "0x0000 <= codepoint && codepoint <= 0xF"...
mov esi, 1D93h
loc_42C9D:
xor eax, eax
call _ggml_abort
| long long nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get_codepoint(
__m128i *a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
long long a7,
long long a8,
long long a9)
{
long long v9; // r15
unsigned int v10; // ebp
int v11; // r14d
__int32 v12; // eax
__int32 v13; // edx
__int32 v14; // eax
long long v16; // rsi
long long v17; // rdx
long long v18; // rcx
long long v19; // r8
long long v20; // r9
_OWORD v21[3]; // [rsp+0h] [rbp-38h]
if ( a1[1].m128i_i32[1] == 117 )
{
v21[0] = xmmword_8C4C0;
v9 = 0LL;
v10 = 0;
while ( v9 != 16 )
{
v11 = *(_DWORD *)((char *)v21 + v9);
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(a1);
v12 = a1[1].m128i_i32[1];
v13 = v12 - 48;
if ( (unsigned int)(v12 - 48) >= 0xA )
{
if ( (unsigned int)(v12 - 65) > 5 )
{
if ( (unsigned int)(v12 - 97) > 5 )
return (unsigned int)-1;
v14 = v12 - 87;
}
else
{
v14 = v12 - 55;
}
v13 = v14;
}
v10 += v13 << v11;
v9 += 4LL;
}
if ( v10 < 0x10000 )
return v10;
v16 = 7571LL;
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
7571LL,
"GGML_ASSERT(%s) failed",
"0x0000 <= codepoint && codepoint <= 0xFFFF");
}
else
{
v16 = 7545LL;
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
7545LL,
"GGML_ASSERT(%s) failed",
"current == 'u'");
}
return nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::next_byte_in_range(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
v16,
v17,
v18,
v19,
v20,
a7,
a8,
a9);
}
| get_codepoint:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x10
CMP dword ptr [RDI + 0x14],0x75
JNZ 0x00142c67
MOV RBX,RDI
MOVAPS XMM0,xmmword ptr [0x0018c4c0]
MOVAPS xmmword ptr [RSP],XMM0
XOR R15D,R15D
PUSH -0x1
POP R12
XOR EBP,EBP
LAB_00142c07:
CMP R15,0x10
JZ 0x00142c4b
MOV R14D,dword ptr [RSP + R15*0x1]
MOV RDI,RBX
CALL 0x00142ac8
MOV EAX,dword ptr [RBX + 0x14]
LEA EDX,[RAX + -0x30]
CMP EDX,0xa
JC 0x00142c3e
LEA ECX,[RAX + -0x41]
CMP ECX,0x5
JA 0x00142c31
ADD EAX,-0x37
JMP 0x00142c3c
LAB_00142c31:
LEA ECX,[RAX + -0x61]
CMP ECX,0x5
JA 0x00142c62
ADD EAX,-0x57
LAB_00142c3c:
MOV EDX,EAX
LAB_00142c3e:
MOV ECX,R14D
SHL EDX,CL
ADD EBP,EDX
ADD R15,0x4
JMP 0x00142c07
LAB_00142c4b:
CMP EBP,0x10000
JNC 0x00142c83
LAB_00142c53:
MOV EAX,EBP
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00142c62:
MOV EBP,R12D
JMP 0x00142c53
LAB_00142c67:
LEA RDI,[0x18e6c7]
LEA RDX,[0x18ce81]
LEA RCX,[0x18f906]
MOV ESI,0x1d79
JMP 0x00142c9d
LAB_00142c83:
LEA RDI,[0x18e6c7]
LEA RDX,[0x18ce81]
LEA RCX,[0x18f915]
MOV ESI,0x1d93
LAB_00142c9d:
XOR EAX,EAX
CALL 0x00120af0
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* 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 > > >::get_codepoint() */
uint __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>>>
::get_codepoint(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)
{
int4 uVar1;
int iVar2;
uint uVar3;
char *pcVar4;
uint uVar5;
int8 uVar6;
long lVar7;
int8 local_38;
int8 uStack_30;
if (*(int *)(this + 0x14) == 0x75) {
local_38 = _DAT_0018c4c0;
uStack_30 = _UNK_0018c4c8;
uVar5 = 0;
for (lVar7 = 0; lVar7 != 0x10; lVar7 = lVar7 + 4) {
uVar1 = *(int4 *)((long)&local_38 + lVar7);
get(this);
iVar2 = *(int *)(this + 0x14);
uVar3 = iVar2 - 0x30;
if (9 < uVar3) {
if (iVar2 - 0x41U < 6) {
uVar3 = iVar2 - 0x37;
}
else {
if (5 < iVar2 - 0x61U) {
return 0xffffffff;
}
uVar3 = iVar2 - 0x57;
}
}
uVar5 = uVar5 + (uVar3 << ((byte)uVar1 & 0x1f));
}
if (uVar5 < 0x10000) {
return uVar5;
}
pcVar4 = "0x0000 <= codepoint && codepoint <= 0xFFFF";
uVar6 = 0x1d93;
}
else {
pcVar4 = "current == \'u\'";
uVar6 = 0x1d79;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",uVar6,
"GGML_ASSERT(%s) failed",pcVar4);
}
| |
52,924 | js_parse_error | bluesky950520[P]quickjs/quickjs.c | int __attribute__((format(printf, 2, 3))) js_parse_error(JSParseState *s, const char *fmt, ...)
{
JSContext *ctx = s->ctx;
va_list ap;
int backtrace_flags;
va_start(ap, fmt);
JS_ThrowError2(ctx, JS_SYNTAX_ERROR, fmt, ap, FALSE);
va_end(ap);
backtrace_flags = 0;
if (s->cur_func && s->cur_func->backtrace_barrier)
backtrace_flags = JS_BACKTRACE_FLAG_SINGLE_LEVEL;
build_backtrace(ctx, ctx->rt->current_exception, JS_UNDEFINED, s->filename,
s->line_num, s->col_num, backtrace_flags);
return -1;
} | O0 | c | js_parse_error:
pushq %rbx
subq $0x130, %rsp # imm = 0x130
testb %al, %al
je 0x4e9c3
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %r9, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rdi, 0x128(%rsp)
movq %rsi, 0x120(%rsp)
movq 0x128(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x118(%rsp)
leaq 0x100(%rsp), %rax
leaq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x140(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq 0x118(%rsp), %rdi
movq 0x120(%rsp), %rdx
leaq 0x100(%rsp), %rcx
movl $0x3, %esi
xorl %r8d, %r8d
callq 0x4eb20
movq %rax, 0xe8(%rsp)
movq %rdx, 0xf0(%rsp)
leaq 0x100(%rsp), %rax
movl $0x0, 0xfc(%rsp)
movq 0x128(%rsp), %rax
cmpq $0x0, 0x90(%rax)
je 0x4eaa1
movq 0x128(%rsp), %rax
movq 0x90(%rax), %rax
cmpl $0x0, 0x80(%rax)
je 0x4eaa1
movl $0x2, 0xfc(%rsp)
movq 0x118(%rsp), %rdi
movq 0x18(%rdi), %rax
movl $0x0, 0xd8(%rsp)
movq $0x3, 0xe0(%rsp)
movq 0x128(%rsp), %rcx
movq 0x18(%rcx), %r9
movl 0x10(%rcx), %r10d
movl 0x14(%rcx), %r11d
movl 0xfc(%rsp), %ebx
movq 0xf0(%rax), %rsi
movq 0xf8(%rax), %rdx
movq 0xd8(%rsp), %rcx
movq 0xe0(%rsp), %r8
movq %rsp, %rax
movl %ebx, 0x10(%rax)
movl %r11d, 0x8(%rax)
movl %r10d, (%rax)
callq 0x4ec40
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq $0x130, %rsp # imm = 0x130
popq %rbx
retq
nopl (%rax)
| js_parse_error:
push rbx
sub rsp, 130h
test al, al
jz short loc_4E9C3
movaps [rsp+138h+var_E8], xmm0
movaps [rsp+138h+var_D8], xmm1
movaps [rsp+138h+var_C8], xmm2
movaps [rsp+138h+var_B8], xmm3
movaps [rsp+138h+var_A8], xmm4
movaps [rsp+138h+var_98], xmm5
movaps [rsp+138h+var_88], xmm6
movaps [rsp+138h+var_78], xmm7
loc_4E9C3:
mov [rsp+138h+var_F0], r9
mov [rsp+138h+var_F8], r8
mov [rsp+138h+var_100], rcx
mov [rsp+138h+var_108], rdx
mov [rsp+138h+var_10], rdi
mov [rsp+138h+var_18], rsi
mov rax, [rsp+138h+var_10]
mov rax, [rax]
mov [rsp+138h+var_20], rax
lea rax, [rsp+138h+var_38]
lea rcx, [rsp+138h+var_118]
mov [rax+10h], rcx
lea rcx, [rsp+138h+arg_0]
mov [rax+8], rcx
mov dword ptr [rax+4], 30h ; '0'
mov dword ptr [rax], 10h
mov rdi, [rsp+138h+var_20]
mov rdx, [rsp+138h+var_18]
lea rcx, [rsp+138h+var_38]
mov esi, 3
xor r8d, r8d
call JS_ThrowError2
mov [rsp+138h+var_50], rax
mov [rsp+138h+var_48], rdx
lea rax, [rsp+138h+var_38]
mov [rsp+138h+var_3C], 0
mov rax, [rsp+138h+var_10]
cmp qword ptr [rax+90h], 0
jz short loc_4EAA1
mov rax, [rsp+138h+var_10]
mov rax, [rax+90h]
cmp dword ptr [rax+80h], 0
jz short loc_4EAA1
mov [rsp+138h+var_3C], 2
loc_4EAA1:
mov rdi, [rsp+138h+var_20]
mov rax, [rdi+18h]
mov dword ptr [rsp+138h+var_60], 0
mov [rsp+138h+var_58], 3
mov rcx, [rsp+138h+var_10]
mov r9, [rcx+18h]
mov r10d, [rcx+10h]
mov r11d, [rcx+14h]
mov ebx, [rsp+138h+var_3C]
mov rsi, [rax+0F0h]
mov rdx, [rax+0F8h]
mov rcx, [rsp+138h+var_60]
mov r8, [rsp+138h+var_58]
mov rax, rsp
mov [rax+10h], ebx
mov [rax+8], r11d
mov [rax], r10d
call build_backtrace
mov eax, 0FFFFFFFFh
add rsp, 130h
pop rbx
retn
| long long js_parse_error(
_QWORD *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,
char a15)
{
long long v15; // rdx
long long v16; // rax
char v18; // [rsp+20h] [rbp-118h] BYREF
long long v19; // [rsp+30h] [rbp-108h]
long long v20; // [rsp+38h] [rbp-100h]
long long v21; // [rsp+40h] [rbp-F8h]
long long v22; // [rsp+48h] [rbp-F0h]
__m128 v23; // [rsp+50h] [rbp-E8h]
__m128 v24; // [rsp+60h] [rbp-D8h]
__m128 v25; // [rsp+70h] [rbp-C8h]
__m128 v26; // [rsp+80h] [rbp-B8h]
__m128 v27; // [rsp+90h] [rbp-A8h]
__m128 v28; // [rsp+A0h] [rbp-98h]
__m128 v29; // [rsp+B0h] [rbp-88h]
__m128 v30; // [rsp+C0h] [rbp-78h]
long long v31; // [rsp+D8h] [rbp-60h]
long long v32; // [rsp+E0h] [rbp-58h]
long long v33; // [rsp+E8h] [rbp-50h]
long long v34; // [rsp+F0h] [rbp-48h]
int v35; // [rsp+FCh] [rbp-3Ch]
_DWORD v36[2]; // [rsp+100h] [rbp-38h] BYREF
char *v37; // [rsp+108h] [rbp-30h]
char *v38; // [rsp+110h] [rbp-28h]
long long v39; // [rsp+118h] [rbp-20h]
long long v40; // [rsp+120h] [rbp-18h]
_QWORD *v41; // [rsp+128h] [rbp-10h]
v23 = a7;
v24 = a8;
v25 = a9;
v26 = a10;
v27 = a11;
v28 = a12;
v29 = a13;
v30 = a14;
v22 = a6;
v21 = a5;
v20 = a4;
v19 = a3;
v41 = a1;
v40 = a2;
v39 = *a1;
v38 = &v18;
v37 = &a15;
v36[1] = 48;
v36[0] = 16;
v33 = JS_ThrowError2(v39, 3LL, a2, v36, 0LL);
v34 = v15;
v35 = 0;
if ( v41[18] && *(_DWORD *)(v41[18] + 128LL) )
v35 = 2;
v16 = *(_QWORD *)(v39 + 24);
LODWORD(v31) = 0;
v32 = 3LL;
build_backtrace(
v39,
*(_QWORD *)(v16 + 240),
*(_QWORD *)(v16 + 248),
0,
3,
v41[3],
*((_DWORD *)v41 + 4),
*((_DWORD *)v41 + 5),
v35);
return 0xFFFFFFFFLL;
}
| js_parse_error:
PUSH RBX
SUB RSP,0x130
TEST AL,AL
JZ 0x0014e9c3
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOVAPS xmmword ptr [RSP + 0x60],XMM1
MOVAPS xmmword ptr [RSP + 0x70],XMM2
MOVAPS xmmword ptr [RSP + 0x80],XMM3
MOVAPS xmmword ptr [RSP + 0x90],XMM4
MOVAPS xmmword ptr [RSP + 0xa0],XMM5
MOVAPS xmmword ptr [RSP + 0xb0],XMM6
MOVAPS xmmword ptr [RSP + 0xc0],XMM7
LAB_0014e9c3:
MOV qword ptr [RSP + 0x48],R9
MOV qword ptr [RSP + 0x40],R8
MOV qword ptr [RSP + 0x38],RCX
MOV qword ptr [RSP + 0x30],RDX
MOV qword ptr [RSP + 0x128],RDI
MOV qword ptr [RSP + 0x120],RSI
MOV RAX,qword ptr [RSP + 0x128]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP + 0x118],RAX
LEA RAX,[RSP + 0x100]
LEA RCX,[RSP + 0x20]
MOV qword ptr [RAX + 0x10],RCX
LEA RCX,[RSP + 0x140]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RAX + 0x4],0x30
MOV dword ptr [RAX],0x10
MOV RDI,qword ptr [RSP + 0x118]
MOV RDX,qword ptr [RSP + 0x120]
LEA RCX,[RSP + 0x100]
MOV ESI,0x3
XOR R8D,R8D
CALL 0x0014eb20
MOV qword ptr [RSP + 0xe8],RAX
MOV qword ptr [RSP + 0xf0],RDX
LEA RAX,[RSP + 0x100]
MOV dword ptr [RSP + 0xfc],0x0
MOV RAX,qword ptr [RSP + 0x128]
CMP qword ptr [RAX + 0x90],0x0
JZ 0x0014eaa1
MOV RAX,qword ptr [RSP + 0x128]
MOV RAX,qword ptr [RAX + 0x90]
CMP dword ptr [RAX + 0x80],0x0
JZ 0x0014eaa1
MOV dword ptr [RSP + 0xfc],0x2
LAB_0014eaa1:
MOV RDI,qword ptr [RSP + 0x118]
MOV RAX,qword ptr [RDI + 0x18]
MOV dword ptr [RSP + 0xd8],0x0
MOV qword ptr [RSP + 0xe0],0x3
MOV RCX,qword ptr [RSP + 0x128]
MOV R9,qword ptr [RCX + 0x18]
MOV R10D,dword ptr [RCX + 0x10]
MOV R11D,dword ptr [RCX + 0x14]
MOV EBX,dword ptr [RSP + 0xfc]
MOV RSI,qword ptr [RAX + 0xf0]
MOV RDX,qword ptr [RAX + 0xf8]
MOV RCX,qword ptr [RSP + 0xd8]
MOV R8,qword ptr [RSP + 0xe0]
MOV RAX,RSP
MOV dword ptr [RAX + 0x10],EBX
MOV dword ptr [RAX + 0x8],R11D
MOV dword ptr [RAX],R10D
CALL 0x0014ec40
MOV EAX,0xffffffff
ADD RSP,0x130
POP RBX
RET
|
int8
js_parse_error(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
long *param_9,int8 param_10,int8 param_11,int8 param_12,
int8 param_13,int8 param_14)
{
char in_AL;
int1 local_118 [16];
int8 local_108;
int8 local_100;
int8 local_f8;
int8 local_f0;
int8 local_e8;
int8 local_d8;
int8 local_c8;
int8 local_b8;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
int4 local_60;
uint uStack_5c;
int8 local_58;
int1 local_50 [16];
int4 local_3c;
int4 local_38;
int4 local_34;
int1 *local_30;
int1 *local_28;
long local_20;
int8 local_18;
long *local_10;
if (in_AL != '\0') {
local_e8 = param_1;
local_d8 = param_2;
local_c8 = param_3;
local_b8 = param_4;
local_a8 = param_5;
local_98 = param_6;
local_88 = param_7;
local_78 = param_8;
}
local_20 = *param_9;
local_28 = local_118;
local_30 = &stack0x00000008;
local_34 = 0x30;
local_38 = 0x10;
local_108 = param_11;
local_100 = param_12;
local_f8 = param_13;
local_f0 = param_14;
local_18 = param_10;
local_10 = param_9;
local_50 = JS_ThrowError2(local_20,3,param_10,&local_38,0);
local_3c = 0;
if ((local_10[0x12] != 0) && (*(int *)(local_10[0x12] + 0x80) != 0)) {
local_3c = 2;
}
local_60 = 0;
local_58 = 3;
build_backtrace(local_20,*(int8 *)(*(long *)(local_20 + 0x18) + 0xf0),
*(int8 *)(*(long *)(local_20 + 0x18) + 0xf8),(ulong)uStack_5c << 0x20,3,
local_10[3],(int)local_10[2],*(int4 *)((long)local_10 + 0x14),local_3c);
return 0xffffffff;
}
| |
52,925 | js_parse_error | bluesky950520[P]quickjs/quickjs.c | int __attribute__((format(printf, 2, 3))) js_parse_error(JSParseState *s, const char *fmt, ...)
{
JSContext *ctx = s->ctx;
va_list ap;
int backtrace_flags;
va_start(ap, fmt);
JS_ThrowError2(ctx, JS_SYNTAX_ERROR, fmt, ap, FALSE);
va_end(ap);
backtrace_flags = 0;
if (s->cur_func && s->cur_func->backtrace_barrier)
backtrace_flags = JS_BACKTRACE_FLAG_SINGLE_LEVEL;
build_backtrace(ctx, ctx->rt->current_exception, JS_UNDEFINED, s->filename,
s->line_num, s->col_num, backtrace_flags);
return -1;
} | O2 | c | js_parse_error:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %r10
movq %rdi, %r14
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x2c069
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq (%rdi), %rbx
movq %rsp, %rcx
movq %rsi, 0x10(%rcx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000010, %rax # imm = 0x3000000010
movq %rax, (%rcx)
pushq $0x3
popq %rsi
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r10, %rdx
xorl %r8d, %r8d
callq 0x2c107
movq 0x90(%r14), %rax
testq %rax, %rax
je 0x2c0bd
xorl %r15d, %r15d
cmpl $0x0, 0x80(%rax)
setne %r15b
addl %r15d, %r15d
movq 0x18(%rbx), %rax
movq 0x18(%r14), %r9
movl 0x10(%r14), %r10d
movl 0x14(%r14), %r11d
movq 0xf0(%rax), %rsi
movq 0xf8(%rax), %rdx
subq $0x8, %rsp
pushq $0x3
popq %r8
movq %rbx, %rdi
xorl %ecx, %ecx
pushq %r15
pushq %r11
pushq %r10
callq 0x2c162
addq $0x20, %rsp
pushq $-0x1
popq %rax
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
| js_parse_error:
push r15
push r14
push rbx
sub rsp, 0D0h
mov r10, rsi
mov r14, rdi
lea rsi, [rsp+0E8h+var_C8]
mov [rsi+10h], rdx
mov [rsi+18h], rcx
mov [rsi+20h], r8
mov [rsi+28h], r9
test al, al
jz short loc_2C069
movaps [rsp+0E8h+var_98], xmm0
movaps [rsp+0E8h+var_88], xmm1
movaps [rsp+0E8h+var_78], xmm2
movaps [rsp+0E8h+var_68], xmm3
movaps [rsp+0E8h+var_58], xmm4
movaps [rsp+0E8h+var_48], xmm5
movaps [rsp+0E8h+var_38], xmm6
movaps [rsp+0E8h+var_28], xmm7
loc_2C069:
mov rbx, [rdi]
mov rcx, rsp
mov [rcx+10h], rsi
lea rax, [rsp+0E8h+arg_0]
mov [rcx+8], rax
mov rax, 3000000010h
mov [rcx], rax
push 3
pop rsi
xor r15d, r15d
mov rdi, rbx
mov rdx, r10
xor r8d, r8d
call JS_ThrowError2
mov rax, [r14+90h]
test rax, rax
jz short loc_2C0BD
xor r15d, r15d
cmp dword ptr [rax+80h], 0
setnz r15b
add r15d, r15d
loc_2C0BD:
mov rax, [rbx+18h]
mov r9, [r14+18h]
mov r10d, [r14+10h]
mov r11d, [r14+14h]
mov rsi, [rax+0F0h]
mov rdx, [rax+0F8h]
sub rsp, 8
push 3
pop r8
mov rdi, rbx
xor ecx, ecx
push r15
push r11
push r10
call build_backtrace
add rsp, 20h
push 0FFFFFFFFFFFFFFFFh
pop rax
add rsp, 0D0h
pop rbx
pop r14
pop r15
retn
| long long js_parse_error(
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,
char a15)
{
long long v15; // rbx
int v16; // r15d
long long v17; // rax
_QWORD v19[4]; // [rsp+0h] [rbp-E8h] BYREF
char v20; // [rsp+20h] [rbp-C8h] BYREF
long long v21; // [rsp+30h] [rbp-B8h]
long long v22; // [rsp+38h] [rbp-B0h]
long long v23; // [rsp+40h] [rbp-A8h]
long long v24; // [rsp+48h] [rbp-A0h]
__m128 v25; // [rsp+50h] [rbp-98h]
__m128 v26; // [rsp+60h] [rbp-88h]
__m128 v27; // [rsp+70h] [rbp-78h]
__m128 v28; // [rsp+80h] [rbp-68h]
__m128 v29; // [rsp+90h] [rbp-58h]
__m128 v30; // [rsp+A0h] [rbp-48h]
__m128 v31; // [rsp+B0h] [rbp-38h]
__m128 v32; // [rsp+C0h] [rbp-28h]
v25 = a7;
v26 = a8;
v27 = a9;
v28 = a10;
v29 = a11;
v30 = a12;
v31 = a13;
v32 = a14;
v21 = a3;
v22 = a4;
v23 = a5;
v24 = a6;
v15 = *a1;
v19[2] = &v20;
v19[1] = &a15;
v19[0] = 0x3000000010LL;
v16 = 0;
JS_ThrowError2(v15, 3LL, a2, v19, 0LL);
v17 = a1[18];
if ( v17 )
v16 = 2 * (*(_DWORD *)(v17 + 128) != 0);
build_backtrace(
v15,
*(_QWORD *)(*(_QWORD *)(v15 + 24) + 240LL),
*(_QWORD *)(*(_QWORD *)(v15 + 24) + 248LL),
0,
3,
a1[3],
*((_DWORD *)a1 + 4),
*((_DWORD *)a1 + 5),
v16);
return -1LL;
}
| js_parse_error:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0xd0
MOV R10,RSI
MOV R14,RDI
LEA RSI,[RSP + 0x20]
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 0x0012c069
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOVAPS xmmword ptr [RSP + 0x60],XMM1
MOVAPS xmmword ptr [RSP + 0x70],XMM2
MOVAPS xmmword ptr [RSP + 0x80],XMM3
MOVAPS xmmword ptr [RSP + 0x90],XMM4
MOVAPS xmmword ptr [RSP + 0xa0],XMM5
MOVAPS xmmword ptr [RSP + 0xb0],XMM6
MOVAPS xmmword ptr [RSP + 0xc0],XMM7
LAB_0012c069:
MOV RBX,qword ptr [RDI]
MOV RCX,RSP
MOV qword ptr [RCX + 0x10],RSI
LEA RAX,[RSP + 0xf0]
MOV qword ptr [RCX + 0x8],RAX
MOV RAX,0x3000000010
MOV qword ptr [RCX],RAX
PUSH 0x3
POP RSI
XOR R15D,R15D
MOV RDI,RBX
MOV RDX,R10
XOR R8D,R8D
CALL 0x0012c107
MOV RAX,qword ptr [R14 + 0x90]
TEST RAX,RAX
JZ 0x0012c0bd
XOR R15D,R15D
CMP dword ptr [RAX + 0x80],0x0
SETNZ R15B
ADD R15D,R15D
LAB_0012c0bd:
MOV RAX,qword ptr [RBX + 0x18]
MOV R9,qword ptr [R14 + 0x18]
MOV R10D,dword ptr [R14 + 0x10]
MOV R11D,dword ptr [R14 + 0x14]
MOV RSI,qword ptr [RAX + 0xf0]
MOV RDX,qword ptr [RAX + 0xf8]
SUB RSP,0x8
PUSH 0x3
POP R8
MOV RDI,RBX
XOR ECX,ECX
PUSH R15
PUSH R11
PUSH R10
CALL 0x0012c162
ADD RSP,0x20
PUSH -0x1
POP RAX
ADD RSP,0xd0
POP RBX
POP R14
POP R15
RET
|
int8
js_parse_error(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
long *param_9,int8 param_10,int8 param_11,int8 param_12,
int8 param_13,int8 param_14)
{
long lVar1;
char in_AL;
char cVar2;
int8 local_e8;
int1 *local_e0;
int1 *local_d8;
int1 local_c8 [16];
int8 local_b8;
int8 local_b0;
int8 local_a8;
int8 local_a0;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
int8 local_58;
int8 local_48;
int8 local_38;
int8 local_28;
local_d8 = local_c8;
if (in_AL != '\0') {
local_98 = param_1;
local_88 = param_2;
local_78 = param_3;
local_68 = param_4;
local_58 = param_5;
local_48 = param_6;
local_38 = param_7;
local_28 = param_8;
}
lVar1 = *param_9;
local_e0 = &stack0x00000008;
local_e8 = 0x3000000010;
cVar2 = '\0';
local_b8 = param_11;
local_b0 = param_12;
local_a8 = param_13;
local_a0 = param_14;
JS_ThrowError2(lVar1,3,param_10,&local_e8,0);
if (param_9[0x12] != 0) {
cVar2 = (*(int *)(param_9[0x12] + 0x80) != 0) * '\x02';
}
build_backtrace(lVar1,*(int8 *)(*(long *)(lVar1 + 0x18) + 0xf0),
*(int8 *)(*(long *)(lVar1 + 0x18) + 0xf8),0,3,param_9[3],(int)param_9[2],
*(int4 *)((long)param_9 + 0x14),cVar2);
return 0xffffffffffffffff;
}
| |
52,926 | minja::LoopControlException::LoopControlException(minja::LoopControlType) | monkey531[P]llama/common/minja.hpp | LoopControlException(LoopControlType control_type)
: std::runtime_error((control_type == LoopControlType::Continue ? "continue" : "break") + std::string(" outside of a loop")),
control_type(control_type) {} | O2 | cpp | minja::LoopControlException::LoopControlException(minja::LoopControlType):
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x3d17d(%rip), %rsi # 0xb4f86
leaq 0x30(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0x2724a
cmpl $0x1, %ebx
leaq 0x3be2a(%rip), %rax # 0xb3c4f
leaq 0x3be1d(%rip), %rsi # 0xb3c49
cmoveq %rax, %rsi
leaq 0x10(%rsp), %rdi
movq %r15, %rdx
callq 0x2730b
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x23b30
leaq 0x10(%rsp), %rdi
callq 0x24218
leaq 0x30(%rsp), %rdi
callq 0x24218
leaq 0x851b3(%rip), %rax # 0xfd018
addq $0x10, %rax
movq %rax, (%r14)
movl %ebx, 0x10(%r14)
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x24218
jmp 0x77e8c
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x24218
movq %rbx, %rdi
callq 0x23fd0
| _ZN5minja20LoopControlExceptionC2ENS_15LoopControlTypeE:
push r15
push r14
push rbx
sub rsp, 50h
mov ebx, esi
mov r14, rdi
lea rsi, aOutsideOfALoop; " outside of a loop"
lea r15, [rsp+68h+var_38]
lea rdx, [rsp+68h+var_59]
mov rdi, r15
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
cmp ebx, 1
lea rax, aContinue; "continue"
lea rsi, aBreak; "break"
cmovz rsi, rax
lea rdi, [rsp+68h+var_58]
mov rdx, r15
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
lea rsi, [rsp+68h+var_58]
mov rdi, r14
call __ZNSt13runtime_errorC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
lea rdi, [rsp+68h+var_58]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+68h+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rax, _ZTVN5minja20LoopControlExceptionE; `vtable for'minja::LoopControlException
add rax, 10h
mov [r14], rax
mov [r14+10h], ebx
add rsp, 50h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
lea rdi, [rsp+arg_8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_77E8C
mov rbx, rax
loc_77E8C:
lea rdi, [rsp+arg_28]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbx
call __Unwind_Resume
| long long * minja::LoopControlException::LoopControlException(long long a1, int a2)
{
const char *v3; // rsi
long long *result; // rax
_BYTE v5[32]; // [rsp+10h] [rbp-58h] BYREF
_QWORD v6[7]; // [rsp+30h] [rbp-38h] BYREF
std::string::basic_string<std::allocator<char>>(v6, (long long)" outside of a loop");
v3 = "break";
if ( a2 == 1 )
v3 = "continue";
std::operator+<char>((long long)v5, (long long)v3, (long long)v6);
std::runtime_error::runtime_error(a1);
std::string::~string(v5);
std::string::~string(v6);
result = &`vtable for'minja::LoopControlException + 2;
*(_QWORD *)a1 = &`vtable for'minja::LoopControlException + 2;
*(_DWORD *)(a1 + 16) = a2;
return result;
}
| LoopControlException:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x50
MOV EBX,ESI
MOV R14,RDI
LEA RSI,[0x1b4f86]
LEA R15,[RSP + 0x30]
LEA RDX,[RSP + 0xf]
MOV RDI,R15
CALL 0x0012724a
CMP EBX,0x1
LEA RAX,[0x1b3c4f]
LEA RSI,[0x1b3c49]
CMOVZ RSI,RAX
LAB_00177e30:
LEA RDI,[RSP + 0x10]
MOV RDX,R15
CALL 0x0012730b
LAB_00177e3d:
LEA RSI,[RSP + 0x10]
MOV RDI,R14
CALL 0x00123b30
LAB_00177e4a:
LEA RDI,[RSP + 0x10]
CALL 0x00124218
LEA RDI,[RSP + 0x30]
CALL 0x00124218
LEA RAX,[0x1fd018]
ADD RAX,0x10
MOV qword ptr [R14],RAX
MOV dword ptr [R14 + 0x10],EBX
ADD RSP,0x50
POP RBX
POP R14
POP R15
RET
|
/* minja::LoopControlException::LoopControlException(minja::LoopControlType) */
void __thiscall
minja::LoopControlException::LoopControlException(LoopControlException *this,int param_2)
{
char *pcVar1;
allocator local_59;
string local_58 [32];
string local_38 [32];
std::__cxx11::string::string<std::allocator<char>>(local_38," outside of a loop",&local_59);
pcVar1 = "break";
if (param_2 == 1) {
pcVar1 = "continue";
}
/* try { // try from 00177e30 to 00177e3c has its CatchHandler @ 00177e89 */
std::operator+((char *)local_58,(string *)pcVar1);
/* try { // try from 00177e3d to 00177e49 has its CatchHandler @ 00177e7a */
std::runtime_error::runtime_error((runtime_error *)this,local_58);
std::__cxx11::string::~string(local_58);
std::__cxx11::string::~string(local_38);
*(int ***)this = &PTR__runtime_error_001fd028;
*(int *)(this + 0x10) = param_2;
return;
}
| |
52,927 | minja::LoopControlException::LoopControlException(minja::LoopControlType) | monkey531[P]llama/common/minja.hpp | LoopControlException(LoopControlType control_type)
: std::runtime_error((control_type == LoopControlType::Continue ? "continue" : "break") + std::string(" outside of a loop")),
control_type(control_type) {} | O3 | cpp | minja::LoopControlException::LoopControlException(minja::LoopControlType):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x4ff23(%rip), %rsi # 0xf0f96
leaq 0x4ff2e(%rip), %rdx # 0xf0fa8
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x222de
xorl %eax, %eax
cmpl $0x1, %ebx
sete %al
leaq 0x4ebc9(%rip), %rdx # 0xefc5f
leaq 0x4ebbc(%rip), %rcx # 0xefc59
cmoveq %rdx, %rcx
leaq (%rax,%rax,2), %r8
addq $0x5, %r8
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1aa00
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xa10dc
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0xa10e3
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %r14, %rdi
callq 0x1ab00
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xa111e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a900
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xa1135
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1a900
leaq 0x89edc(%rip), %rax # 0x12b018
addq $0x10, %rax
movq %rax, (%r14)
movl %ebx, 0x10(%r14)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xa1172
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a900
jmp 0xa1172
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xa1189
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1a900
movq %rbx, %rdi
callq 0x1afd0
nop
| _ZN5minja20LoopControlExceptionC2ENS_15LoopControlTypeE:
push r15
push r14
push r12
push rbx
sub rsp, 48h
mov ebx, esi
mov r14, rdi
lea r12, [rsp+68h+var_30]
mov [r12-10h], r12
lea rsi, aOutsideOfALoop; " outside of a loop"
lea rdx, aOutsideOfALoop+12h; ""
lea r15, [rsp+68h+var_40]
mov rdi, r15
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)
xor eax, eax
cmp ebx, 1
setz al
lea rdx, aContinue; "continue"
lea rcx, aBreak; "break"
cmovz rcx, rdx
lea r8, [rax+rax*2]
add r8, 5
mov rdi, r15
xor esi, esi
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7replaceEmmPKcm; std::string::replace(ulong,ulong,char const*,ulong)
lea r15, [rsp+68h+var_50]
mov [r15-10h], r15
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_A10DC
mov [rsp+68h+var_60], rdx
mov rdx, [rcx]
mov [rsp+68h+var_50], rdx
jmp short loc_A10E3
loc_A10DC:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r15], xmm0
loc_A10E3:
mov rdx, [rax+8]
lea rsi, [rsp+68h+var_60]
mov [rsi+8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
mov rdi, r14
call __ZNSt13runtime_errorC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
mov rdi, [rsp+68h+var_60]; void *
cmp rdi, r15
jz short loc_A111E
mov rsi, [rsp+68h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A111E:
mov rdi, [rsp+68h+var_40]; void *
cmp rdi, r12
jz short loc_A1135
mov rsi, [rsp+68h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A1135:
lea rax, _ZTVN5minja20LoopControlExceptionE; `vtable for'minja::LoopControlException
add rax, 10h
mov [r14], rax
mov [r14+10h], ebx
add rsp, 48h
pop rbx
pop r12
pop r14
pop r15
retn
mov rbx, rax
mov rdi, [rsp+arg_0]; void *
cmp rdi, r15
jz short loc_A1172
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_A1172
mov rbx, rax
loc_A1172:
mov rdi, [rsp+arg_20]; void *
cmp rdi, r12
jz short loc_A1189
mov rsi, [rsp+arg_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A1189:
mov rdi, rbx
call __Unwind_Resume
| long long * minja::LoopControlException::LoopControlException(long long a1, int a2)
{
const char *v2; // rcx
long long v3; // rax
__int128 *v4; // rcx
long long *result; // rax
void *v6[2]; // [rsp+8h] [rbp-60h] BYREF
__int128 v7; // [rsp+18h] [rbp-50h] BYREF
void *v8[2]; // [rsp+28h] [rbp-40h] BYREF
_QWORD v9[6]; // [rsp+38h] [rbp-30h] BYREF
v8[0] = v9;
std::string::_M_construct<char const*>((long long)v8, " outside of a loop", (long long)"");
v2 = "break";
if ( a2 == 1 )
v2 = "continue";
v3 = std::string::replace(v8, 0LL, 0LL, v2, 3LL * (a2 == 1) + 5);
v6[0] = &v7;
v4 = (__int128 *)(v3 + 16);
if ( *(_QWORD *)v3 == v3 + 16 )
{
v7 = *v4;
}
else
{
v6[0] = *(void **)v3;
*(_QWORD *)&v7 = *(_QWORD *)v4;
}
v6[1] = *(void **)(v3 + 8);
*(_QWORD *)v3 = v4;
*(_QWORD *)(v3 + 8) = 0LL;
*(_BYTE *)(v3 + 16) = 0;
std::runtime_error::runtime_error(a1, v6);
if ( v6[0] != &v7 )
operator delete(v6[0], v7 + 1);
if ( v8[0] != v9 )
operator delete(v8[0], v9[0] + 1LL);
result = &`vtable for'minja::LoopControlException + 2;
*(_QWORD *)a1 = &`vtable for'minja::LoopControlException + 2;
*(_DWORD *)(a1 + 16) = a2;
return result;
}
| LoopControlException:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV EBX,ESI
MOV R14,RDI
LEA R12,[RSP + 0x38]
MOV qword ptr [R12 + -0x10],R12
LEA RSI,[0x1f0f96]
LEA RDX,[0x1f0fa8]
LEA R15,[RSP + 0x28]
MOV RDI,R15
CALL 0x001222de
XOR EAX,EAX
CMP EBX,0x1
SETZ AL
LEA RDX,[0x1efc5f]
LEA RCX,[0x1efc59]
CMOVZ RCX,RDX
LEA R8,[RAX + RAX*0x2]
ADD R8,0x5
LAB_001a10a9:
MOV RDI,R15
XOR ESI,ESI
XOR EDX,EDX
CALL 0x0011aa00
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x10],R15
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x001a10dc
MOV qword ptr [RSP + 0x8],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x18],RDX
JMP 0x001a10e3
LAB_001a10dc:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [R15],XMM0
LAB_001a10e3:
MOV RDX,qword ptr [RAX + 0x8]
LEA RSI,[RSP + 0x8]
MOV qword ptr [RSI + 0x8],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
LAB_001a10ff:
MOV RDI,R14
CALL 0x0011ab00
LAB_001a1107:
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R15
JZ 0x001a111e
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011a900
LAB_001a111e:
MOV RDI,qword ptr [RSP + 0x28]
CMP RDI,R12
JZ 0x001a1135
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x0011a900
LAB_001a1135:
LEA RAX,[0x22b018]
ADD RAX,0x10
MOV qword ptr [R14],RAX
MOV dword ptr [R14 + 0x10],EBX
ADD RSP,0x48
POP RBX
POP R12
POP R14
POP R15
RET
|
/* minja::LoopControlException::LoopControlException(minja::LoopControlType) */
void __thiscall
minja::LoopControlException::LoopControlException(LoopControlException *this,int param_2)
{
long *plVar1;
char *pcVar2;
long *plVar3;
long *local_60;
long local_58;
long local_50;
long lStack_48;
long *local_40 [2];
long local_30 [2];
local_40[0] = local_30;
std::__cxx11::string::_M_construct<char_const*>(local_40," outside of a loop","");
pcVar2 = "break";
if (param_2 == 1) {
pcVar2 = "continue";
}
/* try { // try from 001a10a9 to 001a10b4 has its CatchHandler @ 001a116f */
plVar1 = (long *)std::__cxx11::string::replace((ulong)local_40,0,(char *)0x0,(ulong)pcVar2);
plVar3 = plVar1 + 2;
if ((long *)*plVar1 == plVar3) {
local_50 = *plVar3;
lStack_48 = plVar1[3];
local_60 = &local_50;
}
else {
local_50 = *plVar3;
local_60 = (long *)*plVar1;
}
local_58 = plVar1[1];
*plVar1 = (long)plVar3;
plVar1[1] = 0;
*(int1 *)(plVar1 + 2) = 0;
/* try { // try from 001a10ff to 001a1106 has its CatchHandler @ 001a1153 */
std::runtime_error::runtime_error((runtime_error *)this,(string *)&local_60);
if (local_60 != &local_50) {
operator_delete(local_60,local_50 + 1);
}
if (local_40[0] != local_30) {
operator_delete(local_40[0],local_30[0] + 1);
}
*(int ***)this = &PTR__runtime_error_0022b028;
*(int *)(this + 0x10) = param_2;
return;
}
| |
52,928 | inline_mysql_file_close | eloqsql/include/mysql/psi/mysql_file.h | static inline int
inline_mysql_file_close(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
File file, myf flags)
{
int result;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_descriptor_locker)(&state, file, PSI_FILE_CLOSE);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_close_wait)(locker, src_file, src_line);
result= my_close(file, flags);
PSI_FILE_CALL(end_file_close_wait)(locker, result);
return result;
}
#endif
result= my_close(file, flags);
return result;
} | O0 | c | inline_mysql_file_close:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq 0x1c1a38(%rip), %rax # 0x232838
movq (%rax), %rax
movq 0x158(%rax), %rax
movl -0x18(%rbp), %esi
leaq -0x78(%rbp), %rdi
movl $0x4, %edx
callq *%rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x70e8b
leaq 0x1c19f5(%rip), %rax # 0x232838
movq (%rax), %rax
movq 0x220(%rax), %rax
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq *%rax
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0x7d5b0
movl %eax, -0x24(%rbp)
leaq 0x1c19c8(%rip), %rax # 0x232838
movq (%rax), %rax
movq 0x228(%rax), %rax
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
callq *%rax
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x70ea0
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0x7d5b0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
| inline_mysql_file_close:
push rbp
mov rbp, rsp
sub rsp, 80h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov [rbp+var_20], rcx
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+158h]
mov esi, [rbp+var_18]
lea rdi, [rbp+var_78]
mov edx, 4
call rax
mov [rbp+var_30], rax
cmp [rbp+var_30], 0
setnz al
and al, 1
movzx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_70E8B
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+220h]
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_10]
mov edx, [rbp+var_14]
call rax
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
call my_close
mov [rbp+var_24], eax
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+228h]
mov rdi, [rbp+var_30]
mov esi, [rbp+var_24]
call rax
mov eax, [rbp+var_24]
mov [rbp+var_4], eax
jmp short loc_70EA0
loc_70E8B:
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
call my_close
mov [rbp+var_24], eax
mov eax, [rbp+var_24]
mov [rbp+var_4], eax
loc_70EA0:
mov eax, [rbp+var_4]
add rsp, 80h
pop rbp
retn
| long long inline_mysql_file_close(long long a1, unsigned int a2, unsigned int a3, long long a4)
{
_BYTE v5[72]; // [rsp+8h] [rbp-78h] BYREF
long long v6; // [rsp+50h] [rbp-30h]
unsigned int v7; // [rsp+5Ch] [rbp-24h]
long long v8; // [rsp+60h] [rbp-20h]
unsigned int v9; // [rsp+68h] [rbp-18h]
unsigned int v10; // [rsp+6Ch] [rbp-14h]
long long v11; // [rsp+70h] [rbp-10h]
v11 = a1;
v10 = a2;
v9 = a3;
v8 = a4;
v6 = (*((long long ( **)(_BYTE *, _QWORD, long long))PSI_server + 43))(v5, a3, 4LL);
if ( v6 )
{
(*((void ( **)(long long, long long, _QWORD))PSI_server + 68))(v6, v11, v10);
v7 = my_close(v9, v8);
(*((void ( **)(long long, _QWORD))PSI_server + 69))(v6, v7);
}
else
{
return (unsigned int)my_close(v9, v8);
}
return v7;
}
| inline_mysql_file_close:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV qword ptr [RBP + -0x20],RCX
LEA RAX,[0x332838]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x158]
MOV ESI,dword ptr [RBP + -0x18]
LEA RDI,[RBP + -0x78]
MOV EDX,0x4
CALL RAX
MOV qword ptr [RBP + -0x30],RAX
CMP qword ptr [RBP + -0x30],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x00170e8b
LEA RAX,[0x332838]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x220]
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x14]
CALL RAX
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x0017d5b0
MOV dword ptr [RBP + -0x24],EAX
LEA RAX,[0x332838]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x228]
MOV RDI,qword ptr [RBP + -0x30]
MOV ESI,dword ptr [RBP + -0x24]
CALL RAX
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00170ea0
LAB_00170e8b:
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x0017d5b0
MOV dword ptr [RBP + -0x24],EAX
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x4],EAX
LAB_00170ea0:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x80
POP RBP
RET
|
int4
inline_mysql_file_close(int8 param_1,int4 param_2,int4 param_3,int8 param_4)
{
int1 local_80 [72];
long local_38;
int4 local_2c;
int8 local_28;
int4 local_20;
int4 local_1c;
int8 local_18;
int4 local_c;
local_28 = param_4;
local_20 = param_3;
local_1c = param_2;
local_18 = param_1;
local_38 = (**(code **)(PSI_server + 0x158))(local_80,param_3,4);
if (local_38 == 0) {
local_c = my_close(local_20,local_28);
}
else {
(**(code **)(PSI_server + 0x220))(local_38,local_18,local_1c);
local_2c = my_close(local_20,local_28);
(**(code **)(PSI_server + 0x228))(local_38,local_2c);
local_c = local_2c;
}
return local_c;
}
| |
52,929 | glfwPlatformWindowMaximized | untodesu[P]riteg/build_O0/_deps/glfw-src/src/x11_window.c | int _glfwPlatformWindowMaximized(_GLFWwindow* window)
{
Atom* states;
unsigned long i;
GLFWbool maximized = GLFW_FALSE;
if (!_glfw.x11.NET_WM_STATE ||
!_glfw.x11.NET_WM_STATE_MAXIMIZED_VERT ||
!_glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ)
{
return maximized;
}
const unsigned long count =
_glfwGetWindowPropertyX11(window->x11.handle,
_glfw.x11.NET_WM_STATE,
XA_ATOM,
(unsigned char**) &states);
for (i = 0; i < count; i++)
{
if (states[i] == _glfw.x11.NET_WM_STATE_MAXIMIZED_VERT ||
states[i] == _glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ)
{
maximized = GLFW_TRUE;
break;
}
}
if (states)
XFree(states);
return maximized;
} | O0 | c | glfwPlatformWindowMaximized:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x24(%rbp)
leaq 0xae22e(%rip), %rax # 0xe0c68
cmpq $0x0, 0x20440(%rax)
je 0x32a66
leaq 0xae21d(%rip), %rax # 0xe0c68
cmpq $0x0, 0x20458(%rax)
je 0x32a66
leaq 0xae20c(%rip), %rax # 0xe0c68
cmpq $0x0, 0x20460(%rax)
jne 0x32a71
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x32b15
movq -0x10(%rbp), %rax
movq 0x348(%rax), %rdi
leaq 0xae1e5(%rip), %rax # 0xe0c68
movq 0x20440(%rax), %rsi
movl $0x4, %edx
leaq -0x18(%rbp), %rcx
callq 0x2ff50
movq %rax, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x32aff
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
leaq 0xae1a7(%rip), %rcx # 0xe0c68
cmpq 0x20458(%rcx), %rax
je 0x32ae6
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
leaq 0xae18b(%rip), %rcx # 0xe0c68
cmpq 0x20460(%rcx), %rax
jne 0x32aef
movl $0x1, -0x24(%rbp)
jmp 0x32aff
jmp 0x32af1
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x32aa4
cmpq $0x0, -0x18(%rbp)
je 0x32b0f
movq -0x18(%rbp), %rdi
callq 0xcb90
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
| _glfwPlatformWindowMaximized:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_24], 0
lea rax, _glfw
cmp qword ptr ds:_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEmcRKS3_[rax], 0; std::string::basic_string<std::allocator<char>>(ulong,char,std::allocator<char> const&)
jz short loc_32A66
lea rax, _glfw
cmp qword ptr [rax+20458h], 0
jz short loc_32A66
lea rax, _glfw
cmp qword ptr [rax+20460h], 0
jnz short loc_32A71
loc_32A66:
mov eax, [rbp+var_24]
mov [rbp+var_4], eax
jmp loc_32B15
loc_32A71:
mov rax, [rbp+var_10]
mov rdi, [rax+348h]
lea rax, _glfw
mov rsi, qword ptr ds:_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEmcRKS3_[rax]; std::string::basic_string<std::allocator<char>>(ulong,char,std::allocator<char> const&)
mov edx, 4
lea rcx, [rbp+var_18]
call _glfwGetWindowPropertyX11
mov [rbp+var_30], rax
mov [rbp+var_20], 0
loc_32AA4:
mov rax, [rbp+var_20]
cmp rax, [rbp+var_30]
jnb short loc_32AFF
mov rax, [rbp+var_18]
mov rcx, [rbp+var_20]
mov rax, [rax+rcx*8]
lea rcx, _glfw
cmp rax, [rcx+20458h]
jz short loc_32AE6
mov rax, [rbp+var_18]
mov rcx, [rbp+var_20]
mov rax, [rax+rcx*8]
lea rcx, _glfw
cmp rax, [rcx+20460h]
jnz short loc_32AEF
loc_32AE6:
mov [rbp+var_24], 1
jmp short loc_32AFF
loc_32AEF:
jmp short $+2
loc_32AF1:
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_20], rax
jmp short loc_32AA4
loc_32AFF:
cmp [rbp+var_18], 0
jz short loc_32B0F
mov rdi, [rbp+var_18]
call _XFree
loc_32B0F:
mov eax, [rbp+var_24]
mov [rbp+var_4], eax
loc_32B15:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long glfwPlatformWindowMaximized(long long a1)
{
unsigned long long WindowPropertyX11; // [rsp+0h] [rbp-30h]
unsigned int v3; // [rsp+Ch] [rbp-24h]
unsigned long long i; // [rsp+10h] [rbp-20h]
long long v5; // [rsp+18h] [rbp-18h] BYREF
long long v6; // [rsp+20h] [rbp-10h]
v6 = a1;
v3 = 0;
if ( *(_QWORD *)((char *)std::string::basic_string<std::allocator<char>> + (_QWORD)glfw)
&& *(_QWORD *)&glfw[33046]
&& *(_QWORD *)&glfw[33048] )
{
WindowPropertyX11 = glfwGetWindowPropertyX11(
*(_QWORD *)(v6 + 840),
*(_QWORD *)((char *)std::string::basic_string<std::allocator<char>> + (_QWORD)glfw),
4LL,
(long long)&v5);
for ( i = 0LL; i < WindowPropertyX11; ++i )
{
if ( *(_QWORD *)(v5 + 8 * i) == *(_QWORD *)&glfw[33046] || *(_QWORD *)(v5 + 8 * i) == *(_QWORD *)&glfw[33048] )
{
v3 = 1;
break;
}
}
if ( v5 )
XFree(v5);
return v3;
}
else
{
return 0;
}
}
| _glfwPlatformWindowMaximized:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x24],0x0
LEA RAX,[0x1e0c68]
CMP qword ptr [RAX + 0x20440],0x0
JZ 0x00132a66
LEA RAX,[0x1e0c68]
CMP qword ptr [RAX + 0x20458],0x0
JZ 0x00132a66
LEA RAX,[0x1e0c68]
CMP qword ptr [RAX + 0x20460],0x0
JNZ 0x00132a71
LAB_00132a66:
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00132b15
LAB_00132a71:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x348]
LEA RAX,[0x1e0c68]
MOV RSI,qword ptr [RAX + 0x20440]
MOV EDX,0x4
LEA RCX,[RBP + -0x18]
CALL 0x0012ff50
MOV qword ptr [RBP + -0x30],RAX
MOV qword ptr [RBP + -0x20],0x0
LAB_00132aa4:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x30]
JNC 0x00132aff
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + RCX*0x8]
LEA RCX,[0x1e0c68]
CMP RAX,qword ptr [RCX + 0x20458]
JZ 0x00132ae6
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + RCX*0x8]
LEA RCX,[0x1e0c68]
CMP RAX,qword ptr [RCX + 0x20460]
JNZ 0x00132aef
LAB_00132ae6:
MOV dword ptr [RBP + -0x24],0x1
JMP 0x00132aff
LAB_00132aef:
JMP 0x00132af1
LAB_00132af1:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
JMP 0x00132aa4
LAB_00132aff:
CMP qword ptr [RBP + -0x18],0x0
JZ 0x00132b0f
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x0010cb90
LAB_00132b0f:
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x4],EAX
LAB_00132b15:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 _glfwPlatformWindowMaximized(long param_1)
{
ulong uVar1;
int4 local_2c;
ulong local_28;
long local_20;
long local_18;
int4 local_c;
local_2c = 0;
if (((DAT_002010a8 == 0) || (DAT_002010c0 == 0)) || (DAT_002010c8 == 0)) {
local_c = 0;
}
else {
local_18 = param_1;
uVar1 = _glfwGetWindowPropertyX11(*(int8 *)(param_1 + 0x348),DAT_002010a8,4,&local_20);
for (local_28 = 0; local_28 < uVar1; local_28 = local_28 + 1) {
if ((*(long *)(local_20 + local_28 * 8) == DAT_002010c0) ||
(*(long *)(local_20 + local_28 * 8) == DAT_002010c8)) {
local_2c = 1;
break;
}
}
if (local_20 != 0) {
XFree(local_20);
}
local_c = local_2c;
}
return local_c;
}
| |
52,930 | apply_shift | eloqsql/strings/ctype-uca.c | static my_bool
apply_shift(MY_CHARSET_LOADER *loader,
MY_COLL_RULES *rules, MY_COLL_RULE *r, int level,
uint16 *to, size_t nweights)
{
/* Apply level difference. */
if (nweights)
{
to[nweights - 1]+= r->diff[level];
if (r->before_level == 1) /* Apply "&[before primary]" */
{
if (nweights >= 2)
{
to[nweights - 2]--; /* Reset before */
if (rules->shift_after_method == my_shift_method_expand)
{
/*
Special case. Don't let characters shifted after X
and before next(X) intermix to each other.
For example:
"[shift-after-method expand] &0 < a &[before primary]1 < A".
I.e. we reorder 'a' after '0', and then 'A' before '1'.
'a' must be sorted before 'A'.
Note, there are no real collations in CLDR which shift
after and before two neighbourgh characters. We need this
just in case. Reserving 4096 (0x1000) weights for such
cases is perfectly enough.
*/
to[nweights - 1]+= 0x1000; /* W3-TODO: const may vary on levels 2,3*/
}
}
else
{
my_snprintf(loader->error, sizeof(loader->error),
"Can't reset before "
"a primary ignorable character U+%04lX", r->base[0]);
return TRUE;
}
}
}
else
{
/* Shift to an ignorable character, e.g.: & \u0000 < \u0001 */
DBUG_ASSERT(to[0] == 0);
to[0]= r->diff[level];
}
return FALSE;
} | O0 | c | apply_shift:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0xaf0da
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl 0x80(%rax,%rcx,4), %esi
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
subq $0x1, %rcx
movzwl (%rax,%rcx,2), %edx
addl %esi, %edx
movw %dx, (%rax,%rcx,2)
movq -0x20(%rbp), %rax
cmpq $0x1, 0x90(%rax)
jne 0xaf0d8
cmpq $0x2, -0x38(%rbp)
jb 0xaf0b2
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
subq $0x2, %rcx
movw (%rax,%rcx,2), %dx
addw $-0x1, %dx
movw %dx, (%rax,%rcx,2)
movq -0x18(%rbp), %rax
cmpl $0x1, 0x30(%rax)
jne 0xaf0b0
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
subq $0x1, %rcx
movzwl (%rax,%rcx,2), %edx
addl $0x1000, %edx # imm = 0x1000
movw %dx, (%rax,%rcx,2)
jmp 0xaf0d6
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movl $0x80, %esi
leaq 0x2d54f(%rip), %rdx # 0xdc618
movb $0x0, %al
callq 0xd4c60
movb $0x1, -0x1(%rbp)
jmp 0xaf0fb
jmp 0xaf0d8
jmp 0xaf0f7
jmp 0xaf0dc
jmp 0xaf0de
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl 0x80(%rax,%rcx,4), %eax
movw %ax, %cx
movq -0x30(%rbp), %rax
movw %cx, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| apply_shift:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_24], ecx
mov [rbp+var_30], r8
mov [rbp+var_38], r9
cmp [rbp+var_38], 0
jz loc_AF0DA
mov rax, [rbp+var_20]
movsxd rcx, [rbp+var_24]
mov esi, [rax+rcx*4+80h]
mov rax, [rbp+var_30]
mov rcx, [rbp+var_38]
sub rcx, 1
movzx edx, word ptr [rax+rcx*2]
add edx, esi
mov [rax+rcx*2], dx
mov rax, [rbp+var_20]
cmp qword ptr [rax+90h], 1
jnz short loc_AF0D8
cmp [rbp+var_38], 2
jb short loc_AF0B2
mov rax, [rbp+var_30]
mov rcx, [rbp+var_38]
sub rcx, 2
mov dx, [rax+rcx*2]
add dx, 0FFFFh
mov [rax+rcx*2], dx
mov rax, [rbp+var_18]
cmp dword ptr [rax+30h], 1
jnz short loc_AF0B0
mov rax, [rbp+var_30]
mov rcx, [rbp+var_38]
sub rcx, 1
movzx edx, word ptr [rax+rcx*2]
add edx, 1000h
mov [rax+rcx*2], dx
loc_AF0B0:
jmp short loc_AF0D6
loc_AF0B2:
mov rdi, [rbp+var_10]
mov rax, [rbp+var_20]
mov rcx, [rax]
mov esi, 80h
lea rdx, aCanTResetBefor; "Can't reset before a primary ignorable "...
mov al, 0
call my_snprintf
mov [rbp+var_1], 1
jmp short loc_AF0FB
loc_AF0D6:
jmp short $+2
loc_AF0D8:
jmp short loc_AF0F7
loc_AF0DA:
jmp short $+2
loc_AF0DC:
jmp short $+2
loc_AF0DE:
mov rax, [rbp+var_20]
movsxd rcx, [rbp+var_24]
mov eax, [rax+rcx*4+80h]
mov cx, ax
mov rax, [rbp+var_30]
mov [rax], cx
loc_AF0F7:
mov [rbp+var_1], 0
loc_AF0FB:
mov al, [rbp+var_1]
add rsp, 40h
pop rbp
retn
| char apply_shift(int a1, long long a2, _QWORD *a3, int a4, _WORD *a5, unsigned long long a6)
{
if ( !a6 )
{
*a5 = *((_DWORD *)a3 + a4 + 32);
return 0;
}
a5[a6 - 1] += *((_DWORD *)a3 + a4 + 32);
if ( a3[18] != 1LL )
return 0;
if ( a6 >= 2 )
{
--a5[a6 - 2];
if ( *(_DWORD *)(a2 + 48) == 1 )
a5[a6 - 1] += 4096;
return 0;
}
my_snprintf(a1, 128, (unsigned int)"Can't reset before a primary ignorable character U+%04lX", *a3, (_DWORD)a5, a6);
return 1;
}
| apply_shift:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV dword ptr [RBP + -0x24],ECX
MOV qword ptr [RBP + -0x30],R8
MOV qword ptr [RBP + -0x38],R9
CMP qword ptr [RBP + -0x38],0x0
JZ 0x001af0da
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RCX,dword ptr [RBP + -0x24]
MOV ESI,dword ptr [RAX + RCX*0x4 + 0x80]
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x38]
SUB RCX,0x1
MOVZX EDX,word ptr [RAX + RCX*0x2]
ADD EDX,ESI
MOV word ptr [RAX + RCX*0x2],DX
MOV RAX,qword ptr [RBP + -0x20]
CMP qword ptr [RAX + 0x90],0x1
JNZ 0x001af0d8
CMP qword ptr [RBP + -0x38],0x2
JC 0x001af0b2
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x38]
SUB RCX,0x2
MOV DX,word ptr [RAX + RCX*0x2]
ADD DX,-0x1
MOV word ptr [RAX + RCX*0x2],DX
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX + 0x30],0x1
JNZ 0x001af0b0
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x38]
SUB RCX,0x1
MOVZX EDX,word ptr [RAX + RCX*0x2]
ADD EDX,0x1000
MOV word ptr [RAX + RCX*0x2],DX
LAB_001af0b0:
JMP 0x001af0d6
LAB_001af0b2:
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX]
MOV ESI,0x80
LEA RDX,[0x1dc618]
MOV AL,0x0
CALL 0x001d4c60
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001af0fb
LAB_001af0d6:
JMP 0x001af0d8
LAB_001af0d8:
JMP 0x001af0f7
LAB_001af0da:
JMP 0x001af0dc
LAB_001af0dc:
JMP 0x001af0de
LAB_001af0de:
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RCX,dword ptr [RBP + -0x24]
MOV EAX,dword ptr [RAX + RCX*0x4 + 0x80]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x30]
MOV word ptr [RAX],CX
LAB_001af0f7:
MOV byte ptr [RBP + -0x1],0x0
LAB_001af0fb:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x40
POP RBP
RET
|
int1
apply_shift(int8 param_1,long param_2,int8 *param_3,int param_4,int2 *param_5,
ulong param_6)
{
if (param_6 == 0) {
*param_5 = (short)*(int4 *)((long)param_3 + (long)param_4 * 4 + 0x80);
}
else {
param_5[param_6 - 1] =
param_5[param_6 - 1] + (short)*(int4 *)((long)param_3 + (long)param_4 * 4 + 0x80);
if (param_3[0x12] == 1) {
if (param_6 < 2) {
my_snprintf(param_1,0x80,"Can\'t reset before a primary ignorable character U+%04lX",
*param_3);
return 1;
}
param_5[param_6 - 2] = param_5[param_6 - 2] + -1;
if (*(int *)(param_2 + 0x30) == 1) {
param_5[param_6 - 1] = param_5[param_6 - 1] + 0x1000;
}
}
}
return 0;
}
| |
52,931 | ftxui::InputOption::Default() | Andrewchistyakov[P]flashcards_lyc/build_O0/_deps/ftxui-src/src/ftxui/component/component_options.cpp | InputOption InputOption::Default() {
InputOption option;
option.transform = [](InputState state) {
state.element |= color(Color::White);
if (state.is_placeholder) {
state.element |= dim;
}
if (state.focused) {
state.element |= inverted;
} else if (state.hovered) {
state.element |= bgcolor(Color::GrayDark);
}
return state.element;
};
return option;
} | O0 | cpp | ftxui::InputOption::Default():
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
callq 0x7acf0
movq -0x18(%rbp), %rdi
addq $0x50, %rdi
leaq -0xa(%rbp), %rsi
callq 0x75940
movb $0x1, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x75934
movq -0x18(%rbp), %rdi
callq 0x20010
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
| _ZN5ftxui11InputOption7DefaultEv:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov rax, rdi
mov [rbp+var_20], rax
mov [rbp+var_8], rdi
mov [rbp+var_9], 0
call _ZN5ftxui11InputOptionC2Ev; ftxui::InputOption::InputOption(void)
mov rdi, [rbp+var_18]
add rdi, 50h ; 'P'
lea rsi, [rbp+var_A]
call _ZNSt8functionIFSt10shared_ptrIN5ftxui4NodeEENS1_10InputStateEEEaSIZNS1_11InputOption7DefaultEvE3$_0EENSt9enable_ifIXsrNS6_9_CallableIT_NSA_IXntsr7is_sameINSt9remove_cvINSt16remove_referenceISC_E4typeEE4typeES6_EE5valueESt5decayISC_EE4type4typeESt15__invoke_resultIRSN_JS4_EEEE5valueERS6_E4typeEOSC_
mov [rbp+var_9], 1
test [rbp+var_9], 1
jnz short loc_75934
mov rdi, [rbp+var_18]; this
call _ZN5ftxui11InputOptionD2Ev; ftxui::InputOption::~InputOption()
loc_75934:
mov rax, [rbp+var_20]
add rsp, 20h
pop rbp
retn
| ftxui::InputOption * ftxui::InputOption::Default(ftxui::InputOption *this)
{
_BYTE v2[2]; // [rsp+16h] [rbp-Ah] BYREF
ftxui::InputOption *v3; // [rsp+18h] [rbp-8h]
v3 = this;
v2[1] = 0;
ftxui::InputOption::InputOption(this);
std::function<std::shared_ptr<ftxui::Node> ()(ftxui::InputState)>::operator=<ftxui::InputOption::Default(void)::$_0>(
(char *)this + 80,
v2);
return this;
}
| Default:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV RAX,RDI
MOV qword ptr [RBP + -0x20],RAX
MOV qword ptr [RBP + -0x8],RDI
MOV byte ptr [RBP + -0x9],0x0
CALL 0x0017acf0
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x50
LEA RSI,[RBP + -0xa]
CALL 0x00175940
MOV byte ptr [RBP + -0x9],0x1
TEST byte ptr [RBP + -0x9],0x1
JNZ 0x00175934
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00120010
LAB_00175934:
MOV RAX,qword ptr [RBP + -0x20]
ADD RSP,0x20
POP RBP
RET
|
/* WARNING: Removing unreachable block (ram,0x0017592b) */
/* ftxui::InputOption::Default() */
InputOption * __thiscall ftxui::InputOption::Default(InputOption *this)
{
__0 local_12;
int1 local_11;
InputOption *local_10;
local_11 = 0;
local_10 = this;
InputOption(this);
std::function<std::shared_ptr<ftxui::Node>(ftxui::InputState)>::operator=
((function<std::shared_ptr<ftxui::Node>(ftxui::InputState)> *)(this + 0x50),&local_12);
return this;
}
| |
52,932 | my_strnxfrm_simple_nopad | eloqsql/strings/ctype-simple.c | size_t my_strnxfrm_simple_nopad(CHARSET_INFO * cs,
uchar *dst, size_t dstlen, uint nweights,
const uchar *src, size_t srclen, uint flags)
{
uchar *d0= dst;
dst= d0 + my_strnxfrm_simple_internal(cs, dst, dstlen, &nweights,
src, srclen);
return my_strxfrm_pad_desc_and_reverse_nopad(cs, d0, dst, d0 + dstlen,
nweights, flags, 0);
} | O0 | c | my_strnxfrm_simple_nopad:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
leaq -0x1c(%rbp), %rcx
callq 0x93d90
movq %rax, %rcx
movq -0x40(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x38(%rbp), %rcx
addq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %r8d
movl 0x10(%rbp), %r9d
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x940f0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
| my_strnxfrm_simple_nopad:
push rbp
mov rbp, rsp
sub rsp, 50h
mov eax, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov rax, [rbp+var_10]
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov [rbp+var_40], rax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov r8, [rbp+var_28]
mov r9, [rbp+var_30]
lea rcx, [rbp+var_1C]
call my_strnxfrm_simple_internal
mov rcx, rax
mov rax, [rbp+var_40]
add rax, rcx
mov [rbp+var_10], rax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_38]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_38]
add rcx, [rbp+var_18]
mov r8d, [rbp+var_1C]
mov r9d, [rbp+arg_0]
xor eax, eax
mov [rsp+50h+var_50], 0
call my_strxfrm_pad_desc_and_reverse_nopad
add rsp, 50h
pop rbp
retn
| long long my_strnxfrm_simple_nopad(
long long a1,
unsigned __int8 *a2,
unsigned long long a3,
unsigned int a4,
unsigned __int8 *a5,
unsigned long long a6,
int a7)
{
_BYTE *v7; // rax
unsigned int v9; // [rsp+34h] [rbp-1Ch] BYREF
unsigned long long v10; // [rsp+38h] [rbp-18h]
unsigned __int8 *v11; // [rsp+40h] [rbp-10h]
long long v12; // [rsp+48h] [rbp-8h]
v12 = a1;
v11 = a2;
v10 = a3;
v9 = a4;
v7 = my_strnxfrm_simple_internal(a1, a2, a3, &v9, a5, a6);
v11 = &a2[(_QWORD)v7];
return my_strxfrm_pad_desc_and_reverse_nopad(v12, (_DWORD)a2, (int)v7 + (int)a2, (int)v10 + (int)a2, v9, a7, 0);
}
| my_strnxfrm_simple_nopad:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV EAX,dword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV R8,qword ptr [RBP + -0x28]
MOV R9,qword ptr [RBP + -0x30]
LEA RCX,[RBP + -0x1c]
CALL 0x00193d90
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x38]
ADD RCX,qword ptr [RBP + -0x18]
MOV R8D,dword ptr [RBP + -0x1c]
MOV R9D,dword ptr [RBP + 0x10]
XOR EAX,EAX
MOV dword ptr [RSP],0x0
CALL 0x001940f0
ADD RSP,0x50
POP RBP
RET
|
void my_strnxfrm_simple_nopad
(int8 param_1,long param_2,long param_3,int4 param_4,int8 param_5,
int8 param_6,int4 param_7)
{
int4 local_24;
long local_20;
long local_18;
int8 local_10;
local_24 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
local_18 = my_strnxfrm_simple_internal(param_1,param_2,param_3,&local_24,param_5,param_6);
local_18 = param_2 + local_18;
my_strxfrm_pad_desc_and_reverse_nopad
(local_10,param_2,local_18,param_2 + local_20,local_24,param_7,0);
return;
}
| |
52,933 | LefDefParser::defiPin::addAntennaModel(int) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defiPinCap.cpp | void defiPin::addAntennaModel(int oxide) {
// For version 5.5 only OXIDE1, OXIDE2, OXIDE3, & OXIDE4
// are defined within a pin
defiPinAntennaModel* amo;
int i;
if (numAntennaModel_ == 0) { // does not have antennaModel
if (!antennaModel_) // only need to malloc if it is nill
antennaModel_ = (defiPinAntennaModel**)
malloc(sizeof(defiPinAntennaModel*)*4);
antennaModelAllocated_ = 4;
for (i = 0; i < 4; i++) {
antennaModel_[i] = new defiPinAntennaModel(defData);
}
numAntennaModel_++;
antennaModelAllocated_ = 4;
amo = antennaModel_[0];
} else {
amo = antennaModel_[numAntennaModel_];
numAntennaModel_++;
}
amo->Init();
amo->setAntennaModel(oxide);
return;
} | O3 | cpp | LefDefParser::defiPin::addAntennaModel(int):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movslq 0x100(%rdi), %rax
movq 0x108(%rdi), %rcx
testq %rax, %rax
je 0x1b55f
movq (%rcx,%rax,8), %r15
incl %eax
movl %eax, 0x100(%r14)
jmp 0x1b5cf
testq %rcx, %rcx
jne 0x1b575
movl $0x20, %edi
callq 0x6270
movq %rax, 0x108(%r14)
movl $0x4, 0x104(%r14)
xorl %r12d, %r12d
movl $0x70, %edi
callq 0x61b0
movq %rax, %r15
movq 0x1a0(%r14), %rsi
movq %rax, %rdi
callq 0x19320
movq 0x108(%r14), %rax
movq %r15, (%rax,%r12,8)
incq %r12
cmpq $0x4, %r12
jne 0x1b583
incl 0x100(%r14)
movl $0x4, 0x104(%r14)
movq 0x108(%r14), %rax
movq (%rax), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%r15)
movups %xmm0, 0x48(%r15)
movups %xmm0, 0x38(%r15)
movups %xmm0, 0x28(%r15)
movups %xmm0, 0x18(%r15)
movups %xmm0, 0x8(%r15)
addl $-0x2, %ebx
cmpl $0x2, %ebx
ja 0x1b607
movl %ebx, %eax
leaq 0x45e7f(%rip), %rcx # 0x61480
movq (%rcx,%rax,8), %rdi
jmp 0x1b60e
leaq 0x2c00b(%rip), %rdi # 0x47619
callq 0x6320
movq %rax, (%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x70, %esi
movq %r15, %rdi
callq 0x61c0
movq %rbx, %rdi
callq 0x6300
| _ZN12LefDefParser7defiPin15addAntennaModelEi:
push r15
push r14
push r12
push rbx
push rax
mov ebx, esi
mov r14, rdi
movsxd rax, dword ptr [rdi+100h]
mov rcx, [rdi+108h]
test rax, rax
jz short loc_1B55F
mov r15, [rcx+rax*8]
inc eax
mov [r14+100h], eax
jmp short loc_1B5CF
loc_1B55F:
test rcx, rcx
jnz short loc_1B575
mov edi, 20h ; ' '
call _malloc
mov [r14+108h], rax
loc_1B575:
mov dword ptr [r14+104h], 4
xor r12d, r12d
loc_1B583:
mov edi, 70h ; 'p'; unsigned __int64
call __Znwm; operator new(ulong)
mov r15, rax
mov rsi, [r14+1A0h]; LefDefParser::defrData *
mov rdi, rax; this
call _ZN12LefDefParser19defiPinAntennaModelC2EPNS_8defrDataE; LefDefParser::defiPinAntennaModel::defiPinAntennaModel(LefDefParser::defrData *)
mov rax, [r14+108h]
mov [rax+r12*8], r15
inc r12
cmp r12, 4
jnz short loc_1B583
inc dword ptr [r14+100h]
mov dword ptr [r14+104h], 4
mov rax, [r14+108h]
mov r15, [rax]
loc_1B5CF:
xorps xmm0, xmm0
movups xmmword ptr [r15+58h], xmm0
movups xmmword ptr [r15+48h], xmm0
movups xmmword ptr [r15+38h], xmm0
movups xmmword ptr [r15+28h], xmm0
movups xmmword ptr [r15+18h], xmm0
movups xmmword ptr [r15+8], xmm0
add ebx, 0FFFFFFFEh
cmp ebx, 2
ja short loc_1B607
mov eax, ebx
lea rcx, off_61480; "OXIDE2"
mov rdi, [rcx+rax*8]
jmp short loc_1B60E
loc_1B607:
lea rdi, aKOxide1+2; "OXIDE1"
loc_1B60E:
call _strdup
mov [r15], rax
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
mov rbx, rax
mov esi, 70h ; 'p'; unsigned __int64
mov rdi, r15; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rdi, rbx
call __Unwind_Resume
| long long LefDefParser::defiPin::addAntennaModel(LefDefParser::defiPin *this, int a2)
{
long long v2; // rax
long long v3; // rcx
long long v4; // r15
long long i; // r12
LefDefParser::defiPinAntennaModel *v6; // r15
char *v7; // rdi
long long result; // rax
v2 = *((int *)this + 64);
v3 = *((_QWORD *)this + 33);
if ( *((_DWORD *)this + 64) )
{
v4 = *(_QWORD *)(v3 + 8 * v2);
*((_DWORD *)this + 64) = v2 + 1;
}
else
{
if ( !v3 )
*((_QWORD *)this + 33) = malloc(32LL);
*((_DWORD *)this + 65) = 4;
for ( i = 0LL; i != 4; ++i )
{
v6 = (LefDefParser::defiPinAntennaModel *)operator new(0x70uLL);
LefDefParser::defiPinAntennaModel::defiPinAntennaModel(v6, *((LefDefParser::defrData **)this + 52));
*(_QWORD *)(*((_QWORD *)this + 33) + 8 * i) = v6;
}
++*((_DWORD *)this + 64);
*((_DWORD *)this + 65) = 4;
v4 = **((_QWORD **)this + 33);
}
*(_OWORD *)(v4 + 88) = 0LL;
*(_OWORD *)(v4 + 72) = 0LL;
*(_OWORD *)(v4 + 56) = 0LL;
*(_OWORD *)(v4 + 40) = 0LL;
*(_OWORD *)(v4 + 24) = 0LL;
*(_OWORD *)(v4 + 8) = 0LL;
if ( (unsigned int)(a2 - 2) > 2 )
v7 = "OXIDE1";
else
v7 = (char *)*(&off_61480 + (unsigned int)(a2 - 2));
result = strdup(v7);
*(_QWORD *)v4 = result;
return result;
}
| addAntennaModel:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV EBX,ESI
MOV R14,RDI
MOVSXD RAX,dword ptr [RDI + 0x100]
MOV RCX,qword ptr [RDI + 0x108]
TEST RAX,RAX
JZ 0x0011b55f
MOV R15,qword ptr [RCX + RAX*0x8]
INC EAX
MOV dword ptr [R14 + 0x100],EAX
JMP 0x0011b5cf
LAB_0011b55f:
TEST RCX,RCX
JNZ 0x0011b575
MOV EDI,0x20
CALL 0x00106270
MOV qword ptr [R14 + 0x108],RAX
LAB_0011b575:
MOV dword ptr [R14 + 0x104],0x4
XOR R12D,R12D
LAB_0011b583:
MOV EDI,0x70
CALL 0x001061b0
MOV R15,RAX
MOV RSI,qword ptr [R14 + 0x1a0]
LAB_0011b597:
MOV RDI,RAX
CALL 0x00119320
LAB_0011b59f:
MOV RAX,qword ptr [R14 + 0x108]
MOV qword ptr [RAX + R12*0x8],R15
INC R12
CMP R12,0x4
JNZ 0x0011b583
INC dword ptr [R14 + 0x100]
MOV dword ptr [R14 + 0x104],0x4
MOV RAX,qword ptr [R14 + 0x108]
MOV R15,qword ptr [RAX]
LAB_0011b5cf:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R15 + 0x58],XMM0
MOVUPS xmmword ptr [R15 + 0x48],XMM0
MOVUPS xmmword ptr [R15 + 0x38],XMM0
MOVUPS xmmword ptr [R15 + 0x28],XMM0
MOVUPS xmmword ptr [R15 + 0x18],XMM0
MOVUPS xmmword ptr [R15 + 0x8],XMM0
ADD EBX,-0x2
CMP EBX,0x2
JA 0x0011b607
MOV EAX,EBX
LEA RCX,[0x161480]
MOV RDI,qword ptr [RCX + RAX*0x8]
JMP 0x0011b60e
LAB_0011b607:
LEA RDI,[0x147619]
LAB_0011b60e:
CALL 0x00106320
MOV qword ptr [R15],RAX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* LefDefParser::defiPin::addAntennaModel(int) */
void __thiscall LefDefParser::defiPin::addAntennaModel(defiPin *this,int param_1)
{
int iVar1;
void *pvVar2;
defiPinAntennaModel *this_00;
char *pcVar3;
long lVar4;
int8 *puVar5;
iVar1 = *(int *)(this + 0x100);
if ((long)iVar1 == 0) {
if (*(long *)(this + 0x108) == 0) {
pvVar2 = malloc(0x20);
*(void **)(this + 0x108) = pvVar2;
}
*(int4 *)(this + 0x104) = 4;
lVar4 = 0;
do {
this_00 = (defiPinAntennaModel *)operator_new(0x70);
/* try { // try from 0011b597 to 0011b59e has its CatchHandler @ 0011b622 */
defiPinAntennaModel::defiPinAntennaModel(this_00,*(defrData **)(this + 0x1a0));
*(defiPinAntennaModel **)(*(long *)(this + 0x108) + lVar4 * 8) = this_00;
lVar4 = lVar4 + 1;
} while (lVar4 != 4);
*(int *)(this + 0x100) = *(int *)(this + 0x100) + 1;
*(int4 *)(this + 0x104) = 4;
puVar5 = (int8 *)**(int8 **)(this + 0x108);
}
else {
puVar5 = *(int8 **)(*(long *)(this + 0x108) + (long)iVar1 * 8);
*(int *)(this + 0x100) = iVar1 + 1;
}
puVar5[0xb] = 0;
puVar5[0xc] = 0;
puVar5[9] = 0;
puVar5[10] = 0;
puVar5[7] = 0;
puVar5[8] = 0;
puVar5[5] = 0;
puVar5[6] = 0;
puVar5[3] = 0;
puVar5[4] = 0;
puVar5[1] = 0;
puVar5[2] = 0;
if (param_1 - 2U < 3) {
pcVar3 = (&PTR_s_OXIDE2_00161480)[param_1 - 2U];
}
else {
pcVar3 = "OXIDE1";
}
pcVar3 = strdup(pcVar3);
*puVar5 = pcVar3;
return;
}
| |
52,934 | bool nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::contains<char const (&) [6], 0>(char const (&) [6]) const | monkey531[P]llama/common/json.hpp | constexpr bool is_object() const noexcept
{
return m_data.m_type == value_t::object;
} | O3 | cpp | bool nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::contains<char const (&) [6], 0>(char const (&) [6]) const:
cmpb $0x1, (%rdi)
jne 0xd139b
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x8(%rdi), %r12
movq (%r12), %rbx
cmpq 0x8(%r12), %rbx
je 0xd139e
movq %rsi, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1b220
testl %eax, %eax
je 0xd138e
addq $0x30, %rbx
cmpq 0x8(%r12), %rbx
jne 0xd1374
movq %rbx, %rax
movq 0x8(%r14), %rcx
movq 0x8(%rcx), %rbx
jmp 0xd13a1
xorl %eax, %eax
retq
movq %rbx, %rax
cmpq %rbx, %rax
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA6_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_:
cmp byte ptr [rdi], 1
jnz short loc_D139B
push r15
push r14
push r12
push rbx
push rax
mov r14, rdi
mov r12, [rdi+8]
mov rbx, [r12]
cmp rbx, [r12+8]
jz short loc_D139E
mov r15, rsi
loc_D1374:
mov rdi, rbx
mov rsi, r15
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_D138E
add rbx, 30h ; '0'
cmp rbx, [r12+8]
jnz short loc_D1374
loc_D138E:
mov rax, rbx
mov rcx, [r14+8]
mov rbx, [rcx+8]
jmp short loc_D13A1
loc_D139B:
xor eax, eax
retn
loc_D139E:
mov rax, rbx
loc_D13A1:
cmp rax, rbx
setnz al
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| bool ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA6_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_(
long long a1,
long long a2)
{
long long *v2; // r12
long long v3; // rbx
long long v4; // rax
if ( *(_BYTE *)a1 != 1 )
return 0;
v2 = *(long long **)(a1 + 8);
v3 = *v2;
if ( *v2 == v2[1] )
{
v4 = *v2;
}
else
{
do
{
if ( !(unsigned int)std::string::compare(v3, a2) )
break;
v3 += 48LL;
}
while ( v3 != v2[1] );
v4 = v3;
v3 = *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL);
}
return v4 != v3;
}
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA6_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_:
CMP byte ptr [RDI],0x1
JNZ 0x001d139b
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDI
MOV R12,qword ptr [RDI + 0x8]
MOV RBX,qword ptr [R12]
CMP RBX,qword ptr [R12 + 0x8]
JZ 0x001d139e
MOV R15,RSI
LAB_001d1374:
MOV RDI,RBX
MOV RSI,R15
CALL 0x0011b220
TEST EAX,EAX
JZ 0x001d138e
ADD RBX,0x30
CMP RBX,qword ptr [R12 + 0x8]
JNZ 0x001d1374
LAB_001d138e:
MOV RAX,RBX
MOV RCX,qword ptr [R14 + 0x8]
MOV RBX,qword ptr [RCX + 0x8]
JMP 0x001d13a1
LAB_001d139b:
XOR EAX,EAX
RET
LAB_001d139e:
MOV RAX,RBX
LAB_001d13a1:
CMP RAX,RBX
SETNZ AL
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
int8
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA6_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_
(char *param_1)
{
long *plVar1;
int iVar2;
char *pcVar3;
char *pcVar4;
if (*param_1 != '\x01') {
return 0;
}
plVar1 = *(long **)(param_1 + 8);
pcVar3 = (char *)*plVar1;
pcVar4 = pcVar3;
if (pcVar3 != (char *)plVar1[1]) {
do {
iVar2 = std::__cxx11::string::compare(pcVar3);
if (iVar2 == 0) break;
pcVar3 = pcVar3 + 0x30;
} while (pcVar3 != (char *)plVar1[1]);
pcVar4 = *(char **)(*(long *)(param_1 + 8) + 8);
}
return CONCAT71((int7)((ulong)pcVar3 >> 8),pcVar3 != pcVar4);
}
| |
52,935 | intx::uint<256u> intx::to_big_endian<intx::uint<256u>>(intx::uint<256u> const&) | corpus-core[P]colibri-stateless/build_O0/_deps/intx-src/include/intx/intx.hpp | inline constexpr T to_big_endian(const T& x) noexcept
{
if constexpr (std::endian::native == std::endian::little)
return bswap(x);
else if constexpr (std::is_integral_v<T>)
return x;
else // Swap words.
{
T r;
for (size_t i = 0; i < T::num_words; ++i)
r[T::num_words - 1 - i] = x[i];
return r;
}
} | O0 | cpp | intx::uint<256u> intx::to_big_endian<intx::uint<256u>>(intx::uint<256u> const&):
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, %rax
movq %rax, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
callq 0x689f0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZN4intx13to_big_endianINS_4uintILj256EEEEET_RKS3_:
push rbp
mov rbp, rsp
sub rsp, 10h
mov rax, rdi
mov [rbp+var_10], rax
mov [rbp+var_8], rsi
mov rsi, [rbp+var_8]
call _ZN4intx5bswapERKNS_4uintILj256EEE; intx::bswap(intx::uint<256u> const&)
mov rax, [rbp+var_10]
add rsp, 10h
pop rbp
retn
| long long intx::to_big_endian<intx::uint<256u>>(long long a1, long long a2)
{
intx::bswap(a1, a2);
return a1;
}
| to_big_endian<intx::uint<256u>>:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV RAX,RDI
MOV qword ptr [RBP + -0x10],RAX
MOV qword ptr [RBP + -0x8],RSI
MOV RSI,qword ptr [RBP + -0x8]
CALL 0x001689f0
MOV RAX,qword ptr [RBP + -0x10]
ADD RSP,0x10
POP RBP
RET
|
/* intx::uint<256u> intx::to_big_endian<intx::uint<256u> >(intx::uint<256u> const&) */
intx * __thiscall intx::to_big_endian<intx::uint<256u>>(intx *this,uint *param_1)
{
bswap(this,param_1);
return this;
}
| |
52,936 | my_time_init | eloqsql/mysys/my_getsystime.c | void my_time_init()
{
#ifdef _WIN32
compile_time_assert(sizeof(LARGE_INTEGER) ==
sizeof(query_performance_frequency));
QueryPerformanceFrequency((LARGE_INTEGER *)&query_performance_frequency);
DBUG_ASSERT(query_performance_frequency);
#endif
} | O0 | c | my_time_init:
pushq %rbp
movq %rsp, %rbp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_time_init:
push rbp
mov rbp, rsp
pop rbp
retn
| void my_time_init()
{
;
}
| my_time_init:
PUSH RBP
MOV RBP,RSP
POP RBP
RET
|
void my_time_init(void)
{
return;
}
| |
52,937 | nglog::IsLoggingPrefix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | ng-log[P]ng-log/src/googletest.h | static inline bool IsLoggingPrefix(const string& s) {
if (s.size() != kLoggingPrefixLength) {
return false;
}
if (!strchr("IWEF", s[0])) return false;
for (size_t i = 1; i <= 8; ++i) {
if (!isdigit(s[i]) && s[i] != "YEARDATE"[i - 1]) return false;
}
return true;
} | O0 | c | nglog::IsLoggingPrefix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa5a0
cmpq $0x9, %rax
je 0x207d4
movb $0x0, -0x1(%rbp)
jmp 0x20866
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xa900
movsbl (%rax), %esi
leaq 0x4ddef(%rip), %rdi # 0x6e5da
callq 0xa2c0
cmpq $0x0, %rax
jne 0x207fc
movb $0x0, -0x1(%rbp)
jmp 0x20866
movq $0x1, -0x18(%rbp)
cmpq $0x8, -0x18(%rbp)
ja 0x20862
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa900
movsbl (%rax), %edi
callq 0xa6f0
cmpl $0x0, %eax
jne 0x20852
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa900
movsbl (%rax), %eax
movq -0x18(%rbp), %rdx
subq $0x1, %rdx
leaq 0x4dd9b(%rip), %rcx # 0x6e5df
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x20852
movb $0x0, -0x1(%rbp)
jmp 0x20866
jmp 0x20854
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x20804
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZN5nglogL15IsLoggingPrefixERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov rdi, [rbp+var_10]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4sizeEv; std::string::size(void)
cmp rax, 9
jz short loc_207D4
mov [rbp+var_1], 0
jmp loc_20866
loc_207D4:
mov rdi, [rbp+var_10]
xor eax, eax
mov esi, eax
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEixEm; std::string::operator[](ulong)
movsx esi, byte ptr [rax]
lea rdi, aIwef; "IWEF"
call _strchr
cmp rax, 0
jnz short loc_207FC
mov [rbp+var_1], 0
jmp short loc_20866
loc_207FC:
mov [rbp+var_18], 1
loc_20804:
cmp [rbp+var_18], 8
ja short loc_20862
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEixEm; std::string::operator[](ulong)
movsx edi, byte ptr [rax]
call _isdigit
cmp eax, 0
jnz short loc_20852
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEixEm; std::string::operator[](ulong)
movsx eax, byte ptr [rax]
mov rdx, [rbp+var_18]
sub rdx, 1
lea rcx, aYeardate; "YEARDATE"
movsx ecx, byte ptr [rcx+rdx]
cmp eax, ecx
jz short loc_20852
mov [rbp+var_1], 0
jmp short loc_20866
loc_20852:
jmp short $+2
loc_20854:
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
jmp short loc_20804
loc_20862:
mov [rbp+var_1], 1
loc_20866:
mov al, [rbp+var_1]
and al, 1
add rsp, 20h
pop rbp
retn
| char nglog::IsLoggingPrefix(long long a1)
{
char *v1; // rax
char *v2; // rax
unsigned long long i; // [rsp+8h] [rbp-18h]
if ( std::string::size(a1) != 9 )
return 0;
v1 = (char *)std::string::operator[](a1, 0LL);
if ( !strchr("IWEF", (unsigned int)*v1) )
return 0;
for ( i = 1LL; i <= 8; ++i )
{
v2 = (char *)std::string::operator[](a1, i);
if ( !(unsigned int)isdigit((unsigned int)*v2) && *(char *)std::string::operator[](a1, i) != aYeardate[i - 1] )
return 0;
}
return 1;
}
| IsLoggingPrefix:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0010a5a0
CMP RAX,0x9
JZ 0x001207d4
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00120866
LAB_001207d4:
MOV RDI,qword ptr [RBP + -0x10]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x0010a900
MOVSX ESI,byte ptr [RAX]
LEA RDI,[0x16e5da]
CALL 0x0010a2c0
CMP RAX,0x0
JNZ 0x001207fc
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00120866
LAB_001207fc:
MOV qword ptr [RBP + -0x18],0x1
LAB_00120804:
CMP qword ptr [RBP + -0x18],0x8
JA 0x00120862
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x0010a900
MOVSX EDI,byte ptr [RAX]
CALL 0x0010a6f0
CMP EAX,0x0
JNZ 0x00120852
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x0010a900
MOVSX EAX,byte ptr [RAX]
MOV RDX,qword ptr [RBP + -0x18]
SUB RDX,0x1
LEA RCX,[0x16e5df]
MOVSX ECX,byte ptr [RCX + RDX*0x1]
CMP EAX,ECX
JZ 0x00120852
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00120866
LAB_00120852:
JMP 0x00120854
LAB_00120854:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
JMP 0x00120804
LAB_00120862:
MOV byte ptr [RBP + -0x1],0x1
LAB_00120866:
MOV AL,byte ptr [RBP + -0x1]
AND AL,0x1
ADD RSP,0x20
POP RBP
RET
|
/* nglog::IsLoggingPrefix(std::__cxx11::string const&) */
int1 nglog::IsLoggingPrefix(string *param_1)
{
int iVar1;
long lVar2;
char *pcVar3;
ulong local_20;
int1 local_9;
lVar2 = std::__cxx11::string::size();
if (lVar2 == 9) {
pcVar3 = (char *)std::__cxx11::string::operator[]((ulong)param_1);
pcVar3 = strchr("IWEF",(int)*pcVar3);
if (pcVar3 == (char *)0x0) {
local_9 = 0;
}
else {
for (local_20 = 1; local_20 < 9; local_20 = local_20 + 1) {
pcVar3 = (char *)std::__cxx11::string::operator[]((ulong)param_1);
iVar1 = isdigit((int)*pcVar3);
if ((iVar1 == 0) &&
(pcVar3 = (char *)std::__cxx11::string::operator[]((ulong)param_1),
*pcVar3 != (&UNK_0016e5de)[local_20])) {
return 0;
}
}
local_9 = 1;
}
}
else {
local_9 = 0;
}
return local_9;
}
| |
52,938 | ma_apply_redo_index_free_page | eloqsql/storage/maria/ma_key_recover.c | uint _ma_apply_redo_index_free_page(MARIA_HA *info,
LSN lsn,
const uchar *header)
{
pgcache_page_no_t page= page_korr(header);
pgcache_page_no_t free_page= page_korr(header + PAGE_STORE_SIZE);
my_off_t old_link;
MARIA_PINNED_PAGE page_link;
MARIA_SHARE *share= info->s;
uchar *buff;
int result;
DBUG_ENTER("_ma_apply_redo_index_free_page");
DBUG_PRINT("enter", ("page: %lu free_page: %lu",
(ulong) page, (ulong) free_page));
share->state.changed|= (STATE_CHANGED | STATE_NOT_OPTIMIZED_KEYS |
STATE_NOT_SORTED_PAGES | STATE_NOT_ZEROFILLED |
STATE_NOT_MOVABLE);
if (cmp_translog_addr(lsn, share->state.is_of_horizon) >= 0)
share->state.key_del= (my_off_t) page * share->block_size;
old_link= ((free_page != IMPOSSIBLE_PAGE_NO) ?
(my_off_t) free_page * share->block_size :
HA_OFFSET_ERROR);
if (!(buff= pagecache_read(share->pagecache, &share->kfile,
page, 0, 0,
PAGECACHE_PLAIN_PAGE, PAGECACHE_LOCK_WRITE,
&page_link.link)))
{
result= (uint) my_errno;
_ma_set_fatal_error(info, my_errno);
goto err;
}
if (lsn_korr(buff) >= lsn)
{
/* Already applied */
check_skipped_lsn(info, lsn_korr(buff), 0, page);
result= 0;
goto err;
}
/* Free page */
bzero(buff + LSN_STORE_SIZE, share->keypage_header - LSN_STORE_SIZE);
_ma_store_keynr(share, buff, (uchar) MARIA_DELETE_KEY_NR);
_ma_store_page_used(share, buff, share->keypage_header + 8);
mi_sizestore(buff + share->keypage_header, old_link);
#ifdef IDENTICAL_PAGES_AFTER_RECOVERY
{
bzero(buff + share->keypage_header + 8,
share->block_size - share->keypage_header - 8 -
KEYPAGE_CHECKSUM_SIZE);
}
#endif
/* Mark page to be unlocked and written at _ma_unpin_all_pages() */
page_link.unlock= PAGECACHE_LOCK_WRITE_UNLOCK;
page_link.changed= 1;
push_dynamic(&info->pinned_pages, (void*) &page_link);
DBUG_RETURN(0);
err:
pagecache_unlock_by_link(share->pagecache, page_link.link,
PAGECACHE_LOCK_WRITE_UNLOCK,
PAGECACHE_UNPIN, LSN_IMPOSSIBLE,
LSN_IMPOSSIBLE, 0, FALSE);
DBUG_RETURN(result);
} | O0 | c | ma_apply_redo_index_free_page:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x45790
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
addq $0x5, %rdi
callq 0x45790
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
jmp 0x45802
movq -0x58(%rbp), %rax
movl 0x170(%rax), %ecx
orl $0x1b1, %ecx # imm = 0x1B1
movl %ecx, 0x170(%rax)
movq -0x18(%rbp), %rax
movq -0x58(%rbp), %rcx
subq 0x180(%rcx), %rax
cmpq $0x0, %rax
jl 0x4584a
movq -0x28(%rbp), %rcx
movq -0x58(%rbp), %rax
movl 0x7bc(%rax), %eax
imulq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, 0x120(%rax)
movabsq $0xffffffffff, %rax # imm = 0xFFFFFFFFFF
cmpq %rax, -0x30(%rbp)
je 0x45875
movq -0x30(%rbp), %rax
movq -0x58(%rbp), %rcx
movl 0x7bc(%rcx), %ecx
imulq %rcx, %rax
movq %rax, -0x90(%rbp)
jmp 0x45885
movq $-0x1, %rax
movq %rax, -0x90(%rbp)
jmp 0x45885
movq -0x90(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x58(%rbp), %rax
movq 0x600(%rax), %rdi
movq -0x58(%rbp), %rsi
addq $0x750, %rsi # imm = 0x750
movq -0x28(%rbp), %rdx
leaq -0x50(%rbp), %rax
xorl %ecx, %ecx
xorl %r8d, %r8d
movl $0x1, %r9d
movl $0x4, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x3d190
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
jne 0x45901
callq 0xf6210
movl (%rax), %eax
movl %eax, -0x64(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
callq 0xf6210
movq -0x98(%rbp), %rdi
movl (%rax), %esi
callq 0x43f20
jmp 0x45b36
movq -0x60(%rbp), %rax
movzbl (%rax), %eax
movq -0x60(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl %eax, %eax
shlq $0x20, %rax
movq -0x60(%rbp), %rcx
movl 0x3(%rcx), %ecx
orq %rcx, %rax
cmpq -0x18(%rbp), %rax
jl 0x45986
movq -0x10(%rbp), %rdi
movq -0x60(%rbp), %rax
movzbl (%rax), %eax
movq -0x60(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl %eax, %eax
movl %eax, %esi
shlq $0x20, %rsi
movq -0x60(%rbp), %rax
movl 0x3(%rax), %eax
orq %rax, %rsi
movq -0x28(%rbp), %rcx
xorl %edx, %edx
callq 0x33ff0
movl $0x0, -0x64(%rbp)
jmp 0x45b36
movq -0x60(%rbp), %rdi
addq $0x7, %rdi
movq -0x58(%rbp), %rax
movl 0x744(%rax), %eax
subl $0x7, %eax
movl %eax, %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x2a2a0
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
movl 0x744(%rcx), %ecx
subl $0x1, %ecx
subl $0x1, %ecx
subl $0x2, %ecx
movl %ecx, %ecx
movb $-0x1, (%rax,%rcx)
movq -0x58(%rbp), %rax
movl 0x744(%rax), %eax
addl $0x8, %eax
movl %eax, -0x68(%rbp)
movl -0x68(%rbp), %eax
movb %al, %dl
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
movl 0x744(%rcx), %ecx
movb %dl, -0x1(%rax,%rcx)
movl -0x68(%rbp), %eax
shrl $0x8, %eax
movb %al, %dl
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
movl 0x744(%rcx), %ecx
movb %dl, -0x2(%rax,%rcx)
movq -0x38(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x38(%rbp), %rax
shrq $0x20, %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movb %al, %dl
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
movl 0x744(%rcx), %ecx
movb %dl, 0x3(%rax,%rcx)
movq -0x80(%rbp), %rax
shrq $0x8, %rax
movb %al, %dl
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
movl 0x744(%rcx), %ecx
movb %dl, 0x2(%rax,%rcx)
movq -0x80(%rbp), %rax
shrq $0x10, %rax
movb %al, %dl
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
movl 0x744(%rcx), %ecx
movb %dl, 0x1(%rax,%rcx)
movq -0x80(%rbp), %rax
shrq $0x18, %rax
movb %al, %dl
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
movl 0x744(%rcx), %ecx
movb %dl, (%rax,%rcx)
movq -0x70(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
movb %al, %dl
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
movl 0x744(%rcx), %ecx
movb %dl, 0x7(%rax,%rcx)
movq -0x88(%rbp), %rax
shrq $0x8, %rax
movb %al, %dl
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
movl 0x744(%rcx), %ecx
movb %dl, 0x6(%rax,%rcx)
movq -0x88(%rbp), %rax
shrq $0x10, %rax
movb %al, %dl
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
movl 0x744(%rcx), %ecx
movb %dl, 0x5(%rax,%rcx)
movq -0x88(%rbp), %rax
shrq $0x18, %rax
movb %al, %dl
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
movl 0x744(%rcx), %ecx
movb %dl, 0x4(%rax,%rcx)
movl $0x6, -0x48(%rbp)
movb $0x1, -0x40(%rbp)
movq -0x10(%rbp), %rdi
addq $0x2e8, %rdi # imm = 0x2E8
leaq -0x50(%rbp), %rsi
callq 0xda810
movl $0x0, -0x4(%rbp)
jmp 0x45b73
movq -0x58(%rbp), %rax
movq 0x600(%rax), %rdi
movq -0x50(%rbp), %rsi
movl $0x6, %edx
movl $0x3, %ecx
xorl %eax, %eax
movl %eax, %r9d
xorl %eax, %eax
movq %r9, %r8
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x3cf30
movl -0x64(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nop
| _ma_apply_redo_index_free_page:
push rbp
mov rbp, rsp
sub rsp, 0B0h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rdi, [rbp+var_20]
call uint5korr
mov [rbp+var_28], rax
mov rdi, [rbp+var_20]
add rdi, 5
call uint5korr
mov [rbp+var_30], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_58], rax
jmp short $+2
loc_45802:
mov rax, [rbp+var_58]
mov ecx, [rax+170h]
or ecx, 1B1h
mov [rax+170h], ecx
mov rax, [rbp+var_18]
mov rcx, [rbp+var_58]
sub rax, [rcx+180h]
cmp rax, 0
jl short loc_4584A
mov rcx, [rbp+var_28]
mov rax, [rbp+var_58]
mov eax, [rax+7BCh]
imul rcx, rax
mov rax, [rbp+var_58]
mov [rax+120h], rcx
loc_4584A:
mov rax, 0FFFFFFFFFFh
cmp [rbp+var_30], rax
jz short loc_45875
mov rax, [rbp+var_30]
mov rcx, [rbp+var_58]
mov ecx, [rcx+7BCh]
imul rax, rcx
mov [rbp+var_90], rax
jmp short loc_45885
loc_45875:
mov rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_90], rax
jmp short $+2
loc_45885:
mov rax, [rbp+var_90]
mov [rbp+var_38], rax
mov rax, [rbp+var_58]
mov rdi, [rax+600h]
mov rsi, [rbp+var_58]
add rsi, 750h
mov rdx, [rbp+var_28]
lea rax, [rbp+var_50]
xor ecx, ecx
xor r8d, r8d
mov r9d, 1
mov [rsp+0B0h+var_B0], 4
mov [rsp+0B0h+var_A8], rax
call pagecache_read
mov [rbp+var_60], rax
cmp rax, 0
jnz short loc_45901
call _my_thread_var
mov eax, [rax]
mov [rbp+var_64], eax
mov rax, [rbp+var_10]
mov [rbp+var_98], rax
call _my_thread_var
mov rdi, [rbp+var_98]
mov esi, [rax]
call _ma_set_fatal_error
jmp loc_45B36
loc_45901:
mov rax, [rbp+var_60]
movzx eax, byte ptr [rax]
mov rcx, [rbp+var_60]
movzx ecx, byte ptr [rcx+1]
shl ecx, 8
or eax, ecx
mov rcx, [rbp+var_60]
movzx ecx, byte ptr [rcx+2]
shl ecx, 10h
or eax, ecx
mov eax, eax
shl rax, 20h
mov rcx, [rbp+var_60]
mov ecx, [rcx+3]
or rax, rcx
cmp rax, [rbp+var_18]
jl short loc_45986
mov rdi, [rbp+var_10]
mov rax, [rbp+var_60]
movzx eax, byte ptr [rax]
mov rcx, [rbp+var_60]
movzx ecx, byte ptr [rcx+1]
shl ecx, 8
or eax, ecx
mov rcx, [rbp+var_60]
movzx ecx, byte ptr [rcx+2]
shl ecx, 10h
or eax, ecx
mov eax, eax
mov esi, eax
shl rsi, 20h
mov rax, [rbp+var_60]
mov eax, [rax+3]
or rsi, rax
mov rcx, [rbp+var_28]
xor edx, edx
call check_skipped_lsn
mov [rbp+var_64], 0
jmp loc_45B36
loc_45986:
mov rdi, [rbp+var_60]
add rdi, 7
mov rax, [rbp+var_58]
mov eax, [rax+744h]
sub eax, 7
mov eax, eax
mov edx, eax
xor esi, esi
call _memset
mov rax, [rbp+var_60]
mov rcx, [rbp+var_58]
mov ecx, [rcx+744h]
sub ecx, 1
sub ecx, 1
sub ecx, 2
mov ecx, ecx
mov byte ptr [rax+rcx], 0FFh
mov rax, [rbp+var_58]
mov eax, [rax+744h]
add eax, 8
mov [rbp+var_68], eax
mov eax, [rbp+var_68]
mov dl, al
mov rax, [rbp+var_60]
mov rcx, [rbp+var_58]
mov ecx, [rcx+744h]
mov [rax+rcx-1], dl
mov eax, [rbp+var_68]
shr eax, 8
mov dl, al
mov rax, [rbp+var_60]
mov rcx, [rbp+var_58]
mov ecx, [rcx+744h]
mov [rax+rcx-2], dl
mov rax, [rbp+var_38]
mov [rbp+var_70], rax
mov rax, [rbp+var_38]
shr rax, 20h
mov [rbp+var_78], rax
mov rax, [rbp+var_78]
mov [rbp+var_80], rax
mov rax, [rbp+var_80]
mov dl, al
mov rax, [rbp+var_60]
mov rcx, [rbp+var_58]
mov ecx, [rcx+744h]
mov [rax+rcx+3], dl
mov rax, [rbp+var_80]
shr rax, 8
mov dl, al
mov rax, [rbp+var_60]
mov rcx, [rbp+var_58]
mov ecx, [rcx+744h]
mov [rax+rcx+2], dl
mov rax, [rbp+var_80]
shr rax, 10h
mov dl, al
mov rax, [rbp+var_60]
mov rcx, [rbp+var_58]
mov ecx, [rcx+744h]
mov [rax+rcx+1], dl
mov rax, [rbp+var_80]
shr rax, 18h
mov dl, al
mov rax, [rbp+var_60]
mov rcx, [rbp+var_58]
mov ecx, [rcx+744h]
mov [rax+rcx], dl
mov rax, [rbp+var_70]
mov [rbp+var_88], rax
mov rax, [rbp+var_88]
mov dl, al
mov rax, [rbp+var_60]
mov rcx, [rbp+var_58]
mov ecx, [rcx+744h]
mov [rax+rcx+7], dl
mov rax, [rbp+var_88]
shr rax, 8
mov dl, al
mov rax, [rbp+var_60]
mov rcx, [rbp+var_58]
mov ecx, [rcx+744h]
mov [rax+rcx+6], dl
mov rax, [rbp+var_88]
shr rax, 10h
mov dl, al
mov rax, [rbp+var_60]
mov rcx, [rbp+var_58]
mov ecx, [rcx+744h]
mov [rax+rcx+5], dl
mov rax, [rbp+var_88]
shr rax, 18h
mov dl, al
mov rax, [rbp+var_60]
mov rcx, [rbp+var_58]
mov ecx, [rcx+744h]
mov [rax+rcx+4], dl
mov [rbp+var_48], 6
mov [rbp+var_40], 1
mov rdi, [rbp+var_10]
add rdi, 2E8h
lea rsi, [rbp+var_50]
call insert_dynamic
mov [rbp+var_4], 0
jmp short loc_45B73
loc_45B36:
mov rax, [rbp+var_58]
mov rdi, [rax+600h]
mov rsi, [rbp+var_50]
mov edx, 6
mov ecx, 3
xor eax, eax
mov r9d, eax
xor eax, eax
mov r8, r9
mov [rsp+0B0h+var_B0], 0
mov dword ptr [rsp+0B0h+var_A8], 0
call pagecache_unlock_by_link
mov eax, [rbp+var_64]
mov [rbp+var_4], eax
loc_45B73:
mov eax, [rbp+var_4]
add rsp, 0B0h
pop rbp
retn
| long long ma_apply_redo_index_free_page(_QWORD *a1, signed long long a2, unsigned int *a3)
{
int *v3; // rax
long long v4; // rdx
long long v5; // rcx
long long v6; // r8
int v7; // r9d
_DWORD *v9; // [rsp+18h] [rbp-98h]
long long v10; // [rsp+20h] [rbp-90h]
unsigned long long v11; // [rsp+30h] [rbp-80h]
int v12; // [rsp+40h] [rbp-70h]
int v13; // [rsp+48h] [rbp-68h]
_BYTE v14[12]; // [rsp+4Ch] [rbp-64h]
long long v15; // [rsp+58h] [rbp-58h]
long long v16; // [rsp+60h] [rbp-50h] BYREF
int v17; // [rsp+68h] [rbp-48h]
char v18; // [rsp+70h] [rbp-40h]
unsigned long long v19; // [rsp+78h] [rbp-38h]
unsigned long long v20; // [rsp+80h] [rbp-30h]
unsigned long long v21; // [rsp+88h] [rbp-28h]
unsigned int *v22; // [rsp+90h] [rbp-20h]
signed long long v23; // [rsp+98h] [rbp-18h]
_DWORD *v24; // [rsp+A0h] [rbp-10h]
v24 = a1;
v23 = a2;
v22 = a3;
v21 = uint5korr(a3);
v20 = uint5korr((unsigned int *)((char *)v22 + 5));
v15 = *a1;
*(_DWORD *)(v15 + 368) |= 0x1B1u;
if ( v23 - *(_QWORD *)(v15 + 384) >= 0 )
*(_QWORD *)(v15 + 288) = *(unsigned int *)(v15 + 1980) * v21;
if ( v20 == 0xFFFFFFFFFFLL )
v10 = -1LL;
else
v10 = *(unsigned int *)(v15 + 1980) * v20;
v19 = v10;
*(_QWORD *)&v14[4] = pagecache_read(*(_QWORD **)(v15 + 1536), v15 + 1872, v21, 0, 0LL, 1, 4u, (char *)&v16);
if ( !*(_QWORD *)&v14[4] )
{
*(_QWORD *)v14 = *(unsigned int *)my_thread_var();
v9 = v24;
v3 = (int *)my_thread_var();
ma_set_fatal_error(v9, *v3, v4, v5, v6, v7);
LABEL_11:
pagecache_unlock_by_link(*(_QWORD **)(v15 + 1536), v16, 6, 3, 0LL, 0LL, 0, 0);
return *(unsigned int *)v14;
}
if ( (long long)(*(unsigned int *)(*(_QWORD *)&v14[4] + 3LL) | ((unsigned long long)((*(unsigned __int8 *)(*(_QWORD *)&v14[4] + 2LL) << 16) | (unsigned int)(unsigned __int16)**(_WORD **)&v14[4]) << 32)) >= v23 )
{
check_skipped_lsn(
(long long)v24,
*(unsigned int *)(*(_QWORD *)&v14[4] + 3LL) | ((unsigned long long)((*(unsigned __int8 *)(*(_QWORD *)&v14[4] + 2LL) << 16) | (unsigned int)(unsigned __int16)**(_WORD **)&v14[4]) << 32),
0,
v21);
*(_DWORD *)v14 = 0;
goto LABEL_11;
}
memset(*(_QWORD *)&v14[4] + 7LL, 0LL, (unsigned int)(*(_DWORD *)(v15 + 1860) - 7));
*(_BYTE *)(*(_QWORD *)&v14[4] + (unsigned int)(*(_DWORD *)(v15 + 1860) - 4)) = -1;
v13 = *(_DWORD *)(v15 + 1860) + 8;
*(_BYTE *)(*(_QWORD *)&v14[4] + *(unsigned int *)(v15 + 1860) - 1LL) = v13;
*(_BYTE *)(*(_QWORD *)&v14[4] + *(unsigned int *)(v15 + 1860) - 2LL) = BYTE1(v13);
v12 = v19;
v11 = HIDWORD(v19);
*(_BYTE *)(*(_QWORD *)&v14[4] + *(unsigned int *)(v15 + 1860) + 3LL) = BYTE4(v19);
*(_BYTE *)(*(_QWORD *)&v14[4] + *(unsigned int *)(v15 + 1860) + 2LL) = BYTE1(v11);
*(_BYTE *)(*(_QWORD *)&v14[4] + *(unsigned int *)(v15 + 1860) + 1LL) = BYTE2(v11);
*(_BYTE *)(*(_QWORD *)&v14[4] + *(unsigned int *)(v15 + 1860)) = BYTE3(v11);
*(_BYTE *)(*(_QWORD *)&v14[4] + *(unsigned int *)(v15 + 1860) + 7LL) = v12;
*(_BYTE *)(*(_QWORD *)&v14[4] + *(unsigned int *)(v15 + 1860) + 6LL) = BYTE1(v12);
*(_BYTE *)(*(_QWORD *)&v14[4] + *(unsigned int *)(v15 + 1860) + 5LL) = BYTE2(v12);
*(_BYTE *)(*(_QWORD *)&v14[4] + *(unsigned int *)(v15 + 1860) + 4LL) = HIBYTE(v12);
v17 = 6;
v18 = 1;
insert_dynamic(v24 + 186, &v16);
return 0;
}
| _ma_apply_redo_index_free_page:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xb0
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x00145790
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x5
CALL 0x00145790
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x58],RAX
JMP 0x00145802
LAB_00145802:
MOV RAX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RAX + 0x170]
OR ECX,0x1b1
MOV dword ptr [RAX + 0x170],ECX
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x58]
SUB RAX,qword ptr [RCX + 0x180]
CMP RAX,0x0
JL 0x0014584a
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x58]
MOV EAX,dword ptr [RAX + 0x7bc]
IMUL RCX,RAX
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RAX + 0x120],RCX
LAB_0014584a:
MOV RAX,0xffffffffff
CMP qword ptr [RBP + -0x30],RAX
JZ 0x00145875
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RCX + 0x7bc]
IMUL RAX,RCX
MOV qword ptr [RBP + -0x90],RAX
JMP 0x00145885
LAB_00145875:
MOV RAX,-0x1
MOV qword ptr [RBP + -0x90],RAX
JMP 0x00145885
LAB_00145885:
MOV RAX,qword ptr [RBP + -0x90]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x58]
MOV RDI,qword ptr [RAX + 0x600]
MOV RSI,qword ptr [RBP + -0x58]
ADD RSI,0x750
MOV RDX,qword ptr [RBP + -0x28]
LEA RAX,[RBP + -0x50]
XOR ECX,ECX
XOR R8D,R8D
MOV R9D,0x1
MOV dword ptr [RSP],0x4
MOV qword ptr [RSP + 0x8],RAX
CALL 0x0013d190
MOV qword ptr [RBP + -0x60],RAX
CMP RAX,0x0
JNZ 0x00145901
CALL 0x001f6210
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x64],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x98],RAX
CALL 0x001f6210
MOV RDI,qword ptr [RBP + -0x98]
MOV ESI,dword ptr [RAX]
CALL 0x00143f20
JMP 0x00145b36
LAB_00145901:
MOV RAX,qword ptr [RBP + -0x60]
MOVZX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x60]
MOVZX ECX,byte ptr [RCX + 0x1]
SHL ECX,0x8
OR EAX,ECX
MOV RCX,qword ptr [RBP + -0x60]
MOVZX ECX,byte ptr [RCX + 0x2]
SHL ECX,0x10
OR EAX,ECX
MOV EAX,EAX
SHL RAX,0x20
MOV RCX,qword ptr [RBP + -0x60]
MOV ECX,dword ptr [RCX + 0x3]
OR RAX,RCX
CMP RAX,qword ptr [RBP + -0x18]
JL 0x00145986
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x60]
MOVZX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x60]
MOVZX ECX,byte ptr [RCX + 0x1]
SHL ECX,0x8
OR EAX,ECX
MOV RCX,qword ptr [RBP + -0x60]
MOVZX ECX,byte ptr [RCX + 0x2]
SHL ECX,0x10
OR EAX,ECX
MOV EAX,EAX
MOV ESI,EAX
SHL RSI,0x20
MOV RAX,qword ptr [RBP + -0x60]
MOV EAX,dword ptr [RAX + 0x3]
OR RSI,RAX
MOV RCX,qword ptr [RBP + -0x28]
XOR EDX,EDX
CALL 0x00133ff0
MOV dword ptr [RBP + -0x64],0x0
JMP 0x00145b36
LAB_00145986:
MOV RDI,qword ptr [RBP + -0x60]
ADD RDI,0x7
MOV RAX,qword ptr [RBP + -0x58]
MOV EAX,dword ptr [RAX + 0x744]
SUB EAX,0x7
MOV EAX,EAX
MOV EDX,EAX
XOR ESI,ESI
CALL 0x0012a2a0
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RCX + 0x744]
SUB ECX,0x1
SUB ECX,0x1
SUB ECX,0x2
MOV ECX,ECX
MOV byte ptr [RAX + RCX*0x1],0xff
MOV RAX,qword ptr [RBP + -0x58]
MOV EAX,dword ptr [RAX + 0x744]
ADD EAX,0x8
MOV dword ptr [RBP + -0x68],EAX
MOV EAX,dword ptr [RBP + -0x68]
MOV DL,AL
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RCX + 0x744]
MOV byte ptr [RAX + RCX*0x1 + -0x1],DL
MOV EAX,dword ptr [RBP + -0x68]
SHR EAX,0x8
MOV DL,AL
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RCX + 0x744]
MOV byte ptr [RAX + RCX*0x1 + -0x2],DL
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x70],RAX
MOV RAX,qword ptr [RBP + -0x38]
SHR RAX,0x20
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,qword ptr [RBP + -0x78]
MOV qword ptr [RBP + -0x80],RAX
MOV RAX,qword ptr [RBP + -0x80]
MOV DL,AL
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RCX + 0x744]
MOV byte ptr [RAX + RCX*0x1 + 0x3],DL
MOV RAX,qword ptr [RBP + -0x80]
SHR RAX,0x8
MOV DL,AL
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RCX + 0x744]
MOV byte ptr [RAX + RCX*0x1 + 0x2],DL
MOV RAX,qword ptr [RBP + -0x80]
SHR RAX,0x10
MOV DL,AL
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RCX + 0x744]
MOV byte ptr [RAX + RCX*0x1 + 0x1],DL
MOV RAX,qword ptr [RBP + -0x80]
SHR RAX,0x18
MOV DL,AL
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RCX + 0x744]
MOV byte ptr [RAX + RCX*0x1],DL
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RBP + -0x88],RAX
MOV RAX,qword ptr [RBP + -0x88]
MOV DL,AL
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RCX + 0x744]
MOV byte ptr [RAX + RCX*0x1 + 0x7],DL
MOV RAX,qword ptr [RBP + -0x88]
SHR RAX,0x8
MOV DL,AL
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RCX + 0x744]
MOV byte ptr [RAX + RCX*0x1 + 0x6],DL
MOV RAX,qword ptr [RBP + -0x88]
SHR RAX,0x10
MOV DL,AL
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RCX + 0x744]
MOV byte ptr [RAX + RCX*0x1 + 0x5],DL
MOV RAX,qword ptr [RBP + -0x88]
SHR RAX,0x18
MOV DL,AL
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RCX + 0x744]
MOV byte ptr [RAX + RCX*0x1 + 0x4],DL
MOV dword ptr [RBP + -0x48],0x6
MOV byte ptr [RBP + -0x40],0x1
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x2e8
LEA RSI,[RBP + -0x50]
CALL 0x001da810
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00145b73
LAB_00145b36:
MOV RAX,qword ptr [RBP + -0x58]
MOV RDI,qword ptr [RAX + 0x600]
MOV RSI,qword ptr [RBP + -0x50]
MOV EDX,0x6
MOV ECX,0x3
XOR EAX,EAX
MOV R9D,EAX
XOR EAX,EAX
MOV R8,R9
MOV dword ptr [RSP],0x0
MOV dword ptr [RSP + 0x8],0x0
CALL 0x0013cf30
MOV EAX,dword ptr [RBP + -0x64]
MOV dword ptr [RBP + -0x4],EAX
LAB_00145b73:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0xb0
POP RBP
RET
|
int4 _ma_apply_redo_index_free_page(long *param_1,long param_2,long param_3)
{
long lVar1;
long *plVar2;
int iVar3;
int3 *puVar4;
int4 *puVar5;
int8 *puVar6;
long local_98;
int4 local_6c;
int8 local_58;
int4 local_50;
int1 local_48;
long local_40;
long local_38;
long local_30;
long local_28;
long local_20;
long *local_18;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
local_30 = uint5korr(param_3);
local_38 = uint5korr(local_28 + 5);
lVar1 = *local_18;
*(uint *)(lVar1 + 0x170) = *(uint *)(lVar1 + 0x170) | 0x1b1;
if (-1 < local_20 - *(long *)(lVar1 + 0x180)) {
*(ulong *)(lVar1 + 0x120) = local_30 * (ulong)*(uint *)(lVar1 + 0x7bc);
}
if (local_38 == 0xffffffffff) {
local_98 = -1;
}
else {
local_98 = local_38 * (ulong)*(uint *)(lVar1 + 0x7bc);
}
local_40 = local_98;
puVar6 = &local_58;
puVar4 = (int3 *)
pagecache_read(*(int8 *)(lVar1 + 0x600),lVar1 + 0x750,local_30,0,0,1,4,puVar6);
if (puVar4 == (int3 *)0x0) {
puVar5 = (int4 *)_my_thread_var();
plVar2 = local_18;
local_6c = *puVar5;
puVar5 = (int4 *)_my_thread_var();
_ma_set_fatal_error(plVar2,*puVar5);
}
else {
if ((long)(ulong)CONCAT34(*puVar4,*(int4 *)((long)puVar4 + 3)) < local_20) {
memset((void *)((long)puVar4 + 7),0,(ulong)(*(int *)(lVar1 + 0x744) - 7));
*(int1 *)((long)puVar4 + (ulong)(*(int *)(lVar1 + 0x744) - 4)) = 0xff;
iVar3 = *(int *)(lVar1 + 0x744) + 8;
*(char *)((long)puVar4 + ((ulong)*(uint *)(lVar1 + 0x744) - 1)) = (char)iVar3;
*(char *)((long)puVar4 + ((ulong)*(uint *)(lVar1 + 0x744) - 2)) = (char)((uint)iVar3 >> 8);
*(char *)((long)puVar4 + (ulong)*(uint *)(lVar1 + 0x744) + 3) =
(char)((ulong)local_40 >> 0x20);
*(char *)((long)puVar4 + (ulong)*(uint *)(lVar1 + 0x744) + 2) =
(char)((ulong)local_40 >> 0x28);
*(char *)((long)puVar4 + (ulong)*(uint *)(lVar1 + 0x744) + 1) =
(char)((ulong)local_40 >> 0x30);
*(char *)((long)puVar4 + (ulong)*(uint *)(lVar1 + 0x744)) = (char)((ulong)local_40 >> 0x38);
*(char *)((long)puVar4 + (ulong)*(uint *)(lVar1 + 0x744) + 7) = (char)local_40;
*(char *)((long)puVar4 + (ulong)*(uint *)(lVar1 + 0x744) + 6) = (char)((ulong)local_40 >> 8);
*(char *)((long)puVar4 + (ulong)*(uint *)(lVar1 + 0x744) + 5) =
(char)((ulong)local_40 >> 0x10);
*(char *)((long)puVar4 + (ulong)*(uint *)(lVar1 + 0x744) + 4) =
(char)((ulong)local_40 >> 0x18);
local_50 = 6;
local_48 = 1;
insert_dynamic(local_18 + 0x5d,&local_58);
return 0;
}
check_skipped_lsn(local_18,(ulong)CONCAT34(*puVar4,*(int4 *)((long)puVar4 + 3)),0,local_30
);
local_6c = 0;
}
pagecache_unlock_by_link
(*(int8 *)(lVar1 + 0x600),local_58,6,3,0,0,0,(ulong)puVar6 & 0xffffffff00000000);
return local_6c;
}
| |
52,939 | minja::TemplateToken::typeToString[abi:cxx11](minja::TemplateToken::Type) | monkey531[P]llama/common/minja.hpp | static std::string typeToString(Type t) {
switch (t) {
case Type::Text: return "text";
case Type::Expression: return "expression";
case Type::If: return "if";
case Type::Else: return "else";
case Type::Elif: return "elif";
case Type::EndIf: return "endif";
case Type::For: return "for";
case Type::EndFor: return "endfor";
case Type::Set: return "set";
case Type::EndSet: return "endset";
case Type::Comment: return "comment";
case Type::Macro: return "macro";
case Type::EndMacro: return "endmacro";
case Type::Filter: return "filter";
case Type::EndFilter: return "endfilter";
case Type::Generation: return "generation";
case Type::EndGeneration: return "endgeneration";
case Type::Break: return "break";
case Type::Continue: return "continue";
}
return "Unknown";
} | O2 | cpp | minja::TemplateToken::typeToString[abi:cxx11](minja::TemplateToken::Type):
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x12, %esi
ja 0x72e71
movl %esi, %eax
leaq 0x419de(%rip), %rcx # 0xb478c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x42767(%rip), %rsi # 0xb5525
jmp 0x72e78
leaq 0x42ae5(%rip), %rsi # 0xb58af
jmp 0x72e78
leaq 0x42aac(%rip), %rsi # 0xb5882
jmp 0x72e78
leaq 0x42a76(%rip), %rsi # 0xb5858
jmp 0x72e78
leaq 0x42974(%rip), %rsi # 0xb5762
jmp 0x72e78
leaq 0x43aea(%rip), %rsi # 0xb68e4
jmp 0x72e78
leaq 0x429ea(%rip), %rsi # 0xb57ed
jmp 0x72e78
leaq 0x3a8bd(%rip), %rsi # 0xad6c9
jmp 0x72e78
leaq 0x42a9d(%rip), %rsi # 0xb58b2
jmp 0x72e78
leaq 0x4296a(%rip), %rsi # 0xb5788
jmp 0x72e78
leaq 0x429bf(%rip), %rsi # 0xb57e6
jmp 0x72e78
leaq 0x42b29(%rip), %rsi # 0xb5959
jmp 0x72e78
leaq 0x42a80(%rip), %rsi # 0xb58b9
jmp 0x72e78
leaq 0x4294b(%rip), %rsi # 0xb578d
jmp 0x72e78
leaq 0x42a3a(%rip), %rsi # 0xb5885
jmp 0x72e78
leaq 0x42995(%rip), %rsi # 0xb57e9
jmp 0x72e78
leaq 0x42a62(%rip), %rsi # 0xb58bf
jmp 0x72e78
leaq 0x47b2e(%rip), %rsi # 0xba994
jmp 0x72e78
leaq 0x42981(%rip), %rsi # 0xb57f0
jmp 0x72e78
leaq 0x43a74(%rip), %rsi # 0xb68ec
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x27852
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
| _ZN5minja13TemplateToken12typeToStringB5cxx11ENS0_4TypeE:
push rbx
sub rsp, 10h
mov rbx, rdi
cmp esi, 12h; switch 19 cases
ja def_72DB5; jumptable 0000000000072DB5 default case
mov eax, esi
lea rcx, jpt_72DB5
movsxd rax, ds:(jpt_72DB5 - 0B478Ch)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_72DB7:
lea rsi, aText; jumptable 0000000000072DB5 case 0
jmp loc_72E78
loc_72DC3:
lea rsi, aEndfilter; jumptable 0000000000072DB5 case 16
jmp loc_72E78
loc_72DCF:
lea rsi, aEndmacro; jumptable 0000000000072DB5 case 14
jmp loc_72E78
loc_72DDB:
lea rsi, aEndset; jumptable 0000000000072DB5 case 11
jmp loc_72E78
loc_72DE7:
lea rsi, aElif; jumptable 0000000000072DB5 case 4
jmp loc_72E78
loc_72DF3:
lea rsi, aComment; jumptable 0000000000072DB5 case 12
jmp short loc_72E78
loc_72DFC:
lea rsi, aEndgeneration; jumptable 0000000000072DB5 case 9
jmp short loc_72E78
loc_72E05:
lea rsi, aIf+1; jumptable 0000000000072DB5 case 2
jmp short loc_72E78
loc_72E0E:
lea rsi, aEndfilter+3; jumptable 0000000000072DB5 case 15
jmp short loc_72E78
loc_72E17:
lea rsi, aElse; jumptable 0000000000072DB5 case 3
jmp short loc_72E78
loc_72E20:
lea rsi, aEndfor; jumptable 0000000000072DB5 case 7
jmp short loc_72E78
loc_72E29:
lea rsi, aExpectedLeftSi_0+24h; jumptable 0000000000072DB5 case 1
jmp short loc_72E78
loc_72E32:
lea rsi, aBreak; jumptable 0000000000072DB5 case 17
jmp short loc_72E78
loc_72E3B:
lea rsi, aEndif; jumptable 0000000000072DB5 case 5
jmp short loc_72E78
loc_72E44:
lea rsi, aEndmacro+3; jumptable 0000000000072DB5 case 13
jmp short loc_72E78
loc_72E4D:
lea rsi, aEndfor+3; jumptable 0000000000072DB5 case 6
jmp short loc_72E78
loc_72E56:
lea rsi, aContinue; jumptable 0000000000072DB5 case 18
jmp short loc_72E78
loc_72E5F:
lea rsi, aAtLeastOneOfMi+2Fh; jumptable 0000000000072DB5 case 10
jmp short loc_72E78
loc_72E68:
lea rsi, aEndgeneration+3; jumptable 0000000000072DB5 case 8
jmp short loc_72E78
def_72DB5:
lea rsi, aUnknown; jumptable 0000000000072DB5 default case
loc_72E78:
lea rdx, [rsp+18h+var_9]
mov rdi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
mov rax, rbx
add rsp, 10h
pop rbx
retn
| _QWORD * minja::TemplateToken::typeToString[abi:cxx11](_QWORD *a1, int a2)
{
char *v2; // rsi
switch ( a2 )
{
case 0:
v2 = "text";
break;
case 1:
v2 = (char *)"expression";
break;
case 2:
v2 = "if";
break;
case 3:
v2 = "else";
break;
case 4:
v2 = "elif";
break;
case 5:
v2 = "endif";
break;
case 6:
v2 = "for";
break;
case 7:
v2 = "endfor";
break;
case 8:
v2 = "generation";
break;
case 9:
v2 = "endgeneration";
break;
case 10:
v2 = (char *)"set";
break;
case 11:
v2 = "endset";
break;
case 12:
v2 = "comment";
break;
case 13:
v2 = "macro";
break;
case 14:
v2 = "endmacro";
break;
case 15:
v2 = "filter";
break;
case 16:
v2 = "endfilter";
break;
case 17:
v2 = "break";
break;
case 18:
v2 = "continue";
break;
default:
v2 = "Unknown";
break;
}
std::string::basic_string<std::allocator<char>>(a1, (long long)v2);
return a1;
}
| typeToString[abi:cxx11]:
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
CMP ESI,0x12
JA 0x00172e71
MOV EAX,ESI
LEA RCX,[0x1b478c]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_0:
LEA RSI,[0x1b5525]
JMP 0x00172e78
caseD_10:
LEA RSI,[0x1b58af]
JMP 0x00172e78
caseD_e:
LEA RSI,[0x1b5882]
JMP 0x00172e78
caseD_b:
LEA RSI,[0x1b5858]
JMP 0x00172e78
caseD_4:
LEA RSI,[0x1b5762]
JMP 0x00172e78
caseD_c:
LEA RSI,[0x1b68e4]
JMP 0x00172e78
caseD_9:
LEA RSI,[0x1b57ed]
JMP 0x00172e78
caseD_2:
LEA RSI,[0x1ad6c9]
JMP 0x00172e78
caseD_f:
LEA RSI,[0x1b58b2]
JMP 0x00172e78
caseD_3:
LEA RSI,[0x1b5788]
JMP 0x00172e78
caseD_7:
LEA RSI,[0x1b57e6]
JMP 0x00172e78
caseD_1:
LEA RSI,[0x1b5959]
JMP 0x00172e78
caseD_11:
LEA RSI,[0x1b58b9]
JMP 0x00172e78
caseD_5:
LEA RSI,[0x1b578d]
JMP 0x00172e78
caseD_d:
LEA RSI,[0x1b5885]
JMP 0x00172e78
caseD_6:
LEA RSI,[0x1b57e9]
JMP 0x00172e78
caseD_12:
LEA RSI,[0x1b58bf]
JMP 0x00172e78
caseD_a:
LEA RSI,[0x1ba994]
JMP 0x00172e78
caseD_8:
LEA RSI,[0x1b57f0]
JMP 0x00172e78
default:
LEA RSI,[0x1b68ec]
LAB_00172e78:
LEA RDX,[RSP + 0xf]
MOV RDI,RBX
CALL 0x00127852
MOV RAX,RBX
ADD RSP,0x10
POP RBX
RET
|
/* minja::TemplateToken::typeToString[abi:cxx11](minja::TemplateToken::Type) */
TemplateToken * __thiscall
minja::TemplateToken::typeToString_abi_cxx11_(TemplateToken *this,int4 param_2)
{
char *pcVar1;
allocator local_9;
switch(param_2) {
case 0:
pcVar1 = "text";
break;
case 1:
pcVar1 = "expression";
break;
case 2:
pcVar1 = "if";
break;
case 3:
pcVar1 = "else";
break;
case 4:
pcVar1 = "elif";
break;
case 5:
pcVar1 = "endif";
break;
case 6:
pcVar1 = "for";
break;
case 7:
pcVar1 = "endfor";
break;
case 8:
pcVar1 = "generation";
break;
case 9:
pcVar1 = "endgeneration";
break;
case 10:
pcVar1 = "set";
break;
case 0xb:
pcVar1 = "endset";
break;
case 0xc:
pcVar1 = "comment";
break;
case 0xd:
pcVar1 = "macro";
break;
case 0xe:
pcVar1 = "endmacro";
break;
case 0xf:
pcVar1 = "filter";
break;
case 0x10:
pcVar1 = "endfilter";
break;
case 0x11:
pcVar1 = "break";
break;
case 0x12:
pcVar1 = "continue";
break;
default:
pcVar1 = "Unknown";
}
std::__cxx11::string::string<std::allocator<char>>((string *)this,pcVar1,&local_9);
return this;
}
| |
52,940 | CLI::detail::trim_copy(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | MikePodsytnik[P]TCRtrie/build_O1/_deps/cli11-src/include/CLI/StringTools.hpp | inline std::string trim_copy(const std::string &str) {
std::string s = str;
return trim(s);
} | O1 | cpp | CLI::detail::trim_copy(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x178c0
movq (%r14), %rax
movq 0x8(%r14), %rcx
addq %rax, %rcx
leaq 0x38(%rsp), %rsi
movq %rcx, (%rsi)
leaq 0x30(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x28(%rsp), %rdi
callq 0x1b10c
movq 0x28(%rsp), %rax
movq %rax, %rcx
subq 0x8(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movb $0x0, (%rax)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq %rdi, %rsi
callq 0x1afc9
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rdx
addq %rcx, %rdx
cmpq %rax, %rdx
je 0x1af5b
subq %rcx, %rax
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0x74e0
jmp 0x1af67
movq $0x0, 0x10(%rsp)
movb $0x0, (%rcx)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x178c0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1af9a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7430
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1afc1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7430
movq %rbx, %rdi
callq 0x7780
| _ZN3CLI6detail9trim_copyERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r15
push r14
push rbx
sub rsp, 40h
mov rbx, rdi
lea r15, [rsp+58h+var_40]
mov [r15-10h], r15
mov rax, [rsi]
mov rdx, [rsi+8]
add rdx, rax
lea r14, [rsp+58h+var_50]
mov rdi, r14
mov rsi, rax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
mov rax, [r14]
mov rcx, [r14+8]
add rcx, rax
lea rsi, [rsp+58h+var_20]
mov [rsi], rcx
lea rdx, [rsp+58h+var_28]
mov [rdx], rax
lea rdi, [rsp+58h+var_30]
call _ZSt9__find_ifISt16reverse_iteratorIN9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEENS1_5__ops10_Iter_predIZN3CLI6detail5rtrimERS9_EUlcE_EEET_SJ_SJ_T0_St26random_access_iterator_tag; std::__find_if<std::reverse_iterator<__gnu_cxx::__normal_iterator<char *,std::string>>,__gnu_cxx::__ops::_Iter_pred<CLI::detail::rtrim(std::string&)::{lambda(char)#1}>>(std::reverse_iterator<__gnu_cxx::__normal_iterator<char *,std::string>>,std::reverse_iterator<__gnu_cxx::__normal_iterator<char *,std::string>>,__gnu_cxx::__ops::_Iter_pred<CLI::detail::rtrim(std::string&)::{lambda(char)#1}>,std::random_access_iterator_tag)
mov rax, [rsp+58h+var_30]
mov rcx, rax
sub rcx, [rsp+58h+var_50]
mov [rsp+58h+var_48], rcx
mov byte ptr [rax], 0
mov rdi, [rsp+58h+var_50]
mov rsi, [rsp+58h+var_48]
add rsi, rdi
call _ZSt9__find_ifIN9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEENS0_5__ops10_Iter_predIZN3CLI6detail5ltrimERS8_EUlcE_EEET_SH_SH_T0_St26random_access_iterator_tag; std::__find_if<__gnu_cxx::__normal_iterator<char *,std::string>,__gnu_cxx::__ops::_Iter_pred<CLI::detail::ltrim(std::string&)::{lambda(char)#1}>>(__gnu_cxx::__normal_iterator<char *,std::string>,__gnu_cxx::__normal_iterator<char *,std::string>,__gnu_cxx::__ops::_Iter_pred<CLI::detail::ltrim(std::string&)::{lambda(char)#1}>,std::random_access_iterator_tag)
mov rcx, [rsp+58h+var_50]
mov rdx, [rsp+58h+var_48]
add rdx, rcx
cmp rdx, rax
jz short loc_1AF5B
sub rax, rcx
lea rdi, [rsp+58h+var_50]
xor esi, esi
mov rdx, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE8_M_eraseEmm; std::string::_M_erase(ulong,ulong)
jmp short loc_1AF67
loc_1AF5B:
mov [rsp+58h+var_48], 0
mov byte ptr [rcx], 0
loc_1AF67:
lea rax, [rbx+10h]
mov [rbx], rax
mov rsi, [rsp+58h+var_50]
mov rdx, [rsp+58h+var_48]
add rdx, rsi
mov rdi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
mov rdi, [rsp+58h+var_50]; void *
cmp rdi, r15
jz short loc_1AF9A
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1AF9A:
mov rax, rbx
add rsp, 40h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
mov rdi, [rsp+arg_0]; void *
cmp rdi, r15
jz short loc_1AFC1
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1AFC1:
mov rdi, rbx
call __Unwind_Resume
| _QWORD * CLI::detail::trim_copy(_QWORD *a1, long long a2)
{
_BYTE *v2; // rax
void *v4; // [rsp+8h] [rbp-50h] BYREF
long long v5; // [rsp+10h] [rbp-48h]
_QWORD v6[2]; // [rsp+18h] [rbp-40h] BYREF
_BYTE *v7; // [rsp+28h] [rbp-30h] BYREF
void *v8; // [rsp+30h] [rbp-28h] BYREF
char *v9; // [rsp+38h] [rbp-20h] BYREF
v4 = v6;
std::string::_M_construct<char *>(&v4, *(_BYTE **)a2, *(_QWORD *)a2 + *(_QWORD *)(a2 + 8));
v9 = (char *)v4 + v5;
v8 = v4;
std::__find_if<std::reverse_iterator<__gnu_cxx::__normal_iterator<char *,std::string>>,__gnu_cxx::__ops::_Iter_pred<CLI::detail::rtrim(std::string&)::{lambda(char)#1}>>(
&v7,
&v9,
&v8);
v5 = v7 - (_BYTE *)v4;
*v7 = 0;
v2 = (_BYTE *)std::__find_if<__gnu_cxx::__normal_iterator<char *,std::string>,__gnu_cxx::__ops::_Iter_pred<CLI::detail::ltrim(std::string&)::{lambda(char)#1}>>(
v4,
(char *)v4 + v5);
if ( (char *)v4 + v5 == v2 )
{
v5 = 0LL;
*(_BYTE *)v4 = 0;
}
else
{
std::string::_M_erase(&v4, 0LL, v2 - (_BYTE *)v4);
}
*a1 = a1 + 2;
std::string::_M_construct<char *>(a1, v4, (long long)v4 + v5);
if ( v4 != v6 )
operator delete(v4, v6[0] + 1LL);
return a1;
}
| trim_copy:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV RBX,RDI
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x10],R15
MOV RAX,qword ptr [RSI]
MOV RDX,qword ptr [RSI + 0x8]
ADD RDX,RAX
LEA R14,[RSP + 0x8]
MOV RDI,R14
MOV RSI,RAX
CALL 0x001178c0
MOV RAX,qword ptr [R14]
MOV RCX,qword ptr [R14 + 0x8]
ADD RCX,RAX
LEA RSI,[RSP + 0x38]
MOV qword ptr [RSI],RCX
LEA RDX,[RSP + 0x30]
MOV qword ptr [RDX],RAX
LAB_0011af04:
LEA RDI,[RSP + 0x28]
CALL 0x0011b10c
MOV RAX,qword ptr [RSP + 0x28]
MOV RCX,RAX
SUB RCX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x10],RCX
MOV byte ptr [RAX],0x0
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x10]
ADD RSI,RDI
CALL 0x0011afc9
MOV RCX,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
ADD RDX,RCX
CMP RDX,RAX
JZ 0x0011af5b
SUB RAX,RCX
LEA RDI,[RSP + 0x8]
XOR ESI,ESI
MOV RDX,RAX
CALL 0x001074e0
JMP 0x0011af67
LAB_0011af5b:
MOV qword ptr [RSP + 0x10],0x0
MOV byte ptr [RCX],0x0
LAB_0011af67:
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
ADD RDX,RSI
MOV RDI,RBX
CALL 0x001178c0
LAB_0011af83:
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R15
JZ 0x0011af9a
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x00107430
LAB_0011af9a:
MOV RAX,RBX
ADD RSP,0x40
POP RBX
POP R14
POP R15
RET
|
/* CLI::detail::trim_copy(std::__cxx11::string const&) */
detail * __thiscall CLI::detail::trim_copy(detail *this,string *param_1)
{
int1 *puVar1;
long *local_50;
long local_48;
long local_40 [2];
int1 *local_30;
long *local_28;
int1 *local_20;
local_50 = local_40;
std::__cxx11::string::_M_construct<char*>
(&local_50,*(long *)param_1,*(long *)(param_1 + 8) + *(long *)param_1);
local_20 = (int1 *)(local_48 + (long)local_50);
local_28 = local_50;
/* try { // try from 0011af04 to 0011af82 has its CatchHandler @ 0011afa7 */
std::
__find_if<std::reverse_iterator<__gnu_cxx::__normal_iterator<char*,std::__cxx11::string>>,__gnu_cxx::__ops::_Iter_pred<CLI::detail::rtrim(std::__cxx11::string&)::_lambda(char)_1_>>
(&local_30);
local_48 = (long)local_30 - (long)local_50;
*local_30 = 0;
puVar1 = (int1 *)
std::
__find_if<__gnu_cxx::__normal_iterator<char*,std::__cxx11::string>,__gnu_cxx::__ops::_Iter_pred<CLI::detail::ltrim(std::__cxx11::string&)::_lambda(char)_1_>>
();
if ((int1 *)(local_48 + (long)local_50) == puVar1) {
local_48 = 0;
*(int1 *)local_50 = 0;
}
else {
std::__cxx11::string::_M_erase((ulong)&local_50,0);
}
*(detail **)this = this + 0x10;
std::__cxx11::string::_M_construct<char*>(this,local_50,(int1 *)(local_48 + (long)local_50))
;
if (local_50 != local_40) {
operator_delete(local_50,local_40[0] + 1);
}
return this;
}
| |
52,941 | 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>>>>>::get_token_string() const | monkey531[P]llama/common/json.hpp | std::string get_token_string() const
{
// escape control characters
std::string result;
for (const auto c : token_string)
{
if (static_cast<unsigned char>(c) <= '\x1F')
{
// escape control characters
std::array<char, 9> cs{{}};
static_cast<void>((std::snprintf)(cs.data(), cs.size(), "<U+%.4X>", static_cast<unsigned char>(c))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
result += cs.data();
}
else
{
// add character as is
result.push_back(static_cast<std::string::value_type>(c));
}
}
return result;
} | O0 | 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>>>>>::get_token_string() const:
subq $0x78, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
movb $0x0, 0x67(%rsp)
callq 0x5e600
movq 0x20(%rsp), %rax
addq $0x38, %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdi
callq 0x888c0
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rdi
callq 0x888f0
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x88ed0
testb $0x1, %al
jne 0xe1ba3
jmp 0xe1c5b
leaq 0x50(%rsp), %rdi
callq 0x88f10
movb (%rax), %al
movb %al, 0x47(%rsp)
movzbl 0x47(%rsp), %eax
cmpl $0x1f, %eax
jg 0xe1c37
movb $0x0, 0x40(%rsp)
movq $0x0, 0x38(%rsp)
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xf36e0
movq 0x8(%rsp), %rdi
movq %rax, (%rsp)
callq 0xf36f0
movq (%rsp), %rdi
movq %rax, %rsi
movzbl 0x47(%rsp), %ecx
leaq 0x13b82e(%rip), %rdx # 0x21d429
xorl %eax, %eax
callq 0x5e930
movq 0x8(%rsp), %rdi
callq 0xf36e0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x5e230
jmp 0xe1c1b
jmp 0xe1c4a
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x5f5d8
jmp 0xe1c7b
movq 0x10(%rsp), %rdi
movsbl 0x47(%rsp), %esi
callq 0x5f4c0
jmp 0xe1c48
jmp 0xe1c4a
jmp 0xe1c4c
leaq 0x50(%rsp), %rdi
callq 0x88ff0
jmp 0xe1b8b
movb $0x1, 0x67(%rsp)
testb $0x1, 0x67(%rsp)
jne 0xe1c71
movq 0x10(%rsp), %rdi
callq 0x5f5d8
movq 0x18(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x5ebf0
nopw %cs:(%rax,%rax)
nop
| _ZNK8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE16get_token_stringEv:
sub rsp, 78h
mov [rsp+78h+var_68], rdi
mov rax, rdi
mov [rsp+78h+var_60], rax
mov [rsp+78h+var_8], rdi
mov [rsp+78h+var_10], rsi
mov rax, [rsp+78h+var_10]
mov [rsp+78h+var_58], rax
mov [rsp+78h+var_11], 0
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev; std::string::basic_string(void)
mov rax, [rsp+78h+var_58]
add rax, 38h ; '8'
mov [rsp+78h+var_20], rax
mov rdi, [rsp+78h+var_20]
call _ZNKSt6vectorIcSaIcEE5beginEv; std::vector<char>::begin(void)
mov [rsp+78h+var_28], rax
mov rdi, [rsp+78h+var_20]
call _ZNKSt6vectorIcSaIcEE3endEv; std::vector<char>::end(void)
mov [rsp+78h+var_30], rax
loc_E1B8B:
lea rdi, [rsp+78h+var_28]
lea rsi, [rsp+78h+var_30]
call _ZN9__gnu_cxxneIPKcSt6vectorIcSaIcEEEEbRKNS_17__normal_iteratorIT_T0_EESB_; __gnu_cxx::operator!=<char const*,std::vector<char>>(__gnu_cxx::__normal_iterator<char const*,std::vector<char>> const&,__gnu_cxx::__normal_iterator<char const*,std::vector<char>> const&)
test al, 1
jnz short loc_E1BA3
jmp loc_E1C5B
loc_E1BA3:
lea rdi, [rsp+78h+var_28]
call _ZNK9__gnu_cxx17__normal_iteratorIPKcSt6vectorIcSaIcEEEdeEv; __gnu_cxx::__normal_iterator<char const*,std::vector<char>>::operator*(void)
mov al, [rax]
mov [rsp+78h+var_31], al
movzx eax, [rsp+78h+var_31]
cmp eax, 1Fh
jg short loc_E1C37
mov [rsp+78h+var_38], 0
mov [rsp+78h+var_40], 0
lea rdi, [rsp+78h+var_40]
mov [rsp+78h+var_70], rdi
call _ZNSt5arrayIcLm9EE4dataEv; std::array<char,9ul>::data(void)
mov rdi, [rsp+78h+var_70]
mov [rsp+78h+var_78], rax
call _ZNKSt5arrayIcLm9EE4sizeEv; std::array<char,9ul>::size(void)
mov rdi, [rsp+78h+var_78]
mov rsi, rax
movzx ecx, [rsp+78h+var_31]
lea rdx, aU4x; "<U+%.4X>"
xor eax, eax
call _snprintf
mov rdi, [rsp+78h+var_70]
call _ZNSt5arrayIcLm9EE4dataEv; std::array<char,9ul>::data(void)
mov rdi, [rsp+78h+var_68]
mov rsi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEpLEPKc; std::string::operator+=(char const*)
jmp short $+2
loc_E1C1B:
jmp short loc_E1C4A
mov rdi, [rsp+arg_8]; void *
mov rcx, rax
mov eax, edx
mov [rsp+arg_28], rcx
mov [rsp+arg_24], eax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_E1C7B
loc_E1C37:
mov rdi, [rsp+78h+var_68]
movsx esi, [rsp+78h+var_31]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
jmp short $+2
loc_E1C48:
jmp short $+2
loc_E1C4A:
jmp short $+2
loc_E1C4C:
lea rdi, [rsp+78h+var_28]
call _ZN9__gnu_cxx17__normal_iteratorIPKcSt6vectorIcSaIcEEEppEv; __gnu_cxx::__normal_iterator<char const*,std::vector<char>>::operator++(void)
jmp loc_E1B8B
loc_E1C5B:
mov [rsp+78h+var_11], 1
test [rsp+78h+var_11], 1
jnz short loc_E1C71
mov rdi, [rsp+78h+var_68]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_E1C71:
mov rax, [rsp+78h+var_60]
add rsp, 78h
retn
loc_E1C7B:
mov rdi, [rsp+arg_28]
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get_token_string(
long long a1,
long long a2)
{
long long v2; // rax
long long v3; // rax
long long v5; // [rsp+0h] [rbp-78h]
long long v6; // [rsp+38h] [rbp-40h] BYREF
char v7; // [rsp+40h] [rbp-38h]
unsigned __int8 v8; // [rsp+47h] [rbp-31h]
long long v9; // [rsp+48h] [rbp-30h] BYREF
_QWORD v10[2]; // [rsp+50h] [rbp-28h] BYREF
char v11; // [rsp+67h] [rbp-11h]
long long v12; // [rsp+68h] [rbp-10h]
long long v13; // [rsp+70h] [rbp-8h]
v13 = a1;
v12 = a2;
v11 = 0;
std::string::basic_string(a1);
v10[1] = a2 + 56;
v10[0] = std::vector<char>::begin((_QWORD *)(a2 + 56));
v9 = std::vector<char>::end(a2 + 56);
while ( __gnu_cxx::operator!=<char const*,std::vector<char>>((long long)v10, (long long)&v9) )
{
v8 = *(_BYTE *)__gnu_cxx::__normal_iterator<char const*,std::vector<char>>::operator*((long long)v10);
if ( v8 > 0x1Fu )
{
std::string::push_back(a1, (unsigned int)(char)v8);
}
else
{
v7 = 0;
v6 = 0LL;
v5 = ((long long (*)(void))std::array<char,9ul>::data)();
v2 = std::array<char,9ul>::size(&v6);
snprintf(v5, v2, "<U+%.4X>", v8);
v3 = std::array<char,9ul>::data(&v6);
std::string::operator+=(a1, v3);
}
__gnu_cxx::__normal_iterator<char const*,std::vector<char>>::operator++(v10);
}
return a1;
}
| get_token_string:
SUB RSP,0x78
MOV qword ptr [RSP + 0x10],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x70],RDI
MOV qword ptr [RSP + 0x68],RSI
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RSP + 0x20],RAX
MOV byte ptr [RSP + 0x67],0x0
CALL 0x0015e600
MOV RAX,qword ptr [RSP + 0x20]
ADD RAX,0x38
MOV qword ptr [RSP + 0x58],RAX
MOV RDI,qword ptr [RSP + 0x58]
CALL 0x001888c0
MOV qword ptr [RSP + 0x50],RAX
MOV RDI,qword ptr [RSP + 0x58]
CALL 0x001888f0
MOV qword ptr [RSP + 0x48],RAX
LAB_001e1b8b:
LEA RDI,[RSP + 0x50]
LEA RSI,[RSP + 0x48]
CALL 0x00188ed0
TEST AL,0x1
JNZ 0x001e1ba3
JMP 0x001e1c5b
LAB_001e1ba3:
LEA RDI,[RSP + 0x50]
CALL 0x00188f10
MOV AL,byte ptr [RAX]
MOV byte ptr [RSP + 0x47],AL
MOVZX EAX,byte ptr [RSP + 0x47]
CMP EAX,0x1f
JG 0x001e1c37
MOV byte ptr [RSP + 0x40],0x0
MOV qword ptr [RSP + 0x38],0x0
LEA RDI,[RSP + 0x38]
MOV qword ptr [RSP + 0x8],RDI
CALL 0x001f36e0
MOV RDI,qword ptr [RSP + 0x8]
MOV qword ptr [RSP],RAX
CALL 0x001f36f0
MOV RDI,qword ptr [RSP]
MOV RSI,RAX
MOVZX ECX,byte ptr [RSP + 0x47]
LEA RDX,[0x31d429]
XOR EAX,EAX
CALL 0x0015e930
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x001f36e0
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,RAX
LAB_001e1c14:
CALL 0x0015e230
JMP 0x001e1c1b
LAB_001e1c1b:
JMP 0x001e1c4a
LAB_001e1c37:
MOV RDI,qword ptr [RSP + 0x10]
MOVSX ESI,byte ptr [RSP + 0x47]
CALL 0x0015f4c0
LAB_001e1c46:
JMP 0x001e1c48
LAB_001e1c48:
JMP 0x001e1c4a
LAB_001e1c4a:
JMP 0x001e1c4c
LAB_001e1c4c:
LEA RDI,[RSP + 0x50]
CALL 0x00188ff0
JMP 0x001e1b8b
LAB_001e1c5b:
MOV byte ptr [RSP + 0x67],0x1
TEST byte ptr [RSP + 0x67],0x1
JNZ 0x001e1c71
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x0015f5d8
LAB_001e1c71:
MOV RAX,qword ptr [RSP + 0x18]
ADD RSP,0x78
RET
|
/* WARNING: Removing unreachable block (ram,0x001e1c67) */
/* 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 > > >::get_token_string() const */
string * 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>>>
::get_token_string(void)
{
bool bVar1;
byte *pbVar2;
char *pcVar3;
size_t __maxlen;
long in_RSI;
string *in_RDI;
int8 local_40;
int1 local_38;
byte local_31;
int8 local_30;
int8 local_28;
vector<char,std::allocator<char>> *local_20;
int1 local_11;
local_11 = 0;
std::__cxx11::string::string(in_RDI);
local_20 = (vector<char,std::allocator<char>> *)(in_RSI + 0x38);
local_28 = std::vector<char,std::allocator<char>>::begin(local_20);
local_30 = std::vector<char,std::allocator<char>>::end(local_20);
while (bVar1 = __gnu_cxx::operator!=
((__normal_iterator *)&local_28,(__normal_iterator *)&local_30), bVar1) {
pbVar2 = (byte *)__gnu_cxx::
__normal_iterator<char_const*,std::vector<char,std::allocator<char>>>::
operator*((__normal_iterator<char_const*,std::vector<char,std::allocator<char>>>
*)&local_28);
local_31 = *pbVar2;
if (local_31 < 0x20) {
local_38 = 0;
local_40 = 0;
pcVar3 = (char *)std::array<char,9ul>::data((array<char,9ul> *)&local_40);
__maxlen = std::array<char,9ul>::size();
snprintf(pcVar3,__maxlen,"<U+%.4X>",(ulong)local_31);
pcVar3 = (char *)std::array<char,9ul>::data((array<char,9ul> *)&local_40);
/* try { // try from 001e1c14 to 001e1c45 has its CatchHandler @ 001e1c1d */
std::__cxx11::string::operator+=(in_RDI,pcVar3);
}
else {
std::__cxx11::string::push_back((char)in_RDI);
}
__gnu_cxx::__normal_iterator<char_const*,std::vector<char,std::allocator<char>>>::operator++
((__normal_iterator<char_const*,std::vector<char,std::allocator<char>>> *)&local_28);
}
return in_RDI;
}
| |
52,942 | 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>>>>>::get_token_string() const | monkey531[P]llama/common/json.hpp | std::string get_token_string() const
{
// escape control characters
std::string result;
for (const auto c : token_string)
{
if (static_cast<unsigned char>(c) <= '\x1F')
{
// escape control characters
std::array<char, 9> cs{{}};
static_cast<void>((std::snprintf)(cs.data(), cs.size(), "<U+%.4X>", static_cast<unsigned char>(c))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
result += cs.data();
}
else
{
// add character as is
result.push_back(static_cast<std::string::value_type>(c));
}
}
return result;
} | 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>>>>>::get_token_string() const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x38(%rsi), %r13
movq 0x40(%rsi), %rbp
cmpq %rbp, %r13
je 0x6d0dd
leaq 0x88de0(%rip), %r14 # 0xf5e6e
leaq 0x8(%rsp), %r15
movzbl (%r13), %ecx
cmpl $0x1f, %ecx
ja 0x6d0ca
movb $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movl $0x9, %esi
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1be30
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1c160
jmp 0x6d0d5
movsbl %cl, %esi
movq %rbx, %rdi
callq 0x1b7a0
incq %r13
cmpq %rbp, %r13
jne 0x6d093
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6d0f1
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x6d108
movq (%r12), %rsi
incq %rsi
callq 0x1b910
movq %r14, %rdi
callq 0x1bff0
| _ZNK8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE16get_token_stringEv:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rdi
lea r12, [rdi+10h]
mov [rdi], r12
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
mov r13, [rsi+38h]
mov rbp, [rsi+40h]
cmp r13, rbp
jz short loc_6D0DD
lea r14, aU4x; "<U+%.4X>"
lea r15, [rsp+48h+var_40]
loc_6D093:
movzx ecx, byte ptr [r13+0]
cmp ecx, 1Fh
ja short loc_6D0CA
mov [rsp+48h+var_38], 0
mov [rsp+48h+var_40], 0
mov esi, 9
mov rdi, r15
mov rdx, r14
xor eax, eax
call _snprintf
mov rdi, rbx
mov rsi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
jmp short loc_6D0D5
loc_6D0CA:
movsx esi, cl
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
loc_6D0D5:
inc r13
cmp r13, rbp
jnz short loc_6D093
loc_6D0DD:
mov rax, rbx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short $+2
loc_6D0F1:
mov r14, rax
mov rdi, [rbx]; void *
cmp rdi, r12
jz short loc_6D108
mov rsi, [r12]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_6D108:
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get_token_string(
long long a1,
long long a2,
long long a3)
{
unsigned __int8 *v3; // r13
unsigned __int8 *i; // rbp
long long v5; // rcx
long long v7; // [rsp+8h] [rbp-40h] BYREF
char v8; // [rsp+10h] [rbp-38h]
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
v3 = *(unsigned __int8 **)(a2 + 56);
for ( i = *(unsigned __int8 **)(a2 + 64); v3 != i; ++v3 )
{
v5 = *v3;
if ( (unsigned int)v5 > 0x1F )
{
std::string::push_back(a1, (unsigned int)(char)v5, a3, v5);
}
else
{
v8 = 0;
v7 = 0LL;
snprintf(&v7, 9LL, "<U+%.4X>", v5);
std::string::append(a1, &v7);
}
}
return a1;
}
| get_token_string:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
LEA R12,[RDI + 0x10]
MOV qword ptr [RDI],R12
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
MOV R13,qword ptr [RSI + 0x38]
MOV RBP,qword ptr [RSI + 0x40]
CMP R13,RBP
JZ 0x0016d0dd
LEA R14,[0x1f5e6e]
LEA R15,[RSP + 0x8]
LAB_0016d093:
MOVZX ECX,byte ptr [R13]
CMP ECX,0x1f
JA 0x0016d0ca
MOV byte ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x8],0x0
MOV ESI,0x9
MOV RDI,R15
MOV RDX,R14
XOR EAX,EAX
CALL 0x0011be30
LAB_0016d0bd:
MOV RDI,RBX
MOV RSI,R15
CALL 0x0011c160
JMP 0x0016d0d5
LAB_0016d0ca:
MOVSX ESI,CL
MOV RDI,RBX
CALL 0x0011b7a0
LAB_0016d0d5:
INC R13
CMP R13,RBP
JNZ 0x0016d093
LAB_0016d0dd:
MOV RAX,RBX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
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 > > >::get_token_string() const */
void 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>>>
::get_token_string(void)
{
byte *pbVar1;
long in_RSI;
long *in_RDI;
byte *pbVar2;
char local_40 [16];
*in_RDI = (long)(in_RDI + 2);
in_RDI[1] = 0;
*(int1 *)(in_RDI + 2) = 0;
pbVar2 = *(byte **)(in_RSI + 0x38);
pbVar1 = *(byte **)(in_RSI + 0x40);
if (pbVar2 != pbVar1) {
do {
if (*pbVar2 < 0x20) {
local_40[8] = 0;
local_40[0] = '\0';
local_40[1] = '\0';
local_40[2] = '\0';
local_40[3] = '\0';
local_40[4] = '\0';
local_40[5] = '\0';
local_40[6] = '\0';
local_40[7] = '\0';
snprintf(local_40,9,"<U+%.4X>");
/* try { // try from 0016d0bd to 0016d0c7 has its CatchHandler @ 0016d0f1 */
std::__cxx11::string::append((char *)in_RDI);
}
else {
/* try { // try from 0016d0ca to 0016d0d4 has its CatchHandler @ 0016d0ef */
std::__cxx11::string::push_back((char)in_RDI);
}
pbVar2 = pbVar2 + 1;
} while (pbVar2 != pbVar1);
}
return;
}
| |
52,943 | 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 0x8377b
movl (%r15), %r12d
decl %eax
movl %eax, 0x4(%r15)
btl %eax, %r12d
jae 0x83798
subq %r14, %rbx
jmp 0x83815
movq %r15, %rdi
callq 0x8222d
movl $0x1f, 0x4(%r15)
movl (%r15), %r12d
movl $0x1f, %eax
testl %r12d, %r12d
js 0x83773
movq %r13, %rdx
movl 0x1c(%r13), %r13d
movl %eax, %ecx
subl %r13d, %ecx
movq %rdx, -0x30(%rbp)
jae 0x837e4
subl %eax, %r13d
movl %eax, %eax
leaq 0x5e0ba(%rip), %rcx # 0xe1870
andl (%rcx,%rax,4), %r12d
movl %r13d, %ecx
shll %cl, %r12d
movq %r15, %rdi
callq 0x8222d
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 0x837f9
movl %ecx, 0x4(%r15)
shrl %cl, %r12d
movl 0x1c(%rdx), %eax
leaq 0x5e07b(%rip), %rcx # 0xe1870
andl (%rcx,%rax,4), %r12d
movl %r12d, %r13d
subq %r14, %rbx
movq 0x18(%r15), %rdx
leaq (%rdx,%r13), %rcx
cmpq 0x20(%r15), %rcx
jbe 0x83830
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 0x292a0
addl $-0x8, %ebx
movq -0x30(%rbp), %rdi
movq %r15, %rsi
callq 0x82b1e
movq %r14, %rdi
movl %ebx, %esi
movl %r13d, %edx
callq 0x78f0b
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_8377B
mov r12d, [r15]
dec eax
mov [r15+4], eax
bt r12d, eax
jnb short loc_83798
loc_83773:
sub rbx, r14
jmp loc_83815
loc_8377B:
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_83773
loc_83798:
mov rdx, r13
mov r13d, [r13+1Ch]
mov ecx, eax
sub ecx, r13d
mov [rbp+var_30], rdx
jnb short loc_837E4
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_837F9
loc_837E4:
mov [r15+4], ecx
shr r12d, cl
mov eax, [rdx+1Ch]
lea rcx, mask_0
and r12d, [rcx+rax*4]
loc_837F9:
mov r13d, r12d
sub rbx, r14
mov rdx, [r15+18h]
lea rcx, [rdx+r13]
cmp rcx, [r15+20h]
jbe short loc_83830
mov dword ptr [r15+28h], 1
loc_83815:
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_83830:
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 0x0018377b
MOV R12D,dword ptr [R15]
DEC EAX
MOV dword ptr [R15 + 0x4],EAX
BT R12D,EAX
JNC 0x00183798
LAB_00183773:
SUB RBX,R14
JMP 0x00183815
LAB_0018377b:
MOV RDI,R15
CALL 0x0018222d
MOV dword ptr [R15 + 0x4],0x1f
MOV R12D,dword ptr [R15]
MOV EAX,0x1f
TEST R12D,R12D
JS 0x00183773
LAB_00183798:
MOV RDX,R13
MOV R13D,dword ptr [R13 + 0x1c]
MOV ECX,EAX
SUB ECX,R13D
MOV qword ptr [RBP + -0x30],RDX
JNC 0x001837e4
SUB R13D,EAX
MOV EAX,EAX
LEA RCX,[0x1e1870]
AND R12D,dword ptr [RCX + RAX*0x4]
MOV ECX,R13D
SHL R12D,CL
MOV RDI,R15
CALL 0x0018222d
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 0x001837f9
LAB_001837e4:
MOV dword ptr [R15 + 0x4],ECX
SHR R12D,CL
MOV EAX,dword ptr [RDX + 0x1c]
LEA RCX,[0x1e1870]
AND R12D,dword ptr [RCX + RAX*0x4]
LAB_001837f9:
MOV R13D,R12D
SUB RBX,R14
MOV RDX,qword ptr [R15 + 0x18]
LEA RCX,[RDX + R13*0x1]
CMP RCX,qword ptr [R15 + 0x20]
JBE 0x00183830
MOV dword ptr [R15 + 0x28],0x1
LAB_00183815:
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 0x001292a0
LAB_00183830:
ADD EBX,-0x8
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,R15
CALL 0x00182b1e
MOV RDI,R14
MOV ESI,EBX
MOV EDX,R13D
CALL 0x00178f0b
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_00183798;
}
else {
uVar5 = *param_2;
uVar3 = param_2[1] - 1;
param_2[1] = uVar3;
if ((uVar5 >> (uVar3 & 0x1f) & 1) == 0) {
LAB_00183798:
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_00183815;
}
}
__n = param_4 - (long)param_3;
LAB_00183815:
memset(param_3,0,__n);
return;
}
| |
52,944 | psi_prlock_wrlock | eloqsql/mysys/my_thr_init.c | ATTRIBUTE_COLD
int psi_prlock_wrlock(mysql_prlock_t *that, const char *file, uint line)
{
PSI_rwlock_locker_state state;
PSI_rwlock_locker *locker= PSI_RWLOCK_CALL(start_rwlock_wrwait)
(&state, that->m_psi, PSI_RWLOCK_WRITELOCK, file, line);
int result= rw_pr_wrlock(&that->m_prlock);
if (locker)
PSI_RWLOCK_CALL(end_rwlock_wrwait)(locker, result);
return result;
} | O3 | c | psi_prlock_wrlock:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %edx, %r8d
movq %rsi, %rcx
movq %rdi, %r14
leaq 0x2d1ef9(%rip), %r15 # 0x2f68a8
movq (%r15), %rax
movq 0x68(%rdi), %rsi
leaq -0x48(%rbp), %rdi
pushq $0x1
popq %rdx
callq *0x1b0(%rax)
movq %rax, %rbx
movq %r14, %rdi
callq 0x2cb55
movl %eax, %r14d
testq %rbx, %rbx
je 0x249e5
movq (%r15), %rax
movq %rbx, %rdi
movl %r14d, %esi
callq *0x1b8(%rax)
movl %r14d, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| psi_prlock_wrlock:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 38h
mov r8d, edx
mov rcx, rsi
mov r14, rdi
lea r15, PSI_server
mov rax, [r15]
mov rsi, [rdi+68h]
lea rdi, [rbp+var_48]
push 1
pop rdx
call qword ptr [rax+1B0h]
mov rbx, rax
mov rdi, r14
call rw_pr_wrlock
mov r14d, eax
test rbx, rbx
jz short loc_249E5
mov rax, [r15]
mov rdi, rbx
mov esi, r14d
call qword ptr [rax+1B8h]
loc_249E5:
mov eax, r14d
add rsp, 38h
pop rbx
pop r14
pop r15
pop rbp
retn
| long long psi_prlock_wrlock(long long a1, long long a2, unsigned int a3)
{
long long v3; // rbx
unsigned int v4; // r14d
_BYTE v6[72]; // [rsp+8h] [rbp-48h] BYREF
v3 = (*((long long ( **)(_BYTE *, _QWORD, long long, long long, _QWORD))PSI_server[0] + 54))(
v6,
*(_QWORD *)(a1 + 104),
1LL,
a2,
a3);
v4 = rw_pr_wrlock(a1);
if ( v3 )
(*((void ( **)(long long, _QWORD))PSI_server[0] + 55))(v3, v4);
return v4;
}
| psi_prlock_wrlock:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x38
MOV R8D,EDX
MOV RCX,RSI
MOV R14,RDI
LEA R15,[0x3f68a8]
MOV RAX,qword ptr [R15]
MOV RSI,qword ptr [RDI + 0x68]
LEA RDI,[RBP + -0x48]
PUSH 0x1
POP RDX
CALL qword ptr [RAX + 0x1b0]
MOV RBX,RAX
MOV RDI,R14
CALL 0x0012cb55
MOV R14D,EAX
TEST RBX,RBX
JZ 0x001249e5
MOV RAX,qword ptr [R15]
MOV RDI,RBX
MOV ESI,R14D
CALL qword ptr [RAX + 0x1b8]
LAB_001249e5:
MOV EAX,R14D
ADD RSP,0x38
POP RBX
POP R14
POP R15
POP RBP
RET
|
int4 psi_prlock_wrlock(long param_1,int8 param_2,int4 param_3)
{
int4 uVar1;
long lVar2;
int1 local_50 [48];
lVar2 = (**(code **)(PSI_server + 0x1b0))
(local_50,*(int8 *)(param_1 + 0x68),1,param_2,param_3);
uVar1 = rw_pr_wrlock(param_1);
if (lVar2 != 0) {
(**(code **)(PSI_server + 0x1b8))(lVar2,uVar1);
}
return uVar1;
}
| |
52,945 | fmt::v8::detail::iterator_buffer<std::back_insert_iterator<fmt::v8::basic_memory_buffer<char, 250ul, std::allocator<char>>>, char, fmt::v8::detail::buffer_traits>::grow(unsigned long) | aimrt_mujoco_sim/_deps/spdlog_lib-src/include/spdlog/fmt/bundled/core.h | void grow(size_t capacity) final FMT_OVERRIDE {
container_.resize(capacity);
this->set(&container_[0], capacity);
} | O3 | c | fmt::v8::detail::iterator_buffer<std::back_insert_iterator<fmt::v8::basic_memory_buffer<char, 250ul, std::allocator<char>>>, char, fmt::v8::detail::buffer_traits>::grow(unsigned long):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %r15
movq 0x18(%r15), %rax
movq %r15, %rcx
cmpq %rsi, %rax
jae 0x3e620
movq (%r15), %rax
movq %r15, %rdi
movq %rbx, %rsi
callq *(%rax)
movq 0x18(%r15), %rax
movq 0x20(%r14), %rcx
cmpq %rbx, %rax
cmovaeq %rbx, %rax
movq %rax, 0x10(%r15)
movq 0x8(%rcx), %rax
movq %rax, 0x8(%r14)
movq %rbx, 0x18(%r14)
popq %rbx
popq %r14
popq %r15
retq
nop
| _ZN3fmt2v86detail15iterator_bufferISt20back_insert_iteratorINS0_19basic_memory_bufferIcLm250ESaIcEEEEcNS1_13buffer_traitsEE4growEm:
push r15
push r14
push rbx
mov rbx, rsi
mov r14, rdi
mov r15, [rdi+20h]
mov rax, [r15+18h]
mov rcx, r15
cmp rax, rsi
jnb short loc_3E620
mov rax, [r15]
mov rdi, r15
mov rsi, rbx
call qword ptr [rax]
mov rax, [r15+18h]
mov rcx, [r14+20h]
loc_3E620:
cmp rax, rbx
cmovnb rax, rbx
mov [r15+10h], rax
mov rax, [rcx+8]
mov [r14+8], rax
mov [r14+18h], rbx
pop rbx
pop r14
pop r15
retn
| long long fmt::v8::detail::iterator_buffer<std::back_insert_iterator<fmt::v8::basic_memory_buffer<char,250ul,std::allocator<char>>>,char,fmt::v8::detail::buffer_traits>::grow(
_QWORD *a1,
unsigned long long a2,
long long a3)
{
long long v3; // r15
unsigned long long v4; // rax
long long v5; // rcx
long long result; // rax
v3 = a1[4];
v4 = *(_QWORD *)(v3 + 24);
v5 = v3;
if ( v4 < a2 )
{
(**(void ( ***)(_QWORD, unsigned long long, long long, long long))v3)(a1[4], a2, a3, v3);
v4 = *(_QWORD *)(v3 + 24);
v5 = a1[4];
}
if ( v4 >= a2 )
v4 = a2;
*(_QWORD *)(v3 + 16) = v4;
result = *(_QWORD *)(v5 + 8);
a1[1] = result;
a1[3] = a2;
return result;
}
| grow:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R14,RDI
MOV R15,qword ptr [RDI + 0x20]
MOV RAX,qword ptr [R15 + 0x18]
MOV RCX,R15
CMP RAX,RSI
JNC 0x0013e620
MOV RAX,qword ptr [R15]
MOV RDI,R15
MOV RSI,RBX
CALL qword ptr [RAX]
MOV RAX,qword ptr [R15 + 0x18]
MOV RCX,qword ptr [R14 + 0x20]
LAB_0013e620:
CMP RAX,RBX
CMOVNC RAX,RBX
MOV qword ptr [R15 + 0x10],RAX
MOV RAX,qword ptr [RCX + 0x8]
MOV qword ptr [R14 + 0x8],RAX
MOV qword ptr [R14 + 0x18],RBX
POP RBX
POP R14
POP R15
RET
|
/* fmt::v8::detail::iterator_buffer<std::back_insert_iterator<fmt::v8::basic_memory_buffer<char,
250ul, std::allocator<char> > >, char, fmt::v8::detail::buffer_traits>::grow(unsigned long) */
void __thiscall
fmt::v8::detail::
iterator_buffer<std::back_insert_iterator<fmt::v8::basic_memory_buffer<char,250ul,std::allocator<char>>>,char,fmt::v8::detail::buffer_traits>
::grow(iterator_buffer<std::back_insert_iterator<fmt::v8::basic_memory_buffer<char,250ul,std::allocator<char>>>,char,fmt::v8::detail::buffer_traits>
*this,ulong param_1)
{
int8 *puVar1;
ulong uVar2;
int8 *puVar3;
puVar1 = *(int8 **)(this + 0x20);
uVar2 = puVar1[3];
puVar3 = puVar1;
if (uVar2 < param_1) {
(**(code **)*puVar1)(puVar1,param_1);
uVar2 = puVar1[3];
puVar3 = *(int8 **)(this + 0x20);
}
if (param_1 <= uVar2) {
uVar2 = param_1;
}
puVar1[2] = uVar2;
*(int8 *)(this + 8) = puVar3[1];
*(ulong *)(this + 0x18) = param_1;
return;
}
| |
52,946 | testing::internal::EqFailure(char const*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | seiftnesse[P]memoryallocator/build_O1/_deps/googletest-src/googletest/src/gtest.cc | AssertionResult EqFailure(const char* lhs_expression,
const char* rhs_expression,
const std::string& lhs_value,
const std::string& rhs_value, bool ignoring_case) {
Message msg;
msg << "Expected equality of these values:";
msg << "\n " << lhs_expression;
if (lhs_value != lhs_expression) {
msg << "\n Which is: " << lhs_value;
}
msg << "\n " << rhs_expression;
if (rhs_value != rhs_expression) {
msg << "\n Which is: " << rhs_value;
}
if (ignoring_case) {
msg << "\nIgnoring case";
}
if (!lhs_value.empty() && !rhs_value.empty()) {
const std::vector<std::string> lhs_lines = SplitEscapedString(lhs_value);
const std::vector<std::string> rhs_lines = SplitEscapedString(rhs_value);
if (lhs_lines.size() > 1 || rhs_lines.size() > 1) {
msg << "\nWith diff:\n"
<< edit_distance::CreateUnifiedDiff(lhs_lines, rhs_lines);
}
}
return AssertionFailure() << msg;
} | O1 | cpp | testing::internal::EqFailure(char const*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r9d, %ebp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, 0x30(%rsp)
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x20c50
movq (%rbx), %rdi
addq $0x10, %rdi
leaq 0x21154(%rip), %rsi # 0x42e15
movl $0x22, %edx
callq 0x95a0
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
leaq 0x2115d(%rip), %rsi # 0x42e38
movl $0x3, %edx
callq 0x95a0
movq 0x8(%rsp), %rbx
addq $0x10, %rbx
testq %r13, %r13
je 0x21d03
movq %r13, %rdi
callq 0x91f0
movq %rax, %rdx
movq %r13, %rsi
jmp 0x21d0f
movl $0x6, %edx
leaq 0x1ea86(%rip), %rsi # 0x40795
movq %rbx, %rdi
callq 0x95a0
movq %r15, %rdi
movq %r13, %rsi
callq 0x9160
testl %eax, %eax
je 0x21d55
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
leaq 0x21106(%rip), %rsi # 0x42e3c
movl $0xf, %edx
callq 0x95a0
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movq (%r15), %rsi
movq 0x8(%r15), %rdx
callq 0x95a0
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
leaq 0x210d3(%rip), %rsi # 0x42e38
movl $0x3, %edx
callq 0x95a0
movq 0x8(%rsp), %rbx
addq $0x10, %rbx
testq %r12, %r12
je 0x21d8d
movq %r12, %rdi
callq 0x91f0
movq %rax, %rdx
movq %r12, %rsi
jmp 0x21d99
movl $0x6, %edx
leaq 0x1e9fc(%rip), %rsi # 0x40795
movq %rbx, %rdi
callq 0x95a0
movq %r14, %rdi
movq %r12, %rsi
callq 0x9160
testl %eax, %eax
je 0x21ddf
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
leaq 0x2107c(%rip), %rsi # 0x42e3c
movl $0xf, %edx
callq 0x95a0
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movq (%r14), %rsi
movq 0x8(%r14), %rdx
callq 0x95a0
testb %bpl, %bpl
je 0x21dfe
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
leaq 0x21058(%rip), %rsi # 0x42e4c
movl $0xe, %edx
callq 0x95a0
cmpq $0x0, 0x8(%r15)
movq 0x30(%rsp), %rbx
je 0x21ecd
cmpq $0x0, 0x8(%r14)
je 0x21ecd
leaq 0x50(%rsp), %rdi
movq %r15, %rsi
callq 0x21fa0
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
callq 0x21fa0
movq 0x58(%rsp), %rax
subq 0x50(%rsp), %rax
cmpq $0x20, %rax
ja 0x21e53
movq 0x40(%rsp), %rax
subq 0x38(%rsp), %rax
cmpq $0x21, %rax
jb 0x21eb9
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
leaq 0x20ff8(%rip), %rsi # 0x42e5b
movl $0xc, %edx
callq 0x95a0
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0x38(%rsp), %rdx
movl $0x2, %ecx
callq 0x21606
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x95a0
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x21eb9
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x94c0
leaq 0x38(%rsp), %rdi
callq 0x3538e
leaq 0x50(%rsp), %rdi
callq 0x3538e
leaq 0x18(%rsp), %r14
movb $0x0, -0x8(%r14)
movq $0x0, (%r14)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x350ca
movq %rbx, %rdi
movq %rax, %rsi
callq 0x11fe4
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x21f0a
movq %r14, %rdi
callq 0xf756
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x21f1a
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x21f51
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x94c0
jmp 0x21f51
jmp 0x21f4e
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x3538e
jmp 0x21f60
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x3538e
jmp 0x21f88
jmp 0x21f85
movq %rax, %rbx
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x21f88
movq %r14, %rdi
callq 0xf756
jmp 0x21f88
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x21f98
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x99a0
| _ZN7testing8internal9EqFailureEPKcS2_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESA_b:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov ebp, r9d
mov r14, r8
mov r15, rcx
mov r12, rdx
mov r13, rsi
mov [rsp+98h+var_68], rdi
lea rbx, [rsp+98h+var_90]
mov rdi, rbx; this
call _ZN7testing7MessageC2Ev; testing::Message::Message(void)
mov rdi, [rbx]
add rdi, 10h
lea rsi, aExpectedEquali; "Expected equality of these values:"
mov edx, 22h ; '"'
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+98h+var_90]
add rdi, 10h
lea rsi, asc_42E38; "\n "
mov edx, 3
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rbx, [rsp+98h+var_90]
add rbx, 10h
test r13, r13
jz short loc_21D03
mov rdi, r13
call _strlen
mov rdx, rax
mov rsi, r13
jmp short loc_21D0F
loc_21D03:
mov edx, 6
lea rsi, aNull; "(null)"
loc_21D0F:
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rdi, r15
mov rsi, r13
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_21D55
mov rdi, [rsp+98h+var_90]
add rdi, 10h
lea rsi, aWhichIs; "\n Which is: "
mov edx, 0Fh
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+98h+var_90]
add rdi, 10h
mov rsi, [r15]
mov rdx, [r15+8]
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
loc_21D55:
mov rdi, [rsp+98h+var_90]
add rdi, 10h
lea rsi, asc_42E38; "\n "
mov edx, 3
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rbx, [rsp+98h+var_90]
add rbx, 10h
test r12, r12
jz short loc_21D8D
mov rdi, r12
call _strlen
mov rdx, rax
mov rsi, r12
jmp short loc_21D99
loc_21D8D:
mov edx, 6
lea rsi, aNull; "(null)"
loc_21D99:
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rdi, r14
mov rsi, r12
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_21DDF
mov rdi, [rsp+98h+var_90]
add rdi, 10h
lea rsi, aWhichIs; "\n Which is: "
mov edx, 0Fh
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+98h+var_90]
add rdi, 10h
mov rsi, [r14]
mov rdx, [r14+8]
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
loc_21DDF:
test bpl, bpl
jz short loc_21DFE
mov rdi, [rsp+98h+var_90]
add rdi, 10h
lea rsi, aIgnoringCase; "\nIgnoring case"
mov edx, 0Eh
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
loc_21DFE:
cmp qword ptr [r15+8], 0
mov rbx, [rsp+98h+var_68]
jz loc_21ECD
cmp qword ptr [r14+8], 0
jz loc_21ECD
lea rdi, [rsp+98h+var_48]; int
mov rsi, r15; int
call _ZN7testing8internal12_GLOBAL__N_118SplitEscapedStringERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; testing::internal::`anonymous namespace'::SplitEscapedString(std::string const&)
lea rdi, [rsp+98h+var_60]; int
mov rsi, r14; int
call _ZN7testing8internal12_GLOBAL__N_118SplitEscapedStringERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; testing::internal::`anonymous namespace'::SplitEscapedString(std::string const&)
mov rax, [rsp+98h+var_40]
sub rax, qword ptr [rsp+98h+var_48]
cmp rax, 20h ; ' '
ja short loc_21E53
mov rax, [rsp+98h+var_58]
sub rax, qword ptr [rsp+98h+var_60]
cmp rax, 21h ; '!'
jb short loc_21EB9
loc_21E53:
mov rdi, [rsp+98h+var_90]
add rdi, 10h
lea rsi, aWithDiff; "\nWith diff:\n"
mov edx, 0Ch
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rdi, [rsp+98h+var_88]
lea rsi, [rsp+98h+var_48]
lea rdx, [rsp+98h+var_60]
mov ecx, 2
call _ZN7testing8internal13edit_distance17CreateUnifiedDiffERKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS8_EESC_m; testing::internal::edit_distance::CreateUnifiedDiff(std::vector<std::string> const&,std::vector<std::string> const&,ulong)
mov rdi, [rsp+98h+var_90]
add rdi, 10h
mov rsi, [rsp+98h+var_88]
mov rdx, [rsp+98h+var_80]
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rax, [rsp+98h+var_78]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_21EB9
mov rsi, [rsp+98h+var_78]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_21EB9:
lea rdi, [rsp+98h+var_60]; void *
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
lea rdi, [rsp+98h+var_48]; void *
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
loc_21ECD:
lea r14, [rsp+98h+var_80]
mov byte ptr [r14-8], 0
mov qword ptr [r14], 0
lea rdi, [rsp+98h+var_88]; this
lea rsi, [rsp+98h+var_90]
call _ZN7testing15AssertionResultlsINS_7MessageEEERS0_RKT_; testing::AssertionResult::operator<<<testing::Message>(testing::Message const&)
mov rdi, rbx
mov rsi, rax
call _ZN7testing15AssertionResultC2ERKS0_; testing::AssertionResult::AssertionResult(testing::AssertionResult const&)
mov rsi, [rsp+98h+var_80]
test rsi, rsi
jz short loc_21F0A
mov rdi, r14
call _ZNKSt14default_deleteINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEclEPS5_; std::default_delete<std::string>::operator()(std::string*)
loc_21F0A:
mov rdi, [rsp+98h+var_90]
test rdi, rdi
jz short loc_21F1A
mov rax, [rdi]
call qword ptr [rax+8]
loc_21F1A:
mov rax, rbx
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
lea rax, [rsp+arg_18]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_21F51
mov rsi, [rsp+arg_18]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_21F51
jmp short $+2
loc_21F4E:
mov rbx, rax
loc_21F51:
lea rdi, [rsp+arg_30]; void *
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
jmp short loc_21F60
mov rbx, rax
loc_21F60:
lea rdi, [rsp+arg_48]; void *
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
jmp short loc_21F88
jmp short loc_21F85
mov rbx, rax
mov rsi, [rsp+arg_10]
test rsi, rsi
jz short loc_21F88
mov rdi, r14
call _ZNKSt14default_deleteINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEclEPS5_; std::default_delete<std::string>::operator()(std::string*)
jmp short loc_21F88
loc_21F85:
mov rbx, rax
loc_21F88:
mov rdi, [rsp+arg_0]
test rdi, rdi
jz short loc_21F98
mov rax, [rdi]
call qword ptr [rax+8]
loc_21F98:
mov rdi, rbx
call __Unwind_Resume
| testing::AssertionResult * testing::internal::EqFailure(
testing::AssertionResult *a1,
const char *a2,
const char *a3,
_QWORD *a4,
_QWORD *a5,
char a6)
{
const char *v10; // r13
long long v11; // rbx
long long v12; // rdx
long long v13; // rbx
long long v14; // rdx
const char *v15; // rsi
int v16; // edx
int v17; // ecx
int v18; // r8d
int v19; // r9d
testing::AssertionResult *v20; // rbx
int v21; // edx
int v22; // ecx
int v23; // r8d
int v24; // r9d
const testing::AssertionResult *v25; // rax
void *v27; // [rsp+0h] [rbp-98h]
void *v28; // [rsp+0h] [rbp-98h]
long long v29; // [rsp+8h] [rbp-90h] BYREF
long long *v30; // [rsp+10h] [rbp-88h] BYREF
long long v31; // [rsp+18h] [rbp-80h] BYREF
long long v32; // [rsp+20h] [rbp-78h] BYREF
testing::AssertionResult *v33; // [rsp+30h] [rbp-68h]
int v34[2]; // [rsp+38h] [rbp-60h] BYREF
long long v35; // [rsp+40h] [rbp-58h]
int v36[2]; // [rsp+50h] [rbp-48h] BYREF
long long v37; // [rsp+58h] [rbp-40h]
v10 = a2;
v33 = a1;
testing::Message::Message((testing::Message *)&v29);
std::__ostream_insert<char,std::char_traits<char>>(v29 + 16, "Expected equality of these values:", 34LL);
std::__ostream_insert<char,std::char_traits<char>>(v29 + 16, "\n ", 3LL);
v11 = v29 + 16;
if ( a2 )
{
v12 = strlen(a2);
}
else
{
v12 = 6LL;
a2 = "(null)";
}
std::__ostream_insert<char,std::char_traits<char>>(v11, a2, v12);
if ( (unsigned int)std::string::compare(a4, v10) )
{
std::__ostream_insert<char,std::char_traits<char>>(v29 + 16, "\n Which is: ", 15LL);
std::__ostream_insert<char,std::char_traits<char>>(v29 + 16, *a4, a4[1]);
}
std::__ostream_insert<char,std::char_traits<char>>(v29 + 16, "\n ", 3LL);
v13 = v29 + 16;
if ( a3 )
{
v14 = strlen(a3);
v15 = a3;
}
else
{
v14 = 6LL;
v15 = "(null)";
}
std::__ostream_insert<char,std::char_traits<char>>(v13, v15, v14);
if ( (unsigned int)std::string::compare(a5, a3) )
{
std::__ostream_insert<char,std::char_traits<char>>(v29 + 16, "\n Which is: ", 15LL);
std::__ostream_insert<char,std::char_traits<char>>(v29 + 16, *a5, a5[1]);
}
if ( a6 )
std::__ostream_insert<char,std::char_traits<char>>(v29 + 16, "\nIgnoring case", 14LL);
v20 = v33;
if ( a4[1] && a5[1] )
{
testing::internal::`anonymous namespace'::SplitEscapedString(
(int)v36,
(int)a4,
v16,
v17,
v18,
v19,
v27,
v29,
(long long)v30);
testing::internal::`anonymous namespace'::SplitEscapedString(
(int)v34,
(int)a5,
v21,
v22,
v23,
v24,
v28,
v29,
(long long)v30);
if ( (unsigned long long)(v37 - *(_QWORD *)v36) > 0x20 || (unsigned long long)(v35 - *(_QWORD *)v34) >= 0x21 )
{
std::__ostream_insert<char,std::char_traits<char>>(v29 + 16, "\nWith diff:\n", 12LL);
testing::internal::edit_distance::CreateUnifiedDiff(
(long long)&v30,
(long long *)v36,
(long long *)v34,
(char *)&dword_0 + 2);
std::__ostream_insert<char,std::char_traits<char>>(v29 + 16, v30, v31);
if ( v30 != &v32 )
operator delete(v30, v32 + 1);
}
std::vector<std::string>::~vector(v34);
std::vector<std::string>::~vector(v36);
}
LOBYTE(v30) = 0;
v25 = (const testing::AssertionResult *)testing::AssertionResult::operator<<<testing::Message>(
(testing::AssertionResult *)&v30,
(long long)v27,
v29,
(int)v30,
0LL);
testing::AssertionResult::AssertionResult(v20, v25);
if ( v31 )
std::default_delete<std::string>::operator()((long long)&v31, v31);
if ( v29 )
(*(void ( **)(long long))(*(_QWORD *)v29 + 8LL))(v29);
return v20;
}
| EqFailure:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV EBP,R9D
MOV R14,R8
MOV R15,RCX
MOV R12,RDX
MOV R13,RSI
MOV qword ptr [RSP + 0x30],RDI
LEA RBX,[RSP + 0x8]
MOV RDI,RBX
CALL 0x00120c50
MOV RDI,qword ptr [RBX]
ADD RDI,0x10
LAB_00121cba:
LEA RSI,[0x142e15]
MOV EDX,0x22
CALL 0x001095a0
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x10
LEA RSI,[0x142e38]
MOV EDX,0x3
CALL 0x001095a0
MOV RBX,qword ptr [RSP + 0x8]
ADD RBX,0x10
TEST R13,R13
JZ 0x00121d03
MOV RDI,R13
CALL 0x001091f0
MOV RDX,RAX
MOV RSI,R13
JMP 0x00121d0f
LAB_00121d03:
MOV EDX,0x6
LEA RSI,[0x140795]
LAB_00121d0f:
MOV RDI,RBX
CALL 0x001095a0
MOV RDI,R15
MOV RSI,R13
CALL 0x00109160
TEST EAX,EAX
JZ 0x00121d55
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x10
LEA RSI,[0x142e3c]
MOV EDX,0xf
CALL 0x001095a0
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x10
MOV RSI,qword ptr [R15]
MOV RDX,qword ptr [R15 + 0x8]
CALL 0x001095a0
LAB_00121d55:
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x10
LEA RSI,[0x142e38]
MOV EDX,0x3
CALL 0x001095a0
MOV RBX,qword ptr [RSP + 0x8]
ADD RBX,0x10
TEST R12,R12
JZ 0x00121d8d
MOV RDI,R12
CALL 0x001091f0
MOV RDX,RAX
MOV RSI,R12
JMP 0x00121d99
LAB_00121d8d:
MOV EDX,0x6
LEA RSI,[0x140795]
LAB_00121d99:
MOV RDI,RBX
CALL 0x001095a0
MOV RDI,R14
MOV RSI,R12
CALL 0x00109160
TEST EAX,EAX
JZ 0x00121ddf
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x10
LEA RSI,[0x142e3c]
MOV EDX,0xf
CALL 0x001095a0
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x10
MOV RSI,qword ptr [R14]
MOV RDX,qword ptr [R14 + 0x8]
CALL 0x001095a0
LAB_00121ddf:
TEST BPL,BPL
JZ 0x00121dfe
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x10
LEA RSI,[0x142e4c]
MOV EDX,0xe
CALL 0x001095a0
LAB_00121dfe:
CMP qword ptr [R15 + 0x8],0x0
MOV RBX,qword ptr [RSP + 0x30]
JZ 0x00121ecd
CMP qword ptr [R14 + 0x8],0x0
JZ 0x00121ecd
LAB_00121e19:
LEA RDI,[RSP + 0x50]
MOV RSI,R15
CALL 0x00121fa0
LAB_00121e26:
LEA RDI,[RSP + 0x38]
MOV RSI,R14
CALL 0x00121fa0
MOV RAX,qword ptr [RSP + 0x58]
SUB RAX,qword ptr [RSP + 0x50]
CMP RAX,0x20
JA 0x00121e53
MOV RAX,qword ptr [RSP + 0x40]
SUB RAX,qword ptr [RSP + 0x38]
CMP RAX,0x21
JC 0x00121eb9
LAB_00121e53:
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x10
LAB_00121e5c:
LEA RSI,[0x142e5b]
MOV EDX,0xc
CALL 0x001095a0
LAB_00121e6d:
LEA RDI,[RSP + 0x10]
LEA RSI,[RSP + 0x50]
LEA RDX,[RSP + 0x38]
MOV ECX,0x2
CALL 0x00121606
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x10
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x18]
LAB_00121e99:
CALL 0x001095a0
LEA RAX,[RSP + 0x20]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x00121eb9
MOV RSI,qword ptr [RSP + 0x20]
INC RSI
CALL 0x001094c0
LAB_00121eb9:
LEA RDI,[RSP + 0x38]
CALL 0x0013538e
LEA RDI,[RSP + 0x50]
CALL 0x0013538e
LAB_00121ecd:
LEA R14,[RSP + 0x18]
MOV byte ptr [R14 + -0x8],0x0
MOV qword ptr [R14],0x0
LAB_00121ede:
LEA RDI,[RSP + 0x10]
LEA RSI,[RSP + 0x8]
CALL 0x001350ca
MOV RDI,RBX
MOV RSI,RAX
CALL 0x00111fe4
LAB_00121ef8:
MOV RSI,qword ptr [RSP + 0x18]
TEST RSI,RSI
JZ 0x00121f0a
MOV RDI,R14
CALL 0x0010f756
LAB_00121f0a:
MOV RDI,qword ptr [RSP + 0x8]
TEST RDI,RDI
JZ 0x00121f1a
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_00121f1a:
MOV RAX,RBX
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* testing::internal::EqFailure(char const*, char const*, std::__cxx11::string const&,
std::__cxx11::string const&, bool) */
AssertionResult * __thiscall
testing::internal::EqFailure
(internal *this,char *param_1,char *param_2,string *param_3,string *param_4,bool param_5)
{
internal *this_00;
int iVar1;
size_t sVar2;
AssertionResult *pAVar3;
ostream *poVar4;
long *local_90;
edit_distance local_88;
int7 uStack_87;
string *local_80;
long local_78 [2];
internal *local_68;
long local_60;
long local_58;
long local_48;
long local_40;
local_68 = this;
Message::Message((Message *)&local_90);
/* try { // try from 00121cba to 00121dfd has its CatchHandler @ 00121f85 */
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)(local_90 + 2),"Expected equality of these values:",0x22);
std::__ostream_insert<char,std::char_traits<char>>((ostream *)(local_90 + 2),"\n ",3);
poVar4 = (ostream *)(local_90 + 2);
if (param_1 == (char *)0x0) {
sVar2 = 6;
param_1 = "(null)";
}
else {
sVar2 = strlen(param_1);
}
std::__ostream_insert<char,std::char_traits<char>>(poVar4,param_1,sVar2);
iVar1 = std::__cxx11::string::compare((char *)param_3);
if (iVar1 != 0) {
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)(local_90 + 2),"\n Which is: ",0xf);
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)(local_90 + 2),*(char **)param_3,*(long *)(param_3 + 8));
}
std::__ostream_insert<char,std::char_traits<char>>((ostream *)(local_90 + 2),"\n ",3);
poVar4 = (ostream *)(local_90 + 2);
if (param_2 == (char *)0x0) {
sVar2 = 6;
param_2 = "(null)";
}
else {
sVar2 = strlen(param_2);
}
std::__ostream_insert<char,std::char_traits<char>>(poVar4,param_2,sVar2);
iVar1 = std::__cxx11::string::compare((char *)param_4);
if (iVar1 != 0) {
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)(local_90 + 2),"\n Which is: ",0xf);
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)(local_90 + 2),*(char **)param_4,*(long *)(param_4 + 8));
}
if (param_5) {
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)(local_90 + 2),"\nIgnoring case",0xe);
}
this_00 = local_68;
if ((*(long *)(param_3 + 8) != 0) && (*(long *)(param_4 + 8) != 0)) {
/* try { // try from 00121e19 to 00121e25 has its CatchHandler @ 00121f6c */
(anonymous_namespace)::SplitEscapedString((_anonymous_namespace_ *)&local_48,param_3);
/* try { // try from 00121e26 to 00121e32 has its CatchHandler @ 00121f5d */
(anonymous_namespace)::SplitEscapedString((_anonymous_namespace_ *)&local_60,param_4);
if ((0x20 < (ulong)(local_40 - local_48)) || (0x20 < (ulong)(local_58 - local_60))) {
/* try { // try from 00121e5c to 00121e6c has its CatchHandler @ 00121f4e */
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)(local_90 + 2),"\nWith diff:\n",0xc);
/* try { // try from 00121e6d to 00121e85 has its CatchHandler @ 00121f4c */
edit_distance::CreateUnifiedDiff(&local_88,(vector *)&local_48,(vector *)&local_60,2);
/* try { // try from 00121e99 to 00121e9d has its CatchHandler @ 00121f2c */
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)(local_90 + 2),(char *)CONCAT71(uStack_87,local_88),(long)local_80);
if ((long *)CONCAT71(uStack_87,local_88) != local_78) {
operator_delete((long *)CONCAT71(uStack_87,local_88),local_78[0] + 1);
}
}
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)&local_60);
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)&local_48);
}
local_88 = (edit_distance)0x0;
local_80 = (string *)0x0;
/* try { // try from 00121ede to 00121ef7 has its CatchHandler @ 00121f6e */
pAVar3 = AssertionResult::operator<<((AssertionResult *)&local_88,(Message *)&local_90);
AssertionResult::AssertionResult((AssertionResult *)this_00,pAVar3);
if (local_80 != (string *)0x0) {
std::default_delete<std::__cxx11::string>::operator()
((default_delete<std::__cxx11::string> *)&local_80,local_80);
}
if (local_90 != (long *)0x0) {
(**(code **)(*local_90 + 8))();
}
return (AssertionResult *)this_00;
}
| |
52,947 | bitmap_is_overlapping | eloqsql/mysys/my_bitmap.c | my_bool bitmap_is_overlapping(const MY_BITMAP *map1, const MY_BITMAP *map2)
{
my_bitmap_map *m1= map1->bitmap, *m2= map2->bitmap, *end;
DBUG_ASSERT(map1->bitmap);
DBUG_ASSERT(map2->bitmap);
DBUG_ASSERT(map1->n_bits==map2->n_bits);
end= map1->last_word_ptr;
while (m1 < end)
{
if ((*m1++) & (*m2++))
return 1;
}
/* here both maps have the same number of bits - see assert above */
return ((*m1 & *m2 & ~map1->last_word_mask) ? 1 : 0);
} | O3 | c | bitmap_is_overlapping:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movq 0x8(%rdi), %rdx
movq (%rsi), %rcx
cmpq %rdx, %rax
jae 0x9e5ba
leaq 0x4(%rax), %rsi
movl (%rcx), %r8d
addq $0x4, %rcx
testl %r8d, (%rax)
movq %rsi, %rax
je 0x9e59e
movb $0x1, %al
jmp 0x9e5c8
movl (%rcx), %ecx
andl (%rax), %ecx
movl 0x18(%rdi), %eax
notl %eax
testl %eax, %ecx
setne %al
popq %rbp
retq
| bitmap_is_overlapping:
push rbp
mov rbp, rsp
mov rax, [rdi]
mov rdx, [rdi+8]
mov rcx, [rsi]
loc_9E59E:
cmp rax, rdx
jnb short loc_9E5BA
lea rsi, [rax+4]
mov r8d, [rcx]
add rcx, 4
test [rax], r8d
mov rax, rsi
jz short loc_9E59E
mov al, 1
jmp short loc_9E5C8
loc_9E5BA:
mov ecx, [rcx]
and ecx, [rax]
mov eax, [rdi+18h]
not eax
test ecx, eax
setnz al
loc_9E5C8:
pop rbp
retn
| bool bitmap_is_overlapping(long long a1, int **a2)
{
_DWORD *v2; // rax
int *v3; // rcx
int v4; // r8d
v2 = *(_DWORD **)a1;
v3 = *a2;
while ( (unsigned long long)v2 < *(_QWORD *)(a1 + 8) )
{
v4 = *v3++;
if ( (v4 & *v2++) != 0 )
return 1;
}
return (~*(_DWORD *)(a1 + 24) & *v2 & *v3) != 0;
}
| bitmap_is_overlapping:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RDI]
MOV RDX,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RSI]
LAB_0019e59e:
CMP RAX,RDX
JNC 0x0019e5ba
LEA RSI,[RAX + 0x4]
MOV R8D,dword ptr [RCX]
ADD RCX,0x4
TEST dword ptr [RAX],R8D
MOV RAX,RSI
JZ 0x0019e59e
MOV AL,0x1
JMP 0x0019e5c8
LAB_0019e5ba:
MOV ECX,dword ptr [RCX]
AND ECX,dword ptr [RAX]
MOV EAX,dword ptr [RDI + 0x18]
NOT EAX
TEST ECX,EAX
SETNZ AL
LAB_0019e5c8:
POP RBP
RET
|
ulong bitmap_is_overlapping(int8 *param_1,int8 *param_2)
{
uint *puVar1;
uint uVar2;
uint uVar3;
uint *puVar4;
uint *puVar5;
puVar5 = (uint *)*param_2;
puVar4 = (uint *)*param_1;
do {
if ((uint *)param_1[1] <= puVar4) {
return (ulong)CONCAT31((int3)(~*(uint *)(param_1 + 3) >> 8),
(*puVar5 & *puVar4 & ~*(uint *)(param_1 + 3)) != 0);
}
puVar1 = puVar4 + 1;
uVar2 = *puVar5;
puVar5 = puVar5 + 1;
uVar3 = *puVar4;
puVar4 = puVar1;
} while ((uVar3 & uVar2) == 0);
return CONCAT71((int7)((ulong)puVar1 >> 8),1);
}
| |
52,948 | my_snprintf | eloqsql/strings/my_vsnprintf.c | size_t my_snprintf(char* to, size_t n, const char* fmt, ...)
{
size_t result;
va_list args;
va_start(args,fmt);
result= my_vsnprintf(to, n, fmt, args);
va_end(args);
return result;
} | O0 | c | my_snprintf:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x769fb
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0xf0(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x30, -0x3c(%rbp)
movl $0x18, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x76980
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_snprintf:
push rbp
mov rbp, rsp
sub rsp, 0F0h
test al, al
jz short loc_769FB
movaps [rbp+var_C0], xmm0
movaps [rbp+var_B0], xmm1
movaps [rbp+var_A0], xmm2
movaps [rbp+var_90], xmm3
movaps [rbp+var_80], xmm4
movaps [rbp+var_70], xmm5
movaps [rbp+var_60], xmm6
movaps [rbp+var_50], xmm7
loc_769FB:
mov [rbp+var_C8], r9
mov [rbp+var_D0], r8
mov [rbp+var_D8], rcx
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
lea rax, [rbp+var_F0]
mov [rbp+var_30], rax
lea rax, [rbp+arg_0]
mov [rbp+var_38], rax
mov [rbp+var_3C], 30h ; '0'
mov [rbp+var_40], 18h
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
lea rcx, [rbp+var_40]
call my_vsnprintf
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
add rsp, 0F0h
pop rbp
retn
| _BYTE * my_snprintf(
_BYTE *a1,
long long a2,
char *a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
char v16; // [rsp+0h] [rbp-F0h] BYREF
long long v17; // [rsp+18h] [rbp-D8h]
long long v18; // [rsp+20h] [rbp-D0h]
long long v19; // [rsp+28h] [rbp-C8h]
__m128 v20; // [rsp+30h] [rbp-C0h]
__m128 v21; // [rsp+40h] [rbp-B0h]
__m128 v22; // [rsp+50h] [rbp-A0h]
__m128 v23; // [rsp+60h] [rbp-90h]
__m128 v24; // [rsp+70h] [rbp-80h]
__m128 v25; // [rsp+80h] [rbp-70h]
__m128 v26; // [rsp+90h] [rbp-60h]
__m128 v27; // [rsp+A0h] [rbp-50h]
int v28[2]; // [rsp+B0h] [rbp-40h] BYREF
char *v29; // [rsp+B8h] [rbp-38h]
char *v30; // [rsp+C0h] [rbp-30h]
char *v31; // [rsp+D8h] [rbp-18h]
long long v32; // [rsp+E0h] [rbp-10h]
_BYTE *v33; // [rsp+E8h] [rbp-8h]
v20 = a7;
v21 = a8;
v22 = a9;
v23 = a10;
v24 = a11;
v25 = a12;
v26 = a13;
v27 = a14;
v19 = a6;
v18 = a5;
v17 = a4;
v33 = a1;
v32 = a2;
v31 = a3;
v30 = &v16;
v29 = &a15;
v28[1] = 48;
v28[0] = 24;
return my_vsnprintf(a1, a2, a3, v28);
}
| my_snprintf:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xf0
TEST AL,AL
JZ 0x001769fb
MOVAPS xmmword ptr [RBP + -0xc0],XMM0
MOVAPS xmmword ptr [RBP + -0xb0],XMM1
MOVAPS xmmword ptr [RBP + -0xa0],XMM2
MOVAPS xmmword ptr [RBP + -0x90],XMM3
MOVAPS xmmword ptr [RBP + -0x80],XMM4
MOVAPS xmmword ptr [RBP + -0x70],XMM5
MOVAPS xmmword ptr [RBP + -0x60],XMM6
MOVAPS xmmword ptr [RBP + -0x50],XMM7
LAB_001769fb:
MOV qword ptr [RBP + -0xc8],R9
MOV qword ptr [RBP + -0xd0],R8
MOV qword ptr [RBP + -0xd8],RCX
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
LEA RAX,[RBP + -0xf0]
MOV qword ptr [RBP + -0x30],RAX
LEA RAX,[RBP + 0x10]
MOV qword ptr [RBP + -0x38],RAX
MOV dword ptr [RBP + -0x3c],0x30
MOV dword ptr [RBP + -0x40],0x18
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
LEA RCX,[RBP + -0x40]
CALL 0x00176980
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RSP,0xf0
POP RBP
RET
|
int8
my_snprintf(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
int8 param_9,int8 param_10,int8 param_11,int8 param_12,
int8 param_13,int8 param_14)
{
char in_AL;
int8 uVar1;
int1 local_f8 [24];
int8 local_e0;
int8 local_d8;
int8 local_d0;
int8 local_c8;
int8 local_b8;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
int8 local_58;
int4 local_48;
int4 local_44;
int1 *local_40;
int1 *local_38;
int8 local_20;
int8 local_18;
int8 local_10;
if (in_AL != '\0') {
local_c8 = param_1;
local_b8 = param_2;
local_a8 = param_3;
local_98 = param_4;
local_88 = param_5;
local_78 = param_6;
local_68 = param_7;
local_58 = param_8;
}
local_38 = local_f8;
local_40 = &stack0x00000008;
local_44 = 0x30;
local_48 = 0x18;
local_e0 = param_12;
local_d8 = param_13;
local_d0 = param_14;
local_20 = param_11;
local_18 = param_10;
local_10 = param_9;
uVar1 = my_vsnprintf(param_9,param_10,param_11,&local_48);
return uVar1;
}
| |
52,949 | diagnostic_error | eshkol/src/core/diagnostics/diagnostics.c | void diagnostic_error(DiagnosticContext* context, int line, int column, const char* message) {
assert(context != NULL);
assert(message != NULL);
// Create source location
SourceLocation location = source_location_create(NULL, line, column, 0);
// Add diagnostic
diagnostic_context_add(context, DIAGNOSTIC_ERROR, location, message, NULL);
} | O3 | c | diagnostic_error:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
testq %rdi, %rdi
je 0x2a0b
testq %rcx, %rcx
je 0x2a2a
movq $0x0, -0x18(%rbp)
movl %esi, -0x10(%rbp)
movl %edx, -0xc(%rbp)
movl $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, 0x10(%rsp)
movups -0x18(%rbp), %xmm0
movups %xmm0, (%rsp)
movl $0x2, %esi
movq %rcx, %rdx
xorl %ecx, %ecx
callq 0x25d2
addq $0x30, %rsp
popq %rbp
retq
leaq 0xb687(%rip), %rdi # 0xe099
leaq 0xbde7(%rip), %rsi # 0xe800
leaq 0xc0ab(%rip), %rcx # 0xeacb
movl $0xdd, %edx
callq 0x1130
leaq 0xbec1(%rip), %rdi # 0xe8f2
leaq 0xbdc8(%rip), %rsi # 0xe800
leaq 0xc08c(%rip), %rcx # 0xeacb
movl $0xde, %edx
callq 0x1130
| diagnostic_error:
push rbp
mov rbp, rsp
sub rsp, 30h
test rdi, rdi
jz short loc_2A0B
test rcx, rcx
jz short loc_2A2A
mov qword ptr [rbp+var_18], 0
mov dword ptr [rbp+var_18+8], esi
mov dword ptr [rbp+var_18+0Ch], edx
mov dword ptr [rbp+var_8], 0
mov rax, [rbp+var_8]
mov [rsp+30h+var_20], rax
movups xmm0, [rbp+var_18]
movups [rsp+30h+var_30], xmm0
mov esi, 2
mov rdx, rcx
xor ecx, ecx
call diagnostic_context_add
add rsp, 30h
pop rbp
retn
loc_2A0B:
lea rdi, aTypeContextNul+5; "context != NULL"
lea rsi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/eshkol"...
lea rcx, aVoidDiagnostic_1; "void diagnostic_error(DiagnosticContext"...
mov edx, 0DDh
call ___assert_fail
loc_2A2A:
lea rdi, aMessageNull; "message != NULL"
lea rsi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/eshkol"...
lea rcx, aVoidDiagnostic_1; "void diagnostic_error(DiagnosticContext"...
mov edx, 0DEh
call ___assert_fail
| long long diagnostic_error(long long *a1, unsigned int a2, unsigned int a3, long long a4, long long a5, long long a6)
{
__int128 v7; // [rsp+18h] [rbp-18h]
long long v8; // [rsp+28h] [rbp-8h]
if ( !a1 )
__assert_fail(
"context != NULL",
"/workspace/llm4binary/github2025/eshkol/src/core/diagnostics/diagnostics.c",
221LL,
"void diagnostic_error(DiagnosticContext *, int, int, const char *)");
if ( !a4 )
__assert_fail(
"message != NULL",
"/workspace/llm4binary/github2025/eshkol/src/core/diagnostics/diagnostics.c",
222LL,
"void diagnostic_error(DiagnosticContext *, int, int, const char *)");
*(_QWORD *)&v7 = 0LL;
*((_QWORD *)&v7 + 1) = __PAIR64__(a3, a2);
LODWORD(v8) = 0;
return diagnostic_context_add(a1, 2, a4, 0LL, a5, a6, v7, v8);
}
| diagnostic_error:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
TEST RDI,RDI
JZ 0x00102a0b
TEST RCX,RCX
JZ 0x00102a2a
MOV qword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x10],ESI
MOV dword ptr [RBP + -0xc],EDX
MOV dword ptr [RBP + -0x8],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [RBP + -0x18]
MOVUPS xmmword ptr [RSP],XMM0
MOV ESI,0x2
MOV RDX,RCX
XOR ECX,ECX
CALL 0x001025d2
ADD RSP,0x30
POP RBP
RET
LAB_00102a0b:
LEA RDI,[0x10e099]
LEA RSI,[0x10e800]
LEA RCX,[0x10eacb]
MOV EDX,0xdd
CALL 0x00101130
LAB_00102a2a:
LEA RDI,[0x10e8f2]
LEA RSI,[0x10e800]
LEA RCX,[0x10eacb]
MOV EDX,0xde
CALL 0x00101130
|
void diagnostic_error(long param_1,int4 param_2,int8 param_3,long param_4,
int8 param_5,int8 param_6)
{
uint uStack_c;
if (param_1 == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("context != NULL",
"/workspace/llm4binary/github2025/eshkol/src/core/diagnostics/diagnostics.c",0xdd,
"void diagnostic_error(DiagnosticContext *, int, int, const char *)");
}
if (param_4 != 0) {
diagnostic_context_add(param_1,2,param_4,0,param_5,param_6,0,param_2,(ulong)uStack_c << 0x20);
return;
}
/* WARNING: Subroutine does not return */
__assert_fail("message != NULL",
"/workspace/llm4binary/github2025/eshkol/src/core/diagnostics/diagnostics.c",0xde,
"void diagnostic_error(DiagnosticContext *, int, int, const char *)");
}
| |
52,950 | DrawCircleGradient | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rshapes.c | void DrawCircleGradient(int centerX, int centerY, float radius, Color inner, Color outer)
{
rlBegin(RL_TRIANGLES);
for (int i = 0; i < 360; i += 10)
{
rlColor4ub(inner.r, inner.g, inner.b, inner.a);
rlVertex2f((float)centerX, (float)centerY);
rlColor4ub(outer.r, outer.g, outer.b, outer.a);
rlVertex2f((float)centerX + cosf(DEG2RAD*(i + 10))*radius, (float)centerY + sinf(DEG2RAD*(i + 10))*radius);
rlColor4ub(outer.r, outer.g, outer.b, outer.a);
rlVertex2f((float)centerX + cosf(DEG2RAD*i)*radius, (float)centerY + sinf(DEG2RAD*i)*radius);
}
rlEnd();
} | O0 | c | DrawCircleGradient:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edx, -0x4(%rbp)
movl %ecx, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movl $0x4, %edi
callq 0xb07c0
movl $0x0, -0x18(%rbp)
cmpl $0x168, -0x18(%rbp) # imm = 0x168
jge 0xd852b
movb -0x4(%rbp), %dl
movb -0x3(%rbp), %cl
movb -0x2(%rbp), %al
movzbl %dl, %edi
movzbl %cl, %esi
movzbl %al, %edx
movzbl -0x1(%rbp), %ecx
callq 0xb2160
cvtsi2ssl -0xc(%rbp), %xmm0
cvtsi2ssl -0x10(%rbp), %xmm1
callq 0xb1f10
movb -0x8(%rbp), %dl
movb -0x7(%rbp), %cl
movb -0x6(%rbp), %al
movzbl %dl, %edi
movzbl %cl, %esi
movzbl %al, %edx
movzbl -0x5(%rbp), %ecx
callq 0xb2160
cvtsi2ssl -0xc(%rbp), %xmm0
movss %xmm0, -0x30(%rbp)
movl -0x18(%rbp), %eax
addl $0xa, %eax
cvtsi2ss %eax, %xmm1
movss 0xdaf08(%rip), %xmm0 # 0x1b3330
mulss %xmm1, %xmm0
callq 0xa390
movss -0x30(%rbp), %xmm1
movss -0x14(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x28(%rbp)
cvtsi2ssl -0x10(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
movl -0x18(%rbp), %eax
addl $0xa, %eax
cvtsi2ss %eax, %xmm1
movss 0xdaecc(%rip), %xmm0 # 0x1b3330
mulss %xmm1, %xmm0
callq 0xa410
movss -0x2c(%rbp), %xmm2
movaps %xmm0, %xmm1
movss -0x28(%rbp), %xmm0
movss -0x14(%rbp), %xmm3
mulss %xmm3, %xmm1
addss %xmm2, %xmm1
callq 0xb1f10
movb -0x8(%rbp), %dl
movb -0x7(%rbp), %cl
movb -0x6(%rbp), %al
movzbl %dl, %edi
movzbl %cl, %esi
movzbl %al, %edx
movzbl -0x5(%rbp), %ecx
callq 0xb2160
cvtsi2ssl -0xc(%rbp), %xmm0
movss %xmm0, -0x24(%rbp)
cvtsi2ssl -0x18(%rbp), %xmm1
movss 0xdae72(%rip), %xmm0 # 0x1b3330
mulss %xmm1, %xmm0
callq 0xa390
movss -0x24(%rbp), %xmm1
movss -0x14(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x1c(%rbp)
cvtsi2ssl -0x10(%rbp), %xmm0
movss %xmm0, -0x20(%rbp)
cvtsi2ssl -0x18(%rbp), %xmm1
movss 0xdae3b(%rip), %xmm0 # 0x1b3330
mulss %xmm1, %xmm0
callq 0xa410
movss -0x20(%rbp), %xmm2
movaps %xmm0, %xmm1
movss -0x1c(%rbp), %xmm0
movss -0x14(%rbp), %xmm3
mulss %xmm3, %xmm1
addss %xmm2, %xmm1
callq 0xb1f10
movl -0x18(%rbp), %eax
addl $0xa, %eax
movl %eax, -0x18(%rbp)
jmp 0xd83ba
callq 0xb1990
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| DrawCircleGradient:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_4], edx
mov [rbp+var_8], ecx
mov [rbp+var_C], edi
mov [rbp+var_10], esi
movss [rbp+var_14], xmm0
mov edi, 4
call rlBegin
mov [rbp+var_18], 0
loc_D83BA:
cmp [rbp+var_18], 168h
jge loc_D852B
mov dl, byte ptr [rbp+var_4]
mov cl, byte ptr [rbp+var_4+1]
mov al, byte ptr [rbp+var_4+2]
movzx edi, dl
movzx esi, cl
movzx edx, al
movzx ecx, byte ptr [rbp+var_4+3]
call rlColor4ub
cvtsi2ss xmm0, [rbp+var_C]
cvtsi2ss xmm1, [rbp+var_10]
call rlVertex2f
mov dl, byte ptr [rbp+var_8]
mov cl, byte ptr [rbp+var_8+1]
mov al, byte ptr [rbp+var_8+2]
movzx edi, dl
movzx esi, cl
movzx edx, al
movzx ecx, byte ptr [rbp+var_8+3]
call rlColor4ub
cvtsi2ss xmm0, [rbp+var_C]
movss [rbp+var_30], xmm0
mov eax, [rbp+var_18]
add eax, 0Ah
cvtsi2ss xmm1, eax
movss xmm0, cs:dword_1B3330
mulss xmm0, xmm1
call _cosf
movss xmm1, [rbp+var_30]
movss xmm2, [rbp+var_14]
mulss xmm0, xmm2
addss xmm0, xmm1
movss [rbp+var_28], xmm0
cvtsi2ss xmm0, [rbp+var_10]
movss [rbp+var_2C], xmm0
mov eax, [rbp+var_18]
add eax, 0Ah
cvtsi2ss xmm1, eax
movss xmm0, cs:dword_1B3330
mulss xmm0, xmm1
call _sinf
movss xmm2, [rbp+var_2C]
movaps xmm1, xmm0
movss xmm0, [rbp+var_28]
movss xmm3, [rbp+var_14]
mulss xmm1, xmm3
addss xmm1, xmm2
call rlVertex2f
mov dl, byte ptr [rbp+var_8]
mov cl, byte ptr [rbp+var_8+1]
mov al, byte ptr [rbp+var_8+2]
movzx edi, dl
movzx esi, cl
movzx edx, al
movzx ecx, byte ptr [rbp+var_8+3]
call rlColor4ub
cvtsi2ss xmm0, [rbp+var_C]
movss [rbp+var_24], xmm0
cvtsi2ss xmm1, [rbp+var_18]
movss xmm0, cs:dword_1B3330
mulss xmm0, xmm1
call _cosf
movss xmm1, [rbp+var_24]
movss xmm2, [rbp+var_14]
mulss xmm0, xmm2
addss xmm0, xmm1
movss [rbp+var_1C], xmm0
cvtsi2ss xmm0, [rbp+var_10]
movss [rbp+var_20], xmm0
cvtsi2ss xmm1, [rbp+var_18]
movss xmm0, cs:dword_1B3330
mulss xmm0, xmm1
call _sinf
movss xmm2, [rbp+var_20]
movaps xmm1, xmm0
movss xmm0, [rbp+var_1C]
movss xmm3, [rbp+var_14]
mulss xmm1, xmm3
addss xmm1, xmm2
call rlVertex2f
mov eax, [rbp+var_18]
add eax, 0Ah
mov [rbp+var_18], eax
jmp loc_D83BA
loc_D852B:
call rlEnd
add rsp, 30h
pop rbp
retn
| double DrawCircleGradient(int a1, long long a2, int a3, int a4, float a5)
{
long long v5; // rdi
long long v6; // rdx
double v7; // xmm0_8
double v8; // xmm0_8
float v10; // [rsp+8h] [rbp-28h]
float v11; // [rsp+14h] [rbp-1Ch]
int i; // [rsp+18h] [rbp-18h]
int v14; // [rsp+20h] [rbp-10h]
v14 = a2;
v5 = 4LL;
rlBegin(4);
for ( i = 0; i < 360; i += 10 )
{
rlColor4ub(a3, SBYTE1(a3), SBYTE2(a3), SHIBYTE(a3));
rlVertex2f((float)a1, (float)v14);
rlColor4ub(a4, SBYTE1(a4), SBYTE2(a4), SHIBYTE(a4));
v10 = (float)(cosf(0.017453292 * (float)(i + 10)) * a5) + (float)a1;
v7 = sinf(0.017453292 * (float)(i + 10));
rlVertex2f(v10, (float)(*(float *)&v7 * a5) + (float)v14);
v5 = (unsigned __int8)a4;
a2 = BYTE1(a4);
rlColor4ub(a4, SBYTE1(a4), SBYTE2(a4), SHIBYTE(a4));
v11 = (float)(cosf(0.017453292 * (float)i) * a5) + (float)a1;
v8 = sinf(0.017453292 * (float)i);
rlVertex2f(v11, (float)(*(float *)&v8 * a5) + (float)v14);
}
return rlEnd(v5, a2, v6);
}
| DrawCircleGradient:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x4],EDX
MOV dword ptr [RBP + -0x8],ECX
MOV dword ptr [RBP + -0xc],EDI
MOV dword ptr [RBP + -0x10],ESI
MOVSS dword ptr [RBP + -0x14],XMM0
MOV EDI,0x4
CALL 0x001b07c0
MOV dword ptr [RBP + -0x18],0x0
LAB_001d83ba:
CMP dword ptr [RBP + -0x18],0x168
JGE 0x001d852b
MOV DL,byte ptr [RBP + -0x4]
MOV CL,byte ptr [RBP + -0x3]
MOV AL,byte ptr [RBP + -0x2]
MOVZX EDI,DL
MOVZX ESI,CL
MOVZX EDX,AL
MOVZX ECX,byte ptr [RBP + -0x1]
CALL 0x001b2160
CVTSI2SS XMM0,dword ptr [RBP + -0xc]
CVTSI2SS XMM1,dword ptr [RBP + -0x10]
CALL 0x001b1f10
MOV DL,byte ptr [RBP + -0x8]
MOV CL,byte ptr [RBP + -0x7]
MOV AL,byte ptr [RBP + -0x6]
MOVZX EDI,DL
MOVZX ESI,CL
MOVZX EDX,AL
MOVZX ECX,byte ptr [RBP + -0x5]
CALL 0x001b2160
CVTSI2SS XMM0,dword ptr [RBP + -0xc]
MOVSS dword ptr [RBP + -0x30],XMM0
MOV EAX,dword ptr [RBP + -0x18]
ADD EAX,0xa
CVTSI2SS XMM1,EAX
MOVSS XMM0,dword ptr [0x002b3330]
MULSS XMM0,XMM1
CALL 0x0010a390
MOVSS XMM1,dword ptr [RBP + -0x30]
MOVSS XMM2,dword ptr [RBP + -0x14]
MULSS XMM0,XMM2
ADDSS XMM0,XMM1
MOVSS dword ptr [RBP + -0x28],XMM0
CVTSI2SS XMM0,dword ptr [RBP + -0x10]
MOVSS dword ptr [RBP + -0x2c],XMM0
MOV EAX,dword ptr [RBP + -0x18]
ADD EAX,0xa
CVTSI2SS XMM1,EAX
MOVSS XMM0,dword ptr [0x002b3330]
MULSS XMM0,XMM1
CALL 0x0010a410
MOVSS XMM2,dword ptr [RBP + -0x2c]
MOVAPS XMM1,XMM0
MOVSS XMM0,dword ptr [RBP + -0x28]
MOVSS XMM3,dword ptr [RBP + -0x14]
MULSS XMM1,XMM3
ADDSS XMM1,XMM2
CALL 0x001b1f10
MOV DL,byte ptr [RBP + -0x8]
MOV CL,byte ptr [RBP + -0x7]
MOV AL,byte ptr [RBP + -0x6]
MOVZX EDI,DL
MOVZX ESI,CL
MOVZX EDX,AL
MOVZX ECX,byte ptr [RBP + -0x5]
CALL 0x001b2160
CVTSI2SS XMM0,dword ptr [RBP + -0xc]
MOVSS dword ptr [RBP + -0x24],XMM0
CVTSI2SS XMM1,dword ptr [RBP + -0x18]
MOVSS XMM0,dword ptr [0x002b3330]
MULSS XMM0,XMM1
CALL 0x0010a390
MOVSS XMM1,dword ptr [RBP + -0x24]
MOVSS XMM2,dword ptr [RBP + -0x14]
MULSS XMM0,XMM2
ADDSS XMM0,XMM1
MOVSS dword ptr [RBP + -0x1c],XMM0
CVTSI2SS XMM0,dword ptr [RBP + -0x10]
MOVSS dword ptr [RBP + -0x20],XMM0
CVTSI2SS XMM1,dword ptr [RBP + -0x18]
MOVSS XMM0,dword ptr [0x002b3330]
MULSS XMM0,XMM1
CALL 0x0010a410
MOVSS XMM2,dword ptr [RBP + -0x20]
MOVAPS XMM1,XMM0
MOVSS XMM0,dword ptr [RBP + -0x1c]
MOVSS XMM3,dword ptr [RBP + -0x14]
MULSS XMM1,XMM3
ADDSS XMM1,XMM2
CALL 0x001b1f10
MOV EAX,dword ptr [RBP + -0x18]
ADD EAX,0xa
MOV dword ptr [RBP + -0x18],EAX
JMP 0x001d83ba
LAB_001d852b:
CALL 0x001b1990
ADD RSP,0x30
POP RBP
RET
|
void DrawCircleGradient(float param_1,int param_2,int param_3,int4 param_4,int4 param_5)
{
float fVar1;
float fVar2;
int4 local_20;
int1 local_10;
int1 uStack_f;
int1 uStack_e;
int1 uStack_d;
int1 local_c;
int1 uStack_b;
int1 uStack_a;
int1 uStack_9;
rlBegin(4);
for (local_20 = 0; local_20 < 0x168; local_20 = local_20 + 10) {
local_c = (int1)param_4;
uStack_b = (int1)((uint)param_4 >> 8);
uStack_a = (int1)((uint)param_4 >> 0x10);
uStack_9 = (int1)((uint)param_4 >> 0x18);
rlColor4ub(local_c,uStack_b,uStack_a,uStack_9);
rlVertex2f((float)param_2,(float)param_3);
local_10 = (int1)param_5;
uStack_f = (int1)((uint)param_5 >> 8);
uStack_e = (int1)((uint)param_5 >> 0x10);
uStack_d = (int1)((uint)param_5 >> 0x18);
rlColor4ub(local_10,uStack_f,uStack_e,uStack_d);
fVar1 = cosf(DAT_002b3330 * (float)(local_20 + 10));
fVar2 = sinf(DAT_002b3330 * (float)(local_20 + 10));
rlVertex2f(fVar1 * param_1 + (float)param_2,fVar2 * param_1 + (float)param_3);
rlColor4ub(local_10,uStack_f,uStack_e,uStack_d);
fVar1 = cosf(DAT_002b3330 * (float)local_20);
fVar2 = sinf(DAT_002b3330 * (float)local_20);
rlVertex2f(fVar1 * param_1 + (float)param_2,fVar2 * param_1 + (float)param_3);
}
rlEnd();
return;
}
| |
52,951 | DrawCircleGradient | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rshapes.c | void DrawCircleGradient(int centerX, int centerY, float radius, Color inner, Color outer)
{
rlBegin(RL_TRIANGLES);
for (int i = 0; i < 360; i += 10)
{
rlColor4ub(inner.r, inner.g, inner.b, inner.a);
rlVertex2f((float)centerX, (float)centerY);
rlColor4ub(outer.r, outer.g, outer.b, outer.a);
rlVertex2f((float)centerX + cosf(DEG2RAD*(i + 10))*radius, (float)centerY + sinf(DEG2RAD*(i + 10))*radius);
rlColor4ub(outer.r, outer.g, outer.b, outer.a);
rlVertex2f((float)centerX + cosf(DEG2RAD*i)*radius, (float)centerY + sinf(DEG2RAD*i)*radius);
}
rlEnd();
} | O2 | c | DrawCircleGradient:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movl %edx, %r13d
movss %xmm0, 0xc(%rsp)
movl %esi, 0x8(%rsp)
movl %edi, %r14d
movl %edx, %eax
shrl $0x8, %eax
movl %eax, 0x4(%rsp)
movl %edx, %eax
shrl $0x10, %eax
movl %eax, (%rsp)
movl %edx, %r12d
shrl $0x18, %r12d
movl %ecx, 0x14(%rsp)
movl %ecx, %ebx
shrl $0x8, %ebx
movl %ecx, %r15d
shrl $0x10, %r15d
shrl $0x18, %ebp
pushq $0x4
popq %rdi
callq 0x51283
cvtsi2ss %r14d, %xmm0
movss %xmm0, 0x10(%rsp)
cvtsi2ssl 0x8(%rsp), %xmm0
movss %xmm0, 0x8(%rsp)
xorl %r14d, %r14d
movzbl %r13b, %eax
movl %eax, 0x24(%rsp)
movzbl 0x4(%rsp), %eax
movl %eax, 0x20(%rsp)
movzbl (%rsp), %eax
movl %eax, 0x1c(%rsp)
movzbl %r12b, %eax
movl %eax, 0x18(%rsp)
movzbl 0x14(%rsp), %r12d
movzbl %bl, %r13d
movzbl %r15b, %ebx
movzbl %bpl, %ebp
cmpl $0x168, %r14d # imm = 0x168
jae 0x66f62
movl 0x24(%rsp), %edi
movl 0x20(%rsp), %esi
movl 0x1c(%rsp), %edx
movl 0x18(%rsp), %ecx
callq 0x52b4f
movss 0x10(%rsp), %xmm0
movss 0x8(%rsp), %xmm1
callq 0x529f9
movl %r12d, %edi
movl %r13d, %esi
movl %ebx, %edx
movl %ebp, %ecx
callq 0x52b4f
leal 0xa(%r14), %r15d
cvtsi2ss %r15d, %xmm1
movss 0x5c619(%rip), %xmm0 # 0xc34d0
mulss %xmm0, %xmm1
movss %xmm1, (%rsp)
movaps %xmm1, %xmm0
callq 0x9390
mulss 0xc(%rsp), %xmm0
addss 0x10(%rsp), %xmm0
movss %xmm0, 0x4(%rsp)
movss (%rsp), %xmm0
callq 0x9410
movaps %xmm0, %xmm1
mulss 0xc(%rsp), %xmm1
addss 0x8(%rsp), %xmm1
movss 0x4(%rsp), %xmm0
callq 0x529f9
movl %r12d, %edi
movl %r13d, %esi
movl %ebx, %edx
movl %ebp, %ecx
callq 0x52b4f
cvtsi2ss %r14d, %xmm0
mulss 0x5c5b6(%rip), %xmm0 # 0xc34d0
movss %xmm0, (%rsp)
callq 0x9390
mulss 0xc(%rsp), %xmm0
addss 0x10(%rsp), %xmm0
movss %xmm0, 0x4(%rsp)
movss (%rsp), %xmm0
callq 0x9410
movaps %xmm0, %xmm1
mulss 0xc(%rsp), %xmm1
addss 0x8(%rsp), %xmm1
movss 0x4(%rsp), %xmm0
callq 0x529f9
movl %r15d, %r14d
jmp 0x66e64
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5265a
| DrawCircleGradient:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov ebp, ecx
mov r13d, edx
movss [rsp+58h+var_4C], xmm0
mov [rsp+58h+var_50], esi
mov r14d, edi
mov eax, edx
shr eax, 8
mov [rsp+58h+var_54], eax
mov eax, edx
shr eax, 10h
mov [rsp+58h+var_58], eax
mov r12d, edx
shr r12d, 18h
mov [rsp+58h+var_44], ecx
mov ebx, ecx
shr ebx, 8
mov r15d, ecx
shr r15d, 10h
shr ebp, 18h
push 4
pop rdi
call rlBegin
cvtsi2ss xmm0, r14d
movss [rsp+58h+var_48], xmm0
cvtsi2ss xmm0, [rsp+58h+var_50]
movss [rsp+58h+var_50], xmm0
xor r14d, r14d
movzx eax, r13b
mov [rsp+58h+var_34], eax
movzx eax, byte ptr [rsp+58h+var_54]
mov [rsp+58h+var_38], eax
movzx eax, byte ptr [rsp+58h+var_58]
mov [rsp+58h+var_3C], eax
movzx eax, r12b
mov [rsp+58h+var_40], eax
movzx r12d, byte ptr [rsp+58h+var_44]
movzx r13d, bl
movzx ebx, r15b
movzx ebp, bpl
loc_66E64:
cmp r14d, 168h
jnb loc_66F62
mov edi, [rsp+58h+var_34]
mov esi, [rsp+58h+var_38]
mov edx, [rsp+58h+var_3C]
mov ecx, [rsp+58h+var_40]
call rlColor4ub
movss xmm0, [rsp+58h+var_48]
movss xmm1, [rsp+58h+var_50]
call rlVertex2f
mov edi, r12d
mov esi, r13d
mov edx, ebx
mov ecx, ebp
call rlColor4ub
lea r15d, [r14+0Ah]
cvtsi2ss xmm1, r15d
movss xmm0, cs:dword_C34D0
mulss xmm1, xmm0
movss [rsp+58h+var_58], xmm1
movaps xmm0, xmm1
call _cosf
mulss xmm0, [rsp+58h+var_4C]
addss xmm0, [rsp+58h+var_48]
movss [rsp+58h+var_54], xmm0
movss xmm0, [rsp+58h+var_58]
call _sinf
movaps xmm1, xmm0
mulss xmm1, [rsp+58h+var_4C]
addss xmm1, [rsp+58h+var_50]
movss xmm0, [rsp+58h+var_54]
call rlVertex2f
mov edi, r12d
mov esi, r13d
mov edx, ebx
mov ecx, ebp
call rlColor4ub
cvtsi2ss xmm0, r14d
mulss xmm0, cs:dword_C34D0
movss [rsp+58h+var_58], xmm0
call _cosf
mulss xmm0, [rsp+58h+var_4C]
addss xmm0, [rsp+58h+var_48]
movss [rsp+58h+var_54], xmm0
movss xmm0, [rsp+58h+var_58]
call _sinf
movaps xmm1, xmm0
mulss xmm1, [rsp+58h+var_4C]
addss xmm1, [rsp+58h+var_50]
movss xmm0, [rsp+58h+var_54]
call rlVertex2f
mov r14d, r15d
jmp loc_66E64
loc_66F62:
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp rlEnd
| double DrawCircleGradient(int a1, long long a2, unsigned int a3, unsigned int a4, float a5)
{
char v5; // r13
unsigned int v7; // r12d
unsigned int v8; // ebx
unsigned int v9; // r15d
unsigned int v10; // ebp
long long v11; // rdi
long long v12; // rdx
int v13; // r14d
double v14; // xmm0_8
__m128 v15; // xmm0
__m128 v16; // xmm1
__m128 v17; // xmm0
__m128 v18; // xmm1
unsigned int v20; // [rsp+0h] [rbp-58h]
float v21; // [rsp+0h] [rbp-58h]
float v22; // [rsp+0h] [rbp-58h]
unsigned int v23; // [rsp+4h] [rbp-54h]
unsigned int v24; // [rsp+4h] [rbp-54h]
unsigned int v25; // [rsp+4h] [rbp-54h]
float v26; // [rsp+8h] [rbp-50h]
float v28; // [rsp+10h] [rbp-48h]
unsigned __int8 v29; // [rsp+14h] [rbp-44h]
char v30; // [rsp+1Ch] [rbp-3Ch]
char v31; // [rsp+20h] [rbp-38h]
v5 = a3;
v23 = a3 >> 8;
v20 = HIWORD(a3);
v7 = HIBYTE(a3);
v29 = a4;
v8 = a4 >> 8;
v9 = HIWORD(a4);
v10 = HIBYTE(a4);
v11 = 4LL;
rlBegin(4);
v28 = (float)a1;
v26 = (float)(int)a2;
v13 = 0;
v31 = v23;
v30 = v20;
while ( (unsigned int)v13 < 0x168 )
{
rlColor4ub(v5, v31, v30, v7);
rlVertex2f((__m128)LODWORD(v28), (__m128)LODWORD(v26));
rlColor4ub(v29, v8, v9, v10);
v21 = (float)(v13 + 10) * 0.017453292;
v14 = cosf(v21);
*(float *)&v24 = (float)(*(float *)&v14 * a5) + v28;
v15 = (__m128)LODWORD(v21);
*(double *)v15.m128_u64 = sinf(v21);
v16 = v15;
v16.m128_f32[0] = (float)(v15.m128_f32[0] * a5) + v26;
rlVertex2f((__m128)v24, v16);
v11 = v29;
a2 = (unsigned __int8)v8;
rlColor4ub(v29, v8, v9, v10);
v22 = (float)v13 * 0.017453292;
*(double *)v15.m128_u64 = cosf(v22);
*(float *)&v25 = (float)(v15.m128_f32[0] * a5) + v28;
v17 = (__m128)LODWORD(v22);
*(double *)v17.m128_u64 = sinf(v22);
v18 = v17;
v18.m128_f32[0] = (float)(v17.m128_f32[0] * a5) + v26;
rlVertex2f((__m128)v25, v18);
v13 += 10;
}
return rlEnd(v11, a2, v12);
}
| DrawCircleGradient:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV EBP,ECX
MOV R13D,EDX
MOVSS dword ptr [RSP + 0xc],XMM0
MOV dword ptr [RSP + 0x8],ESI
MOV R14D,EDI
MOV EAX,EDX
SHR EAX,0x8
MOV dword ptr [RSP + 0x4],EAX
MOV EAX,EDX
SHR EAX,0x10
MOV dword ptr [RSP],EAX
MOV R12D,EDX
SHR R12D,0x18
MOV dword ptr [RSP + 0x14],ECX
MOV EBX,ECX
SHR EBX,0x8
MOV R15D,ECX
SHR R15D,0x10
SHR EBP,0x18
PUSH 0x4
POP RDI
CALL 0x00151283
CVTSI2SS XMM0,R14D
MOVSS dword ptr [RSP + 0x10],XMM0
CVTSI2SS XMM0,dword ptr [RSP + 0x8]
MOVSS dword ptr [RSP + 0x8],XMM0
XOR R14D,R14D
MOVZX EAX,R13B
MOV dword ptr [RSP + 0x24],EAX
MOVZX EAX,byte ptr [RSP + 0x4]
MOV dword ptr [RSP + 0x20],EAX
MOVZX EAX,byte ptr [RSP]
MOV dword ptr [RSP + 0x1c],EAX
MOVZX EAX,R12B
MOV dword ptr [RSP + 0x18],EAX
MOVZX R12D,byte ptr [RSP + 0x14]
MOVZX R13D,BL
MOVZX EBX,R15B
MOVZX EBP,BPL
LAB_00166e64:
CMP R14D,0x168
JNC 0x00166f62
MOV EDI,dword ptr [RSP + 0x24]
MOV ESI,dword ptr [RSP + 0x20]
MOV EDX,dword ptr [RSP + 0x1c]
MOV ECX,dword ptr [RSP + 0x18]
CALL 0x00152b4f
MOVSS XMM0,dword ptr [RSP + 0x10]
MOVSS XMM1,dword ptr [RSP + 0x8]
CALL 0x001529f9
MOV EDI,R12D
MOV ESI,R13D
MOV EDX,EBX
MOV ECX,EBP
CALL 0x00152b4f
LEA R15D,[R14 + 0xa]
CVTSI2SS XMM1,R15D
MOVSS XMM0,dword ptr [0x001c34d0]
MULSS XMM1,XMM0
MOVSS dword ptr [RSP],XMM1
MOVAPS XMM0,XMM1
CALL 0x00109390
MULSS XMM0,dword ptr [RSP + 0xc]
ADDSS XMM0,dword ptr [RSP + 0x10]
MOVSS dword ptr [RSP + 0x4],XMM0
MOVSS XMM0,dword ptr [RSP]
CALL 0x00109410
MOVAPS XMM1,XMM0
MULSS XMM1,dword ptr [RSP + 0xc]
ADDSS XMM1,dword ptr [RSP + 0x8]
MOVSS XMM0,dword ptr [RSP + 0x4]
CALL 0x001529f9
MOV EDI,R12D
MOV ESI,R13D
MOV EDX,EBX
MOV ECX,EBP
CALL 0x00152b4f
CVTSI2SS XMM0,R14D
MULSS XMM0,dword ptr [0x001c34d0]
MOVSS dword ptr [RSP],XMM0
CALL 0x00109390
MULSS XMM0,dword ptr [RSP + 0xc]
ADDSS XMM0,dword ptr [RSP + 0x10]
MOVSS dword ptr [RSP + 0x4],XMM0
MOVSS XMM0,dword ptr [RSP]
CALL 0x00109410
MOVAPS XMM1,XMM0
MULSS XMM1,dword ptr [RSP + 0xc]
ADDSS XMM1,dword ptr [RSP + 0x8]
MOVSS XMM0,dword ptr [RSP + 0x4]
CALL 0x001529f9
MOV R14D,R15D
JMP 0x00166e64
LAB_00166f62:
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0015265a
|
void DrawCircleGradient(float param_1,int param_2,int param_3,int8 param_4,ulong param_5)
{
ulong uVar1;
int1 uVar2;
ulong uVar3;
uint uVar4;
float fVar5;
float fVar6;
float fVar7;
float fVar8;
int1 local_44;
rlBegin(4);
fVar5 = (float)param_2;
fVar6 = (float)param_3;
local_44 = (int1)param_5;
uVar3 = param_5 >> 8 & 0xff;
uVar1 = param_5 >> 0x10 & 0xff;
uVar2 = (int1)(param_5 >> 0x18);
uVar4 = 0;
while (uVar4 < 0x168) {
rlColor4ub((uint)param_4 & 0xff,(uint)((ulong)param_4 >> 8) & 0xff,
(uint)((ulong)param_4 >> 0x10) & 0xff,(uint)((ulong)param_4 >> 0x18) & 0xff);
rlVertex2f(fVar5,fVar6);
rlColor4ub(local_44,uVar3,uVar1,uVar2);
fVar8 = (float)(int)(uVar4 + 10) * DAT_001c34d0;
fVar7 = cosf(fVar8);
fVar8 = sinf(fVar8);
rlVertex2f(fVar7 * param_1 + fVar5,fVar8 * param_1 + fVar6);
rlColor4ub(local_44,uVar3,uVar1,uVar2);
fVar7 = (float)(int)uVar4 * DAT_001c34d0;
fVar8 = cosf(fVar7);
fVar7 = sinf(fVar7);
rlVertex2f(fVar8 * param_1 + fVar5,fVar7 * param_1 + fVar6);
uVar4 = uVar4 + 10;
}
rlEnd();
return;
}
| |
52,952 | LefDefParser::defiNonDefault::addMinCuts(char const*, int) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defiNonDefault.cpp | void defiNonDefault::addMinCuts(const char* name, int numCuts) {
if (numMinCuts_ == minCutsAllocated_) {
int i;
char** cln;
int* nc;
if (minCutsAllocated_ == 0)
minCutsAllocated_ = 2;
else
minCutsAllocated_ *= 2;
cln = (char**)malloc(sizeof(char*)* minCutsAllocated_);
nc = (int*)malloc(sizeof(int)* minCutsAllocated_);
for (i = 0; i < numMinCuts_; i++) {
cln[i] = cutLayerName_[i];
nc[i] = numCuts_[i];
}
if (minCutsAllocated_ > 2) {
free((char*)(cutLayerName_));
free((char*)(numCuts_));
}
cutLayerName_ = cln;
numCuts_ = nc;
}
cutLayerName_[numMinCuts_] = (char*)malloc(strlen(name)+1);
strcpy(cutLayerName_[numMinCuts_], defData->DEFCASE(name));
numCuts_[numMinCuts_] = numCuts;
numMinCuts_ += 1;
} | O0 | cpp | LefDefParser::defiNonDefault::addMinCuts(char const*, int):
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x30(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movl 0x78(%rcx), %eax
cmpl 0x7c(%rcx), %eax
jne 0x44b1b
movq 0x8(%rsp), %rax
cmpl $0x0, 0x7c(%rax)
jne 0x44a31
movq 0x8(%rsp), %rax
movl $0x2, 0x7c(%rax)
jmp 0x44a3e
movq 0x8(%rsp), %rax
movl 0x7c(%rax), %ecx
shll %ecx
movl %ecx, 0x7c(%rax)
movq 0x8(%rsp), %rax
movslq 0x7c(%rax), %rdi
shlq $0x3, %rdi
callq 0x72d0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rsp)
movslq 0x7c(%rax), %rdi
shlq $0x2, %rdi
callq 0x72d0
movq %rax, 0x10(%rsp)
movl $0x0, 0x20(%rsp)
movq 0x8(%rsp), %rcx
movl 0x20(%rsp), %eax
cmpl 0x78(%rcx), %eax
jge 0x44ad1
movq 0x8(%rsp), %rax
movq 0x80(%rax), %rcx
movslq 0x20(%rsp), %rdx
movq (%rcx,%rdx,8), %rsi
movq 0x18(%rsp), %rcx
movslq 0x20(%rsp), %rdx
movq %rsi, (%rcx,%rdx,8)
movq 0x88(%rax), %rax
movslq 0x20(%rsp), %rcx
movl (%rax,%rcx,4), %edx
movq 0x10(%rsp), %rax
movslq 0x20(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x44a77
movq 0x8(%rsp), %rax
cmpl $0x2, 0x7c(%rax)
jle 0x44afe
movq 0x8(%rsp), %rax
movq 0x80(%rax), %rdi
callq 0x72a0
movq 0x8(%rsp), %rax
movq 0x88(%rax), %rdi
callq 0x72a0
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x80(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x88(%rax)
movq 0x28(%rsp), %rdi
callq 0x70e0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x72d0
movq %rax, %rsi
movq 0x8(%rsp), %rax
movq 0x80(%rax), %rcx
movslq 0x78(%rax), %rdx
movq %rsi, (%rcx,%rdx,8)
movq 0x80(%rax), %rcx
movslq 0x78(%rax), %rdx
movq (%rcx,%rdx,8), %rcx
movq %rcx, (%rsp)
movq 0xb8(%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0x250b0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x7220
movq 0x8(%rsp), %rax
movl 0x24(%rsp), %esi
movq 0x88(%rax), %rcx
movslq 0x78(%rax), %rdx
movl %esi, (%rcx,%rdx,4)
movl 0x78(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x78(%rax)
addq $0x38, %rsp
retq
nopl (%rax)
| _ZN12LefDefParser14defiNonDefault10addMinCutsEPKci:
sub rsp, 38h
mov [rsp+38h+var_8], rdi
mov [rsp+38h+var_10], rsi
mov [rsp+38h+var_14], edx
mov rcx, [rsp+38h+var_8]
mov [rsp+38h+var_30], rcx
mov eax, [rcx+78h]
cmp eax, [rcx+7Ch]
jnz loc_44B1B
mov rax, [rsp+38h+var_30]
cmp dword ptr [rax+7Ch], 0
jnz short loc_44A31
mov rax, [rsp+38h+var_30]
mov dword ptr [rax+7Ch], 2
jmp short loc_44A3E
loc_44A31:
mov rax, [rsp+38h+var_30]
mov ecx, [rax+7Ch]
shl ecx, 1
mov [rax+7Ch], ecx
loc_44A3E:
mov rax, [rsp+38h+var_30]
movsxd rdi, dword ptr [rax+7Ch]
shl rdi, 3
call _malloc
mov rcx, rax
mov rax, [rsp+38h+var_30]
mov [rsp+38h+var_20], rcx
movsxd rdi, dword ptr [rax+7Ch]
shl rdi, 2
call _malloc
mov [rsp+38h+var_28], rax
mov [rsp+38h+var_18], 0
loc_44A77:
mov rcx, [rsp+38h+var_30]
mov eax, [rsp+38h+var_18]
cmp eax, [rcx+78h]
jge short loc_44AD1
mov rax, [rsp+38h+var_30]
mov rcx, [rax+80h]
movsxd rdx, [rsp+38h+var_18]
mov rsi, [rcx+rdx*8]
mov rcx, [rsp+38h+var_20]
movsxd rdx, [rsp+38h+var_18]
mov [rcx+rdx*8], rsi
mov rax, [rax+88h]
movsxd rcx, [rsp+38h+var_18]
mov edx, [rax+rcx*4]
mov rax, [rsp+38h+var_28]
movsxd rcx, [rsp+38h+var_18]
mov [rax+rcx*4], edx
mov eax, [rsp+38h+var_18]
add eax, 1
mov [rsp+38h+var_18], eax
jmp short loc_44A77
loc_44AD1:
mov rax, [rsp+38h+var_30]
cmp dword ptr [rax+7Ch], 2
jle short loc_44AFE
mov rax, [rsp+38h+var_30]
mov rdi, [rax+80h]
call _free
mov rax, [rsp+38h+var_30]
mov rdi, [rax+88h]
call _free
loc_44AFE:
mov rax, [rsp+38h+var_30]
mov rcx, [rsp+38h+var_20]
mov [rax+80h], rcx
mov rcx, [rsp+38h+var_28]
mov [rax+88h], rcx
loc_44B1B:
mov rdi, [rsp+38h+var_10]
call _strlen
mov rdi, rax
add rdi, 1
call _malloc
mov rsi, rax
mov rax, [rsp+38h+var_30]
mov rcx, [rax+80h]
movsxd rdx, dword ptr [rax+78h]
mov [rcx+rdx*8], rsi
mov rcx, [rax+80h]
movsxd rdx, dword ptr [rax+78h]
mov rcx, [rcx+rdx*8]
mov [rsp+38h+var_38], rcx
mov rdi, [rax+0B8h]; this
mov rsi, [rsp+38h+var_10]; char *
call _ZN12LefDefParser8defrData7DEFCASEEPKc; LefDefParser::defrData::DEFCASE(char const*)
mov rdi, [rsp+38h+var_38]
mov rsi, rax
call _strcpy
mov rax, [rsp+38h+var_30]
mov esi, [rsp+38h+var_14]
mov rcx, [rax+88h]
movsxd rdx, dword ptr [rax+78h]
mov [rcx+rdx*4], esi
mov ecx, [rax+78h]
add ecx, 1
mov [rax+78h], ecx
add rsp, 38h
retn
| LefDefParser::defiNonDefault * LefDefParser::defiNonDefault::addMinCuts(
LefDefParser::defiNonDefault *this,
const char *a2,
int a3)
{
long long v3; // rax
const char *v4; // rax
LefDefParser::defiNonDefault *result; // rax
long long v6; // [rsp+0h] [rbp-38h]
long long v7; // [rsp+10h] [rbp-28h]
long long v8; // [rsp+18h] [rbp-20h]
int i; // [rsp+20h] [rbp-18h]
if ( *((_DWORD *)this + 30) == *((_DWORD *)this + 31) )
{
if ( *((_DWORD *)this + 31) )
*((_DWORD *)this + 31) *= 2;
else
*((_DWORD *)this + 31) = 2;
v8 = malloc(8LL * *((int *)this + 31));
v7 = malloc(4LL * *((int *)this + 31));
for ( i = 0; i < *((_DWORD *)this + 30); ++i )
{
*(_QWORD *)(v8 + 8LL * i) = *(_QWORD *)(*((_QWORD *)this + 16) + 8LL * i);
*(_DWORD *)(v7 + 4LL * i) = *(_DWORD *)(*((_QWORD *)this + 17) + 4LL * i);
}
if ( *((int *)this + 31) > 2 )
{
free(*((_QWORD *)this + 16));
free(*((_QWORD *)this + 17));
}
*((_QWORD *)this + 16) = v8;
*((_QWORD *)this + 17) = v7;
}
v3 = strlen(a2);
*(_QWORD *)(*((_QWORD *)this + 16) + 8LL * *((int *)this + 30)) = malloc(v3 + 1);
v6 = *(_QWORD *)(*((_QWORD *)this + 16) + 8LL * *((int *)this + 30));
v4 = LefDefParser::defrData::DEFCASE(*((LefDefParser::defrData **)this + 23), a2);
strcpy(v6, v4);
result = this;
*(_DWORD *)(*((_QWORD *)this + 17) + 4LL * (int)(*((_DWORD *)this + 30))++) = a3;
return result;
}
| addMinCuts:
SUB RSP,0x38
MOV qword ptr [RSP + 0x30],RDI
MOV qword ptr [RSP + 0x28],RSI
MOV dword ptr [RSP + 0x24],EDX
MOV RCX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x8],RCX
MOV EAX,dword ptr [RCX + 0x78]
CMP EAX,dword ptr [RCX + 0x7c]
JNZ 0x00144b1b
MOV RAX,qword ptr [RSP + 0x8]
CMP dword ptr [RAX + 0x7c],0x0
JNZ 0x00144a31
MOV RAX,qword ptr [RSP + 0x8]
MOV dword ptr [RAX + 0x7c],0x2
JMP 0x00144a3e
LAB_00144a31:
MOV RAX,qword ptr [RSP + 0x8]
MOV ECX,dword ptr [RAX + 0x7c]
SHL ECX,0x1
MOV dword ptr [RAX + 0x7c],ECX
LAB_00144a3e:
MOV RAX,qword ptr [RSP + 0x8]
MOVSXD RDI,dword ptr [RAX + 0x7c]
SHL RDI,0x3
CALL 0x001072d0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x18],RCX
MOVSXD RDI,dword ptr [RAX + 0x7c]
SHL RDI,0x2
CALL 0x001072d0
MOV qword ptr [RSP + 0x10],RAX
MOV dword ptr [RSP + 0x20],0x0
LAB_00144a77:
MOV RCX,qword ptr [RSP + 0x8]
MOV EAX,dword ptr [RSP + 0x20]
CMP EAX,dword ptr [RCX + 0x78]
JGE 0x00144ad1
MOV RAX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RAX + 0x80]
MOVSXD RDX,dword ptr [RSP + 0x20]
MOV RSI,qword ptr [RCX + RDX*0x8]
MOV RCX,qword ptr [RSP + 0x18]
MOVSXD RDX,dword ptr [RSP + 0x20]
MOV qword ptr [RCX + RDX*0x8],RSI
MOV RAX,qword ptr [RAX + 0x88]
MOVSXD RCX,dword ptr [RSP + 0x20]
MOV EDX,dword ptr [RAX + RCX*0x4]
MOV RAX,qword ptr [RSP + 0x10]
MOVSXD RCX,dword ptr [RSP + 0x20]
MOV dword ptr [RAX + RCX*0x4],EDX
MOV EAX,dword ptr [RSP + 0x20]
ADD EAX,0x1
MOV dword ptr [RSP + 0x20],EAX
JMP 0x00144a77
LAB_00144ad1:
MOV RAX,qword ptr [RSP + 0x8]
CMP dword ptr [RAX + 0x7c],0x2
JLE 0x00144afe
MOV RAX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RAX + 0x80]
CALL 0x001072a0
MOV RAX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RAX + 0x88]
CALL 0x001072a0
LAB_00144afe:
MOV RAX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RSP + 0x18]
MOV qword ptr [RAX + 0x80],RCX
MOV RCX,qword ptr [RSP + 0x10]
MOV qword ptr [RAX + 0x88],RCX
LAB_00144b1b:
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x001070e0
MOV RDI,RAX
ADD RDI,0x1
CALL 0x001072d0
MOV RSI,RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RAX + 0x80]
MOVSXD RDX,dword ptr [RAX + 0x78]
MOV qword ptr [RCX + RDX*0x8],RSI
MOV RCX,qword ptr [RAX + 0x80]
MOVSXD RDX,dword ptr [RAX + 0x78]
MOV RCX,qword ptr [RCX + RDX*0x8]
MOV qword ptr [RSP],RCX
MOV RDI,qword ptr [RAX + 0xb8]
MOV RSI,qword ptr [RSP + 0x28]
CALL 0x001250b0
MOV RDI,qword ptr [RSP]
MOV RSI,RAX
CALL 0x00107220
MOV RAX,qword ptr [RSP + 0x8]
MOV ESI,dword ptr [RSP + 0x24]
MOV RCX,qword ptr [RAX + 0x88]
MOVSXD RDX,dword ptr [RAX + 0x78]
MOV dword ptr [RCX + RDX*0x4],ESI
MOV ECX,dword ptr [RAX + 0x78]
ADD ECX,0x1
MOV dword ptr [RAX + 0x78],ECX
ADD RSP,0x38
RET
|
/* LefDefParser::defiNonDefault::addMinCuts(char const*, int) */
void __thiscall
LefDefParser::defiNonDefault::addMinCuts(defiNonDefault *this,char *param_1,int param_2)
{
char *__dest;
void *pvVar1;
void *pvVar2;
size_t sVar3;
char *__src;
int local_18;
if (*(int *)(this + 0x78) == *(int *)(this + 0x7c)) {
if (*(int *)(this + 0x7c) == 0) {
*(int4 *)(this + 0x7c) = 2;
}
else {
*(int *)(this + 0x7c) = *(int *)(this + 0x7c) << 1;
}
pvVar1 = malloc((long)*(int *)(this + 0x7c) << 3);
pvVar2 = malloc((long)*(int *)(this + 0x7c) << 2);
for (local_18 = 0; local_18 < *(int *)(this + 0x78); local_18 = local_18 + 1) {
*(int8 *)((long)pvVar1 + (long)local_18 * 8) =
*(int8 *)(*(long *)(this + 0x80) + (long)local_18 * 8);
*(int4 *)((long)pvVar2 + (long)local_18 * 4) =
*(int4 *)(*(long *)(this + 0x88) + (long)local_18 * 4);
}
if (2 < *(int *)(this + 0x7c)) {
free(*(void **)(this + 0x80));
free(*(void **)(this + 0x88));
}
*(void **)(this + 0x80) = pvVar1;
*(void **)(this + 0x88) = pvVar2;
}
sVar3 = strlen(param_1);
pvVar1 = malloc(sVar3 + 1);
*(void **)(*(long *)(this + 0x80) + (long)*(int *)(this + 0x78) * 8) = pvVar1;
__dest = *(char **)(*(long *)(this + 0x80) + (long)*(int *)(this + 0x78) * 8);
__src = (char *)defrData::DEFCASE(*(defrData **)(this + 0xb8),param_1);
strcpy(__dest,__src);
*(int *)(*(long *)(this + 0x88) + (long)*(int *)(this + 0x78) * 4) = param_2;
*(int *)(this + 0x78) = *(int *)(this + 0x78) + 1;
return;
}
| |
52,953 | ggml_set_name | ngxson[P]ggml-easy/ggml/src/ggml.c | struct ggml_tensor * ggml_set_name(struct ggml_tensor * tensor, const char * name) {
size_t i;
for (i = 0; i < sizeof(tensor->name) - 1 && name[i] != '\0'; i++) {
tensor->name[i] = name[i];
}
tensor->name[i] = '\0';
return tensor;
} | O0 | c | ggml_set_name:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq $0x0, -0x18(%rsp)
xorl %eax, %eax
cmpq $0x3f, -0x18(%rsp)
movb %al, -0x19(%rsp)
jae 0x4a9e9
movq -0x10(%rsp), %rax
movq -0x18(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x19(%rsp)
movb -0x19(%rsp), %al
testb $0x1, %al
jne 0x4a9f3
jmp 0x4aa21
movq -0x10(%rsp), %rax
movq -0x18(%rsp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rsp), %rax
movq -0x18(%rsp), %rcx
movb %dl, 0x100(%rax,%rcx)
movq -0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rsp)
jmp 0x4a9c3
movq -0x8(%rsp), %rax
movq -0x18(%rsp), %rcx
movb $0x0, 0x100(%rax,%rcx)
movq -0x8(%rsp), %rax
retq
nopl (%rax)
| ggml_set_name:
mov [rsp+var_8], rdi
mov [rsp+var_10], rsi
mov [rsp+var_18], 0
loc_4A9C3:
xor eax, eax
cmp [rsp+var_18], 3Fh ; '?'
mov [rsp+var_19], al
jnb short loc_4A9E9
mov rax, [rsp+var_10]
mov rcx, [rsp+var_18]
movsx eax, byte ptr [rax+rcx]
cmp eax, 0
setnz al
mov [rsp+var_19], al
loc_4A9E9:
mov al, [rsp+var_19]
test al, 1
jnz short loc_4A9F3
jmp short loc_4AA21
loc_4A9F3:
mov rax, [rsp+var_10]
mov rcx, [rsp+var_18]
mov dl, [rax+rcx]
mov rax, [rsp+var_8]
mov rcx, [rsp+var_18]
mov [rax+rcx+100h], dl
mov rax, [rsp+var_18]
add rax, 1
mov [rsp+var_18], rax
jmp short loc_4A9C3
loc_4AA21:
mov rax, [rsp+var_8]
mov rcx, [rsp+var_18]
mov byte ptr [rax+rcx+100h], 0
mov rax, [rsp+var_8]
retn
| long long ggml_set_name(long long a1, long long a2)
{
bool v3; // [rsp+1h] [rbp-19h]
unsigned long long i; // [rsp+2h] [rbp-18h]
for ( i = 0LL; ; ++i )
{
v3 = 0;
if ( i < 0x3F )
v3 = *(_BYTE *)(a2 + i) != 0;
if ( !v3 )
break;
*(_BYTE *)(a1 + i + 256) = *(_BYTE *)(a2 + i);
}
*(_BYTE *)(a1 + i + 256) = 0;
return a1;
}
| ggml_set_name:
MOV qword ptr [RSP + -0x8],RDI
MOV qword ptr [RSP + -0x10],RSI
MOV qword ptr [RSP + -0x18],0x0
LAB_0014a9c3:
XOR EAX,EAX
CMP qword ptr [RSP + -0x18],0x3f
MOV byte ptr [RSP + -0x19],AL
JNC 0x0014a9e9
MOV RAX,qword ptr [RSP + -0x10]
MOV RCX,qword ptr [RSP + -0x18]
MOVSX EAX,byte ptr [RAX + RCX*0x1]
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RSP + -0x19],AL
LAB_0014a9e9:
MOV AL,byte ptr [RSP + -0x19]
TEST AL,0x1
JNZ 0x0014a9f3
JMP 0x0014aa21
LAB_0014a9f3:
MOV RAX,qword ptr [RSP + -0x10]
MOV RCX,qword ptr [RSP + -0x18]
MOV DL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RSP + -0x8]
MOV RCX,qword ptr [RSP + -0x18]
MOV byte ptr [RAX + RCX*0x1 + 0x100],DL
MOV RAX,qword ptr [RSP + -0x18]
ADD RAX,0x1
MOV qword ptr [RSP + -0x18],RAX
JMP 0x0014a9c3
LAB_0014aa21:
MOV RAX,qword ptr [RSP + -0x8]
MOV RCX,qword ptr [RSP + -0x18]
MOV byte ptr [RAX + RCX*0x1 + 0x100],0x0
MOV RAX,qword ptr [RSP + -0x8]
RET
|
long ggml_set_name(long param_1,long param_2)
{
bool bVar1;
int8 local_18;
local_18 = 0;
while( true ) {
bVar1 = false;
if (local_18 < 0x3f) {
bVar1 = *(char *)(param_2 + local_18) != '\0';
}
if (!bVar1) break;
*(int1 *)(param_1 + 0x100 + local_18) = *(int1 *)(param_2 + local_18);
local_18 = local_18 + 1;
}
*(int1 *)(param_1 + 0x100 + local_18) = 0;
return param_1;
}
| |
52,954 | testing::internal::JsonUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int) | giladroyz[P]FindPeaks/build_O3/_deps/googletest-src/googletest/src/gtest.cc | void JsonUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
int /*iteration*/) {
FILE* jsonout = OpenFileForWriting(output_file_);
std::stringstream stream;
PrintJsonUnitTest(&stream, unit_test);
fprintf(jsonout, "%s", StringStreamToString(&stream).c_str());
fclose(jsonout);
} | O3 | cpp | testing::internal::JsonUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int):
pushq %r14
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rsi, %r14
addq $0x8, %rdi
callq 0x23fe2
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x8340
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x2856a
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x1cbbf
leaq 0x10(%rsp), %r14
movq -0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x8580
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0x2850e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84e0
movq %rbx, %rdi
callq 0x84a0
movq 0x30a73(%rip), %rsi # 0x58f90
leaq 0x20(%rsp), %rdi
callq 0x8390
leaq 0xa0(%rsp), %rdi
callq 0x8190
addq $0x1a8, %rsp # imm = 0x1A8
popq %rbx
popq %r14
retq
jmp 0x28541
movq %rax, %rbx
movq 0x30a45(%rip), %rsi # 0x58f90
leaq 0x20(%rsp), %rdi
callq 0x8390
leaq 0xa0(%rsp), %rdi
callq 0x8190
movq %rbx, %rdi
callq 0x8990
| _ZN7testing8internal25JsonUnitTestResultPrinter18OnTestIterationEndERKNS_8UnitTestEi:
push r14
push rbx
sub rsp, 1A8h
mov r14, rsi
add rdi, 8; int
call _ZN7testing8internalL18OpenFileForWritingERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; testing::internal::OpenFileForWriting(std::string const&)
mov rbx, rax
lea rdi, [rsp+1B8h+var_198]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(void)
lea rdi, [rsp+1B8h+var_188]; this
mov rsi, r14; std::ostream *
call _ZN7testing8internal25JsonUnitTestResultPrinter17PrintJsonUnitTestEPSoRKNS_8UnitTestE; testing::internal::JsonUnitTestResultPrinter::PrintJsonUnitTest(std::ostream *,testing::UnitTest const&)
mov rdi, rsp
lea rsi, [rsp+1B8h+var_198]
call _ZN7testing8internal20StringStreamToStringEPNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEE; testing::internal::StringStreamToString(std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>> *)
lea r14, [rsp+1B8h+var_1A8]
mov rdi, [r14-10h]
mov rsi, rbx
call _fputs
mov rdi, [r14-10h]; void *
cmp rdi, r14
jz short loc_2850E
mov rsi, [rsp+1B8h+var_1A8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2850E:
mov rdi, rbx
call _fclose
mov rsi, cs:_ZTTNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+1B8h+var_198]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED2Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
lea rdi, [rsp+1B8h+var_118]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
add rsp, 1A8h
pop rbx
pop r14
retn
jmp short $+2
loc_28541:
mov rbx, rax
mov rsi, cs:_ZTTNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+arg_18]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED2Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
lea rdi, [rsp+arg_98]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
mov rdi, rbx
call __Unwind_Resume
| void testing::internal::JsonUnitTestResultPrinter::OnTestIterationEnd(
testing::internal::JsonUnitTestResultPrinter *this,
const testing::UnitTest *a2)
{
long long v2; // rbx
const testing::UnitTest *v3; // rdx
long long *v4; // [rsp+0h] [rbp-1B8h] BYREF
long long v5; // [rsp+10h] [rbp-1A8h] BYREF
_BYTE v6[16]; // [rsp+20h] [rbp-198h] BYREF
_BYTE v7[112]; // [rsp+30h] [rbp-188h] BYREF
_BYTE v8[280]; // [rsp+A0h] [rbp-118h] BYREF
v2 = testing::internal::OpenFileForWriting((_QWORD *)this + 1);
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(v6);
testing::internal::JsonUnitTestResultPrinter::PrintJsonUnitTest(
(testing::internal::JsonUnitTestResultPrinter *)v7,
a2,
v3);
testing::internal::StringStreamToString((long long)&v4, (long long)v6);
fputs(v4, v2);
if ( v4 != &v5 )
operator delete(v4, v5 + 1);
fclose(v2);
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream(
v6,
&`VTT for'std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>);
std::ios_base::~ios_base((std::ios_base *)v8);
}
| OnTestIterationEnd:
PUSH R14
PUSH RBX
SUB RSP,0x1a8
MOV R14,RSI
ADD RDI,0x8
CALL 0x00123fe2
MOV RBX,RAX
LEA RDI,[RSP + 0x20]
CALL 0x00108340
LEA RDI,[RSP + 0x30]
LAB_001284d2:
MOV RSI,R14
CALL 0x0012856a
LAB_001284da:
MOV RDI,RSP
LEA RSI,[RSP + 0x20]
CALL 0x0011cbbf
LAB_001284e7:
LEA R14,[RSP + 0x10]
MOV RDI,qword ptr [R14 + -0x10]
MOV RSI,RBX
CALL 0x00108580
MOV RDI,qword ptr [R14 + -0x10]
CMP RDI,R14
JZ 0x0012850e
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x001084e0
LAB_0012850e:
MOV RDI,RBX
CALL 0x001084a0
MOV RSI,qword ptr [0x00158f90]
LEA RDI,[RSP + 0x20]
CALL 0x00108390
LEA RDI,[RSP + 0xa0]
CALL 0x00108190
ADD RSP,0x1a8
POP RBX
POP R14
RET
|
/* testing::internal::JsonUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int)
*/
void testing::internal::JsonUnitTestResultPrinter::OnTestIterationEnd(UnitTest *param_1,int param_2)
{
FILE *__stream;
int4 in_register_00000034;
long *local_1b8 [2];
long local_1a8 [2];
stringstream local_198 [16];
ostream local_188 [112];
ios_base local_118 [264];
__stream = (FILE *)OpenFileForWriting((string *)(param_1 + 8));
std::__cxx11::stringstream::stringstream(local_198);
/* try { // try from 001284d2 to 001284d9 has its CatchHandler @ 00128541 */
PrintJsonUnitTest(local_188,(UnitTest *)CONCAT44(in_register_00000034,param_2));
/* try { // try from 001284da to 001284e6 has its CatchHandler @ 0012853f */
StringStreamToString((stringstream *)local_1b8);
fputs((char *)local_1b8[0],__stream);
if (local_1b8[0] != local_1a8) {
operator_delete(local_1b8[0],local_1a8[0] + 1);
}
fclose(__stream);
std::__cxx11::stringstream::~stringstream(local_198);
std::ios_base::~ios_base(local_118);
return;
}
| |
52,955 | action_p_add | qoraal-tictactoe/build_O0/_deps/qoraal_engine-src/src/parts/engine.c | int32_t
action_p_add (PENGINE_T instance, uint32_t parm, uint32_t flags)
{
int32_t value ;
int32_t p = 0 ;
if (flags & (PART_ACTION_FLAG_VALIDATE)) {
return parts_valadate_int (instance, parm, flags, INT_MIN, INT_MAX) ;
}
value = parts_get_int (instance, parm, flags, INT_MIN, INT_MAX) ;
engine_get_variable (instance, ENGINE_VARIABLE_PARAMETER, &p) ;
value += p ;
engine_set_variable (instance, ENGINE_VARIABLE_PARAMETER, value) ;
return value ;
} | O0 | c | action_p_add:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x18(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x8243
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl $0x80000000, %ecx # imm = 0x80000000
movl $0x7fffffff, %r8d # imm = 0x7FFFFFFF
callq 0x91b0
movl %eax, -0x4(%rbp)
jmp 0x8292
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl $0x80000000, %ecx # imm = 0x80000000
movl $0x7fffffff, %r8d # imm = 0x7FFFFFFF
callq 0x92f0
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
leaq -0x20(%rbp), %rdx
callq 0x13470
movl -0x20(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %edx
movl $0x2, %esi
callq 0x13550
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| action_p_add:
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_20], 0
mov eax, [rbp+var_18]
and eax, 1
cmp eax, 0
jz short loc_8243
mov rdi, [rbp+var_10]
mov esi, [rbp+var_14]
mov edx, [rbp+var_18]
mov ecx, 80000000h
mov r8d, 7FFFFFFFh
call parts_valadate_int
mov [rbp+var_4], eax
jmp short loc_8292
loc_8243:
mov rdi, [rbp+var_10]
mov esi, [rbp+var_14]
mov edx, [rbp+var_18]
mov ecx, 80000000h
mov r8d, 7FFFFFFFh
call parts_get_int
mov [rbp+var_1C], eax
mov rdi, [rbp+var_10]
mov esi, 2
lea rdx, [rbp+var_20]
call engine_get_variable
mov eax, [rbp+var_20]
add eax, [rbp+var_1C]
mov [rbp+var_1C], eax
mov rdi, [rbp+var_10]
mov edx, [rbp+var_1C]
mov esi, 2
call engine_set_variable
mov eax, [rbp+var_1C]
mov [rbp+var_4], eax
loc_8292:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
| long long action_p_add(long long a1, unsigned int a2, unsigned int a3)
{
int v4; // [rsp+0h] [rbp-20h] BYREF
unsigned int v5; // [rsp+4h] [rbp-1Ch]
unsigned int v6; // [rsp+8h] [rbp-18h]
unsigned int v7; // [rsp+Ch] [rbp-14h]
long long v8; // [rsp+10h] [rbp-10h]
v8 = a1;
v7 = a2;
v6 = a3;
v4 = 0;
if ( (a3 & 1) != 0 )
{
return (unsigned int)parts_valadate_int(v8, v7, v6, 0x80000000LL, 0x7FFFFFFFLL);
}
else
{
v5 = parts_get_int(v8, v7, v6, 0x80000000LL, 0x7FFFFFFFLL);
engine_get_variable(v8, 2LL, &v4);
v5 += v4;
engine_set_variable(v8, 2LL, v5);
return v5;
}
}
| action_p_add:
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 + -0x20],0x0
MOV EAX,dword ptr [RBP + -0x18]
AND EAX,0x1
CMP EAX,0x0
JZ 0x00108243
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x14]
MOV EDX,dword ptr [RBP + -0x18]
MOV ECX,0x80000000
MOV R8D,0x7fffffff
CALL 0x001091b0
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00108292
LAB_00108243:
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x14]
MOV EDX,dword ptr [RBP + -0x18]
MOV ECX,0x80000000
MOV R8D,0x7fffffff
CALL 0x001092f0
MOV dword ptr [RBP + -0x1c],EAX
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x2
LEA RDX,[RBP + -0x20]
CALL 0x00113470
MOV EAX,dword ptr [RBP + -0x20]
ADD EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x1c],EAX
MOV RDI,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x1c]
MOV ESI,0x2
CALL 0x00113550
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x4],EAX
LAB_00108292:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int action_p_add(int8 param_1,int4 param_2,uint param_3)
{
int local_28;
int local_24;
uint local_20;
int4 local_1c;
int8 local_18;
int local_c;
local_28 = 0;
local_20 = param_3;
local_1c = param_2;
local_18 = param_1;
if ((param_3 & 1) == 0) {
local_24 = parts_get_int(param_1,param_2,param_3,0x80000000,0x7fffffff);
engine_get_variable(local_18,2,&local_28);
local_24 = local_28 + local_24;
engine_set_variable(local_18,2,local_24);
local_c = local_24;
}
else {
local_c = parts_valadate_int(param_1,param_2,param_3,0x80000000,0x7fffffff);
}
return local_c;
}
| |
52,956 | bool google::protobuf::internal::MergeFromImpl<false>(google::protobuf::internal::BoundedZCIS, google::protobuf::MessageLite*, google::protobuf::MessageLite::ParseFlags) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/message_lite.cc | bool MergeFromImpl(BoundedZCIS input, MessageLite* msg,
MessageLite::ParseFlags parse_flags) {
const char* ptr;
internal::ParseContext ctx(io::CodedInputStream::GetDefaultRecursionLimit(),
aliasing, &ptr, input.zcis, input.limit);
ptr = msg->_InternalParse(ptr, &ctx);
if (PROTOBUF_PREDICT_FALSE(!ptr)) return false;
ctx.BackUp(ptr);
if (PROTOBUF_PREDICT_TRUE(ctx.EndedAtLimit())) {
return CheckFieldPresence(ctx, *msg, parse_flags);
}
return false;
} | O0 | cpp | bool google::protobuf::internal::MergeFromImpl<false>(google::protobuf::internal::BoundedZCIS, google::protobuf::MessageLite*, google::protobuf::MessageLite::ParseFlags):
subq $0xa8, %rsp
movq %rdi, 0x90(%rsp)
movl %esi, 0x98(%rsp)
movq %rdx, 0x88(%rsp)
movl %ecx, 0x84(%rsp)
callq 0x175db0
movl %eax, %esi
leaq 0x90(%rsp), %r8
leaq 0x90(%rsp), %r9
addq $0x8, %r9
movq %rsp, %rdi
movl $0x1, %edx
leaq 0x78(%rsp), %rcx
callq 0x176270
movq 0x88(%rsp), %rdi
movq 0x78(%rsp), %rsi
movq (%rdi), %rax
movq %rsp, %rdx
callq *0x50(%rax)
movq %rax, 0x78(%rsp)
cmpq $0x0, 0x78(%rsp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1764ce
jmp 0x1764d8
movb $0x0, 0xa7(%rsp)
jmp 0x17651d
movq 0x78(%rsp), %rsi
movq %rsp, %rdi
callq 0x176300
movq %rsp, %rdi
callq 0x175e50
testb $0x1, %al
jne 0x1764f3
jmp 0x176515
movq 0x88(%rsp), %rsi
movl 0x84(%rsp), %edx
movq %rsp, %rdi
callq 0x1734c0
andb $0x1, %al
movb %al, 0xa7(%rsp)
jmp 0x17651d
movb $0x0, 0xa7(%rsp)
movb 0xa7(%rsp), %al
andb $0x1, %al
addq $0xa8, %rsp
retq
nop
| _ZN6google8protobuf8internal13MergeFromImplILb1EEEbNS1_11BoundedZCISEPNS0_11MessageLiteENS4_10ParseFlagsE:
sub rsp, 0A8h
mov [rsp+0A8h+var_18], rdi
mov [rsp+0A8h+var_10], esi
mov [rsp+0A8h+var_20], rdx
mov [rsp+0A8h+var_24], ecx
call _ZN6google8protobuf2io16CodedInputStream24GetDefaultRecursionLimitEv; google::protobuf::io::CodedInputStream::GetDefaultRecursionLimit(void)
mov esi, eax
lea r8, [rsp+0A8h+var_18]
lea r9, [rsp+0A8h+var_18]
add r9, 8
mov rdi, rsp
mov edx, 1
lea rcx, [rsp+0A8h+var_30]
call _ZN6google8protobuf8internal12ParseContextC2IJRPNS0_2io19ZeroCopyInputStreamERiEEEibPPKcDpOT_; google::protobuf::internal::ParseContext::ParseContext<google::protobuf::io::ZeroCopyInputStream *&,int &>(int,bool,char const**,google::protobuf::io::ZeroCopyInputStream *&,int &)
mov rdi, [rsp+0A8h+var_20]
mov rsi, [rsp+0A8h+var_30]
mov rax, [rdi]
mov rdx, rsp
call qword ptr [rax+50h]
mov [rsp+0A8h+var_30], rax
cmp [rsp+0A8h+var_30], 0
setnz al
xor al, 0FFh
test al, 1
jnz short loc_1764CE
jmp short loc_1764D8
loc_1764CE:
mov [rsp+0A8h+var_1], 0
jmp short loc_17651D
loc_1764D8:
mov rsi, [rsp+0A8h+var_30]; char *
mov rdi, rsp; this
call _ZN6google8protobuf8internal18EpsCopyInputStream6BackUpEPKc; google::protobuf::internal::EpsCopyInputStream::BackUp(char const*)
mov rdi, rsp; this
call _ZNK6google8protobuf8internal18EpsCopyInputStream12EndedAtLimitEv; google::protobuf::internal::EpsCopyInputStream::EndedAtLimit(void)
test al, 1
jnz short loc_1764F3
jmp short loc_176515
loc_1764F3:
mov rsi, [rsp+0A8h+var_20]
mov edx, [rsp+0A8h+var_24]
mov rdi, rsp
call _ZN6google8protobuf12_GLOBAL__N_118CheckFieldPresenceERKNS0_8internal12ParseContextERKNS0_11MessageLiteENS6_10ParseFlagsE; google::protobuf::`anonymous namespace'::CheckFieldPresence(google::protobuf::internal::ParseContext const&,google::protobuf::MessageLite const&,google::protobuf::MessageLite::ParseFlags)
and al, 1
mov [rsp+0A8h+var_1], al
jmp short loc_17651D
loc_176515:
mov [rsp+0A8h+var_1], 0
loc_17651D:
mov al, [rsp+0A8h+var_1]
and al, 1
add rsp, 0A8h
retn
| char google::protobuf::internal::MergeFromImpl<true>(
google::protobuf::io::ZeroCopyInputStream *a1,
int a2,
google::protobuf::MessageLite *a3,
int a4)
{
int DefaultRecursionLimit; // eax
_DWORD v6[30]; // [rsp+0h] [rbp-A8h] BYREF
char *v7; // [rsp+78h] [rbp-30h] BYREF
int v8; // [rsp+84h] [rbp-24h]
google::protobuf::MessageLite *v9; // [rsp+88h] [rbp-20h]
google::protobuf::io::ZeroCopyInputStream *v10; // [rsp+90h] [rbp-18h] BYREF
int v11[3]; // [rsp+98h] [rbp-10h] BYREF
v10 = a1;
v11[0] = a2;
v9 = a3;
v8 = a4;
DefaultRecursionLimit = google::protobuf::io::CodedInputStream::GetDefaultRecursionLimit(a1);
google::protobuf::internal::ParseContext::ParseContext<google::protobuf::io::ZeroCopyInputStream *&,int &>(
v6,
DefaultRecursionLimit,
1,
(long long *)&v7,
&v10,
v11);
v7 = (char *)(*(long long ( **)(google::protobuf::MessageLite *, char *, _DWORD *))(*(_QWORD *)v9 + 80LL))(
v9,
v7,
v6);
if ( !v7 )
return 0;
google::protobuf::internal::EpsCopyInputStream::BackUp((google::protobuf::internal::EpsCopyInputStream *)v6, v7);
if ( google::protobuf::internal::EpsCopyInputStream::EndedAtLimit((google::protobuf::internal::EpsCopyInputStream *)v6) )
return google::protobuf::`anonymous namespace'::CheckFieldPresence((long long)v6, v9, v8) & 1;
else
return 0;
}
| |||
52,957 | bool google::protobuf::internal::MergeFromImpl<false>(google::protobuf::internal::BoundedZCIS, google::protobuf::MessageLite*, google::protobuf::MessageLite::ParseFlags) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/message_lite.cc | bool MergeFromImpl(BoundedZCIS input, MessageLite* msg,
MessageLite::ParseFlags parse_flags) {
const char* ptr;
internal::ParseContext ctx(io::CodedInputStream::GetDefaultRecursionLimit(),
aliasing, &ptr, input.zcis, input.limit);
ptr = msg->_InternalParse(ptr, &ctx);
if (PROTOBUF_PREDICT_FALSE(!ptr)) return false;
ctx.BackUp(ptr);
if (PROTOBUF_PREDICT_TRUE(ctx.EndedAtLimit())) {
return CheckFieldPresence(ctx, *msg, parse_flags);
}
return false;
} | O3 | cpp | bool google::protobuf::internal::MergeFromImpl<false>(google::protobuf::internal::BoundedZCIS, google::protobuf::MessageLite*, google::protobuf::MessageLite::ParseFlags):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movl %ecx, %ebp
movq %rdx, %rbx
movl %esi, %edx
movq %rdi, %rsi
leaq 0x1e22ba(%rip), %rax # 0x211888
movl (%rax), %eax
xorps %xmm0, %xmm0
leaq 0x8(%rsp), %r14
movups %xmm0, 0x20(%r14)
movups %xmm0, 0x30(%r14)
andq $0x0, 0x40(%r14)
movq $0x1, 0x48(%r14)
movabsq $0x7fffffff00000000, %rcx # imm = 0x7FFFFFFF00000000
movq %rcx, 0x50(%r14)
movl %eax, 0x58(%r14)
movl $0x80000000, 0x5c(%r14) # imm = 0x80000000
movups %xmm0, 0x60(%r14)
andq $0x0, 0x70(%r14)
movq %r14, %rdi
callq 0x7c856
movq (%rbx), %rcx
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq *0x50(%rcx)
testq %rax, %rax
je 0x2f692
leaq 0x30(%rsp), %rcx
cmpq %rcx, -0x18(%rcx)
je 0x2f649
movl 0x10(%rsp), %r14d
subl %eax, %r14d
addl 0x20(%rsp), %r14d
jmp 0x2f655
movl 0x10(%rsp), %r14d
subl %eax, %r14d
addl $0x10, %r14d
testl %r14d, %r14d
jle 0x2f66d
movq 0x28(%rsp), %rdi
movq (%rdi), %rax
movl %r14d, %esi
callq *0x18(%rax)
addl %r14d, 0x5c(%rsp)
cmpl $0x0, 0x58(%rsp)
jne 0x2f692
movb $0x1, %r14b
testb $0x2, %bpl
jne 0x2f695
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
testb %al, %al
jne 0x2f695
movq %rbx, %rdi
callq 0x7b6de
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
| _ZN6google8protobuf8internal13MergeFromImplILb1EEEbNS1_11BoundedZCISEPNS0_11MessageLiteENS4_10ParseFlagsE:
push rbp
push r14
push rbx
sub rsp, 80h
mov ebp, ecx
mov rbx, rdx
mov edx, esi; int
mov rsi, rdi; google::protobuf::io::ZeroCopyInputStream *
lea rax, _ZN6google8protobuf2io16CodedInputStream24default_recursion_limit_E; google::protobuf::io::CodedInputStream::default_recursion_limit_
mov eax, [rax]
xorps xmm0, xmm0
lea r14, [rsp+98h+var_90]
movups xmmword ptr [r14+20h], xmm0
movups xmmword ptr [r14+30h], xmm0
and qword ptr [r14+40h], 0
mov qword ptr [r14+48h], 1
mov rcx, 7FFFFFFF00000000h
mov [r14+50h], rcx
mov [r14+58h], eax
mov dword ptr [r14+5Ch], 80000000h
movups xmmword ptr [r14+60h], xmm0
and qword ptr [r14+70h], 0
mov rdi, r14; this
call _ZN6google8protobuf8internal18EpsCopyInputStream8InitFromEPNS0_2io19ZeroCopyInputStreamEi; google::protobuf::internal::EpsCopyInputStream::InitFrom(google::protobuf::io::ZeroCopyInputStream *,int)
mov rcx, [rbx]
mov rdi, rbx
mov rsi, rax
mov rdx, r14
call qword ptr [rcx+50h]
test rax, rax
jz short loc_2F692
lea rcx, [rsp+98h+var_68]
cmp [rcx-18h], rcx
jz short loc_2F649
mov r14d, [rsp+98h+var_88]
sub r14d, eax
add r14d, [rsp+98h+var_78]
jmp short loc_2F655
loc_2F649:
mov r14d, [rsp+98h+var_88]
sub r14d, eax
add r14d, 10h
loc_2F655:
test r14d, r14d
jle short loc_2F66D
mov rdi, [rsp+98h+var_70]
mov rax, [rdi]
mov esi, r14d
call qword ptr [rax+18h]
add [rsp+98h+var_3C], r14d
loc_2F66D:
cmp [rsp+98h+var_40], 0
jnz short loc_2F692
mov r14b, 1
test bpl, 2
jnz short loc_2F695
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax+28h]
test al, al
jnz short loc_2F695
mov rdi, rbx; this
call _ZNK6google8protobuf11MessageLite29LogInitializationErrorMessageEv; google::protobuf::MessageLite::LogInitializationErrorMessage(void)
loc_2F692:
xor r14d, r14d
loc_2F695:
mov eax, r14d
add rsp, 80h
pop rbx
pop r14
pop rbp
retn
| long long google::protobuf::internal::MergeFromImpl<true>(
google::protobuf::io::ZeroCopyInputStream *a1,
int a2,
google::protobuf::MessageLite *this,
char a4)
{
long long v6; // rax
long long v7; // rax
int v8; // r14d
_BYTE v10[8]; // [rsp+8h] [rbp-90h] BYREF
int v11; // [rsp+10h] [rbp-88h]
_QWORD *v12; // [rsp+18h] [rbp-80h]
int v13; // [rsp+20h] [rbp-78h]
_QWORD v14[6]; // [rsp+28h] [rbp-70h] BYREF
long long v15; // [rsp+58h] [rbp-40h]
int v16; // [rsp+60h] [rbp-38h]
unsigned int v17; // [rsp+64h] [rbp-34h]
__int128 v18; // [rsp+68h] [rbp-30h]
long long v19; // [rsp+78h] [rbp-20h]
memset(v14, 0, 40);
v14[5] = 1LL;
v15 = 0x7FFFFFFF00000000LL;
v16 = google::protobuf::io::CodedInputStream::default_recursion_limit_;
v17 = 0x80000000;
v18 = 0LL;
v19 = 0LL;
v6 = google::protobuf::internal::EpsCopyInputStream::InitFrom(
(google::protobuf::internal::EpsCopyInputStream *)v10,
a1,
a2);
v7 = (*(long long ( **)(google::protobuf::MessageLite *, long long, _BYTE *))(*(_QWORD *)this + 80LL))(
this,
v6,
v10);
if ( !v7 )
return 0;
v8 = v12 == &v14[1] ? v11 - v7 + 16 : v13 + v11 - (int)v7;
if ( v8 > 0 )
{
(*(void ( **)(_QWORD, _QWORD))(*(_QWORD *)v14[0] + 24LL))(v14[0], (unsigned int)v8);
HIDWORD(v15) += v8;
}
if ( (_DWORD)v15 )
return 0;
LOBYTE(v8) = 1;
if ( (a4 & 2) == 0
&& !(*(unsigned __int8 ( **)(google::protobuf::MessageLite *))(*(_QWORD *)this + 40LL))(this) )
{
google::protobuf::MessageLite::LogInitializationErrorMessage(this);
return 0;
}
return (unsigned int)v8;
}
| MergeFromImpl<true>:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x80
MOV EBP,ECX
MOV RBX,RDX
MOV EDX,ESI
MOV RSI,RDI
LEA RAX,[0x311888]
MOV EAX,dword ptr [RAX]
XORPS XMM0,XMM0
LEA R14,[RSP + 0x8]
MOVUPS xmmword ptr [R14 + 0x20],XMM0
MOVUPS xmmword ptr [R14 + 0x30],XMM0
AND qword ptr [R14 + 0x40],0x0
MOV qword ptr [R14 + 0x48],0x1
MOV RCX,0x7fffffff00000000
MOV qword ptr [R14 + 0x50],RCX
MOV dword ptr [R14 + 0x58],EAX
MOV dword ptr [R14 + 0x5c],0x80000000
MOVUPS xmmword ptr [R14 + 0x60],XMM0
AND qword ptr [R14 + 0x70],0x0
MOV RDI,R14
CALL 0x0017c856
MOV RCX,qword ptr [RBX]
MOV RDI,RBX
MOV RSI,RAX
MOV RDX,R14
CALL qword ptr [RCX + 0x50]
TEST RAX,RAX
JZ 0x0012f692
LEA RCX,[RSP + 0x30]
CMP qword ptr [RCX + -0x18],RCX
JZ 0x0012f649
MOV R14D,dword ptr [RSP + 0x10]
SUB R14D,EAX
ADD R14D,dword ptr [RSP + 0x20]
JMP 0x0012f655
LAB_0012f649:
MOV R14D,dword ptr [RSP + 0x10]
SUB R14D,EAX
ADD R14D,0x10
LAB_0012f655:
TEST R14D,R14D
JLE 0x0012f66d
MOV RDI,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RDI]
MOV ESI,R14D
CALL qword ptr [RAX + 0x18]
ADD dword ptr [RSP + 0x5c],R14D
LAB_0012f66d:
CMP dword ptr [RSP + 0x58],0x0
JNZ 0x0012f692
MOV R14B,0x1
TEST BPL,0x2
JNZ 0x0012f695
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
CALL qword ptr [RAX + 0x28]
TEST AL,AL
JNZ 0x0012f695
MOV RDI,RBX
CALL 0x0017b6de
LAB_0012f692:
XOR R14D,R14D
LAB_0012f695:
MOV EAX,R14D
ADD RSP,0x80
POP RBX
POP R14
POP RBP
RET
|
/* bool google::protobuf::internal::MergeFromImpl<true>(google::protobuf::internal::BoundedZCIS,
google::protobuf::MessageLite*, google::protobuf::MessageLite::ParseFlags) */
bool __thiscall
google::protobuf::internal::MergeFromImpl<true>
(internal *this,int param_2,MessageLite *param_3,uint param_4)
{
char cVar1;
int8 uVar2;
long lVar3;
int iVar4;
EpsCopyInputStream local_90 [8];
int local_88;
int8 *local_80;
int local_78;
long *local_70;
int8 uStack_68;
int8 local_60;
int8 uStack_58;
int8 local_50;
int8 local_48;
int8 local_40;
int4 local_38;
int4 local_34;
int8 local_30;
int8 uStack_28;
int8 local_20;
local_70 = (long *)0x0;
uStack_68 = 0;
local_60 = 0;
uStack_58 = 0;
local_50 = 0;
local_48 = 1;
local_40 = 0x7fffffff00000000;
local_38 = io::CodedInputStream::default_recursion_limit_;
local_34 = 0x80000000;
local_30 = 0;
uStack_28 = 0;
local_20 = 0;
uVar2 = EpsCopyInputStream::InitFrom(local_90,(ZeroCopyInputStream *)this,param_2);
lVar3 = (**(code **)(*(long *)param_3 + 0x50))(param_3,uVar2,local_90);
if (lVar3 != 0) {
if (local_80 == &uStack_68) {
iVar4 = (local_88 - (int)lVar3) + 0x10;
}
else {
iVar4 = (local_88 - (int)lVar3) + local_78;
}
if (0 < iVar4) {
(**(code **)(*local_70 + 0x18))(local_70,iVar4);
local_40 = CONCAT44(local_40._4_4_ + iVar4,(int)local_40);
}
if ((int)local_40 == 0) {
if ((param_4 & 2) != 0) {
return true;
}
cVar1 = (**(code **)(*(long *)param_3 + 0x28))(param_3);
if (cVar1 != '\0') {
return true;
}
MessageLite::LogInitializationErrorMessage(param_3);
}
}
return false;
}
| |
52,958 | JS_WriteObjectAtoms | bluesky950520[P]quickjs/quickjs.c | static int JS_WriteObjectAtoms(BCWriterState *s)
{
JSRuntime *rt = s->ctx->rt;
DynBuf dbuf1;
int i, atoms_size;
dbuf1 = s->dbuf;
js_dbuf_init(s->ctx, &s->dbuf);
bc_put_u8(s, BC_VERSION);
bc_put_leb128(s, s->idx_to_atom_count);
for(i = 0; i < s->idx_to_atom_count; i++) {
JSAtom atom = s->idx_to_atom[i];
if (__JS_AtomIsConst(atom)) {
bc_put_u8(s, 0 /* the type */);
/* TODO(saghul): encoding for tagged integers and keyword-ish atoms could be
more efficient. */
bc_put_u32(s, atom);
} else {
JSAtomStruct *p = rt->atom_array[atom];
uint8_t type = p->atom_type;
assert(type != JS_ATOM_TYPE_PRIVATE);
bc_put_u8(s, type);
JS_WriteString(s, p);
}
}
/* XXX: should check for OOM in above phase */
/* move the atoms at the start */
/* XXX: could just append dbuf1 data, but it uses more memory if
dbuf1 is larger than dbuf */
atoms_size = s->dbuf.size;
if (dbuf_realloc(&dbuf1, dbuf1.size + atoms_size))
goto fail;
memmove(dbuf1.buf + atoms_size, dbuf1.buf, dbuf1.size);
memcpy(dbuf1.buf, s->dbuf.buf, atoms_size);
dbuf1.size += atoms_size;
dbuf_free(&s->dbuf);
s->dbuf = dbuf1;
return 0;
fail:
dbuf_free(&dbuf1);
return -1;
} | O0 | c | JS_WriteObjectAtoms:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rsi
addq $0x8, %rsi
leaq 0x20(%rsp), %rdi
movl $0x30, %edx
callq 0xe5a0
movq 0x58(%rsp), %rax
movq (%rax), %rdi
movq 0x58(%rsp), %rsi
addq $0x8, %rsi
callq 0x49f70
movq 0x58(%rsp), %rdi
movl $0x13, %esi
callq 0x768e0
movq 0x58(%rsp), %rdi
movq 0x58(%rsp), %rax
movl 0x58(%rax), %esi
callq 0x77470
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movq 0x58(%rsp), %rcx
cmpl 0x58(%rcx), %eax
jge 0x4a779
movq 0x58(%rsp), %rax
movq 0x50(%rax), %rax
movslq 0x1c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %edi
callq 0x26d40
cmpl $0x0, %eax
je 0x4a722
movq 0x58(%rsp), %rdi
xorl %esi, %esi
callq 0x768e0
movq 0x58(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x78e30
jmp 0x4a767
movq 0x50(%rsp), %rax
movq 0x68(%rax), %rax
movl 0x14(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x4(%rax), %rax
shrq $0x3e, %rax
movb %al, 0x7(%rsp)
movq 0x58(%rsp), %rdi
movzbl 0x7(%rsp), %esi
callq 0x768e0
movq 0x58(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x76990
jmp 0x4a769
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x4a6d1
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rax
movl %eax, 0x18(%rsp)
movq 0x28(%rsp), %rsi
movslq 0x18(%rsp), %rax
addq %rax, %rsi
leaq 0x20(%rsp), %rdi
callq 0x1d130
cmpl $0x0, %eax
je 0x4a7a4
jmp 0x4a817
movq 0x20(%rsp), %rdi
movslq 0x18(%rsp), %rax
addq %rax, %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0xe700
movq 0x20(%rsp), %rdi
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rsi
movslq 0x18(%rsp), %rdx
callq 0xe5a0
movslq 0x18(%rsp), %rax
addq 0x28(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x58(%rsp), %rdi
addq $0x8, %rdi
callq 0x1d670
movq 0x58(%rsp), %rdi
addq $0x8, %rdi
leaq 0x20(%rsp), %rsi
movl $0x30, %edx
callq 0xe5a0
movl $0x0, 0x64(%rsp)
jmp 0x4a829
leaq 0x20(%rsp), %rdi
callq 0x1d670
movl $0xffffffff, 0x64(%rsp) # imm = 0xFFFFFFFF
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
| JS_WriteObjectAtoms:
sub rsp, 68h
mov [rsp+68h+var_10], rdi
mov rax, [rsp+68h+var_10]
mov rax, [rax]
mov rax, [rax+18h]
mov [rsp+68h+var_18], rax
mov rsi, [rsp+68h+var_10]
add rsi, 8
lea rdi, [rsp+68h+var_48]
mov edx, 30h ; '0'
call _memcpy
mov rax, [rsp+68h+var_10]
mov rdi, [rax]
mov rsi, [rsp+68h+var_10]
add rsi, 8
call js_dbuf_init
mov rdi, [rsp+68h+var_10]
mov esi, 13h
call bc_put_u8
mov rdi, [rsp+68h+var_10]
mov rax, [rsp+68h+var_10]
mov esi, [rax+58h]
call bc_put_leb128
mov [rsp+68h+var_4C], 0
loc_4A6D1:
mov eax, [rsp+68h+var_4C]
mov rcx, [rsp+68h+var_10]
cmp eax, [rcx+58h]
jge loc_4A779
mov rax, [rsp+68h+var_10]
mov rax, [rax+50h]
movsxd rcx, [rsp+68h+var_4C]
mov eax, [rax+rcx*4]
mov [rsp+68h+var_54], eax
mov edi, [rsp+68h+var_54]
call __JS_AtomIsConst
cmp eax, 0
jz short loc_4A722
mov rdi, [rsp+68h+var_10]
xor esi, esi
call bc_put_u8
mov rdi, [rsp+68h+var_10]
mov esi, [rsp+68h+var_54]
call bc_put_u32
jmp short loc_4A767
loc_4A722:
mov rax, [rsp+68h+var_18]
mov rax, [rax+68h]
mov ecx, [rsp+68h+var_54]
mov rax, [rax+rcx*8]
mov [rsp+68h+var_60], rax
mov rax, [rsp+68h+var_60]
mov rax, [rax+4]
shr rax, 3Eh
mov [rsp+68h+var_61], al
mov rdi, [rsp+68h+var_10]
movzx esi, [rsp+68h+var_61]
call bc_put_u8
mov rdi, [rsp+68h+var_10]
mov rsi, [rsp+68h+var_60]
call JS_WriteString
loc_4A767:
jmp short $+2
loc_4A769:
mov eax, [rsp+68h+var_4C]
add eax, 1
mov [rsp+68h+var_4C], eax
jmp loc_4A6D1
loc_4A779:
mov rax, [rsp+68h+var_10]
mov rax, [rax+10h]
mov [rsp+68h+var_50], eax
mov rsi, [rsp+68h+var_40]
movsxd rax, [rsp+68h+var_50]
add rsi, rax
lea rdi, [rsp+68h+var_48]
call dbuf_realloc
cmp eax, 0
jz short loc_4A7A4
jmp short loc_4A817
loc_4A7A4:
mov rdi, [rsp+68h+var_48]
movsxd rax, [rsp+68h+var_50]
add rdi, rax
mov rsi, [rsp+68h+var_48]
mov rdx, [rsp+68h+var_40]
call _memmove
mov rdi, [rsp+68h+var_48]
mov rax, [rsp+68h+var_10]
mov rsi, [rax+8]
movsxd rdx, [rsp+68h+var_50]
call _memcpy
movsxd rax, [rsp+68h+var_50]
add rax, [rsp+68h+var_40]
mov [rsp+68h+var_40], rax
mov rdi, [rsp+68h+var_10]
add rdi, 8
call dbuf_free
mov rdi, [rsp+68h+var_10]
add rdi, 8
lea rsi, [rsp+68h+var_48]
mov edx, 30h ; '0'
call _memcpy
mov [rsp+68h+var_4], 0
jmp short loc_4A829
loc_4A817:
lea rdi, [rsp+68h+var_48]
call dbuf_free
mov [rsp+68h+var_4], 0FFFFFFFFh
loc_4A829:
mov eax, [rsp+68h+var_4]
add rsp, 68h
retn
| long long JS_WriteObjectAtoms(long long a1)
{
long long v2; // [rsp+8h] [rbp-60h]
unsigned int v3; // [rsp+14h] [rbp-54h]
int v4; // [rsp+18h] [rbp-50h]
int i; // [rsp+1Ch] [rbp-4Ch]
long long v6; // [rsp+20h] [rbp-48h] BYREF
long long v7; // [rsp+28h] [rbp-40h]
long long v8; // [rsp+50h] [rbp-18h]
long long v9; // [rsp+58h] [rbp-10h]
v9 = a1;
v8 = *(_QWORD *)(*(_QWORD *)a1 + 24LL);
memcpy(&v6, a1 + 8, 48LL);
js_dbuf_init(*(_QWORD *)v9, v9 + 8);
bc_put_u8(v9, 19LL);
bc_put_leb128(v9, *(unsigned int *)(v9 + 88));
for ( i = 0; i < *(_DWORD *)(v9 + 88); ++i )
{
v3 = *(_DWORD *)(*(_QWORD *)(v9 + 80) + 4LL * i);
if ( _JS_AtomIsConst(v3) )
{
bc_put_u8(v9, 0LL);
bc_put_u32(v9, v3);
}
else
{
v2 = *(_QWORD *)(*(_QWORD *)(v8 + 104) + 8LL * v3);
bc_put_u8(v9, *(_QWORD *)(v2 + 4) >> 62);
JS_WriteString(v9, v2);
}
}
v4 = *(_QWORD *)(v9 + 16);
if ( (unsigned int)dbuf_realloc((long long)&v6, v4 + v7) )
{
dbuf_free((long long)&v6);
return (unsigned int)-1;
}
else
{
memmove(v4 + v6, v6, v7);
memcpy(v6, *(_QWORD *)(v9 + 8), v4);
v7 += v4;
dbuf_free(v9 + 8);
memcpy(v9 + 8, &v6, 48LL);
return 0;
}
}
| JS_WriteObjectAtoms:
SUB RSP,0x68
MOV qword ptr [RSP + 0x58],RDI
MOV RAX,qword ptr [RSP + 0x58]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RSP + 0x50],RAX
MOV RSI,qword ptr [RSP + 0x58]
ADD RSI,0x8
LEA RDI,[RSP + 0x20]
MOV EDX,0x30
CALL 0x0010e5a0
MOV RAX,qword ptr [RSP + 0x58]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RSP + 0x58]
ADD RSI,0x8
CALL 0x00149f70
MOV RDI,qword ptr [RSP + 0x58]
MOV ESI,0x13
CALL 0x001768e0
MOV RDI,qword ptr [RSP + 0x58]
MOV RAX,qword ptr [RSP + 0x58]
MOV ESI,dword ptr [RAX + 0x58]
CALL 0x00177470
MOV dword ptr [RSP + 0x1c],0x0
LAB_0014a6d1:
MOV EAX,dword ptr [RSP + 0x1c]
MOV RCX,qword ptr [RSP + 0x58]
CMP EAX,dword ptr [RCX + 0x58]
JGE 0x0014a779
MOV RAX,qword ptr [RSP + 0x58]
MOV RAX,qword ptr [RAX + 0x50]
MOVSXD RCX,dword ptr [RSP + 0x1c]
MOV EAX,dword ptr [RAX + RCX*0x4]
MOV dword ptr [RSP + 0x14],EAX
MOV EDI,dword ptr [RSP + 0x14]
CALL 0x00126d40
CMP EAX,0x0
JZ 0x0014a722
MOV RDI,qword ptr [RSP + 0x58]
XOR ESI,ESI
CALL 0x001768e0
MOV RDI,qword ptr [RSP + 0x58]
MOV ESI,dword ptr [RSP + 0x14]
CALL 0x00178e30
JMP 0x0014a767
LAB_0014a722:
MOV RAX,qword ptr [RSP + 0x50]
MOV RAX,qword ptr [RAX + 0x68]
MOV ECX,dword ptr [RSP + 0x14]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX + 0x4]
SHR RAX,0x3e
MOV byte ptr [RSP + 0x7],AL
MOV RDI,qword ptr [RSP + 0x58]
MOVZX ESI,byte ptr [RSP + 0x7]
CALL 0x001768e0
MOV RDI,qword ptr [RSP + 0x58]
MOV RSI,qword ptr [RSP + 0x8]
CALL 0x00176990
LAB_0014a767:
JMP 0x0014a769
LAB_0014a769:
MOV EAX,dword ptr [RSP + 0x1c]
ADD EAX,0x1
MOV dword ptr [RSP + 0x1c],EAX
JMP 0x0014a6d1
LAB_0014a779:
MOV RAX,qword ptr [RSP + 0x58]
MOV RAX,qword ptr [RAX + 0x10]
MOV dword ptr [RSP + 0x18],EAX
MOV RSI,qword ptr [RSP + 0x28]
MOVSXD RAX,dword ptr [RSP + 0x18]
ADD RSI,RAX
LEA RDI,[RSP + 0x20]
CALL 0x0011d130
CMP EAX,0x0
JZ 0x0014a7a4
JMP 0x0014a817
LAB_0014a7a4:
MOV RDI,qword ptr [RSP + 0x20]
MOVSXD RAX,dword ptr [RSP + 0x18]
ADD RDI,RAX
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
CALL 0x0010e700
MOV RDI,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RSP + 0x58]
MOV RSI,qword ptr [RAX + 0x8]
MOVSXD RDX,dword ptr [RSP + 0x18]
CALL 0x0010e5a0
MOVSXD RAX,dword ptr [RSP + 0x18]
ADD RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x28],RAX
MOV RDI,qword ptr [RSP + 0x58]
ADD RDI,0x8
CALL 0x0011d670
MOV RDI,qword ptr [RSP + 0x58]
ADD RDI,0x8
LEA RSI,[RSP + 0x20]
MOV EDX,0x30
CALL 0x0010e5a0
MOV dword ptr [RSP + 0x64],0x0
JMP 0x0014a829
LAB_0014a817:
LEA RDI,[RSP + 0x20]
CALL 0x0011d670
MOV dword ptr [RSP + 0x64],0xffffffff
LAB_0014a829:
MOV EAX,dword ptr [RSP + 0x64]
ADD RSP,0x68
RET
|
int4 JS_WriteObjectAtoms(long *param_1)
{
uint uVar1;
long lVar2;
int iVar3;
int iVar4;
int local_4c;
void *local_48;
size_t local_40;
long local_18;
long *local_10;
int4 local_4;
local_18 = *(long *)(*param_1 + 0x18);
local_10 = param_1;
memcpy(&local_48,param_1 + 1,0x30);
js_dbuf_init(*local_10,local_10 + 1);
bc_put_u8(local_10,0x13);
bc_put_leb128(local_10,(int)local_10[0xb]);
for (local_4c = 0; local_4c < (int)local_10[0xb]; local_4c = local_4c + 1) {
uVar1 = *(uint *)(local_10[10] + (long)local_4c * 4);
iVar3 = __JS_AtomIsConst(uVar1);
if (iVar3 == 0) {
lVar2 = *(long *)(*(long *)(local_18 + 0x68) + (ulong)uVar1 * 8);
bc_put_u8(local_10,(byte)((ulong)*(int8 *)(lVar2 + 4) >> 0x3e));
JS_WriteString(local_10,lVar2);
}
else {
bc_put_u8(local_10,0);
bc_put_u32(local_10);
}
}
iVar3 = (int)local_10[2];
iVar4 = dbuf_realloc(&local_48,local_40 + (long)iVar3);
if (iVar4 == 0) {
memmove((void *)((long)local_48 + (long)iVar3),local_48,local_40);
memcpy(local_48,(void *)local_10[1],(long)iVar3);
local_40 = (long)iVar3 + local_40;
dbuf_free(local_10 + 1);
memcpy(local_10 + 1,&local_48,0x30);
local_4 = 0;
}
else {
dbuf_free(&local_48);
local_4 = 0xffffffff;
}
return local_4;
}
| |
52,959 | maria_flush_log_for_page | eloqsql/storage/maria/ma_pagecrc.c | my_bool maria_flush_log_for_page(PAGECACHE_IO_HOOK_ARGS *args)
{
LSN lsn;
uchar *page= args->page;
MARIA_SHARE *share= (MARIA_SHARE *)args->data;
DBUG_ENTER("maria_flush_log_for_page");
/* share is 0 here only in unittest */
DBUG_ASSERT(!share || share->page_type == PAGECACHE_LSN_PAGE);
lsn= lsn_korr(page);
if (translog_flush(lsn))
DBUG_RETURN(1);
/*
Now when log is written, it's safe to incremented 'open' counter for
the table so that we know it was not closed properly.
*/
if (share && !share->global_changed)
_ma_mark_file_changed_now(share);
DBUG_RETURN(0);
} | O0 | c | maria_flush_log_for_page:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x41605
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movq -0x20(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x20(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl %eax, %eax
shlq $0x20, %rax
movq -0x20(%rbp), %rcx
movl 0x3(%rcx), %ecx
orq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x34660
cmpb $0x0, %al
je 0x4164f
jmp 0x41649
movb $0x1, -0x1(%rbp)
jmp 0x41672
cmpq $0x0, -0x28(%rbp)
je 0x4166c
movq -0x28(%rbp), %rax
cmpb $0x0, 0x7df(%rax)
jne 0x4166c
movq -0x28(%rbp), %rdi
callq 0x48e20
jmp 0x4166e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| maria_flush_log_for_page:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rax, [rax+10h]
mov [rbp+var_28], rax
jmp short $+2
loc_41605:
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax]
mov rcx, [rbp+var_20]
movzx ecx, byte ptr [rcx+1]
shl ecx, 8
or eax, ecx
mov rcx, [rbp+var_20]
movzx ecx, byte ptr [rcx+2]
shl ecx, 10h
or eax, ecx
mov eax, eax
shl rax, 20h
mov rcx, [rbp+var_20]
mov ecx, [rcx+3]
or rax, rcx
mov [rbp+var_18], rax
mov rdi, [rbp+var_18]
call translog_flush
cmp al, 0
jz short loc_4164F
jmp short $+2
loc_41649:
mov [rbp+var_1], 1
jmp short loc_41672
loc_4164F:
cmp [rbp+var_28], 0
jz short loc_4166C
mov rax, [rbp+var_28]
cmp byte ptr [rax+7DFh], 0
jnz short loc_4166C
mov rdi, [rbp+var_28]
call _ma_mark_file_changed_now
loc_4166C:
jmp short $+2
loc_4166E:
mov [rbp+var_1], 0
loc_41672:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
| char maria_flush_log_for_page(unsigned __int16 **a1)
{
unsigned __int16 *v2; // [rsp+8h] [rbp-28h]
v2 = a1[2];
if ( translog_flush(*(unsigned int *)((char *)*a1 + 3) | ((unsigned long long)((*((unsigned __int8 *)*a1 + 2) << 16) | (unsigned int)**a1) << 32)) )
return 1;
if ( v2 && !*((_BYTE *)v2 + 2015) )
ma_mark_file_changed_now(v2);
return 0;
}
| maria_flush_log_for_page:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00141605
LAB_00141605:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x20]
MOVZX ECX,byte ptr [RCX + 0x1]
SHL ECX,0x8
OR EAX,ECX
MOV RCX,qword ptr [RBP + -0x20]
MOVZX ECX,byte ptr [RCX + 0x2]
SHL ECX,0x10
OR EAX,ECX
MOV EAX,EAX
SHL RAX,0x20
MOV RCX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RCX + 0x3]
OR RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00134660
CMP AL,0x0
JZ 0x0014164f
JMP 0x00141649
LAB_00141649:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00141672
LAB_0014164f:
CMP qword ptr [RBP + -0x28],0x0
JZ 0x0014166c
MOV RAX,qword ptr [RBP + -0x28]
CMP byte ptr [RAX + 0x7df],0x0
JNZ 0x0014166c
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x00148e20
LAB_0014166c:
JMP 0x0014166e
LAB_0014166e:
MOV byte ptr [RBP + -0x1],0x0
LAB_00141672:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int1 maria_flush_log_for_page(long *param_1)
{
long lVar1;
char cVar2;
int1 local_9;
lVar1 = param_1[2];
cVar2 = translog_flush((ulong)CONCAT34(*(int3 *)*param_1,*(int4 *)(*param_1 + 3)));
if (cVar2 == '\0') {
if ((lVar1 != 0) && (*(char *)(lVar1 + 0x7df) == '\0')) {
_ma_mark_file_changed_now(lVar1);
}
local_9 = 0;
}
else {
local_9 = 1;
}
return local_9;
}
| |
52,960 | mysql_stmt_send_long_data_cont | eloqsql/libmariadb/libmariadb/mariadb_async.c | int STDCALL
mysql_stmt_send_long_data_cont(my_bool *ret, MYSQL_STMT *stmt, int ready_status)
{
MK_ASYNC_CONT_BODY(
stmt->mysql,
TRUE,
r_my_bool)
} | O3 | c | mysql_stmt_send_long_data_cont:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rsi), %rax
movq 0x480(%rax), %rcx
movq 0x28(%rcx), %r15
cmpb $0x0, 0x15(%r15)
je 0x33af9
movb $0x1, 0x14(%r15)
movl %edx, 0x4(%r15)
leaq 0x38(%r15), %rdi
callq 0x3464f
movb $0x0, 0x14(%r15)
testl %eax, %eax
jle 0x33b5c
movl (%r15), %r15d
jmp 0x33bd2
movl $0x7de, 0x90(%rax) # imm = 0x7DE
movl $0x297, %edi # imm = 0x297
addq 0x38(%r14), %rdi
leaq 0x1e6fd(%rip), %rax # 0x52210
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13220
movq 0x38(%r14), %rax
xorl %r15d, %r15d
movb %r15b, 0x29c(%rax)
movl $0x97, %edi
addq 0x38(%r14), %rdi
leaq 0x1e6e2(%rip), %rax # 0x52220
movq 0x70(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x13220
movq 0x38(%r14), %rax
movb %r15b, 0x296(%rax)
movb $0x1, (%rbx)
jmp 0x33bd2
movb $0x0, 0x15(%r15)
js 0x33b69
movb 0x8(%r15), %al
jmp 0x33bcd
movq 0x38(%r14), %rax
movl $0x7d8, 0x90(%rax) # imm = 0x7D8
movl $0x297, %edi # imm = 0x297
addq 0x38(%r14), %rdi
leaq 0x1e689(%rip), %rax # 0x52210
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13220
movq 0x38(%r14), %rax
xorl %r15d, %r15d
movb %r15b, 0x29c(%rax)
movl $0x97, %edi
addq 0x38(%r14), %rdi
leaq 0x1e66e(%rip), %rax # 0x52220
movq 0x40(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x13220
movq 0x38(%r14), %rax
movb %r15b, 0x296(%rax)
movb $0x1, %al
movb %al, (%rbx)
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| mysql_stmt_send_long_data_cont:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
mov rax, [rsi+38h]
mov rcx, [rax+480h]
mov r15, [rcx+28h]
cmp byte ptr [r15+15h], 0
jz short loc_33AF9
mov byte ptr [r15+14h], 1
mov [r15+4], edx
lea rdi, [r15+38h]
call my_context_continue
mov byte ptr [r15+14h], 0
test eax, eax
jle short loc_33B5C
mov r15d, [r15]
jmp loc_33BD2
loc_33AF9:
mov dword ptr [rax+90h], 7DEh
mov edi, 297h
add rdi, [r14+38h]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [r14+38h]
xor r15d, r15d
mov [rax+29Ch], r15b
mov edi, 97h
add rdi, [r14+38h]
lea rax, client_errors
mov rsi, [rax+70h]
mov edx, 1FFh
call _strncpy
mov rax, [r14+38h]
mov [rax+296h], r15b
mov byte ptr [rbx], 1
jmp short loc_33BD2
loc_33B5C:
mov byte ptr [r15+15h], 0
js short loc_33B69
mov al, [r15+8]
jmp short loc_33BCD
loc_33B69:
mov rax, [r14+38h]
mov dword ptr [rax+90h], 7D8h
mov edi, 297h
add rdi, [r14+38h]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [r14+38h]
xor r15d, r15d
mov [rax+29Ch], r15b
mov edi, 97h
add rdi, [r14+38h]
lea rax, client_errors
mov rsi, [rax+40h]
mov edx, 1FFh
call _strncpy
mov rax, [r14+38h]
mov [rax+296h], r15b
mov al, 1
loc_33BCD:
mov [rbx], al
xor r15d, r15d
loc_33BD2:
mov eax, r15d
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long mysql_stmt_send_long_data_cont(char *a1, long long a2, unsigned int a3)
{
long long v3; // rax
unsigned int *v4; // r15
int v5; // eax
unsigned int v6; // r15d
char v7; // al
v3 = *(_QWORD *)(a2 + 56);
v4 = *(unsigned int **)(*(_QWORD *)(v3 + 1152) + 40LL);
if ( *((_BYTE *)v4 + 21) )
{
*((_BYTE *)v4 + 20) = 1;
v4[1] = a3;
v5 = my_context_continue(v4 + 14);
*((_BYTE *)v4 + 20) = 0;
if ( v5 <= 0 )
{
*((_BYTE *)v4 + 21) = 0;
if ( v5 < 0 )
{
*(_DWORD *)(*(_QWORD *)(a2 + 56) + 144LL) = 2008;
strncpy(*(_QWORD *)(a2 + 56) + 663LL, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(*(_QWORD *)(a2 + 56) + 668LL) = 0;
strncpy(*(_QWORD *)(a2 + 56) + 151LL, client_errors[8], 511LL);
*(_BYTE *)(*(_QWORD *)(a2 + 56) + 662LL) = 0;
v7 = 1;
}
else
{
v7 = *((_BYTE *)v4 + 8);
}
*a1 = v7;
return 0;
}
else
{
return *v4;
}
}
else
{
*(_DWORD *)(v3 + 144) = 2014;
strncpy(*(_QWORD *)(a2 + 56) + 663LL, SQLSTATE_UNKNOWN, 5LL);
v6 = 0;
*(_BYTE *)(*(_QWORD *)(a2 + 56) + 668LL) = 0;
strncpy(*(_QWORD *)(a2 + 56) + 151LL, client_errors[14], 511LL);
*(_BYTE *)(*(_QWORD *)(a2 + 56) + 662LL) = 0;
*a1 = 1;
}
return v6;
}
| mysql_stmt_send_long_data_cont:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RSI + 0x38]
MOV RCX,qword ptr [RAX + 0x480]
MOV R15,qword ptr [RCX + 0x28]
CMP byte ptr [R15 + 0x15],0x0
JZ 0x00133af9
MOV byte ptr [R15 + 0x14],0x1
MOV dword ptr [R15 + 0x4],EDX
LEA RDI,[R15 + 0x38]
CALL 0x0013464f
MOV byte ptr [R15 + 0x14],0x0
TEST EAX,EAX
JLE 0x00133b5c
MOV R15D,dword ptr [R15]
JMP 0x00133bd2
LAB_00133af9:
MOV dword ptr [RAX + 0x90],0x7de
MOV EDI,0x297
ADD RDI,qword ptr [R14 + 0x38]
LEA RAX,[0x152210]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113220
MOV RAX,qword ptr [R14 + 0x38]
XOR R15D,R15D
MOV byte ptr [RAX + 0x29c],R15B
MOV EDI,0x97
ADD RDI,qword ptr [R14 + 0x38]
LEA RAX,[0x152220]
MOV RSI,qword ptr [RAX + 0x70]
MOV EDX,0x1ff
CALL 0x00113220
MOV RAX,qword ptr [R14 + 0x38]
MOV byte ptr [RAX + 0x296],R15B
MOV byte ptr [RBX],0x1
JMP 0x00133bd2
LAB_00133b5c:
MOV byte ptr [R15 + 0x15],0x0
JS 0x00133b69
MOV AL,byte ptr [R15 + 0x8]
JMP 0x00133bcd
LAB_00133b69:
MOV RAX,qword ptr [R14 + 0x38]
MOV dword ptr [RAX + 0x90],0x7d8
MOV EDI,0x297
ADD RDI,qword ptr [R14 + 0x38]
LEA RAX,[0x152210]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113220
MOV RAX,qword ptr [R14 + 0x38]
XOR R15D,R15D
MOV byte ptr [RAX + 0x29c],R15B
MOV EDI,0x97
ADD RDI,qword ptr [R14 + 0x38]
LEA RAX,[0x152220]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x1ff
CALL 0x00113220
MOV RAX,qword ptr [R14 + 0x38]
MOV byte ptr [RAX + 0x296],R15B
MOV AL,0x1
LAB_00133bcd:
MOV byte ptr [RBX],AL
XOR R15D,R15D
LAB_00133bd2:
MOV EAX,R15D
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int4 mysql_stmt_send_long_data_cont(int1 *param_1,long param_2,int4 param_3)
{
int4 *puVar1;
int1 uVar2;
int iVar3;
int4 uVar4;
puVar1 = *(int4 **)(*(long *)(*(long *)(param_2 + 0x38) + 0x480) + 0x28);
if (*(char *)((long)puVar1 + 0x15) == '\0') {
*(int4 *)(*(long *)(param_2 + 0x38) + 0x90) = 0x7de;
strncpy((char *)(*(long *)(param_2 + 0x38) + 0x297),SQLSTATE_UNKNOWN,5);
uVar4 = 0;
*(int1 *)(*(long *)(param_2 + 0x38) + 0x29c) = 0;
strncpy((char *)(*(long *)(param_2 + 0x38) + 0x97),
PTR_s_Commands_out_of_sync__you_can_t_r_00152290,0x1ff);
*(int1 *)(*(long *)(param_2 + 0x38) + 0x296) = 0;
*param_1 = 1;
}
else {
*(int1 *)(puVar1 + 5) = 1;
puVar1[1] = param_3;
iVar3 = my_context_continue(puVar1 + 0xe);
*(int1 *)(puVar1 + 5) = 0;
if (iVar3 < 1) {
*(int1 *)((long)puVar1 + 0x15) = 0;
if (iVar3 < 0) {
*(int4 *)(*(long *)(param_2 + 0x38) + 0x90) = 0x7d8;
strncpy((char *)(*(long *)(param_2 + 0x38) + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(*(long *)(param_2 + 0x38) + 0x29c) = 0;
strncpy((char *)(*(long *)(param_2 + 0x38) + 0x97),PTR_s_Client_run_out_of_memory_00152260,
0x1ff);
*(int1 *)(*(long *)(param_2 + 0x38) + 0x296) = 0;
uVar2 = 1;
}
else {
uVar2 = *(int1 *)(puVar1 + 2);
}
*param_1 = uVar2;
uVar4 = 0;
}
else {
uVar4 = *puVar1;
}
}
return uVar4;
}
| |
52,961 | js_parse_property_name | bluesky950520[P]quickjs/quickjs.c | static int __exception js_parse_property_name(JSParseState *s,
JSAtom *pname,
BOOL allow_method, BOOL allow_var,
BOOL allow_private)
{
int is_private = 0;
BOOL is_non_reserved_ident;
JSAtom name;
int prop_type;
prop_type = PROP_TYPE_IDENT;
if (allow_method) {
if (token_is_pseudo_keyword(s, JS_ATOM_get)
|| token_is_pseudo_keyword(s, JS_ATOM_set)) {
/* get x(), set x() */
name = JS_DupAtom(s->ctx, s->token.u.ident.atom);
if (next_token(s))
goto fail1;
if (s->token.val == ':' || s->token.val == ',' ||
s->token.val == '}' || s->token.val == '(' ||
s->token.val == '=' || s->token.val == ';') {
is_non_reserved_ident = TRUE;
goto ident_found;
}
prop_type = PROP_TYPE_GET + (name == JS_ATOM_set);
JS_FreeAtom(s->ctx, name);
} else if (s->token.val == '*') {
if (next_token(s))
goto fail;
prop_type = PROP_TYPE_STAR;
} else if (token_is_pseudo_keyword(s, JS_ATOM_async) &&
peek_token(s, TRUE) != '\n') {
name = JS_DupAtom(s->ctx, s->token.u.ident.atom);
if (next_token(s))
goto fail1;
if (s->token.val == ':' || s->token.val == ',' ||
s->token.val == '}' || s->token.val == '(' ||
s->token.val == '=' || s->token.val == ';') {
is_non_reserved_ident = TRUE;
goto ident_found;
}
JS_FreeAtom(s->ctx, name);
if (s->token.val == '*') {
if (next_token(s))
goto fail;
prop_type = PROP_TYPE_ASYNC_STAR;
} else {
prop_type = PROP_TYPE_ASYNC;
}
}
}
if (token_is_ident(s->token.val)) {
/* variable can only be a non-reserved identifier */
is_non_reserved_ident =
(s->token.val == TOK_IDENT && !s->token.u.ident.is_reserved);
/* keywords and reserved words have a valid atom */
name = JS_DupAtom(s->ctx, s->token.u.ident.atom);
if (next_token(s))
goto fail1;
ident_found:
if (is_non_reserved_ident &&
prop_type == PROP_TYPE_IDENT && allow_var) {
if (!(s->token.val == ':' ||
(s->token.val == '(' && allow_method))) {
prop_type = PROP_TYPE_VAR;
}
}
} else if (s->token.val == TOK_STRING) {
name = JS_ValueToAtom(s->ctx, s->token.u.str.str);
if (name == JS_ATOM_NULL)
goto fail;
if (next_token(s))
goto fail1;
} else if (s->token.val == TOK_NUMBER) {
JSValue val;
val = s->token.u.num.val;
name = JS_ValueToAtom(s->ctx, val);
if (name == JS_ATOM_NULL)
goto fail;
if (next_token(s))
goto fail1;
} else if (s->token.val == '[') {
if (next_token(s))
goto fail;
if (js_parse_expr(s))
goto fail;
if (js_parse_expect(s, ']'))
goto fail;
name = JS_ATOM_NULL;
} else if (s->token.val == TOK_PRIVATE_NAME && allow_private) {
name = JS_DupAtom(s->ctx, s->token.u.ident.atom);
if (next_token(s))
goto fail1;
is_private = PROP_TYPE_PRIVATE;
} else {
goto invalid_prop;
}
if (prop_type != PROP_TYPE_IDENT && prop_type != PROP_TYPE_VAR &&
s->token.val != '(') {
JS_FreeAtom(s->ctx, name);
invalid_prop:
js_parse_error(s, "invalid property name");
goto fail;
}
*pname = name;
return prop_type | is_private;
fail1:
JS_FreeAtom(s->ctx, name);
fail:
*pname = JS_ATOM_NULL;
return -1;
} | O1 | c | js_parse_property_name:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %r13d
movl %ecx, %r12d
movl %edx, %ebp
movq %rsi, 0x10(%rsp)
movq %rdi, %r14
xorl %ebx, %ebx
testl %edx, %edx
je 0x65d5c
movl 0x20(%r14), %eax
cmpl $-0x7d, %eax
jne 0x65bee
cmpl $0x42, 0x38(%r14)
jne 0x65bd7
cmpl $0x0, 0x3c(%r14)
je 0x65cde
cmpl $-0x7d, %eax
jne 0x65bee
cmpl $0x43, 0x38(%r14)
jne 0x65bee
cmpl $0x0, 0x3c(%r14)
je 0x65cde
cmpl $0x2a, %eax
jne 0x65c0d
movq %r14, %rdi
callq 0x5d1cf
testl %eax, %eax
jne 0x65f4b
movl $0x4, %ebx
jmp 0x65d5c
cmpl $-0x7d, %eax
jne 0x65d5c
cmpl $0x86, 0x38(%r14)
jne 0x65d5c
cmpl $0x0, 0x3c(%r14)
jne 0x65d5c
movq %r14, %rdi
movl $0x1, %esi
callq 0x5f895
cmpl $0xa, %eax
je 0x65d5c
movslq 0x38(%r14), %r15
cmpq $0xe0, %r15
jl 0x65c63
movq (%r14), %rax
movq 0x18(%rax), %rax
movq 0x68(%rax), %rax
movq (%rax,%r15,8), %rax
incl (%rax)
movq %r14, %rdi
callq 0x5d1cf
testl %eax, %eax
jne 0x65dff
movl %r12d, 0xc(%rsp)
movl 0x20(%r14), %eax
xorl %ebx, %ebx
movl $0x1, %r12d
cmpq $0x3d, %rax
ja 0x65c9e
movabsq $0x2c00110000000000, %rcx # imm = 0x2C00110000000000
btq %rax, %rcx
jb 0x65e0f
cmpl $0x7d, %eax
je 0x65e0f
movq (%r14), %rdi
movl %r15d, %esi
callq 0x207d8
movl $0x5, %ebx
cmpl $0x2a, 0x20(%r14)
movl 0xc(%rsp), %r12d
jne 0x65d5c
movq %r14, %rdi
callq 0x5d1cf
testl %eax, %eax
jne 0x65f4b
movl $0x6, %ebx
jmp 0x65d57
movslq 0x38(%r14), %r15
cmpq $0xe0, %r15
jl 0x65cfc
movq (%r14), %rax
movq 0x18(%rax), %rax
movq 0x68(%rax), %rax
movq (%rax,%r15,8), %rax
incl (%rax)
movq %r14, %rdi
callq 0x5d1cf
testl %eax, %eax
jne 0x65dff
movl %r12d, 0xc(%rsp)
movl 0x20(%r14), %eax
xorl %ebx, %ebx
movl $0x1, %r12d
cmpq $0x3d, %rax
ja 0x65d37
movabsq $0x2c00110000000000, %rcx # imm = 0x2C00110000000000
btq %rax, %rcx
jb 0x65e0f
cmpl $0x7d, %eax
je 0x65e0f
xorl %ebx, %ebx
cmpl $0x43, %r15d
sete %bl
orl $0x2, %ebx
movq (%r14), %rdi
movl %r15d, %esi
callq 0x207d8
movl 0xc(%rsp), %r12d
movl 0x20(%r14), %eax
cmpl $-0x7d, %eax
setne %cl
leal 0x27(%rax), %edx
cmpl $-0x2e, %edx
setb %dl
testb %dl, %cl
je 0x65dbc
cmpl $-0x80, %eax
je 0x65e92
cmpl $0x5b, %eax
je 0x65e50
cmpl $-0x7f, %eax
jne 0x65ebe
movq (%r14), %rdi
movq 0x38(%r14), %rsi
movq 0x40(%r14), %rdx
callq 0x24093
testl %eax, %eax
je 0x65f4b
movl %eax, %r15d
movq %r14, %rdi
callq 0x5d1cf
testl %eax, %eax
jne 0x65dff
xorl %eax, %eax
jmp 0x65f17
movl %r12d, 0xc(%rsp)
xorl %r12d, %r12d
cmpl $-0x7d, %eax
jne 0x65dd5
xorl %r12d, %r12d
cmpl $0x0, 0x40(%r14)
sete %r12b
movslq 0x38(%r14), %r15
cmpq $0xe0, %r15
jl 0x65df3
movq (%r14), %rax
movq 0x18(%rax), %rax
movq 0x68(%rax), %rax
movq (%rax,%r15,8), %rax
incl (%rax)
movq %r14, %rdi
callq 0x5d1cf
testl %eax, %eax
je 0x65e0f
movq (%r14), %rdi
movl %r15d, %esi
callq 0x207d8
jmp 0x65f4b
xorl %eax, %eax
cmpl $0x0, 0xc(%rsp)
je 0x65f17
testl %r12d, %r12d
je 0x65f17
testl %ebx, %ebx
jne 0x65f17
testl %ebp, %ebp
sete %cl
movl 0x20(%r14), %edx
cmpl $0x3a, %edx
setne %sil
cmpl $0x28, %edx
setne %dl
orb %cl, %dl
andb %sil, %dl
movzbl %dl, %ebx
jmp 0x65f17
movq %r14, %rdi
callq 0x5d1cf
testl %eax, %eax
jne 0x65f4b
movq %r14, %rdi
movl $0x1, %esi
callq 0x6a9b7
testl %eax, %eax
jne 0x65f4b
movq %r14, %rdi
movl $0x5d, %esi
callq 0x637c4
testl %eax, %eax
jne 0x65f4b
xorl %r15d, %r15d
jmp 0x65db5
movq (%r14), %rdi
movq 0x38(%r14), %rsi
movq 0x40(%r14), %rdx
callq 0x24093
movl %eax, %r15d
testl %eax, %eax
je 0x65f03
movq %r14, %rdi
callq 0x5d1cf
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %al
addl %eax, %eax
jmp 0x65f08
cmpl $-0x57, %eax
setne %al
testl %r13d, %r13d
sete %cl
orb %al, %cl
jne 0x65f3a
movslq 0x38(%r14), %r15
cmpq $0xe0, %r15
jl 0x65eec
movq (%r14), %rax
movq 0x18(%rax), %rax
movq 0x68(%rax), %rax
movq (%rax,%r15,8), %rax
incl (%rax)
movq %r14, %rdi
callq 0x5d1cf
testl %eax, %eax
jne 0x65dff
movl $0x10, %eax
jmp 0x65f17
movl $0x4, %eax
testl %eax, %eax
je 0x65f17
cmpl $0x2, %eax
je 0x65dff
jmp 0x65f4b
cmpl $0x2, %ebx
jb 0x65f23
cmpl $0x28, 0x20(%r14)
jne 0x65f2f
movq 0x10(%rsp), %rcx
movl %r15d, (%rcx)
orl %ebx, %eax
jmp 0x65f5b
movq (%r14), %rdi
movl %r15d, %esi
callq 0x207d8
leaq 0x3b20c(%rip), %rsi # 0xa114d
movq %r14, %rdi
xorl %eax, %eax
callq 0x2fce9
movq 0x10(%rsp), %rax
movl $0x0, (%rax)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| js_parse_property_name:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r13d, r8d
mov r12d, ecx
mov ebp, edx
mov [rsp+48h+var_38], rsi
mov r14, rdi
xor ebx, ebx
test edx, edx
jz loc_65D5C
mov eax, [r14+20h]
cmp eax, 0FFFFFF83h
jnz short loc_65BEE
cmp dword ptr [r14+38h], 42h ; 'B'
jnz short loc_65BD7
cmp dword ptr [r14+3Ch], 0
jz loc_65CDE
loc_65BD7:
cmp eax, 0FFFFFF83h
jnz short loc_65BEE
cmp dword ptr [r14+38h], 43h ; 'C'
jnz short loc_65BEE
cmp dword ptr [r14+3Ch], 0
jz loc_65CDE
loc_65BEE:
cmp eax, 2Ah ; '*'
jnz short loc_65C0D
mov rdi, r14
call next_token
test eax, eax
jnz loc_65F4B
mov ebx, 4
jmp loc_65D5C
loc_65C0D:
cmp eax, 0FFFFFF83h
jnz loc_65D5C
cmp dword ptr [r14+38h], 86h
jnz loc_65D5C
cmp dword ptr [r14+3Ch], 0
jnz loc_65D5C
mov rdi, r14
mov esi, 1
call peek_token
cmp eax, 0Ah
jz loc_65D5C
movsxd r15, dword ptr [r14+38h]
cmp r15, 0E0h
jl short loc_65C63
mov rax, [r14]
mov rax, [rax+18h]
mov rax, [rax+68h]
mov rax, [rax+r15*8]
inc dword ptr [rax]
loc_65C63:
mov rdi, r14
call next_token
test eax, eax
jnz loc_65DFF
mov [rsp+48h+var_3C], r12d
mov eax, [r14+20h]
xor ebx, ebx
mov r12d, 1
cmp rax, 3Dh ; '='
ja short loc_65C9E
mov rcx, 2C00110000000000h
bt rcx, rax
jb loc_65E0F
loc_65C9E:
cmp eax, 7Dh ; '}'
jz loc_65E0F
mov rdi, [r14]
mov esi, r15d
call JS_FreeAtom
mov ebx, 5
cmp dword ptr [r14+20h], 2Ah ; '*'
mov r12d, [rsp+48h+var_3C]
jnz loc_65D5C
mov rdi, r14
call next_token
test eax, eax
jnz loc_65F4B
mov ebx, 6
jmp short loc_65D57
loc_65CDE:
movsxd r15, dword ptr [r14+38h]
cmp r15, 0E0h
jl short loc_65CFC
mov rax, [r14]
mov rax, [rax+18h]
mov rax, [rax+68h]
mov rax, [rax+r15*8]
inc dword ptr [rax]
loc_65CFC:
mov rdi, r14
call next_token
test eax, eax
jnz loc_65DFF
mov [rsp+48h+var_3C], r12d
mov eax, [r14+20h]
xor ebx, ebx
mov r12d, 1
cmp rax, 3Dh ; '='
ja short loc_65D37
mov rcx, 2C00110000000000h
bt rcx, rax
jb loc_65E0F
loc_65D37:
cmp eax, 7Dh ; '}'
jz loc_65E0F
xor ebx, ebx
cmp r15d, 43h ; 'C'
setz bl
or ebx, 2
mov rdi, [r14]
mov esi, r15d
call JS_FreeAtom
loc_65D57:
mov r12d, [rsp+48h+var_3C]
loc_65D5C:
mov eax, [r14+20h]
cmp eax, 0FFFFFF83h
setnz cl
lea edx, [rax+27h]
cmp edx, 0FFFFFFD2h
setb dl
test cl, dl
jz short loc_65DBC
cmp eax, 0FFFFFF80h
jz loc_65E92
cmp eax, 5Bh ; '['
jz loc_65E50
cmp eax, 0FFFFFF81h
jnz loc_65EBE
mov rdi, [r14]
mov rsi, [r14+38h]
mov rdx, [r14+40h]
call JS_ValueToAtom
test eax, eax
jz loc_65F4B
mov r15d, eax
mov rdi, r14
call next_token
test eax, eax
jnz short loc_65DFF
loc_65DB5:
xor eax, eax
jmp loc_65F17
loc_65DBC:
mov [rsp+48h+var_3C], r12d
xor r12d, r12d
cmp eax, 0FFFFFF83h
jnz short loc_65DD5
xor r12d, r12d
cmp dword ptr [r14+40h], 0
setz r12b
loc_65DD5:
movsxd r15, dword ptr [r14+38h]
cmp r15, 0E0h
jl short loc_65DF3
mov rax, [r14]
mov rax, [rax+18h]
mov rax, [rax+68h]
mov rax, [rax+r15*8]
inc dword ptr [rax]
loc_65DF3:
mov rdi, r14
call next_token
test eax, eax
jz short loc_65E0F
loc_65DFF:
mov rdi, [r14]
mov esi, r15d
call JS_FreeAtom
jmp loc_65F4B
loc_65E0F:
xor eax, eax
cmp [rsp+48h+var_3C], 0
jz loc_65F17
test r12d, r12d
jz loc_65F17
test ebx, ebx
jnz loc_65F17
test ebp, ebp
setz cl
mov edx, [r14+20h]
cmp edx, 3Ah ; ':'
setnz sil
cmp edx, 28h ; '('
setnz dl
or dl, cl
and dl, sil
movzx ebx, dl
jmp loc_65F17
loc_65E50:
mov rdi, r14
call next_token
test eax, eax
jnz loc_65F4B
mov rdi, r14
mov esi, 1
call js_parse_expr2
test eax, eax
jnz loc_65F4B
mov rdi, r14
mov esi, 5Dh ; ']'
call js_parse_expect
test eax, eax
jnz loc_65F4B
xor r15d, r15d
jmp loc_65DB5
loc_65E92:
mov rdi, [r14]
mov rsi, [r14+38h]
mov rdx, [r14+40h]
call JS_ValueToAtom
mov r15d, eax
test eax, eax
jz short loc_65F03
mov rdi, r14
call next_token
mov ecx, eax
xor eax, eax
test ecx, ecx
setnz al
add eax, eax
jmp short loc_65F08
loc_65EBE:
cmp eax, 0FFFFFFA9h
setnz al
test r13d, r13d
setz cl
or cl, al
jnz short loc_65F3A
movsxd r15, dword ptr [r14+38h]
cmp r15, 0E0h
jl short loc_65EEC
mov rax, [r14]
mov rax, [rax+18h]
mov rax, [rax+68h]
mov rax, [rax+r15*8]
inc dword ptr [rax]
loc_65EEC:
mov rdi, r14
call next_token
test eax, eax
jnz loc_65DFF
mov eax, 10h
jmp short loc_65F17
loc_65F03:
mov eax, 4
loc_65F08:
test eax, eax
jz short loc_65F17
cmp eax, 2
jz loc_65DFF
jmp short loc_65F4B
loc_65F17:
cmp ebx, 2
jb short loc_65F23
cmp dword ptr [r14+20h], 28h ; '('
jnz short loc_65F2F
loc_65F23:
mov rcx, [rsp+48h+var_38]
mov [rcx], r15d
or eax, ebx
jmp short loc_65F5B
loc_65F2F:
mov rdi, [r14]
mov esi, r15d
call JS_FreeAtom
loc_65F3A:
lea rsi, aInvalidPropert_1; "invalid property name"
mov rdi, r14
xor eax, eax
call js_parse_error
loc_65F4B:
mov rax, [rsp+48h+var_38]
mov dword ptr [rax], 0
mov eax, 0FFFFFFFFh
loc_65F5B:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long js_parse_property_name(
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; // r13d
int v15; // r12d
int v16; // ebp
unsigned int v17; // ebx
int v18; // eax
long long v19; // rdx
long long v20; // r15
_DWORD *v21; // rax
unsigned long long v22; // rax
BOOL v23; // r12d
long long v24; // rcx
long long v25; // rdx
_DWORD *v26; // rax
unsigned long long v27; // rax
long long v28; // rcx
int v29; // eax
long long v30; // rdx
long long v31; // rsi
int v32; // eax
long long v33; // rdx
long long v34; // rcx
long long v35; // r8
long long v36; // r9
__m128 v37; // xmm4
__m128 v38; // xmm5
int v39; // eax
_DWORD *v40; // rax
long long v41; // rdx
long long v42; // rcx
long long v43; // r8
long long v44; // r9
__m128 v45; // xmm4
__m128 v46; // xmm5
long long v47; // rsi
long long v48; // rdx
long long v49; // rcx
long long v50; // r8
long long v51; // r9
__m128 v52; // xmm4
__m128 v53; // xmm5
_DWORD *v54; // rax
char v56; // [rsp+0h] [rbp-48h]
int v57; // [rsp+Ch] [rbp-3Ch]
_DWORD *v58; // [rsp+10h] [rbp-38h]
v14 = a5;
v15 = a4;
v16 = a3;
v58 = (_DWORD *)a2;
v17 = 0;
if ( !(_DWORD)a3 )
goto LABEL_31;
v18 = *((_DWORD *)a1 + 8);
if ( v18 == -125
&& (*((_DWORD *)a1 + 14) == 66 && !*((_DWORD *)a1 + 15) || *((_DWORD *)a1 + 14) == 67 && !*((_DWORD *)a1 + 15)) )
{
v20 = *((int *)a1 + 14);
if ( v20 >= 224 )
{
v26 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(*a1 + 24) + 104LL) + 8 * v20);
++*v26;
}
if ( (unsigned int)next_token((long long)a1, a7, a8, a9, a10, a11, a12, a13, a14, a2, a3, a4, a5, a6) )
goto LABEL_43;
v57 = v15;
v27 = *((unsigned int *)a1 + 8);
v17 = 0;
v23 = 1;
if ( v27 <= 0x3D )
{
v28 = 0x2C00110000000000LL;
if ( _bittest64(&v28, v27) )
goto LABEL_44;
}
if ( (_DWORD)v27 == 125 )
goto LABEL_44;
v17 = ((_DWORD)v20 == 67) | 2;
a2 = (unsigned int)v20;
JS_FreeAtom(*a1, v20);
goto LABEL_30;
}
if ( v18 == 42 )
{
if ( (unsigned int)next_token((long long)a1, a7, a8, a9, a10, a11, a12, a13, a14, a2, a3, a4, a5, a6) )
goto LABEL_68;
v17 = 4;
goto LABEL_31;
}
if ( v18 == -125 && *((_DWORD *)a1 + 14) == 134 && !*((_DWORD *)a1 + 15) )
{
a2 = 1LL;
if ( (unsigned int)peek_token((long long)a1, 1) != 10 )
{
v20 = *((int *)a1 + 14);
if ( v20 >= 224 )
{
v21 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(*a1 + 24) + 104LL) + 8 * v20);
++*v21;
}
if ( (unsigned int)next_token((long long)a1, a7, a8, a9, a10, a11, a12, a13, a14, 1LL, v19, a4, a5, a6) )
goto LABEL_43;
v57 = v15;
v22 = *((unsigned int *)a1 + 8);
v17 = 0;
v23 = 1;
if ( v22 <= 0x3D && (v24 = 0x2C00110000000000LL, _bittest64(&v24, v22)) || (_DWORD)v22 == 125 )
{
LABEL_44:
v39 = 0;
if ( v57 && v23 && !v17 )
v17 = *((_DWORD *)a1 + 8) != 58 && (v16 == 0 || *((_DWORD *)a1 + 8) != 40);
goto LABEL_63;
}
a2 = (unsigned int)v20;
JS_FreeAtom(*a1, v20);
v17 = 5;
v15 = v57;
if ( *((_DWORD *)a1 + 8) == 42 )
{
if ( (unsigned int)next_token(
(long long)a1,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
(unsigned int)v20,
v25,
a4,
a5,
a6) )
goto LABEL_68;
v17 = 6;
LABEL_30:
v15 = v57;
}
}
}
LABEL_31:
v29 = *((_DWORD *)a1 + 8);
LOBYTE(a4) = v29 != -125;
v30 = (unsigned int)(v29 + 39);
LOBYTE(v30) = (unsigned int)v30 < 0xFFFFFFD2;
if ( ((unsigned __int8)v30 & (unsigned __int8)a4) == 0 )
{
v57 = v15;
v23 = 0;
if ( v29 == -125 )
v23 = *((_DWORD *)a1 + 16) == 0;
v20 = *((int *)a1 + 14);
if ( v20 >= 224 )
{
v40 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(*a1 + 24) + 104LL) + 8 * v20);
++*v40;
}
if ( (unsigned int)next_token((long long)a1, a7, a8, a9, a10, a11, a12, a13, a14, a2, v30, a4, a5, a6) )
{
LABEL_43:
JS_FreeAtom(*a1, v20);
goto LABEL_68;
}
goto LABEL_44;
}
if ( v29 == -128 )
{
v47 = a1[7];
LODWORD(v20) = JS_ValueToAtom(*a1, v47, a1[8]);
if ( (_DWORD)v20 )
v39 = 2
* ((unsigned int)next_token((long long)a1, a7, a8, a9, a10, v52, v53, a13, a14, v47, v48, v49, v50, v51) != 0);
else
v39 = 4;
if ( !v39 )
goto LABEL_63;
if ( v39 != 2 )
goto LABEL_68;
goto LABEL_43;
}
if ( v29 == 91 )
{
if ( (unsigned int)next_token((long long)a1, a7, a8, a9, a10, a11, a12, a13, a14, a2, v30, a4, a5, a6)
|| (unsigned int)js_parse_expr2(a1, 1LL)
|| (unsigned int)js_parse_expect(a1, 93LL, v41, v42, v43, v44, a7, a8, a9, a10, v45, v46, a13, a14) )
{
goto LABEL_68;
}
LODWORD(v20) = 0;
goto LABEL_37;
}
if ( v29 != -127 )
{
LOBYTE(a4) = v29 != -87 || v14 == 0;
if ( (_BYTE)a4 )
{
LABEL_67:
js_parse_error(a1, (long long)"invalid property name", v30, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v56);
goto LABEL_68;
}
v20 = *((int *)a1 + 14);
if ( v20 >= 224 )
{
v54 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(*a1 + 24) + 104LL) + 8 * v20);
++*v54;
}
if ( !(unsigned int)next_token((long long)a1, a7, a8, a9, a10, a11, a12, a13, a14, a2, v30, a4, a5, a6) )
{
v39 = 16;
LABEL_63:
if ( v17 < 2 || *((_DWORD *)a1 + 8) == 40 )
{
*v58 = v20;
return v17 | v39;
}
JS_FreeAtom(*a1, v20);
goto LABEL_67;
}
goto LABEL_43;
}
v31 = a1[7];
v32 = JS_ValueToAtom(*a1, v31, a1[8]);
if ( v32 )
{
LODWORD(v20) = v32;
if ( !(unsigned int)next_token((long long)a1, a7, a8, a9, a10, v37, v38, a13, a14, v31, v33, v34, v35, v36) )
{
LABEL_37:
v39 = 0;
goto LABEL_63;
}
goto LABEL_43;
}
LABEL_68:
*v58 = 0;
return 0xFFFFFFFFLL;
}
| js_parse_property_name:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R13D,R8D
MOV R12D,ECX
MOV EBP,EDX
MOV qword ptr [RSP + 0x10],RSI
MOV R14,RDI
XOR EBX,EBX
TEST EDX,EDX
JZ 0x00165d5c
MOV EAX,dword ptr [R14 + 0x20]
CMP EAX,-0x7d
JNZ 0x00165bee
CMP dword ptr [R14 + 0x38],0x42
JNZ 0x00165bd7
CMP dword ptr [R14 + 0x3c],0x0
JZ 0x00165cde
LAB_00165bd7:
CMP EAX,-0x7d
JNZ 0x00165bee
CMP dword ptr [R14 + 0x38],0x43
JNZ 0x00165bee
CMP dword ptr [R14 + 0x3c],0x0
JZ 0x00165cde
LAB_00165bee:
CMP EAX,0x2a
JNZ 0x00165c0d
MOV RDI,R14
CALL 0x0015d1cf
TEST EAX,EAX
JNZ 0x00165f4b
MOV EBX,0x4
JMP 0x00165d5c
LAB_00165c0d:
CMP EAX,-0x7d
JNZ 0x00165d5c
CMP dword ptr [R14 + 0x38],0x86
JNZ 0x00165d5c
CMP dword ptr [R14 + 0x3c],0x0
JNZ 0x00165d5c
MOV RDI,R14
MOV ESI,0x1
CALL 0x0015f895
CMP EAX,0xa
JZ 0x00165d5c
MOVSXD R15,dword ptr [R14 + 0x38]
CMP R15,0xe0
JL 0x00165c63
MOV RAX,qword ptr [R14]
MOV RAX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RAX + 0x68]
MOV RAX,qword ptr [RAX + R15*0x8]
INC dword ptr [RAX]
LAB_00165c63:
MOV RDI,R14
CALL 0x0015d1cf
TEST EAX,EAX
JNZ 0x00165dff
MOV dword ptr [RSP + 0xc],R12D
MOV EAX,dword ptr [R14 + 0x20]
XOR EBX,EBX
MOV R12D,0x1
CMP RAX,0x3d
JA 0x00165c9e
MOV RCX,0x2c00110000000000
BT RCX,RAX
JC 0x00165e0f
LAB_00165c9e:
CMP EAX,0x7d
JZ 0x00165e0f
MOV RDI,qword ptr [R14]
MOV ESI,R15D
CALL 0x001207d8
MOV EBX,0x5
CMP dword ptr [R14 + 0x20],0x2a
MOV R12D,dword ptr [RSP + 0xc]
JNZ 0x00165d5c
MOV RDI,R14
CALL 0x0015d1cf
TEST EAX,EAX
JNZ 0x00165f4b
MOV EBX,0x6
JMP 0x00165d57
LAB_00165cde:
MOVSXD R15,dword ptr [R14 + 0x38]
CMP R15,0xe0
JL 0x00165cfc
MOV RAX,qword ptr [R14]
MOV RAX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RAX + 0x68]
MOV RAX,qword ptr [RAX + R15*0x8]
INC dword ptr [RAX]
LAB_00165cfc:
MOV RDI,R14
CALL 0x0015d1cf
TEST EAX,EAX
JNZ 0x00165dff
MOV dword ptr [RSP + 0xc],R12D
MOV EAX,dword ptr [R14 + 0x20]
XOR EBX,EBX
MOV R12D,0x1
CMP RAX,0x3d
JA 0x00165d37
MOV RCX,0x2c00110000000000
BT RCX,RAX
JC 0x00165e0f
LAB_00165d37:
CMP EAX,0x7d
JZ 0x00165e0f
XOR EBX,EBX
CMP R15D,0x43
SETZ BL
OR EBX,0x2
MOV RDI,qword ptr [R14]
MOV ESI,R15D
CALL 0x001207d8
LAB_00165d57:
MOV R12D,dword ptr [RSP + 0xc]
LAB_00165d5c:
MOV EAX,dword ptr [R14 + 0x20]
CMP EAX,-0x7d
SETNZ CL
LEA EDX,[RAX + 0x27]
CMP EDX,-0x2e
SETC DL
TEST CL,DL
JZ 0x00165dbc
CMP EAX,-0x80
JZ 0x00165e92
CMP EAX,0x5b
JZ 0x00165e50
CMP EAX,-0x7f
JNZ 0x00165ebe
MOV RDI,qword ptr [R14]
MOV RSI,qword ptr [R14 + 0x38]
MOV RDX,qword ptr [R14 + 0x40]
CALL 0x00124093
TEST EAX,EAX
JZ 0x00165f4b
MOV R15D,EAX
MOV RDI,R14
CALL 0x0015d1cf
TEST EAX,EAX
JNZ 0x00165dff
LAB_00165db5:
XOR EAX,EAX
JMP 0x00165f17
LAB_00165dbc:
MOV dword ptr [RSP + 0xc],R12D
XOR R12D,R12D
CMP EAX,-0x7d
JNZ 0x00165dd5
XOR R12D,R12D
CMP dword ptr [R14 + 0x40],0x0
SETZ R12B
LAB_00165dd5:
MOVSXD R15,dword ptr [R14 + 0x38]
CMP R15,0xe0
JL 0x00165df3
MOV RAX,qword ptr [R14]
MOV RAX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RAX + 0x68]
MOV RAX,qword ptr [RAX + R15*0x8]
INC dword ptr [RAX]
LAB_00165df3:
MOV RDI,R14
CALL 0x0015d1cf
TEST EAX,EAX
JZ 0x00165e0f
LAB_00165dff:
MOV RDI,qword ptr [R14]
MOV ESI,R15D
CALL 0x001207d8
JMP 0x00165f4b
LAB_00165e0f:
XOR EAX,EAX
CMP dword ptr [RSP + 0xc],0x0
JZ 0x00165f17
TEST R12D,R12D
JZ 0x00165f17
TEST EBX,EBX
JNZ 0x00165f17
TEST EBP,EBP
SETZ CL
MOV EDX,dword ptr [R14 + 0x20]
CMP EDX,0x3a
SETNZ SIL
CMP EDX,0x28
SETNZ DL
OR DL,CL
AND DL,SIL
MOVZX EBX,DL
JMP 0x00165f17
LAB_00165e50:
MOV RDI,R14
CALL 0x0015d1cf
TEST EAX,EAX
JNZ 0x00165f4b
MOV RDI,R14
MOV ESI,0x1
CALL 0x0016a9b7
TEST EAX,EAX
JNZ 0x00165f4b
MOV RDI,R14
MOV ESI,0x5d
CALL 0x001637c4
TEST EAX,EAX
JNZ 0x00165f4b
XOR R15D,R15D
JMP 0x00165db5
LAB_00165e92:
MOV RDI,qword ptr [R14]
MOV RSI,qword ptr [R14 + 0x38]
MOV RDX,qword ptr [R14 + 0x40]
CALL 0x00124093
MOV R15D,EAX
TEST EAX,EAX
JZ 0x00165f03
MOV RDI,R14
CALL 0x0015d1cf
MOV ECX,EAX
XOR EAX,EAX
TEST ECX,ECX
SETNZ AL
ADD EAX,EAX
JMP 0x00165f08
LAB_00165ebe:
CMP EAX,-0x57
SETNZ AL
TEST R13D,R13D
SETZ CL
OR CL,AL
JNZ 0x00165f3a
MOVSXD R15,dword ptr [R14 + 0x38]
CMP R15,0xe0
JL 0x00165eec
MOV RAX,qword ptr [R14]
MOV RAX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RAX + 0x68]
MOV RAX,qword ptr [RAX + R15*0x8]
INC dword ptr [RAX]
LAB_00165eec:
MOV RDI,R14
CALL 0x0015d1cf
TEST EAX,EAX
JNZ 0x00165dff
MOV EAX,0x10
JMP 0x00165f17
LAB_00165f03:
MOV EAX,0x4
LAB_00165f08:
TEST EAX,EAX
JZ 0x00165f17
CMP EAX,0x2
JZ 0x00165dff
JMP 0x00165f4b
LAB_00165f17:
CMP EBX,0x2
JC 0x00165f23
CMP dword ptr [R14 + 0x20],0x28
JNZ 0x00165f2f
LAB_00165f23:
MOV RCX,qword ptr [RSP + 0x10]
MOV dword ptr [RCX],R15D
OR EAX,EBX
JMP 0x00165f5b
LAB_00165f2f:
MOV RDI,qword ptr [R14]
MOV ESI,R15D
CALL 0x001207d8
LAB_00165f3a:
LEA RSI,[0x1a114d]
MOV RDI,R14
XOR EAX,EAX
CALL 0x0012fce9
LAB_00165f4b:
MOV RAX,qword ptr [RSP + 0x10]
MOV dword ptr [RAX],0x0
MOV EAX,0xffffffff
LAB_00165f5b:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
uint js_parse_property_name(long *param_1,int4 *param_2,int param_3,int param_4,int param_5)
{
int *piVar1;
long lVar2;
int iVar3;
int iVar4;
uint uVar5;
uint uVar6;
ulong uVar7;
bool bVar8;
uVar5 = 0;
uVar6 = 0;
if (param_3 == 0) {
LAB_00165d5c:
iVar3 = (int)param_1[4];
if (iVar3 != -0x7d && iVar3 + 0x27U < 0xffffffd2) {
if (iVar3 == -0x80) {
uVar5 = JS_ValueToAtom(*param_1,param_1[7],param_1[8]);
uVar7 = (ulong)uVar5;
if (uVar5 == 0) {
uVar5 = 4;
}
else {
iVar3 = next_token(param_1);
uVar5 = (uint)(iVar3 != 0) * 2;
}
if (uVar5 != 0) {
if (uVar5 != 2) goto LAB_00165f4b;
goto LAB_00165dff;
}
LAB_00165f17:
if ((uVar6 < 2) || ((int)param_1[4] == 0x28)) {
*param_2 = (int)uVar7;
return uVar5 | uVar6;
}
JS_FreeAtom(*param_1,uVar7 & 0xffffffff);
}
else {
if (iVar3 == 0x5b) {
iVar3 = next_token(param_1);
if (((iVar3 != 0) || (iVar3 = js_parse_expr2(param_1,1), iVar3 != 0)) ||
(iVar3 = js_parse_expect(param_1,0x5d), iVar3 != 0)) goto LAB_00165f4b;
uVar7 = 0;
LAB_00165db5:
uVar5 = 0;
goto LAB_00165f17;
}
if (iVar3 == -0x7f) {
uVar5 = JS_ValueToAtom(*param_1,param_1[7],param_1[8]);
if (uVar5 == 0) goto LAB_00165f4b;
uVar7 = (ulong)uVar5;
iVar3 = next_token(param_1);
if (iVar3 == 0) goto LAB_00165db5;
goto LAB_00165dff;
}
if (param_5 != 0 && iVar3 == -0x57) {
uVar7 = (ulong)(int)param_1[7];
if (0xdf < (long)uVar7) {
piVar1 = *(int **)(*(long *)(*(long *)(*param_1 + 0x18) + 0x68) + uVar7 * 8);
*piVar1 = *piVar1 + 1;
}
iVar3 = next_token(param_1);
if (iVar3 == 0) {
uVar5 = 0x10;
goto LAB_00165f17;
}
goto LAB_00165dff;
}
}
js_parse_error(param_1,"invalid property name");
goto LAB_00165f4b;
}
bVar8 = false;
if (iVar3 == -0x7d) {
bVar8 = (int)param_1[8] == 0;
}
uVar7 = (ulong)(int)param_1[7];
if (0xdf < (long)uVar7) {
piVar1 = *(int **)(*(long *)(*(long *)(*param_1 + 0x18) + 0x68) + uVar7 * 8);
*piVar1 = *piVar1 + 1;
}
iVar3 = next_token(param_1);
if (iVar3 == 0) {
LAB_00165e0f:
uVar5 = 0;
if (((param_4 != 0) && (bVar8)) && (uVar6 == 0)) {
uVar6 = (uint)(((int)param_1[4] != 0x28 || param_3 == 0) && (int)param_1[4] != 0x3a);
}
goto LAB_00165f17;
}
}
else {
iVar3 = (int)param_1[4];
if ((iVar3 != -0x7d) ||
((((int)param_1[7] != 0x42 || (*(int *)((long)param_1 + 0x3c) != 0)) &&
(((int)param_1[7] != 0x43 || (*(int *)((long)param_1 + 0x3c) != 0)))))) {
if (iVar3 == 0x2a) {
iVar3 = next_token(param_1);
if (iVar3 != 0) goto LAB_00165f4b;
uVar6 = 4;
}
else {
uVar6 = uVar5;
if ((((iVar3 == -0x7d) && ((int)param_1[7] == 0x86)) &&
(*(int *)((long)param_1 + 0x3c) == 0)) && (iVar3 = peek_token(param_1,1), iVar3 != 10))
{
lVar2 = param_1[7];
uVar7 = (ulong)(int)lVar2;
if (0xdf < (long)uVar7) {
piVar1 = *(int **)(*(long *)(*(long *)(*param_1 + 0x18) + 0x68) + uVar7 * 8);
*piVar1 = *piVar1 + 1;
}
iVar3 = next_token(param_1);
if (iVar3 != 0) goto LAB_00165dff;
uVar5 = *(uint *)(param_1 + 4);
bVar8 = true;
if ((((ulong)uVar5 < 0x3e) &&
(uVar6 = 0, (0x2c00110000000000U >> ((ulong)uVar5 & 0x3f) & 1) != 0)) ||
(uVar6 = 0, uVar5 == 0x7d)) goto LAB_00165e0f;
JS_FreeAtom(*param_1,(int)lVar2);
uVar6 = 5;
if ((int)param_1[4] == 0x2a) {
iVar3 = next_token(param_1);
if (iVar3 != 0) goto LAB_00165f4b;
uVar6 = 6;
}
}
}
goto LAB_00165d5c;
}
iVar3 = (int)param_1[7];
uVar7 = (ulong)iVar3;
if (0xdf < (long)uVar7) {
piVar1 = *(int **)(*(long *)(*(long *)(*param_1 + 0x18) + 0x68) + uVar7 * 8);
*piVar1 = *piVar1 + 1;
}
iVar4 = next_token(param_1);
if (iVar4 == 0) {
uVar5 = *(uint *)(param_1 + 4);
uVar6 = 0;
bVar8 = true;
if (((0x3d < (ulong)uVar5) || ((0x2c00110000000000U >> ((ulong)uVar5 & 0x3f) & 1) == 0)) &&
(uVar5 != 0x7d)) {
uVar6 = iVar3 == 0x43 | 2;
JS_FreeAtom(*param_1,iVar3);
goto LAB_00165d5c;
}
goto LAB_00165e0f;
}
}
LAB_00165dff:
JS_FreeAtom(*param_1,uVar7 & 0xffffffff);
LAB_00165f4b:
*param_2 = 0;
return 0xffffffff;
}
| |
52,962 | js_parse_property_name | bluesky950520[P]quickjs/quickjs.c | static int __exception js_parse_property_name(JSParseState *s,
JSAtom *pname,
BOOL allow_method, BOOL allow_var,
BOOL allow_private)
{
int is_private = 0;
BOOL is_non_reserved_ident;
JSAtom name;
int prop_type;
prop_type = PROP_TYPE_IDENT;
if (allow_method) {
if (token_is_pseudo_keyword(s, JS_ATOM_get)
|| token_is_pseudo_keyword(s, JS_ATOM_set)) {
/* get x(), set x() */
name = JS_DupAtom(s->ctx, s->token.u.ident.atom);
if (next_token(s))
goto fail1;
if (s->token.val == ':' || s->token.val == ',' ||
s->token.val == '}' || s->token.val == '(' ||
s->token.val == '=' || s->token.val == ';') {
is_non_reserved_ident = TRUE;
goto ident_found;
}
prop_type = PROP_TYPE_GET + (name == JS_ATOM_set);
JS_FreeAtom(s->ctx, name);
} else if (s->token.val == '*') {
if (next_token(s))
goto fail;
prop_type = PROP_TYPE_STAR;
} else if (token_is_pseudo_keyword(s, JS_ATOM_async) &&
peek_token(s, TRUE) != '\n') {
name = JS_DupAtom(s->ctx, s->token.u.ident.atom);
if (next_token(s))
goto fail1;
if (s->token.val == ':' || s->token.val == ',' ||
s->token.val == '}' || s->token.val == '(' ||
s->token.val == '=' || s->token.val == ';') {
is_non_reserved_ident = TRUE;
goto ident_found;
}
JS_FreeAtom(s->ctx, name);
if (s->token.val == '*') {
if (next_token(s))
goto fail;
prop_type = PROP_TYPE_ASYNC_STAR;
} else {
prop_type = PROP_TYPE_ASYNC;
}
}
}
if (token_is_ident(s->token.val)) {
/* variable can only be a non-reserved identifier */
is_non_reserved_ident =
(s->token.val == TOK_IDENT && !s->token.u.ident.is_reserved);
/* keywords and reserved words have a valid atom */
name = JS_DupAtom(s->ctx, s->token.u.ident.atom);
if (next_token(s))
goto fail1;
ident_found:
if (is_non_reserved_ident &&
prop_type == PROP_TYPE_IDENT && allow_var) {
if (!(s->token.val == ':' ||
(s->token.val == '(' && allow_method))) {
prop_type = PROP_TYPE_VAR;
}
}
} else if (s->token.val == TOK_STRING) {
name = JS_ValueToAtom(s->ctx, s->token.u.str.str);
if (name == JS_ATOM_NULL)
goto fail;
if (next_token(s))
goto fail1;
} else if (s->token.val == TOK_NUMBER) {
JSValue val;
val = s->token.u.num.val;
name = JS_ValueToAtom(s->ctx, val);
if (name == JS_ATOM_NULL)
goto fail;
if (next_token(s))
goto fail1;
} else if (s->token.val == '[') {
if (next_token(s))
goto fail;
if (js_parse_expr(s))
goto fail;
if (js_parse_expect(s, ']'))
goto fail;
name = JS_ATOM_NULL;
} else if (s->token.val == TOK_PRIVATE_NAME && allow_private) {
name = JS_DupAtom(s->ctx, s->token.u.ident.atom);
if (next_token(s))
goto fail1;
is_private = PROP_TYPE_PRIVATE;
} else {
goto invalid_prop;
}
if (prop_type != PROP_TYPE_IDENT && prop_type != PROP_TYPE_VAR &&
s->token.val != '(') {
JS_FreeAtom(s->ctx, name);
invalid_prop:
js_parse_error(s, "invalid property name");
goto fail;
}
*pname = name;
return prop_type | is_private;
fail1:
JS_FreeAtom(s->ctx, name);
fail:
*pname = JS_ATOM_NULL;
return -1;
} | O2 | c | js_parse_property_name:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %r13d
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, 0x10(%rsp)
movq %rdi, %r14
xorl %r12d, %r12d
testl %edx, %edx
je 0x56c45
pushq $0x42
popq %rsi
movq %r14, %rdi
callq 0x51b2a
testl %eax, %eax
jne 0x56bca
pushq $0x43
popq %rsi
movq %r14, %rdi
callq 0x51b2a
testl %eax, %eax
je 0x56cfb
movslq 0x38(%r14), %r15
cmpq $0xe0, %r15
jl 0x56be8
movq (%r14), %rax
movq 0x18(%rax), %rax
movq 0x68(%rax), %rax
movq (%rax,%r15,8), %rax
incl (%rax)
movq %r14, %rdi
callq 0x4fa4e
testl %eax, %eax
jne 0x56ce0
movl %ebx, 0xc(%rsp)
movl 0x20(%r14), %eax
xorl %r12d, %r12d
pushq $0x1
popq %rbx
cmpq $0x3d, %rax
ja 0x56c20
movabsq $0x2c00110000000000, %rcx # imm = 0x2C00110000000000
btq %rax, %rcx
jb 0x56e16
cmpl $0x7d, %eax
je 0x56e16
xorl %r12d, %r12d
cmpl $0x43, %r15d
sete %r12b
orl $0x2, %r12d
movq (%r14), %rdi
movl %r15d, %esi
callq 0x1a995
jmp 0x56c49
movl %ebx, 0xc(%rsp)
movl 0x20(%r14), %eax
cmpl $-0x7d, %eax
setne %cl
leal 0x27(%rax), %edx
cmpl $-0x2e, %edx
setb %dl
testb %dl, %cl
je 0x56ca1
cmpl $-0x80, %eax
je 0x56c77
cmpl $0x5b, %eax
je 0x56d1f
cmpl $-0x7f, %eax
jne 0x56d4e
movq (%r14), %rdi
movq 0x38(%r14), %rsi
movq 0x40(%r14), %rdx
callq 0x1e0bc
testl %eax, %eax
je 0x56ceb
movl %eax, %r15d
movq %r14, %rdi
callq 0x4fa4e
testl %eax, %eax
jne 0x56ce0
xorl %eax, %eax
jmp 0x56e49
xorl %ebx, %ebx
cmpl $-0x7d, %eax
jne 0x56cb2
xorl %ebx, %ebx
cmpl $0x0, 0x40(%r14)
sete %bl
movslq 0x38(%r14), %r15
cmpq $0xe0, %r15
jl 0x56cd0
movq (%r14), %rax
movq 0x18(%rax), %rax
movq 0x68(%rax), %rax
movq (%rax,%r15,8), %rax
incl (%rax)
movq %r14, %rdi
callq 0x4fa4e
testl %eax, %eax
je 0x56e16
movq (%r14), %rdi
movl %r15d, %esi
callq 0x1a995
movq 0x10(%rsp), %rax
andl $0x0, (%rax)
pushq $-0x1
popq %rax
jmp 0x56e61
cmpl $0x2a, 0x20(%r14)
jne 0x56d98
movq %r14, %rdi
callq 0x4fa4e
testl %eax, %eax
jne 0x56ceb
movl %ebx, 0xc(%rsp)
pushq $0x4
popq %r12
jmp 0x56c49
movq %r14, %rdi
callq 0x4fa4e
testl %eax, %eax
jne 0x56ceb
movq %r14, %rdi
callq 0x59f66
testl %eax, %eax
jne 0x56ceb
pushq $0x5d
popq %rsi
movq %r14, %rdi
callq 0x5523b
testl %eax, %eax
jne 0x56ceb
xorl %r15d, %r15d
jmp 0x56c9a
cmpl $-0x57, %eax
setne %al
testl %r13d, %r13d
sete %cl
orb %al, %cl
jne 0x56e7b
movslq 0x38(%r14), %r15
cmpq $0xe0, %r15
jl 0x56d80
movq (%r14), %rax
movq 0x18(%rax), %rax
movq 0x68(%rax), %rax
movq (%rax,%r15,8), %rax
incl (%rax)
movq %r14, %rdi
callq 0x4fa4e
testl %eax, %eax
jne 0x56ce0
pushq $0x10
popq %rax
jmp 0x56e49
movl %ebx, 0xc(%rsp)
movq %r14, %rdi
movl $0x86, %esi
callq 0x51b2a
testl %eax, %eax
je 0x56c49
pushq $0x1
popq %rbx
movq %r14, %rdi
movl %ebx, %esi
callq 0x51b41
cmpl $0xa, %eax
je 0x56c49
movslq 0x38(%r14), %r15
cmpq $0xe0, %r15
jl 0x56de5
movq (%r14), %rax
movq 0x18(%rax), %rax
movq 0x68(%rax), %rax
movq (%rax,%r15,8), %rax
incl (%rax)
movq %r14, %rdi
callq 0x4fa4e
testl %eax, %eax
jne 0x56ce0
movl 0x20(%r14), %eax
xorl %r12d, %r12d
cmpq $0x3d, %rax
ja 0x56e91
movabsq $0x2c00110000000000, %rcx # imm = 0x2C00110000000000
btq %rax, %rcx
jae 0x56e91
xorl %eax, %eax
cmpl $0x0, 0xc(%rsp)
je 0x56e49
testl %ebx, %ebx
je 0x56e49
testl %r12d, %r12d
jne 0x56e49
testl %ebp, %ebp
sete %al
movl 0x20(%r14), %ecx
cmpl $0x3a, %ecx
setne %dl
cmpl $0x28, %ecx
setne %cl
orb %al, %cl
andb %dl, %cl
movzbl %cl, %r12d
xorl %eax, %eax
jmp 0x56e56
cmpl $0x2, %r12d
jb 0x56e56
cmpl $0x28, 0x20(%r14)
jne 0x56e70
orl %r12d, %eax
movq 0x10(%rsp), %rcx
movl %r15d, (%rcx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r14), %rdi
movl %r15d, %esi
callq 0x1a995
leaq 0x31205(%rip), %rsi # 0x88087
movq %r14, %rdi
xorl %eax, %eax
callq 0x28457
jmp 0x56ceb
cmpl $0x7d, %eax
je 0x56e16
movq (%r14), %rdi
movl %r15d, %esi
callq 0x1a995
cmpl $0x2a, 0x20(%r14)
jne 0x56ebf
movq %r14, %rdi
callq 0x4fa4e
testl %eax, %eax
jne 0x56ceb
pushq $0x6
jmp 0x56d18
pushq $0x5
jmp 0x56d18
| js_parse_property_name:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r13d, r8d
mov ebx, ecx
mov ebp, edx
mov [rsp+48h+var_38], rsi
mov r14, rdi
xor r12d, r12d
test edx, edx
jz loc_56C45
push 42h ; 'B'
pop rsi
mov rdi, r14
call token_is_pseudo_keyword
test eax, eax
jnz short loc_56BCA
push 43h ; 'C'
pop rsi
mov rdi, r14
call token_is_pseudo_keyword
test eax, eax
jz loc_56CFB
loc_56BCA:
movsxd r15, dword ptr [r14+38h]
cmp r15, 0E0h
jl short loc_56BE8
mov rax, [r14]
mov rax, [rax+18h]
mov rax, [rax+68h]
mov rax, [rax+r15*8]
inc dword ptr [rax]
loc_56BE8:
mov rdi, r14
call next_token
test eax, eax
jnz loc_56CE0
mov [rsp+48h+var_3C], ebx
mov eax, [r14+20h]
xor r12d, r12d
push 1
pop rbx
cmp rax, 3Dh ; '='
ja short loc_56C20
mov rcx, 2C00110000000000h
bt rcx, rax
jb loc_56E16
loc_56C20:
cmp eax, 7Dh ; '}'
jz loc_56E16
xor r12d, r12d
cmp r15d, 43h ; 'C'
setz r12b
or r12d, 2
mov rdi, [r14]
mov esi, r15d
call JS_FreeAtom
jmp short loc_56C49
loc_56C45:
mov [rsp+48h+var_3C], ebx
loc_56C49:
mov eax, [r14+20h]
cmp eax, 0FFFFFF83h
setnz cl
lea edx, [rax+27h]
cmp edx, 0FFFFFFD2h
setb dl
test cl, dl
jz short loc_56CA1
cmp eax, 0FFFFFF80h
jz short loc_56C77
cmp eax, 5Bh ; '['
jz loc_56D1F
cmp eax, 0FFFFFF81h
jnz loc_56D4E
loc_56C77:
mov rdi, [r14]
mov rsi, [r14+38h]
mov rdx, [r14+40h]
call JS_ValueToAtom
test eax, eax
jz short loc_56CEB
mov r15d, eax
mov rdi, r14
call next_token
test eax, eax
jnz short loc_56CE0
loc_56C9A:
xor eax, eax
jmp loc_56E49
loc_56CA1:
xor ebx, ebx
cmp eax, 0FFFFFF83h
jnz short loc_56CB2
xor ebx, ebx
cmp dword ptr [r14+40h], 0
setz bl
loc_56CB2:
movsxd r15, dword ptr [r14+38h]
cmp r15, 0E0h
jl short loc_56CD0
mov rax, [r14]
mov rax, [rax+18h]
mov rax, [rax+68h]
mov rax, [rax+r15*8]
inc dword ptr [rax]
loc_56CD0:
mov rdi, r14
call next_token
test eax, eax
jz loc_56E16
loc_56CE0:
mov rdi, [r14]
mov esi, r15d
call JS_FreeAtom
loc_56CEB:
mov rax, [rsp+48h+var_38]
and dword ptr [rax], 0
push 0FFFFFFFFFFFFFFFFh
pop rax
jmp loc_56E61
loc_56CFB:
cmp dword ptr [r14+20h], 2Ah ; '*'
jnz loc_56D98
mov rdi, r14
call next_token
test eax, eax
jnz short loc_56CEB
mov [rsp+48h+var_3C], ebx
push 4
loc_56D18:
pop r12
jmp loc_56C49
loc_56D1F:
mov rdi, r14
call next_token
test eax, eax
jnz short loc_56CEB
mov rdi, r14
call js_parse_expr
test eax, eax
jnz short loc_56CEB
push 5Dh ; ']'
pop rsi
mov rdi, r14
call js_parse_expect
test eax, eax
jnz short loc_56CEB
xor r15d, r15d
jmp loc_56C9A
loc_56D4E:
cmp eax, 0FFFFFFA9h
setnz al
test r13d, r13d
setz cl
or cl, al
jnz loc_56E7B
movsxd r15, dword ptr [r14+38h]
cmp r15, 0E0h
jl short loc_56D80
mov rax, [r14]
mov rax, [rax+18h]
mov rax, [rax+68h]
mov rax, [rax+r15*8]
inc dword ptr [rax]
loc_56D80:
mov rdi, r14
call next_token
test eax, eax
jnz loc_56CE0
push 10h
pop rax
jmp loc_56E49
loc_56D98:
mov [rsp+48h+var_3C], ebx
mov rdi, r14
mov esi, 86h
call token_is_pseudo_keyword
test eax, eax
jz loc_56C49
push 1
pop rbx
mov rdi, r14
mov esi, ebx
call peek_token
cmp eax, 0Ah
jz loc_56C49
movsxd r15, dword ptr [r14+38h]
cmp r15, 0E0h
jl short loc_56DE5
mov rax, [r14]
mov rax, [rax+18h]
mov rax, [rax+68h]
mov rax, [rax+r15*8]
inc dword ptr [rax]
loc_56DE5:
mov rdi, r14
call next_token
test eax, eax
jnz loc_56CE0
mov eax, [r14+20h]
xor r12d, r12d
cmp rax, 3Dh ; '='
ja loc_56E91
mov rcx, 2C00110000000000h
bt rcx, rax
jnb short loc_56E91
loc_56E16:
xor eax, eax
cmp [rsp+48h+var_3C], 0
jz short loc_56E49
test ebx, ebx
jz short loc_56E49
test r12d, r12d
jnz short loc_56E49
test ebp, ebp
setz al
mov ecx, [r14+20h]
cmp ecx, 3Ah ; ':'
setnz dl
cmp ecx, 28h ; '('
setnz cl
or cl, al
and cl, dl
movzx r12d, cl
xor eax, eax
jmp short loc_56E56
loc_56E49:
cmp r12d, 2
jb short loc_56E56
cmp dword ptr [r14+20h], 28h ; '('
jnz short loc_56E70
loc_56E56:
or eax, r12d
mov rcx, [rsp+48h+var_38]
mov [rcx], r15d
loc_56E61:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_56E70:
mov rdi, [r14]
mov esi, r15d
call JS_FreeAtom
loc_56E7B:
lea rsi, aInvalidPropert_1; "invalid property name"
mov rdi, r14
xor eax, eax
call js_parse_error
jmp loc_56CEB
loc_56E91:
cmp eax, 7Dh ; '}'
jz short loc_56E16
mov rdi, [r14]
mov esi, r15d
call JS_FreeAtom
cmp dword ptr [r14+20h], 2Ah ; '*'
jnz short loc_56EBF
mov rdi, r14
call next_token
test eax, eax
jnz loc_56CEB
push 6
jmp loc_56D18
loc_56EBF:
push 5
jmp loc_56D18
| long long js_parse_property_name(
long long a1,
long long a2,
int a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
int v14; // r13d
int v15; // ebx
unsigned int v17; // r12d
long long v18; // rdx
long long v19; // rcx
long long v20; // r8
long long v21; // r9
__m128 v22; // xmm4
__m128 v23; // xmm5
long long v24; // r15
_DWORD *v25; // rax
unsigned long long v26; // rax
BOOL v27; // ebx
long long v28; // rcx
int v29; // eax
long long v30; // rdx
long long v31; // rsi
int v32; // eax
long long v33; // rdx
long long v34; // rcx
long long v35; // r8
long long v36; // r9
__m128 v37; // xmm4
__m128 v38; // xmm5
int v39; // eax
_DWORD *v40; // rax
long long result; // rax
long long v42; // rdx
long long v43; // rcx
long long v44; // r8
long long v45; // r9
__m128 v46; // xmm4
__m128 v47; // xmm5
_DWORD *v48; // rax
long long v49; // rdx
_DWORD *v50; // rax
unsigned long long v51; // rax
long long v52; // rcx
long long v53; // rdx
int v54; // [rsp-8h] [rbp-50h]
char v55; // [rsp+0h] [rbp-48h]
int v56; // [rsp+Ch] [rbp-3Ch]
_DWORD *v57; // [rsp+10h] [rbp-38h]
v14 = a5;
v15 = a4;
v57 = (_DWORD *)a2;
v17 = 0;
if ( a3 )
{
a2 = 66LL;
if ( token_is_pseudo_keyword((_DWORD *)a1, 66) || (a2 = 67LL, token_is_pseudo_keyword((_DWORD *)a1, 67)) )
{
v24 = *(int *)(a1 + 56);
if ( v24 >= 224 )
{
v25 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(*(_QWORD *)a1 + 24LL) + 104LL) + 8 * v24);
++*v25;
}
if ( (unsigned int)next_token(a1, a2, v18, a7, a8, a9, a10, v22, v23, a13, a14, v19, v20, v21) )
goto LABEL_24;
v56 = v15;
v26 = *(unsigned int *)(a1 + 32);
v17 = 0;
v27 = 1;
if ( v26 <= 0x3D )
{
v28 = 0x2C00110000000000LL;
if ( _bittest64(&v28, v26) )
goto LABEL_46;
}
if ( (_DWORD)v26 == 125 )
goto LABEL_46;
v17 = ((_DWORD)v24 == 67) | 2;
a2 = (unsigned int)v24;
JS_FreeAtom(*(_QWORD *)a1, v24);
}
else
{
if ( *(_DWORD *)(a1 + 32) == 42 )
{
if ( (unsigned int)next_token(a1, 67LL, v18, a7, a8, a9, a10, v22, v23, a13, a14, v19, v20, v21) )
goto LABEL_25;
v56 = v15;
v54 = 4;
}
else
{
v56 = v15;
a2 = 134LL;
if ( !token_is_pseudo_keyword((_DWORD *)a1, 134) )
goto LABEL_12;
v27 = 1;
a2 = 1LL;
if ( (unsigned int)peek_token(a1, 1) == 10 )
goto LABEL_12;
v24 = *(int *)(a1 + 56);
if ( v24 >= 224 )
{
v50 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(*(_QWORD *)a1 + 24LL) + 104LL) + 8 * v24);
++*v50;
}
if ( (unsigned int)next_token(a1, 1LL, v49, a7, a8, a9, a10, a11, a12, a13, a14, a4, a5, a6) )
goto LABEL_24;
v51 = *(unsigned int *)(a1 + 32);
v17 = 0;
if ( v51 <= 0x3D )
{
v52 = 0x2C00110000000000LL;
if ( _bittest64(&v52, v51) )
goto LABEL_46;
}
if ( (_DWORD)v51 == 125 )
goto LABEL_46;
a2 = (unsigned int)v24;
JS_FreeAtom(*(_QWORD *)a1, v24);
if ( *(_DWORD *)(a1 + 32) == 42 )
{
if ( (unsigned int)next_token(a1, (unsigned int)v24, v53, a7, a8, a9, a10, a11, a12, a13, a14, a4, a5, a6) )
goto LABEL_25;
v54 = 6;
}
else
{
v54 = 5;
}
}
v17 = v54;
}
}
else
{
v56 = a4;
}
LABEL_12:
v29 = *(_DWORD *)(a1 + 32);
LOBYTE(a4) = v29 != -125;
v30 = (unsigned int)(v29 + 39);
LOBYTE(v30) = (unsigned int)v30 < 0xFFFFFFD2;
if ( ((unsigned __int8)v30 & (unsigned __int8)a4) != 0 )
{
switch ( v29 )
{
case -128:
goto LABEL_16;
case 91:
if ( (unsigned int)next_token(a1, a2, v30, a7, a8, a9, a10, a11, a12, a13, a14, a4, a5, a6)
|| (unsigned int)js_parse_expr(a1)
|| (unsigned int)js_parse_expect(a1, 93LL, v42, v43, v44, v45, a7, a8, a9, a10, v46, v47, a13, a14) )
{
goto LABEL_25;
}
LODWORD(v24) = 0;
goto LABEL_18;
case -127:
LABEL_16:
v31 = *(_QWORD *)(a1 + 56);
v32 = JS_ValueToAtom(*(_QWORD *)a1, v31, *(_QWORD *)(a1 + 64));
if ( !v32 )
{
LABEL_25:
*v57 = 0;
return -1LL;
}
LODWORD(v24) = v32;
if ( !(unsigned int)next_token(a1, v31, v33, a7, a8, a9, a10, v37, v38, a13, a14, v34, v35, v36) )
{
LABEL_18:
v39 = 0;
goto LABEL_50;
}
break;
default:
LOBYTE(a4) = v29 != -87 || v14 == 0;
if ( (_BYTE)a4 )
{
LABEL_54:
js_parse_error(
(long long *)a1,
(long long)"invalid property name",
v30,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v55);
goto LABEL_25;
}
v24 = *(int *)(a1 + 56);
if ( v24 >= 224 )
{
v48 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(*(_QWORD *)a1 + 24LL) + 104LL) + 8 * v24);
++*v48;
}
if ( !(unsigned int)next_token(a1, a2, v30, a7, a8, a9, a10, a11, a12, a13, a14, a4, a5, a6) )
{
v39 = 16;
LABEL_50:
if ( v17 < 2 || *(_DWORD *)(a1 + 32) == 40 )
goto LABEL_52;
JS_FreeAtom(*(_QWORD *)a1, v24);
goto LABEL_54;
}
break;
}
LABEL_24:
JS_FreeAtom(*(_QWORD *)a1, v24);
goto LABEL_25;
}
v27 = 0;
if ( v29 == -125 )
v27 = *(_DWORD *)(a1 + 64) == 0;
v24 = *(int *)(a1 + 56);
if ( v24 >= 224 )
{
v40 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(*(_QWORD *)a1 + 24LL) + 104LL) + 8 * v24);
++*v40;
}
if ( (unsigned int)next_token(a1, a2, v30, a7, a8, a9, a10, a11, a12, a13, a14, a4, a5, a6) )
goto LABEL_24;
LABEL_46:
v39 = 0;
if ( !v56 || !v27 || v17 )
goto LABEL_50;
v17 = *(_DWORD *)(a1 + 32) != 58 && (a3 == 0 || *(_DWORD *)(a1 + 32) != 40);
v39 = 0;
LABEL_52:
result = v17 | v39;
*v57 = v24;
return result;
}
| js_parse_property_name:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R13D,R8D
MOV EBX,ECX
MOV EBP,EDX
MOV qword ptr [RSP + 0x10],RSI
MOV R14,RDI
XOR R12D,R12D
TEST EDX,EDX
JZ 0x00156c45
PUSH 0x42
POP RSI
MOV RDI,R14
CALL 0x00151b2a
TEST EAX,EAX
JNZ 0x00156bca
PUSH 0x43
POP RSI
MOV RDI,R14
CALL 0x00151b2a
TEST EAX,EAX
JZ 0x00156cfb
LAB_00156bca:
MOVSXD R15,dword ptr [R14 + 0x38]
CMP R15,0xe0
JL 0x00156be8
MOV RAX,qword ptr [R14]
MOV RAX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RAX + 0x68]
MOV RAX,qword ptr [RAX + R15*0x8]
INC dword ptr [RAX]
LAB_00156be8:
MOV RDI,R14
CALL 0x0014fa4e
TEST EAX,EAX
JNZ 0x00156ce0
MOV dword ptr [RSP + 0xc],EBX
MOV EAX,dword ptr [R14 + 0x20]
XOR R12D,R12D
PUSH 0x1
POP RBX
CMP RAX,0x3d
JA 0x00156c20
MOV RCX,0x2c00110000000000
BT RCX,RAX
JC 0x00156e16
LAB_00156c20:
CMP EAX,0x7d
JZ 0x00156e16
XOR R12D,R12D
CMP R15D,0x43
SETZ R12B
OR R12D,0x2
MOV RDI,qword ptr [R14]
MOV ESI,R15D
CALL 0x0011a995
JMP 0x00156c49
LAB_00156c45:
MOV dword ptr [RSP + 0xc],EBX
LAB_00156c49:
MOV EAX,dword ptr [R14 + 0x20]
CMP EAX,-0x7d
SETNZ CL
LEA EDX,[RAX + 0x27]
CMP EDX,-0x2e
SETC DL
TEST CL,DL
JZ 0x00156ca1
CMP EAX,-0x80
JZ 0x00156c77
CMP EAX,0x5b
JZ 0x00156d1f
CMP EAX,-0x7f
JNZ 0x00156d4e
LAB_00156c77:
MOV RDI,qword ptr [R14]
MOV RSI,qword ptr [R14 + 0x38]
MOV RDX,qword ptr [R14 + 0x40]
CALL 0x0011e0bc
TEST EAX,EAX
JZ 0x00156ceb
MOV R15D,EAX
MOV RDI,R14
CALL 0x0014fa4e
TEST EAX,EAX
JNZ 0x00156ce0
LAB_00156c9a:
XOR EAX,EAX
JMP 0x00156e49
LAB_00156ca1:
XOR EBX,EBX
CMP EAX,-0x7d
JNZ 0x00156cb2
XOR EBX,EBX
CMP dword ptr [R14 + 0x40],0x0
SETZ BL
LAB_00156cb2:
MOVSXD R15,dword ptr [R14 + 0x38]
CMP R15,0xe0
JL 0x00156cd0
MOV RAX,qword ptr [R14]
MOV RAX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RAX + 0x68]
MOV RAX,qword ptr [RAX + R15*0x8]
INC dword ptr [RAX]
LAB_00156cd0:
MOV RDI,R14
CALL 0x0014fa4e
TEST EAX,EAX
JZ 0x00156e16
LAB_00156ce0:
MOV RDI,qword ptr [R14]
MOV ESI,R15D
CALL 0x0011a995
LAB_00156ceb:
MOV RAX,qword ptr [RSP + 0x10]
AND dword ptr [RAX],0x0
PUSH -0x1
POP RAX
JMP 0x00156e61
LAB_00156cfb:
CMP dword ptr [R14 + 0x20],0x2a
JNZ 0x00156d98
MOV RDI,R14
CALL 0x0014fa4e
TEST EAX,EAX
JNZ 0x00156ceb
MOV dword ptr [RSP + 0xc],EBX
PUSH 0x4
LAB_00156d18:
POP R12
JMP 0x00156c49
LAB_00156d1f:
MOV RDI,R14
CALL 0x0014fa4e
TEST EAX,EAX
JNZ 0x00156ceb
MOV RDI,R14
CALL 0x00159f66
TEST EAX,EAX
JNZ 0x00156ceb
PUSH 0x5d
POP RSI
MOV RDI,R14
CALL 0x0015523b
TEST EAX,EAX
JNZ 0x00156ceb
XOR R15D,R15D
JMP 0x00156c9a
LAB_00156d4e:
CMP EAX,-0x57
SETNZ AL
TEST R13D,R13D
SETZ CL
OR CL,AL
JNZ 0x00156e7b
MOVSXD R15,dword ptr [R14 + 0x38]
CMP R15,0xe0
JL 0x00156d80
MOV RAX,qword ptr [R14]
MOV RAX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RAX + 0x68]
MOV RAX,qword ptr [RAX + R15*0x8]
INC dword ptr [RAX]
LAB_00156d80:
MOV RDI,R14
CALL 0x0014fa4e
TEST EAX,EAX
JNZ 0x00156ce0
PUSH 0x10
POP RAX
JMP 0x00156e49
LAB_00156d98:
MOV dword ptr [RSP + 0xc],EBX
MOV RDI,R14
MOV ESI,0x86
CALL 0x00151b2a
TEST EAX,EAX
JZ 0x00156c49
PUSH 0x1
POP RBX
MOV RDI,R14
MOV ESI,EBX
CALL 0x00151b41
CMP EAX,0xa
JZ 0x00156c49
MOVSXD R15,dword ptr [R14 + 0x38]
CMP R15,0xe0
JL 0x00156de5
MOV RAX,qword ptr [R14]
MOV RAX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RAX + 0x68]
MOV RAX,qword ptr [RAX + R15*0x8]
INC dword ptr [RAX]
LAB_00156de5:
MOV RDI,R14
CALL 0x0014fa4e
TEST EAX,EAX
JNZ 0x00156ce0
MOV EAX,dword ptr [R14 + 0x20]
XOR R12D,R12D
CMP RAX,0x3d
JA 0x00156e91
MOV RCX,0x2c00110000000000
BT RCX,RAX
JNC 0x00156e91
LAB_00156e16:
XOR EAX,EAX
CMP dword ptr [RSP + 0xc],0x0
JZ 0x00156e49
TEST EBX,EBX
JZ 0x00156e49
TEST R12D,R12D
JNZ 0x00156e49
TEST EBP,EBP
SETZ AL
MOV ECX,dword ptr [R14 + 0x20]
CMP ECX,0x3a
SETNZ DL
CMP ECX,0x28
SETNZ CL
OR CL,AL
AND CL,DL
MOVZX R12D,CL
XOR EAX,EAX
JMP 0x00156e56
LAB_00156e49:
CMP R12D,0x2
JC 0x00156e56
CMP dword ptr [R14 + 0x20],0x28
JNZ 0x00156e70
LAB_00156e56:
OR EAX,R12D
MOV RCX,qword ptr [RSP + 0x10]
MOV dword ptr [RCX],R15D
LAB_00156e61:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00156e70:
MOV RDI,qword ptr [R14]
MOV ESI,R15D
CALL 0x0011a995
LAB_00156e7b:
LEA RSI,[0x188087]
MOV RDI,R14
XOR EAX,EAX
CALL 0x00128457
JMP 0x00156ceb
LAB_00156e91:
CMP EAX,0x7d
JZ 0x00156e16
MOV RDI,qword ptr [R14]
MOV ESI,R15D
CALL 0x0011a995
CMP dword ptr [R14 + 0x20],0x2a
JNZ 0x00156ebf
MOV RDI,R14
CALL 0x0014fa4e
TEST EAX,EAX
JNZ 0x00156ceb
PUSH 0x6
JMP 0x00156d18
LAB_00156ebf:
PUSH 0x5
JMP 0x00156d18
|
ulong js_parse_property_name(long *param_1,int4 *param_2,int param_3,int param_4,int param_5)
{
int *piVar1;
long lVar2;
int iVar3;
int iVar4;
uint uVar5;
uint uVar6;
int4 uVar7;
ulong uVar8;
bool bVar9;
uVar6 = 0;
if (param_3 == 0) goto LAB_00156c49;
iVar3 = token_is_pseudo_keyword(param_1,0x42);
if ((iVar3 == 0) && (iVar3 = token_is_pseudo_keyword(param_1,0x43), iVar3 == 0)) {
if ((int)param_1[4] == 0x2a) {
iVar3 = next_token(param_1);
if (iVar3 == 0) {
uVar6 = 4;
goto LAB_00156c49;
}
}
else {
iVar3 = token_is_pseudo_keyword(param_1,0x86);
uVar6 = 0;
if (iVar3 != 0) {
bVar9 = true;
iVar3 = peek_token(param_1,1);
uVar6 = 0;
if (iVar3 != 10) {
lVar2 = param_1[7];
uVar8 = (ulong)(int)lVar2;
if (0xdf < (long)uVar8) {
piVar1 = *(int **)(*(long *)(*(long *)(*param_1 + 0x18) + 0x68) + uVar8 * 8);
*piVar1 = *piVar1 + 1;
}
iVar3 = next_token(param_1);
if (iVar3 != 0) goto LAB_00156ce0;
uVar5 = *(uint *)(param_1 + 4);
if ((((ulong)uVar5 < 0x3e) &&
(uVar6 = 0, (0x2c00110000000000U >> ((ulong)uVar5 & 0x3f) & 1) != 0)) ||
(uVar6 = 0, uVar5 == 0x7d)) goto LAB_00156e16;
JS_FreeAtom(*param_1,(int)lVar2);
if ((int)param_1[4] == 0x2a) {
iVar3 = next_token(param_1);
if (iVar3 != 0) goto LAB_00156ceb;
uVar6 = 6;
}
else {
uVar6 = 5;
}
}
}
LAB_00156c49:
iVar3 = (int)param_1[4];
if (iVar3 == -0x7d || 0xffffffd1 < iVar3 + 0x27U) {
bVar9 = false;
if (iVar3 == -0x7d) {
bVar9 = (int)param_1[8] == 0;
}
uVar8 = (ulong)(int)param_1[7];
if (0xdf < (long)uVar8) {
piVar1 = *(int **)(*(long *)(*(long *)(*param_1 + 0x18) + 0x68) + uVar8 * 8);
*piVar1 = *piVar1 + 1;
}
iVar3 = next_token(param_1);
if (iVar3 == 0) goto LAB_00156e16;
goto LAB_00156ce0;
}
if (iVar3 == -0x80) {
LAB_00156c77:
uVar5 = JS_ValueToAtom(*param_1,param_1[7],param_1[8]);
if (uVar5 == 0) goto LAB_00156ceb;
uVar8 = (ulong)uVar5;
iVar3 = next_token(param_1);
if (iVar3 != 0) goto LAB_00156ce0;
LAB_00156c9a:
uVar5 = 0;
goto LAB_00156e49;
}
if (iVar3 == 0x5b) {
iVar3 = next_token(param_1);
if (((iVar3 != 0) || (iVar3 = js_parse_expr(param_1), iVar3 != 0)) ||
(iVar3 = js_parse_expect(param_1,0x5d), iVar3 != 0)) goto LAB_00156ceb;
uVar8 = 0;
goto LAB_00156c9a;
}
if (iVar3 == -0x7f) goto LAB_00156c77;
if (param_5 != 0 && iVar3 == -0x57) {
uVar8 = (ulong)(int)param_1[7];
if (0xdf < (long)uVar8) {
piVar1 = *(int **)(*(long *)(*(long *)(*param_1 + 0x18) + 0x68) + uVar8 * 8);
*piVar1 = *piVar1 + 1;
}
iVar3 = next_token(param_1);
if (iVar3 != 0) goto LAB_00156ce0;
uVar5 = 0x10;
goto LAB_00156e49;
}
LAB_00156e7b:
js_parse_error(param_1,"invalid property name");
}
LAB_00156ceb:
*param_2 = 0;
uVar8 = 0xffffffffffffffff;
}
else {
iVar3 = (int)param_1[7];
uVar8 = (ulong)iVar3;
if (0xdf < (long)uVar8) {
piVar1 = *(int **)(*(long *)(*(long *)(*param_1 + 0x18) + 0x68) + uVar8 * 8);
*piVar1 = *piVar1 + 1;
}
iVar4 = next_token(param_1);
if (iVar4 != 0) {
LAB_00156ce0:
JS_FreeAtom(*param_1,uVar8 & 0xffffffff);
goto LAB_00156ceb;
}
uVar5 = *(uint *)(param_1 + 4);
bVar9 = true;
uVar6 = 0;
if (((0x3d < (ulong)uVar5) || ((0x2c00110000000000U >> ((ulong)uVar5 & 0x3f) & 1) == 0)) &&
(uVar5 != 0x7d)) {
JS_FreeAtom(*param_1,iVar3);
uVar6 = iVar3 == 0x43 | 2;
goto LAB_00156c49;
}
LAB_00156e16:
uVar7 = (int4)uVar8;
uVar5 = 0;
if (((param_4 == 0) || (!bVar9)) || (uVar6 != 0)) {
LAB_00156e49:
uVar7 = (int4)uVar8;
if ((1 < uVar6) && ((int)param_1[4] != 0x28)) {
JS_FreeAtom(*param_1,uVar8 & 0xffffffff);
goto LAB_00156e7b;
}
}
else {
uVar6 = (uint)(((int)param_1[4] != 0x28 || param_3 == 0) && (int)param_1[4] != 0x3a);
uVar5 = 0;
}
uVar8 = (ulong)(uVar5 | uVar6);
*param_2 = uVar7;
}
return uVar8;
}
| |
52,963 | testing::UnitTest::test_suite_to_run_count() const | giladroyz[P]FindPeaks/build_O1/_deps/googletest-src/googletest/include/gtest/gtest.h | const internal::UnitTestImpl* impl() const { return impl_; } | O1 | c | testing::UnitTest::test_suite_to_run_count() const:
movq 0x40(%rdi), %rax
movq 0xb8(%rax), %rcx
movq 0xc0(%rax), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x2d454
movq (%rcx), %rsi
movzbl 0x70(%rsi), %esi
addl %esi, %eax
addq $0x8, %rcx
jmp 0x2d440
retq
nop
| _ZNK7testing8UnitTest22test_case_to_run_countEv:
mov rax, [rdi+40h]
mov rcx, [rax+0B8h]
mov rdx, [rax+0C0h]
xor eax, eax
loc_2D440:
cmp rcx, rdx
jz short locret_2D454
mov rsi, [rcx]
movzx esi, byte ptr [rsi+70h]
add eax, esi
add rcx, 8
jmp short loc_2D440
locret_2D454:
retn
| long long testing::UnitTest::test_case_to_run_count(testing::UnitTest *this)
{
long long v1; // rax
long long v2; // rcx
long long v3; // rdx
long long result; // rax
v1 = *((_QWORD *)this + 8);
v2 = *(_QWORD *)(v1 + 184);
v3 = *(_QWORD *)(v1 + 192);
result = 0LL;
while ( v2 != v3 )
{
result = *(unsigned __int8 *)(*(_QWORD *)v2 + 112LL) + (unsigned int)result;
v2 += 8LL;
}
return result;
}
| test_case_to_run_count:
MOV RAX,qword ptr [RDI + 0x40]
MOV RCX,qword ptr [RAX + 0xb8]
MOV RDX,qword ptr [RAX + 0xc0]
XOR EAX,EAX
LAB_0012d440:
CMP RCX,RDX
JZ 0x0012d454
MOV RSI,qword ptr [RCX]
MOVZX ESI,byte ptr [RSI + 0x70]
ADD EAX,ESI
ADD RCX,0x8
JMP 0x0012d440
LAB_0012d454:
RET
|
/* testing::UnitTest::test_case_to_run_count() const */
int __thiscall testing::UnitTest::test_case_to_run_count(UnitTest *this)
{
int iVar1;
long *plVar2;
iVar1 = 0;
for (plVar2 = *(long **)(*(long *)(this + 0x40) + 0xb8);
plVar2 != *(long **)(*(long *)(this + 0x40) + 0xc0); plVar2 = plVar2 + 1) {
iVar1 = iVar1 + (uint)*(byte *)(*plVar2 + 0x70);
}
return iVar1;
}
| |
52,964 | nglog::tools::SafeAppendString(char const*, char*, unsigned long) | ng-log[P]ng-log/src/symbolize.cc | static void SafeAppendString(const char* source, char* dest, size_t dest_size) {
size_t dest_string_length = strlen(dest);
NGLOG_SAFE_ASSERT(dest_string_length < dest_size);
dest += dest_string_length;
dest_size -= dest_string_length;
strncpy(dest, source, dest_size);
// Making sure |dest| is always null-terminated.
dest[dest_size - 1] = '\0';
} | O3 | cpp | nglog::tools::SafeAppendString(char const*, char*, unsigned long):
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x71f0
movq %rbx, %rdx
subq %rax, %rdx
jbe 0x205ac
addq %r14, %rax
movq %rax, %rdi
movq %r15, %rsi
callq 0x7250
movb $0x0, -0x1(%r14,%rbx)
popq %rbx
popq %r14
popq %r15
retq
callq 0x72c0
| _ZN5nglog5toolsL16SafeAppendStringEPKcPcm:
push r15
push r14
push rbx
mov rbx, rdx
mov r14, rsi
mov r15, rdi
mov rdi, rsi
call _strlen
mov rdx, rbx
sub rdx, rax
jbe short loc_205AC
add rax, r14
mov rdi, rax
mov rsi, r15
call _strncpy
mov byte ptr [r14+rbx-1], 0
pop rbx
pop r14
pop r15
retn
loc_205AC:
call _abort
| long long nglog::tools::SafeAppendString(nglog::tools *this, const char *a2, char *a3)
{
unsigned long long v4; // rax
long long result; // rax
v4 = strlen(a2);
if ( (unsigned long long)a3 <= v4 )
abort(a2);
result = strncpy(&a2[v4], this, &a3[-v4]);
a3[(_QWORD)a2 - 1] = 0;
return result;
}
| SafeAppendString:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
MOV RDI,RSI
CALL 0x001071f0
MOV RDX,RBX
SUB RDX,RAX
JBE 0x001205ac
ADD RAX,R14
MOV RDI,RAX
MOV RSI,R15
CALL 0x00107250
MOV byte ptr [R14 + RBX*0x1 + -0x1],0x0
POP RBX
POP R14
POP R15
RET
LAB_001205ac:
CALL 0x001072c0
|
/* nglog::tools::SafeAppendString(char const*, char*, unsigned long) */
void nglog::tools::SafeAppendString(char *param_1,char *param_2,ulong param_3)
{
size_t sVar1;
sVar1 = strlen(param_2);
if (sVar1 <= param_3 && param_3 - sVar1 != 0) {
strncpy(param_2 + sVar1,param_1,param_3 - sVar1);
param_2[param_3 - 1] = '\0';
return;
}
/* WARNING: Subroutine does not return */
abort();
}
| |
52,965 | mthd_my_send_cmd | eloqsql/libmariadb/libmariadb/mariadb_lib.c | int
mthd_my_send_cmd(MYSQL *mysql,enum enum_server_command command, const char *arg,
size_t length, my_bool skip_check, void *opt_arg)
{
NET *net= &mysql->net;
int result= -1;
if (mysql->net.pvio == 0)
{
/* Do reconnect if possible */
if (mariadb_reconnect(mysql))
return(1);
}
if (mysql->status != MYSQL_STATUS_READY ||
mysql->server_status & SERVER_MORE_RESULTS_EXIST)
{
SET_CLIENT_ERROR(mysql, CR_COMMANDS_OUT_OF_SYNC, SQLSTATE_UNKNOWN, 0);
goto end;
}
if (IS_CONNHDLR_ACTIVE(mysql))
{
result= mysql->extension->conn_hdlr->plugin->set_connection(mysql, command, arg, length, skip_check, opt_arg);
if (result== -1)
return(result);
}
CLEAR_CLIENT_ERROR(mysql);
if (command == COM_QUERY ||
command == COM_STMT_PREPARE)
{
if ((mysql->options.client_flag & CLIENT_LOCAL_FILES) &&
mysql->options.extension && mysql->extension->auto_local_infile == WAIT_FOR_QUERY &&
arg && (*arg == 'l' || *arg == 'L'))
{
if (strncasecmp(arg, "load", 4) == 0)
mysql->extension->auto_local_infile= ACCEPT_FILE_REQUEST;
}
}
mysql->info=0;
mysql->affected_rows= ~(unsigned long long) 0;
ma_net_clear(net); /* Clear receive buffer */
if (!arg)
arg="";
if (net->extension->multi_status== COM_MULTI_ENABLED)
{
return net_add_multi_command(net, command, (const uchar *)arg, length);
}
if (ma_net_write_command(net,(uchar) command,arg,
length ? length : (ulong) strlen(arg), 0))
{
if (net->last_errno == ER_NET_PACKET_TOO_LARGE)
{
my_set_error(mysql, CR_NET_PACKET_TOO_LARGE, SQLSTATE_UNKNOWN, 0);
goto end;
}
end_server(mysql);
if (mariadb_reconnect(mysql))
goto end;
if (ma_net_write_command(net,(uchar) command,arg,
length ? length : (ulong) strlen(arg), 0))
{
my_set_error(mysql, CR_SERVER_GONE_ERROR, SQLSTATE_UNKNOWN, 0);
goto end;
}
}
result=0;
if (net->extension->multi_status > COM_MULTI_OFF)
skip_check= 1;
if (!skip_check)
{
result= ((mysql->packet_length=ma_net_safe_read(mysql)) == packet_error ?
1 : 0);
}
end:
return(result);
} | O0 | c | mthd_my_send_cmd:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movb %al, -0x29(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0xffffffff, -0x44(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x30cb8
movq -0x10(%rbp), %rdi
callq 0x31080
cmpb $0x0, %al
je 0x30cb6
movl $0x1, -0x4(%rbp)
jmp 0x31071
jmp 0x30cb8
movq -0x10(%rbp), %rax
cmpl $0x0, 0x488(%rax)
jne 0x30cd7
movq -0x10(%rbp), %rax
movl 0x380(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x30d41
jmp 0x30cd9
movq -0x10(%rbp), %rax
movl $0x7de, 0x90(%rax) # imm = 0x7DE
movq -0x10(%rbp), %rdi
addq $0x297, %rdi # imm = 0x297
leaq 0x501a7(%rip), %rax # 0x80ea0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x14220
movq -0x10(%rbp), %rax
movb $0x0, 0x29c(%rax)
movq -0x10(%rbp), %rdi
addq $0x97, %rdi
leaq 0x5018d(%rip), %rax # 0x80eb0
movq 0x70(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x14220
movq -0x10(%rbp), %rax
movb $0x0, 0x296(%rax)
jmp 0x3106b
movq -0x10(%rbp), %rax
cmpq $0x0, 0x4f0(%rax)
je 0x30da8
movq -0x10(%rbp), %rax
movq 0x4f0(%rax), %rax
cmpq $0x0, (%rax)
je 0x30da8
movq -0x10(%rbp), %rax
movq 0x4f0(%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x70(%rax), %rax
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movb -0x29(%rbp), %r8b
movq -0x38(%rbp), %r9
movsbl %r8b, %r8d
callq *%rax
movl %eax, -0x44(%rbp)
cmpl $-0x1, -0x44(%rbp)
jne 0x30da6
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x31071
jmp 0x30da8
jmp 0x30daa
movq -0x10(%rbp), %rax
movl $0x0, 0x90(%rax)
movq -0x10(%rbp), %rdi
addq $0x297, %rdi # imm = 0x297
leaq 0x39de5(%rip), %rsi # 0x6abaf
callq 0x143d0
movq -0x10(%rbp), %rax
movb $0x0, 0x97(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x2a0(%rax)
je 0x30dfa
movq -0x10(%rbp), %rax
movq 0x2a0(%rax), %rax
movl $0x0, 0x4(%rax)
jmp 0x30dfc
cmpl $0x3, -0x14(%rbp)
je 0x30e0c
cmpl $0x16, -0x14(%rbp)
jne 0x30e91
movq -0x10(%rbp), %rax
movq 0x3a8(%rax), %rax
andq $0x80, %rax
cmpq $0x0, %rax
je 0x30e8f
movq -0x10(%rbp), %rax
cmpq $0x0, 0x480(%rax)
je 0x30e8f
movq -0x10(%rbp), %rax
movq 0x4f0(%rax), %rax
movsbl 0x78(%rax), %eax
cmpl $0x1, %eax
jne 0x30e8f
cmpq $0x0, -0x20(%rbp)
je 0x30e8f
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x6c, %eax
je 0x30e64
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x4c, %eax
jne 0x30e8f
movq -0x20(%rbp), %rdi
leaq 0x39d46(%rip), %rsi # 0x6abb5
movl $0x4, %edx
callq 0x14580
cmpl $0x0, %eax
jne 0x30e8d
movq -0x10(%rbp), %rax
movq 0x4f0(%rax), %rax
movb $0x2, 0x78(%rax)
jmp 0x30e8f
jmp 0x30e91
movq -0x10(%rbp), %rax
movq $0x0, 0x2e0(%rax)
movq -0x10(%rbp), %rax
movq $-0x1, 0x338(%rax)
movq -0x40(%rbp), %rdi
callq 0x602e0
cmpq $0x0, -0x20(%rbp)
jne 0x30eca
leaq 0x354aa(%rip), %rax # 0x66370
movq %rax, -0x20(%rbp)
movq -0x40(%rbp), %rax
movq 0x2a0(%rax), %rax
cmpl $0x2, (%rax)
jne 0x30ef9
movq -0x40(%rbp), %rdi
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movzbl %al, %esi
callq 0x61330
movl %eax, -0x4(%rbp)
jmp 0x31071
movq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0x14(%rbp), %eax
movb %al, -0x51(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x30f20
movq -0x28(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0x30f2d
movq -0x20(%rbp), %rdi
callq 0x141a0
movq %rax, -0x68(%rbp)
movq -0x50(%rbp), %rdx
movb -0x51(%rbp), %al
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rcx
xorl %r8d, %r8d
movzbl %al, %esi
callq 0x60a80
cmpl $0x0, %eax
je 0x3101c
movq -0x40(%rbp), %rax
cmpl $0x481, 0x90(%rax) # imm = 0x481
jne 0x30f83
movq -0x10(%rbp), %rdi
leaq 0x4ff35(%rip), %rax # 0x80ea0
movq (%rax), %rdx
movl $0x7e4, %esi # imm = 0x7E4
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x307d0
jmp 0x3106b
movq -0x10(%rbp), %rdi
callq 0x30780
movq -0x10(%rbp), %rdi
callq 0x31080
cmpb $0x0, %al
je 0x30f9e
jmp 0x3106b
movq -0x40(%rbp), %rax
movq %rax, -0x80(%rbp)
movl -0x14(%rbp), %eax
movb %al, -0x71(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x30fc8
movq -0x28(%rbp), %rax
movq %rax, -0x88(%rbp)
jmp 0x30fd8
movq -0x20(%rbp), %rdi
callq 0x141a0
movq %rax, -0x88(%rbp)
movq -0x70(%rbp), %rdx
movb -0x71(%rbp), %al
movq -0x80(%rbp), %rdi
movq -0x88(%rbp), %rcx
xorl %r8d, %r8d
movzbl %al, %esi
callq 0x60a80
cmpl $0x0, %eax
je 0x3101a
movq -0x10(%rbp), %rdi
leaq 0x4fe9b(%rip), %rax # 0x80ea0
movq (%rax), %rdx
movl $0x7d6, %esi # imm = 0x7D6
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x307d0
jmp 0x3106b
jmp 0x3101c
movl $0x0, -0x44(%rbp)
movq -0x40(%rbp), %rax
movq 0x2a0(%rax), %rax
cmpl $0x0, (%rax)
jbe 0x31037
movb $0x1, -0x29(%rbp)
cmpb $0x0, -0x29(%rbp)
jne 0x31069
movq -0x10(%rbp), %rdi
callq 0x304c0
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq %rdx, 0x358(%rax)
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
xorl %eax, %eax
movl $0x1, %ecx
cmpq %rsi, %rdx
cmovel %ecx, %eax
movl %eax, -0x44(%rbp)
jmp 0x3106b
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
| mthd_my_send_cmd:
push rbp
mov rbp, rsp
sub rsp, 90h
mov al, r8b
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_29], al
mov [rbp+var_38], r9
mov rax, [rbp+var_10]
mov [rbp+var_40], rax
mov [rbp+var_44], 0FFFFFFFFh
mov rax, [rbp+var_10]
cmp qword ptr [rax], 0
jnz short loc_30CB8
mov rdi, [rbp+var_10]
call mariadb_reconnect
cmp al, 0
jz short loc_30CB6
mov [rbp+var_4], 1
jmp loc_31071
loc_30CB6:
jmp short $+2
loc_30CB8:
mov rax, [rbp+var_10]
cmp dword ptr [rax+488h], 0
jnz short loc_30CD7
mov rax, [rbp+var_10]
mov eax, [rax+380h]
and eax, 8
cmp eax, 0
jz short loc_30D41
loc_30CD7:
jmp short $+2
loc_30CD9:
mov rax, [rbp+var_10]
mov dword ptr [rax+90h], 7DEh
mov rdi, [rbp+var_10]
add rdi, 297h
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [rbp+var_10]
mov byte ptr [rax+29Ch], 0
mov rdi, [rbp+var_10]
add rdi, 97h
lea rax, client_errors
mov rsi, [rax+70h]
mov edx, 1FFh
call _strncpy
mov rax, [rbp+var_10]
mov byte ptr [rax+296h], 0
jmp loc_3106B
loc_30D41:
mov rax, [rbp+var_10]
cmp qword ptr [rax+4F0h], 0
jz short loc_30DA8
mov rax, [rbp+var_10]
mov rax, [rax+4F0h]
cmp qword ptr [rax], 0
jz short loc_30DA8
mov rax, [rbp+var_10]
mov rax, [rax+4F0h]
mov rax, [rax]
mov rax, [rax]
mov rax, [rax+70h]
mov rdi, [rbp+var_10]
mov esi, [rbp+var_14]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_28]
mov r8b, [rbp+var_29]
mov r9, [rbp+var_38]
movsx r8d, r8b
call rax
mov [rbp+var_44], eax
cmp [rbp+var_44], 0FFFFFFFFh
jnz short loc_30DA6
mov eax, [rbp+var_44]
mov [rbp+var_4], eax
jmp loc_31071
loc_30DA6:
jmp short $+2
loc_30DA8:
jmp short $+2
loc_30DAA:
mov rax, [rbp+var_10]
mov dword ptr [rax+90h], 0
mov rdi, [rbp+var_10]
add rdi, 297h
lea rsi, a00000; "00000"
call _strcpy
mov rax, [rbp+var_10]
mov byte ptr [rax+97h], 0
mov rax, [rbp+var_10]
cmp qword ptr [rax+2A0h], 0
jz short loc_30DFA
mov rax, [rbp+var_10]
mov rax, [rax+2A0h]
mov dword ptr [rax+4], 0
loc_30DFA:
jmp short $+2
loc_30DFC:
cmp [rbp+var_14], 3
jz short loc_30E0C
cmp [rbp+var_14], 16h
jnz loc_30E91
loc_30E0C:
mov rax, [rbp+var_10]
mov rax, [rax+3A8h]
and rax, 80h
cmp rax, 0
jz short loc_30E8F
mov rax, [rbp+var_10]
cmp qword ptr [rax+480h], 0
jz short loc_30E8F
mov rax, [rbp+var_10]
mov rax, [rax+4F0h]
movsx eax, byte ptr [rax+78h]
cmp eax, 1
jnz short loc_30E8F
cmp [rbp+var_20], 0
jz short loc_30E8F
mov rax, [rbp+var_20]
movsx eax, byte ptr [rax]
cmp eax, 6Ch ; 'l'
jz short loc_30E64
mov rax, [rbp+var_20]
movsx eax, byte ptr [rax]
cmp eax, 4Ch ; 'L'
jnz short loc_30E8F
loc_30E64:
mov rdi, [rbp+var_20]
lea rsi, aLoad; "load"
mov edx, 4
call _strncasecmp
cmp eax, 0
jnz short loc_30E8D
mov rax, [rbp+var_10]
mov rax, [rax+4F0h]
mov byte ptr [rax+78h], 2
loc_30E8D:
jmp short $+2
loc_30E8F:
jmp short $+2
loc_30E91:
mov rax, [rbp+var_10]
mov qword ptr [rax+2E0h], 0
mov rax, [rbp+var_10]
mov qword ptr [rax+338h], 0FFFFFFFFFFFFFFFFh
mov rdi, [rbp+var_40]
call ma_net_clear
cmp [rbp+var_20], 0
jnz short loc_30ECA
lea rax, a12+4; ""
mov [rbp+var_20], rax
loc_30ECA:
mov rax, [rbp+var_40]
mov rax, [rax+2A0h]
cmp dword ptr [rax], 2
jnz short loc_30EF9
mov rdi, [rbp+var_40]
mov eax, [rbp+var_14]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_28]
movzx esi, al
call net_add_multi_command
mov [rbp+var_4], eax
jmp loc_31071
loc_30EF9:
mov rax, [rbp+var_40]
mov [rbp+var_60], rax
mov eax, [rbp+var_14]
mov [rbp+var_51], al
mov rax, [rbp+var_20]
mov [rbp+var_50], rax
cmp [rbp+var_28], 0
jz short loc_30F20
mov rax, [rbp+var_28]
mov [rbp+var_68], rax
jmp short loc_30F2D
loc_30F20:
mov rdi, [rbp+var_20]
call _strlen
mov [rbp+var_68], rax
loc_30F2D:
mov rdx, [rbp+var_50]
mov al, [rbp+var_51]
mov rdi, [rbp+var_60]
mov rcx, [rbp+var_68]
xor r8d, r8d
movzx esi, al
call ma_net_write_command
cmp eax, 0
jz loc_3101C
mov rax, [rbp+var_40]
cmp dword ptr [rax+90h], 481h
jnz short loc_30F83
mov rdi, [rbp+var_10]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
mov esi, 7E4h
xor eax, eax
mov ecx, eax
mov al, 0
call my_set_error
jmp loc_3106B
loc_30F83:
mov rdi, [rbp+var_10]
call end_server
mov rdi, [rbp+var_10]
call mariadb_reconnect
cmp al, 0
jz short loc_30F9E
jmp loc_3106B
loc_30F9E:
mov rax, [rbp+var_40]
mov [rbp+var_80], rax
mov eax, [rbp+var_14]
mov [rbp+var_71], al
mov rax, [rbp+var_20]
mov [rbp+var_70], rax
cmp [rbp+var_28], 0
jz short loc_30FC8
mov rax, [rbp+var_28]
mov [rbp+var_88], rax
jmp short loc_30FD8
loc_30FC8:
mov rdi, [rbp+var_20]
call _strlen
mov [rbp+var_88], rax
loc_30FD8:
mov rdx, [rbp+var_70]
mov al, [rbp+var_71]
mov rdi, [rbp+var_80]
mov rcx, [rbp+var_88]
xor r8d, r8d
movzx esi, al
call ma_net_write_command
cmp eax, 0
jz short loc_3101A
mov rdi, [rbp+var_10]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
mov esi, 7D6h
xor eax, eax
mov ecx, eax
mov al, 0
call my_set_error
jmp short loc_3106B
loc_3101A:
jmp short $+2
loc_3101C:
mov [rbp+var_44], 0
mov rax, [rbp+var_40]
mov rax, [rax+2A0h]
cmp dword ptr [rax], 0
jbe short loc_31037
mov [rbp+var_29], 1
loc_31037:
cmp [rbp+var_29], 0
jnz short loc_31069
mov rdi, [rbp+var_10]
call ma_net_safe_read
mov rdx, rax
mov rax, [rbp+var_10]
mov [rax+358h], rdx
mov esi, 0FFFFFFFFh
xor eax, eax
mov ecx, 1
cmp rdx, rsi
cmovz eax, ecx
mov [rbp+var_44], eax
loc_31069:
jmp short $+2
loc_3106B:
mov eax, [rbp+var_44]
mov [rbp+var_4], eax
loc_31071:
mov eax, [rbp+var_4]
add rsp, 90h
pop rbp
retn
| long long mthd_my_send_cmd(long long a1, long long a2, char *a3, long long a4, char a5, long long a6)
{
long long v6; // rdx
long long v7; // rcx
int v8; // r8d
int v9; // r9d
long long v10; // rdx
long long v12; // [rsp+8h] [rbp-88h]
long long v13; // [rsp+28h] [rbp-68h]
unsigned int v14; // [rsp+4Ch] [rbp-44h]
v14 = -1;
if ( *(_QWORD *)a1 || !(unsigned __int8)mariadb_reconnect(a1) )
{
if ( *(_DWORD *)(a1 + 1160) || (*(_DWORD *)(a1 + 896) & 8) != 0 )
{
*(_DWORD *)(a1 + 144) = 2014;
strncpy(a1 + 663, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 668) = 0;
strncpy(a1 + 151, client_errors[14], 511LL);
*(_BYTE *)(a1 + 662) = 0;
return v14;
}
if ( *(_QWORD *)(a1 + 1264) )
{
if ( **(_QWORD **)(a1 + 1264) )
{
v14 = (*(long long ( **)(long long, _QWORD, char *, long long, _QWORD, long long))(***(_QWORD ***)(a1 + 1264)
+ 112LL))(
a1,
(unsigned int)a2,
a3,
a4,
(unsigned int)a5,
a6);
if ( v14 == -1 )
return (unsigned int)-1;
}
}
*(_DWORD *)(a1 + 144) = 0;
strcpy(a1 + 663, "00000");
*(_BYTE *)(a1 + 151) = 0;
if ( *(_QWORD *)(a1 + 672) )
*(_DWORD *)(*(_QWORD *)(a1 + 672) + 4LL) = 0;
if ( ((_DWORD)a2 == 3 || (_DWORD)a2 == 22)
&& (*(_QWORD *)(a1 + 936) & 0x80LL) != 0
&& *(_QWORD *)(a1 + 1152)
&& *(_BYTE *)(*(_QWORD *)(a1 + 1264) + 120LL) == 1
&& a3
&& (*a3 == 108 || *a3 == 76)
&& !(unsigned int)strncasecmp(a3, "load", 4LL) )
{
*(_BYTE *)(*(_QWORD *)(a1 + 1264) + 120LL) = 2;
}
*(_QWORD *)(a1 + 736) = 0LL;
*(_QWORD *)(a1 + 824) = -1LL;
ma_net_clear(a1);
if ( !a3 )
a3 = "";
if ( **(_DWORD **)(a1 + 672) == 2 )
return (unsigned int)net_add_multi_command(a1, (unsigned __int8)a2, a3, a4);
if ( a4 )
v13 = a4;
else
v13 = strlen(a3);
a2 = (unsigned __int8)a2;
if ( (unsigned int)ma_net_write_command(a1, (unsigned __int8)a2, a3, v13, 0LL) )
{
if ( *(_DWORD *)(a1 + 144) == 1153 )
{
my_set_error(a1, 0x7E4u, (long long)SQLSTATE_UNKNOWN, 0LL);
return v14;
}
end_server((_QWORD *)a1);
if ( (unsigned __int8)mariadb_reconnect(a1) )
return v14;
if ( a4 )
v12 = a4;
else
v12 = strlen(a3);
a2 = (unsigned __int8)a2;
if ( (unsigned int)ma_net_write_command(a1, (unsigned __int8)a2, a3, v12, 0LL) )
{
my_set_error(a1, 0x7D6u, (long long)SQLSTATE_UNKNOWN, 0LL);
return v14;
}
}
v14 = 0;
if ( **(_DWORD **)(a1 + 672) )
a5 = 1;
if ( !a5 )
{
v10 = ma_net_safe_read(a1, a2, v6, v7, v8, v9);
*(_QWORD *)(a1 + 856) = v10;
return v10 == 0xFFFFFFFFLL;
}
return v14;
}
return 1;
}
| mthd_my_send_cmd:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV AL,R8B
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV byte ptr [RBP + -0x29],AL
MOV qword ptr [RBP + -0x38],R9
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x40],RAX
MOV dword ptr [RBP + -0x44],0xffffffff
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX],0x0
JNZ 0x00130cb8
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00131080
CMP AL,0x0
JZ 0x00130cb6
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00131071
LAB_00130cb6:
JMP 0x00130cb8
LAB_00130cb8:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x488],0x0
JNZ 0x00130cd7
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x380]
AND EAX,0x8
CMP EAX,0x0
JZ 0x00130d41
LAB_00130cd7:
JMP 0x00130cd9
LAB_00130cd9:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x90],0x7de
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x297
LEA RAX,[0x180ea0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00114220
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x29c],0x0
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x97
LEA RAX,[0x180eb0]
MOV RSI,qword ptr [RAX + 0x70]
MOV EDX,0x1ff
CALL 0x00114220
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x296],0x0
JMP 0x0013106b
LAB_00130d41:
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x4f0],0x0
JZ 0x00130da8
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x4f0]
CMP qword ptr [RAX],0x0
JZ 0x00130da8
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x4f0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x70]
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x14]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x28]
MOV R8B,byte ptr [RBP + -0x29]
MOV R9,qword ptr [RBP + -0x38]
MOVSX R8D,R8B
CALL RAX
MOV dword ptr [RBP + -0x44],EAX
CMP dword ptr [RBP + -0x44],-0x1
JNZ 0x00130da6
MOV EAX,dword ptr [RBP + -0x44]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00131071
LAB_00130da6:
JMP 0x00130da8
LAB_00130da8:
JMP 0x00130daa
LAB_00130daa:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x90],0x0
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x297
LEA RSI,[0x16abaf]
CALL 0x001143d0
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x97],0x0
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x2a0],0x0
JZ 0x00130dfa
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x2a0]
MOV dword ptr [RAX + 0x4],0x0
LAB_00130dfa:
JMP 0x00130dfc
LAB_00130dfc:
CMP dword ptr [RBP + -0x14],0x3
JZ 0x00130e0c
CMP dword ptr [RBP + -0x14],0x16
JNZ 0x00130e91
LAB_00130e0c:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x3a8]
AND RAX,0x80
CMP RAX,0x0
JZ 0x00130e8f
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x480],0x0
JZ 0x00130e8f
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x4f0]
MOVSX EAX,byte ptr [RAX + 0x78]
CMP EAX,0x1
JNZ 0x00130e8f
CMP qword ptr [RBP + -0x20],0x0
JZ 0x00130e8f
MOV RAX,qword ptr [RBP + -0x20]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x6c
JZ 0x00130e64
MOV RAX,qword ptr [RBP + -0x20]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x4c
JNZ 0x00130e8f
LAB_00130e64:
MOV RDI,qword ptr [RBP + -0x20]
LEA RSI,[0x16abb5]
MOV EDX,0x4
CALL 0x00114580
CMP EAX,0x0
JNZ 0x00130e8d
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x4f0]
MOV byte ptr [RAX + 0x78],0x2
LAB_00130e8d:
JMP 0x00130e8f
LAB_00130e8f:
JMP 0x00130e91
LAB_00130e91:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x2e0],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x338],-0x1
MOV RDI,qword ptr [RBP + -0x40]
CALL 0x001602e0
CMP qword ptr [RBP + -0x20],0x0
JNZ 0x00130eca
LEA RAX,[0x166370]
MOV qword ptr [RBP + -0x20],RAX
LAB_00130eca:
MOV RAX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RAX + 0x2a0]
CMP dword ptr [RAX],0x2
JNZ 0x00130ef9
MOV RDI,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RBP + -0x14]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x28]
MOVZX ESI,AL
CALL 0x00161330
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00131071
LAB_00130ef9:
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x60],RAX
MOV EAX,dword ptr [RBP + -0x14]
MOV byte ptr [RBP + -0x51],AL
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x50],RAX
CMP qword ptr [RBP + -0x28],0x0
JZ 0x00130f20
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x68],RAX
JMP 0x00130f2d
LAB_00130f20:
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x001141a0
MOV qword ptr [RBP + -0x68],RAX
LAB_00130f2d:
MOV RDX,qword ptr [RBP + -0x50]
MOV AL,byte ptr [RBP + -0x51]
MOV RDI,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x68]
XOR R8D,R8D
MOVZX ESI,AL
CALL 0x00160a80
CMP EAX,0x0
JZ 0x0013101c
MOV RAX,qword ptr [RBP + -0x40]
CMP dword ptr [RAX + 0x90],0x481
JNZ 0x00130f83
MOV RDI,qword ptr [RBP + -0x10]
LEA RAX,[0x180ea0]
MOV RDX,qword ptr [RAX]
MOV ESI,0x7e4
XOR EAX,EAX
MOV ECX,EAX
MOV AL,0x0
CALL 0x001307d0
JMP 0x0013106b
LAB_00130f83:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00130780
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00131080
CMP AL,0x0
JZ 0x00130f9e
JMP 0x0013106b
LAB_00130f9e:
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x80],RAX
MOV EAX,dword ptr [RBP + -0x14]
MOV byte ptr [RBP + -0x71],AL
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x70],RAX
CMP qword ptr [RBP + -0x28],0x0
JZ 0x00130fc8
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x88],RAX
JMP 0x00130fd8
LAB_00130fc8:
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x001141a0
MOV qword ptr [RBP + -0x88],RAX
LAB_00130fd8:
MOV RDX,qword ptr [RBP + -0x70]
MOV AL,byte ptr [RBP + -0x71]
MOV RDI,qword ptr [RBP + -0x80]
MOV RCX,qword ptr [RBP + -0x88]
XOR R8D,R8D
MOVZX ESI,AL
CALL 0x00160a80
CMP EAX,0x0
JZ 0x0013101a
MOV RDI,qword ptr [RBP + -0x10]
LEA RAX,[0x180ea0]
MOV RDX,qword ptr [RAX]
MOV ESI,0x7d6
XOR EAX,EAX
MOV ECX,EAX
MOV AL,0x0
CALL 0x001307d0
JMP 0x0013106b
LAB_0013101a:
JMP 0x0013101c
LAB_0013101c:
MOV dword ptr [RBP + -0x44],0x0
MOV RAX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RAX + 0x2a0]
CMP dword ptr [RAX],0x0
JBE 0x00131037
MOV byte ptr [RBP + -0x29],0x1
LAB_00131037:
CMP byte ptr [RBP + -0x29],0x0
JNZ 0x00131069
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001304c0
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x358],RDX
MOV ESI,0xffffffff
XOR EAX,EAX
MOV ECX,0x1
CMP RDX,RSI
CMOVZ EAX,ECX
MOV dword ptr [RBP + -0x44],EAX
LAB_00131069:
JMP 0x0013106b
LAB_0013106b:
MOV EAX,dword ptr [RBP + -0x44]
MOV dword ptr [RBP + -0x4],EAX
LAB_00131071:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x90
POP RBP
RET
|
uint mthd_my_send_cmd(long *param_1,uint param_2,char *param_3,size_t param_4,char param_5,
int8 param_6)
{
char cVar1;
int iVar2;
uint uVar3;
long lVar4;
size_t local_90;
size_t local_70;
uint local_4c;
char local_31;
char *local_28;
local_4c = 0xffffffff;
if ((*param_1 == 0) && (cVar1 = mariadb_reconnect(param_1), cVar1 != '\0')) {
return 1;
}
if (((int)param_1[0x91] != 0) || ((*(uint *)(param_1 + 0x70) & 8) != 0)) {
*(int4 *)(param_1 + 0x12) = 0x7de;
strncpy((char *)((long)param_1 + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)((long)param_1 + 0x29c) = 0;
strncpy((char *)((long)param_1 + 0x97),PTR_s_Commands_out_of_sync__you_can_t_r_00180f20,0x1ff);
*(int1 *)((long)param_1 + 0x296) = 0;
return 0xffffffff;
}
if (((param_1[0x9e] != 0) && (*(long *)param_1[0x9e] != 0)) &&
(local_4c = (**(code **)(**(long **)param_1[0x9e] + 0x70))
(param_1,param_2,param_3,param_4,(int)param_5,param_6),
local_4c == 0xffffffff)) {
return 0xffffffff;
}
*(int4 *)(param_1 + 0x12) = 0;
strcpy((char *)((long)param_1 + 0x297),"00000");
*(int1 *)((long)param_1 + 0x97) = 0;
if (param_1[0x54] != 0) {
*(int4 *)(param_1[0x54] + 4) = 0;
}
if (((((param_2 == 3) || (param_2 == 0x16)) &&
(((param_1[0x75] & 0x80U) != 0 &&
((param_1[0x90] != 0 && (*(char *)(param_1[0x9e] + 0x78) == '\x01')))))) &&
(param_3 != (char *)0x0)) &&
(((*param_3 == 'l' || (*param_3 == 'L')) && (iVar2 = strncasecmp(param_3,"load",4), iVar2 == 0)
))) {
*(int1 *)(param_1[0x9e] + 0x78) = 2;
}
param_1[0x5c] = 0;
param_1[0x67] = -1;
ma_net_clear(param_1);
local_28 = param_3;
if (param_3 == (char *)0x0) {
local_28 = "";
}
if (*(int *)param_1[0x54] != 2) {
local_70 = param_4;
if (param_4 == 0) {
local_70 = strlen(local_28);
}
iVar2 = ma_net_write_command(param_1,(char)param_2,local_28,local_70,0);
if (iVar2 != 0) {
if ((int)param_1[0x12] == 0x481) {
my_set_error(param_1,0x7e4,SQLSTATE_UNKNOWN,0);
return local_4c;
}
end_server(param_1);
cVar1 = mariadb_reconnect(param_1);
if (cVar1 != '\0') {
return local_4c;
}
local_90 = param_4;
if (param_4 == 0) {
local_90 = strlen(local_28);
}
iVar2 = ma_net_write_command(param_1,(char)param_2,local_28,local_90,0);
if (iVar2 != 0) {
my_set_error(param_1,0x7d6,SQLSTATE_UNKNOWN,0);
return local_4c;
}
}
local_4c = 0;
local_31 = param_5;
if (*(int *)param_1[0x54] != 0) {
local_31 = '\x01';
}
if (local_31 == '\0') {
lVar4 = ma_net_safe_read(param_1);
param_1[0x6b] = lVar4;
local_4c = (uint)(lVar4 == 0xffffffff);
}
return local_4c;
}
uVar3 = net_add_multi_command(param_1,param_2 & 0xff,local_28,param_4);
return uVar3;
}
| |
52,966 | psi_rwlock_wrlock | eloqsql/mysys/my_thr_init.c | ATTRIBUTE_COLD
int psi_rwlock_wrlock(mysql_rwlock_t *that, const char *file, uint line)
{
PSI_rwlock_locker_state state;
PSI_rwlock_locker *locker= PSI_RWLOCK_CALL(start_rwlock_wrwait)
(&state, that->m_psi, PSI_RWLOCK_WRITELOCK, file, line);
int result= rw_wrlock(&that->m_rwlock);
if (locker)
PSI_RWLOCK_CALL(end_rwlock_wrwait)(locker, result);
return result;
} | O0 | c | psi_rwlock_wrlock:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq 0x1b59fe(%rip), %rax # 0x235ca8
movq (%rax), %rax
movq 0x1b0(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x90(%rcx), %rsi
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %r8d
leaq -0x48(%rbp), %rdi
movl $0x1, %edx
callq *%rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0x80810
movl %eax, -0x54(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0x80303
leaq 0x1b59b8(%rip), %rax # 0x235ca8
movq (%rax), %rax
movq 0x1b8(%rax), %rax
movq -0x50(%rbp), %rdi
movl -0x54(%rbp), %esi
callq *%rax
movl -0x54(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
| psi_rwlock_wrlock:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1B0h]
mov rcx, [rbp+var_8]
mov rsi, [rcx+90h]
mov rcx, [rbp+var_10]
mov r8d, [rbp+var_14]
lea rdi, [rbp+var_48]
mov edx, 1
call rax
mov [rbp+var_50], rax
mov rdi, [rbp+var_8]
call my_rw_wrlock
mov [rbp+var_54], eax
cmp [rbp+var_50], 0
jz short loc_80303
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1B8h]
mov rdi, [rbp+var_50]
mov esi, [rbp+var_54]
call rax
loc_80303:
mov eax, [rbp+var_54]
add rsp, 60h
pop rbp
retn
| long long psi_rwlock_wrlock(long long a1, long long a2, unsigned int a3)
{
unsigned int v4; // [rsp+Ch] [rbp-54h]
long long v5; // [rsp+10h] [rbp-50h]
_BYTE v6[52]; // [rsp+18h] [rbp-48h] BYREF
unsigned int v7; // [rsp+4Ch] [rbp-14h]
long long v8; // [rsp+50h] [rbp-10h]
long long v9; // [rsp+58h] [rbp-8h]
v9 = a1;
v8 = a2;
v7 = a3;
v5 = (*((long long ( **)(_BYTE *, _QWORD, long long, long long, _QWORD))PSI_server + 54))(
v6,
*(_QWORD *)(a1 + 144),
1LL,
a2,
a3);
v4 = my_rw_wrlock(v9);
if ( v5 )
(*((void ( **)(long long, _QWORD))PSI_server + 55))(v5, v4);
return v4;
}
| psi_rwlock_wrlock:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
LEA RAX,[0x335ca8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1b0]
MOV RCX,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RCX + 0x90]
MOV RCX,qword ptr [RBP + -0x10]
MOV R8D,dword ptr [RBP + -0x14]
LEA RDI,[RBP + -0x48]
MOV EDX,0x1
CALL RAX
MOV qword ptr [RBP + -0x50],RAX
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00180810
MOV dword ptr [RBP + -0x54],EAX
CMP qword ptr [RBP + -0x50],0x0
JZ 0x00180303
LEA RAX,[0x335ca8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1b8]
MOV RDI,qword ptr [RBP + -0x50]
MOV ESI,dword ptr [RBP + -0x54]
CALL RAX
LAB_00180303:
MOV EAX,dword ptr [RBP + -0x54]
ADD RSP,0x60
POP RBP
RET
|
int4 psi_rwlock_wrlock(long param_1,int8 param_2,int4 param_3)
{
int4 uVar1;
long lVar2;
int1 local_50 [52];
int4 local_1c;
int8 local_18;
long local_10;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
lVar2 = (**(code **)(PSI_server + 0x1b0))
(local_50,*(int8 *)(param_1 + 0x90),1,param_2,param_3);
uVar1 = my_rw_wrlock(local_10);
if (lVar2 != 0) {
(**(code **)(PSI_server + 0x1b8))(lVar2,uVar1);
}
return uVar1;
}
| |
52,967 | pfs_get_thread_file_descriptor_locker_v1 | eloqsql/storage/perfschema/pfs.cc | PSI_file_locker*
pfs_get_thread_file_descriptor_locker_v1(PSI_file_locker_state *state,
File file, PSI_file_operation op)
{
int index= static_cast<int> (file);
assert(static_cast<int> (op) >= 0);
assert(static_cast<uint> (op) < array_elements(file_operation_map));
assert(state != NULL);
if (unlikely((index < 0) || (index >= file_handle_max)))
return NULL;
PFS_file *pfs_file= file_handle_array[index];
if (unlikely(pfs_file == NULL))
return NULL;
/*
We are about to close a file by descriptor number,
and the calling code still holds the descriptor.
Cleanup the file descriptor <--> file instrument association.
Remove the instrumentation *before* the close to avoid race
conditions with another thread opening a file
(that could be given the same descriptor).
*/
if (op == PSI_FILE_CLOSE)
file_handle_array[index]= NULL;
if (! pfs_file->m_enabled)
return NULL;
assert(pfs_file->m_class != NULL);
PFS_file_class *klass= pfs_file->m_class;
/* Needed for the LF_HASH */
PFS_thread *pfs_thread= my_thread_get_THR_PFS();
if (unlikely(pfs_thread == NULL))
return NULL;
uint flags;
/* Always populated */
state->m_thread= reinterpret_cast<PSI_thread *> (pfs_thread);
if (flag_thread_instrumentation)
{
if (! pfs_thread->m_enabled)
return NULL;
flags= STATE_FLAG_THREAD;
if (pfs_file->m_timed)
flags|= STATE_FLAG_TIMED;
if (flag_events_waits_current)
{
if (unlikely(pfs_thread->m_events_waits_current >=
& pfs_thread->m_events_waits_stack[WAIT_STACK_SIZE]))
{
locker_lost++;
return NULL;
}
PFS_events_waits *wait= pfs_thread->m_events_waits_current;
state->m_wait= wait;
flags|= STATE_FLAG_EVENT;
PFS_events_waits *parent_event= wait - 1;
wait->m_event_type= EVENT_TYPE_WAIT;
wait->m_nesting_event_id= parent_event->m_event_id;
wait->m_nesting_event_type= parent_event->m_event_type;
wait->m_thread_internal_id= pfs_thread->m_thread_internal_id;
wait->m_class= klass;
wait->m_timer_start= 0;
wait->m_timer_end= 0;
wait->m_object_instance_addr= pfs_file;
wait->m_weak_file= pfs_file;
wait->m_weak_version= pfs_file->get_version();
wait->m_event_id= pfs_thread->m_event_id++;
wait->m_end_event_id= 0;
wait->m_operation= file_operation_map[static_cast<int> (op)];
wait->m_wait_class= WAIT_CLASS_FILE;
pfs_thread->m_events_waits_current++;
}
}
else
{
if (pfs_file->m_timed)
{
flags= STATE_FLAG_TIMED;
}
else
{
/* TODO: consider a shortcut. */
flags= 0;
}
}
state->m_flags= flags;
state->m_file= reinterpret_cast<PSI_file*> (pfs_file);
state->m_operation= op;
state->m_name= NULL;
state->m_class= klass;
return reinterpret_cast<PSI_file_locker*> (state);
} | O0 | cpp | pfs_get_thread_file_descriptor_locker_v1:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movb $0x1, %al
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x51(%rbp)
jl 0x4b677
movslq -0x1c(%rbp), %rax
leaq 0x3c2412(%rip), %rcx # 0x40da80
cmpq (%rcx), %rax
setge %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x4b691
movq $0x0, -0x8(%rbp)
jmp 0x4b969
leaq 0x3c2458(%rip), %rax # 0x40daf0
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x4b6c6
movq $0x0, -0x8(%rbp)
jmp 0x4b969
cmpl $0x4, -0x18(%rbp)
jne 0x4b6e2
leaq 0x3c241d(%rip), %rax # 0x40daf0
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
testb $0x1, 0x4(%rax)
jne 0x4b6f9
movq $0x0, -0x8(%rbp)
jmp 0x4b969
movq -0x28(%rbp), %rax
movq 0x220(%rax), %rax
movq %rax, -0x30(%rbp)
callq 0x48dd0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x4b730
movq $0x0, -0x8(%rbp)
jmp 0x4b969
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
leaq 0x3c587d(%rip), %rax # 0x410fc0
testb $0x1, (%rax)
je 0x4b90e
movq -0x38(%rbp), %rax
testb $0x1, 0x7e0(%rax)
jne 0x4b766
movq $0x0, -0x8(%rbp)
jmp 0x4b969
movl $0x2, -0x3c(%rbp)
movq -0x28(%rbp), %rax
testb $0x1, 0x5(%rax)
je 0x4b780
movl -0x3c(%rbp), %eax
orl $0x1, %eax
movl %eax, -0x3c(%rbp)
leaq 0x3c5739(%rip), %rax # 0x410ec0
testb $0x1, (%rax)
je 0x4b90c
movq -0x38(%rbp), %rax
movq 0x7f0(%rax), %rax
movq -0x38(%rbp), %rcx
addq $0x878, %rcx # imm = 0x878
addq $0x420, %rcx # imm = 0x420
cmpq %rcx, %rax
setae %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x4b7e2
leaq 0x3c2304(%rip), %rax # 0x40dac8
movq (%rax), %rcx
addq $0x1, %rcx
leaq 0x3c22f6(%rip), %rax # 0x40dac8
movq %rcx, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x4b969
movq -0x38(%rbp), %rax
movq 0x7f0(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movl -0x3c(%rbp), %eax
orl $0x4, %eax
movl %eax, -0x3c(%rbp)
movq -0x48(%rbp), %rax
addq $-0xb0, %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rax
movl $0x4, 0x18(%rax)
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x50(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x48(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x38(%rbp), %rax
movq 0x850(%rax), %rcx
movq -0x48(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x48(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x48(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x28(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x28(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x28(%rbp), %rdi
callq 0x51af0
movl %eax, %ecx
movq -0x48(%rbp), %rax
movl %ecx, 0x80(%rax)
movq -0x38(%rbp), %rax
movq 0x7f8(%rax), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, 0x7f8(%rax)
movq -0x48(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x48(%rbp), %rax
movq $0x0, 0x10(%rax)
movslq -0x18(%rbp), %rcx
leaq 0x1cab65(%rip), %rax # 0x216440
movl (%rax,%rcx,4), %ecx
movq -0x48(%rbp), %rax
movl %ecx, 0x90(%rax)
movq -0x48(%rbp), %rax
movl $0x5, 0x58(%rax)
movq -0x38(%rbp), %rax
movq 0x7f0(%rax), %rcx
addq $0xb0, %rcx
movq %rcx, 0x7f0(%rax)
jmp 0x4b92a
movq -0x28(%rbp), %rax
testb $0x1, 0x5(%rax)
je 0x4b921
movl $0x1, -0x3c(%rbp)
jmp 0x4b928
movl $0x0, -0x3c(%rbp)
jmp 0x4b92a
movl -0x3c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| pfs_get_thread_file_descriptor_locker_v1:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov eax, [rbp+var_14]
mov [rbp+var_1C], eax
mov al, 1
cmp [rbp+var_1C], 0
mov [rbp+var_51], al
jl short loc_4B677
movsxd rax, [rbp+var_1C]
lea rcx, file_handle_max
cmp rax, [rcx]
setnl al
mov [rbp+var_51], al
loc_4B677:
mov al, [rbp+var_51]
and al, 1
movzx eax, al
cmp eax, 0
jz short loc_4B691
mov [rbp+var_8], 0
jmp loc_4B969
loc_4B691:
lea rax, file_handle_array
mov rax, [rax]
movsxd rcx, [rbp+var_1C]
mov rax, [rax+rcx*8]
mov [rbp+var_28], rax
cmp [rbp+var_28], 0
setz al
and al, 1
movzx eax, al
cmp eax, 0
jz short loc_4B6C6
mov [rbp+var_8], 0
jmp loc_4B969
loc_4B6C6:
cmp [rbp+var_18], 4
jnz short loc_4B6E2
lea rax, file_handle_array
mov rax, [rax]
movsxd rcx, [rbp+var_1C]
mov qword ptr [rax+rcx*8], 0
loc_4B6E2:
mov rax, [rbp+var_28]
test byte ptr [rax+4], 1
jnz short loc_4B6F9
mov [rbp+var_8], 0
jmp loc_4B969
loc_4B6F9:
mov rax, [rbp+var_28]
mov rax, [rax+220h]
mov [rbp+var_30], rax
call _ZL21my_thread_get_THR_PFSv; my_thread_get_THR_PFS(void)
mov [rbp+var_38], rax
cmp [rbp+var_38], 0
setz al
and al, 1
movzx eax, al
cmp eax, 0
jz short loc_4B730
mov [rbp+var_8], 0
jmp loc_4B969
loc_4B730:
mov rcx, [rbp+var_38]
mov rax, [rbp+var_10]
mov [rax+20h], rcx
lea rax, flag_thread_instrumentation
test byte ptr [rax], 1
jz loc_4B90E
mov rax, [rbp+var_38]
test byte ptr [rax+7E0h], 1
jnz short loc_4B766
mov [rbp+var_8], 0
jmp loc_4B969
loc_4B766:
mov [rbp+var_3C], 2
mov rax, [rbp+var_28]
test byte ptr [rax+5], 1
jz short loc_4B780
mov eax, [rbp+var_3C]
or eax, 1
mov [rbp+var_3C], eax
loc_4B780:
lea rax, flag_events_waits_current
test byte ptr [rax], 1
jz loc_4B90C
mov rax, [rbp+var_38]
mov rax, [rax+7F0h]
mov rcx, [rbp+var_38]
add rcx, 878h
add rcx, 420h
cmp rax, rcx
setnb al
and al, 1
movzx eax, al
cmp eax, 0
jz short loc_4B7E2
lea rax, locker_lost
mov rcx, [rax]
add rcx, 1
lea rax, locker_lost
mov [rax], rcx
mov [rbp+var_8], 0
jmp loc_4B969
loc_4B7E2:
mov rax, [rbp+var_38]
mov rax, [rax+7F0h]
mov [rbp+var_48], rax
mov rcx, [rbp+var_48]
mov rax, [rbp+var_10]
mov [rax+40h], rcx
mov eax, [rbp+var_3C]
or eax, 4
mov [rbp+var_3C], eax
mov rax, [rbp+var_48]
add rax, 0FFFFFFFFFFFFFF50h
mov [rbp+var_50], rax
mov rax, [rbp+var_48]
mov dword ptr [rax+18h], 4
mov rax, [rbp+var_50]
mov rcx, [rax+8]
mov rax, [rbp+var_48]
mov [rax+20h], rcx
mov rax, [rbp+var_50]
mov ecx, [rax+18h]
mov rax, [rbp+var_48]
mov [rax+28h], ecx
mov rax, [rbp+var_38]
mov rcx, [rax+850h]
mov rax, [rbp+var_48]
mov [rax], rcx
mov rcx, [rbp+var_30]
mov rax, [rbp+var_48]
mov [rax+30h], rcx
mov rax, [rbp+var_48]
mov qword ptr [rax+38h], 0
mov rax, [rbp+var_48]
mov qword ptr [rax+40h], 0
mov rcx, [rbp+var_28]
mov rax, [rbp+var_48]
mov [rax+88h], rcx
mov rcx, [rbp+var_28]
mov rax, [rbp+var_48]
mov [rax+68h], rcx
mov rdi, [rbp+var_28]; this
call _ZN8PFS_file11get_versionEv; PFS_file::get_version(void)
mov ecx, eax
mov rax, [rbp+var_48]
mov [rax+80h], ecx
mov rax, [rbp+var_38]
mov rcx, [rax+7F8h]
mov rdx, rcx
add rdx, 1
mov [rax+7F8h], rdx
mov rax, [rbp+var_48]
mov [rax+8], rcx
mov rax, [rbp+var_48]
mov qword ptr [rax+10h], 0
movsxd rcx, [rbp+var_18]
lea rax, _ZL18file_operation_map; file_operation_map
mov ecx, [rax+rcx*4]
mov rax, [rbp+var_48]
mov [rax+90h], ecx
mov rax, [rbp+var_48]
mov dword ptr [rax+58h], 5
mov rax, [rbp+var_38]
mov rcx, [rax+7F0h]
add rcx, 0B0h
mov [rax+7F0h], rcx
loc_4B90C:
jmp short loc_4B92A
loc_4B90E:
mov rax, [rbp+var_28]
test byte ptr [rax+5], 1
jz short loc_4B921
mov [rbp+var_3C], 1
jmp short loc_4B928
loc_4B921:
mov [rbp+var_3C], 0
loc_4B928:
jmp short $+2
loc_4B92A:
mov ecx, [rbp+var_3C]
mov rax, [rbp+var_10]
mov [rax], ecx
mov rcx, [rbp+var_28]
mov rax, [rbp+var_10]
mov [rax+8], rcx
mov ecx, [rbp+var_18]
mov rax, [rbp+var_10]
mov [rax+4], ecx
mov rax, [rbp+var_10]
mov qword ptr [rax+10h], 0
mov rcx, [rbp+var_30]
mov rax, [rbp+var_10]
mov [rax+18h], rcx
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
loc_4B969:
mov rax, [rbp+var_8]
add rsp, 60h
pop rbp
retn
| long long pfs_get_thread_file_descriptor_locker_v1(long long a1, int a2, int a3)
{
long long v3; // rcx
bool v5; // [rsp+Fh] [rbp-51h]
long long v6; // [rsp+18h] [rbp-48h]
int v7; // [rsp+24h] [rbp-3Ch]
long long THR_PFS; // [rsp+28h] [rbp-38h]
long long v9; // [rsp+30h] [rbp-30h]
PFS_file *v10; // [rsp+38h] [rbp-28h]
v5 = 1;
if ( a2 >= 0 )
v5 = a2 >= (long long)file_handle_max;
if ( v5 )
return 0LL;
v10 = (PFS_file *)*((_QWORD *)file_handle_array + a2);
if ( !v10 )
return 0LL;
if ( a3 == 4 )
*((_QWORD *)file_handle_array + a2) = 0LL;
if ( (*((_BYTE *)v10 + 4) & 1) == 0 )
return 0LL;
v9 = *((_QWORD *)v10 + 68);
THR_PFS = my_thread_get_THR_PFS();
if ( THR_PFS )
{
*(_QWORD *)(a1 + 32) = THR_PFS;
if ( (flag_thread_instrumentation & 1) != 0 )
{
if ( (*(_BYTE *)(THR_PFS + 2016) & 1) == 0 )
return 0LL;
v7 = 2;
if ( (*((_BYTE *)v10 + 5) & 1) != 0 )
v7 = 3;
if ( (flag_events_waits_current & 1) != 0 )
{
if ( *(_QWORD *)(THR_PFS + 2032) >= (unsigned long long)(THR_PFS + 3224) )
{
++locker_lost;
return 0LL;
}
v6 = *(_QWORD *)(THR_PFS + 2032);
*(_QWORD *)(a1 + 64) = v6;
v7 |= 4u;
*(_DWORD *)(v6 + 24) = 4;
*(_QWORD *)(v6 + 32) = *(_QWORD *)(v6 - 176 + 8);
*(_DWORD *)(v6 + 40) = *(_DWORD *)(v6 - 176 + 24);
*(_QWORD *)v6 = *(_QWORD *)(THR_PFS + 2128);
*(_QWORD *)(v6 + 48) = v9;
*(_QWORD *)(v6 + 56) = 0LL;
*(_QWORD *)(v6 + 64) = 0LL;
*(_QWORD *)(v6 + 136) = v10;
*(_QWORD *)(v6 + 104) = v10;
*(_DWORD *)(v6 + 128) = PFS_file::get_version(v10);
v3 = *(_QWORD *)(THR_PFS + 2040);
*(_QWORD *)(THR_PFS + 2040) = v3 + 1;
*(_QWORD *)(v6 + 8) = v3;
*(_QWORD *)(v6 + 16) = 0LL;
*(_DWORD *)(v6 + 144) = file_operation_map[a3];
*(_DWORD *)(v6 + 88) = 5;
*(_QWORD *)(THR_PFS + 2032) += 176LL;
}
}
else
{
v7 = (*((_BYTE *)v10 + 5) & 1) != 0;
}
*(_DWORD *)a1 = v7;
*(_QWORD *)(a1 + 8) = v10;
*(_DWORD *)(a1 + 4) = a3;
*(_QWORD *)(a1 + 16) = 0LL;
*(_QWORD *)(a1 + 24) = v9;
return a1;
}
return 0LL;
}
| pfs_get_thread_file_descriptor_locker_v1:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x1c],EAX
MOV AL,0x1
CMP dword ptr [RBP + -0x1c],0x0
MOV byte ptr [RBP + -0x51],AL
JL 0x0014b677
MOVSXD RAX,dword ptr [RBP + -0x1c]
LEA RCX,[0x50da80]
CMP RAX,qword ptr [RCX]
SETGE AL
MOV byte ptr [RBP + -0x51],AL
LAB_0014b677:
MOV AL,byte ptr [RBP + -0x51]
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x0014b691
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0014b969
LAB_0014b691:
LEA RAX,[0x50daf0]
MOV RAX,qword ptr [RAX]
MOVSXD RCX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x28],RAX
CMP qword ptr [RBP + -0x28],0x0
SETZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x0014b6c6
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0014b969
LAB_0014b6c6:
CMP dword ptr [RBP + -0x18],0x4
JNZ 0x0014b6e2
LEA RAX,[0x50daf0]
MOV RAX,qword ptr [RAX]
MOVSXD RCX,dword ptr [RBP + -0x1c]
MOV qword ptr [RAX + RCX*0x8],0x0
LAB_0014b6e2:
MOV RAX,qword ptr [RBP + -0x28]
TEST byte ptr [RAX + 0x4],0x1
JNZ 0x0014b6f9
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0014b969
LAB_0014b6f9:
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x220]
MOV qword ptr [RBP + -0x30],RAX
CALL 0x00148dd0
MOV qword ptr [RBP + -0x38],RAX
CMP qword ptr [RBP + -0x38],0x0
SETZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x0014b730
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0014b969
LAB_0014b730:
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x20],RCX
LEA RAX,[0x510fc0]
TEST byte ptr [RAX],0x1
JZ 0x0014b90e
MOV RAX,qword ptr [RBP + -0x38]
TEST byte ptr [RAX + 0x7e0],0x1
JNZ 0x0014b766
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0014b969
LAB_0014b766:
MOV dword ptr [RBP + -0x3c],0x2
MOV RAX,qword ptr [RBP + -0x28]
TEST byte ptr [RAX + 0x5],0x1
JZ 0x0014b780
MOV EAX,dword ptr [RBP + -0x3c]
OR EAX,0x1
MOV dword ptr [RBP + -0x3c],EAX
LAB_0014b780:
LEA RAX,[0x510ec0]
TEST byte ptr [RAX],0x1
JZ 0x0014b90c
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x7f0]
MOV RCX,qword ptr [RBP + -0x38]
ADD RCX,0x878
ADD RCX,0x420
CMP RAX,RCX
SETNC AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x0014b7e2
LEA RAX,[0x50dac8]
MOV RCX,qword ptr [RAX]
ADD RCX,0x1
LEA RAX,[0x50dac8]
MOV qword ptr [RAX],RCX
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0014b969
LAB_0014b7e2:
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x7f0]
MOV qword ptr [RBP + -0x48],RAX
MOV RCX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x40],RCX
MOV EAX,dword ptr [RBP + -0x3c]
OR EAX,0x4
MOV dword ptr [RBP + -0x3c],EAX
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,-0xb0
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV dword ptr [RAX + 0x18],0x4
MOV RAX,qword ptr [RBP + -0x50]
MOV RCX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX + 0x20],RCX
MOV RAX,qword ptr [RBP + -0x50]
MOV ECX,dword ptr [RAX + 0x18]
MOV RAX,qword ptr [RBP + -0x48]
MOV dword ptr [RAX + 0x28],ECX
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RAX + 0x850]
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX + 0x30],RCX
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX + 0x38],0x0
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX + 0x40],0x0
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX + 0x88],RCX
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX + 0x68],RCX
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x00151af0
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x48]
MOV dword ptr [RAX + 0x80],ECX
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RAX + 0x7f8]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RAX + 0x7f8],RDX
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX + 0x10],0x0
MOVSXD RCX,dword ptr [RBP + -0x18]
LEA RAX,[0x316440]
MOV ECX,dword ptr [RAX + RCX*0x4]
MOV RAX,qword ptr [RBP + -0x48]
MOV dword ptr [RAX + 0x90],ECX
MOV RAX,qword ptr [RBP + -0x48]
MOV dword ptr [RAX + 0x58],0x5
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RAX + 0x7f0]
ADD RCX,0xb0
MOV qword ptr [RAX + 0x7f0],RCX
LAB_0014b90c:
JMP 0x0014b92a
LAB_0014b90e:
MOV RAX,qword ptr [RBP + -0x28]
TEST byte ptr [RAX + 0x5],0x1
JZ 0x0014b921
MOV dword ptr [RBP + -0x3c],0x1
JMP 0x0014b928
LAB_0014b921:
MOV dword ptr [RBP + -0x3c],0x0
LAB_0014b928:
JMP 0x0014b92a
LAB_0014b92a:
MOV ECX,dword ptr [RBP + -0x3c]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],ECX
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV ECX,dword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x4],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x10],0x0
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x18],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
LAB_0014b969:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x60
POP RBP
RET
|
uint * pfs_get_thread_file_descriptor_locker_v1(uint *param_1,int param_2,uint param_3)
{
PFS_file *this;
int8 uVar1;
int8 *puVar2;
long lVar3;
int4 uVar4;
long lVar5;
uint local_44;
uint *local_10;
if (param_2 < 0 || file_handle_max <= param_2) {
local_10 = (uint *)0x0;
}
else {
this = *(PFS_file **)(file_handle_array + (long)param_2 * 8);
if (this == (PFS_file *)0x0) {
local_10 = (uint *)0x0;
}
else {
if (param_3 == 4) {
*(int8 *)(file_handle_array + (long)param_2 * 8) = 0;
}
if (((byte)this[4] & 1) == 0) {
local_10 = (uint *)0x0;
}
else {
uVar1 = *(int8 *)(this + 0x220);
lVar5 = my_thread_get_THR_PFS();
if (lVar5 == 0) {
local_10 = (uint *)0x0;
}
else {
*(long *)(param_1 + 8) = lVar5;
if ((flag_thread_instrumentation & 1) == 0) {
local_44 = (uint)(((byte)this[5] & 1) != 0);
}
else {
if ((*(byte *)(lVar5 + 0x7e0) & 1) == 0) {
return (uint *)0x0;
}
local_44 = 2;
if (((byte)this[5] & 1) != 0) {
local_44 = 3;
}
if ((flag_events_waits_current & 1) != 0) {
if (lVar5 + 0xc98U <= *(ulong *)(lVar5 + 0x7f0)) {
locker_lost = locker_lost + 1;
return (uint *)0x0;
}
puVar2 = *(int8 **)(lVar5 + 0x7f0);
*(int8 **)(param_1 + 0x10) = puVar2;
local_44 = local_44 | 4;
*(int4 *)(puVar2 + 3) = 4;
puVar2[4] = puVar2[-0x15];
*(int4 *)(puVar2 + 5) = *(int4 *)(puVar2 + -0x13);
*puVar2 = *(int8 *)(lVar5 + 0x850);
puVar2[6] = uVar1;
puVar2[7] = 0;
puVar2[8] = 0;
puVar2[0x11] = this;
puVar2[0xd] = this;
uVar4 = PFS_file::get_version(this);
*(int4 *)(puVar2 + 0x10) = uVar4;
lVar3 = *(long *)(lVar5 + 0x7f8);
*(long *)(lVar5 + 0x7f8) = lVar3 + 1;
puVar2[1] = lVar3;
puVar2[2] = 0;
*(int4 *)(puVar2 + 0x12) =
*(int4 *)(file_operation_map + (long)(int)param_3 * 4);
*(int4 *)(puVar2 + 0xb) = 5;
*(long *)(lVar5 + 0x7f0) = *(long *)(lVar5 + 0x7f0) + 0xb0;
}
}
*param_1 = local_44;
*(PFS_file **)(param_1 + 2) = this;
param_1[1] = param_3;
param_1[4] = 0;
param_1[5] = 0;
*(int8 *)(param_1 + 6) = uVar1;
local_10 = param_1;
}
}
}
}
return local_10;
}
| |
52,968 | my_instr_simple | eloqsql/strings/ctype-simple.c | uint my_instr_simple(CHARSET_INFO *cs,
const char *b, size_t b_length,
const char *s, size_t s_length,
my_match_t *match, uint nmatch)
{
register const uchar *str, *search, *end, *search_end;
if (s_length <= b_length)
{
if (!s_length)
{
if (nmatch)
{
match->beg= 0;
match->end= 0;
match->mb_len= 0;
}
return 1; /* Empty string is always found */
}
str= (const uchar*) b;
search= (const uchar*) s;
end= (const uchar*) b+b_length-s_length+1;
search_end= (const uchar*) s + s_length;
skip:
while (str != end)
{
if (cs->sort_order[*str++] == cs->sort_order[*search])
{
register const uchar *i,*j;
i= str;
j= search+1;
while (j != search_end)
if (cs->sort_order[*i++] != cs->sort_order[*j++])
goto skip;
if (nmatch > 0)
{
match[0].beg= 0;
match[0].end= (uint) (str- (const uchar*)b-1);
match[0].mb_len= match[0].end;
if (nmatch > 1)
{
match[1].beg= match[0].end;
match[1].end= (uint)(match[0].end+s_length);
match[1].mb_len= match[1].end-match[1].beg;
}
}
return 2;
}
}
}
return 0;
} | O3 | c | my_instr_simple:
xorl %eax, %eax
cmpq %rdx, %r8
ja 0x3dc1c
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl 0x10(%rbp), %r11d
testq %r8, %r8
je 0x3dbe2
addq %rsi, %rdx
subq %r8, %rdx
incq %rdx
movq %rsi, %r10
cmpq %rdx, %r10
je 0x3dc12
movq %r10, %rbx
movq 0x58(%rdi), %r14
incq %r10
movzbl (%rbx), %r15d
movb (%r14,%r15), %r15b
movzbl (%rcx), %r12d
cmpb (%r14,%r12), %r15b
jne 0x3db62
movl $0x1, %r15d
cmpq %r15, %r8
je 0x3dbab
movzbl (%rbx,%r15), %r12d
movb (%r14,%r12), %r12b
movzbl (%rcx,%r15), %r13d
incq %r15
cmpb (%r14,%r13), %r12b
je 0x3db8d
jmp 0x3db62
movl $0x2, %eax
testl %r11d, %r11d
je 0x3dc12
movl $0x0, (%r9)
notl %esi
addl %esi, %r10d
movl %r10d, 0x4(%r9)
movl %r10d, 0x8(%r9)
cmpl $0x1, %r11d
je 0x3dc12
movl %r10d, 0xc(%r9)
addl %r8d, %r10d
movl $0x14, %ecx
movl $0x10, %edx
jmp 0x3dc03
testl %r11d, %r11d
je 0x3dc0d
movl $0x0, (%r9)
movl $0x1, %eax
movl $0x8, %ecx
xorl %r10d, %r10d
movl $0x4, %edx
xorl %r8d, %r8d
movl %r10d, (%r9,%rdx)
movl %r8d, (%r9,%rcx)
jmp 0x3dc12
movl $0x1, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_instr_simple:
xor eax, eax
cmp r8, rdx
ja locret_3DC1C
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
mov r11d, [rbp+10h]
test r8, r8
jz loc_3DBE2
add rdx, rsi
sub rdx, r8
inc rdx
mov r10, rsi
loc_3DB62:
cmp r10, rdx
jz loc_3DC12
mov rbx, r10
mov r14, [rdi+58h]
inc r10
movzx r15d, byte ptr [rbx]
mov r15b, [r14+r15]
movzx r12d, byte ptr [rcx]
cmp r15b, [r14+r12]
jnz short loc_3DB62
mov r15d, 1
loc_3DB8D:
cmp r8, r15
jz short loc_3DBAB
movzx r12d, byte ptr [rbx+r15]
mov r12b, [r14+r12]
movzx r13d, byte ptr [rcx+r15]
inc r15
cmp r12b, [r14+r13]
jz short loc_3DB8D
jmp short loc_3DB62
loc_3DBAB:
mov eax, 2
test r11d, r11d
jz short loc_3DC12
mov dword ptr [r9], 0
not esi
add r10d, esi
mov [r9+4], r10d
mov [r9+8], r10d
cmp r11d, 1
jz short loc_3DC12
mov [r9+0Ch], r10d
add r10d, r8d
mov ecx, 14h
mov edx, 10h
jmp short loc_3DC03
loc_3DBE2:
test r11d, r11d
jz short loc_3DC0D
mov dword ptr [r9], 0
mov eax, 1
mov ecx, 8
xor r10d, r10d
mov edx, 4
xor r8d, r8d
loc_3DC03:
mov [r9+rdx], r10d
mov [r9+rcx], r8d
jmp short loc_3DC12
loc_3DC0D:
mov eax, 1
loc_3DC12:
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
locret_3DC1C:
retn
| long long my_instr_simple(
long long a1,
unsigned __int8 *a2,
unsigned long long a3,
unsigned __int8 *a4,
unsigned long long a5,
_DWORD *a6,
int a7)
{
long long result; // rax
long long v8; // rdx
unsigned __int8 *v9; // r10
unsigned __int8 *v10; // rbx
long long v11; // r14
long long v12; // r15
char v13; // r12
long long v14; // r13
int v15; // r10d
int v16; // r10d
long long v17; // rcx
long long v18; // rdx
result = 0LL;
if ( a5 <= a3 )
{
if ( a5 )
{
v8 = (long long)&a2[a3 - a5 + 1];
v9 = a2;
LABEL_4:
while ( v9 != (unsigned __int8 *)v8 )
{
v10 = v9;
v11 = *(_QWORD *)(a1 + 88);
++v9;
if ( *(_BYTE *)(v11 + *v10) == *(_BYTE *)(v11 + *a4) )
{
v12 = 1LL;
while ( a5 != v12 )
{
v13 = *(_BYTE *)(v11 + v10[v12]);
v14 = a4[v12++];
if ( v13 != *(_BYTE *)(v11 + v14) )
goto LABEL_4;
}
result = 2LL;
if ( a7 )
{
*a6 = 0;
v15 = ~(_DWORD)a2 + (_DWORD)v9;
a6[1] = v15;
a6[2] = v15;
if ( a7 != 1 )
{
a6[3] = v15;
v16 = a5 + v15;
v17 = 5LL;
v18 = 4LL;
goto LABEL_15;
}
}
return result;
}
}
}
else if ( a7 )
{
*a6 = 0;
result = 1LL;
v17 = 2LL;
v16 = 0;
v18 = 1LL;
LODWORD(a5) = 0;
LABEL_15:
a6[v18] = v16;
a6[v17] = a5;
}
else
{
return 1LL;
}
}
return result;
}
| my_instr_simple:
XOR EAX,EAX
CMP R8,RDX
JA 0x0013dc1c
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV R11D,dword ptr [RBP + 0x10]
TEST R8,R8
JZ 0x0013dbe2
ADD RDX,RSI
SUB RDX,R8
INC RDX
MOV R10,RSI
LAB_0013db62:
CMP R10,RDX
JZ 0x0013dc12
MOV RBX,R10
MOV R14,qword ptr [RDI + 0x58]
INC R10
MOVZX R15D,byte ptr [RBX]
MOV R15B,byte ptr [R14 + R15*0x1]
MOVZX R12D,byte ptr [RCX]
CMP R15B,byte ptr [R14 + R12*0x1]
JNZ 0x0013db62
MOV R15D,0x1
LAB_0013db8d:
CMP R8,R15
JZ 0x0013dbab
MOVZX R12D,byte ptr [RBX + R15*0x1]
MOV R12B,byte ptr [R14 + R12*0x1]
MOVZX R13D,byte ptr [RCX + R15*0x1]
INC R15
CMP R12B,byte ptr [R14 + R13*0x1]
JZ 0x0013db8d
JMP 0x0013db62
LAB_0013dbab:
MOV EAX,0x2
TEST R11D,R11D
JZ 0x0013dc12
MOV dword ptr [R9],0x0
NOT ESI
ADD R10D,ESI
MOV dword ptr [R9 + 0x4],R10D
MOV dword ptr [R9 + 0x8],R10D
CMP R11D,0x1
JZ 0x0013dc12
MOV dword ptr [R9 + 0xc],R10D
ADD R10D,R8D
MOV ECX,0x14
MOV EDX,0x10
JMP 0x0013dc03
LAB_0013dbe2:
TEST R11D,R11D
JZ 0x0013dc0d
MOV dword ptr [R9],0x0
MOV EAX,0x1
MOV ECX,0x8
XOR R10D,R10D
MOV EDX,0x4
XOR R8D,R8D
LAB_0013dc03:
MOV dword ptr [R9 + RDX*0x1],R10D
MOV dword ptr [R9 + RCX*0x1],R8D
JMP 0x0013dc12
LAB_0013dc0d:
MOV EAX,0x1
LAB_0013dc12:
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
LAB_0013dc1c:
RET
|
int8
my_instr_simple(long param_1,byte *param_2,ulong param_3,byte *param_4,ulong param_5,
int4 *param_6,int param_7)
{
byte *pbVar1;
byte *pbVar2;
int8 uVar3;
long lVar4;
long lVar5;
int iVar6;
byte *pbVar7;
byte *pbVar8;
ulong uVar9;
uVar3 = 0;
if (param_5 <= param_3) {
if (param_5 == 0) {
if (param_7 == 0) {
uVar3 = 1;
}
else {
*param_6 = 0;
uVar3 = 1;
lVar4 = 8;
iVar6 = 0;
lVar5 = 4;
param_5 = 0;
LAB_0013dc03:
*(int *)((long)param_6 + lVar5) = iVar6;
*(int *)((long)param_6 + lVar4) = (int)param_5;
}
}
else {
pbVar8 = param_2;
while (pbVar7 = pbVar8, pbVar7 != param_2 + (param_3 - param_5) + 1) {
lVar4 = *(long *)(param_1 + 0x58);
pbVar8 = pbVar7 + 1;
if (*(char *)(lVar4 + (ulong)*pbVar7) == *(char *)(lVar4 + (ulong)*param_4)) {
uVar9 = 1;
do {
if (param_5 == uVar9) {
uVar3 = 2;
if (param_7 == 0) {
return 2;
}
*param_6 = 0;
iVar6 = (int)pbVar8 + ~(uint)param_2;
param_6[1] = iVar6;
param_6[2] = iVar6;
if (param_7 == 1) {
return 2;
}
param_6[3] = iVar6;
iVar6 = iVar6 + (int)param_5;
lVar4 = 0x14;
lVar5 = 0x10;
goto LAB_0013dc03;
}
pbVar1 = pbVar7 + uVar9;
pbVar2 = param_4 + uVar9;
uVar9 = uVar9 + 1;
} while (*(char *)(lVar4 + (ulong)*pbVar1) == *(char *)(lVar4 + (ulong)*pbVar2));
}
}
}
}
return uVar3;
}
| |
52,969 | ggml_easy::string_replace_all(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | ngxson[P]ggml-easy/ggml-easy.h | void string_replace_all(std::string & s, const std::string & search, const std::string & replace) {
if (search.empty()) {
return;
}
std::string builder;
builder.reserve(s.length());
size_t pos = 0;
size_t last_pos = 0;
while ((pos = s.find(search, last_pos)) != std::string::npos) {
builder.append(s, last_pos, pos - last_pos);
builder.append(replace);
last_pos = pos + search.length();
}
builder.append(s, last_pos, std::string::npos);
s = std::move(builder);
} | O0 | c | ggml_easy::string_replace_all(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x58(%rsp), %rdi
callq 0xa8a0
testb $0x1, %al
jne 0xbca3
jmp 0xbca8
jmp 0xbda4
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xa730
movq 0x60(%rsp), %rdi
callq 0xa7c0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xa800
jmp 0xbcd0
movq $0x0, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0xaa30
movq %rax, 0x18(%rsp)
cmpq $-0x1, %rax
je 0xbd6e
movq 0x60(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
subq %rdx, %rcx
leaq 0x30(%rsp), %rdi
callq 0xa720
jmp 0xbd1f
movq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0xa9f0
jmp 0xbd30
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x58(%rsp), %rdi
callq 0xa7c0
movq %rax, %rcx
movq (%rsp), %rax
addq %rcx, %rax
movq %rax, 0x10(%rsp)
jmp 0xbce2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xa380
jmp 0xbda9
movq 0x60(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x30(%rsp), %rdi
movq $-0x1, %rcx
callq 0xa720
jmp 0xbd8b
movq 0x60(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xa610
leaq 0x30(%rsp), %rdi
callq 0xa380
addq $0x68, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xa930
nopw %cs:(%rax,%rax)
| _ZN9ggml_easy18string_replace_allERNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKS5_S8_:
sub rsp, 68h
mov [rsp+68h+var_8], rdi
mov [rsp+68h+var_10], rsi
mov [rsp+68h+var_18], rdx
mov rdi, [rsp+68h+var_10]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5emptyEv; std::string::empty(void)
test al, 1
jnz short loc_BCA3
jmp short loc_BCA8
loc_BCA3:
jmp loc_BDA4
loc_BCA8:
lea rdi, [rsp+68h+var_38]
mov [rsp+68h+var_60], rdi
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev; std::string::basic_string(void)
mov rdi, [rsp+68h+var_8]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6lengthEv; std::string::length(void)
mov rdi, [rsp+68h+var_60]
mov rsi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
jmp short $+2
loc_BCD0:
mov [rsp+68h+var_50], 0
mov [rsp+68h+var_58], 0
loc_BCE2:
mov rdi, [rsp+68h+var_8]
mov rsi, [rsp+68h+var_10]
mov rdx, [rsp+68h+var_58]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findERKS4_m; std::string::find(std::string const&,ulong)
mov [rsp+68h+var_50], rax
cmp rax, 0FFFFFFFFFFFFFFFFh
jz short loc_BD6E
mov rsi, [rsp+68h+var_8]
mov rdx, [rsp+68h+var_58]
mov rcx, [rsp+68h+var_50]
sub rcx, rdx
lea rdi, [rsp+68h+var_38]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendERKS4_mm; std::string::append(std::string const&,ulong,ulong)
jmp short $+2
loc_BD1F:
mov rsi, [rsp+68h+var_18]
lea rdi, [rsp+68h+var_38]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendERKS4_; std::string::append(std::string const&)
jmp short $+2
loc_BD30:
mov rax, [rsp+68h+var_50]
mov [rsp+68h+var_68], rax
mov rdi, [rsp+68h+var_10]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6lengthEv; std::string::length(void)
mov rcx, rax
mov rax, [rsp+68h+var_68]
add rax, rcx
mov [rsp+68h+var_58], rax
jmp short loc_BCE2
mov rcx, rax
mov eax, edx
mov [rsp+arg_20], rcx
mov [rsp+arg_1C], eax
lea rdi, [rsp+arg_28]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_BDA9
loc_BD6E:
mov rsi, [rsp+68h+var_8]
mov rdx, [rsp+68h+var_58]
lea rdi, [rsp+68h+var_38]
mov rcx, 0FFFFFFFFFFFFFFFFh
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendERKS4_mm; std::string::append(std::string const&,ulong,ulong)
jmp short $+2
loc_BD8B:
mov rdi, [rsp+68h+var_8]
lea rsi, [rsp+68h+var_38]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
lea rdi, [rsp+68h+var_38]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_BDA4:
add rsp, 68h
retn
loc_BDA9:
mov rdi, [rsp+arg_20]
call __Unwind_Resume
| long long ggml_easy::string_replace_all(long long a1, long long a2, long long a3)
{
long long result; // rax
long long v4; // rax
long long i; // rax
long long v6; // [rsp+10h] [rbp-58h]
long long v7; // [rsp+18h] [rbp-50h]
_BYTE v8[32]; // [rsp+30h] [rbp-38h] BYREF
long long v9; // [rsp+50h] [rbp-18h]
long long v10; // [rsp+58h] [rbp-10h]
long long v11; // [rsp+60h] [rbp-8h]
v11 = a1;
v10 = a2;
v9 = a3;
result = std::string::empty(a2);
if ( (result & 1) == 0 )
{
std::string::basic_string(v8);
v4 = std::string::length(v11);
std::string::reserve(v8, v4);
v6 = 0LL;
for ( i = std::string::find(v11, v10, 0LL); ; i = std::string::find(v11, v10, v6) )
{
v7 = i;
if ( i == -1 )
break;
std::string::append(v8, v11, v6, i - v6);
std::string::append(v8, v9);
v6 = std::string::length(v10) + v7;
}
std::string::append(v8, v11, v6, -1LL);
std::string::operator=(v11, v8);
return std::string::~string(v8);
}
return result;
}
| string_replace_all:
SUB RSP,0x68
MOV qword ptr [RSP + 0x60],RDI
MOV qword ptr [RSP + 0x58],RSI
MOV qword ptr [RSP + 0x50],RDX
MOV RDI,qword ptr [RSP + 0x58]
CALL 0x0010a8a0
TEST AL,0x1
JNZ 0x0010bca3
JMP 0x0010bca8
LAB_0010bca3:
JMP 0x0010bda4
LAB_0010bca8:
LEA RDI,[RSP + 0x30]
MOV qword ptr [RSP + 0x8],RDI
CALL 0x0010a730
MOV RDI,qword ptr [RSP + 0x60]
CALL 0x0010a7c0
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,RAX
LAB_0010bcc9:
CALL 0x0010a800
JMP 0x0010bcd0
LAB_0010bcd0:
MOV qword ptr [RSP + 0x18],0x0
MOV qword ptr [RSP + 0x10],0x0
LAB_0010bce2:
MOV RDI,qword ptr [RSP + 0x60]
MOV RSI,qword ptr [RSP + 0x58]
MOV RDX,qword ptr [RSP + 0x10]
CALL 0x0010aa30
MOV qword ptr [RSP + 0x18],RAX
CMP RAX,-0x1
JZ 0x0010bd6e
MOV RSI,qword ptr [RSP + 0x60]
MOV RDX,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP + 0x18]
SUB RCX,RDX
LEA RDI,[RSP + 0x30]
CALL 0x0010a720
JMP 0x0010bd1f
LAB_0010bd1f:
MOV RSI,qword ptr [RSP + 0x50]
LEA RDI,[RSP + 0x30]
CALL 0x0010a9f0
JMP 0x0010bd30
LAB_0010bd30:
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP],RAX
MOV RDI,qword ptr [RSP + 0x58]
CALL 0x0010a7c0
MOV RCX,RAX
MOV RAX,qword ptr [RSP]
ADD RAX,RCX
MOV qword ptr [RSP + 0x10],RAX
JMP 0x0010bce2
LAB_0010bd6e:
MOV RSI,qword ptr [RSP + 0x60]
MOV RDX,qword ptr [RSP + 0x10]
LEA RDI,[RSP + 0x30]
MOV RCX,-0x1
CALL 0x0010a720
LAB_0010bd89:
JMP 0x0010bd8b
LAB_0010bd8b:
MOV RDI,qword ptr [RSP + 0x60]
LEA RSI,[RSP + 0x30]
CALL 0x0010a610
LEA RDI,[RSP + 0x30]
CALL 0x0010a380
LAB_0010bda4:
ADD RSP,0x68
RET
|
/* ggml_easy::string_replace_all(std::__cxx11::string&, std::__cxx11::string const&,
std::__cxx11::string const&) */
void ggml_easy::string_replace_all(string *param_1,string *param_2,string *param_3)
{
ulong uVar1;
long lVar2;
long lVar3;
ulong local_58;
string local_38 [32];
string *local_18;
string *local_10;
string *local_8;
local_18 = param_3;
local_10 = param_2;
local_8 = param_1;
uVar1 = std::__cxx11::string::empty();
if ((uVar1 & 1) == 0) {
std::__cxx11::string::string(local_38);
std::__cxx11::string::length();
/* try { // try from 0010bcc9 to 0010bd88 has its CatchHandler @ 0010bd54 */
std::__cxx11::string::reserve((ulong)local_38);
local_58 = 0;
while (lVar2 = std::__cxx11::string::find(local_8,(ulong)local_10), lVar2 != -1) {
std::__cxx11::string::append(local_38,(ulong)local_8,local_58);
std::__cxx11::string::append(local_38);
lVar3 = std::__cxx11::string::length();
local_58 = lVar2 + lVar3;
}
std::__cxx11::string::append(local_38,(ulong)local_8,local_58);
std::__cxx11::string::operator=(local_8,local_38);
std::__cxx11::string::~string(local_38);
}
return;
}
| |
52,970 | minja::IfTemplateToken::~IfTemplateToken() | monkey531[P]llama/common/minja.hpp | IfTemplateToken(const Location & location, SpaceHandling pre, SpaceHandling post, std::shared_ptr<Expression> && c) : TemplateToken(Type::If, location, pre, post), condition(std::move(c)) {} | O3 | cpp | minja::IfTemplateToken::~IfTemplateToken():
pushq %rbx
movq %rdi, %rbx
leaq 0x93155(%rip), %rax # 0x12fb30
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x9c9f0
callq 0x267a6
leaq 0x928f1(%rip), %rax # 0x12f2e8
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x9ca0d
popq %rbx
jmp 0x267a6
popq %rbx
retq
nop
| _ZN5minja15IfTemplateTokenD2Ev:
push rbx
mov rbx, rdi
lea rax, _ZTVN5minja15IfTemplateTokenE; `vtable for'minja::IfTemplateToken
add rax, 10h
mov [rdi], rax
mov rdi, [rdi+38h]
test rdi, rdi
jz short loc_9C9F0
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9C9F0:
lea rax, _ZTVN5minja13TemplateTokenE; `vtable for'minja::TemplateToken
add rax, 10h
mov [rbx], rax
mov rdi, [rbx+18h]
test rdi, rdi
jz short loc_9CA0D
pop rbx
jmp _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9CA0D:
pop rbx
retn
| void minja::IfTemplateToken::~IfTemplateToken(minja::IfTemplateToken *this)
{
volatile signed __int32 *v2; // rdi
volatile signed __int32 *v3; // rdi
*(_QWORD *)this = &`vtable for'minja::IfTemplateToken + 2;
v2 = (volatile signed __int32 *)*((_QWORD *)this + 7);
if ( v2 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v2);
*(_QWORD *)this = &`vtable for'minja::TemplateToken + 2;
v3 = (volatile signed __int32 *)*((_QWORD *)this + 3);
if ( v3 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v3);
}
| ~IfTemplateToken:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x22fb30]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x38]
TEST RDI,RDI
JZ 0x0019c9f0
CALL 0x001267a6
LAB_0019c9f0:
LEA RAX,[0x22f2e8]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
MOV RDI,qword ptr [RBX + 0x18]
TEST RDI,RDI
JZ 0x0019ca0d
POP RBX
JMP 0x001267a6
LAB_0019ca0d:
POP RBX
RET
|
/* minja::IfTemplateToken::~IfTemplateToken() */
void __thiscall minja::IfTemplateToken::~IfTemplateToken(IfTemplateToken *this)
{
*(int ***)this = &PTR__IfTemplateToken_0022fb40;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x38) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x38));
}
*(int ***)this = &PTR__TemplateToken_0022f2f8;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x18) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x18));
return;
}
return;
}
| |
52,971 | minja::Value::Value(char const*) | monkey531[P]llama/common/minja.hpp | Value(const char * v) : primitive_(std::string(v)) {} | O3 | cpp | minja::Value::Value(char const*):
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x1d6de
leaq 0x40(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2d3d4
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x60c06
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x186a0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x60c31
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x186a0
jmp 0x60c31
movq %rax, %r14
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x60c3f
callq 0x30ed6
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x60c4d
callq 0x30ed6
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x60c5b
callq 0x30ed6
movq %rbx, %rdi
callq 0x40da8
movq %r14, %rdi
callq 0x18bc0
nop
| _ZN5minja5ValueC2EPKc:
push r14
push rbx
sub rsp, 28h
mov rbx, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi+30h], xmm0
movups xmmword ptr [rdi+20h], xmm0
movups xmmword ptr [rdi+10h], xmm0
movups xmmword ptr [rdi], xmm0
lea rdi, [rsp+38h+var_30]
lea rdx, [rsp+38h+var_31]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rdi, [rbx+40h]
lea rsi, [rsp+38h+var_30]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SG_EE5valueEiE4typeELi0EEEOT_
lea rax, [rsp+38h+var_20]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_60C06
mov rsi, [rsp+38h+var_20]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_60C06:
add rsp, 28h
pop rbx
pop r14
retn
mov r14, rax
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_60C31
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_60C31
mov r14, rax
loc_60C31:
mov rdi, [rbx+38h]
test rdi, rdi
jz short loc_60C3F
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_60C3F:
mov rdi, [rbx+28h]
test rdi, rdi
jz short loc_60C4D
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_60C4D:
mov rdi, [rbx+18h]
test rdi, rdi
jz short loc_60C5B
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_60C5B:
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
| void minja::Value::Value(minja::Value *this, const char *a2)
{
long long *v2; // [rsp+8h] [rbp-30h] BYREF
long long v3; // [rsp+18h] [rbp-20h] BYREF
*((_OWORD *)this + 3) = 0LL;
*((_OWORD *)this + 2) = 0LL;
*((_OWORD *)this + 1) = 0LL;
*(_OWORD *)this = 0LL;
std::string::basic_string<std::allocator<char>>(&v2, (long long)a2);
ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SG_EE5valueEiE4typeELi0EEEOT_((_OWORD *)this + 4);
if ( v2 != &v3 )
operator delete(v2, v3 + 1);
}
| Value:
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x30],XMM0
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOVUPS xmmword ptr [RDI + 0x10],XMM0
MOVUPS xmmword ptr [RDI],XMM0
LAB_00160bce:
LEA RDI,[RSP + 0x8]
LEA RDX,[RSP + 0x7]
CALL 0x0011d6de
LEA RDI,[RBX + 0x40]
LAB_00160be1:
LEA RSI,[RSP + 0x8]
CALL 0x0012d3d4
LAB_00160beb:
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x00160c06
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001186a0
LAB_00160c06:
ADD RSP,0x28
POP RBX
POP R14
RET
|
/* minja::Value::Value(char const*) */
void __thiscall minja::Value::Value(Value *this,char *param_1)
{
allocator local_31;
long *local_30 [2];
long local_20 [2];
*(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 00160bce to 00160bdc has its CatchHandler @ 00160c2e */
std::__cxx11::string::string<std::allocator<char>>((string *)local_30,param_1,&local_31);
/* try { // try from 00160be1 to 00160bea has its CatchHandler @ 00160c0e */
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SG_EE5valueEiE4typeELi0EEEOT_
(this + 0x40,local_30);
if (local_30[0] != local_20) {
operator_delete(local_30[0],local_20[0] + 1);
}
return;
}
| |
52,972 | trnman_get_max_trid | eloqsql/storage/maria/trnman.c | TrID trnman_get_max_trid()
{
TrID id;
/* Check if trnman has been initalized */
if (short_trid_to_active_trn == NULL)
return 0;
mysql_mutex_lock(&LOCK_trn_list);
id= global_trid_generator;
mysql_mutex_unlock(&LOCK_trn_list);
return id;
} | O0 | c | trnman_get_max_trid:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x40e6f0(%rip) # 0x486dd0
jne 0x786ec
movq $0x0, -0x8(%rbp)
jmp 0x78723
leaq 0x40ea8d(%rip), %rdi # 0x487180
leaq 0xe4928(%rip), %rsi # 0x15d022
movl $0x38c, %edx # imm = 0x38C
callq 0x77720
movq 0x40e9a5(%rip), %rax # 0x4870b0
movq %rax, -0x10(%rbp)
leaq 0x40ea6a(%rip), %rdi # 0x487180
callq 0x77790
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| trnman_get_max_trid:
push rbp
mov rbp, rsp
sub rsp, 10h
cmp cs:short_trid_to_active_trn, 0
jnz short loc_786EC
mov [rbp+var_8], 0
jmp short loc_78723
loc_786EC:
lea rdi, LOCK_trn_list
lea rsi, aWorkspaceLlm4b_17; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 38Ch
call inline_mysql_mutex_lock_10
mov rax, cs:global_trid_generator
mov [rbp+var_10], rax
lea rdi, LOCK_trn_list
call inline_mysql_mutex_unlock_11
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
loc_78723:
mov rax, [rbp+var_8]
add rsp, 10h
pop rbp
retn
| long long trnman_get_max_trid()
{
long long v1; // [rsp+0h] [rbp-10h]
if ( !short_trid_to_active_trn )
return 0LL;
inline_mysql_mutex_lock_10(
(long long)&LOCK_trn_list,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/trnman.c",
0x38Cu);
v1 = global_trid_generator;
inline_mysql_mutex_unlock_11((long long)&LOCK_trn_list);
return v1;
}
| trnman_get_max_trid:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
CMP qword ptr [0x00586dd0],0x0
JNZ 0x001786ec
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00178723
LAB_001786ec:
LEA RDI,[0x587180]
LEA RSI,[0x25d022]
MOV EDX,0x38c
CALL 0x00177720
MOV RAX,qword ptr [0x005870b0]
MOV qword ptr [RBP + -0x10],RAX
LEA RDI,[0x587180]
CALL 0x00177790
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
LAB_00178723:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x10
POP RBP
RET
|
int8 trnman_get_max_trid(void)
{
int8 local_10;
if (short_trid_to_active_trn == 0) {
local_10 = 0;
}
else {
inline_mysql_mutex_lock
(LOCK_trn_list,"/workspace/llm4binary/github2025/eloqsql/storage/maria/trnman.c",0x38c
);
local_10 = global_trid_generator;
inline_mysql_mutex_unlock(LOCK_trn_list);
}
return local_10;
}
| |
52,973 | mariadb_compression_algorithm_str | eloqsql/libmariadb/libmariadb/ma_compress.c | const char *_mariadb_compression_algorithm_str(enum enum_ma_compression_algorithm algorithm)
{
switch(algorithm) {
case COMPRESSION_NONE:
case COMPRESSION_ZLIB:
case COMPRESSION_ZSTD:
return compression_algorithms[algorithm] ;
default:
return compression_algorithms[COMPRESSION_UNKNOWN];
}
} | O0 | c | mariadb_compression_algorithm_str:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
subl $0x2, %eax
ja 0x3f8f7
jmp 0x3f8e1
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x40313(%rip), %rax # 0x7fc00
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x3f906
leaq 0x40302(%rip), %rax # 0x7fc00
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
| _mariadb_compression_algorithm_str:
push rbp
mov rbp, rsp
mov [rbp+var_C], edi
mov eax, [rbp+var_C]
sub eax, 2
ja short loc_3F8F7
jmp short $+2
loc_3F8E1:
mov eax, [rbp+var_C]
mov ecx, eax
lea rax, compression_algorithms
mov rax, [rax+rcx*8]
mov [rbp+var_8], rax
jmp short loc_3F906
loc_3F8F7:
lea rax, compression_algorithms
mov rax, [rax+18h]
mov [rbp+var_8], rax
loc_3F906:
mov rax, [rbp+var_8]
pop rbp
retn
| char * mariadb_compression_algorithm_str(unsigned int a1)
{
if ( a1 > 2 )
return compression_algorithms[3];
else
return compression_algorithms[a1];
}
| _mariadb_compression_algorithm_str:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0xc],EDI
MOV EAX,dword ptr [RBP + -0xc]
SUB EAX,0x2
JA 0x0013f8f7
JMP 0x0013f8e1
LAB_0013f8e1:
MOV EAX,dword ptr [RBP + -0xc]
MOV ECX,EAX
LEA RAX,[0x17fc00]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0013f906
LAB_0013f8f7:
LEA RAX,[0x17fc00]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RBP + -0x8],RAX
LAB_0013f906:
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
int8 _mariadb_compression_algorithm_str(uint param_1)
{
int8 local_10;
if (param_1 < 3) {
local_10 = *(int8 *)(compression_algorithms + (ulong)param_1 * 8);
}
else {
local_10 = compression_algorithms._24_8_;
}
return local_10;
}
| |
52,974 | nlohmann::json_abi_v3_11_3::detail::lexer_base<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::token_type_name(nlohmann::json_abi_v3_11_3::detail::lexer_base<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::token_type) | llama.cpp/common/json.hpp | static const char* token_type_name(const token_type t) noexcept
{
switch (t)
{
case token_type::uninitialized:
return "<uninitialized>";
case token_type::literal_true:
return "true literal";
case token_type::literal_false:
return "false literal";
case token_type::literal_null:
return "null literal";
case token_type::value_string:
return "string literal";
case token_type::value_unsigned:
case token_type::value_integer:
case token_type::value_float:
return "number literal";
case token_type::begin_array:
return "'['";
case token_type::begin_object:
return "'{'";
case token_type::end_array:
return "']'";
case token_type::end_object:
return "'}'";
case token_type::name_separator:
return "':'";
case token_type::value_separator:
return "','";
case token_type::parse_error:
return "<parse error>";
case token_type::end_of_input:
return "end of input";
case token_type::literal_or_value:
return "'[', '{', or a literal";
// LCOV_EXCL_START
default: // catch non-enum values
return "unknown token";
// LCOV_EXCL_STOP
}
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::lexer_base<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::token_type_name(nlohmann::json_abi_v3_11_3::detail::lexer_base<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::token_type):
cmpl $0x10, %edi
ja 0x8cd59
movl %edi, %eax
leaq 0xd2f34(%rip), %rcx # 0x15fc88
movq (%rcx,%rax,8), %rax
retq
leaq 0x8df72(%rip), %rax # 0x11acd2
retq
nop
| _ZN8nlohmann16json_abi_v3_11_36detail10lexer_baseINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE15token_type_nameENSG_10token_typeE:
cmp edi, 10h
ja short loc_8CD59
mov eax, edi
lea rcx, off_15FC88; "<uninitialized>"
mov rax, [rcx+rax*8]
retn
loc_8CD59:
lea rax, aUnknownToken; "unknown token"
retn
| const char * nlohmann::json_abi_v3_11_3::detail::lexer_base<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::token_type_name(
unsigned int a1)
{
if ( a1 > 0x10 )
return "unknown token";
else
return off_15FC88[a1];
}
| token_type_name:
CMP EDI,0x10
JA 0x0018cd59
MOV EAX,EDI
LEA RCX,[0x25fc88]
MOV RAX,qword ptr [RCX + RAX*0x8]
RET
LAB_0018cd59:
LEA RAX,[0x21acd2]
RET
|
/* nlohmann::json_abi_v3_11_3::detail::lexer_base<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>
>::token_type_name(nlohmann::json_abi_v3_11_3::detail::lexer_base<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::token_type) */
char * nlohmann::json_abi_v3_11_3::detail::
lexer_base<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::token_type_name(uint param_1)
{
if (param_1 < 0x11) {
return (&PTR_s_<uninitialized>_0025fc88)[param_1];
}
return "unknown token";
}
| |
52,975 | js_cond_destroy | bluesky950520[P]quickjs/cutils.c | void js_cond_destroy(js_cond_t *cond) {
#if defined(__APPLE__) && defined(__MACH__)
/* It has been reported that destroying condition variables that have been
* signalled but not waited on can sometimes result in application crashes.
* See https://codereview.chromium.org/1323293005.
*/
pthread_mutex_t mutex;
struct timespec ts;
int err;
if (pthread_mutex_init(&mutex, NULL))
abort();
if (pthread_mutex_lock(&mutex))
abort();
ts.tv_sec = 0;
ts.tv_nsec = 1;
err = pthread_cond_timedwait_relative_np(cond, &mutex, &ts);
if (err != 0 && err != ETIMEDOUT)
abort();
if (pthread_mutex_unlock(&mutex))
abort();
if (pthread_mutex_destroy(&mutex))
abort();
#endif /* defined(__APPLE__) && defined(__MACH__) */
if (pthread_cond_destroy(cond))
abort();
} | O0 | c | js_cond_destroy:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0xe770
cmpl $0x0, %eax
je 0x1fd38
callq 0xe090
popq %rax
retq
nopw (%rax,%rax)
| js_cond_destroy:
push rax
mov [rsp+8+var_8], rdi
mov rdi, [rsp+8+var_8]
call _pthread_cond_destroy
cmp eax, 0
jz short loc_1FD38
call _abort
loc_1FD38:
pop rax
retn
| long long js_cond_destroy(long long a1)
{
if ( (unsigned int)pthread_cond_destroy(a1) )
abort();
return a1;
}
| js_cond_destroy:
PUSH RAX
MOV qword ptr [RSP],RDI
MOV RDI,qword ptr [RSP]
CALL 0x0010e770
CMP EAX,0x0
JZ 0x0011fd38
CALL 0x0010e090
LAB_0011fd38:
POP RAX
RET
|
pthread_cond_t * js_cond_destroy(pthread_cond_t *param_1)
{
int iVar1;
iVar1 = pthread_cond_destroy(param_1);
if (iVar1 != 0) {
/* WARNING: Subroutine does not return */
abort();
}
return param_1;
}
| |
52,976 | js_cond_destroy | bluesky950520[P]quickjs/cutils.c | void js_cond_destroy(js_cond_t *cond) {
#if defined(__APPLE__) && defined(__MACH__)
/* It has been reported that destroying condition variables that have been
* signalled but not waited on can sometimes result in application crashes.
* See https://codereview.chromium.org/1323293005.
*/
pthread_mutex_t mutex;
struct timespec ts;
int err;
if (pthread_mutex_init(&mutex, NULL))
abort();
if (pthread_mutex_lock(&mutex))
abort();
ts.tv_sec = 0;
ts.tv_nsec = 1;
err = pthread_cond_timedwait_relative_np(cond, &mutex, &ts);
if (err != 0 && err != ETIMEDOUT)
abort();
if (pthread_mutex_unlock(&mutex))
abort();
if (pthread_mutex_destroy(&mutex))
abort();
#endif /* defined(__APPLE__) && defined(__MACH__) */
if (pthread_cond_destroy(cond))
abort();
} | O1 | c | js_cond_destroy:
pushq %rax
callq 0xe780
testl %eax, %eax
jne 0x1bbd4
popq %rax
retq
callq 0xe090
| js_cond_destroy:
push rax
call _pthread_cond_destroy
test eax, eax
jnz short loc_1BBD4
pop rax
retn
loc_1BBD4:
call _abort
| void __spoils<rdx,rcx,r8,r9,r10,r11,xmm4,xmm5> js_cond_destroy()
{
if ( (unsigned int)pthread_cond_destroy() )
abort();
}
| js_cond_destroy:
PUSH RAX
CALL 0x0010e780
TEST EAX,EAX
JNZ 0x0011bbd4
POP RAX
RET
LAB_0011bbd4:
CALL 0x0010e090
|
int8 js_cond_destroy(pthread_cond_t *param_1)
{
int iVar1;
int8 in_RAX;
iVar1 = pthread_cond_destroy(param_1);
if (iVar1 == 0) {
return in_RAX;
}
/* WARNING: Subroutine does not return */
abort();
}
| |
52,977 | js_cond_destroy | bluesky950520[P]quickjs/cutils.c | void js_cond_destroy(js_cond_t *cond) {
#if defined(__APPLE__) && defined(__MACH__)
/* It has been reported that destroying condition variables that have been
* signalled but not waited on can sometimes result in application crashes.
* See https://codereview.chromium.org/1323293005.
*/
pthread_mutex_t mutex;
struct timespec ts;
int err;
if (pthread_mutex_init(&mutex, NULL))
abort();
if (pthread_mutex_lock(&mutex))
abort();
ts.tv_sec = 0;
ts.tv_nsec = 1;
err = pthread_cond_timedwait_relative_np(cond, &mutex, &ts);
if (err != 0 && err != ETIMEDOUT)
abort();
if (pthread_mutex_unlock(&mutex))
abort();
if (pthread_mutex_destroy(&mutex))
abort();
#endif /* defined(__APPLE__) && defined(__MACH__) */
if (pthread_cond_destroy(cond))
abort();
} | O3 | c | js_cond_destroy:
pushq %rax
callq 0xe780
testl %eax, %eax
jne 0x1c4aa
popq %rax
retq
callq 0xe090
| js_cond_destroy:
push rax
call _pthread_cond_destroy
test eax, eax
jnz short loc_1C4AA
pop rax
retn
loc_1C4AA:
call _abort
| void __spoils<rdx,rcx,r8,r9,r10,r11,xmm4,xmm5> js_cond_destroy()
{
if ( (unsigned int)pthread_cond_destroy() )
abort();
}
| js_cond_destroy:
PUSH RAX
CALL 0x0010e780
TEST EAX,EAX
JNZ 0x0011c4aa
POP RAX
RET
LAB_0011c4aa:
CALL 0x0010e090
|
int8 js_cond_destroy(pthread_cond_t *param_1)
{
int iVar1;
int8 in_RAX;
iVar1 = pthread_cond_destroy(param_1);
if (iVar1 == 0) {
return in_RAX;
}
/* WARNING: Subroutine does not return */
abort();
}
| |
52,978 | add_shape_property | bluesky950520[P]quickjs/quickjs.c | static int add_shape_property(JSContext *ctx, JSShape **psh,
JSObject *p, JSAtom atom, int prop_flags)
{
JSRuntime *rt = ctx->rt;
JSShape *sh = *psh;
JSShapeProperty *pr, *prop;
uint32_t hash_mask, new_shape_hash = 0;
intptr_t h;
/* update the shape hash */
if (sh->is_hashed) {
js_shape_hash_unlink(rt, sh);
new_shape_hash = shape_hash(shape_hash(sh->hash, atom), prop_flags);
}
if (unlikely(sh->prop_count >= sh->prop_size)) {
if (resize_properties(ctx, psh, p, sh->prop_count + 1)) {
/* in case of error, reinsert in the hash table.
sh is still valid if resize_properties() failed */
if (sh->is_hashed)
js_shape_hash_link(rt, sh);
return -1;
}
sh = *psh;
}
if (sh->is_hashed) {
sh->hash = new_shape_hash;
js_shape_hash_link(rt, sh);
}
/* Initialize the new shape property.
The object property at p->prop[sh->prop_count] is uninitialized */
prop = get_shape_prop(sh);
pr = &prop[sh->prop_count++];
pr->atom = JS_DupAtom(ctx, atom);
pr->flags = prop_flags;
sh->has_small_array_index |= __JS_AtomIsTaggedInt(atom);
/* add in hash table */
hash_mask = sh->prop_hash_mask;
h = atom & hash_mask;
pr->hash_next = prop_hash_end(sh)[-h - 1];
prop_hash_end(sh)[-h - 1] = sh->prop_count;
return 0;
} | O3 | c | add_shape_property:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movl %ecx, %ebx
movq %rsi, %r15
movq 0x18(%rdi), %r13
movq (%rsi), %r12
cmpb $0x0, 0x18(%r12)
je 0x3cbfe
movl 0x1c(%r12), %eax
xorl %ecx, %ecx
subb 0x184(%r13), %cl
shrl %cl, %eax
shlq $0x3, %rax
addq 0x190(%r13), %rax
movq %rax, %rcx
movq (%rax), %rsi
leaq 0x30(%rsi), %rax
cmpq %r12, %rsi
jne 0x3cbc8
movq 0x30(%r12), %rax
movq %rax, (%rcx)
decl 0x18c(%r13)
movl 0x1c(%r12), %eax
addl %ebx, %eax
imull $0x9e370001, %eax, %eax # imm = 0x9E370001
addl %ebp, %eax
imull $0x9e370001, %eax, %r14d # imm = 0x9E370001
jmp 0x3cc01
xorl %r14d, %r14d
movl 0x28(%r12), %ecx
cmpl 0x24(%r12), %ecx
jge 0x3cccd
cmpb $0x0, 0x18(%r12)
je 0x3cc4c
movl %r14d, 0x1c(%r12)
xorl %ecx, %ecx
subb 0x184(%r13), %cl
shrl %cl, %r14d
movq 0x190(%r13), %rax
movq (%rax,%r14,8), %rax
movq %rax, 0x30(%r12)
movq 0x190(%r13), %rax
movq %r12, (%rax,%r14,8)
incl 0x18c(%r13)
movslq 0x28(%r12), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x28(%r12)
cmpl $0xe0, %ebx
jl 0x3cc71
movq 0x18(%rdi), %rcx
movq 0x68(%rcx), %rcx
movl %ebx, %edx
movq (%rcx,%rdx,8), %rcx
incl (%rcx)
movl %ebx, 0x44(%r12,%rax,8)
shll $0x1a, %ebp
movl $0x3ffffff, %ecx # imm = 0x3FFFFFF
movl 0x40(%r12,%rax,8), %edx
andl %ecx, %edx
orl %ebp, %edx
movl %edx, 0x40(%r12,%rax,8)
movl %ebx, %edx
shrl $0x1f, %edx
orb %dl, 0x19(%r12)
andl 0x20(%r12), %ebx
notq %rbx
andl (%r12,%rbx,4), %ecx
movl $0xfc000000, %edx # imm = 0xFC000000
andl 0x40(%r12,%rax,8), %edx
orl %ecx, %edx
movl %edx, 0x40(%r12,%rax,8)
movl 0x28(%r12), %eax
movl %eax, (%r12,%rbx,4)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
incl %ecx
movq %rdi, (%rsp)
movq %r15, %rsi
callq 0x3cd2c
testl %eax, %eax
je 0x3cd20
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpb $0x0, 0x18(%r12)
je 0x3ccbe
movl 0x1c(%r12), %edx
xorl %ecx, %ecx
subb 0x184(%r13), %cl
shrl %cl, %edx
movq 0x190(%r13), %rcx
movq (%rcx,%rdx,8), %rcx
movq %rcx, 0x30(%r12)
movq 0x190(%r13), %rcx
movq %r12, (%rcx,%rdx,8)
incl 0x18c(%r13)
jmp 0x3ccbe
movq (%r15), %r12
movq (%rsp), %rdi
jmp 0x3cc11
| add_shape_property:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov ebp, r8d
mov ebx, ecx
mov r15, rsi
mov r13, [rdi+18h]
mov r12, [rsi]
cmp byte ptr [r12+18h], 0
jz short loc_3CBFE
mov eax, [r12+1Ch]
xor ecx, ecx
sub cl, [r13+184h]
shr eax, cl
shl rax, 3
add rax, [r13+190h]
loc_3CBC8:
mov rcx, rax
mov rsi, [rax]
lea rax, [rsi+30h]
cmp rsi, r12
jnz short loc_3CBC8
mov rax, [r12+30h]
mov [rcx], rax
dec dword ptr [r13+18Ch]
mov eax, [r12+1Ch]
add eax, ebx
imul eax, 9E370001h
add eax, ebp
imul r14d, eax, 9E370001h
jmp short loc_3CC01
loc_3CBFE:
xor r14d, r14d
loc_3CC01:
mov ecx, [r12+28h]
cmp ecx, [r12+24h]
jge loc_3CCCD
loc_3CC11:
cmp byte ptr [r12+18h], 0
jz short loc_3CC4C
mov [r12+1Ch], r14d
xor ecx, ecx
sub cl, [r13+184h]
shr r14d, cl
mov rax, [r13+190h]
mov rax, [rax+r14*8]
mov [r12+30h], rax
mov rax, [r13+190h]
mov [rax+r14*8], r12
inc dword ptr [r13+18Ch]
loc_3CC4C:
movsxd rax, dword ptr [r12+28h]
lea ecx, [rax+1]
mov [r12+28h], ecx
cmp ebx, 0E0h
jl short loc_3CC71
mov rcx, [rdi+18h]
mov rcx, [rcx+68h]
mov edx, ebx
mov rcx, [rcx+rdx*8]
inc dword ptr [rcx]
loc_3CC71:
mov [r12+rax*8+44h], ebx
shl ebp, 1Ah
mov ecx, 3FFFFFFh
mov edx, [r12+rax*8+40h]
and edx, ecx
or edx, ebp
mov [r12+rax*8+40h], edx
mov edx, ebx
shr edx, 1Fh
or [r12+19h], dl
and ebx, [r12+20h]
not rbx
and ecx, [r12+rbx*4]
mov edx, 0FC000000h
and edx, [r12+rax*8+40h]
or edx, ecx
mov [r12+rax*8+40h], edx
mov eax, [r12+28h]
mov [r12+rbx*4], eax
xor eax, eax
loc_3CCBE:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3CCCD:
inc ecx
mov [rsp+38h+var_38], rdi
mov rsi, r15
call resize_properties
test eax, eax
jz short loc_3CD20
mov eax, 0FFFFFFFFh
cmp byte ptr [r12+18h], 0
jz short loc_3CCBE
mov edx, [r12+1Ch]
xor ecx, ecx
sub cl, [r13+184h]
shr edx, cl
mov rcx, [r13+190h]
mov rcx, [rcx+rdx*8]
mov [r12+30h], rcx
mov rcx, [r13+190h]
mov [rcx+rdx*8], r12
inc dword ptr [r13+18Ch]
jmp short loc_3CCBE
loc_3CD20:
mov r12, [r15]
mov rdi, [rsp+38h+var_38]
jmp loc_3CC11
| long long add_shape_property(long long a1, long long *a2, long long a3, int a4, int a5)
{
long long v8; // r13
long long v9; // r12
_QWORD *v10; // rax
_QWORD *v11; // rcx
long long v12; // rsi
unsigned int v13; // r14d
long long v14; // r14
long long v15; // rax
_DWORD *v16; // rcx
unsigned long long v17; // rbx
long long result; // rax
long long v19; // rdx
v8 = *(_QWORD *)(a1 + 24);
v9 = *a2;
if ( *(_BYTE *)(*a2 + 24) )
{
v10 = (_QWORD *)(*(_QWORD *)(v8 + 400) + 8LL * (unsigned int)(*(_DWORD *)(v9 + 28) >> -*(_BYTE *)(v8 + 388)));
do
{
v11 = v10;
v12 = *v10;
v10 = (_QWORD *)(*v10 + 48LL);
}
while ( v12 != v9 );
*v11 = *(_QWORD *)(v9 + 48);
--*(_DWORD *)(v8 + 396);
v13 = -1640562687 * (a5 - 1640562687 * (a4 + *(_DWORD *)(v9 + 28)));
}
else
{
v13 = 0;
}
if ( *(_DWORD *)(v9 + 40) < *(_DWORD *)(v9 + 36) )
goto LABEL_7;
if ( !(unsigned int)resize_properties(a1, a2, a3) )
{
v9 = *a2;
LABEL_7:
if ( *(_BYTE *)(v9 + 24) )
{
*(_DWORD *)(v9 + 28) = v13;
v14 = v13 >> -*(_BYTE *)(v8 + 388);
*(_QWORD *)(v9 + 48) = *(_QWORD *)(*(_QWORD *)(v8 + 400) + 8 * v14);
*(_QWORD *)(*(_QWORD *)(v8 + 400) + 8 * v14) = v9;
++*(_DWORD *)(v8 + 396);
}
v15 = *(int *)(v9 + 40);
*(_DWORD *)(v9 + 40) = v15 + 1;
if ( a4 >= 224 )
{
v16 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(a1 + 24) + 104LL) + 8LL * (unsigned int)a4);
++*v16;
}
*(_DWORD *)(v9 + 8 * v15 + 68) = a4;
*(_DWORD *)(v9 + 8 * v15 + 64) = (a5 << 26) | *(_DWORD *)(v9 + 8 * v15 + 64) & 0x3FFFFFF;
*(_BYTE *)(v9 + 25) |= a4 < 0;
v17 = ~(unsigned long long)(*(_DWORD *)(v9 + 32) & (unsigned int)a4);
*(_DWORD *)(v9 + 8 * v15 + 64) = *(_DWORD *)(v9 + 4 * v17) & 0x3FFFFFF | *(_DWORD *)(v9 + 8 * v15 + 64) & 0xFC000000;
*(_DWORD *)(v9 + 4 * v17) = *(_DWORD *)(v9 + 40);
return 0LL;
}
result = 0xFFFFFFFFLL;
if ( *(_BYTE *)(v9 + 24) )
{
v19 = (unsigned int)(*(_DWORD *)(v9 + 28) >> -*(_BYTE *)(v8 + 388));
*(_QWORD *)(v9 + 48) = *(_QWORD *)(*(_QWORD *)(v8 + 400) + 8 * v19);
*(_QWORD *)(*(_QWORD *)(v8 + 400) + 8 * v19) = v9;
++*(_DWORD *)(v8 + 396);
}
return result;
}
| add_shape_property:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV EBP,R8D
MOV EBX,ECX
MOV R15,RSI
MOV R13,qword ptr [RDI + 0x18]
MOV R12,qword ptr [RSI]
CMP byte ptr [R12 + 0x18],0x0
JZ 0x0013cbfe
MOV EAX,dword ptr [R12 + 0x1c]
XOR ECX,ECX
SUB CL,byte ptr [R13 + 0x184]
SHR EAX,CL
SHL RAX,0x3
ADD RAX,qword ptr [R13 + 0x190]
LAB_0013cbc8:
MOV RCX,RAX
MOV RSI,qword ptr [RAX]
LEA RAX,[RSI + 0x30]
CMP RSI,R12
JNZ 0x0013cbc8
MOV RAX,qword ptr [R12 + 0x30]
MOV qword ptr [RCX],RAX
DEC dword ptr [R13 + 0x18c]
MOV EAX,dword ptr [R12 + 0x1c]
ADD EAX,EBX
IMUL EAX,EAX,-0x61c8ffff
ADD EAX,EBP
IMUL R14D,EAX,-0x61c8ffff
JMP 0x0013cc01
LAB_0013cbfe:
XOR R14D,R14D
LAB_0013cc01:
MOV ECX,dword ptr [R12 + 0x28]
CMP ECX,dword ptr [R12 + 0x24]
JGE 0x0013cccd
LAB_0013cc11:
CMP byte ptr [R12 + 0x18],0x0
JZ 0x0013cc4c
MOV dword ptr [R12 + 0x1c],R14D
XOR ECX,ECX
SUB CL,byte ptr [R13 + 0x184]
SHR R14D,CL
MOV RAX,qword ptr [R13 + 0x190]
MOV RAX,qword ptr [RAX + R14*0x8]
MOV qword ptr [R12 + 0x30],RAX
MOV RAX,qword ptr [R13 + 0x190]
MOV qword ptr [RAX + R14*0x8],R12
INC dword ptr [R13 + 0x18c]
LAB_0013cc4c:
MOVSXD RAX,dword ptr [R12 + 0x28]
LEA ECX,[RAX + 0x1]
MOV dword ptr [R12 + 0x28],ECX
CMP EBX,0xe0
JL 0x0013cc71
MOV RCX,qword ptr [RDI + 0x18]
MOV RCX,qword ptr [RCX + 0x68]
MOV EDX,EBX
MOV RCX,qword ptr [RCX + RDX*0x8]
INC dword ptr [RCX]
LAB_0013cc71:
MOV dword ptr [R12 + RAX*0x8 + 0x44],EBX
SHL EBP,0x1a
MOV ECX,0x3ffffff
MOV EDX,dword ptr [R12 + RAX*0x8 + 0x40]
AND EDX,ECX
OR EDX,EBP
MOV dword ptr [R12 + RAX*0x8 + 0x40],EDX
MOV EDX,EBX
SHR EDX,0x1f
OR byte ptr [R12 + 0x19],DL
AND EBX,dword ptr [R12 + 0x20]
NOT RBX
AND ECX,dword ptr [R12 + RBX*0x4]
MOV EDX,0xfc000000
AND EDX,dword ptr [R12 + RAX*0x8 + 0x40]
OR EDX,ECX
MOV dword ptr [R12 + RAX*0x8 + 0x40],EDX
MOV EAX,dword ptr [R12 + 0x28]
MOV dword ptr [R12 + RBX*0x4],EAX
XOR EAX,EAX
LAB_0013ccbe:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013cccd:
INC ECX
MOV qword ptr [RSP],RDI
MOV RSI,R15
CALL 0x0013cd2c
TEST EAX,EAX
JZ 0x0013cd20
MOV EAX,0xffffffff
CMP byte ptr [R12 + 0x18],0x0
JZ 0x0013ccbe
MOV EDX,dword ptr [R12 + 0x1c]
XOR ECX,ECX
SUB CL,byte ptr [R13 + 0x184]
SHR EDX,CL
MOV RCX,qword ptr [R13 + 0x190]
MOV RCX,qword ptr [RCX + RDX*0x8]
MOV qword ptr [R12 + 0x30],RCX
MOV RCX,qword ptr [R13 + 0x190]
MOV qword ptr [RCX + RDX*0x8],R12
INC dword ptr [R13 + 0x18c]
JMP 0x0013ccbe
LAB_0013cd20:
MOV R12,qword ptr [R15]
MOV RDI,qword ptr [RSP]
JMP 0x0013cc11
|
int8
add_shape_property(long param_1,long *param_2,int8 param_3,uint param_4,int param_5)
{
long lVar1;
int *piVar2;
long *plVar3;
int iVar4;
long *plVar5;
long lVar6;
ulong uVar7;
long lVar8;
uint uVar9;
lVar6 = *(long *)(param_1 + 0x18);
lVar8 = *param_2;
if (*(char *)(lVar8 + 0x18) == '\0') {
uVar9 = 0;
}
else {
plVar3 = (long *)((ulong)(*(uint *)(lVar8 + 0x1c) >> (-*(char *)(lVar6 + 0x184) & 0x1fU)) * 8 +
*(long *)(lVar6 + 400));
do {
plVar5 = plVar3;
lVar1 = *plVar5;
plVar3 = (long *)(lVar1 + 0x30);
} while (lVar1 != lVar8);
*plVar5 = *(long *)(lVar8 + 0x30);
*(int *)(lVar6 + 0x18c) = *(int *)(lVar6 + 0x18c) + -1;
uVar9 = ((*(int *)(lVar8 + 0x1c) + param_4) * -0x61c8ffff + param_5) * -0x61c8ffff;
}
if (*(int *)(lVar8 + 0x24) <= *(int *)(lVar8 + 0x28)) {
iVar4 = resize_properties(param_1,param_2);
if (iVar4 != 0) {
if (*(char *)(lVar8 + 0x18) == '\0') {
return 0xffffffff;
}
uVar7 = (ulong)(*(uint *)(lVar8 + 0x1c) >> (-*(char *)(lVar6 + 0x184) & 0x1fU));
*(int8 *)(lVar8 + 0x30) = *(int8 *)(*(long *)(lVar6 + 400) + uVar7 * 8);
*(long *)(*(long *)(lVar6 + 400) + uVar7 * 8) = lVar8;
*(int *)(lVar6 + 0x18c) = *(int *)(lVar6 + 0x18c) + 1;
return 0xffffffff;
}
lVar8 = *param_2;
}
if (*(char *)(lVar8 + 0x18) != '\0') {
*(uint *)(lVar8 + 0x1c) = uVar9;
uVar7 = (ulong)(uVar9 >> (-*(char *)(lVar6 + 0x184) & 0x1fU));
*(int8 *)(lVar8 + 0x30) = *(int8 *)(*(long *)(lVar6 + 400) + uVar7 * 8);
*(long *)(*(long *)(lVar6 + 400) + uVar7 * 8) = lVar8;
*(int *)(lVar6 + 0x18c) = *(int *)(lVar6 + 0x18c) + 1;
}
lVar6 = (long)*(int *)(lVar8 + 0x28);
*(int *)(lVar8 + 0x28) = *(int *)(lVar8 + 0x28) + 1;
if (0xdf < (int)param_4) {
piVar2 = *(int **)(*(long *)(*(long *)(param_1 + 0x18) + 0x68) + (ulong)param_4 * 8);
*piVar2 = *piVar2 + 1;
}
*(uint *)(lVar8 + 0x44 + lVar6 * 8) = param_4;
*(uint *)(lVar8 + 0x40 + lVar6 * 8) =
*(uint *)(lVar8 + 0x40 + lVar6 * 8) & 0x3ffffff | param_5 << 0x1a;
*(byte *)(lVar8 + 0x19) = *(byte *)(lVar8 + 0x19) | (byte)(param_4 >> 0x1f);
uVar7 = ~(ulong)(param_4 & *(uint *)(lVar8 + 0x20));
*(uint *)(lVar8 + 0x40 + lVar6 * 8) =
*(uint *)(lVar8 + 0x40 + lVar6 * 8) & 0xfc000000 | *(uint *)(lVar8 + uVar7 * 4) & 0x3ffffff;
*(int4 *)(lVar8 + uVar7 * 4) = *(int4 *)(lVar8 + 0x28);
return 0;
}
| |
52,979 | linenoiseHistoryLoad | ericcurtin[P]linenoise/linenoise.cpp | int linenoiseHistoryLoad(const char * filename) {
File file;
file.open(filename, "r");
char buf[LINENOISE_MAX_LINE];
if (file.file == NULL) {
return -1;
}
while (fgets(buf, LINENOISE_MAX_LINE, file.file) != NULL) {
char * p;
p = strchr(buf, '\r');
if (!p) {
p = strchr(buf, '\n');
}
if (p) {
*p = '\0';
}
linenoiseHistoryAdd(buf);
}
return 0;
} | O0 | cpp | linenoiseHistoryLoad:
pushq %rbp
movq %rsp, %rbp
subq $0x1090, %rsp # imm = 0x1090
movq %rdi, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x69b0
movq -0x10(%rbp), %rax
movq %rax, -0x1080(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x1078(%rbp)
callq 0x2400
movq -0x1080(%rbp), %rsi
movq -0x1078(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x2820
jmp 0x4e1c
leaq 0x7c9b(%rip), %rdx # 0xcabe
leaq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x69d0
jmp 0x4e32
leaq -0x40(%rbp), %rdi
callq 0x2130
leaq -0x41(%rbp), %rdi
callq 0x2220
cmpq $0x0, -0x20(%rbp)
jne 0x4e92
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x1064(%rbp)
jmp 0x4f3f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x4e84
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2130
leaq -0x41(%rbp), %rdi
callq 0x2220
jmp 0x4f54
jmp 0x4e94
movq -0x20(%rbp), %rdx
leaq -0x1060(%rbp), %rdi
movl $0x1000, %esi # imm = 0x1000
callq 0x2370
movq %rax, -0x1088(%rbp)
jmp 0x4eb2
movq -0x1088(%rbp), %rax
cmpq $0x0, %rax
je 0x4f2e
leaq -0x1060(%rbp), %rdi
movl $0xd, %esi
callq 0x20b0
movq %rax, -0x1070(%rbp)
cmpq $0x0, -0x1070(%rbp)
jne 0x4f09
leaq -0x1060(%rbp), %rdi
movl $0xa, %esi
callq 0x20b0
movq %rax, -0x1070(%rbp)
jmp 0x4f09
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x4f54
cmpq $0x0, -0x1070(%rbp)
je 0x4f1d
movq -0x1070(%rbp), %rax
movb $0x0, (%rax)
leaq -0x1060(%rbp), %rdi
callq 0x3ec0
jmp 0x4e94
movl $0x0, -0x4(%rbp)
movl $0x1, -0x1064(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x6a20
movl -0x4(%rbp), %eax
addq $0x1090, %rsp # imm = 0x1090
popq %rbp
retq
leaq -0x20(%rbp), %rdi
callq 0x6a20
movq -0x50(%rbp), %rdi
callq 0x23e0
nopw %cs:(%rax,%rax)
| linenoiseHistoryLoad:
push rbp
mov rbp, rsp
sub rsp, 1090h
mov [rbp+var_10], rdi
lea rdi, [rbp+var_20]; this
call _ZN4FileC2Ev; File::File(void)
mov rax, [rbp+var_10]
mov [rbp+var_1080], rax
lea rdi, [rbp+var_41]
mov [rbp+var_1078], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rsi, [rbp+var_1080]
mov rdx, [rbp+var_1078]
lea rdi, [rbp+var_40]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_4E1C:
lea rdx, aR; "r"
lea rdi, [rbp+var_20]
lea rsi, [rbp+var_40]
call _ZN4File4openERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPKc; File::open(std::string const&,char const*)
jmp short $+2
loc_4E32:
lea rdi, [rbp+var_40]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rbp+var_41]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
cmp [rbp+var_20], 0
jnz short loc_4E92
mov [rbp+var_4], 0FFFFFFFFh
mov [rbp+var_1064], 1
jmp loc_4F3F
mov rcx, rax
mov eax, edx
mov [rbp+var_50], rcx
mov [rbp+var_54], eax
jmp short loc_4E84
mov rcx, rax
mov eax, edx
mov [rbp+var_50], rcx
mov [rbp+var_54], eax
lea rdi, [rbp+var_40]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_4E84:
lea rdi, [rbp+var_41]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp loc_4F54
loc_4E92:
jmp short $+2
loc_4E94:
mov rdx, [rbp+var_20]
lea rdi, [rbp+var_1060]
mov esi, 1000h
call _fgets
mov [rbp+var_1088], rax
jmp short $+2
loc_4EB2:
mov rax, [rbp+var_1088]
cmp rax, 0
jz short loc_4F2E
lea rdi, [rbp+var_1060]
mov esi, 0Dh
call _strchr
mov [rbp+var_1070], rax
cmp [rbp+var_1070], 0
jnz short loc_4F09
lea rdi, [rbp+var_1060]
mov esi, 0Ah
call _strchr
mov [rbp+var_1070], rax
jmp short loc_4F09
mov rcx, rax
mov eax, edx
mov [rbp+var_50], rcx
mov [rbp+var_54], eax
jmp short loc_4F54
loc_4F09:
cmp [rbp+var_1070], 0
jz short loc_4F1D
mov rax, [rbp+var_1070]
mov byte ptr [rax], 0
loc_4F1D:
lea rdi, [rbp+var_1060]
call linenoiseHistoryAdd
jmp loc_4E94
loc_4F2E:
mov [rbp+var_4], 0
mov [rbp+var_1064], 1
loc_4F3F:
lea rdi, [rbp+var_20]; this
call _ZN4FileD2Ev; File::~File()
mov eax, [rbp+var_4]
add rsp, 1090h
pop rbp
retn
loc_4F54:
lea rdi, [rbp+var_20]; this
call _ZN4FileD2Ev; File::~File()
mov rdi, [rbp+var_50]
call __Unwind_Resume
| long long linenoiseHistoryLoad(long long a1)
{
long long v2; // [rsp+10h] [rbp-1080h]
_BYTE *v3; // [rsp+20h] [rbp-1070h]
_BYTE v4[4108]; // [rsp+30h] [rbp-1060h] BYREF
char v5; // [rsp+104Fh] [rbp-41h] BYREF
_BYTE v6[32]; // [rsp+1050h] [rbp-40h] BYREF
_QWORD v7[2]; // [rsp+1070h] [rbp-20h] BYREF
long long v8; // [rsp+1080h] [rbp-10h]
unsigned int v9; // [rsp+108Ch] [rbp-4h]
v8 = a1;
File::File((File *)v7);
v2 = v8;
std::allocator<char>::allocator();
std::string::basic_string<std::allocator<char>>((long long)v6, v2, (long long)&v5);
File::open(v7, v6, "r");
std::string::~string(v6);
std::allocator<char>::~allocator(&v5);
if ( v7[0] )
{
while ( fgets(v4, 4096LL, v7[0]) )
{
v3 = (_BYTE *)strchr(v4, 13LL);
if ( !v3 )
v3 = (_BYTE *)strchr(v4, 10LL);
if ( v3 )
*v3 = 0;
linenoiseHistoryAdd((long long)v4);
}
v9 = 0;
}
else
{
v9 = -1;
}
File::~File((File *)v7);
return v9;
}
| linenoiseHistoryLoad:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x1090
MOV qword ptr [RBP + -0x10],RDI
LEA RDI,[RBP + -0x20]
CALL 0x001069b0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x1080],RAX
LEA RDI,[RBP + -0x41]
MOV qword ptr [RBP + -0x1078],RDI
CALL 0x00102400
MOV RSI,qword ptr [RBP + -0x1080]
MOV RDX,qword ptr [RBP + -0x1078]
LAB_00104e11:
LEA RDI,[RBP + -0x40]
CALL 0x00102820
JMP 0x00104e1c
LAB_00104e1c:
LEA RDX,[0x10cabe]
LEA RDI,[RBP + -0x20]
LEA RSI,[RBP + -0x40]
CALL 0x001069d0
JMP 0x00104e32
LAB_00104e32:
LEA RDI,[RBP + -0x40]
CALL 0x00102130
LEA RDI,[RBP + -0x41]
CALL 0x00102220
CMP qword ptr [RBP + -0x20],0x0
JNZ 0x00104e92
MOV dword ptr [RBP + -0x4],0xffffffff
MOV dword ptr [RBP + -0x1064],0x1
JMP 0x00104f3f
LAB_00104e92:
JMP 0x00104e94
LAB_00104e94:
MOV RDX,qword ptr [RBP + -0x20]
LAB_00104e98:
LEA RDI,[RBP + -0x1060]
MOV ESI,0x1000
CALL 0x00102370
LAB_00104ea9:
MOV qword ptr [RBP + -0x1088],RAX
JMP 0x00104eb2
LAB_00104eb2:
MOV RAX,qword ptr [RBP + -0x1088]
CMP RAX,0x0
JZ 0x00104f2e
LEA RDI,[RBP + -0x1060]
MOV ESI,0xd
CALL 0x001020b0
MOV qword ptr [RBP + -0x1070],RAX
CMP qword ptr [RBP + -0x1070],0x0
JNZ 0x00104f09
LEA RDI,[RBP + -0x1060]
MOV ESI,0xa
CALL 0x001020b0
MOV qword ptr [RBP + -0x1070],RAX
JMP 0x00104f09
LAB_00104f09:
CMP qword ptr [RBP + -0x1070],0x0
JZ 0x00104f1d
MOV RAX,qword ptr [RBP + -0x1070]
MOV byte ptr [RAX],0x0
LAB_00104f1d:
LEA RDI,[RBP + -0x1060]
CALL 0x00103ec0
JMP 0x00104e94
LAB_00104f2e:
MOV dword ptr [RBP + -0x4],0x0
MOV dword ptr [RBP + -0x1064],0x1
LAB_00104f3f:
LEA RDI,[RBP + -0x20]
CALL 0x00106a20
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x1090
POP RBP
RET
|
int4 linenoiseHistoryLoad(char *param_1)
{
char *pcVar1;
char *local_1078;
char local_1068 [4127];
allocator local_49;
string local_48 [32];
FILE *local_28 [2];
char *local_18;
int4 local_c;
local_18 = param_1;
File::File((File *)local_28);
pcVar1 = local_18;
std::allocator<char>::allocator();
/* try { // try from 00104e11 to 00104e19 has its CatchHandler @ 00104e61 */
std::__cxx11::string::string<std::allocator<char>>(local_48,pcVar1,&local_49);
/* try { // try from 00104e1c to 00104e2f has its CatchHandler @ 00104e6f */
File::open((File *)local_28,local_48,"r");
std::__cxx11::string::~string(local_48);
std::allocator<char>::~allocator((allocator<char> *)&local_49);
if (local_28[0] == (FILE *)0x0) {
local_c = 0xffffffff;
}
else {
/* try { // try from 00104e98 to 00104ea8 has its CatchHandler @ 00104efb */
while (pcVar1 = fgets(local_1068,0x1000,local_28[0]), pcVar1 != (char *)0x0) {
local_1078 = strchr(local_1068,0xd);
if (local_1078 == (char *)0x0) {
local_1078 = strchr(local_1068,10);
}
if (local_1078 != (char *)0x0) {
*local_1078 = '\0';
}
linenoiseHistoryAdd(local_1068);
}
local_c = 0;
}
File::~File((File *)local_28);
return local_c;
}
| |
52,980 | linenoiseHistoryLoad | ericcurtin[P]linenoise/linenoise.cpp | int linenoiseHistoryLoad(const char * filename) {
File file;
file.open(filename, "r");
char buf[LINENOISE_MAX_LINE];
if (file.file == NULL) {
return -1;
}
while (fgets(buf, LINENOISE_MAX_LINE, file.file) != NULL) {
char * p;
p = strchr(buf, '\r');
if (!p) {
p = strchr(buf, '\n');
}
if (p) {
*p = '\0';
}
linenoiseHistoryAdd(buf);
}
return 0;
} | O2 | cpp | linenoiseHistoryLoad:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1020, %rsp # imm = 0x1020
andq $0x0, 0x10(%rsp)
movq %rdi, %rsi
orl $-0x1, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x25a0
leaq 0x20(%rsp), %rbx
movq (%rbx), %rdi
leaq 0x5c87(%rip), %rsi # 0x98c3
callq 0x21f0
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
callq 0x20d0
movq 0x10(%rsp), %rdx
testq %rdx, %rdx
je 0x3cab
leaq 0x20(%rsp), %rbx
pushq $0xd
popq %rbp
pushq $0xa
popq %r14
movq %rbx, %rdi
movl $0x1000, %esi # imm = 0x1000
callq 0x22e0
testq %rax, %rax
je 0x3ca7
movq %rbx, %rdi
movl %ebp, %esi
callq 0x20a0
testq %rax, %rax
jne 0x3c95
movq %rbx, %rdi
movl %r14d, %esi
callq 0x20a0
testq %rax, %rax
je 0x3c98
movb $0x0, (%rax)
movq %rbx, %rdi
callq 0x2f66
movq 0x10(%rsp), %rdx
jmp 0x3c64
xorl %ebx, %ebx
jmp 0x3cae
pushq $-0x1
popq %rbx
leaq 0x10(%rsp), %rdi
callq 0x4592
movl %ebx, %eax
addq $0x1020, %rsp # imm = 0x1020
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4592
movq %rbx, %rdi
callq 0x2330
| linenoiseHistoryLoad:
push rbp
push r14
push rbx
sub rsp, 1020h
and [rsp+1038h+var_1028], 0
mov rsi, rdi
or [rsp+1038h+var_1020], 0FFFFFFFFh
lea rdi, [rsp+1038h+var_1018]
lea rdx, [rsp+1038h+var_1029]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rbx, [rsp+1038h+var_1018]
mov rdi, [rbx]
lea rsi, aR; "r"
call _fopen
mov [rsp+1038h+var_1028], rax
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdx, [rsp+1038h+var_1028]
test rdx, rdx
jz short loc_3CAB
lea rbx, [rsp+1038h+var_1018]
push 0Dh
pop rbp
push 0Ah
pop r14
loc_3C64:
mov rdi, rbx
mov esi, 1000h
call _fgets
test rax, rax
jz short loc_3CA7
mov rdi, rbx
mov esi, ebp
call _strchr
test rax, rax
jnz short loc_3C95
mov rdi, rbx
mov esi, r14d
call _strchr
test rax, rax
jz short loc_3C98
loc_3C95:
mov byte ptr [rax], 0
loc_3C98:
mov rdi, rbx
call linenoiseHistoryAdd
mov rdx, [rsp+1038h+var_1028]
jmp short loc_3C64
loc_3CA7:
xor ebx, ebx
jmp short loc_3CAE
loc_3CAB:
push 0FFFFFFFFFFFFFFFFh
pop rbx
loc_3CAE:
lea rdi, [rsp+1038h+var_1028]; this
call _ZN4FileD2Ev; File::~File()
mov eax, ebx
add rsp, 1020h
pop rbx
pop r14
pop rbp
retn
mov rbx, rax
lea rdi, [rsp+arg_8]; this
call _ZN4FileD2Ev; File::~File()
mov rdi, rbx
call __Unwind_Resume
| long long linenoiseHistoryLoad(long long a1)
{
long long v1; // rdx
_BYTE *v2; // rax
unsigned int v3; // ebx
long long v5; // [rsp+10h] [rbp-1028h] BYREF
int v6; // [rsp+18h] [rbp-1020h]
_QWORD v7[515]; // [rsp+20h] [rbp-1018h] BYREF
v6 = -1;
std::string::basic_string<std::allocator<char>>(v7, a1);
v5 = fopen(v7[0], "r");
std::string::~string(v7);
v1 = v5;
if ( v5 )
{
while ( fgets(v7, 4096LL, v1) )
{
v2 = (_BYTE *)strchr(v7, 13LL);
if ( v2 || (v2 = (_BYTE *)strchr(v7, 10LL)) != 0LL )
*v2 = 0;
linenoiseHistoryAdd((long long)v7);
v1 = v5;
}
v3 = 0;
}
else
{
v3 = -1;
}
File::~File((File *)&v5);
return v3;
}
| linenoiseHistoryLoad:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x1020
AND qword ptr [RSP + 0x10],0x0
MOV RSI,RDI
OR dword ptr [RSP + 0x18],0xffffffff
LAB_00103c1e:
LEA RDI,[RSP + 0x20]
LEA RDX,[RSP + 0xf]
CALL 0x001025a0
LAB_00103c2d:
LEA RBX,[RSP + 0x20]
MOV RDI,qword ptr [RBX]
LEA RSI,[0x1098c3]
CALL 0x001021f0
MOV qword ptr [RSP + 0x10],RAX
MOV RDI,RBX
CALL 0x001020d0
MOV RDX,qword ptr [RSP + 0x10]
TEST RDX,RDX
JZ 0x00103cab
LEA RBX,[RSP + 0x20]
PUSH 0xd
POP RBP
PUSH 0xa
POP R14
LAB_00103c64:
MOV RDI,RBX
MOV ESI,0x1000
CALL 0x001022e0
TEST RAX,RAX
JZ 0x00103ca7
MOV RDI,RBX
MOV ESI,EBP
CALL 0x001020a0
TEST RAX,RAX
JNZ 0x00103c95
MOV RDI,RBX
MOV ESI,R14D
CALL 0x001020a0
TEST RAX,RAX
JZ 0x00103c98
LAB_00103c95:
MOV byte ptr [RAX],0x0
LAB_00103c98:
MOV RDI,RBX
CALL 0x00102f66
MOV RDX,qword ptr [RSP + 0x10]
JMP 0x00103c64
LAB_00103ca7:
XOR EBX,EBX
JMP 0x00103cae
LAB_00103cab:
PUSH -0x1
POP RBX
LAB_00103cae:
LEA RDI,[RSP + 0x10]
CALL 0x00104592
MOV EAX,EBX
ADD RSP,0x1020
POP RBX
POP R14
POP RBP
RET
|
int4 linenoiseHistoryLoad(char *param_1)
{
char *pcVar1;
int4 uVar2;
allocator local_1029;
FILE *local_1028;
int4 local_1020;
char *local_1018 [512];
local_1028 = (FILE *)0x0;
local_1020 = 0xffffffff;
/* try { // try from 00103c1e to 00103c2c has its CatchHandler @ 00103cc6 */
std::__cxx11::string::string<std::allocator<char>>((string *)local_1018,param_1,&local_1029);
local_1028 = fopen(local_1018[0],"r");
std::__cxx11::string::~string((string *)local_1018);
if (local_1028 == (FILE *)0x0) {
uVar2 = 0xffffffff;
}
else {
while( true ) {
pcVar1 = fgets((char *)local_1018,0x1000,local_1028);
if (pcVar1 == (char *)0x0) break;
pcVar1 = strchr((char *)local_1018,0xd);
if (pcVar1 == (char *)0x0) {
pcVar1 = strchr((char *)local_1018,10);
if (pcVar1 != (char *)0x0) goto LAB_00103c95;
}
else {
LAB_00103c95:
*pcVar1 = '\0';
}
linenoiseHistoryAdd(local_1018);
}
uVar2 = 0;
}
File::~File((File *)&local_1028);
return uVar2;
}
| |
52,981 | Catch::Singleton<Catch::(anonymous namespace)::RegistryHub, Catch::IRegistryHub, Catch::IMutableRegistryHub>::getInternal() | AlayaLite/build_O3/_deps/libcoro-src/test/catch_amalgamated.hpp | static auto getInternal() -> Singleton* {
static Singleton* s_instance = nullptr;
if( !s_instance ) {
s_instance = new Singleton;
addSingleton( s_instance );
}
return s_instance;
} | O3 | cpp | Catch::Singleton<Catch::(anonymous namespace)::RegistryHub, Catch::IRegistryHub, Catch::IMutableRegistryHub>::getInternal():
pushq %rbx
movq %rdi, %rbx
leaq 0xbc05f(%rip), %rax # 0x12f820
movq %rax, (%rdi)
leaq 0xbc0d5(%rip), %rax # 0x12f8a0
movq %rax, 0x8(%rdi)
leaq 0xbb7ca(%rip), %rax # 0x12efa0
addq $0x10, %rax
movq %rax, 0x158(%rdi)
addq $0x160, %rdi # imm = 0x160
callq 0x806fe
leaq 0x140(%rbx), %rdi
callq 0x81ca8
leaq 0x108(%rbx), %rdi
callq 0x6141c
leaq 0xe8(%rbx), %rdi
callq 0x5c530
leaq 0x98(%rbx), %rdi
callq 0x5d576
leaq 0x10(%rbx), %rdi
callq 0x7a55e
movl $0x180, %esi # imm = 0x180
movq %rbx, %rdi
popq %rbx
jmp 0x17150
| _ZN5Catch9SingletonINS_12_GLOBAL__N_111RegistryHubENS_12IRegistryHubENS_19IMutableRegistryHubEED0Ev:
push rbx
mov rbx, rdi
lea rax, off_12F820
mov [rdi], rax
lea rax, off_12F8A0
mov [rdi+8], rax
lea rax, _ZTVN5Catch6Detail18EnumValuesRegistryE; `vtable for'Catch::Detail::EnumValuesRegistry
add rax, 10h
mov [rdi+158h], rax
add rdi, 160h
call _ZNSt6vectorIN5Catch6Detail10unique_ptrINS1_8EnumInfoEEESaIS4_EED2Ev; std::vector<Catch::Detail::unique_ptr<Catch::Detail::EnumInfo>>::~vector()
lea rdi, [rbx+140h]
call _ZNSt6vectorINSt15__exception_ptr13exception_ptrESaIS1_EED2Ev; std::vector<std::__exception_ptr::exception_ptr>::~vector()
lea rdi, [rbx+108h]; this
call _ZN5Catch16TagAliasRegistryD2Ev; Catch::TagAliasRegistry::~TagAliasRegistry()
lea rdi, [rbx+0E8h]; this
call _ZN5Catch27ExceptionTranslatorRegistryD2Ev; Catch::ExceptionTranslatorRegistry::~ExceptionTranslatorRegistry()
lea rdi, [rbx+98h]; this
call _ZN5Catch16ReporterRegistryD2Ev; Catch::ReporterRegistry::~ReporterRegistry()
lea rdi, [rbx+10h]; this
call _ZN5Catch12TestRegistryD2Ev; Catch::TestRegistry::~TestRegistry()
mov esi, 180h; unsigned __int64
mov rdi, rbx; void *
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
| void Catch::Singleton<Catch::`anonymous namespace'::RegistryHub,Catch::IRegistryHub,Catch::IMutableRegistryHub>::~Singleton(
_QWORD *a1)
{
*a1 = off_12F820;
a1[1] = off_12F8A0;
a1[43] = &`vtable for'Catch::Detail::EnumValuesRegistry + 2;
std::vector<Catch::Detail::unique_ptr<Catch::Detail::EnumInfo>>::~vector(a1 + 44);
std::vector<std::__exception_ptr::exception_ptr>::~vector(a1 + 40);
Catch::TagAliasRegistry::~TagAliasRegistry((Catch::TagAliasRegistry *)(a1 + 33));
Catch::ExceptionTranslatorRegistry::~ExceptionTranslatorRegistry((Catch::ExceptionTranslatorRegistry *)(a1 + 29));
Catch::ReporterRegistry::~ReporterRegistry((Catch::ReporterRegistry *)(a1 + 19));
Catch::TestRegistry::~TestRegistry((Catch::TestRegistry *)(a1 + 2));
operator delete(a1, 0x180uLL);
}
| ~Singleton:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x22f820]
MOV qword ptr [RDI],RAX
LEA RAX,[0x22f8a0]
MOV qword ptr [RDI + 0x8],RAX
LEA RAX,[0x22efa0]
ADD RAX,0x10
MOV qword ptr [RDI + 0x158],RAX
ADD RDI,0x160
CALL 0x001806fe
LEA RDI,[RBX + 0x140]
CALL 0x00181ca8
LEA RDI,[RBX + 0x108]
CALL 0x0016141c
LEA RDI,[RBX + 0xe8]
CALL 0x0015c530
LEA RDI,[RBX + 0x98]
CALL 0x0015d576
LEA RDI,[RBX + 0x10]
CALL 0x0017a55e
MOV ESI,0x180
MOV RDI,RBX
POP RBX
JMP 0x00117150
|
/* Catch::Singleton<Catch::(anonymous namespace)::RegistryHub, Catch::IRegistryHub,
Catch::IMutableRegistryHub>::~Singleton() */
void __thiscall
Catch::
Singleton<Catch::(anonymous_namespace)::RegistryHub,Catch::IRegistryHub,Catch::IMutableRegistryHub>
::~Singleton(Singleton<Catch::(anonymous_namespace)::RegistryHub,Catch::IRegistryHub,Catch::IMutableRegistryHub>
*this)
{
*(int ***)this = &PTR__RegistryHub_0022f820;
*(int ***)(this + 8) = &PTR__RegistryHub_0022f8a0;
*(int ***)(this + 0x158) = &PTR__EnumValuesRegistry_0022efb0;
std::
vector<Catch::Detail::unique_ptr<Catch::Detail::EnumInfo>,std::allocator<Catch::Detail::unique_ptr<Catch::Detail::EnumInfo>>>
::~vector((vector<Catch::Detail::unique_ptr<Catch::Detail::EnumInfo>,std::allocator<Catch::Detail::unique_ptr<Catch::Detail::EnumInfo>>>
*)(this + 0x160));
std::
vector<std::__exception_ptr::exception_ptr,std::allocator<std::__exception_ptr::exception_ptr>>::
~vector((vector<std::__exception_ptr::exception_ptr,std::allocator<std::__exception_ptr::exception_ptr>>
*)(this + 0x140));
TagAliasRegistry::~TagAliasRegistry((TagAliasRegistry *)(this + 0x108));
ExceptionTranslatorRegistry::~ExceptionTranslatorRegistry
((ExceptionTranslatorRegistry *)(this + 0xe8));
ReporterRegistry::~ReporterRegistry((ReporterRegistry *)(this + 0x98));
TestRegistry::~TestRegistry((TestRegistry *)(this + 0x10));
operator_delete(this,0x180);
return;
}
| |
52,982 | write_rest_of_head | eloqsql/storage/maria/ma_bitmap.c | static my_bool write_rest_of_head(MARIA_HA *info, uint position,
ulong rest_length)
{
MARIA_SHARE *share= info->s;
uint full_page_size= FULL_PAGE_SIZE(share);
MARIA_BITMAP_BLOCK *block;
DBUG_ENTER("write_rest_of_head");
DBUG_PRINT("enter", ("position: %u rest_length: %lu", position,
rest_length));
if (position == 0)
{
/* Write out full pages */
uint pages= rest_length / full_page_size;
rest_length%= full_page_size;
if (rest_length >= MAX_TAIL_SIZE(share->block_size))
{
/* Put tail on a full page */
pages++;
rest_length= 0;
}
if (find_mid(info, pages, 1))
DBUG_RETURN(1);
/*
Insert empty block after full pages, to allow write_block_record() to
split segment into used + free page
*/
block= dynamic_element(&info->bitmap_blocks, 2, MARIA_BITMAP_BLOCK*);
block->page_count= 0;
block->used= 0;
}
if (rest_length)
{
if (find_tail(info, rest_length, ELEMENTS_RESERVED_FOR_MAIN_PART - 1))
DBUG_RETURN(1);
}
else
{
/* Empty tail block */
block= dynamic_element(&info->bitmap_blocks,
ELEMENTS_RESERVED_FOR_MAIN_PART - 1,
MARIA_BITMAP_BLOCK *);
block->page_count= 0;
block->used= 0;
}
DBUG_RETURN(0);
} | O0 | c | write_rest_of_head:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x7bc(%rax), %eax
movq -0x28(%rbp), %rcx
movl 0xc18(%rcx), %ecx
addl $0x8, %ecx
subl %ecx, %eax
subl $0x4, %eax
movl %eax, -0x2c(%rbp)
jmp 0x441af
cmpl $0x0, -0x14(%rbp)
jne 0x44249
movq -0x20(%rbp), %rax
movl -0x2c(%rbp), %ecx
xorl %edx, %edx
divq %rcx
movl %eax, -0x3c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, %ecx
movq -0x20(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
imull $0x3, 0x7bc(%rcx), %ecx
shrl $0x2, %ecx
movl %ecx, %ecx
cmpq %rcx, %rax
jb 0x44204
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x3c(%rbp), %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x46aa0
cmpb $0x0, %al
je 0x44223
jmp 0x4421d
movb $0x1, -0x1(%rbp)
jmp 0x4429e
movq -0x10(%rbp), %rax
movq 0x2c0(%rax), %rax
addq $0x30, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x38(%rbp), %rax
movb $0x0, 0x14(%rax)
cmpq $0x0, -0x20(%rbp)
je 0x44272
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %esi
movl $0x3, %edx
callq 0x46780
cmpb $0x0, %al
je 0x44270
jmp 0x4426a
movb $0x1, -0x1(%rbp)
jmp 0x4429e
jmp 0x44298
movq -0x10(%rbp), %rax
movq 0x2c0(%rax), %rax
addq $0x48, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x38(%rbp), %rax
movb $0x0, 0x14(%rax)
jmp 0x4429a
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| write_rest_of_head:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
mov eax, [rax+7BCh]
mov rcx, [rbp+var_28]
mov ecx, [rcx+0C18h]
add ecx, 8
sub eax, ecx
sub eax, 4
mov [rbp+var_2C], eax
jmp short $+2
loc_441AF:
cmp [rbp+var_14], 0
jnz loc_44249
mov rax, [rbp+var_20]
mov ecx, [rbp+var_2C]
xor edx, edx
div rcx
mov [rbp+var_3C], eax
mov eax, [rbp+var_2C]
mov ecx, eax
mov rax, [rbp+var_20]
xor edx, edx
div rcx
mov [rbp+var_20], rdx
mov rax, [rbp+var_20]
mov rcx, [rbp+var_28]
imul ecx, [rcx+7BCh], 3
shr ecx, 2
mov ecx, ecx
cmp rax, rcx
jb short loc_44204
mov eax, [rbp+var_3C]
add eax, 1
mov [rbp+var_3C], eax
mov [rbp+var_20], 0
loc_44204:
mov rdi, [rbp+var_10]
mov eax, [rbp+var_3C]
mov esi, eax
mov edx, 1
call find_mid
cmp al, 0
jz short loc_44223
jmp short $+2
loc_4421D:
mov [rbp+var_1], 1
jmp short loc_4429E
loc_44223:
mov rax, [rbp+var_10]
mov rax, [rax+2C0h]
add rax, 30h ; '0'
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov dword ptr [rax+8], 0
mov rax, [rbp+var_38]
mov byte ptr [rax+14h], 0
loc_44249:
cmp [rbp+var_20], 0
jz short loc_44272
mov rdi, [rbp+var_10]
mov rax, [rbp+var_20]
mov esi, eax
mov edx, 3
call find_tail
cmp al, 0
jz short loc_44270
jmp short $+2
loc_4426A:
mov [rbp+var_1], 1
jmp short loc_4429E
loc_44270:
jmp short loc_44298
loc_44272:
mov rax, [rbp+var_10]
mov rax, [rax+2C0h]
add rax, 48h ; 'H'
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov dword ptr [rax+8], 0
mov rax, [rbp+var_38]
mov byte ptr [rax+14h], 0
loc_44298:
jmp short $+2
loc_4429A:
mov [rbp+var_1], 0
loc_4429E:
mov al, [rbp+var_1]
add rsp, 40h
pop rbp
retn
| char write_rest_of_head(_QWORD *a1, int a2, unsigned long long a3)
{
long long v3; // rax
long long v4; // rax
unsigned int v6; // [rsp+4h] [rbp-3Ch]
unsigned int v7; // [rsp+14h] [rbp-2Ch]
unsigned long long v8; // [rsp+20h] [rbp-20h]
v8 = a3;
v7 = *(_DWORD *)(*a1 + 1980LL) - (*(_DWORD *)(*a1 + 3096LL) + 8) - 4;
if ( a2 )
{
LABEL_7:
if ( v8 )
{
if ( (unsigned __int8)find_tail(a1, (unsigned int)v8, 3LL) )
return 1;
}
else
{
v4 = a1[88];
*(_DWORD *)(v4 + 80) = 0;
*(_BYTE *)(v4 + 92) = 0;
}
return 0;
}
v6 = a3 / v7;
v8 = a3 % v7;
if ( v8 >= (unsigned int)(3 * *(_DWORD *)(*a1 + 1980LL)) >> 2 )
{
++v6;
v8 = 0LL;
}
if ( !(unsigned __int8)find_mid(a1, v6, 1LL) )
{
v3 = a1[88];
*(_DWORD *)(v3 + 56) = 0;
*(_BYTE *)(v3 + 68) = 0;
goto LABEL_7;
}
return 1;
}
| write_rest_of_head:
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 RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX + 0x7bc]
MOV RCX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RCX + 0xc18]
ADD ECX,0x8
SUB EAX,ECX
SUB EAX,0x4
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x001441af
LAB_001441af:
CMP dword ptr [RBP + -0x14],0x0
JNZ 0x00144249
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x2c]
XOR EDX,EDX
DIV RCX
MOV dword ptr [RBP + -0x3c],EAX
MOV EAX,dword ptr [RBP + -0x2c]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x20]
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x28]
IMUL ECX,dword ptr [RCX + 0x7bc],0x3
SHR ECX,0x2
MOV ECX,ECX
CMP RAX,RCX
JC 0x00144204
MOV EAX,dword ptr [RBP + -0x3c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x3c],EAX
MOV qword ptr [RBP + -0x20],0x0
LAB_00144204:
MOV RDI,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x3c]
MOV ESI,EAX
MOV EDX,0x1
CALL 0x00146aa0
CMP AL,0x0
JZ 0x00144223
JMP 0x0014421d
LAB_0014421d:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0014429e
LAB_00144223:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x2c0]
ADD RAX,0x30
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x8],0x0
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX + 0x14],0x0
LAB_00144249:
CMP qword ptr [RBP + -0x20],0x0
JZ 0x00144272
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x20]
MOV ESI,EAX
MOV EDX,0x3
CALL 0x00146780
CMP AL,0x0
JZ 0x00144270
JMP 0x0014426a
LAB_0014426a:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0014429e
LAB_00144270:
JMP 0x00144298
LAB_00144272:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x2c0]
ADD RAX,0x48
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x8],0x0
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX + 0x14],0x0
LAB_00144298:
JMP 0x0014429a
LAB_0014429a:
MOV byte ptr [RBP + -0x1],0x0
LAB_0014429e:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x40
POP RBP
RET
|
int1 write_rest_of_head(long *param_1,int param_2,ulong param_3)
{
long lVar1;
char cVar2;
uint uVar3;
int local_44;
ulong local_28;
lVar1 = *param_1;
uVar3 = (*(int *)(lVar1 + 0x7bc) - (*(int *)(lVar1 + 0xc18) + 8)) - 4;
local_28 = param_3;
if (param_2 == 0) {
local_44 = (int)(param_3 / uVar3);
local_28 = param_3 % (ulong)uVar3;
if ((uint)(*(int *)(lVar1 + 0x7bc) * 3) >> 2 <= local_28) {
local_44 = local_44 + 1;
local_28 = 0;
}
cVar2 = find_mid(param_1,local_44,1);
if (cVar2 != '\0') {
return 1;
}
lVar1 = param_1[0x58];
*(int4 *)(lVar1 + 0x38) = 0;
*(int1 *)(lVar1 + 0x44) = 0;
}
if (local_28 == 0) {
lVar1 = param_1[0x58];
*(int4 *)(lVar1 + 0x50) = 0;
*(int1 *)(lVar1 + 0x5c) = 0;
}
else {
cVar2 = find_tail(param_1,local_28 & 0xffffffff,3);
if (cVar2 != '\0') {
return 1;
}
}
return 0;
}
| |
52,983 | my_malloc | eloqsql/mysys/my_malloc.c | void *my_malloc(PSI_memory_key key, size_t size, myf my_flags)
{
my_memory_header *mh;
void *point;
DBUG_ENTER("my_malloc");
DBUG_PRINT("my",("size: %zu flags: %lu", size, my_flags));
compile_time_assert(sizeof(my_memory_header) <= HEADER_SIZE);
if (!(my_flags & (MY_WME | MY_FAE)))
my_flags|= my_global_flags;
/* Safety */
if (!size)
size=1;
if (size > SIZE_T_MAX - 1024L*1024L*16L) /* Wrong call */
DBUG_RETURN(0);
/* We have to align size as we store MY_THREAD_SPECIFIC flag in the LSB */
size= ALIGN_SIZE(size);
if (DBUG_EVALUATE_IF("simulate_out_of_memory", 1, 0))
mh= NULL;
else
mh= (my_memory_header*) sf_malloc(size + HEADER_SIZE, my_flags);
if (mh == NULL)
{
my_errno=errno;
if (my_flags & MY_FAE)
error_handler_hook=fatal_error_handler_hook;
if (my_flags & (MY_FAE+MY_WME))
my_error(EE_OUTOFMEMORY, MYF(ME_BELL+ME_ERROR_LOG+ME_FATAL),size);
if (my_flags & MY_FAE)
abort();
point= NULL;
}
else
{
int flag= MY_TEST(my_flags & MY_THREAD_SPECIFIC);
mh->m_size= size | flag;
mh->m_key= PSI_CALL_memory_alloc(key, size, & mh->m_owner);
update_malloc_size(size + HEADER_SIZE, flag);
point= HEADER_TO_USER(mh);
if (my_flags & MY_ZEROFILL)
bzero(point, size);
else
TRASH_ALLOC(point, size);
}
DBUG_PRINT("exit",("ptr: %p", point));
DBUG_RETURN(point);
} | O3 | c | my_malloc:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r13d
xorl %r14d, %r14d
movl $0x0, %r15d
testb $0x18, %dl
jne 0x2c9c1
leaq 0x33c77a(%rip), %rax # 0x369138
movq (%rax), %r15
cmpq $-0x1000001, %rbx # imm = 0xFEFFFFFF
ja 0x2caa1
orq %rdx, %r15
cmpq $0x1, %rbx
adcq $0x7, %rbx
andq $-0x8, %rbx
leaq 0x18(%rbx), %r12
movq %r12, %rdi
callq 0x24410
testq %rax, %rax
je 0x2ca54
movq %rax, %r14
movl %r13d, %edi
movl %r15d, %r13d
shrl $0x10, %r13d
andl $0x1, %r13d
movq %rbx, %rax
orq %r13, %rax
movq %rax, 0x8(%r14)
leaq 0x2c5e10(%rip), %rax # 0x2f2820
movq (%rax), %rax
movq %rbx, %rsi
movq %r14, %rdx
callq *0x3e0(%rax)
movl %eax, 0x10(%r14)
movq %r12, %rdi
movl %r13d, %esi
callq *0x2c5f69(%rip) # 0x2f2998
addq $0x18, %r14
testb $0x20, %r15b
je 0x2caa1
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 0x24180
callq 0x24060
movl (%rax), %r14d
callq 0x268a6
movl %r14d, (%rax)
testb $0x8, %r15b
je 0x2ca7e
leaq 0x2c5917(%rip), %rax # 0x2f2388
movq (%rax), %rax
leaq 0x2c5905(%rip), %rcx # 0x2f2380
movq %rax, (%rcx)
testb $0x18, %r15b
je 0x2ca98
movl $0x1044, %esi # imm = 0x1044
movl $0x5, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2bf8b
testb $0x8, %r15b
jne 0x2cab3
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x24190
| my_malloc:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rsi
mov r13d, edi
xor r14d, r14d
mov r15d, 0
test dl, 18h
jnz short loc_2C9C1
lea rax, my_global_flags
mov r15, [rax]
loc_2C9C1:
cmp rbx, 0FFFFFFFFFEFFFFFFh
ja loc_2CAA1
or r15, rdx
cmp rbx, 1
adc rbx, 7
and rbx, 0FFFFFFFFFFFFFFF8h
lea r12, [rbx+18h]
mov rdi, r12
call _malloc
test rax, rax
jz short loc_2CA54
mov r14, rax
mov edi, r13d
mov r13d, r15d
shr r13d, 10h
and r13d, 1
mov rax, rbx
or rax, r13
mov [r14+8], rax
lea rax, PSI_server
mov rax, [rax]
mov rsi, rbx
mov rdx, r14
call qword ptr [rax+3E0h]
mov [r14+10h], eax
mov rdi, r12
mov esi, r13d
call cs:update_malloc_size
add r14, 18h
test r15b, 20h
jz short loc_2CAA1
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_2CA54:
call ___errno_location
mov r14d, [rax]
call _my_thread_var
mov [rax], r14d
test r15b, 8
jz short loc_2CA7E
lea rax, fatal_error_handler_hook
mov rax, [rax]
lea rcx, error_handler_hook
mov [rcx], rax
loc_2CA7E:
test r15b, 18h
jz short loc_2CA98
mov esi, 1044h
mov edi, 5
mov rdx, rbx
xor eax, eax
call my_error
loc_2CA98:
test r15b, 8
jnz short loc_2CAB3
xor r14d, r14d
loc_2CAA1:
mov rax, r14
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_2CAB3:
call _abort
| long long my_malloc(unsigned int a1, unsigned long long a2, int a3)
{
long long v4; // r14
int v5; // r15d
unsigned int v6; // r15d
unsigned long long v7; // rbx
long long v8; // rdi
long long v9; // rax
long long v10; // r14
int v12; // r14d
v4 = 0LL;
v5 = 0;
if ( (a3 & 0x18) == 0 )
v5 = my_global_flags;
if ( a2 <= 0xFFFFFFFFFEFFFFFFLL )
{
v6 = a3 | v5;
v7 = ((a2 == 0) + a2 + 7) & 0xFFFFFFFFFFFFFFF8LL;
v8 = v7 + 24;
v9 = malloc(v7 + 24);
if ( v9 )
{
v10 = v9;
*(_QWORD *)(v9 + 8) = HIWORD(v6) & 1 | v7;
*(_DWORD *)(v9 + 16) = (*((long long ( **)(_QWORD, unsigned long long, long long))PSI_server[0] + 124))(
a1,
v7,
v9);
update_malloc_size[0]();
v4 = v10 + 24;
if ( (v6 & 0x20) != 0 )
return memset(v4, 0LL, v7);
}
else
{
v12 = *(_DWORD *)__errno_location(v8);
*(_DWORD *)my_thread_var() = v12;
if ( (v6 & 8) != 0 )
error_handler_hook = (long long ( *)(long long, long long, __int16))fatal_error_handler_hook[0];
if ( (v6 & 0x18) != 0 )
{
v8 = 5LL;
my_error(5u, 4164, v7);
}
if ( (v6 & 8) != 0 )
abort(v8);
return 0LL;
}
}
return v4;
}
| my_malloc:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R13D,EDI
XOR R14D,R14D
MOV R15D,0x0
TEST DL,0x18
JNZ 0x0012c9c1
LEA RAX,[0x469138]
MOV R15,qword ptr [RAX]
LAB_0012c9c1:
CMP RBX,-0x1000001
JA 0x0012caa1
OR R15,RDX
CMP RBX,0x1
ADC RBX,0x7
AND RBX,-0x8
LEA R12,[RBX + 0x18]
MOV RDI,R12
CALL 0x00124410
TEST RAX,RAX
JZ 0x0012ca54
MOV R14,RAX
MOV EDI,R13D
MOV R13D,R15D
SHR R13D,0x10
AND R13D,0x1
MOV RAX,RBX
OR RAX,R13
MOV qword ptr [R14 + 0x8],RAX
LEA RAX,[0x3f2820]
MOV RAX,qword ptr [RAX]
MOV RSI,RBX
MOV RDX,R14
CALL qword ptr [RAX + 0x3e0]
MOV dword ptr [R14 + 0x10],EAX
MOV RDI,R12
MOV ESI,R13D
CALL qword ptr [0x003f2998]
ADD R14,0x18
TEST R15B,0x20
JZ 0x0012caa1
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 0x00124180
LAB_0012ca54:
CALL 0x00124060
MOV R14D,dword ptr [RAX]
CALL 0x001268a6
MOV dword ptr [RAX],R14D
TEST R15B,0x8
JZ 0x0012ca7e
LEA RAX,[0x3f2388]
MOV RAX,qword ptr [RAX]
LEA RCX,[0x3f2380]
MOV qword ptr [RCX],RAX
LAB_0012ca7e:
TEST R15B,0x18
JZ 0x0012ca98
MOV ESI,0x1044
MOV EDI,0x5
MOV RDX,RBX
XOR EAX,EAX
CALL 0x0012bf8b
LAB_0012ca98:
TEST R15B,0x8
JNZ 0x0012cab3
XOR R14D,R14D
LAB_0012caa1:
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0012cab3:
CALL 0x00124190
|
void * my_malloc(int4 param_1,ulong param_2,ulong param_3)
{
int iVar1;
int4 uVar2;
void *pvVar3;
int *piVar4;
ulong __n;
ulong uVar5;
pvVar3 = (void *)0x0;
uVar5 = 0;
if ((param_3 & 0x18) == 0) {
uVar5 = my_global_flags;
}
if (param_2 < 0xffffffffff000000) {
uVar5 = uVar5 | param_3;
__n = param_2 + 7 + (ulong)(param_2 == 0) & 0xfffffffffffffff8;
pvVar3 = malloc(__n + 0x18);
if (pvVar3 == (void *)0x0) {
piVar4 = __errno_location();
iVar1 = *piVar4;
piVar4 = (int *)_my_thread_var();
*piVar4 = iVar1;
if ((uVar5 & 8) != 0) {
error_handler_hook = fatal_error_handler_hook;
}
if ((uVar5 & 0x18) != 0) {
my_error(5,0x1044,__n);
}
if ((uVar5 & 8) != 0) {
/* WARNING: Subroutine does not return */
abort();
}
pvVar3 = (void *)0x0;
}
else {
*(ulong *)((long)pvVar3 + 8) = __n | (uint)(uVar5 >> 0x10) & 1;
uVar2 = (**(code **)(PSI_server + 0x3e0))(param_1,__n,pvVar3);
*(int4 *)((long)pvVar3 + 0x10) = uVar2;
(*(code *)update_malloc_size)(__n + 0x18);
pvVar3 = (void *)((long)pvVar3 + 0x18);
if ((uVar5 & 0x20) != 0) {
pvVar3 = memset(pvVar3,0,__n);
return pvVar3;
}
}
}
return pvVar3;
}
| |
52,984 | l_find(LF_SLIST**, charset_info_st const*, unsigned int, unsigned char const*, unsigned long, CURSOR*, LF_PINS*, char (*)(void*, void*)) | eloqsql/mysys/lf_hash.cc | static int l_find(LF_SLIST **head, CHARSET_INFO *cs, uint32 hashnr,
const uchar *key, size_t keylen, CURSOR *cursor, LF_PINS *pins,
my_hash_walk_action callback)
{
uint32 cur_hashnr;
const uchar *cur_key;
size_t cur_keylen;
intptr link;
DBUG_ASSERT(!cs || !callback); /* should not be set both */
DBUG_ASSERT(!keylen || !callback); /* should not be set both */
retry:
cursor->prev= (intptr *) my_assume_aligned<sizeof(intptr)>(head);
do { /* PTR() isn't necessary below, head is a dummy node */
cursor->curr= my_assume_aligned<sizeof(LF_SLIST *)>((LF_SLIST *)(*cursor->prev));
lf_pin(pins, 1, cursor->curr);
} while (my_atomic_loadptr(
(void **)my_assume_aligned<sizeof(LF_SLIST *)>(cursor->prev))
!= cursor->curr && LF_BACKOFF());
for (;;)
{
if (unlikely(!cursor->curr))
return 0; /* end of the list */
cur_hashnr= cursor->curr->hashnr;
cur_keylen= cursor->curr->keylen;
/* The key element needs to be aligned, not necessary what it points to */
my_assume_aligned<sizeof(const uchar *)>(&cursor->curr->key);
cur_key= (const uchar *) my_atomic_loadptr_explicit((void **) &cursor->curr->key,
MY_MEMORY_ORDER_ACQUIRE);
do {
/* attempting to my_assume_aligned onlink below broke the implementation */
link= (intptr) my_atomic_loadptr_explicit((void **) &cursor->curr->link,
MY_MEMORY_ORDER_RELAXED);
cursor->next= my_assume_aligned<sizeof(LF_SLIST *)>(PTR(link));
lf_pin(pins, 0, cursor->next);
} while (link != (intptr) my_atomic_loadptr((void *volatile *) &cursor->curr->link)
&& LF_BACKOFF());
if (!DELETED(link))
{
if (unlikely(callback))
{
if (cur_hashnr & 1 && callback(cursor->curr + 1, (void*)key))
return 1;
}
else if (cur_hashnr >= hashnr)
{
int r= 1;
if (cur_hashnr > hashnr ||
(r= my_strnncoll(cs, cur_key, cur_keylen, key, keylen)) >= 0)
return !r;
}
cursor->prev= &(cursor->curr->link);
if (!(cur_hashnr & 1)) /* dummy node */
head= (LF_SLIST **)cursor->prev;
lf_pin(pins, 2, cursor->curr);
}
else
{
/*
we found a deleted node - be nice, help the other thread
and remove this deleted node
*/
if (my_atomic_casptr((void **) cursor->prev,
(void **) &cursor->curr, cursor->next) && LF_BACKOFF())
lf_alloc_free(pins, cursor->curr);
else
goto retry;
}
cursor->curr= cursor->next;
lf_pin(pins, 1, cursor->curr);
}
} | O0 | cpp | l_find(LF_SLIST**, charset_info_st const*, unsigned int, unsigned char const*, unsigned long, CURSOR*, LF_PINS*, char (*)(void*, void*)):
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
jmp 0xc907c
jmp 0xc907e
jmp 0xc9080
jmp 0xc9082
movq -0x10(%rbp), %rdi
callq 0xc94b0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0xc94c0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xc90b1
jmp 0xc90b3
movq 0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
xchgq %rax, 0x8(%rcx)
jmp 0xc90cd
movq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0xc94d0
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rcx
movq -0x38(%rbp), %rdx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, -0xb1(%rbp)
je 0xc9107
callq 0xc94e0
cmpl $0x0, %eax
setne %al
movb %al, -0xb1(%rbp)
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0xc9095
jmp 0xc9113
movq -0x38(%rbp), %rax
cmpq $0x0, 0x8(%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0xc9137
movl $0x0, -0x4(%rbp)
jmp 0xc93e1
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x18(%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
addq $0x8, %rdi
callq 0xc9520
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
andq $-0x2, %rdi
callq 0xc94c0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0xc91af
jmp 0xc91b1
movq 0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
xchgq %rax, (%rcx)
jmp 0xc91ca
movq -0x58(%rbp), %rcx
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0xb2(%rbp)
je 0xc9205
callq 0xc94e0
cmpl $0x0, %eax
setne %al
movb %al, -0xb2(%rbp)
movb -0xb2(%rbp), %al
testb $0x1, %al
jne 0xc917e
movq -0x58(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0xc9317
cmpq $0x0, 0x18(%rbp)
je 0xc925f
movl -0x3c(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xc925d
movq 0x18(%rbp), %rax
movq -0x38(%rbp), %rcx
movq 0x8(%rcx), %rdi
addq $0x20, %rdi
movq -0x28(%rbp), %rsi
callq *%rax
cmpb $0x0, %al
je 0xc925d
movl $0x1, -0x4(%rbp)
jmp 0xc93e1
jmp 0xc92c9
movl -0x3c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jb 0xc92c7
movl $0x1, -0x8c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
ja 0xc92ac
movq -0x18(%rbp), %rax
movq 0xc0(%rax), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
xorl %r9d, %r9d
callq *%rax
movl %eax, -0x8c(%rbp)
cmpl $0x0, %eax
jl 0xc92c5
cmpl $0x0, -0x8c(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0xc93e1
jmp 0xc92c7
jmp 0xc92c9
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movl -0x3c(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0xc92ee
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xc92f0
jmp 0xc92f2
jmp 0xc92f4
movq 0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rax
xchgq %rax, 0x10(%rcx)
jmp 0xc93aa
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0xd0(%rbp)
movq (%rax), %rcx
movq 0x10(%rax), %rdx
movq %rdx, -0xa0(%rbp)
movq 0x8(%rax), %rax
movq -0xa0(%rbp), %rdx
lock
cmpxchgq %rdx, (%rcx)
movq %rax, %rcx
sete %al
movb %al, -0xc1(%rbp)
movq %rcx, -0xc0(%rbp)
testb $0x1, %al
jne 0xc936f
movq -0xd0(%rbp), %rax
movq -0xc0(%rbp), %rcx
movq %rcx, (%rax)
movb -0xc1(%rbp), %al
andb $0x1, %al
movb %al, -0xa1(%rbp)
testb $0x1, -0xa1(%rbp)
je 0xc93a3
callq 0xc94e0
cmpl $0x0, %eax
je 0xc93a3
movq 0x10(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xc75e0
jmp 0xc93a8
jmp 0xc9082
jmp 0xc93aa
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xc93bc
jmp 0xc93be
movq 0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rax
xchgq %rax, 0x8(%rcx)
jmp 0xc9113
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax)
| _ZL6l_findPP8LF_SLISTPK15charset_info_stjPKhmP6CURSORP7LF_PINSPFcPvSB_E:
push rbp
mov rbp, rsp
sub rsp, 0D0h
mov rax, [rbp+arg_8]
mov rax, [rbp+arg_0]
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov [rbp+var_38], r9
jmp short $+2
loc_C907C:
jmp short $+2
loc_C907E:
jmp short $+2
loc_C9080:
jmp short $+2
loc_C9082:
mov rdi, [rbp+var_10]
call _ZL17my_assume_alignedILm8EPP8LF_SLISTET0_S3_; my_assume_aligned<8ul,LF_SLIST **>(LF_SLIST **)
mov rcx, rax
mov rax, [rbp+var_38]
mov [rax], rcx
loc_C9095:
mov rax, [rbp+var_38]
mov rax, [rax]
mov rdi, [rax]
call _ZL17my_assume_alignedILm8EP8LF_SLISTET0_S2_; my_assume_aligned<8ul,LF_SLIST *>(LF_SLIST *)
mov rcx, rax
mov rax, [rbp+var_38]
mov [rax+8], rcx
jmp short $+2
loc_C90B1:
jmp short $+2
loc_C90B3:
mov rcx, [rbp+arg_0]
mov rax, [rbp+var_38]
mov rax, [rax+8]
mov [rbp+var_60], rax
mov rax, [rbp+var_60]
xchg rax, [rcx+8]
jmp short $+2
loc_C90CD:
mov rax, [rbp+var_38]
mov rdi, [rax]
call _ZL17my_assume_alignedILm8EPmET0_S1_; my_assume_aligned<8ul,ulong *>(ulong *)
mov rax, [rax]
mov [rbp+var_68], rax
mov rcx, [rbp+var_68]
mov rdx, [rbp+var_38]
xor eax, eax
cmp rcx, [rdx+8]
mov [rbp+var_B1], al
jz short loc_C9107
call _ZL10LF_BACKOFFv; LF_BACKOFF(void)
cmp eax, 0
setnz al
mov [rbp+var_B1], al
loc_C9107:
mov al, [rbp+var_B1]
test al, 1
jnz short loc_C9095
jmp short $+2
loc_C9113:
mov rax, [rbp+var_38]
cmp qword ptr [rax+8], 0
setnz al
xor al, 0FFh
and al, 1
movzx eax, al
cmp eax, 0
jz short loc_C9137
mov [rbp+var_4], 0
jmp loc_C93E1
loc_C9137:
mov rax, [rbp+var_38]
mov rax, [rax+8]
mov eax, [rax+18h]
mov [rbp+var_3C], eax
mov rax, [rbp+var_38]
mov rax, [rax+8]
mov rax, [rax+10h]
mov [rbp+var_50], rax
mov rax, [rbp+var_38]
mov rdi, [rax+8]
add rdi, 8
call _ZL17my_assume_alignedILm8EPPKhET0_S3_; my_assume_aligned<8ul,uchar const**>(uchar const**)
mov rax, [rbp+var_38]
mov rax, [rax+8]
mov rax, [rax+8]
mov [rbp+var_70], rax
mov rax, [rbp+var_70]
mov [rbp+var_48], rax
loc_C917E:
mov rax, [rbp+var_38]
mov rax, [rax+8]
mov rax, [rax]
mov [rbp+var_78], rax
mov rax, [rbp+var_78]
mov [rbp+var_58], rax
mov rdi, [rbp+var_58]
and rdi, 0FFFFFFFFFFFFFFFEh
call _ZL17my_assume_alignedILm8EP8LF_SLISTET0_S2_; my_assume_aligned<8ul,LF_SLIST *>(LF_SLIST *)
mov rcx, rax
mov rax, [rbp+var_38]
mov [rax+10h], rcx
jmp short $+2
loc_C91AF:
jmp short $+2
loc_C91B1:
mov rcx, [rbp+arg_0]
mov rax, [rbp+var_38]
mov rax, [rax+10h]
mov [rbp+var_80], rax
mov rax, [rbp+var_80]
xchg rax, [rcx]
jmp short $+2
loc_C91CA:
mov rcx, [rbp+var_58]
mov rax, [rbp+var_38]
mov rax, [rax+8]
mov rax, [rax]
mov [rbp+var_88], rax
mov rdx, [rbp+var_88]
xor eax, eax
cmp rcx, rdx
mov [rbp+var_B2], al
jz short loc_C9205
call _ZL10LF_BACKOFFv; LF_BACKOFF(void)
cmp eax, 0
setnz al
mov [rbp+var_B2], al
loc_C9205:
mov al, [rbp+var_B2]
test al, 1
jnz loc_C917E
mov rax, [rbp+var_58]
and rax, 1
cmp rax, 0
jnz loc_C9317
cmp [rbp+arg_8], 0
jz short loc_C925F
mov eax, [rbp+var_3C]
and eax, 1
cmp eax, 0
jz short loc_C925D
mov rax, [rbp+arg_8]
mov rcx, [rbp+var_38]
mov rdi, [rcx+8]
add rdi, 20h ; ' '
mov rsi, [rbp+var_28]
call rax
cmp al, 0
jz short loc_C925D
mov [rbp+var_4], 1
jmp loc_C93E1
loc_C925D:
jmp short loc_C92C9
loc_C925F:
mov eax, [rbp+var_3C]
cmp eax, [rbp+var_1C]
jb short loc_C92C7
mov [rbp+var_8C], 1
mov eax, [rbp+var_3C]
cmp eax, [rbp+var_1C]
ja short loc_C92AC
mov rax, [rbp+var_18]
mov rax, [rax+0C0h]
mov rax, [rax+8]
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_48]
mov rdx, [rbp+var_50]
mov rcx, [rbp+var_28]
mov r8, [rbp+var_30]
xor r9d, r9d
call rax
mov [rbp+var_8C], eax
cmp eax, 0
jl short loc_C92C5
loc_C92AC:
cmp [rbp+var_8C], 0
setnz al
xor al, 0FFh
and al, 1
movzx eax, al
mov [rbp+var_4], eax
jmp loc_C93E1
loc_C92C5:
jmp short $+2
loc_C92C7:
jmp short $+2
loc_C92C9:
mov rax, [rbp+var_38]
mov rcx, [rax+8]
mov rax, [rbp+var_38]
mov [rax], rcx
mov eax, [rbp+var_3C]
and eax, 1
cmp eax, 0
jnz short loc_C92EE
mov rax, [rbp+var_38]
mov rax, [rax]
mov [rbp+var_10], rax
loc_C92EE:
jmp short $+2
loc_C92F0:
jmp short $+2
loc_C92F2:
jmp short $+2
loc_C92F4:
mov rcx, [rbp+arg_0]
mov rax, [rbp+var_38]
mov rax, [rax+8]
mov [rbp+var_98], rax
mov rax, [rbp+var_98]
xchg rax, [rcx+10h]
jmp loc_C93AA
loc_C9317:
mov rax, [rbp+var_38]
mov rcx, rax
add rcx, 8
mov [rbp+var_D0], rcx
mov rcx, [rax]
mov rdx, [rax+10h]
mov [rbp+var_A0], rdx
mov rax, [rax+8]
mov rdx, [rbp+var_A0]
lock cmpxchg [rcx], rdx
mov rcx, rax
setz al
mov [rbp+var_C1], al
mov [rbp+var_C0], rcx
test al, 1
jnz short loc_C936F
mov rax, [rbp+var_D0]
mov rcx, [rbp+var_C0]
mov [rax], rcx
loc_C936F:
mov al, [rbp+var_C1]
and al, 1
mov [rbp+var_A1], al
test [rbp+var_A1], 1
jz short loc_C93A3
call _ZL10LF_BACKOFFv; LF_BACKOFF(void)
cmp eax, 0
jz short loc_C93A3
mov rdi, [rbp+arg_0]
mov rax, [rbp+var_38]
mov rsi, [rax+8]
call lf_pinbox_free
jmp short loc_C93A8
loc_C93A3:
jmp loc_C9082
loc_C93A8:
jmp short $+2
loc_C93AA:
mov rax, [rbp+var_38]
mov rcx, [rax+10h]
mov rax, [rbp+var_38]
mov [rax+8], rcx
jmp short $+2
loc_C93BC:
jmp short $+2
loc_C93BE:
mov rcx, [rbp+arg_0]
mov rax, [rbp+var_38]
mov rax, [rax+8]
mov [rbp+var_B0], rax
mov rax, [rbp+var_B0]
xchg rax, [rcx+8]
jmp loc_C9113
loc_C93E1:
mov eax, [rbp+var_4]
add rsp, 0D0h
pop rbp
retn
| _BOOL8 l_find(
volatile signed long long *a1,
long long a2,
unsigned int a3,
long long a4,
long long a5,
volatile signed long long **a6,
volatile long long *a7,
unsigned __int8 ( *a8)(volatile signed long long *, long long))
{
signed long long v8; // rtt
signed long long v9; // rcx
bool v11; // [rsp+Fh] [rbp-C1h]
bool v12; // [rsp+1Eh] [rbp-B2h]
bool v13; // [rsp+1Fh] [rbp-B1h]
int v14; // [rsp+44h] [rbp-8Ch]
long long v15; // [rsp+78h] [rbp-58h]
long long v16; // [rsp+80h] [rbp-50h]
long long v17; // [rsp+88h] [rbp-48h]
unsigned int v18; // [rsp+94h] [rbp-3Ch]
LABEL_1:
*a6 = (volatile signed long long *)my_assume_aligned<8ul,LF_SLIST **>(a1);
do
{
a6[1] = (volatile signed long long *)my_assume_aligned<8ul,LF_SLIST *>(**a6);
_InterlockedExchange64(a7 + 1, (long long)a6[1]);
v13 = 0;
if ( *(volatile signed long long **)my_assume_aligned<8ul,unsigned long *>(*a6) != a6[1] )
v13 = (unsigned int)LF_BACKOFF() != 0;
}
while ( v13 );
while ( 1 )
{
if ( !a6[1] )
return 0;
v18 = *((_DWORD *)a6[1] + 6);
v16 = *((_QWORD *)a6[1] + 2);
my_assume_aligned<8ul,unsigned char const**>(a6[1] + 1);
v17 = *((_QWORD *)a6[1] + 1);
do
{
v15 = *a6[1];
a6[2] = (volatile signed long long *)my_assume_aligned<8ul,LF_SLIST *>(v15 & 0xFFFFFFFFFFFFFFFELL);
_InterlockedExchange64(a7, (long long)a6[2]);
v12 = 0;
if ( v15 != *a6[1] )
v12 = (unsigned int)LF_BACKOFF() != 0;
}
while ( v12 );
if ( (v15 & 1) == 0 )
break;
v8 = (signed long long)a6[1];
v9 = _InterlockedCompareExchange64(*a6, (signed long long)a6[2], v8);
v11 = v8 == v9;
if ( v8 != v9 )
a6[1] = (volatile signed long long *)v9;
if ( !v11 || !(unsigned int)LF_BACKOFF() )
goto LABEL_1;
lf_pinbox_free((long long)a7, (const char *)a6[1]);
LABEL_30:
a6[1] = a6[2];
_InterlockedExchange64(a7 + 1, (long long)a6[1]);
}
if ( a8 )
{
if ( (v18 & 1) != 0 && a8(a6[1] + 4, a4) )
return 1;
goto LABEL_21;
}
if ( v18 < a3
|| (v14 = 1, v18 <= a3)
&& (v14 = (*(long long ( **)(long long, long long, long long, long long, long long, _QWORD))(*(_QWORD *)(a2 + 192)
+ 8LL))(
a2,
v17,
v16,
a4,
a5,
0LL),
v14 < 0) )
{
LABEL_21:
*a6 = a6[1];
if ( (v18 & 1) == 0 )
a1 = *a6;
_InterlockedExchange64(a7 + 2, (long long)a6[1]);
goto LABEL_30;
}
return v14 == 0;
}
| l_find:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xd0
MOV RAX,qword ptr [RBP + 0x18]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV qword ptr [RBP + -0x38],R9
JMP 0x001c907c
LAB_001c907c:
JMP 0x001c907e
LAB_001c907e:
JMP 0x001c9080
LAB_001c9080:
JMP 0x001c9082
LAB_001c9082:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001c94b0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX],RCX
LAB_001c9095:
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX]
CALL 0x001c94c0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x8],RCX
JMP 0x001c90b1
LAB_001c90b1:
JMP 0x001c90b3
LAB_001c90b3:
MOV RCX,qword ptr [RBP + 0x10]
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x60]
XCHG qword ptr [RCX + 0x8],RAX
JMP 0x001c90cd
LAB_001c90cd:
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,qword ptr [RAX]
CALL 0x001c94d0
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x68],RAX
MOV RCX,qword ptr [RBP + -0x68]
MOV RDX,qword ptr [RBP + -0x38]
XOR EAX,EAX
CMP RCX,qword ptr [RDX + 0x8]
MOV byte ptr [RBP + -0xb1],AL
JZ 0x001c9107
CALL 0x001c94e0
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0xb1],AL
LAB_001c9107:
MOV AL,byte ptr [RBP + -0xb1]
TEST AL,0x1
JNZ 0x001c9095
JMP 0x001c9113
LAB_001c9113:
MOV RAX,qword ptr [RBP + -0x38]
CMP qword ptr [RAX + 0x8],0x0
SETNZ AL
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x001c9137
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001c93e1
LAB_001c9137:
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
MOV EAX,dword ptr [RAX + 0x18]
MOV dword ptr [RBP + -0x3c],EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,qword ptr [RAX + 0x8]
ADD RDI,0x8
CALL 0x001c9520
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x70],RAX
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RBP + -0x48],RAX
LAB_001c917e:
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,qword ptr [RBP + -0x78]
MOV qword ptr [RBP + -0x58],RAX
MOV RDI,qword ptr [RBP + -0x58]
AND RDI,-0x2
CALL 0x001c94c0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x10],RCX
JMP 0x001c91af
LAB_001c91af:
JMP 0x001c91b1
LAB_001c91b1:
MOV RCX,qword ptr [RBP + 0x10]
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x80],RAX
MOV RAX,qword ptr [RBP + -0x80]
XCHG qword ptr [RCX],RAX
JMP 0x001c91ca
LAB_001c91ca:
MOV RCX,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x88],RAX
MOV RDX,qword ptr [RBP + -0x88]
XOR EAX,EAX
CMP RCX,RDX
MOV byte ptr [RBP + -0xb2],AL
JZ 0x001c9205
CALL 0x001c94e0
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0xb2],AL
LAB_001c9205:
MOV AL,byte ptr [RBP + -0xb2]
TEST AL,0x1
JNZ 0x001c917e
MOV RAX,qword ptr [RBP + -0x58]
AND RAX,0x1
CMP RAX,0x0
JNZ 0x001c9317
CMP qword ptr [RBP + 0x18],0x0
JZ 0x001c925f
MOV EAX,dword ptr [RBP + -0x3c]
AND EAX,0x1
CMP EAX,0x0
JZ 0x001c925d
MOV RAX,qword ptr [RBP + 0x18]
MOV RCX,qword ptr [RBP + -0x38]
MOV RDI,qword ptr [RCX + 0x8]
ADD RDI,0x20
MOV RSI,qword ptr [RBP + -0x28]
CALL RAX
CMP AL,0x0
JZ 0x001c925d
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001c93e1
LAB_001c925d:
JMP 0x001c92c9
LAB_001c925f:
MOV EAX,dword ptr [RBP + -0x3c]
CMP EAX,dword ptr [RBP + -0x1c]
JC 0x001c92c7
MOV dword ptr [RBP + -0x8c],0x1
MOV EAX,dword ptr [RBP + -0x3c]
CMP EAX,dword ptr [RBP + -0x1c]
JA 0x001c92ac
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0xc0]
MOV RAX,qword ptr [RAX + 0x8]
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RBP + -0x50]
MOV RCX,qword ptr [RBP + -0x28]
MOV R8,qword ptr [RBP + -0x30]
XOR R9D,R9D
CALL RAX
MOV dword ptr [RBP + -0x8c],EAX
CMP EAX,0x0
JL 0x001c92c5
LAB_001c92ac:
CMP dword ptr [RBP + -0x8c],0x0
SETNZ AL
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001c93e1
LAB_001c92c5:
JMP 0x001c92c7
LAB_001c92c7:
JMP 0x001c92c9
LAB_001c92c9:
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX],RCX
MOV EAX,dword ptr [RBP + -0x3c]
AND EAX,0x1
CMP EAX,0x0
JNZ 0x001c92ee
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x10],RAX
LAB_001c92ee:
JMP 0x001c92f0
LAB_001c92f0:
JMP 0x001c92f2
LAB_001c92f2:
JMP 0x001c92f4
LAB_001c92f4:
MOV RCX,qword ptr [RBP + 0x10]
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x98],RAX
MOV RAX,qword ptr [RBP + -0x98]
XCHG qword ptr [RCX + 0x10],RAX
JMP 0x001c93aa
LAB_001c9317:
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,RAX
ADD RCX,0x8
MOV qword ptr [RBP + -0xd0],RCX
MOV RCX,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0xa0],RDX
MOV RAX,qword ptr [RAX + 0x8]
MOV RDX,qword ptr [RBP + -0xa0]
CMPXCHG.LOCK qword ptr [RCX],RDX
MOV RCX,RAX
SETZ AL
MOV byte ptr [RBP + -0xc1],AL
MOV qword ptr [RBP + -0xc0],RCX
TEST AL,0x1
JNZ 0x001c936f
MOV RAX,qword ptr [RBP + -0xd0]
MOV RCX,qword ptr [RBP + -0xc0]
MOV qword ptr [RAX],RCX
LAB_001c936f:
MOV AL,byte ptr [RBP + -0xc1]
AND AL,0x1
MOV byte ptr [RBP + -0xa1],AL
TEST byte ptr [RBP + -0xa1],0x1
JZ 0x001c93a3
CALL 0x001c94e0
CMP EAX,0x0
JZ 0x001c93a3
MOV RDI,qword ptr [RBP + 0x10]
MOV RAX,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RAX + 0x8]
CALL 0x001c75e0
JMP 0x001c93a8
LAB_001c93a3:
JMP 0x001c9082
LAB_001c93a8:
JMP 0x001c93aa
LAB_001c93aa:
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x8],RCX
JMP 0x001c93bc
LAB_001c93bc:
JMP 0x001c93be
LAB_001c93be:
MOV RCX,qword ptr [RBP + 0x10]
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0xb0],RAX
MOV RAX,qword ptr [RBP + -0xb0]
XCHG qword ptr [RCX + 0x8],RAX
JMP 0x001c9113
LAB_001c93e1:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0xd0
POP RBP
RET
|
/* l_find(LF_SLIST**, charset_info_st const*, unsigned int, unsigned char const*, unsigned long,
CURSOR*, LF_PINS*, char (*)(void*, void*)) */
byte l_find(LF_SLIST **param_1,charset_info_st *param_2,uint param_3,uchar *param_4,ulong param_5,
CURSOR *param_6,LF_PINS *param_7,_func_char_void_ptr_void_ptr *param_8)
{
uint uVar1;
int8 uVar2;
int8 uVar3;
ulong uVar4;
long lVar5;
char cVar6;
int iVar7;
LF_SLIST **ppLVar8;
LF_SLIST *pLVar9;
ulong *puVar10;
long lVar11;
bool bVar12;
int local_94;
LF_SLIST **local_18;
local_18 = param_1;
LAB_001c9082:
ppLVar8 = my_assume_aligned<8ul,LF_SLIST**>(local_18);
*(LF_SLIST ***)param_6 = ppLVar8;
do {
pLVar9 = my_assume_aligned<8ul,LF_SLIST*>((LF_SLIST *)**(int8 **)param_6);
*(LF_SLIST **)(param_6 + 8) = pLVar9;
LOCK();
*(int8 *)(param_7 + 8) = *(int8 *)(param_6 + 8);
UNLOCK();
puVar10 = my_assume_aligned<8ul,unsigned_long*>(*(ulong **)param_6);
bVar12 = false;
if (*puVar10 != *(ulong *)(param_6 + 8)) {
iVar7 = LF_BACKOFF();
bVar12 = iVar7 != 0;
}
} while (bVar12);
do {
if (*(long *)(param_6 + 8) == 0) {
return 0;
}
uVar1 = *(uint *)(*(long *)(param_6 + 8) + 0x18);
uVar2 = *(int8 *)(*(long *)(param_6 + 8) + 0x10);
my_assume_aligned<8ul,unsigned_char_const**>((uchar **)(*(long *)(param_6 + 8) + 8));
uVar3 = *(int8 *)(*(long *)(param_6 + 8) + 8);
do {
uVar4 = **(ulong **)(param_6 + 8);
pLVar9 = my_assume_aligned<8ul,LF_SLIST*>((LF_SLIST *)(uVar4 & 0xfffffffffffffffe));
*(LF_SLIST **)(param_6 + 0x10) = pLVar9;
LOCK();
*(int8 *)param_7 = *(int8 *)(param_6 + 0x10);
UNLOCK();
bVar12 = false;
if (uVar4 != **(ulong **)(param_6 + 8)) {
iVar7 = LF_BACKOFF();
bVar12 = iVar7 != 0;
}
} while (bVar12);
if ((uVar4 & 1) == 0) {
if (param_8 == (_func_char_void_ptr_void_ptr *)0x0) {
if ((param_3 <= uVar1) &&
((local_94 = 1, param_3 < uVar1 ||
(local_94 = (**(code **)(*(long *)(param_2 + 0xc0) + 8))
(param_2,uVar3,uVar2,param_4,param_5,0), -1 < local_94)))) {
return (local_94 != 0 ^ 0xffU) & 1;
}
}
else if (((uVar1 & 1) != 0) &&
(cVar6 = (*param_8)((void *)(*(long *)(param_6 + 8) + 0x20),param_4), cVar6 != '\0'))
{
return 1;
}
*(int8 *)param_6 = *(int8 *)(param_6 + 8);
if ((uVar1 & 1) == 0) {
local_18 = *(LF_SLIST ***)param_6;
}
LOCK();
*(int8 *)(param_7 + 0x10) = *(int8 *)(param_6 + 8);
UNLOCK();
}
else {
lVar5 = *(long *)(param_6 + 8);
LOCK();
lVar11 = **(long **)param_6;
bVar12 = lVar5 == lVar11;
if (bVar12) {
**(long **)param_6 = *(long *)(param_6 + 0x10);
lVar11 = lVar5;
}
UNLOCK();
if (!bVar12) {
*(long *)(param_6 + 8) = lVar11;
goto LAB_001c9082;
}
iVar7 = LF_BACKOFF();
if (iVar7 == 0) goto LAB_001c9082;
lf_pinbox_free(param_7,*(int8 *)(param_6 + 8));
}
*(int8 *)(param_6 + 8) = *(int8 *)(param_6 + 0x10);
LOCK();
*(int8 *)(param_7 + 8) = *(int8 *)(param_6 + 8);
UNLOCK();
} while( true );
}
| |
52,985 | split_maria_rtree_node | eloqsql/storage/maria/ma_rt_split.c | static int split_maria_rtree_node(SplitStruct *node, int n_entries,
int all_size, /* Total key's size */
int key_size,
int min_size, /* Minimal group size */
int size1, int size2 /* initial group sizes */,
double **d_buffer, int n_dim)
{
SplitStruct *cur;
SplitStruct *UNINIT_VAR(a);
SplitStruct *UNINIT_VAR(b);
double *g1= reserve_coords(d_buffer, n_dim);
double *g2= reserve_coords(d_buffer, n_dim);
SplitStruct *UNINIT_VAR(next);
int UNINIT_VAR(next_node);
int i;
SplitStruct *end= node + n_entries;
if (all_size < min_size * 2)
{
return 1;
}
cur= node;
for (; cur < end; cur++)
{
cur->square= count_square(cur->coords, n_dim);
cur->n_node= 0;
}
pick_seeds(node, n_entries, &a, &b, n_dim);
a->n_node= 1;
b->n_node= 2;
copy_coords(g1, a->coords, n_dim);
size1+= key_size;
copy_coords(g2, b->coords, n_dim);
size2+= key_size;
for (i=n_entries - 2; i>0; --i)
{
if (all_size - (size2 + key_size) < min_size) /* Can't write into group 2 */
{
mark_all_entries(node, n_entries, 1);
break;
}
if (all_size - (size1 + key_size) < min_size) /* Can't write into group 1 */
{
mark_all_entries(node, n_entries, 2);
break;
}
pick_next(node, n_entries, g1, g2, &next, &next_node, n_dim);
if (next_node == 1)
{
size1+= key_size;
mbr_join(g1, next->coords, n_dim);
}
else
{
size2+= key_size;
mbr_join(g2, next->coords, n_dim);
}
next->n_node= next_node;
}
return 0;
} | O0 | c | split_maria_rtree_node:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl 0x20(%rbp), %eax
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x18(%rbp), %rdi
movl 0x20(%rbp), %esi
callq 0x88380
movq %rax, -0x48(%rbp)
movq 0x18(%rbp), %rdi
movl 0x20(%rbp), %esi
callq 0x88380
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0x5c(%rbp), %eax
movl %eax, -0x5c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x68(%rbp)
movl -0x18(%rbp), %eax
movl -0x20(%rbp), %ecx
shll %ecx
cmpl %ecx, %eax
jge 0x88450
movl $0x1, -0x4(%rbp)
jmp 0x885da
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x68(%rbp), %rax
jae 0x88493
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rdi
movl 0x20(%rbp), %esi
callq 0x888b0
movq -0x30(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x30(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x30(%rbp)
jmp 0x88458
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl 0x20(%rbp), %r8d
leaq -0x38(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x88920
movq -0x38(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x40(%rbp), %rax
movl $0x2, 0x8(%rax)
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rsi
movl 0x20(%rbp), %edx
callq 0x88a30
movl -0x1c(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x50(%rbp), %rdi
movq -0x40(%rbp), %rax
movq 0x18(%rax), %rsi
movl 0x20(%rbp), %edx
callq 0x88a30
movl -0x1c(%rbp), %eax
addl 0x10(%rbp), %eax
movl %eax, 0x10(%rbp)
movl -0x14(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x60(%rbp)
cmpl $0x0, -0x60(%rbp)
jle 0x885d3
movl -0x18(%rbp), %eax
movl 0x10(%rbp), %ecx
addl -0x1c(%rbp), %ecx
subl %ecx, %eax
cmpl -0x20(%rbp), %eax
jge 0x88534
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl $0x1, %edx
callq 0x88a70
jmp 0x885d3
movl -0x18(%rbp), %eax
movl -0x24(%rbp), %ecx
addl -0x1c(%rbp), %ecx
subl %ecx, %eax
cmpl -0x20(%rbp), %eax
jge 0x88557
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl $0x2, %edx
callq 0x88a70
jmp 0x885d3
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x48(%rbp), %rdx
movq -0x50(%rbp), %rcx
movl 0x20(%rbp), %eax
leaq -0x58(%rbp), %r8
leaq -0x5c(%rbp), %r9
movl %eax, (%rsp)
callq 0x88ad0
cmpl $0x1, -0x5c(%rbp)
jne 0x8859e
movl -0x1c(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x48(%rbp), %rdi
movq -0x58(%rbp), %rax
movq 0x18(%rax), %rsi
movl 0x20(%rbp), %edx
callq 0x88bf0
jmp 0x885bb
movl -0x1c(%rbp), %eax
addl 0x10(%rbp), %eax
movl %eax, 0x10(%rbp)
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rax
movq 0x18(%rax), %rsi
movl 0x20(%rbp), %edx
callq 0x88bf0
movl -0x5c(%rbp), %ecx
movq -0x58(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x60(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0x88504
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| split_maria_rtree_node:
push rbp
mov rbp, rsp
sub rsp, 70h
mov eax, [rbp+arg_10]
mov rax, [rbp+arg_8]
mov eax, [rbp+arg_0]
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov [rbp+var_1C], ecx
mov [rbp+var_20], r8d
mov [rbp+var_24], r9d
mov rax, [rbp+var_38]
mov [rbp+var_38], rax
mov rax, [rbp+var_40]
mov [rbp+var_40], rax
mov rdi, [rbp+arg_8]
mov esi, [rbp+arg_10]
call reserve_coords
mov [rbp+var_48], rax
mov rdi, [rbp+arg_8]
mov esi, [rbp+arg_10]
call reserve_coords
mov [rbp+var_50], rax
mov rax, [rbp+var_58]
mov [rbp+var_58], rax
mov eax, [rbp+var_5C]
mov [rbp+var_5C], eax
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_14]
shl rcx, 5
add rax, rcx
mov [rbp+var_68], rax
mov eax, [rbp+var_18]
mov ecx, [rbp+var_20]
shl ecx, 1
cmp eax, ecx
jge short loc_88450
mov [rbp+var_4], 1
jmp loc_885DA
loc_88450:
mov rax, [rbp+var_10]
mov [rbp+var_30], rax
loc_88458:
mov rax, [rbp+var_30]
cmp rax, [rbp+var_68]
jnb short loc_88493
mov rax, [rbp+var_30]
mov rdi, [rax+18h]
mov esi, [rbp+arg_10]
call count_square
mov rax, [rbp+var_30]
movsd qword ptr [rax], xmm0
mov rax, [rbp+var_30]
mov dword ptr [rax+8], 0
mov rax, [rbp+var_30]
add rax, 20h ; ' '
mov [rbp+var_30], rax
jmp short loc_88458
loc_88493:
mov rdi, [rbp+var_10]
mov esi, [rbp+var_14]
mov r8d, [rbp+arg_10]
lea rdx, [rbp+var_38]
lea rcx, [rbp+var_40]
call pick_seeds
mov rax, [rbp+var_38]
mov dword ptr [rax+8], 1
mov rax, [rbp+var_40]
mov dword ptr [rax+8], 2
mov rdi, [rbp+var_48]
mov rax, [rbp+var_38]
mov rsi, [rax+18h]
mov edx, [rbp+arg_10]
call copy_coords
mov eax, [rbp+var_1C]
add eax, [rbp+var_24]
mov [rbp+var_24], eax
mov rdi, [rbp+var_50]
mov rax, [rbp+var_40]
mov rsi, [rax+18h]
mov edx, [rbp+arg_10]
call copy_coords
mov eax, [rbp+var_1C]
add eax, [rbp+arg_0]
mov [rbp+arg_0], eax
mov eax, [rbp+var_14]
sub eax, 2
mov [rbp+var_60], eax
loc_88504:
cmp [rbp+var_60], 0
jle loc_885D3
mov eax, [rbp+var_18]
mov ecx, [rbp+arg_0]
add ecx, [rbp+var_1C]
sub eax, ecx
cmp eax, [rbp+var_20]
jge short loc_88534
mov rdi, [rbp+var_10]
mov esi, [rbp+var_14]
mov edx, 1
call mark_all_entries
jmp loc_885D3
loc_88534:
mov eax, [rbp+var_18]
mov ecx, [rbp+var_24]
add ecx, [rbp+var_1C]
sub eax, ecx
cmp eax, [rbp+var_20]
jge short loc_88557
mov rdi, [rbp+var_10]
mov esi, [rbp+var_14]
mov edx, 2
call mark_all_entries
jmp short loc_885D3
loc_88557:
mov rdi, [rbp+var_10]
mov esi, [rbp+var_14]
mov rdx, [rbp+var_48]
mov rcx, [rbp+var_50]
mov eax, [rbp+arg_10]
lea r8, [rbp+var_58]
lea r9, [rbp+var_5C]
mov [rsp+70h+var_70], eax
call pick_next
cmp [rbp+var_5C], 1
jnz short loc_8859E
mov eax, [rbp+var_1C]
add eax, [rbp+var_24]
mov [rbp+var_24], eax
mov rdi, [rbp+var_48]
mov rax, [rbp+var_58]
mov rsi, [rax+18h]
mov edx, [rbp+arg_10]
call mbr_join
jmp short loc_885BB
loc_8859E:
mov eax, [rbp+var_1C]
add eax, [rbp+arg_0]
mov [rbp+arg_0], eax
mov rdi, [rbp+var_50]
mov rax, [rbp+var_58]
mov rsi, [rax+18h]
mov edx, [rbp+arg_10]
call mbr_join
loc_885BB:
mov ecx, [rbp+var_5C]
mov rax, [rbp+var_58]
mov [rax+8], ecx
mov eax, [rbp+var_60]
add eax, 0FFFFFFFFh
mov [rbp+var_60], eax
jmp loc_88504
loc_885D3:
mov [rbp+var_4], 0
loc_885DA:
mov eax, [rbp+var_4]
add rsp, 70h
pop rbp
retn
| long long split_maria_rtree_node(
unsigned long long a1,
unsigned int a2,
int a3,
int a4,
int a5,
int a6,
int a7,
long long *a8,
unsigned int a9)
{
int j; // [rsp+10h] [rbp-60h]
int v11; // [rsp+14h] [rbp-5Ch] BYREF
long long v12; // [rsp+18h] [rbp-58h] BYREF
long long v13; // [rsp+20h] [rbp-50h]
long long v14; // [rsp+28h] [rbp-48h]
long long v15; // [rsp+30h] [rbp-40h] BYREF
long long v16; // [rsp+38h] [rbp-38h] BYREF
unsigned long long i; // [rsp+40h] [rbp-30h]
int v18; // [rsp+4Ch] [rbp-24h]
int v19; // [rsp+50h] [rbp-20h]
int v20; // [rsp+54h] [rbp-1Ch]
int v21; // [rsp+58h] [rbp-18h]
unsigned int v22; // [rsp+5Ch] [rbp-14h]
unsigned long long v23; // [rsp+60h] [rbp-10h]
int v25; // [rsp+80h] [rbp+10h]
v23 = a1;
v22 = a2;
v21 = a3;
v20 = a4;
v19 = a5;
v18 = a6;
v14 = reserve_coords(a8, a9);
v13 = reserve_coords(a8, a9);
if ( v21 >= 2 * v19 )
{
for ( i = v23; i < 32LL * (int)a2 + a1; i += 32LL )
{
*(double *)i = count_square(*(_QWORD *)(i + 24), a9);
*(_DWORD *)(i + 8) = 0;
}
pick_seeds(v23, v22, &v16, &v15, a9);
*(_DWORD *)(v16 + 8) = 1;
*(_DWORD *)(v15 + 8) = 2;
copy_coords(v14, *(_QWORD *)(v16 + 24), a9);
v18 += v20;
copy_coords(v13, *(_QWORD *)(v15 + 24), a9);
v25 = a7 + v20;
for ( j = v22 - 2; j > 0; --j )
{
if ( v21 - (v20 + v25) < v19 )
{
mark_all_entries(v23, v22, 1LL);
break;
}
if ( v21 - (v20 + v18) < v19 )
{
mark_all_entries(v23, v22, 2LL);
break;
}
pick_next(v23, v22, v14, v13, (unsigned int)&v12, (unsigned int)&v11, a9);
if ( v11 == 1 )
{
v18 += v20;
mbr_join(v14, *(_QWORD *)(v12 + 24), a9);
}
else
{
v25 += v20;
mbr_join(v13, *(_QWORD *)(v12 + 24), a9);
}
*(_DWORD *)(v12 + 8) = v11;
}
return 0;
}
else
{
return 1;
}
}
| split_maria_rtree_node:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV EAX,dword ptr [RBP + 0x20]
MOV RAX,qword ptr [RBP + 0x18]
MOV EAX,dword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV dword ptr [RBP + -0x1c],ECX
MOV dword ptr [RBP + -0x20],R8D
MOV dword ptr [RBP + -0x24],R9D
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + 0x18]
MOV ESI,dword ptr [RBP + 0x20]
CALL 0x00188380
MOV qword ptr [RBP + -0x48],RAX
MOV RDI,qword ptr [RBP + 0x18]
MOV ESI,dword ptr [RBP + 0x20]
CALL 0x00188380
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x58],RAX
MOV EAX,dword ptr [RBP + -0x5c]
MOV dword ptr [RBP + -0x5c],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x14]
SHL RCX,0x5
ADD RAX,RCX
MOV qword ptr [RBP + -0x68],RAX
MOV EAX,dword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x20]
SHL ECX,0x1
CMP EAX,ECX
JGE 0x00188450
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001885da
LAB_00188450:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x30],RAX
LAB_00188458:
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x68]
JNC 0x00188493
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,qword ptr [RAX + 0x18]
MOV ESI,dword ptr [RBP + 0x20]
CALL 0x001888b0
MOV RAX,qword ptr [RBP + -0x30]
MOVSD qword ptr [RAX],XMM0
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x8],0x0
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x20
MOV qword ptr [RBP + -0x30],RAX
JMP 0x00188458
LAB_00188493:
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x14]
MOV R8D,dword ptr [RBP + 0x20]
LEA RDX,[RBP + -0x38]
LEA RCX,[RBP + -0x40]
CALL 0x00188920
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x8],0x1
MOV RAX,qword ptr [RBP + -0x40]
MOV dword ptr [RAX + 0x8],0x2
MOV RDI,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RAX + 0x18]
MOV EDX,dword ptr [RBP + 0x20]
CALL 0x00188a30
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x24],EAX
MOV RDI,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RAX + 0x18]
MOV EDX,dword ptr [RBP + 0x20]
CALL 0x00188a30
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,dword ptr [RBP + 0x10]
MOV dword ptr [RBP + 0x10],EAX
MOV EAX,dword ptr [RBP + -0x14]
SUB EAX,0x2
MOV dword ptr [RBP + -0x60],EAX
LAB_00188504:
CMP dword ptr [RBP + -0x60],0x0
JLE 0x001885d3
MOV EAX,dword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + 0x10]
ADD ECX,dword ptr [RBP + -0x1c]
SUB EAX,ECX
CMP EAX,dword ptr [RBP + -0x20]
JGE 0x00188534
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x14]
MOV EDX,0x1
CALL 0x00188a70
JMP 0x001885d3
LAB_00188534:
MOV EAX,dword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x24]
ADD ECX,dword ptr [RBP + -0x1c]
SUB EAX,ECX
CMP EAX,dword ptr [RBP + -0x20]
JGE 0x00188557
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x14]
MOV EDX,0x2
CALL 0x00188a70
JMP 0x001885d3
LAB_00188557:
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x14]
MOV RDX,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RBP + -0x50]
MOV EAX,dword ptr [RBP + 0x20]
LEA R8,[RBP + -0x58]
LEA R9,[RBP + -0x5c]
MOV dword ptr [RSP],EAX
CALL 0x00188ad0
CMP dword ptr [RBP + -0x5c],0x1
JNZ 0x0018859e
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x24],EAX
MOV RDI,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x58]
MOV RSI,qword ptr [RAX + 0x18]
MOV EDX,dword ptr [RBP + 0x20]
CALL 0x00188bf0
JMP 0x001885bb
LAB_0018859e:
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,dword ptr [RBP + 0x10]
MOV dword ptr [RBP + 0x10],EAX
MOV RDI,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x58]
MOV RSI,qword ptr [RAX + 0x18]
MOV EDX,dword ptr [RBP + 0x20]
CALL 0x00188bf0
LAB_001885bb:
MOV ECX,dword ptr [RBP + -0x5c]
MOV RAX,qword ptr [RBP + -0x58]
MOV dword ptr [RAX + 0x8],ECX
MOV EAX,dword ptr [RBP + -0x60]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x60],EAX
JMP 0x00188504
LAB_001885d3:
MOV dword ptr [RBP + -0x4],0x0
LAB_001885da:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x70
POP RBP
RET
|
int4
split_maria_rtree_node
(int8 *param_1,int param_2,int param_3,int param_4,int param_5,int param_6,
int param_7,int8 param_8,int4 param_9)
{
int8 *puVar1;
int8 uVar2;
int local_68;
int local_64;
long local_60;
int8 local_58;
int8 local_50;
long local_48;
long local_40;
int8 *local_38;
int local_2c;
int local_28;
int local_24;
int local_20;
int local_1c;
int8 *local_18;
int4 local_c;
local_2c = param_6;
local_28 = param_5;
local_24 = param_4;
local_20 = param_3;
local_1c = param_2;
local_18 = param_1;
local_50 = reserve_coords(param_8,param_9);
local_58 = reserve_coords(param_8,param_9);
puVar1 = local_18 + (long)local_1c * 4;
if (SBORROW4(local_20,local_28 * 2) == local_20 + local_28 * -2 < 0) {
for (local_38 = local_18; local_38 < puVar1; local_38 = local_38 + 4) {
uVar2 = count_square(local_38[3],param_9);
*local_38 = uVar2;
*(int4 *)(local_38 + 1) = 0;
}
pick_seeds(local_18,local_1c,&local_40,&local_48,param_9);
*(int4 *)(local_40 + 8) = 1;
*(int4 *)(local_48 + 8) = 2;
copy_coords(local_50,*(int8 *)(local_40 + 0x18),param_9);
local_2c = local_24 + local_2c;
copy_coords(local_58,*(int8 *)(local_48 + 0x18),param_9);
param_7 = local_24 + param_7;
for (local_68 = local_1c + -2; 0 < local_68; local_68 = local_68 + -1) {
if (local_20 - (param_7 + local_24) < local_28) {
mark_all_entries(local_18,local_1c,1);
break;
}
if (local_20 - (local_2c + local_24) < local_28) {
mark_all_entries(local_18,local_1c,2);
break;
}
pick_next(local_18,local_1c,local_50,local_58,&local_60,&local_64,param_9);
if (local_64 == 1) {
local_2c = local_24 + local_2c;
mbr_join(local_50,*(int8 *)(local_60 + 0x18),param_9);
}
else {
param_7 = local_24 + param_7;
mbr_join(local_58,*(int8 *)(local_60 + 0x18),param_9);
}
*(int *)(local_60 + 8) = local_64;
}
local_c = 0;
}
else {
local_c = 1;
}
return local_c;
}
| |
52,986 | dequantize_row_iq1_s | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c | void dequantize_row_iq1_s(const block_iq1_s * restrict x, float * restrict y, int64_t k) {
assert(k % QK_K == 0);
const int64_t nb = k / QK_K;
for (int i = 0; i < nb; i++) {
const float d = GGML_FP16_TO_FP32(x[i].d);
const uint8_t * qs = x[i].qs;
const uint16_t * qh = x[i].qh;
for (int ib = 0; ib < QK_K/32; ++ib) {
const float dl = d * (2*((qh[ib] >> 12) & 7) + 1);
const float delta = qh[ib] & 0x8000 ? -IQ1S_DELTA : IQ1S_DELTA;
for (int l = 0; l < 4; ++l) {
const int8_t * grid = (const int8_t *)(iq1s_grid + (qs[l] | (((qh[ib] >> 3*l) & 7) << 8)));
for (int j = 0; j < 8; ++j) {
y[j] = dl * (grid[j] + delta);
}
y += 8;
}
qs += 4;
}
}
} | O1 | c | dequantize_row_iq1_s:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testb %dl, %dl
jne 0x34954
sarq $0x8, %rdx
testq %rdx, %rdx
jle 0x34945
xorl %eax, %eax
movq 0x3972e(%rip), %r8 # 0x6dfa8
leaq 0x1c5d3(%rip), %r9 # 0x50e54
leaq 0x20b58(%rip), %r10 # 0x553e0
imulq $0x32, %rax, %rcx
leaq (%rdi,%rcx), %r11
leaq (%rdi,%rcx), %rbx
addq $0x2, %rbx
movzwl -0x2(%rbx), %ecx
movss (%r8,%rcx,4), %xmm0
xorl %r14d, %r14d
movzwl 0x22(%r11,%r14,2), %ebp
xorl %ecx, %ecx
testw %bp, %bp
setns %cl
movl %ebp, %r15d
shrl $0xb, %r15d
andl $0xe, %r15d
incl %r15d
xorps %xmm1, %xmm1
cvtsi2ss %r15d, %xmm1
mulss %xmm0, %xmm1
movss (%r9,%rcx,4), %xmm2
xorl %r15d, %r15d
movzbl (%rbx,%r15), %r12d
leal (%r15,%r15,2), %ecx
movl %ebp, %r13d
shrl %cl, %r13d
andl $0x7, %r13d
shll $0x8, %r13d
orl %r12d, %r13d
leaq (%r10,%r13,8), %rcx
xorl %r12d, %r12d
movsbl (%rcx,%r12), %r13d
xorps %xmm3, %xmm3
cvtsi2ss %r13d, %xmm3
addss %xmm2, %xmm3
mulss %xmm1, %xmm3
movss %xmm3, (%rsi,%r12,4)
incq %r12
cmpq $0x8, %r12
jne 0x348f7
addq $0x20, %rsi
incq %r15
cmpq $0x4, %r15
jne 0x348d6
addq $0x4, %rbx
incq %r14
cmpq $0x8, %r14
jne 0x348a5
incq %rax
cmpq %rdx, %rax
jne 0x34888
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x27291(%rip), %rdi # 0x5bbec
leaq 0x26ea2(%rip), %rsi # 0x5b804
leaq 0x27898(%rip), %rcx # 0x5c201
movl $0x938, %edx # imm = 0x938
callq 0x17b00
| dequantize_row_iq1_s:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
test dl, dl
jnz loc_34954
sar rdx, 8
test rdx, rdx
jle loc_34945
xor eax, eax
mov r8, cs:ggml_table_f32_f16_ptr
lea r9, unk_50E54
lea r10, iq1s_grid
loc_34888:
imul rcx, rax, 32h ; '2'
lea r11, [rdi+rcx]
lea rbx, [rdi+rcx]
add rbx, 2
movzx ecx, word ptr [rbx-2]
movss xmm0, dword ptr [r8+rcx*4]
xor r14d, r14d
loc_348A5:
movzx ebp, word ptr [r11+r14*2+22h]
xor ecx, ecx
test bp, bp
setns cl
mov r15d, ebp
shr r15d, 0Bh
and r15d, 0Eh
inc r15d
xorps xmm1, xmm1
cvtsi2ss xmm1, r15d
mulss xmm1, xmm0
movss xmm2, dword ptr [r9+rcx*4]
xor r15d, r15d
loc_348D6:
movzx r12d, byte ptr [rbx+r15]
lea ecx, [r15+r15*2]
mov r13d, ebp
shr r13d, cl
and r13d, 7
shl r13d, 8
or r13d, r12d
lea rcx, [r10+r13*8]
xor r12d, r12d
loc_348F7:
movsx r13d, byte ptr [rcx+r12]
xorps xmm3, xmm3
cvtsi2ss xmm3, r13d
addss xmm3, xmm2
mulss xmm3, xmm1
movss dword ptr [rsi+r12*4], xmm3
inc r12
cmp r12, 8
jnz short loc_348F7
add rsi, 20h ; ' '
inc r15
cmp r15, 4
jnz short loc_348D6
add rbx, 4
inc r14
cmp r14, 8
jnz loc_348A5
inc rax
cmp rax, rdx
jnz loc_34888
loc_34945:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_34954:
lea rdi, aKQkK0; "k % QK_K == 0"
lea rsi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidDequantize_16; "void dequantize_row_iq1_s(const block_i"...
mov edx, 938h
call ___assert_fail
| long long dequantize_row_iq1_s(long long a1, long long a2, long long a3)
{
long long result; // rax
long long v4; // rdx
unsigned __int16 *v5; // r11
unsigned __int16 *v6; // rbx
float v7; // xmm0_4
long long i; // r14
unsigned int v9; // ebp
float v10; // xmm2_4
long long j; // r15
char *v12; // rcx
long long k; // r12
if ( (_BYTE)a3 )
__assert_fail(
"k % QK_K == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c",
2360LL,
"void dequantize_row_iq1_s(const block_iq1_s *restrict, float *restrict, int64_t)");
v4 = a3 >> 8;
if ( v4 > 0 )
{
for ( result = 0LL; result != v4; ++result )
{
v5 = (unsigned __int16 *)(a1 + 50 * result);
v6 = v5 + 1;
v7 = ggml_table_f32_f16[*v5];
for ( i = 0LL; i != 8; ++i )
{
v9 = v5[i + 17];
v10 = flt_50E54[(v9 & 0x8000u) == 0];
for ( j = 0LL; j != 4; ++j )
{
v12 = (char *)&iq1s_grid + 8 * (*((unsigned __int8 *)v6 + j) | (((v9 >> (3 * j)) & 7) << 8));
for ( k = 0LL; k != 8; ++k )
*(float *)(a2 + 4 * k) = (float)((float)v12[k] + v10) * (float)((float)(int)(((v9 >> 11) & 0xE) + 1) * v7);
a2 += 32LL;
}
v6 += 2;
}
}
}
return result;
}
| dequantize_row_iq1_s:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
TEST DL,DL
JNZ 0x00134954
SAR RDX,0x8
TEST RDX,RDX
JLE 0x00134945
XOR EAX,EAX
MOV R8,qword ptr [0x0016dfa8]
LEA R9,[0x150e54]
LEA R10,[0x1553e0]
LAB_00134888:
IMUL RCX,RAX,0x32
LEA R11,[RDI + RCX*0x1]
LEA RBX,[RDI + RCX*0x1]
ADD RBX,0x2
MOVZX ECX,word ptr [RBX + -0x2]
MOVSS XMM0,dword ptr [R8 + RCX*0x4]
XOR R14D,R14D
LAB_001348a5:
MOVZX EBP,word ptr [R11 + R14*0x2 + 0x22]
XOR ECX,ECX
TEST BP,BP
SETNS CL
MOV R15D,EBP
SHR R15D,0xb
AND R15D,0xe
INC R15D
XORPS XMM1,XMM1
CVTSI2SS XMM1,R15D
MULSS XMM1,XMM0
MOVSS XMM2,dword ptr [R9 + RCX*0x4]
XOR R15D,R15D
LAB_001348d6:
MOVZX R12D,byte ptr [RBX + R15*0x1]
LEA ECX,[R15 + R15*0x2]
MOV R13D,EBP
SHR R13D,CL
AND R13D,0x7
SHL R13D,0x8
OR R13D,R12D
LEA RCX,[R10 + R13*0x8]
XOR R12D,R12D
LAB_001348f7:
MOVSX R13D,byte ptr [RCX + R12*0x1]
XORPS XMM3,XMM3
CVTSI2SS XMM3,R13D
ADDSS XMM3,XMM2
MULSS XMM3,XMM1
MOVSS dword ptr [RSI + R12*0x4],XMM3
INC R12
CMP R12,0x8
JNZ 0x001348f7
ADD RSI,0x20
INC R15
CMP R15,0x4
JNZ 0x001348d6
ADD RBX,0x4
INC R14
CMP R14,0x8
JNZ 0x001348a5
INC RAX
CMP RAX,RDX
JNZ 0x00134888
LAB_00134945:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00134954:
LEA RDI,[0x15bbec]
LEA RSI,[0x15b804]
LEA RCX,[0x15c201]
MOV EDX,0x938
CALL 0x00117b00
|
void dequantize_row_iq1_s(long param_1,long param_2,long param_3)
{
ushort *puVar1;
float fVar2;
float fVar3;
byte bVar4;
ushort uVar5;
int *puVar6;
long lVar7;
ushort *puVar8;
long lVar9;
long lVar10;
long lVar11;
puVar6 = PTR_ggml_table_f32_f16_0016dfa8;
if ((char)param_3 == '\0') {
if (0 < param_3 >> 8) {
lVar7 = 0;
do {
puVar1 = (ushort *)(param_1 + lVar7 * 0x32);
puVar8 = puVar1 + 1;
fVar2 = *(float *)(puVar6 + (ulong)*puVar1 * 4);
lVar10 = 0;
do {
uVar5 = *(ushort *)(param_1 + lVar7 * 0x32 + 0x22 + lVar10 * 2);
fVar3 = *(float *)(&DAT_00150e54 + (ulong)(-1 < (short)uVar5) * 4);
lVar11 = 0;
do {
bVar4 = *(byte *)((long)puVar8 + lVar11);
lVar9 = 0;
do {
*(float *)(param_2 + lVar9 * 4) =
((float)(int)(char)iq1s_grid[lVar9 + (ulong)((uVar5 >> ((char)lVar11 * '\x03' &
0x1fU) & 7) << 8 |
(uint)bVar4) * 8] + fVar3) *
(float)(ushort)((uVar5 >> 0xb & 0xe) + 1) * fVar2;
lVar9 = lVar9 + 1;
} while (lVar9 != 8);
param_2 = param_2 + 0x20;
lVar11 = lVar11 + 1;
} while (lVar11 != 4);
puVar8 = puVar8 + 2;
lVar10 = lVar10 + 1;
} while (lVar10 != 8);
lVar7 = lVar7 + 1;
} while (lVar7 != param_3 >> 8);
}
return;
}
/* WARNING: Subroutine does not return */
__assert_fail("k % QK_K == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c"
,0x938,
"void dequantize_row_iq1_s(const block_iq1_s *restrict, float *restrict, int64_t)");
}
| |
52,987 | dequantize_row_iq1_s | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c | void dequantize_row_iq1_s(const block_iq1_s * restrict x, float * restrict y, int64_t k) {
assert(k % QK_K == 0);
const int64_t nb = k / QK_K;
for (int i = 0; i < nb; i++) {
const float d = GGML_FP16_TO_FP32(x[i].d);
const uint8_t * qs = x[i].qs;
const uint16_t * qh = x[i].qh;
for (int ib = 0; ib < QK_K/32; ++ib) {
const float dl = d * (2*((qh[ib] >> 12) & 7) + 1);
const float delta = qh[ib] & 0x8000 ? -IQ1S_DELTA : IQ1S_DELTA;
for (int l = 0; l < 4; ++l) {
const int8_t * grid = (const int8_t *)(iq1s_grid + (qs[l] | (((qh[ib] >> 3*l) & 7) << 8)));
for (int j = 0; j < 8; ++j) {
y[j] = dl * (grid[j] + delta);
}
y += 8;
}
qs += 4;
}
}
} | O2 | c | dequantize_row_iq1_s:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testb %dl, %dl
jne 0x37f64
sarq $0x8, %rdx
xorl %eax, %eax
testq %rdx, %rdx
cmovleq %rax, %rdx
movq 0x3b128(%rip), %r8 # 0x72fa8
leaq 0x1b249(%rip), %r9 # 0x530d0
leaq 0x1f7b2(%rip), %r10 # 0x57640
cmpq %rdx, %rax
je 0x37f55
imulq $0x32, %rax, %rcx
leaq (%rdi,%rcx), %r11
leaq (%rdi,%rcx), %rbx
addq $0x2, %rbx
movzwl -0x2(%rbx), %ecx
movss (%r8,%rcx,4), %xmm0
xorl %r14d, %r14d
cmpq $0x8, %r14
je 0x37f4d
movzwl 0x22(%r11,%r14,2), %ebp
xorl %ecx, %ecx
testw %bp, %bp
setns %cl
movl %ebp, %r15d
shrl $0xb, %r15d
andl $0xe, %r15d
incl %r15d
cvtsi2ss %r15d, %xmm1
mulss %xmm0, %xmm1
movss (%r9,%rcx,4), %xmm2
xorl %r15d, %r15d
cmpq $0x4, %r15
je 0x37f41
movzbl (%rbx,%r15), %r13d
leal (%r15,%r15,2), %ecx
movl %ebp, %r12d
shrl %cl, %r12d
andl $0x7, %r12d
shll $0x8, %r12d
orl %r13d, %r12d
shll $0x3, %r12d
xorl %ecx, %ecx
cmpq $0x8, %rcx
je 0x37f38
leaq (%r12,%rcx), %r13
movsbl (%r10,%r13), %r13d
cvtsi2ss %r13d, %xmm3
addss %xmm2, %xmm3
mulss %xmm1, %xmm3
movss %xmm3, (%rsi,%rcx,4)
incq %rcx
jmp 0x37f12
addq $0x20, %rsi
incq %r15
jmp 0x37eec
addq $0x4, %rbx
incq %r14
jmp 0x37eb4
incq %rax
jmp 0x37e8e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x25ee1(%rip), %rdi # 0x5de4c
leaq 0x25af2(%rip), %rsi # 0x5da64
leaq 0x264e8(%rip), %rcx # 0x5e461
movl $0x938, %edx # imm = 0x938
callq 0x1dfb0
| dequantize_row_iq1_s:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
test dl, dl
jnz loc_37F64
sar rdx, 8
xor eax, eax
test rdx, rdx
cmovle rdx, rax
mov r8, cs:ggml_table_f32_f16_ptr
lea r9, unk_530D0
lea r10, iq1s_grid
loc_37E8E:
cmp rax, rdx
jz loc_37F55
imul rcx, rax, 32h ; '2'
lea r11, [rdi+rcx]
lea rbx, [rdi+rcx]
add rbx, 2
movzx ecx, word ptr [rbx-2]
movss xmm0, dword ptr [r8+rcx*4]
xor r14d, r14d
loc_37EB4:
cmp r14, 8
jz loc_37F4D
movzx ebp, word ptr [r11+r14*2+22h]
xor ecx, ecx
test bp, bp
setns cl
mov r15d, ebp
shr r15d, 0Bh
and r15d, 0Eh
inc r15d
cvtsi2ss xmm1, r15d
mulss xmm1, xmm0
movss xmm2, dword ptr [r9+rcx*4]
xor r15d, r15d
loc_37EEC:
cmp r15, 4
jz short loc_37F41
movzx r13d, byte ptr [rbx+r15]
lea ecx, [r15+r15*2]
mov r12d, ebp
shr r12d, cl
and r12d, 7
shl r12d, 8
or r12d, r13d
shl r12d, 3
xor ecx, ecx
loc_37F12:
cmp rcx, 8
jz short loc_37F38
lea r13, [r12+rcx]
movsx r13d, byte ptr [r10+r13]
cvtsi2ss xmm3, r13d
addss xmm3, xmm2
mulss xmm3, xmm1
movss dword ptr [rsi+rcx*4], xmm3
inc rcx
jmp short loc_37F12
loc_37F38:
add rsi, 20h ; ' '
inc r15
jmp short loc_37EEC
loc_37F41:
add rbx, 4
inc r14
jmp loc_37EB4
loc_37F4D:
inc rax
jmp loc_37E8E
loc_37F55:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_37F64:
lea rdi, aKQkK0; "k % QK_K == 0"
lea rsi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidDequantize_16; "void dequantize_row_iq1_s(const block_i"...
mov edx, 938h
call ___assert_fail
| long long dequantize_row_iq1_s(long long a1, long long a2, long long a3)
{
long long v3; // rdx
long long result; // rax
unsigned __int16 *v5; // r11
unsigned __int16 *v6; // rbx
float v7; // xmm0_4
long long i; // r14
unsigned int v9; // ebp
float v10; // xmm2_4
long long j; // r15
long long v12; // r12
long long k; // rcx
if ( (_BYTE)a3 )
__assert_fail(
"k % QK_K == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c",
2360LL,
"void dequantize_row_iq1_s(const block_iq1_s *restrict, float *restrict, int64_t)");
v3 = a3 >> 8;
result = 0LL;
if ( v3 <= 0 )
v3 = 0LL;
while ( result != v3 )
{
v5 = (unsigned __int16 *)(a1 + 50 * result);
v6 = v5 + 1;
v7 = ggml_table_f32_f16[*v5];
for ( i = 0LL; i != 8; ++i )
{
v9 = v5[i + 17];
v10 = flt_530D0[(v9 & 0x8000u) == 0];
for ( j = 0LL; j != 4; ++j )
{
v12 = 8 * (*((unsigned __int8 *)v6 + j) | (((v9 >> (3 * j)) & 7) << 8));
for ( k = 0LL; k != 8; ++k )
*(float *)(a2 + 4 * k) = (float)((float)iq1s_grid[v12 + k] + v10)
* (float)((float)(int)(((v9 >> 11) & 0xE) + 1) * v7);
a2 += 32LL;
}
v6 += 2;
}
++result;
}
return result;
}
| dequantize_row_iq1_s:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
TEST DL,DL
JNZ 0x00137f64
SAR RDX,0x8
XOR EAX,EAX
TEST RDX,RDX
CMOVLE RDX,RAX
MOV R8,qword ptr [0x00172fa8]
LEA R9,[0x1530d0]
LEA R10,[0x157640]
LAB_00137e8e:
CMP RAX,RDX
JZ 0x00137f55
IMUL RCX,RAX,0x32
LEA R11,[RDI + RCX*0x1]
LEA RBX,[RDI + RCX*0x1]
ADD RBX,0x2
MOVZX ECX,word ptr [RBX + -0x2]
MOVSS XMM0,dword ptr [R8 + RCX*0x4]
XOR R14D,R14D
LAB_00137eb4:
CMP R14,0x8
JZ 0x00137f4d
MOVZX EBP,word ptr [R11 + R14*0x2 + 0x22]
XOR ECX,ECX
TEST BP,BP
SETNS CL
MOV R15D,EBP
SHR R15D,0xb
AND R15D,0xe
INC R15D
CVTSI2SS XMM1,R15D
MULSS XMM1,XMM0
MOVSS XMM2,dword ptr [R9 + RCX*0x4]
XOR R15D,R15D
LAB_00137eec:
CMP R15,0x4
JZ 0x00137f41
MOVZX R13D,byte ptr [RBX + R15*0x1]
LEA ECX,[R15 + R15*0x2]
MOV R12D,EBP
SHR R12D,CL
AND R12D,0x7
SHL R12D,0x8
OR R12D,R13D
SHL R12D,0x3
XOR ECX,ECX
LAB_00137f12:
CMP RCX,0x8
JZ 0x00137f38
LEA R13,[R12 + RCX*0x1]
MOVSX R13D,byte ptr [R10 + R13*0x1]
CVTSI2SS XMM3,R13D
ADDSS XMM3,XMM2
MULSS XMM3,XMM1
MOVSS dword ptr [RSI + RCX*0x4],XMM3
INC RCX
JMP 0x00137f12
LAB_00137f38:
ADD RSI,0x20
INC R15
JMP 0x00137eec
LAB_00137f41:
ADD RBX,0x4
INC R14
JMP 0x00137eb4
LAB_00137f4d:
INC RAX
JMP 0x00137e8e
LAB_00137f55:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00137f64:
LEA RDI,[0x15de4c]
LEA RSI,[0x15da64]
LEA RCX,[0x15e461]
MOV EDX,0x938
CALL 0x0011dfb0
|
void dequantize_row_iq1_s(long param_1,long param_2,long param_3)
{
ushort *puVar1;
float fVar2;
float fVar3;
byte bVar4;
ushort uVar5;
int *puVar6;
long lVar7;
long lVar8;
long lVar9;
ushort *puVar10;
long lVar11;
long lVar12;
puVar6 = PTR_ggml_table_f32_f16_00172fa8;
if ((char)param_3 != '\0') {
/* WARNING: Subroutine does not return */
__assert_fail("k % QK_K == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c"
,0x938,
"void dequantize_row_iq1_s(const block_iq1_s *restrict, float *restrict, int64_t)"
);
}
lVar7 = 0;
lVar9 = param_3 >> 8;
if (param_3 >> 8 < 1) {
lVar9 = lVar7;
}
for (; lVar7 != lVar9; lVar7 = lVar7 + 1) {
puVar1 = (ushort *)(param_1 + lVar7 * 0x32);
puVar10 = puVar1 + 1;
fVar2 = *(float *)(puVar6 + (ulong)*puVar1 * 4);
for (lVar11 = 0; lVar11 != 8; lVar11 = lVar11 + 1) {
uVar5 = *(ushort *)(param_1 + lVar7 * 0x32 + 0x22 + lVar11 * 2);
fVar3 = *(float *)(&DAT_001530d0 + (ulong)(-1 < (short)uVar5) * 4);
for (lVar12 = 0; lVar12 != 4; lVar12 = lVar12 + 1) {
bVar4 = *(byte *)((long)puVar10 + lVar12);
for (lVar8 = 0; lVar8 != 8; lVar8 = lVar8 + 1) {
*(float *)(param_2 + lVar8 * 4) =
((float)(int)(char)iq1s_grid[(ulong)(((uVar5 >> ((char)lVar12 * '\x03' & 0x1fU) & 7)
<< 8 | (uint)bVar4) << 3) + lVar8] + fVar3) *
(float)(ushort)((uVar5 >> 0xb & 0xe) + 1) * fVar2;
}
param_2 = param_2 + 0x20;
}
puVar10 = puVar10 + 2;
}
}
return;
}
| |
52,988 | dequantize_row_iq1_s | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c | void dequantize_row_iq1_s(const block_iq1_s * restrict x, float * restrict y, int64_t k) {
assert(k % QK_K == 0);
const int64_t nb = k / QK_K;
for (int i = 0; i < nb; i++) {
const float d = GGML_FP16_TO_FP32(x[i].d);
const uint8_t * qs = x[i].qs;
const uint16_t * qh = x[i].qh;
for (int ib = 0; ib < QK_K/32; ++ib) {
const float dl = d * (2*((qh[ib] >> 12) & 7) + 1);
const float delta = qh[ib] & 0x8000 ? -IQ1S_DELTA : IQ1S_DELTA;
for (int l = 0; l < 4; ++l) {
const int8_t * grid = (const int8_t *)(iq1s_grid + (qs[l] | (((qh[ib] >> 3*l) & 7) << 8)));
for (int j = 0; j < 8; ++j) {
y[j] = dl * (grid[j] + delta);
}
y += 8;
}
qs += 4;
}
}
} | O3 | c | dequantize_row_iq1_s:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testb %dl, %dl
jne 0x33bdd
sarq $0x8, %rdx
testq %rdx, %rdx
jle 0x33bce
xorl %eax, %eax
movq 0x3a4b4(%rip), %r8 # 0x6dfa8
leaq 0x1d861(%rip), %r9 # 0x5135c
leaq 0x21dce(%rip), %r10 # 0x558d0
imulq $0x32, %rax, %rcx
leaq (%rdi,%rcx), %r11
leaq (%rdi,%rcx), %rbx
addq $0x2, %rbx
movzwl -0x2(%rbx), %ecx
movss (%r8,%rcx,4), %xmm0
xorl %r14d, %r14d
movzwl 0x22(%r11,%r14,2), %ebp
xorl %ecx, %ecx
testw %bp, %bp
setns %cl
movl %ebp, %r15d
shrl $0xb, %r15d
andl $0xe, %r15d
incl %r15d
xorps %xmm1, %xmm1
cvtsi2ss %r15d, %xmm1
mulss %xmm0, %xmm1
movss (%r9,%rcx,4), %xmm2
shufps $0x0, %xmm2, %xmm2 # xmm2 = xmm2[0,0,0,0]
shufps $0x0, %xmm1, %xmm1 # xmm1 = xmm1[0,0,0,0]
xorl %r15d, %r15d
movzbl (%rbx,%r15), %r12d
leal (%r15,%r15,2), %ecx
movl %ebp, %r13d
shrl %cl, %r13d
andl $0x7, %r13d
shll $0x8, %r13d
orl %r12d, %r13d
leaq (%r10,%r13,8), %rcx
xorl %r12d, %r12d
movd (%rcx,%r12), %xmm3
punpcklbw %xmm3, %xmm3 # xmm3 = xmm3[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
punpcklwd %xmm3, %xmm3 # xmm3 = xmm3[0,0,1,1,2,2,3,3]
psrad $0x18, %xmm3
cvtdq2ps %xmm3, %xmm3
addps %xmm2, %xmm3
mulps %xmm1, %xmm3
movups %xmm3, (%rsi,%r12,4)
addq $0x4, %r12
cmpq $0x8, %r12
jne 0x33b79
addq $0x20, %rsi
incq %r15
cmpq $0x4, %r15
jne 0x33b58
addq $0x4, %rbx
incq %r14
cmpq $0x8, %r14
jne 0x33b1f
incq %rax
cmpq %rdx, %rax
jne 0x33b02
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x284f8(%rip), %rdi # 0x5c0dc
leaq 0x28109(%rip), %rsi # 0x5bcf4
leaq 0x28aff(%rip), %rcx # 0x5c6f1
movl $0x938, %edx # imm = 0x938
callq 0x16b00
| dequantize_row_iq1_s:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
test dl, dl
jnz loc_33BDD
sar rdx, 8
test rdx, rdx
jle loc_33BCE
xor eax, eax
mov r8, cs:ggml_table_f32_f16_ptr
lea r9, unk_5135C
lea r10, iq1s_grid
loc_33B02:
imul rcx, rax, 32h ; '2'
lea r11, [rdi+rcx]
lea rbx, [rdi+rcx]
add rbx, 2
movzx ecx, word ptr [rbx-2]
movss xmm0, dword ptr [r8+rcx*4]
xor r14d, r14d
loc_33B1F:
movzx ebp, word ptr [r11+r14*2+22h]
xor ecx, ecx
test bp, bp
setns cl
mov r15d, ebp
shr r15d, 0Bh
and r15d, 0Eh
inc r15d
xorps xmm1, xmm1
cvtsi2ss xmm1, r15d
mulss xmm1, xmm0
movss xmm2, dword ptr [r9+rcx*4]
shufps xmm2, xmm2, 0
shufps xmm1, xmm1, 0
xor r15d, r15d
loc_33B58:
movzx r12d, byte ptr [rbx+r15]
lea ecx, [r15+r15*2]
mov r13d, ebp
shr r13d, cl
and r13d, 7
shl r13d, 8
or r13d, r12d
lea rcx, [r10+r13*8]
xor r12d, r12d
loc_33B79:
movd xmm3, dword ptr [rcx+r12]
punpcklbw xmm3, xmm3
punpcklwd xmm3, xmm3
psrad xmm3, 18h
cvtdq2ps xmm3, xmm3
addps xmm3, xmm2
mulps xmm3, xmm1
movups xmmword ptr [rsi+r12*4], xmm3
add r12, 4
cmp r12, 8
jnz short loc_33B79
add rsi, 20h ; ' '
inc r15
cmp r15, 4
jnz short loc_33B58
add rbx, 4
inc r14
cmp r14, 8
jnz loc_33B1F
inc rax
cmp rax, rdx
jnz loc_33B02
loc_33BCE:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_33BDD:
lea rdi, aKQkK0; "k % QK_K == 0"
lea rsi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidDequantize_16; "void dequantize_row_iq1_s(const block_i"...
mov edx, 938h
call ___assert_fail
| long long dequantize_row_iq1_s(long long a1, long long a2, long long a3)
{
long long result; // rax
long long v4; // rdx
unsigned __int16 *v5; // r11
unsigned __int16 *v6; // rbx
float v7; // xmm0_4
long long i; // r14
unsigned int v9; // ebp
__m128 v10; // xmm1
__m128 v11; // xmm2
__m128 v12; // xmm1
long long j; // r15
long long v14; // r13
long long k; // r12
__m128i v16; // xmm3
__m128i v17; // xmm3
if ( (_BYTE)a3 )
__assert_fail(
"k % QK_K == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c",
2360LL,
"void dequantize_row_iq1_s(const block_iq1_s *restrict, float *restrict, int64_t)");
v4 = a3 >> 8;
if ( v4 > 0 )
{
for ( result = 0LL; result != v4; ++result )
{
v5 = (unsigned __int16 *)(a1 + 50 * result);
v6 = v5 + 1;
v7 = ggml_table_f32_f16[*v5];
for ( i = 0LL; i != 8; ++i )
{
v9 = v5[i + 17];
v10 = 0LL;
v10.m128_f32[0] = (float)(int)(((v9 >> 11) & 0xE) + 1) * v7;
v11 = _mm_shuffle_ps(
(__m128)*((unsigned int *)&unk_5135C + ((v9 & 0x8000u) == 0)),
(__m128)*((unsigned int *)&unk_5135C + ((v9 & 0x8000u) == 0)),
0);
v12 = _mm_shuffle_ps(v10, v10, 0);
for ( j = 0LL; j != 4; ++j )
{
v14 = *((unsigned __int8 *)v6 + j) | (((v9 >> (3 * j)) & 7) << 8);
for ( k = 0LL; k != 2; ++k )
{
v16 = _mm_cvtsi32_si128(iq1s_grid[2 * v14 + k]);
v17 = _mm_unpacklo_epi8(v16, v16);
*(__m128 *)(a2 + 1 * k) = _mm_mul_ps(
_mm_add_ps(
_mm_cvtepi32_ps(_mm_srai_epi32(_mm_unpacklo_epi16(v17, v17), 0x18u)),
v11),
v12);
}
a2 += 32LL;
}
v6 += 2;
}
}
}
return result;
}
| dequantize_row_iq1_s:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
TEST DL,DL
JNZ 0x00133bdd
SAR RDX,0x8
TEST RDX,RDX
JLE 0x00133bce
XOR EAX,EAX
MOV R8,qword ptr [0x0016dfa8]
LEA R9,[0x15135c]
LEA R10,[0x1558d0]
LAB_00133b02:
IMUL RCX,RAX,0x32
LEA R11,[RDI + RCX*0x1]
LEA RBX,[RDI + RCX*0x1]
ADD RBX,0x2
MOVZX ECX,word ptr [RBX + -0x2]
MOVSS XMM0,dword ptr [R8 + RCX*0x4]
XOR R14D,R14D
LAB_00133b1f:
MOVZX EBP,word ptr [R11 + R14*0x2 + 0x22]
XOR ECX,ECX
TEST BP,BP
SETNS CL
MOV R15D,EBP
SHR R15D,0xb
AND R15D,0xe
INC R15D
XORPS XMM1,XMM1
CVTSI2SS XMM1,R15D
MULSS XMM1,XMM0
MOVSS XMM2,dword ptr [R9 + RCX*0x4]
SHUFPS XMM2,XMM2,0x0
SHUFPS XMM1,XMM1,0x0
XOR R15D,R15D
LAB_00133b58:
MOVZX R12D,byte ptr [RBX + R15*0x1]
LEA ECX,[R15 + R15*0x2]
MOV R13D,EBP
SHR R13D,CL
AND R13D,0x7
SHL R13D,0x8
OR R13D,R12D
LEA RCX,[R10 + R13*0x8]
XOR R12D,R12D
LAB_00133b79:
MOVD XMM3,dword ptr [RCX + R12*0x1]
PUNPCKLBW XMM3,XMM3
PUNPCKLWD XMM3,XMM3
PSRAD XMM3,0x18
CVTDQ2PS XMM3,XMM3
ADDPS XMM3,XMM2
MULPS XMM3,XMM1
MOVUPS xmmword ptr [RSI + R12*0x4],XMM3
ADD R12,0x4
CMP R12,0x8
JNZ 0x00133b79
ADD RSI,0x20
INC R15
CMP R15,0x4
JNZ 0x00133b58
ADD RBX,0x4
INC R14
CMP R14,0x8
JNZ 0x00133b1f
INC RAX
CMP RAX,RDX
JNZ 0x00133b02
LAB_00133bce:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00133bdd:
LEA RDI,[0x15c0dc]
LEA RSI,[0x15bcf4]
LEA RCX,[0x15c6f1]
MOV EDX,0x938
CALL 0x00116b00
|
void dequantize_row_iq1_s(long param_1,long param_2,long param_3)
{
ushort *puVar1;
float *pfVar2;
float fVar3;
float fVar4;
byte bVar5;
ushort uVar6;
int4 uVar7;
int8 uVar8;
ulong uVar9;
int6 uVar10;
int1 auVar11 [12];
int *puVar12;
long lVar13;
ushort *puVar14;
long lVar15;
long lVar16;
long lVar17;
float fVar18;
short sVar19;
int1 auVar20 [16];
int1 auVar21 [16];
int1 auVar22 [16];
int1 uVar23;
int2 uVar24;
puVar12 = PTR_ggml_table_f32_f16_0016dfa8;
if ((char)param_3 == '\0') {
if (0 < param_3 >> 8) {
lVar13 = 0;
do {
puVar1 = (ushort *)(param_1 + lVar13 * 0x32);
puVar14 = puVar1 + 1;
fVar3 = *(float *)(puVar12 + (ulong)*puVar1 * 4);
lVar16 = 0;
do {
uVar6 = *(ushort *)(param_1 + lVar13 * 0x32 + 0x22 + lVar16 * 2);
fVar18 = (float)(ushort)((uVar6 >> 0xb & 0xe) + 1) * fVar3;
fVar4 = *(float *)(&DAT_0015135c + (ulong)(-1 < (short)uVar6) * 4);
lVar17 = 0;
do {
bVar5 = *(byte *)((long)puVar14 + lVar17);
lVar15 = 0;
do {
uVar7 = *(int4 *)
(iq1s_grid +
lVar15 + (ulong)((uVar6 >> ((char)lVar17 * '\x03' & 0x1fU) & 7) << 8 |
(uint)bVar5) * 8);
uVar23 = (int1)((uint)uVar7 >> 0x18);
uVar24 = CONCAT11(uVar23,uVar23);
uVar23 = (int1)((uint)uVar7 >> 0x10);
uVar8 = CONCAT35(CONCAT21(uVar24,uVar23),CONCAT14(uVar23,uVar7));
uVar23 = (int1)((uint)uVar7 >> 8);
uVar10 = CONCAT51(CONCAT41((int)((ulong)uVar8 >> 0x20),uVar23),uVar23);
sVar19 = CONCAT11((char)uVar7,(char)uVar7);
uVar9 = CONCAT62(uVar10,sVar19);
auVar22._8_4_ = 0;
auVar22._0_8_ = uVar9;
auVar22._12_2_ = uVar24;
auVar22._14_2_ = uVar24;
uVar24 = (int2)((ulong)uVar8 >> 0x20);
auVar21._12_4_ = auVar22._12_4_;
auVar21._8_2_ = 0;
auVar21._0_8_ = uVar9;
auVar21._10_2_ = uVar24;
auVar20._10_6_ = auVar21._10_6_;
auVar20._8_2_ = uVar24;
auVar20._0_8_ = uVar9;
uVar24 = (int2)uVar10;
auVar11._4_8_ = auVar20._8_8_;
auVar11._2_2_ = uVar24;
auVar11._0_2_ = uVar24;
pfVar2 = (float *)(param_2 + lVar15 * 4);
*pfVar2 = ((float)((int)sVar19 >> 8) + fVar4) * fVar18;
pfVar2[1] = ((float)(auVar11._0_4_ >> 0x18) + fVar4) * fVar18;
pfVar2[2] = ((float)(auVar20._8_4_ >> 0x18) + fVar4) * fVar18;
pfVar2[3] = ((float)(auVar21._12_4_ >> 0x18) + fVar4) * fVar18;
lVar15 = lVar15 + 4;
} while (lVar15 != 8);
param_2 = param_2 + 0x20;
lVar17 = lVar17 + 1;
} while (lVar17 != 4);
puVar14 = puVar14 + 2;
lVar16 = lVar16 + 1;
} while (lVar16 != 8);
lVar13 = lVar13 + 1;
} while (lVar13 != param_3 >> 8);
}
return;
}
/* WARNING: Subroutine does not return */
__assert_fail("k % QK_K == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c"
,0x938,
"void dequantize_row_iq1_s(const block_iq1_s *restrict, float *restrict, int64_t)");
}
| |
52,989 | create_last_word_mask | eloqsql/mysys/my_bitmap.c | void create_last_word_mask(MY_BITMAP *map)
{
unsigned char const mask= invers_last_byte_mask(map->n_bits);
/*
The first bytes are to be set to zero since they represent real bits
in the bitvector. The last bytes are set to 0xFF since they represent
bytes not used by the bitvector. Finally the last byte contains bits
as set by the mask above.
*/
unsigned char *ptr= (unsigned char*)&map->last_word_mask;
map->last_word_ptr= map->bitmap + no_words_in_map(map)-1;
switch (no_bytes_in_map(map) & 3) {
case 1:
map->last_word_mask= ~0U;
ptr[0]= mask;
return;
case 2:
map->last_word_mask= ~0U;
ptr[0]= 0;
ptr[1]= mask;
return;
case 3:
map->last_word_mask= 0U;
ptr[2]= mask;
ptr[3]= 0xFFU;
return;
case 0:
map->last_word_mask= 0U;
ptr[3]= mask;
return;
}
} | O0 | c | create_last_word_mask:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %edi
callq 0xed8b0
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movl 0x1c(%rax), %edx
addl $0x1f, %edx
shrl $0x5, %edx
leaq -0x4(%rcx,%rdx,4), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
addl $0x7, %eax
shrl $0x3, %eax
andl $0x3, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x3, %eax
ja 0xed8a7
movq -0x20(%rbp), %rax
leaq 0x6ae0a(%rip), %rcx # 0x158640
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x18(%rax) # imm = 0xFFFFFFFF
movb -0x9(%rbp), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
jmp 0xed8a7
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x18(%rax) # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movb -0x9(%rbp), %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
jmp 0xed8a7
movq -0x8(%rbp), %rax
movl $0x0, 0x18(%rax)
movb -0x9(%rbp), %cl
movq -0x18(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x18(%rbp), %rax
movb $-0x1, 0x3(%rax)
jmp 0xed8a7
movq -0x8(%rbp), %rax
movl $0x0, 0x18(%rax)
movb -0x9(%rbp), %cl
movq -0x18(%rbp), %rax
movb %cl, 0x3(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| create_last_word_mask:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov edi, [rax+1Ch]
call invers_last_byte_mask
mov [rbp+var_9], al
mov rax, [rbp+var_8]
add rax, 18h
mov [rbp+var_18], rax
mov rax, [rbp+var_8]
mov rcx, [rax]
mov edx, [rax+1Ch]
add edx, 1Fh
shr edx, 5
lea rcx, [rcx+rdx*4-4]
mov [rax+8], rcx
mov rax, [rbp+var_8]
mov eax, [rax+1Ch]
add eax, 7
shr eax, 3
and eax, 3
mov ecx, eax
mov [rbp+var_20], rcx
sub eax, 3; switch 4 cases
ja short def_ED83D; jumptable 00000000000ED83D default case
mov rax, [rbp+var_20]
lea rcx, jpt_ED83D
movsxd rax, ds:(jpt_ED83D - 158640h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_ED83F:
mov rax, [rbp+var_8]; jumptable 00000000000ED83D case 1
mov dword ptr [rax+18h], 0FFFFFFFFh
mov cl, [rbp+var_9]
mov rax, [rbp+var_18]
mov [rax], cl
jmp short def_ED83D; jumptable 00000000000ED83D default case
loc_ED855:
mov rax, [rbp+var_8]; jumptable 00000000000ED83D case 2
mov dword ptr [rax+18h], 0FFFFFFFFh
mov rax, [rbp+var_18]
mov byte ptr [rax], 0
mov cl, [rbp+var_9]
mov rax, [rbp+var_18]
mov [rax+1], cl
jmp short def_ED83D; jumptable 00000000000ED83D default case
loc_ED873:
mov rax, [rbp+var_8]; jumptable 00000000000ED83D case 3
mov dword ptr [rax+18h], 0
mov cl, [rbp+var_9]
mov rax, [rbp+var_18]
mov [rax+2], cl
mov rax, [rbp+var_18]
mov byte ptr [rax+3], 0FFh
jmp short def_ED83D; jumptable 00000000000ED83D default case
loc_ED892:
mov rax, [rbp+var_8]; jumptable 00000000000ED83D case 0
mov dword ptr [rax+18h], 0
mov cl, [rbp+var_9]
mov rax, [rbp+var_18]
mov [rax+3], cl
def_ED83D:
add rsp, 20h; jumptable 00000000000ED83D default case
pop rbp
retn
| long long create_last_word_mask(long long a1)
{
long long result; // rax
_BYTE *v2; // [rsp+8h] [rbp-18h]
char byte_mask; // [rsp+17h] [rbp-9h]
byte_mask = invers_last_byte_mask(*(unsigned int *)(a1 + 28));
v2 = (_BYTE *)(a1 + 24);
*(_QWORD *)(a1 + 8) = *(_QWORD *)a1 + 4LL * ((unsigned int)(*(_DWORD *)(a1 + 28) + 31) >> 5) - 4;
result = ((unsigned int)(*(_DWORD *)(a1 + 28) + 7) >> 3) & 3;
switch ( (int)result )
{
case 0:
*(_DWORD *)(a1 + 24) = 0;
result = a1 + 24;
*(_BYTE *)(a1 + 27) = byte_mask;
break;
case 1:
*(_DWORD *)(a1 + 24) = -1;
result = a1 + 24;
*v2 = byte_mask;
break;
case 2:
*(_DWORD *)(a1 + 24) = -1;
*v2 = 0;
result = a1 + 24;
*(_BYTE *)(a1 + 25) = byte_mask;
break;
case 3:
*(_DWORD *)(a1 + 24) = 0;
*(_BYTE *)(a1 + 26) = byte_mask;
result = a1 + 24;
*(_BYTE *)(a1 + 27) = -1;
break;
default:
return result;
}
return result;
}
| create_last_word_mask:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV EDI,dword ptr [RAX + 0x1c]
CALL 0x001ed8b0
MOV byte ptr [RBP + -0x9],AL
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x18
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX]
MOV EDX,dword ptr [RAX + 0x1c]
ADD EDX,0x1f
SHR EDX,0x5
LEA RCX,[RCX + RDX*0x4 + -0x4]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x1c]
ADD EAX,0x7
SHR EAX,0x3
AND EAX,0x3
MOV ECX,EAX
MOV qword ptr [RBP + -0x20],RCX
SUB EAX,0x3
JA 0x001ed8a7
MOV RAX,qword ptr [RBP + -0x20]
LEA RCX,[0x258640]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x18],0xffffffff
MOV CL,byte ptr [RBP + -0x9]
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX],CL
JMP 0x001ed8a7
caseD_2:
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x18],0xffffffff
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX],0x0
MOV CL,byte ptr [RBP + -0x9]
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x1],CL
JMP 0x001ed8a7
caseD_3:
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x18],0x0
MOV CL,byte ptr [RBP + -0x9]
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x2],CL
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x3],0xff
JMP 0x001ed8a7
caseD_0:
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x18],0x0
MOV CL,byte ptr [RBP + -0x9]
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x3],CL
default:
ADD RSP,0x20
POP RBP
RET
|
void create_last_word_mask(long *param_1)
{
int1 uVar1;
uVar1 = invers_last_byte_mask(*(int4 *)((long)param_1 + 0x1c));
param_1[1] = *param_1 + -4 + (ulong)(*(int *)((long)param_1 + 0x1c) + 0x1fU >> 5) * 4;
switch(*(int *)((long)param_1 + 0x1c) + 7U >> 3 & 3) {
case 0:
*(int4 *)(param_1 + 3) = 0;
*(int1 *)((long)param_1 + 0x1b) = uVar1;
break;
case 1:
*(int4 *)(param_1 + 3) = 0xffffffff;
*(int1 *)(param_1 + 3) = uVar1;
break;
case 2:
*(int4 *)(param_1 + 3) = 0xffffffff;
*(int1 *)(param_1 + 3) = 0;
*(int1 *)((long)param_1 + 0x19) = uVar1;
break;
case 3:
*(int4 *)(param_1 + 3) = 0;
*(int1 *)((long)param_1 + 0x1a) = uVar1;
*(int1 *)((long)param_1 + 0x1b) = 0xff;
}
return;
}
| |
52,990 | asio::detail::deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::steady_clock, asio::wait_traits<std::chrono::_V2::steady_clock>>>::deadline_timer_service(asio::execution_context&) | aimrt_mujoco_sim/_deps/asio-src/asio/include/asio/detail/deadline_timer_service.hpp | deadline_timer_service(execution_context& context)
: execution_context_service_base<
deadline_timer_service<Time_Traits>>(context),
scheduler_(asio::use_service<timer_scheduler>(context))
{
scheduler_.init_task();
scheduler_.add_timer_queue(timer_queue_);
} | O0 | cpp | asio::detail::deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::steady_clock, asio::wait_traits<std::chrono::_V2::steady_clock>>>::deadline_timer_service(asio::execution_context&):
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq 0x38(%rsp), %rsi
callq 0x18c730
movq 0x18(%rsp), %rdi
movq 0x4846e2(%rip), %rax # 0x74cfc0
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x28, %rdi
movq %rdi, 0x20(%rsp)
callq 0x192e10
jmp 0x2c88f5
movq 0x18(%rsp), %rax
addq $0x58, %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0x197aa0
movq %rax, 0x10(%rsp)
jmp 0x2c8914
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rdx
movq %rdx, (%rcx)
movq 0x58(%rax), %rdi
callq 0x19e190
jmp 0x2c8931
movq 0x18(%rsp), %rsi
movq 0x58(%rsi), %rdi
addq $0x28, %rsi
callq 0x18bcf0
jmp 0x2c8945
addq $0x48, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x2c8972
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x18eb30
movq 0x18(%rsp), %rdi
callq 0x18b450
movq 0x30(%rsp), %rdi
callq 0x198ce0
nopw %cs:(%rax,%rax)
| _ZN4asio6detail22deadline_timer_serviceINS0_18chrono_time_traitsINSt6chrono3_V212steady_clockENS_11wait_traitsIS5_EEEEEC2ERNS_17execution_contextE:
sub rsp, 48h
mov [rsp+48h+var_8], rdi
mov [rsp+48h+var_10], rsi
mov rdi, [rsp+48h+var_8]
mov [rsp+48h+var_30], rdi
mov rsi, [rsp+48h+var_10]
call __ZN4asio6detail30execution_context_service_baseINS0_22deadline_timer_serviceINS0_18chrono_time_traitsINSt6chrono3_V212steady_clockENS_11wait_traitsIS6_EEEEEEEC2ERNS_17execution_contextE; asio::detail::execution_context_service_base<asio::detail::deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::steady_clock,asio::wait_traits<std::chrono::_V2::steady_clock>>>>::execution_context_service_base(asio::execution_context &)
mov rdi, [rsp+48h+var_30]
mov rax, cs:_ZTVN4asio6detail22deadline_timer_serviceINS0_18chrono_time_traitsINSt6chrono3_V212steady_clockENS_11wait_traitsIS5_EEEEEE_ptr
add rax, 10h
mov [rdi], rax
add rdi, 28h ; '('
mov [rsp+48h+var_28], rdi
call __ZN4asio6detail11timer_queueINS0_18chrono_time_traitsINSt6chrono3_V212steady_clockENS_11wait_traitsIS5_EEEEEC2Ev; asio::detail::timer_queue<asio::detail::chrono_time_traits<std::chrono::_V2::steady_clock,asio::wait_traits<std::chrono::_V2::steady_clock>>>::timer_queue(void)
jmp short $+2
loc_2C88F5:
mov rax, [rsp+48h+var_30]
add rax, 58h ; 'X'
mov [rsp+48h+var_40], rax
mov rdi, [rsp+48h+var_10]
call __ZN4asio11use_serviceINS_6detail13epoll_reactorEEERT_RNS_17execution_contextE; asio::use_service<asio::detail::epoll_reactor>(asio::execution_context &)
mov [rsp+48h+var_38], rax
jmp short $+2
loc_2C8914:
mov rax, [rsp+48h+var_30]
mov rcx, [rsp+48h+var_40]
mov rdx, [rsp+48h+var_38]
mov [rcx], rdx
mov rdi, [rax+58h]; this
call __ZN4asio6detail13epoll_reactor9init_taskEv; asio::detail::epoll_reactor::init_task(void)
jmp short $+2
loc_2C8931:
mov rsi, [rsp+48h+var_30]
mov rdi, [rsi+58h]
add rsi, 28h ; '('
call __ZN4asio6detail13epoll_reactor15add_timer_queueINS0_18chrono_time_traitsINSt6chrono3_V212steady_clockENS_11wait_traitsIS6_EEEEEEvRNS0_11timer_queueIT_EE; asio::detail::epoll_reactor::add_timer_queue<asio::detail::chrono_time_traits<std::chrono::_V2::steady_clock,asio::wait_traits<std::chrono::_V2::steady_clock>>>(asio::detail::timer_queue<asio::detail::chrono_time_traits<std::chrono::_V2::steady_clock,asio::wait_traits<std::chrono::_V2::steady_clock>>> &)
jmp short $+2
loc_2C8945:
add rsp, 48h
retn
mov rcx, rax
mov eax, edx
mov [rsp+arg_28], rcx
mov [rsp+arg_24], eax
jmp short loc_2C8972
mov rdi, [rsp+arg_18]
mov rcx, rax
mov eax, edx
mov [rsp+arg_28], rcx
mov [rsp+arg_24], eax
call __ZN4asio6detail11timer_queueINS0_18chrono_time_traitsINSt6chrono3_V212steady_clockENS_11wait_traitsIS5_EEEEED2Ev; asio::detail::timer_queue<asio::detail::chrono_time_traits<std::chrono::_V2::steady_clock,asio::wait_traits<std::chrono::_V2::steady_clock>>>::~timer_queue()
loc_2C8972:
mov rdi, [rsp+arg_10]
call __ZN4asio6detail30execution_context_service_baseINS0_22deadline_timer_serviceINS0_18chrono_time_traitsINSt6chrono3_V212steady_clockENS_11wait_traitsIS6_EEEEEEED2Ev; asio::detail::execution_context_service_base<asio::detail::deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::steady_clock,asio::wait_traits<std::chrono::_V2::steady_clock>>>>::~execution_context_service_base()
mov rdi, [rsp+arg_28]
call __Unwind_Resume
| long long asio::detail::deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::steady_clock,asio::wait_traits<std::chrono::_V2::steady_clock>>>::deadline_timer_service(
long long a1,
long long a2)
{
asio::detail::execution_context_service_base<asio::detail::deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::steady_clock,asio::wait_traits<std::chrono::_V2::steady_clock>>>>::execution_context_service_base(
a1,
a2);
*(_QWORD *)a1 = &`vtable for'asio::detail::deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::steady_clock,asio::wait_traits<std::chrono::_V2::steady_clock>>>
+ 2;
asio::detail::timer_queue<asio::detail::chrono_time_traits<std::chrono::_V2::steady_clock,asio::wait_traits<std::chrono::_V2::steady_clock>>>::timer_queue();
*(_QWORD *)(a1 + 88) = asio::use_service<asio::detail::epoll_reactor>(a2);
asio::detail::epoll_reactor::init_task(*(asio::detail::epoll_reactor **)(a1 + 88));
return asio::detail::epoll_reactor::add_timer_queue<asio::detail::chrono_time_traits<std::chrono::_V2::steady_clock,asio::wait_traits<std::chrono::_V2::steady_clock>>>(
*(_QWORD *)(a1 + 88),
a1 + 40);
}
| |||
52,991 | asio::detail::deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::steady_clock, asio::wait_traits<std::chrono::_V2::steady_clock>>>::deadline_timer_service(asio::execution_context&) | aimrt_mujoco_sim/_deps/asio-src/asio/include/asio/detail/deadline_timer_service.hpp | deadline_timer_service(execution_context& context)
: execution_context_service_base<
deadline_timer_service<Time_Traits>>(context),
scheduler_(asio::use_service<timer_scheduler>(context))
{
scheduler_.init_task();
scheduler_.add_timer_queue(timer_queue_);
} | O3 | cpp | asio::detail::deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::steady_clock, asio::wait_traits<std::chrono::_V2::steady_clock>>>::deadline_timer_service(asio::execution_context&):
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq %rsi, 0x18(%rdi)
xorl %eax, %eax
movq %rax, 0x20(%rdi)
movq 0x1ac520(%rip), %rcx # 0x2a0ad8
addq $0x10, %rcx
movq %rcx, (%rdi)
movq %rax, 0x30(%rdi)
movq 0x1ac22e(%rip), %r15 # 0x2a07f8
addq $0x10, %r15
movq %r15, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
movq (%rsi), %rdi
movq 0x1ac3e4(%rip), %rcx # 0x2a09c8
movq %rsp, %rsi
movq %rcx, (%rsi)
movq %rax, 0x8(%rsi)
movq 0x30(%rdi), %rcx
movq 0x1ac95f(%rip), %rdx # 0x2a0f58
callq 0x83930
movq %rax, 0x58(%rbx)
movq 0x30(%rax), %rdi
callq 0x837c0
leaq 0x28(%rbx), %rsi
movq 0x58(%rbx), %rdi
callq 0x82320
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, 0x28(%rbx)
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0xf463e
movq 0x50(%rbx), %rsi
subq %rdi, %rsi
callq 0x82190
movq %r14, %rdi
callq 0x83b70
| _ZN4asio6detail22deadline_timer_serviceINS0_18chrono_time_traitsINSt6chrono3_V212system_clockENS_11wait_traitsIS5_EEEEEC2ERNS_17execution_contextE:
push r15
push r14
push rbx
sub rsp, 10h
mov rbx, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi+8], xmm0
mov [rdi+18h], rsi
xor eax, eax
mov [rdi+20h], rax
mov rcx, cs:_ZTVN4asio6detail22deadline_timer_serviceINS0_18chrono_time_traitsINSt6chrono3_V212system_clockENS_11wait_traitsIS5_EEEEEE_ptr
add rcx, 10h
mov [rdi], rcx
mov [rdi+30h], rax
mov r15, cs:_ZTVN4asio6detail11timer_queueINS0_18chrono_time_traitsINSt6chrono3_V212system_clockENS_11wait_traitsIS5_EEEEEE_ptr
add r15, 10h
mov [rdi+28h], r15
movups xmmword ptr [rdi+38h], xmm0
movups xmmword ptr [rdi+48h], xmm0
mov rdi, [rsi]
mov rcx, cs:_ZTIN4asio6detail14typeid_wrapperINS0_13epoll_reactorEEE_ptr
mov rsi, rsp
mov [rsi], rcx
mov [rsi+8], rax
mov rcx, [rdi+30h]
mov rdx, cs:_ZN4asio6detail16service_registry6createINS0_13epoll_reactorENS_17execution_contextEEEPNS4_7serviceEPv_ptr
call __ZN4asio6detail16service_registry14do_use_serviceERKNS_17execution_context7service3keyEPFPS3_PvES8_; asio::detail::service_registry::do_use_service(asio::execution_context::service::key const&,asio::execution_context::service* (*)(void *),void *)
mov [rbx+58h], rax
mov rdi, [rax+30h]; this
call __ZN4asio6detail9scheduler9init_taskEv; asio::detail::scheduler::init_task(void)
lea rsi, [rbx+28h]
mov rdi, [rbx+58h]
call __ZN4asio6detail13epoll_reactor15add_timer_queueINS0_18chrono_time_traitsINSt6chrono3_V212system_clockENS_11wait_traitsIS6_EEEEEEvRNS0_11timer_queueIT_EE; asio::detail::epoll_reactor::add_timer_queue<asio::detail::chrono_time_traits<std::chrono::_V2::system_clock,asio::wait_traits<std::chrono::_V2::system_clock>>>(asio::detail::timer_queue<asio::detail::chrono_time_traits<std::chrono::_V2::system_clock,asio::wait_traits<std::chrono::_V2::system_clock>>> &)
add rsp, 10h
pop rbx
pop r14
pop r15
retn
mov r14, rax
mov [rbx+28h], r15
mov rdi, [rbx+40h]; void *
test rdi, rdi
jz short loc_F463E
mov rsi, [rbx+50h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_F463E:
mov rdi, r14
call __Unwind_Resume
| long long asio::detail::deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::system_clock,asio::wait_traits<std::chrono::_V2::system_clock>>>::deadline_timer_service(
long long a1,
long long *a2)
{
long long v3; // rdi
long long v4; // rax
_QWORD v6[5]; // [rsp+0h] [rbp-28h] BYREF
*(_OWORD *)(a1 + 8) = 0LL;
*(_QWORD *)(a1 + 24) = a2;
*(_QWORD *)(a1 + 32) = 0LL;
*(_QWORD *)a1 = &`vtable for'asio::detail::deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::system_clock,asio::wait_traits<std::chrono::_V2::system_clock>>>
+ 2;
*(_QWORD *)(a1 + 48) = 0LL;
*(_QWORD *)(a1 + 40) = &`vtable for'asio::detail::timer_queue<asio::detail::chrono_time_traits<std::chrono::_V2::system_clock,asio::wait_traits<std::chrono::_V2::system_clock>>>
+ 2;
*(_OWORD *)(a1 + 56) = 0LL;
*(_OWORD *)(a1 + 72) = 0LL;
v3 = *a2;
v6[0] = &`typeinfo for'asio::detail::typeid_wrapper<asio::detail::epoll_reactor>;
v6[1] = 0LL;
v4 = asio::detail::service_registry::do_use_service(
v3,
v6,
asio::detail::service_registry::create<asio::detail::epoll_reactor,asio::execution_context>);
*(_QWORD *)(a1 + 88) = v4;
asio::detail::scheduler::init_task(*(asio::detail::scheduler **)(v4 + 48));
return asio::detail::epoll_reactor::add_timer_queue<asio::detail::chrono_time_traits<std::chrono::_V2::system_clock,asio::wait_traits<std::chrono::_V2::system_clock>>>(
*(_QWORD *)(a1 + 88),
a1 + 40);
}
| deadline_timer_service:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x8],XMM0
MOV qword ptr [RDI + 0x18],RSI
XOR EAX,EAX
MOV qword ptr [RDI + 0x20],RAX
MOV RCX,qword ptr [0x003a0ad8]
ADD RCX,0x10
MOV qword ptr [RDI],RCX
MOV qword ptr [RDI + 0x30],RAX
MOV R15,qword ptr [0x003a07f8]
ADD R15,0x10
MOV qword ptr [RDI + 0x28],R15
MOVUPS xmmword ptr [RDI + 0x38],XMM0
MOVUPS xmmword ptr [RDI + 0x48],XMM0
MOV RDI,qword ptr [RSI]
MOV RCX,qword ptr [0x003a09c8]
MOV RSI,RSP
MOV qword ptr [RSI],RCX
MOV qword ptr [RSI + 0x8],RAX
MOV RCX,qword ptr [RDI + 0x30]
LAB_001f45f2:
MOV RDX,qword ptr [0x003a0f58]
CALL 0x00183930
MOV qword ptr [RBX + 0x58],RAX
MOV RDI,qword ptr [RAX + 0x30]
CALL 0x001837c0
LEA RSI,[RBX + 0x28]
MOV RDI,qword ptr [RBX + 0x58]
CALL 0x00182320
LAB_001f4618:
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
|
/* asio::detail::deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::system_clock,
asio::wait_traits<std::chrono::_V2::system_clock> >
>::deadline_timer_service(asio::execution_context&) */
void __thiscall
asio::detail::
deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::system_clock,asio::wait_traits<std::chrono::_V2::system_clock>>>
::deadline_timer_service
(deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::system_clock,asio::wait_traits<std::chrono::_V2::system_clock>>>
*this,execution_context *param_1)
{
long lVar1;
int *local_28;
int8 local_20;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
*(execution_context **)(this + 0x18) = param_1;
*(int8 *)(this + 0x20) = 0;
*(int **)this = PTR_vtable_003a0ad8 + 0x10;
*(int8 *)(this + 0x30) = 0;
*(int **)(this + 0x28) = PTR_vtable_003a07f8 + 0x10;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
*(int8 *)(this + 0x50) = 0;
local_28 = PTR_typeinfo_003a09c8;
local_20 = 0;
/* try { // try from 001f45f2 to 001f4617 has its CatchHandler @ 001f4622 */
lVar1 = service_registry::do_use_service
(*(service_registry **)param_1,(key *)&local_28,
(_func_service_ptr_void_ptr *)
PTR_create<asio_detail_epoll_reactor,asio_execution_context>_003a0f58,
*(void **)(*(service_registry **)param_1 + 0x30));
*(long *)(this + 0x58) = lVar1;
scheduler::init_task(*(scheduler **)(lVar1 + 0x30));
epoll_reactor::
add_timer_queue<asio::detail::chrono_time_traits<std::chrono::_V2::system_clock,asio::wait_traits<std::chrono::_V2::system_clock>>>
(*(epoll_reactor **)(this + 0x58),(timer_queue *)(this + 0x28));
return;
}
| |
52,992 | str_to_datetime_or_date_or_interval_day | eloqsql/client/../sql-common/my_time.c | my_bool
str_to_datetime_or_date_or_interval_day(const char *str, size_t length,
MYSQL_TIME *to, ulonglong mode,
MYSQL_TIME_STATUS *status,
ulong time_max_hour,
ulong time_err_hour)
{
my_bool neg;
DBUG_ASSERT(C_FLAGS_OK(mode));
my_time_status_init(status);
/*
For backward compatibility we allow to parse non-delimited
values as DATE rather than as TIME:
EXTRACT(DAY FROM '11111')
*/
return
find_body(&neg, str, length, to, &status->warnings, &str, &length) ||
str_to_datetime_or_date_or_time_body(str, length, to, mode, status,
time_max_hour, time_err_hour,
TRUE, TRUE) ||
set_neg(neg, status, to);
} | O0 | c | str_to_datetime_or_date_or_interval_day:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
jmp 0x48bd6
movq -0x28(%rbp), %rdi
callq 0x478f0
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq -0x31(%rbp), %rdi
leaq -0x8(%rbp), %r9
leaq -0x10(%rbp), %rax
movq %rax, (%rsp)
callq 0x47920
movb %al, %cl
movb $0x1, %al
cmpb $0x0, %cl
movb %al, -0x32(%rbp)
jne 0x48c6c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movq 0x10(%rbp), %rax
movq %rax, (%rsp)
movl $0x1, 0x8(%rsp)
movl $0x1, 0x10(%rsp)
callq 0x488b0
movb %al, %cl
movb $0x1, %al
cmpb $0x0, %cl
movb %al, -0x32(%rbp)
jne 0x48c6c
movb -0x31(%rbp), %al
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
movsbl %al, %edi
callq 0x48a90
cmpb $0x0, %al
setne %al
movb %al, -0x32(%rbp)
movb -0x32(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| str_to_datetime_or_date_or_interval_day:
push rbp
mov rbp, rsp
sub rsp, 50h
mov rax, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
jmp short $+2
loc_48BD6:
mov rdi, [rbp+var_28]
call _ZL19my_time_status_initP20st_mysql_time_status; my_time_status_init(st_mysql_time_status *)
mov rsi, [rbp+var_8]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_18]
mov r8, [rbp+var_28]
lea rdi, [rbp+var_31]
lea r9, [rbp+var_8]
lea rax, [rbp+var_10]
mov [rsp+50h+var_50], rax
call _ZL9find_bodyPcPKcmP13st_mysql_timePiPS1_Pm; find_body(char *,char const*,ulong,st_mysql_time *,int *,char const**,ulong *)
mov cl, al
mov al, 1
cmp cl, 0
mov [rbp+var_32], al
jnz short loc_48C6C
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
mov r8, [rbp+var_28]
mov r9, [rbp+var_30]
mov rax, [rbp+arg_0]
mov [rsp+50h+var_50], rax
mov [rsp+50h+var_48], 1
mov [rsp+50h+var_40], 1
call _ZL36str_to_datetime_or_date_or_time_bodyPKcmP13st_mysql_timeyP20st_mysql_time_statusmmcc; str_to_datetime_or_date_or_time_body(char const*,ulong,st_mysql_time *,ulong long,st_mysql_time_status *,ulong,ulong,char,char)
mov cl, al
mov al, 1
cmp cl, 0
mov [rbp+var_32], al
jnz short loc_48C6C
mov al, [rbp+var_31]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_18]
movsx edi, al
call _ZL7set_negcP20st_mysql_time_statusP13st_mysql_time; set_neg(char,st_mysql_time_status *,st_mysql_time *)
cmp al, 0
setnz al
mov [rbp+var_32], al
loc_48C6C:
mov al, [rbp+var_32]
and al, 1
add rsp, 50h
pop rbp
retn
| bool str_to_datetime_or_date_or_interval_day(
char *a1,
unsigned long long a2,
long long a3,
long long a4,
_DWORD *a5,
unsigned long long a6,
unsigned long long a7)
{
bool v8; // [rsp+1Eh] [rbp-32h]
char v9; // [rsp+1Fh] [rbp-31h] BYREF
unsigned long long v10; // [rsp+20h] [rbp-30h]
_DWORD *v11; // [rsp+28h] [rbp-28h]
long long v12; // [rsp+30h] [rbp-20h]
long long v13; // [rsp+38h] [rbp-18h]
unsigned long long v14; // [rsp+40h] [rbp-10h] BYREF
char *v15; // [rsp+48h] [rbp-8h] BYREF
v15 = a1;
v14 = a2;
v13 = a3;
v12 = a4;
v11 = a5;
v10 = a6;
my_time_status_init(a5);
v8 = 1;
if ( !find_body(&v9, a1, a2, v13, v11, &v15, &v14) )
{
v8 = 1;
if ( !str_to_datetime_or_date_or_time_body(v15, v14, v13, v12, (long long)v11, v10, a7, 1, 1) )
return set_neg(v9, v11, v13) != 0;
}
return v8;
}
| str_to_datetime_or_date_or_interval_day:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
JMP 0x00148bd6
LAB_00148bd6:
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x001478f0
MOV RSI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x18]
MOV R8,qword ptr [RBP + -0x28]
LEA RDI,[RBP + -0x31]
LEA R9,[RBP + -0x8]
LEA RAX,[RBP + -0x10]
MOV qword ptr [RSP],RAX
CALL 0x00147920
MOV CL,AL
MOV AL,0x1
CMP CL,0x0
MOV byte ptr [RBP + -0x32],AL
JNZ 0x00148c6c
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
MOV R8,qword ptr [RBP + -0x28]
MOV R9,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RSP],RAX
MOV dword ptr [RSP + 0x8],0x1
MOV dword ptr [RSP + 0x10],0x1
CALL 0x001488b0
MOV CL,AL
MOV AL,0x1
CMP CL,0x0
MOV byte ptr [RBP + -0x32],AL
JNZ 0x00148c6c
MOV AL,byte ptr [RBP + -0x31]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x18]
MOVSX EDI,AL
CALL 0x00148a90
CMP AL,0x0
SETNZ AL
MOV byte ptr [RBP + -0x32],AL
LAB_00148c6c:
MOV AL,byte ptr [RBP + -0x32]
AND AL,0x1
ADD RSP,0x50
POP RBP
RET
|
int8
str_to_datetime_or_date_or_interval_day
(char *param_1,ulong param_2,st_mysql_time *param_3,ulonglong param_4,
st_mysql_time_status *param_5,ulong param_6,ulong param_7)
{
int8 uVar1;
int7 uVar2;
bool local_3a;
char local_39;
ulong local_38;
st_mysql_time_status *local_30;
ulonglong local_28;
st_mysql_time *local_20;
ulong local_18;
char *local_10;
local_38 = param_6;
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
my_time_status_init(param_5);
uVar1 = find_body(&local_39,local_10,local_18,local_20,(int *)local_30,&local_10,&local_18);
uVar2 = (int7)((ulong)uVar1 >> 8);
local_3a = true;
if ((char)uVar1 == '\0') {
uVar1 = str_to_datetime_or_date_or_time_body
(local_10,local_18,local_20,local_28,local_30,local_38,param_7,'\x01','\x01');
uVar2 = (int7)((ulong)uVar1 >> 8);
local_3a = true;
if ((char)uVar1 == '\0') {
uVar1 = set_neg(local_39,local_30,local_20);
local_3a = (char)uVar1 != '\0';
uVar2 = (int7)((ulong)uVar1 >> 8);
}
}
return CONCAT71(uVar2,local_3a);
}
| |
52,993 | str_to_datetime_or_date_or_interval_day | eloqsql/client/../sql-common/my_time.c | my_bool
str_to_datetime_or_date_or_interval_day(const char *str, size_t length,
MYSQL_TIME *to, ulonglong mode,
MYSQL_TIME_STATUS *status,
ulong time_max_hour,
ulong time_err_hour)
{
my_bool neg;
DBUG_ASSERT(C_FLAGS_OK(mode));
my_time_status_init(status);
/*
For backward compatibility we allow to parse non-delimited
values as DATE rather than as TIME:
EXTRACT(DAY FROM '11111')
*/
return
find_body(&neg, str, length, to, &status->warnings, &str, &length) ||
str_to_datetime_or_date_or_time_body(str, length, to, mode, status,
time_max_hour, time_err_hour,
TRUE, TRUE) ||
set_neg(neg, status, to);
} | O3 | c | str_to_datetime_or_date_or_interval_day:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r12
movq %r8, %rbx
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %rdx
movq %rdi, %rsi
leaq -0x40(%rbp), %r9
movq %rdi, (%r9)
leaq -0x38(%rbp), %rax
movq %rdx, (%rax)
movq $0x0, (%r8)
movl $0x0, 0x8(%r8)
subq $0x8, %rsp
leaq -0x29(%rbp), %rdi
movq %r14, %rcx
pushq %rax
callq 0x450fb
addq $0x10, %rsp
movb $0x1, %r15b
testb %al, %al
jne 0x45f31
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
subq $0x8, %rsp
movl $0x1, %eax
movq %r14, %rdx
movq %r13, %rcx
movq %rbx, %r8
movq %r12, %r9
pushq %rax
pushq %rax
pushq 0x10(%rbp)
callq 0x45c52
addq $0x20, %rsp
testb %al, %al
jne 0x45f31
movb -0x29(%rbp), %al
movb %al, 0x20(%r14)
testb %al, %al
je 0x45f29
cmpl $0x2, 0x24(%r14)
jne 0x45f2e
xorl %r15d, %r15d
jmp 0x45f31
orb $0x2, (%rbx)
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| str_to_datetime_or_date_or_interval_day:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r12, r9
mov rbx, r8
mov r13, rcx
mov r14, rdx
mov rdx, rsi
mov rsi, rdi
lea r9, [rbp+var_40]
mov [r9], rdi
lea rax, [rbp+var_38]
mov [rax], rdx
mov qword ptr [r8], 0
mov dword ptr [r8+8], 0
sub rsp, 8
lea rdi, [rbp+var_29]
mov rcx, r14
push rax
call _ZL9find_bodyPcPKcmP13st_mysql_timePiPS1_Pm; find_body(char *,char const*,ulong,st_mysql_time *,int *,char const**,ulong *)
add rsp, 10h
mov r15b, 1
test al, al
jnz short loc_45F31
mov rdi, [rbp+var_40]
mov rsi, [rbp+var_38]
sub rsp, 8
mov eax, 1
mov rdx, r14
mov rcx, r13
mov r8, rbx
mov r9, r12
push rax
push rax
push [rbp+arg_0]
call _ZL36str_to_datetime_or_date_or_time_bodyPKcmP13st_mysql_timeyP20st_mysql_time_statusmmcc; str_to_datetime_or_date_or_time_body(char const*,ulong,st_mysql_time *,ulong long,st_mysql_time_status *,ulong,ulong,char,char)
add rsp, 20h
test al, al
jnz short loc_45F31
mov al, [rbp+var_29]
mov [r14+20h], al
test al, al
jz short loc_45F29
cmp dword ptr [r14+24h], 2
jnz short loc_45F2E
loc_45F29:
xor r15d, r15d
jmp short loc_45F31
loc_45F2E:
or byte ptr [rbx], 2
loc_45F31:
mov eax, r15d
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long str_to_datetime_or_date_or_interval_day(
char *a1,
long long a2,
long long a3,
int a4,
int *a5,
unsigned long long a6,
unsigned long long a7)
{
unsigned int v7; // r15d
bool v12; // al
char *v14; // [rsp+8h] [rbp-40h] BYREF
unsigned long long v15; // [rsp+10h] [rbp-38h] BYREF
bool v16; // [rsp+1Fh] [rbp-29h] BYREF
v14 = a1;
v15 = a2;
*(_QWORD *)a5 = 0LL;
a5[2] = 0;
LOBYTE(v7) = 1;
if ( !find_body(&v16, (unsigned __int8 *)a1, a2, a3, a5, &v14, (long long *)&v15)
&& !(unsigned __int8)str_to_datetime_or_date_or_time_body(v14, v15, a3, a4, a5, a6, a7, 1, 1) )
{
v12 = v16;
*(_BYTE *)(a3 + 32) = v16;
if ( v12 && *(_DWORD *)(a3 + 36) != 2 )
*(_BYTE *)a5 |= 2u;
else
return 0;
}
return v7;
}
| str_to_datetime_or_date_or_interval_day:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R12,R9
MOV RBX,R8
MOV R13,RCX
MOV R14,RDX
MOV RDX,RSI
MOV RSI,RDI
LEA R9,[RBP + -0x40]
MOV qword ptr [R9],RDI
LEA RAX,[RBP + -0x38]
MOV qword ptr [RAX],RDX
MOV qword ptr [R8],0x0
MOV dword ptr [R8 + 0x8],0x0
SUB RSP,0x8
LEA RDI,[RBP + -0x29]
MOV RCX,R14
PUSH RAX
CALL 0x001450fb
ADD RSP,0x10
MOV R15B,0x1
TEST AL,AL
JNZ 0x00145f31
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x38]
SUB RSP,0x8
MOV EAX,0x1
MOV RDX,R14
MOV RCX,R13
MOV R8,RBX
MOV R9,R12
PUSH RAX
PUSH RAX
PUSH qword ptr [RBP + 0x10]
CALL 0x00145c52
ADD RSP,0x20
TEST AL,AL
JNZ 0x00145f31
MOV AL,byte ptr [RBP + -0x29]
MOV byte ptr [R14 + 0x20],AL
TEST AL,AL
JZ 0x00145f29
CMP dword ptr [R14 + 0x24],0x2
JNZ 0x00145f2e
LAB_00145f29:
XOR R15D,R15D
JMP 0x00145f31
LAB_00145f2e:
OR byte ptr [RBX],0x2
LAB_00145f31:
MOV EAX,R15D
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong str_to_datetime_or_date_or_interval_day
(char *param_1,ulong param_2,st_mysql_time *param_3,ulonglong param_4,
st_mysql_time_status *param_5,ulong param_6,ulong param_7)
{
char cVar1;
int8 unaff_R15;
ulong uVar2;
char *local_48;
ulong local_40;
st_mysql_time local_31;
*(int8 *)param_5 = 0;
*(int4 *)(param_5 + 8) = 0;
local_48 = param_1;
local_40 = param_2;
cVar1 = find_body((char *)&local_31,param_1,param_2,param_3,(int *)param_5,&local_48,&local_40);
uVar2 = CONCAT71((int7)((ulong)unaff_R15 >> 8),1);
if (cVar1 == '\0') {
cVar1 = str_to_datetime_or_date_or_time_body
(local_48,local_40,param_3,param_4,param_5,param_6,param_7,'\x01','\x01');
if (cVar1 == '\0') {
param_3[0x20] = local_31;
if ((local_31 == (st_mysql_time)0x0) || (*(int *)(param_3 + 0x24) == 2)) {
uVar2 = 0;
}
else {
*param_5 = (st_mysql_time_status)((byte)*param_5 | 2);
}
}
}
return uVar2 & 0xffffffff;
}
| |
52,994 | blst_p2_compress | corpus-core[P]colibri-stateless/build_O1/_deps/blst-src/src/e2.c | void blst_p2_compress(unsigned char out[96], const POINTonE2 *in)
{
if (vec_is_zero(in->Z, sizeof(in->Z))) {
bytes_zero(out, 96);
out[0] = 0xc0; /* compressed and infinity bits */
} else {
limb_t sign = POINTonE2_Compress_BE(out, in);
out[0] |= (unsigned char)(0x80 | ((sign & 2) << 4));
}
} | O1 | c | blst_p2_compress:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xc0(%rsi), %r15
movl $0x60, %esi
movq %r15, %rdi
callq 0x30680
testq %rax, %rax
je 0x1c79f
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movb $-0x40, %al
jmp 0x1c7e1
leaq 0x233b2(%rip), %rsi # 0x3fb58
movl $0x60, %edx
movq %r15, %rdi
callq 0x306c0
testq %rax, %rax
jne 0x1c7cd
leaq -0x138(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1c06a
movq %r15, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1c684
shlb $0x4, %al
andb $0x20, %al
orb (%rbx), %al
orb $-0x80, %al
movb %al, (%rbx)
addq $0x128, %rsp # imm = 0x128
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| blst_p2_compress:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 128h
mov r14, rsi
mov rbx, rdi
lea r15, [rsi+0C0h]
mov esi, 60h ; '`'
mov rdi, r15
call vec_is_zero_16x
test rax, rax
jz short loc_1C79F
xorps xmm0, xmm0
movups xmmword ptr [rbx+50h], xmm0
movups xmmword ptr [rbx+40h], xmm0
movups xmmword ptr [rbx+30h], xmm0
movups xmmword ptr [rbx+20h], xmm0
movups xmmword ptr [rbx+10h], xmm0
movups xmmword ptr [rbx], xmm0
mov al, 0C0h
jmp short loc_1C7E1
loc_1C79F:
lea rsi, BLS12_381_Rx
mov edx, 60h ; '`'
mov rdi, r15
call vec_is_equal_16x
test rax, rax
jnz short loc_1C7CD
lea r15, [rbp+var_138]
mov rdi, r15
mov rsi, r14
call POINTonE2_from_Jacobian
mov r14, r15
loc_1C7CD:
mov rdi, rbx
mov rsi, r14
call POINTonE2_affine_Compress_BE
shl al, 4
and al, 20h
or al, [rbx]
or al, 80h
loc_1C7E1:
mov [rbx], al
add rsp, 128h
pop rbx
pop r14
pop r15
pop rbp
retn
| char blst_p2_compress(long long a1, long long a2)
{
_BYTE *v2; // r14
char result; // al
_BYTE v4[312]; // [rsp+8h] [rbp-138h] BYREF
v2 = (_BYTE *)a2;
if ( vec_is_zero_16x(a2 + 192, 96LL) )
{
*(_OWORD *)(a1 + 80) = 0LL;
*(_OWORD *)(a1 + 64) = 0LL;
*(_OWORD *)(a1 + 48) = 0LL;
*(_OWORD *)(a1 + 32) = 0LL;
*(_OWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
result = -64;
}
else
{
if ( !vec_is_equal_16x(a2 + 192, &BLS12_381_Rx, 96LL) )
{
POINTonE2_from_Jacobian((long long)v4, a2);
v2 = v4;
}
result = *(_BYTE *)a1 | (16 * POINTonE2_affine_Compress_BE((_BYTE *)a1, (long long)v2)) & 0x20 | 0x80;
}
*(_BYTE *)a1 = result;
return result;
}
| blst_p2_compress:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x128
MOV R14,RSI
MOV RBX,RDI
LEA R15,[RSI + 0xc0]
MOV ESI,0x60
MOV RDI,R15
CALL 0x00130680
TEST RAX,RAX
JZ 0x0011c79f
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x50],XMM0
MOVUPS xmmword ptr [RBX + 0x40],XMM0
MOVUPS xmmword ptr [RBX + 0x30],XMM0
MOVUPS xmmword ptr [RBX + 0x20],XMM0
MOVUPS xmmword ptr [RBX + 0x10],XMM0
MOVUPS xmmword ptr [RBX],XMM0
MOV AL,0xc0
JMP 0x0011c7e1
LAB_0011c79f:
LEA RSI,[0x13fb58]
MOV EDX,0x60
MOV RDI,R15
CALL 0x001306c0
TEST RAX,RAX
JNZ 0x0011c7cd
LEA R15,[RBP + -0x138]
MOV RDI,R15
MOV RSI,R14
CALL 0x0011c06a
MOV R14,R15
LAB_0011c7cd:
MOV RDI,RBX
MOV RSI,R14
CALL 0x0011c684
SHL AL,0x4
AND AL,0x20
OR AL,byte ptr [RBX]
OR AL,0x80
LAB_0011c7e1:
MOV byte ptr [RBX],AL
ADD RSP,0x128
POP RBX
POP R14
POP R15
POP RBP
RET
|
void blst_p2_compress(byte *param_1,int1 *param_2)
{
long lVar1;
byte bVar2;
int1 *puVar3;
int1 local_140 [288];
lVar1 = vec_is_zero_16x(param_2 + 0xc0,0x60);
if (lVar1 == 0) {
lVar1 = vec_is_equal_16x(param_2 + 0xc0,&BLS12_381_Rx,0x60);
puVar3 = param_2;
if (lVar1 == 0) {
puVar3 = local_140;
POINTonE2_from_Jacobian(puVar3,param_2);
}
bVar2 = POINTonE2_affine_Compress_BE(param_1,puVar3);
bVar2 = (bVar2 & 2) << 4 | *param_1 | 0x80;
}
else {
param_1[0x50] = 0;
param_1[0x51] = 0;
param_1[0x52] = 0;
param_1[0x53] = 0;
param_1[0x54] = 0;
param_1[0x55] = 0;
param_1[0x56] = 0;
param_1[0x57] = 0;
param_1[0x58] = 0;
param_1[0x59] = 0;
param_1[0x5a] = 0;
param_1[0x5b] = 0;
param_1[0x5c] = 0;
param_1[0x5d] = 0;
param_1[0x5e] = 0;
param_1[0x5f] = 0;
param_1[0x40] = 0;
param_1[0x41] = 0;
param_1[0x42] = 0;
param_1[0x43] = 0;
param_1[0x44] = 0;
param_1[0x45] = 0;
param_1[0x46] = 0;
param_1[0x47] = 0;
param_1[0x48] = 0;
param_1[0x49] = 0;
param_1[0x4a] = 0;
param_1[0x4b] = 0;
param_1[0x4c] = 0;
param_1[0x4d] = 0;
param_1[0x4e] = 0;
param_1[0x4f] = 0;
param_1[0x30] = 0;
param_1[0x31] = 0;
param_1[0x32] = 0;
param_1[0x33] = 0;
param_1[0x34] = 0;
param_1[0x35] = 0;
param_1[0x36] = 0;
param_1[0x37] = 0;
param_1[0x38] = 0;
param_1[0x39] = 0;
param_1[0x3a] = 0;
param_1[0x3b] = 0;
param_1[0x3c] = 0;
param_1[0x3d] = 0;
param_1[0x3e] = 0;
param_1[0x3f] = 0;
param_1[0x20] = 0;
param_1[0x21] = 0;
param_1[0x22] = 0;
param_1[0x23] = 0;
param_1[0x24] = 0;
param_1[0x25] = 0;
param_1[0x26] = 0;
param_1[0x27] = 0;
param_1[0x28] = 0;
param_1[0x29] = 0;
param_1[0x2a] = 0;
param_1[0x2b] = 0;
param_1[0x2c] = 0;
param_1[0x2d] = 0;
param_1[0x2e] = 0;
param_1[0x2f] = 0;
param_1[0x10] = 0;
param_1[0x11] = 0;
param_1[0x12] = 0;
param_1[0x13] = 0;
param_1[0x14] = 0;
param_1[0x15] = 0;
param_1[0x16] = 0;
param_1[0x17] = 0;
param_1[0x18] = 0;
param_1[0x19] = 0;
param_1[0x1a] = 0;
param_1[0x1b] = 0;
param_1[0x1c] = 0;
param_1[0x1d] = 0;
param_1[0x1e] = 0;
param_1[0x1f] = 0;
param_1[0] = 0;
param_1[1] = 0;
param_1[2] = 0;
param_1[3] = 0;
param_1[4] = 0;
param_1[5] = 0;
param_1[6] = 0;
param_1[7] = 0;
param_1[8] = 0;
param_1[9] = 0;
param_1[10] = 0;
param_1[0xb] = 0;
param_1[0xc] = 0;
param_1[0xd] = 0;
param_1[0xe] = 0;
param_1[0xf] = 0;
bVar2 = 0xc0;
}
*param_1 = bVar2;
return;
}
| |
52,995 | mi_put_key_in_record | eloqsql/storage/myisam/mi_key.c | static int _mi_put_key_in_record(register MI_INFO *info, uint keynr,
my_bool unpack_blobs, uchar *record)
{
reg2 uchar *key;
uchar *pos,*key_end;
reg1 HA_KEYSEG *keyseg;
uchar *blob_ptr;
DBUG_ENTER("_mi_put_key_in_record");
blob_ptr= (uchar*) info->lastkey2; /* Place to put blob parts */
key=(uchar*) info->lastkey; /* KEy that was read */
key_end=key+info->lastkey_length;
for (keyseg=info->s->keyinfo[keynr].seg ; keyseg->type ;keyseg++)
{
if (keyseg->null_bit)
{
if (!*key++)
{
record[keyseg->null_pos]|= keyseg->null_bit;
continue;
}
record[keyseg->null_pos]&= ~keyseg->null_bit;
}
if (keyseg->type == HA_KEYTYPE_BIT)
{
uint length= keyseg->length;
if (keyseg->bit_length)
{
uchar bits= *key++;
set_rec_bits(bits, record + keyseg->bit_pos, keyseg->bit_start,
keyseg->bit_length);
length--;
}
else
{
clr_rec_bits(record + keyseg->bit_pos, keyseg->bit_start,
keyseg->bit_length);
}
memcpy(record + keyseg->start, (uchar*) key, length);
key+= length;
continue;
}
if (keyseg->flag & HA_SPACE_PACK)
{
uint length;
get_key_length(length,key);
#ifdef CHECK_KEYS
if (length > keyseg->length || key+length > key_end)
goto err;
#endif
pos= record+keyseg->start;
if (keyseg->type != (int) HA_KEYTYPE_NUM)
{
memcpy(pos,key,(size_t) length);
my_ci_fill(keyseg->charset, (char*) pos + length,
keyseg->length - length,
' ');
}
else
{
bfill(pos,keyseg->length-length,' ');
memcpy(pos+keyseg->length-length,key,(size_t) length);
}
key+=length;
continue;
}
if (keyseg->flag & HA_VAR_LENGTH_PART)
{
uint length;
get_key_length(length,key);
#ifdef CHECK_KEYS
if (length > keyseg->length || key+length > key_end)
goto err;
#endif
/* Store key length */
if (keyseg->bit_start == 1)
*(uchar*) (record+keyseg->start)= (uchar) length;
else
int2store(record+keyseg->start, length);
/* And key data */
memcpy(record+keyseg->start + keyseg->bit_start, (uchar*) key, length);
key+= length;
}
else if (keyseg->flag & HA_BLOB_PART)
{
uint length;
get_key_length(length,key);
#ifdef CHECK_KEYS
if (length > keyseg->length || key+length > key_end)
goto err;
#endif
if (unpack_blobs)
{
memcpy(record+keyseg->start+keyseg->bit_start,
&blob_ptr, sizeof(char *));
memcpy(blob_ptr,key,length);
blob_ptr+=length;
/* The above changed info->lastkey2. Inform mi_rnext_same(). */
info->update&= ~HA_STATE_RNEXT_SAME;
_mi_store_blob_length(record+keyseg->start,
(uint) keyseg->bit_start,length);
}
key+=length;
}
else if (keyseg->flag & HA_SWAP_KEY)
{
uchar *to= record+keyseg->start+keyseg->length;
uchar *end= key+keyseg->length;
#ifdef CHECK_KEYS
if (end > key_end)
goto err;
#endif
do
{
*--to= *key++;
} while (key != end);
continue;
}
else
{
#ifdef CHECK_KEYS
if (key+keyseg->length > key_end)
goto err;
#endif
memcpy(record+keyseg->start,(uchar*) key,
(size_t) keyseg->length);
key+= keyseg->length;
}
}
DBUG_RETURN(0);
err:
DBUG_RETURN(1); /* Crashed row */
} | O3 | c | mi_put_key_in_record:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r12
movl %edx, -0x44(%rbp)
movq (%rdi), %rax
movq 0x218(%rax), %rax
movl %esi, %ecx
imulq $0x70, %rcx, %rcx
movq 0x28(%rax,%rcx), %r15
movb 0x18(%r15), %cl
testb %cl, %cl
je 0x7ee22
movq 0x108(%rdi), %r13
movl 0x1d8(%rdi), %eax
addq %r13, %rax
movq %rax, -0x40(%rbp)
leaq 0x18(%r15), %rax
movq %rdi, -0x60(%rbp)
movq 0x110(%rdi), %rdx
movq %rdx, -0x50(%rbp)
leaq -0x1(%r12), %rdx
movq %rdx, -0x58(%rbp)
movq %r12, -0x30(%rbp)
movb 0x19(%r15), %dl
testb %dl, %dl
je 0x7ead4
leaq 0x1(%r13), %rbx
cmpb $0x0, (%r13)
je 0x7eba6
notb %dl
movl 0xc(%r15), %ecx
andb %dl, (%r12,%rcx)
movb (%rax), %cl
movq %rbx, %r13
cmpb $0x13, %cl
jne 0x7eb56
movzwl 0x14(%r15), %esi
movzbl 0x1b(%r15), %eax
testl %eax, %eax
je 0x7ebc7
movzbl (%r13), %edi
movzwl 0x10(%r15), %r8d
movzbl 0x1a(%r15), %edx
movl $0xffffffff, %r9d # imm = 0xFFFFFFFF
movl %eax, %ecx
shll %cl, %r9d
notl %r9d
movl %edx, %ecx
shll %cl, %r9d
movzbl (%r12,%r8), %ecx
notl %r9d
andl %ecx, %r9d
movl %edi, %r10d
movl %edx, %ecx
shll %cl, %r10d
orl %r9d, %r10d
movb %r10b, (%r12,%r8)
addl %edx, %eax
cmpl $0x9, %eax
jb 0x7eb4c
movzbl 0x1(%r12,%r8), %r9d
addb $-0x8, %al
movl %eax, %ecx
shrl %cl, %r9d
shll %cl, %r9d
movb $0x8, %cl
subb %dl, %cl
shrl %cl, %edi
orl %r9d, %edi
movb %dil, 0x1(%r12,%r8)
incq %r13
decl %esi
jmp 0x7ebe5
movzwl 0x12(%r15), %eax
testb $0x1, %al
jne 0x7ebb3
testb $0x8, %al
jne 0x7ec05
testb $0x20, %al
jne 0x7ecc3
movzwl 0x14(%r15), %edx
leaq (%rdx,%r13), %rcx
testb $0x40, %al
jne 0x7ed52
cmpq -0x40(%rbp), %rcx
ja 0x7ee33
movl 0x8(%r15), %edi
addq %r12, %rdi
movq %r13, %rsi
callq 0x29080
movzwl 0x14(%r15), %ebx
addq %r13, %rbx
jmp 0x7ee05
movl 0xc(%r15), %eax
orb %dl, (%r12,%rax)
jmp 0x7ee05
movzbl (%r13), %edi
cmpl $0xff, %edi
je 0x7ec20
movl $0x1, %esi
jmp 0x7ec31
movzbl 0x1a(%r15), %ecx
cmpl $0x9, %ecx
jb 0x7ebe5
addb $-0x8, %cl
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
shll %cl, %eax
movzwl 0x10(%r15), %ecx
andb %al, 0x1(%r12,%rcx)
movl 0x8(%r15), %edi
addq %r12, %rdi
movl %esi, %r14d
movq %r13, %rsi
movq %r14, %rdx
callq 0x29080
addq %r14, %r13
movq %r13, %rbx
jmp 0x7ee05
movzbl (%r13), %ecx
cmpl $0xff, %ecx
je 0x7ecde
movl $0x1, %edx
jmp 0x7ecef
movzwl 0x1(%r13), %eax
rolw $0x8, %ax
movzwl %ax, %edi
movl $0x3, %esi
movzwl 0x14(%r15), %edx
movl $0x1, %eax
subl %edi, %edx
jb 0x7ee24
addq %rsi, %r13
movl %edi, %r14d
leaq (%r14,%r13), %rbx
cmpq -0x40(%rbp), %rbx
ja 0x7ee24
movl 0x8(%r15), %r12d
addq -0x30(%rbp), %r12
cmpb $0x7, %cl
jne 0x7ec89
movq %r12, %rdi
movl $0x20, %esi
callq 0x29270
movzwl 0x14(%r15), %edi
addq %r12, %rdi
subq %r14, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x29080
jmp 0x7ecba
movl %edi, -0x34(%rbp)
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x29080
movq (%r15), %rdi
addq %r14, %r12
movzwl 0x14(%r15), %edx
subl -0x34(%rbp), %edx
movq 0xb8(%rdi), %rax
movq %r12, %rsi
movl $0x20, %ecx
callq *0x78(%rax)
movq -0x30(%rbp), %r12
jmp 0x7ee05
movzbl (%r13), %esi
cmpl $0xff, %esi
je 0x7ed78
movl $0x1, %ecx
jmp 0x7ed89
movzwl 0x1(%r13), %eax
rolw $0x8, %ax
movzwl %ax, %ecx
movl $0x3, %edx
movzwl 0x14(%r15), %esi
movl $0x1, %eax
cmpl %esi, %ecx
ja 0x7ee24
addq %rdx, %r13
movl %ecx, %edx
leaq (%rdx,%r13), %rbx
cmpq -0x40(%rbp), %rbx
ja 0x7ee24
cmpb $0x1, 0x1a(%r15)
jne 0x7ed29
movl 0x8(%r15), %eax
movq -0x30(%rbp), %r12
movb %cl, (%r12,%rax)
jmp 0x7ed36
movl 0x8(%r15), %eax
movq -0x30(%rbp), %r12
movw %cx, (%r12,%rax)
movl 0x8(%r15), %eax
addq %r12, %rax
movzbl 0x1a(%r15), %edi
addq %rax, %rdi
movq %r13, %rsi
callq 0x29080
jmp 0x7ee05
cmpq -0x40(%rbp), %rcx
ja 0x7ee33
movl 0x8(%r15), %eax
addq -0x58(%rbp), %rax
movb (%r13), %cl
incq %r13
movb %cl, (%rax,%rdx)
decq %rdx
jne 0x7ed64
jmp 0x7ebfd
movzwl 0x1(%r13), %eax
rolw $0x8, %ax
movzwl %ax, %esi
movl $0x3, %ecx
movzwl 0x14(%r15), %edx
movl $0x1, %eax
cmpl %edx, %esi
ja 0x7ee24
addq %rcx, %r13
movl %esi, %r12d
leaq (%r12,%r13), %rbx
cmpq -0x40(%rbp), %rbx
ja 0x7ee24
cmpb $0x0, -0x44(%rbp)
je 0x7ecba
movl 0x8(%r15), %eax
addq -0x30(%rbp), %rax
movzbl 0x1a(%r15), %ecx
movq -0x50(%rbp), %r14
movq %r14, (%rcx,%rax)
movq %r14, %rdi
movl %esi, -0x34(%rbp)
movq %r13, %rsi
movq %r12, %rdx
callq 0x29080
movq -0x60(%rbp), %rax
andb $-0x11, 0x1d1(%rax)
addq %r12, %r14
movq %r14, -0x50(%rbp)
movq -0x30(%rbp), %r12
movl 0x8(%r15), %edi
addq %r12, %rdi
movzbl 0x1a(%r15), %esi
movl -0x34(%rbp), %edx
callq 0x7c353
leaq 0x20(%r15), %rdx
movb 0x38(%r15), %cl
addq $0x38, %r15
movq %r15, %rax
movq %rbx, %r13
movq %rdx, %r15
testb %cl, %cl
jne 0x7eaae
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %eax
jmp 0x7ee24
| _mi_put_key_in_record:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r12, rcx
mov [rbp+var_44], edx
mov rax, [rdi]
mov rax, [rax+218h]
mov ecx, esi
imul rcx, 70h ; 'p'
mov r15, [rax+rcx+28h]
mov cl, [r15+18h]
test cl, cl
jz loc_7EE22
mov r13, [rdi+108h]
mov eax, [rdi+1D8h]
add rax, r13
mov [rbp+var_40], rax
lea rax, [r15+18h]
mov [rbp+var_60], rdi
mov rdx, [rdi+110h]
mov [rbp+var_50], rdx
lea rdx, [r12-1]
mov [rbp+var_58], rdx
mov [rbp+var_30], r12
loc_7EAAE:
mov dl, [r15+19h]
test dl, dl
jz short loc_7EAD4
lea rbx, [r13+1]
cmp byte ptr [r13+0], 0
jz loc_7EBA6
not dl
mov ecx, [r15+0Ch]
and [r12+rcx], dl
mov cl, [rax]
mov r13, rbx
loc_7EAD4:
cmp cl, 13h
jnz short loc_7EB56
movzx esi, word ptr [r15+14h]
movzx eax, byte ptr [r15+1Bh]
test eax, eax
jz loc_7EBC7
movzx edi, byte ptr [r13+0]
movzx r8d, word ptr [r15+10h]
movzx edx, byte ptr [r15+1Ah]
mov r9d, 0FFFFFFFFh
mov ecx, eax
shl r9d, cl
not r9d
mov ecx, edx
shl r9d, cl
movzx ecx, byte ptr [r12+r8]
not r9d
and r9d, ecx
mov r10d, edi
mov ecx, edx
shl r10d, cl
or r10d, r9d
mov [r12+r8], r10b
add eax, edx
cmp eax, 9
jb short loc_7EB4C
movzx r9d, byte ptr [r12+r8+1]
add al, 0F8h
mov ecx, eax
shr r9d, cl
shl r9d, cl
mov cl, 8
sub cl, dl
shr edi, cl
or edi, r9d
mov [r12+r8+1], dil
loc_7EB4C:
inc r13
dec esi
jmp loc_7EBE5
loc_7EB56:
movzx eax, word ptr [r15+12h]
test al, 1
jnz short loc_7EBB3
test al, 8
jnz loc_7EC05
test al, 20h
jnz loc_7ECC3
movzx edx, word ptr [r15+14h]
lea rcx, [rdx+r13]
test al, 40h
jnz loc_7ED52
cmp rcx, [rbp+var_40]
ja loc_7EE33
mov edi, [r15+8]
add rdi, r12
mov rsi, r13
call _memcpy
movzx ebx, word ptr [r15+14h]
add rbx, r13
jmp loc_7EE05
loc_7EBA6:
mov eax, [r15+0Ch]
or [r12+rax], dl
jmp loc_7EE05
loc_7EBB3:
movzx edi, byte ptr [r13+0]
cmp edi, 0FFh
jz short loc_7EC20
mov esi, 1
jmp short loc_7EC31
loc_7EBC7:
movzx ecx, byte ptr [r15+1Ah]
cmp ecx, 9
jb short loc_7EBE5
add cl, 0F8h
mov eax, 0FFFFFFFFh
shl eax, cl
movzx ecx, word ptr [r15+10h]
and [r12+rcx+1], al
loc_7EBE5:
mov edi, [r15+8]
add rdi, r12
mov r14d, esi
mov rsi, r13
mov rdx, r14
call _memcpy
add r13, r14
loc_7EBFD:
mov rbx, r13
jmp loc_7EE05
loc_7EC05:
movzx ecx, byte ptr [r13+0]
cmp ecx, 0FFh
jz loc_7ECDE
mov edx, 1
jmp loc_7ECEF
loc_7EC20:
movzx eax, word ptr [r13+1]
rol ax, 8
movzx edi, ax
mov esi, 3
loc_7EC31:
movzx edx, word ptr [r15+14h]
mov eax, 1
sub edx, edi
jb loc_7EE24
add r13, rsi
mov r14d, edi
lea rbx, [r14+r13]
cmp rbx, [rbp+var_40]
ja loc_7EE24
mov r12d, [r15+8]
add r12, [rbp+var_30]
cmp cl, 7
jnz short loc_7EC89
mov rdi, r12
mov esi, 20h ; ' '
call _memset
movzx edi, word ptr [r15+14h]
add rdi, r12
sub rdi, r14
mov rsi, r13
mov rdx, r14
call _memcpy
jmp short loc_7ECBA
loc_7EC89:
mov [rbp+var_34], edi
mov rdi, r12
mov rsi, r13
mov rdx, r14
call _memcpy
mov rdi, [r15]
add r12, r14
movzx edx, word ptr [r15+14h]
sub edx, [rbp+var_34]
mov rax, [rdi+0B8h]
mov rsi, r12
mov ecx, 20h ; ' '
call qword ptr [rax+78h]
loc_7ECBA:
mov r12, [rbp+var_30]
jmp loc_7EE05
loc_7ECC3:
movzx esi, byte ptr [r13+0]
cmp esi, 0FFh
jz loc_7ED78
mov ecx, 1
jmp loc_7ED89
loc_7ECDE:
movzx eax, word ptr [r13+1]
rol ax, 8
movzx ecx, ax
mov edx, 3
loc_7ECEF:
movzx esi, word ptr [r15+14h]
mov eax, 1
cmp ecx, esi
ja loc_7EE24
add r13, rdx
mov edx, ecx
lea rbx, [rdx+r13]
cmp rbx, [rbp+var_40]
ja loc_7EE24
cmp byte ptr [r15+1Ah], 1
jnz short loc_7ED29
mov eax, [r15+8]
mov r12, [rbp+var_30]
mov [r12+rax], cl
jmp short loc_7ED36
loc_7ED29:
mov eax, [r15+8]
mov r12, [rbp+var_30]
mov [r12+rax], cx
loc_7ED36:
mov eax, [r15+8]
add rax, r12
movzx edi, byte ptr [r15+1Ah]
add rdi, rax
mov rsi, r13
call _memcpy
jmp loc_7EE05
loc_7ED52:
cmp rcx, [rbp+var_40]
ja loc_7EE33
mov eax, [r15+8]
add rax, [rbp+var_58]
loc_7ED64:
mov cl, [r13+0]
inc r13
mov [rax+rdx], cl
dec rdx
jnz short loc_7ED64
jmp loc_7EBFD
loc_7ED78:
movzx eax, word ptr [r13+1]
rol ax, 8
movzx esi, ax
mov ecx, 3
loc_7ED89:
movzx edx, word ptr [r15+14h]
mov eax, 1
cmp esi, edx
ja loc_7EE24
add r13, rcx
mov r12d, esi
lea rbx, [r12+r13]
cmp rbx, [rbp+var_40]
ja short loc_7EE24
cmp byte ptr [rbp+var_44], 0
jz loc_7ECBA
mov eax, [r15+8]
add rax, [rbp+var_30]
movzx ecx, byte ptr [r15+1Ah]
mov r14, [rbp+var_50]
mov [rcx+rax], r14
mov rdi, r14
mov [rbp+var_34], esi
mov rsi, r13
mov rdx, r12
call _memcpy
mov rax, [rbp+var_60]
and byte ptr [rax+1D1h], 0EFh
add r14, r12
mov [rbp+var_50], r14
mov r12, [rbp+var_30]
mov edi, [r15+8]
add rdi, r12
movzx esi, byte ptr [r15+1Ah]
mov edx, [rbp+var_34]
call _mi_store_blob_length
loc_7EE05:
lea rdx, [r15+20h]
mov cl, [r15+38h]
add r15, 38h ; '8'
mov rax, r15
mov r13, rbx
mov r15, rdx
test cl, cl
jnz loc_7EAAE
loc_7EE22:
xor eax, eax
loc_7EE24:
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_7EE33:
mov eax, 1
jmp short loc_7EE24
| long long mi_put_key_in_record(long long a1, unsigned int a2, char a3, long long a4)
{
_QWORD *v5; // r15
char v6; // cl
unsigned __int8 *v7; // r13
char *v8; // rax
char v9; // dl
unsigned __int8 *v10; // rbx
unsigned int v11; // esi
int v12; // eax
unsigned int v13; // edi
long long v14; // r8
int v15; // edx
unsigned int v16; // eax
__int16 v17; // ax
long long v18; // rdx
unsigned __int8 *v19; // rcx
unsigned int v20; // edi
long long v21; // rsi
unsigned int v22; // ecx
unsigned int v23; // ecx
long long v24; // rdx
unsigned int v25; // edx
long long result; // rax
bool v27; // cf
long long v28; // rdx
unsigned __int8 *v29; // r13
long long v30; // r12
unsigned int v31; // esi
long long v32; // rcx
unsigned __int8 *v33; // r13
long long v34; // rax
char v35; // cl
unsigned __int8 *v36; // r13
long long v38; // [rsp+8h] [rbp-58h]
long long v39; // [rsp+10h] [rbp-50h]
unsigned __int8 *v41; // [rsp+20h] [rbp-40h]
long long v42; // [rsp+30h] [rbp-30h]
v5 = *(_QWORD **)(*(_QWORD *)(*(_QWORD *)a1 + 536LL) + 112LL * a2 + 40);
v6 = *((_BYTE *)v5 + 24);
if ( v6 )
{
v7 = *(unsigned __int8 **)(a1 + 264);
v41 = &v7[*(unsigned int *)(a1 + 472)];
v8 = (char *)(v5 + 3);
v39 = *(_QWORD *)(a1 + 272);
v38 = a4 - 1;
v42 = a4;
do
{
v9 = *((_BYTE *)v5 + 25);
if ( v9 )
{
v10 = v7 + 1;
if ( !*v7 )
{
*(_BYTE *)(a4 + *((unsigned int *)v5 + 3)) |= v9;
goto LABEL_51;
}
*(_BYTE *)(a4 + *((unsigned int *)v5 + 3)) &= ~v9;
v6 = *v8;
++v7;
}
if ( v6 == 19 )
{
v11 = *((unsigned __int16 *)v5 + 10);
v12 = *((unsigned __int8 *)v5 + 27);
if ( *((_BYTE *)v5 + 27) )
{
v13 = *v7;
v14 = *((unsigned __int16 *)v5 + 8);
v15 = *((unsigned __int8 *)v5 + 26);
*(_BYTE *)(a4 + v14) = *(_BYTE *)(a4 + v14) & ~(~(-1 << v12) << *((_BYTE *)v5 + 26)) | (*v7 << *((_BYTE *)v5 + 26));
v16 = v15 + v12;
if ( v16 >= 9 )
*(_BYTE *)(a4 + v14 + 1) = (*(unsigned __int8 *)(a4 + v14 + 1) >> (v16 - 8) << (v16 - 8)) | (v13 >> (8 - v15));
++v7;
--v11;
}
else
{
v22 = *((unsigned __int8 *)v5 + 26);
if ( v22 >= 9 )
*(_BYTE *)(a4 + *((unsigned __int16 *)v5 + 8) + 1) &= -1 << (v22 - 8);
}
memcpy(a4 + *((unsigned int *)v5 + 2), v7, v11);
v7 += v11;
LABEL_23:
v10 = v7;
goto LABEL_51;
}
v17 = *((_WORD *)v5 + 9);
if ( (v17 & 1) != 0 )
{
v20 = *v7;
if ( v20 == 255 )
{
v20 = (unsigned __int16)__ROL2__(*(_WORD *)(v7 + 1), 8);
v21 = 3LL;
}
else
{
v21 = 1LL;
}
v25 = *((unsigned __int16 *)v5 + 10);
result = 1LL;
v27 = v25 < v20;
v28 = v25 - v20;
if ( v27 )
return result;
v29 = &v7[v21];
v10 = &v29[v20];
if ( v10 > v41 )
return result;
v30 = v42 + *((unsigned int *)v5 + 2);
if ( v6 == 7 )
{
memset(v42 + *((unsigned int *)v5 + 2), 32LL, v28);
memcpy(v30 + *((unsigned __int16 *)v5 + 10) - v20, v29, v20);
}
else
{
memcpy(v30, v29, v20);
(*(void ( **)(_QWORD, long long, _QWORD, long long))(*(_QWORD *)(*v5 + 184LL) + 120LL))(
*v5,
v20 + v30,
*((unsigned __int16 *)v5 + 10) - v20,
32LL);
}
LABEL_32:
a4 = v42;
goto LABEL_51;
}
if ( (v17 & 8) != 0 )
{
v23 = *v7;
if ( v23 == 255 )
{
v23 = (unsigned __int16)__ROL2__(*(_WORD *)(v7 + 1), 8);
v24 = 3LL;
}
else
{
v24 = 1LL;
}
result = 1LL;
if ( v23 > *((unsigned __int16 *)v5 + 10) )
return result;
v33 = &v7[v24];
v10 = &v33[v23];
if ( v10 > v41 )
return result;
a4 = v42;
if ( *((_BYTE *)v5 + 26) == 1 )
*(_BYTE *)(v42 + *((unsigned int *)v5 + 2)) = v23;
else
*(_WORD *)(v42 + *((unsigned int *)v5 + 2)) = v23;
memcpy(v42 + *((unsigned int *)v5 + 2) + *((unsigned __int8 *)v5 + 26), v33, v23);
}
else
{
if ( (v17 & 0x20) != 0 )
{
v31 = *v7;
if ( v31 == 255 )
{
v31 = (unsigned __int16)__ROL2__(*(_WORD *)(v7 + 1), 8);
v32 = 3LL;
}
else
{
v32 = 1LL;
}
result = 1LL;
if ( v31 > *((unsigned __int16 *)v5 + 10) )
return result;
v36 = &v7[v32];
v10 = &v36[v31];
if ( v10 > v41 )
return result;
if ( a3 )
{
*(_QWORD *)(*((unsigned __int8 *)v5 + 26) + v42 + *((unsigned int *)v5 + 2)) = v39;
memcpy(v39, v36, v31);
*(_BYTE *)(a1 + 465) &= ~0x10u;
v39 += v31;
a4 = v42;
mi_store_blob_length((_BYTE *)(v42 + *((unsigned int *)v5 + 2)), *((unsigned __int8 *)v5 + 26), v31);
goto LABEL_51;
}
goto LABEL_32;
}
v18 = *((unsigned __int16 *)v5 + 10);
v19 = &v7[v18];
if ( (v17 & 0x40) != 0 )
{
if ( v19 > v41 )
return 1LL;
v34 = v38 + *((unsigned int *)v5 + 2);
do
{
v35 = *v7++;
*(_BYTE *)(v34 + v18--) = v35;
}
while ( v18 );
goto LABEL_23;
}
if ( v19 > v41 )
return 1LL;
memcpy(a4 + *((unsigned int *)v5 + 2), v7, v18);
v10 = &v7[*((unsigned __int16 *)v5 + 10)];
}
LABEL_51:
v6 = *((_BYTE *)v5 + 56);
v8 = (char *)(v5 + 7);
v7 = v10;
v5 += 4;
}
while ( v6 );
}
return 0LL;
}
| _mi_put_key_in_record:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R12,RCX
MOV dword ptr [RBP + -0x44],EDX
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x218]
MOV ECX,ESI
IMUL RCX,RCX,0x70
MOV R15,qword ptr [RAX + RCX*0x1 + 0x28]
MOV CL,byte ptr [R15 + 0x18]
TEST CL,CL
JZ 0x0017ee22
MOV R13,qword ptr [RDI + 0x108]
MOV EAX,dword ptr [RDI + 0x1d8]
ADD RAX,R13
MOV qword ptr [RBP + -0x40],RAX
LEA RAX,[R15 + 0x18]
MOV qword ptr [RBP + -0x60],RDI
MOV RDX,qword ptr [RDI + 0x110]
MOV qword ptr [RBP + -0x50],RDX
LEA RDX,[R12 + -0x1]
MOV qword ptr [RBP + -0x58],RDX
MOV qword ptr [RBP + -0x30],R12
LAB_0017eaae:
MOV DL,byte ptr [R15 + 0x19]
TEST DL,DL
JZ 0x0017ead4
LEA RBX,[R13 + 0x1]
CMP byte ptr [R13],0x0
JZ 0x0017eba6
NOT DL
MOV ECX,dword ptr [R15 + 0xc]
AND byte ptr [R12 + RCX*0x1],DL
MOV CL,byte ptr [RAX]
MOV R13,RBX
LAB_0017ead4:
CMP CL,0x13
JNZ 0x0017eb56
MOVZX ESI,word ptr [R15 + 0x14]
MOVZX EAX,byte ptr [R15 + 0x1b]
TEST EAX,EAX
JZ 0x0017ebc7
MOVZX EDI,byte ptr [R13]
MOVZX R8D,word ptr [R15 + 0x10]
MOVZX EDX,byte ptr [R15 + 0x1a]
MOV R9D,0xffffffff
MOV ECX,EAX
SHL R9D,CL
NOT R9D
MOV ECX,EDX
SHL R9D,CL
MOVZX ECX,byte ptr [R12 + R8*0x1]
NOT R9D
AND R9D,ECX
MOV R10D,EDI
MOV ECX,EDX
SHL R10D,CL
OR R10D,R9D
MOV byte ptr [R12 + R8*0x1],R10B
ADD EAX,EDX
CMP EAX,0x9
JC 0x0017eb4c
MOVZX R9D,byte ptr [R12 + R8*0x1 + 0x1]
ADD AL,0xf8
MOV ECX,EAX
SHR R9D,CL
SHL R9D,CL
MOV CL,0x8
SUB CL,DL
SHR EDI,CL
OR EDI,R9D
MOV byte ptr [R12 + R8*0x1 + 0x1],DIL
LAB_0017eb4c:
INC R13
DEC ESI
JMP 0x0017ebe5
LAB_0017eb56:
MOVZX EAX,word ptr [R15 + 0x12]
TEST AL,0x1
JNZ 0x0017ebb3
TEST AL,0x8
JNZ 0x0017ec05
TEST AL,0x20
JNZ 0x0017ecc3
MOVZX EDX,word ptr [R15 + 0x14]
LEA RCX,[RDX + R13*0x1]
TEST AL,0x40
JNZ 0x0017ed52
CMP RCX,qword ptr [RBP + -0x40]
JA 0x0017ee33
MOV EDI,dword ptr [R15 + 0x8]
ADD RDI,R12
MOV RSI,R13
CALL 0x00129080
MOVZX EBX,word ptr [R15 + 0x14]
ADD RBX,R13
JMP 0x0017ee05
LAB_0017eba6:
MOV EAX,dword ptr [R15 + 0xc]
OR byte ptr [R12 + RAX*0x1],DL
JMP 0x0017ee05
LAB_0017ebb3:
MOVZX EDI,byte ptr [R13]
CMP EDI,0xff
JZ 0x0017ec20
MOV ESI,0x1
JMP 0x0017ec31
LAB_0017ebc7:
MOVZX ECX,byte ptr [R15 + 0x1a]
CMP ECX,0x9
JC 0x0017ebe5
ADD CL,0xf8
MOV EAX,0xffffffff
SHL EAX,CL
MOVZX ECX,word ptr [R15 + 0x10]
AND byte ptr [R12 + RCX*0x1 + 0x1],AL
LAB_0017ebe5:
MOV EDI,dword ptr [R15 + 0x8]
ADD RDI,R12
MOV R14D,ESI
MOV RSI,R13
MOV RDX,R14
CALL 0x00129080
ADD R13,R14
LAB_0017ebfd:
MOV RBX,R13
JMP 0x0017ee05
LAB_0017ec05:
MOVZX ECX,byte ptr [R13]
CMP ECX,0xff
JZ 0x0017ecde
MOV EDX,0x1
JMP 0x0017ecef
LAB_0017ec20:
MOVZX EAX,word ptr [R13 + 0x1]
ROL AX,0x8
MOVZX EDI,AX
MOV ESI,0x3
LAB_0017ec31:
MOVZX EDX,word ptr [R15 + 0x14]
MOV EAX,0x1
SUB EDX,EDI
JC 0x0017ee24
ADD R13,RSI
MOV R14D,EDI
LEA RBX,[R14 + R13*0x1]
CMP RBX,qword ptr [RBP + -0x40]
JA 0x0017ee24
MOV R12D,dword ptr [R15 + 0x8]
ADD R12,qword ptr [RBP + -0x30]
CMP CL,0x7
JNZ 0x0017ec89
MOV RDI,R12
MOV ESI,0x20
CALL 0x00129270
MOVZX EDI,word ptr [R15 + 0x14]
ADD RDI,R12
SUB RDI,R14
MOV RSI,R13
MOV RDX,R14
CALL 0x00129080
JMP 0x0017ecba
LAB_0017ec89:
MOV dword ptr [RBP + -0x34],EDI
MOV RDI,R12
MOV RSI,R13
MOV RDX,R14
CALL 0x00129080
MOV RDI,qword ptr [R15]
ADD R12,R14
MOVZX EDX,word ptr [R15 + 0x14]
SUB EDX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RDI + 0xb8]
MOV RSI,R12
MOV ECX,0x20
CALL qword ptr [RAX + 0x78]
LAB_0017ecba:
MOV R12,qword ptr [RBP + -0x30]
JMP 0x0017ee05
LAB_0017ecc3:
MOVZX ESI,byte ptr [R13]
CMP ESI,0xff
JZ 0x0017ed78
MOV ECX,0x1
JMP 0x0017ed89
LAB_0017ecde:
MOVZX EAX,word ptr [R13 + 0x1]
ROL AX,0x8
MOVZX ECX,AX
MOV EDX,0x3
LAB_0017ecef:
MOVZX ESI,word ptr [R15 + 0x14]
MOV EAX,0x1
CMP ECX,ESI
JA 0x0017ee24
ADD R13,RDX
MOV EDX,ECX
LEA RBX,[RDX + R13*0x1]
CMP RBX,qword ptr [RBP + -0x40]
JA 0x0017ee24
CMP byte ptr [R15 + 0x1a],0x1
JNZ 0x0017ed29
MOV EAX,dword ptr [R15 + 0x8]
MOV R12,qword ptr [RBP + -0x30]
MOV byte ptr [R12 + RAX*0x1],CL
JMP 0x0017ed36
LAB_0017ed29:
MOV EAX,dword ptr [R15 + 0x8]
MOV R12,qword ptr [RBP + -0x30]
MOV word ptr [R12 + RAX*0x1],CX
LAB_0017ed36:
MOV EAX,dword ptr [R15 + 0x8]
ADD RAX,R12
MOVZX EDI,byte ptr [R15 + 0x1a]
ADD RDI,RAX
MOV RSI,R13
CALL 0x00129080
JMP 0x0017ee05
LAB_0017ed52:
CMP RCX,qword ptr [RBP + -0x40]
JA 0x0017ee33
MOV EAX,dword ptr [R15 + 0x8]
ADD RAX,qword ptr [RBP + -0x58]
LAB_0017ed64:
MOV CL,byte ptr [R13]
INC R13
MOV byte ptr [RAX + RDX*0x1],CL
DEC RDX
JNZ 0x0017ed64
JMP 0x0017ebfd
LAB_0017ed78:
MOVZX EAX,word ptr [R13 + 0x1]
ROL AX,0x8
MOVZX ESI,AX
MOV ECX,0x3
LAB_0017ed89:
MOVZX EDX,word ptr [R15 + 0x14]
MOV EAX,0x1
CMP ESI,EDX
JA 0x0017ee24
ADD R13,RCX
MOV R12D,ESI
LEA RBX,[R12 + R13*0x1]
CMP RBX,qword ptr [RBP + -0x40]
JA 0x0017ee24
CMP byte ptr [RBP + -0x44],0x0
JZ 0x0017ecba
MOV EAX,dword ptr [R15 + 0x8]
ADD RAX,qword ptr [RBP + -0x30]
MOVZX ECX,byte ptr [R15 + 0x1a]
MOV R14,qword ptr [RBP + -0x50]
MOV qword ptr [RCX + RAX*0x1],R14
MOV RDI,R14
MOV dword ptr [RBP + -0x34],ESI
MOV RSI,R13
MOV RDX,R12
CALL 0x00129080
MOV RAX,qword ptr [RBP + -0x60]
AND byte ptr [RAX + 0x1d1],0xef
ADD R14,R12
MOV qword ptr [RBP + -0x50],R14
MOV R12,qword ptr [RBP + -0x30]
MOV EDI,dword ptr [R15 + 0x8]
ADD RDI,R12
MOVZX ESI,byte ptr [R15 + 0x1a]
MOV EDX,dword ptr [RBP + -0x34]
CALL 0x0017c353
LAB_0017ee05:
LEA RDX,[R15 + 0x20]
MOV CL,byte ptr [R15 + 0x38]
ADD R15,0x38
MOV RAX,R15
MOV R13,RBX
MOV R15,RDX
TEST CL,CL
JNZ 0x0017eaae
LAB_0017ee22:
XOR EAX,EAX
LAB_0017ee24:
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0017ee33:
MOV EAX,0x1
JMP 0x0017ee24
|
int8 _mi_put_key_in_record(long *param_1,ulong param_2,char param_3,long param_4)
{
byte bVar1;
byte bVar2;
ushort uVar3;
byte bVar4;
byte *pbVar5;
long *plVar6;
char cVar7;
long lVar8;
ulong uVar9;
uint uVar10;
void *__dest;
byte *__src;
byte *pbVar11;
long *plVar12;
void *local_58;
plVar12 = *(long **)(*(long *)(*param_1 + 0x218) + 0x28 + (param_2 & 0xffffffff) * 0x70);
cVar7 = (char)plVar12[3];
if (cVar7 != '\0') {
pbVar5 = (byte *)param_1[0x21] + *(uint *)(param_1 + 0x3b);
plVar6 = plVar12 + 3;
local_58 = (void *)param_1[0x22];
pbVar11 = (byte *)param_1[0x21];
do {
bVar4 = *(byte *)((long)plVar12 + 0x19);
__src = pbVar11;
if (bVar4 == 0) {
LAB_0017ead4:
if (cVar7 == '\x13') {
uVar3 = *(ushort *)((long)plVar12 + 0x14);
uVar10 = (uint)uVar3;
bVar4 = *(byte *)((long)plVar12 + 0x1b);
if (bVar4 == 0) {
if (8 < *(byte *)((long)plVar12 + 0x1a)) {
pbVar11 = (byte *)(param_4 + 1 + (ulong)*(ushort *)(plVar12 + 2));
*pbVar11 = *pbVar11 & (byte)(-1 << (*(byte *)((long)plVar12 + 0x1a) - 8 & 0x1f));
}
}
else {
bVar1 = *__src;
uVar9 = (ulong)*(ushort *)(plVar12 + 2);
bVar2 = *(byte *)((long)plVar12 + 0x1a);
*(byte *)(param_4 + uVar9) =
bVar1 << (bVar2 & 0x1f) |
~(byte)(~(-1 << (bVar4 & 0x1f)) << (bVar2 & 0x1f)) & *(byte *)(param_4 + uVar9);
if (8 < (uint)bVar4 + (uint)bVar2) {
bVar4 = (char)((uint)bVar4 + (uint)bVar2) - 8;
*(byte *)(param_4 + 1 + uVar9) =
bVar1 >> (8 - bVar2 & 0x1f) |
(*(byte *)(param_4 + 1 + uVar9) >> (bVar4 & 0x1f)) << (bVar4 & 0x1f);
}
__src = __src + 1;
uVar10 = uVar3 - 1;
}
memcpy((void *)((ulong)*(uint *)(plVar12 + 1) + param_4),__src,(ulong)uVar10);
__src = __src + uVar10;
}
else {
uVar3 = *(ushort *)((long)plVar12 + 0x12);
if ((uVar3 & 1) == 0) {
if ((uVar3 & 8) == 0) {
if ((uVar3 & 0x20) == 0) {
uVar9 = (ulong)*(ushort *)((long)plVar12 + 0x14);
if ((uVar3 & 0x40) == 0) {
if (pbVar5 < __src + uVar9) {
return 1;
}
memcpy((void *)((ulong)*(uint *)(plVar12 + 1) + param_4),__src,uVar9);
__src = __src + *(ushort *)((long)plVar12 + 0x14);
}
else {
if (pbVar5 < __src + uVar9) {
return 1;
}
uVar10 = *(uint *)(plVar12 + 1);
do {
bVar4 = *__src;
__src = __src + 1;
*(byte *)((ulong)uVar10 + param_4 + -1 + uVar9) = bVar4;
uVar9 = uVar9 - 1;
} while (uVar9 != 0);
}
}
else {
uVar10 = (uint)*__src;
if (*__src == 0xff) {
uVar10 = (uint)(ushort)(*(ushort *)(__src + 1) << 8 | *(ushort *)(__src + 1) >> 8)
;
lVar8 = 3;
}
else {
lVar8 = 1;
}
if (*(ushort *)((long)plVar12 + 0x14) < uVar10) {
return 1;
}
pbVar11 = __src + lVar8;
uVar9 = (ulong)uVar10;
__src = pbVar11 + uVar9;
if (pbVar5 < __src) {
return 1;
}
if (param_3 != '\0') {
*(void **)((ulong)*(byte *)((long)plVar12 + 0x1a) +
(ulong)*(uint *)(plVar12 + 1) + param_4) = local_58;
memcpy(local_58,pbVar11,uVar9);
*(byte *)((long)param_1 + 0x1d1) = *(byte *)((long)param_1 + 0x1d1) & 0xef;
local_58 = (void *)((long)local_58 + uVar9);
_mi_store_blob_length
((ulong)*(uint *)(plVar12 + 1) + param_4,
*(int1 *)((long)plVar12 + 0x1a),uVar10);
}
}
}
else {
uVar10 = (uint)*__src;
if (*__src == 0xff) {
uVar10 = (uint)(ushort)(*(ushort *)(__src + 1) << 8 | *(ushort *)(__src + 1) >> 8);
lVar8 = 3;
}
else {
lVar8 = 1;
}
if (*(ushort *)((long)plVar12 + 0x14) < uVar10) {
return 1;
}
pbVar11 = __src + lVar8;
__src = pbVar11 + uVar10;
if (pbVar5 < __src) {
return 1;
}
if (*(char *)((long)plVar12 + 0x1a) == '\x01') {
*(char *)(param_4 + (ulong)*(uint *)(plVar12 + 1)) = (char)uVar10;
}
else {
*(short *)(param_4 + (ulong)*(uint *)(plVar12 + 1)) = (short)uVar10;
}
memcpy((void *)((ulong)*(byte *)((long)plVar12 + 0x1a) +
(ulong)*(uint *)(plVar12 + 1) + param_4),pbVar11,(ulong)uVar10);
}
}
else {
uVar10 = (uint)*__src;
if (*__src == 0xff) {
uVar10 = (uint)(ushort)(*(ushort *)(__src + 1) << 8 | *(ushort *)(__src + 1) >> 8);
lVar8 = 3;
}
else {
lVar8 = 1;
}
if (*(ushort *)((long)plVar12 + 0x14) < uVar10) {
return 1;
}
pbVar11 = __src + lVar8;
uVar9 = (ulong)uVar10;
__src = pbVar11 + uVar9;
if (pbVar5 < __src) {
return 1;
}
__dest = (void *)((ulong)*(uint *)(plVar12 + 1) + param_4);
if (cVar7 == '\a') {
memset(__dest,0x20,(ulong)(*(ushort *)((long)plVar12 + 0x14) - uVar10));
memcpy((void *)((long)__dest + (*(ushort *)((long)plVar12 + 0x14) - uVar9)),pbVar11,
uVar9);
}
else {
memcpy(__dest,pbVar11,uVar9);
(**(code **)(*(long *)(*plVar12 + 0xb8) + 0x78))
(*plVar12,(long)__dest + uVar9,*(ushort *)((long)plVar12 + 0x14) - uVar10,
0x20);
}
}
}
}
else {
__src = pbVar11 + 1;
if (*pbVar11 != 0) {
pbVar11 = (byte *)(param_4 + (ulong)*(uint *)((long)plVar12 + 0xc));
*pbVar11 = *pbVar11 & ~bVar4;
cVar7 = (char)*plVar6;
goto LAB_0017ead4;
}
pbVar11 = (byte *)(param_4 + (ulong)*(uint *)((long)plVar12 + 0xc));
*pbVar11 = *pbVar11 | bVar4;
}
cVar7 = (char)plVar12[7];
plVar6 = plVar12 + 7;
pbVar11 = __src;
plVar12 = plVar12 + 4;
} while (cVar7 != '\0');
}
return 0;
}
| |
52,996 | long minja::Value::get<long>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, long) const | llama.cpp/common/minja/minja.hpp | T get(const std::string & key, T default_value) const {
if (!contains(key)) return default_value;
return at(key).get<T>();
} | O3 | cpp | long minja::Value::get<long>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, long) const:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0xe6dec
testb %al, %al
je 0xe6dcc
movq %rsp, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xe1252
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe569a
movq %rax, %rdi
callq 0xe6f36
movq %rax, %rbx
leaq 0x40(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0xaa5c4
movq %r14, %rdi
callq 0xaecde
leaq 0x38(%rsp), %rdi
callq 0x58ca6
leaq 0x28(%rsp), %rdi
callq 0x58ca6
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x58ca6
movq -0x10(%r14), %rdi
testq %rdi, %rdi
je 0xe6dcc
movq 0xa81f1(%rip), %rax # 0x18ef98
cmpb $0x0, (%rax)
je 0xe6db7
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0xe6dc1
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0xe6dcc
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xdb4e8
movq %rbx, %rdi
callq 0x23ee0
| _ZNK5minja5Value3getIlEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES2_:
push r15
push r14
push rbx
sub rsp, 50h
mov rbx, rdx
mov r15, rsi
mov r14, rdi
call _ZNK5minja5Value8containsERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; minja::Value::contains(std::string const&)
test al, al
jz loc_E6DCC
mov rbx, rsp
mov rdi, rbx
mov rsi, r15
call _ZN5minja5ValueC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; minja::Value::Value(std::string const&)
mov rdi, r14; this
mov rsi, rbx; minja::Value *
call _ZN5minja5Value2atERKS0_; minja::Value::at(minja::Value const&)
mov rdi, rax
call _ZNK5minja5Value3getIlEET_v; minja::Value::get<long>(void)
mov rbx, rax
lea r14, [rsp+68h+var_28]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
lea rdi, [rsp+68h+var_30]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea rdi, [rsp+68h+var_40]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea r14, [rsp+68h+var_50]
mov rdi, r14
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rdi, [r14-10h]
test rdi, rdi
jz short loc_E6DCC
mov rax, cs:_ZTISt19_Sp_make_shared_tag; `typeinfo for'std::_Sp_make_shared_tag
cmp byte ptr [rax], 0
jz short loc_E6DB7
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_E6DC1
loc_E6DB7:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_E6DC1:
cmp eax, 1
jnz short loc_E6DCC
mov rax, [rdi]
call qword ptr [rax+18h]
loc_E6DCC:
mov rax, rbx
add rsp, 50h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
mov rdi, rsp; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
mov rdi, rbx
call __Unwind_Resume
| long long minja::Value::get<long>(minja::Value *this, long long a2, long long a3)
{
unsigned long long v4; // rax
long long v5; // rdi
signed __int32 v6; // eax
long long v8; // [rsp+0h] [rbp-68h] BYREF
long long v9; // [rsp+8h] [rbp-60h]
volatile signed __int32 *v10; // [rsp+18h] [rbp-50h] BYREF
volatile signed __int32 *v11; // [rsp+28h] [rbp-40h] BYREF
volatile signed __int32 *v12; // [rsp+38h] [rbp-30h] BYREF
char v13[40]; // [rsp+40h] [rbp-28h] BYREF
if ( (unsigned __int8)minja::Value::contains() )
{
minja::Value::Value((long long)&v8, a2);
v4 = minja::Value::at(this, (const minja::Value *)&v8);
a3 = minja::Value::get<long>(v4);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v13);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v13);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v12);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v11);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v10);
v5 = v9;
if ( v9 )
{
if ( _libc_single_threaded )
{
v6 = *(_DWORD *)(v9 + 12);
*(_DWORD *)(v9 + 12) = v6 - 1;
}
else
{
v6 = _InterlockedExchangeAdd((volatile signed __int32 *)(v9 + 12), 0xFFFFFFFF);
}
if ( v6 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v5 + 24LL))(v5, 0LL);
}
}
return a3;
}
| get<long>:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x50
MOV RBX,RDX
MOV R15,RSI
MOV R14,RDI
CALL 0x001e6dec
TEST AL,AL
JZ 0x001e6dcc
MOV RBX,RSP
MOV RDI,RBX
MOV RSI,R15
CALL 0x001e1252
LAB_001e6d49:
MOV RDI,R14
MOV RSI,RBX
CALL 0x001e569a
MOV RDI,RAX
CALL 0x001e6f36
LAB_001e6d5c:
MOV RBX,RAX
LEA R14,[RSP + 0x40]
MOV RDI,R14
XOR ESI,ESI
CALL 0x001aa5c4
MOV RDI,R14
CALL 0x001aecde
LEA RDI,[RSP + 0x38]
CALL 0x00158ca6
LEA RDI,[RSP + 0x28]
CALL 0x00158ca6
LEA R14,[RSP + 0x18]
MOV RDI,R14
CALL 0x00158ca6
MOV RDI,qword ptr [R14 + -0x10]
TEST RDI,RDI
JZ 0x001e6dcc
MOV RAX,qword ptr [0x0028ef98]
CMP byte ptr [RAX],0x0
JZ 0x001e6db7
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x001e6dc1
LAB_001e6db7:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_001e6dc1:
CMP EAX,0x1
JNZ 0x001e6dcc
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_001e6dcc:
MOV RAX,RBX
ADD RSP,0x50
POP RBX
POP R14
POP R15
RET
|
/* long minja::Value::get<long>(std::__cxx11::string const&, long) const */
long __thiscall minja::Value::get<long>(Value *this,string *param_1,long param_2)
{
int *piVar1;
char cVar2;
int iVar3;
Value *this_00;
Value aVStack_68 [8];
long *local_60;
__shared_count<(__gnu_cxx::_Lock_policy)2> local_50 [16];
__shared_count<(__gnu_cxx::_Lock_policy)2> local_40 [16];
__shared_count<(__gnu_cxx::_Lock_policy)2> local_30 [8];
data local_28 [16];
cVar2 = contains(this,param_1);
if (cVar2 != '\0') {
Value(aVStack_68,param_1);
/* try { // try from 001e6d49 to 001e6d5b has its CatchHandler @ 001e6dd9 */
this_00 = (Value *)at(this,aVStack_68);
param_2 = get<long>(this_00);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_28,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_28);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_30);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_40);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_50);
if (local_60 != (long *)0x0) {
if (*PTR___libc_single_threaded_0028ef98 == '\0') {
LOCK();
piVar1 = (int *)((long)local_60 + 0xc);
iVar3 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar3 = *(int *)((long)local_60 + 0xc);
*(int *)((long)local_60 + 0xc) = iVar3 + -1;
}
if (iVar3 == 1) {
(**(code **)(*local_60 + 0x18))();
}
}
}
return param_2;
}
| |
52,997 | ftb_check_phrase | eloqsql/storage/myisam/ft_boolean_search.c | static int _ftb_check_phrase(FTB *ftb, const uchar *document, uint len,
FTB_EXPR *ftbe, struct st_mysql_ftparser *parser)
{
MY_FTB_PHRASE_PARAM ftb_param;
MYSQL_FTPARSER_PARAM *param;
DBUG_ENTER("_ftb_check_phrase");
DBUG_ASSERT(parser);
if (! (param= ftparser_call_initializer(ftb->info, ftb->keynr, 1)))
DBUG_RETURN(0);
ftb_param.phrase= ftbe->phrase;
ftb_param.document= ftbe->document;
ftb_param.cs= ftb->charset;
ftb_param.phrase_length= list_length(ftbe->phrase);
ftb_param.document_length= 1;
ftb_param.match= 0;
param->mysql_parse= ftb_check_phrase_internal;
param->mysql_add_word= ftb_phrase_add_word;
param->mysql_ftparam= (void *)&ftb_param;
param->cs= ftb->charset;
param->doc= (char *) document;
param->length= len;
param->flags= 0;
param->mode= MYSQL_FTPARSER_WITH_STOPWORDS;
if (unlikely(parser->parse(param)))
return -1;
DBUG_RETURN(ftb_param.match ? 1 : 0);
} | O0 | c | ftb_check_phrase:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
jmp 0x9f8bd
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x340(%rax), %esi
movl $0x1, %edx
callq 0xa2270
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
jne 0x9f8f1
jmp 0x9f8e5
movl $0x0, -0x4(%rbp)
jmp 0x9f9d7
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0xdef20
movl %eax, -0x40(%rbp)
movl $0x1, -0x3c(%rbp)
movl $0x0, -0x38(%rbp)
movq -0x60(%rbp), %rax
leaq 0xa2(%rip), %rcx # 0x9f9e0
movq %rcx, (%rax)
movq -0x60(%rbp), %rax
leaq 0x114(%rip), %rcx # 0x9fa60
movq %rcx, 0x8(%rax)
movq -0x60(%rbp), %rax
leaq -0x58(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x60(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x60(%rbp), %rax
movq %rcx, 0x28(%rax)
movl -0x1c(%rbp), %ecx
movq -0x60(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x60(%rbp), %rax
movl $0x0, 0x34(%rax)
movq -0x60(%rbp), %rax
movl $0x1, 0x38(%rax)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x60(%rbp), %rdi
callq *%rax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x9f9c2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9f9d7
jmp 0x9f9c4
movl -0x38(%rbp), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
| _ftb_check_phrase:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
jmp short $+2
loc_9F8BD:
mov rax, [rbp+var_10]
mov rdi, [rax+8]
mov rax, [rbp+var_10]
mov esi, [rax+340h]
mov edx, 1
call ftparser_call_initializer
mov [rbp+var_60], rax
cmp rax, 0
jnz short loc_9F8F1
jmp short $+2
loc_9F8E5:
mov [rbp+var_4], 0
jmp loc_9F9D7
loc_9F8F1:
mov rax, [rbp+var_28]
mov rax, [rax+30h]
mov [rbp+var_58], rax
mov rax, [rbp+var_28]
mov rax, [rax+38h]
mov [rbp+var_50], rax
mov rax, [rbp+var_10]
mov rax, [rax+10h]
mov [rbp+var_48], rax
mov rax, [rbp+var_28]
mov rdi, [rax+30h]
call list_length
mov [rbp+var_40], eax
mov [rbp+var_3C], 1
mov [rbp+var_38], 0
mov rax, [rbp+var_60]
lea rcx, ftb_check_phrase_internal
mov [rax], rcx
mov rax, [rbp+var_60]
lea rcx, ftb_phrase_add_word
mov [rax+8], rcx
mov rax, [rbp+var_60]
lea rcx, [rbp+var_58]
mov [rax+18h], rcx
mov rax, [rbp+var_10]
mov rcx, [rax+10h]
mov rax, [rbp+var_60]
mov [rax+20h], rcx
mov rcx, [rbp+var_18]
mov rax, [rbp+var_60]
mov [rax+28h], rcx
mov ecx, [rbp+var_1C]
mov rax, [rbp+var_60]
mov [rax+30h], ecx
mov rax, [rbp+var_60]
mov dword ptr [rax+34h], 0
mov rax, [rbp+var_60]
mov dword ptr [rax+38h], 1
mov rax, [rbp+var_30]
mov rax, [rax+8]
mov rdi, [rbp+var_60]
call rax
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_9F9C2
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_9F9D7
loc_9F9C2:
jmp short $+2
loc_9F9C4:
mov edx, [rbp+var_38]
xor eax, eax
mov ecx, 1
cmp edx, 0
cmovnz eax, ecx
mov [rbp+var_4], eax
loc_9F9D7:
mov eax, [rbp+var_4]
add rsp, 60h
pop rbp
retn
| long long ftb_check_phrase(long long a1, long long a2, int a3, long long a4, long long a5)
{
long long v6; // [rsp+0h] [rbp-60h]
_QWORD v7[3]; // [rsp+8h] [rbp-58h] BYREF
int v8; // [rsp+20h] [rbp-40h]
int v9; // [rsp+24h] [rbp-3Ch]
int v10; // [rsp+28h] [rbp-38h]
long long v11; // [rsp+30h] [rbp-30h]
long long v12; // [rsp+38h] [rbp-28h]
int v13; // [rsp+44h] [rbp-1Ch]
long long v14; // [rsp+48h] [rbp-18h]
long long v15; // [rsp+50h] [rbp-10h]
v15 = a1;
v14 = a2;
v13 = a3;
v12 = a4;
v11 = a5;
v6 = ftparser_call_initializer(*(_QWORD *)(v15 + 8), *(unsigned int *)(v15 + 832), 1LL);
if ( v6 )
{
v7[0] = *(_QWORD *)(v12 + 48);
v7[1] = *(_QWORD *)(v12 + 56);
v7[2] = *(_QWORD *)(v15 + 16);
v8 = list_length(*(_QWORD *)(v12 + 48));
v9 = 1;
v10 = 0;
*(_QWORD *)v6 = ftb_check_phrase_internal;
*(_QWORD *)(v6 + 8) = ftb_phrase_add_word;
*(_QWORD *)(v6 + 24) = v7;
*(_QWORD *)(v6 + 32) = *(_QWORD *)(v15 + 16);
*(_QWORD *)(v6 + 40) = v14;
*(_DWORD *)(v6 + 48) = v13;
*(_DWORD *)(v6 + 52) = 0;
*(_DWORD *)(v6 + 56) = 1;
if ( (*(unsigned int ( **)(long long))(v11 + 8))(v6) )
return (unsigned int)-1;
else
return v10 != 0;
}
else
{
return 0;
}
}
| _ftb_check_phrase:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
JMP 0x0019f8bd
LAB_0019f8bd:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RAX + 0x340]
MOV EDX,0x1
CALL 0x001a2270
MOV qword ptr [RBP + -0x60],RAX
CMP RAX,0x0
JNZ 0x0019f8f1
JMP 0x0019f8e5
LAB_0019f8e5:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0019f9d7
LAB_0019f8f1:
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x30]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x38]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,qword ptr [RAX + 0x30]
CALL 0x001def20
MOV dword ptr [RBP + -0x40],EAX
MOV dword ptr [RBP + -0x3c],0x1
MOV dword ptr [RBP + -0x38],0x0
MOV RAX,qword ptr [RBP + -0x60]
LEA RCX,[0x19f9e0]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x60]
LEA RCX,[0x19fa60]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x60]
LEA RCX,[RBP + -0x58]
MOV qword ptr [RAX + 0x18],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RAX + 0x20],RCX
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RAX + 0x28],RCX
MOV ECX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x60]
MOV dword ptr [RAX + 0x30],ECX
MOV RAX,qword ptr [RBP + -0x60]
MOV dword ptr [RAX + 0x34],0x0
MOV RAX,qword ptr [RBP + -0x60]
MOV dword ptr [RAX + 0x38],0x1
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x8]
MOV RDI,qword ptr [RBP + -0x60]
CALL RAX
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x0019f9c2
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x0019f9d7
LAB_0019f9c2:
JMP 0x0019f9c4
LAB_0019f9c4:
MOV EDX,dword ptr [RBP + -0x38]
XOR EAX,EAX
MOV ECX,0x1
CMP EDX,0x0
CMOVNZ EAX,ECX
MOV dword ptr [RBP + -0x4],EAX
LAB_0019f9d7:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x60
POP RBP
RET
|
uint _ftb_check_phrase(long param_1,int8 param_2,int4 param_3,long param_4,long param_5)
{
int iVar1;
int8 *puVar2;
int8 local_60;
int8 local_58;
int8 local_50;
int4 local_48;
int4 local_44;
int local_40;
long local_38;
long local_30;
int4 local_24;
int8 local_20;
long local_18;
uint local_c;
local_38 = param_5;
local_30 = param_4;
local_24 = param_3;
local_20 = param_2;
local_18 = param_1;
puVar2 = (int8 *)
ftparser_call_initializer
(*(int8 *)(param_1 + 8),*(int4 *)(param_1 + 0x340),1);
if (puVar2 == (int8 *)0x0) {
local_c = 0;
}
else {
local_60 = *(int8 *)(local_30 + 0x30);
local_58 = *(int8 *)(local_30 + 0x38);
local_50 = *(int8 *)(local_18 + 0x10);
local_48 = list_length(*(int8 *)(local_30 + 0x30));
local_44 = 1;
local_40 = 0;
*puVar2 = ftb_check_phrase_internal;
puVar2[1] = ftb_phrase_add_word;
puVar2[3] = &local_60;
puVar2[4] = *(int8 *)(local_18 + 0x10);
puVar2[5] = local_20;
*(int4 *)(puVar2 + 6) = local_24;
*(int4 *)((long)puVar2 + 0x34) = 0;
*(int4 *)(puVar2 + 7) = 1;
iVar1 = (**(code **)(local_38 + 8))(puVar2);
if (iVar1 == 0) {
local_c = (uint)(local_40 != 0);
}
else {
local_c = 0xffffffff;
}
}
return local_c;
}
| |
52,998 | ggml_div_impl | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c | static struct ggml_tensor * ggml_div_impl(
struct ggml_context * ctx,
struct ggml_tensor * a,
struct ggml_tensor * b,
bool inplace) {
GGML_ASSERT(ggml_can_repeat(b, a));
struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);
result->op = GGML_OP_DIV;
result->src[0] = a;
result->src[1] = b;
return result;
} | O0 | c | ggml_div_impl:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x47040
testb $0x1, %al
jne 0x4d5bd
leaq 0x64014(%rip), %rdi # 0xb15b7
movl $0x806, %esi # imm = 0x806
leaq 0x6405a(%rip), %rdx # 0xb1609
leaq 0x64272(%rip), %rcx # 0xb1828
movb $0x0, %al
callq 0x48a00
testb $0x1, -0x19(%rbp)
je 0x4d5d6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x428f0
movq %rax, -0x30(%rbp)
jmp 0x4d5e7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x45d90
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x7, 0x50(%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x98(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0xa0(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| ggml_div_impl:
push rbp
mov rbp, rsp
sub rsp, 30h
mov al, cl
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
and al, 1
mov [rbp+var_19], al
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_10]
call _ggml_can_repeat
test al, 1
jnz short loc_4D5BD
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
mov esi, 806h
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlCanRepeatB; "ggml_can_repeat(b, a)"
mov al, 0
call _ggml_abort
loc_4D5BD:
test [rbp+var_19], 1
jz short loc_4D5D6
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
call _ggml_view_tensor
mov [rbp+var_30], rax
jmp short loc_4D5E7
loc_4D5D6:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
call _ggml_dup_tensor
mov [rbp+var_30], rax
loc_4D5E7:
mov rax, [rbp+var_30]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
mov dword ptr [rax+50h], 7
mov rcx, [rbp+var_10]
mov rax, [rbp+var_28]
mov [rax+98h], rcx
mov rcx, [rbp+var_18]
mov rax, [rbp+var_28]
mov [rax+0A0h], rcx
mov rax, [rbp+var_28]
add rsp, 30h
pop rbp
retn
| long long ggml_div_impl(
long long a1,
long long *a2,
_QWORD *a3,
char a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
double a9,
double a10,
__m128 a11,
__m128 a12)
{
double v12; // xmm4_8
double v13; // xmm5_8
long long v15; // [rsp+0h] [rbp-30h]
char v16; // [rsp+17h] [rbp-19h]
v16 = a4 & 1;
if ( !ggml_can_repeat(a3, a2) )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c",
2054,
(long long)"GGML_ASSERT(%s) failed",
"ggml_can_repeat(b, a)");
if ( (v16 & 1) != 0 )
v15 = (long long)ggml_view_tensor(a1, (long long)a2, a5, a6, a7, a8, v12, v13, a11, a12);
else
v15 = ggml_dup_tensor(a1, (unsigned int *)a2);
*(_DWORD *)(v15 + 80) = 7;
*(_QWORD *)(v15 + 152) = a2;
*(_QWORD *)(v15 + 160) = a3;
return v15;
}
| ggml_div_impl:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV AL,CL
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
AND AL,0x1
MOV byte ptr [RBP + -0x19],AL
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x00147040
TEST AL,0x1
JNZ 0x0014d5bd
LEA RDI,[0x1b15b7]
MOV ESI,0x806
LEA RDX,[0x1b1609]
LEA RCX,[0x1b1828]
MOV AL,0x0
CALL 0x00148a00
LAB_0014d5bd:
TEST byte ptr [RBP + -0x19],0x1
JZ 0x0014d5d6
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x001428f0
MOV qword ptr [RBP + -0x30],RAX
JMP 0x0014d5e7
LAB_0014d5d6:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x00145d90
MOV qword ptr [RBP + -0x30],RAX
LAB_0014d5e7:
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX + 0x50],0x7
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0x98],RCX
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0xa0],RCX
MOV RAX,qword ptr [RBP + -0x28]
ADD RSP,0x30
POP RBP
RET
|
long ggml_div_impl(int8 param_1,int8 param_2,int8 param_3,byte param_4)
{
ulong uVar1;
long local_38;
uVar1 = ggml_can_repeat(param_3,param_2);
if ((uVar1 & 1) == 0) {
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c",
0x806,"GGML_ASSERT(%s) failed","ggml_can_repeat(b, a)");
}
if ((param_4 & 1) == 0) {
local_38 = ggml_dup_tensor(param_1,param_2);
}
else {
local_38 = ggml_view_tensor(param_1,param_2);
}
*(int4 *)(local_38 + 0x50) = 7;
*(int8 *)(local_38 + 0x98) = param_2;
*(int8 *)(local_38 + 0xa0) = param_3;
return local_38;
}
| |
52,999 | ggml_div_impl | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c | static struct ggml_tensor * ggml_div_impl(
struct ggml_context * ctx,
struct ggml_tensor * a,
struct ggml_tensor * b,
bool inplace) {
GGML_ASSERT(ggml_can_repeat(b, a));
struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);
result->op = GGML_OP_DIV;
result->src[0] = a;
result->src[1] = b;
return result;
} | O1 | c | ggml_div_impl:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0x185d0
testb %al, %al
je 0x1c4bf
testb %bpl, %bpl
je 0x1c485
movq %r15, %rdi
movq %r14, %rsi
callq 0x17260
jmp 0x1c49f
movl (%r14), %esi
leaq 0x10(%r14), %rcx
movq %r15, %rdi
movl $0x4, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x1b871
movl $0x7, 0x50(%rax)
movq %r14, 0x98(%rax)
movq %rbx, 0xa0(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x300a9(%rip), %rdi # 0x4c56f
leaq 0x300f4(%rip), %rdx # 0x4c5c1
leaq 0x3030c(%rip), %rcx # 0x4c7e0
movl $0x806, %esi # imm = 0x806
xorl %eax, %eax
callq 0x18ce0
| ggml_div_impl:
push rbp
push r15
push r14
push rbx
push rax
mov ebp, ecx
mov rbx, rdx
mov r14, rsi
mov r15, rdi
mov rdi, rdx
call _ggml_can_repeat
test al, al
jz short loc_1C4BF
test bpl, bpl
jz short loc_1C485
mov rdi, r15
mov rsi, r14
call _ggml_view_tensor
jmp short loc_1C49F
loc_1C485:
mov esi, [r14]
lea rcx, [r14+10h]
mov rdi, r15
mov edx, 4
xor r8d, r8d
xor r9d, r9d
call ggml_new_tensor_impl
loc_1C49F:
mov dword ptr [rax+50h], 7
mov [rax+98h], r14
mov [rax+0A0h], rbx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_1C4BF:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlCanRepeatB; "ggml_can_repeat(b, a)"
mov esi, 806h
xor eax, eax
call _ggml_abort
| long long ggml_div_impl(long long a1, long long *a2, _QWORD *a3, char a4, double a5)
{
int v7; // r8d
int v8; // r9d
long long result; // rax
if ( !ggml_can_repeat(a3, a2) )
ggml_abort(
(unsigned int)"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c",
2054,
(unsigned int)"GGML_ASSERT(%s) failed",
(unsigned int)"ggml_can_repeat(b, a)",
v7,
v8);
if ( a4 )
result = ggml_view_tensor(a1, (long long)a2, a5);
else
result = ggml_new_tensor_impl(a1, *(_DWORD *)a2, 4, a2 + 2, 0LL, 0LL, a5);
*(_DWORD *)(result + 80) = 7;
*(_QWORD *)(result + 152) = a2;
*(_QWORD *)(result + 160) = a3;
return result;
}
| ggml_div_impl:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV EBP,ECX
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
MOV RDI,RDX
CALL 0x001185d0
TEST AL,AL
JZ 0x0011c4bf
TEST BPL,BPL
JZ 0x0011c485
MOV RDI,R15
MOV RSI,R14
CALL 0x00117260
JMP 0x0011c49f
LAB_0011c485:
MOV ESI,dword ptr [R14]
LEA RCX,[R14 + 0x10]
MOV RDI,R15
MOV EDX,0x4
XOR R8D,R8D
XOR R9D,R9D
CALL 0x0011b871
LAB_0011c49f:
MOV dword ptr [RAX + 0x50],0x7
MOV qword ptr [RAX + 0x98],R14
MOV qword ptr [RAX + 0xa0],RBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0011c4bf:
LEA RDI,[0x14c56f]
LEA RDX,[0x14c5c1]
LEA RCX,[0x14c7e0]
MOV ESI,0x806
XOR EAX,EAX
CALL 0x00118ce0
|
void ggml_div_impl(int8 param_1,int4 *param_2,int8 param_3,char param_4)
{
char cVar1;
long lVar2;
cVar1 = ggml_can_repeat(param_3);
if (cVar1 != '\0') {
if (param_4 == '\0') {
lVar2 = ggml_new_tensor_impl(param_1,*param_2,4,param_2 + 4,0,0);
}
else {
lVar2 = ggml_view_tensor(param_1,param_2);
}
*(int4 *)(lVar2 + 0x50) = 7;
*(int4 **)(lVar2 + 0x98) = param_2;
*(int8 *)(lVar2 + 0xa0) = param_3;
return;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c",
0x806,"GGML_ASSERT(%s) failed","ggml_can_repeat(b, a)");
}
|
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.