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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
900 | mysql_stmt_execute | eloqsql/libmariadb/libmariadb/mariadb_stmt.c | int STDCALL mysql_stmt_execute(MYSQL_STMT *stmt)
{
MYSQL *mysql= stmt->mysql;
char *request;
int ret;
size_t request_len= 0;
if (!stmt->mysql)
{
SET_CLIENT_STMT_ERROR(stmt, CR_SERVER_LOST, SQLSTATE_UNKNOWN, 0);
return(1);
}
if (stmt->state < MYSQL_STMT_PREPARED)
{
SET_CLIENT_ERROR(mysql, CR_COMMANDS_OUT_OF_SYNC, SQLSTATE_UNKNOWN, 0);
SET_CLIENT_STMT_ERROR(stmt, CR_COMMANDS_OUT_OF_SYNC, SQLSTATE_UNKNOWN, 0);
return(1);
}
if (stmt->param_count && !stmt->bind_param_done)
{
SET_CLIENT_STMT_ERROR(stmt, CR_PARAMS_NOT_BOUND, SQLSTATE_UNKNOWN, 0);
return(1);
}
if (stmt->state == MYSQL_STMT_WAITING_USE_OR_STORE)
{
stmt->default_rset_handler = _mysql_stmt_use_result;
stmt->default_rset_handler(stmt);
}
if (stmt->state > MYSQL_STMT_WAITING_USE_OR_STORE && stmt->state < MYSQL_STMT_FETCH_DONE && !stmt->result.data)
{
if (!stmt->cursor_exists)
do {
stmt->mysql->methods->db_stmt_flush_unbuffered(stmt);
} while(mysql_stmt_more_results(stmt));
stmt->state= MYSQL_STMT_PREPARED;
stmt->mysql->status= MYSQL_STATUS_READY;
}
/* clear data, in case mysql_stmt_store_result was called */
if (stmt->result.data)
{
ma_free_root(&stmt->result.alloc, MYF(MY_KEEP_PREALLOC));
stmt->result_cursor= stmt->result.data= 0;
}
/* CONC-344: set row count to zero */
stmt->result.rows= 0;
request= (char *)ma_stmt_execute_generate_request(stmt, &request_len, 0);
if (!request)
return 1;
ret= stmt->mysql->methods->db_command(mysql,
stmt->array_size > 0 ? COM_STMT_BULK_EXECUTE : COM_STMT_EXECUTE,
request, request_len, 1, stmt);
if (request)
free(request);
if (ret)
{
UPDATE_STMT_ERROR(stmt);
return(1);
}
if (mysql->net.extension->multi_status > COM_MULTI_OFF ||
mysql->options.extension->skip_read_response)
return(0);
return(mthd_stmt_read_execute_response(stmt));
} | O3 | c | mysql_stmt_execute:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x38(%rdi), %r14
movq $0x0, -0x30(%rbp)
testq %r14, %r14
je 0x65dde
movl 0x50(%rbx), %eax
testl %eax, %eax
je 0x65e35
cmpl $0x0, 0x64(%rbx)
je 0x65c79
cmpb $0x0, 0xe9(%rbx)
je 0x65ee7
cmpl $0x3, %eax
jne 0x65c97
leaq -0x31b1(%rip), %rax # 0x62ad4
movq %rax, 0x358(%rbx)
movq %rbx, %rdi
callq 0x62ad4
movl 0x50(%rbx), %eax
andl $-0x2, %eax
cmpl $0x4, %eax
jne 0x65ce7
cmpq $0x0, 0x80(%rbx)
jne 0x65ce7
cmpb $0x0, 0x338(%rbx)
movq 0x38(%rbx), %rax
jne 0x65cd6
movq 0x4d0(%rax), %rax
movq %rbx, %rdi
callq *0x78(%rax)
movq 0x38(%rbx), %rax
movzwl 0x380(%rax), %ecx
testl $0x1008, %ecx # imm = 0x1008
jne 0x65cb6
movl $0x1, 0x50(%rbx)
movl $0x0, 0x488(%rax)
cmpq $0x0, 0x80(%rbx)
je 0x65d12
leaq 0x90(%rbx), %rdi
movl $0x1, %esi
callq 0x61f23
xorl %eax, %eax
movq %rax, 0x80(%rbx)
movq %rax, 0xe0(%rbx)
movq $0x0, 0xc8(%rbx)
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x63b2b
testq %rax, %rax
je 0x65ecf
movq %rax, %r12
movq 0x38(%rbx), %rax
movq 0x4d0(%rax), %rax
cmpl $0x0, 0x368(%rbx)
movl $0x17, %ecx
movl $0xfa, %esi
cmovel %ecx, %esi
movq -0x30(%rbp), %rcx
movl $0x1, %r15d
movq %r14, %rdi
movq %r12, %rdx
movl $0x1, %r8d
movq %rbx, %r9
callq *0x10(%rax)
movl %eax, %r13d
movq %r12, %rdi
callq 0x3a210
testl %r13d, %r13d
je 0x65f30
movq 0x38(%rbx), %rsi
movl 0x90(%rsi), %eax
movl %eax, 0x108(%rbx)
leaq 0x30d(%rbx), %rdi
addq $0x297, %rsi # imm = 0x297
movl $0x5, %edx
callq 0x3a1a0
xorl %r14d, %r14d
movb %r14b, 0x312(%rbx)
leaq 0x10c(%rbx), %rdi
movl $0x97, %esi
addq 0x38(%rbx), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x3a1a0
movb %r14b, 0x30b(%rbx)
jmp 0x65ed5
movl $0x7dd, 0x108(%rbx) # imm = 0x7DD
leaq 0x30d(%rbx), %rdi
leaq 0x307cba(%rip), %rax # 0x36dab0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x3a1a0
xorl %r14d, %r14d
movb %r14b, 0x312(%rbx)
leaq 0x10c(%rbx), %rdi
leaq 0x307ca5(%rip), %rax # 0x36dac0
movq 0x68(%rax), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x3a1a0
movb %r14b, 0x30b(%rbx)
jmp 0x65ecf
movl $0x7de, %eax # imm = 0x7DE
movl %eax, 0x90(%r14)
leaq 0x297(%r14), %rdi
leaq 0x307c61(%rip), %r13 # 0x36dab0
movq (%r13), %rsi
movl $0x5, %edx
callq 0x3a1a0
xorl %r15d, %r15d
movb %r15b, 0x29c(%r14)
leaq 0x97(%r14), %rdi
leaq 0x307c4b(%rip), %r12 # 0x36dac0
movq 0x70(%r12), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x3a1a0
movb %r15b, 0x296(%r14)
movl $0x7de, %eax # imm = 0x7DE
movl %eax, 0x108(%rbx)
leaq 0x30d(%rbx), %rdi
movq (%r13), %rsi
movl $0x5, %edx
callq 0x3a1a0
movb %r15b, 0x312(%rbx)
leaq 0x10c(%rbx), %rdi
movq 0x70(%r12), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x3a1a0
movb %r15b, 0x30b(%rbx)
movl $0x1, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x7ef, 0x108(%rbx) # imm = 0x7EF
leaq 0x30d(%rbx), %rdi
leaq 0x307bb1(%rip), %rax # 0x36dab0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x3a1a0
xorl %r14d, %r14d
movb %r14b, 0x312(%rbx)
leaq 0x10c(%rbx), %rdi
leaq 0x307b9c(%rip), %rax # 0x36dac0
movq 0xf8(%rax), %rsi
jmp 0x65e1f
movq 0x2a0(%r14), %rax
xorl %r15d, %r15d
cmpl $0x0, (%rax)
jne 0x65ed5
movq 0x480(%r14), %rax
cmpb $0x0, 0x148(%rax)
jne 0x65ed5
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x65637
| mysql_stmt_execute:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
mov r14, [rdi+38h]
mov [rbp+var_30], 0
test r14, r14
jz loc_65DDE
mov eax, [rbx+50h]
test eax, eax
jz loc_65E35
cmp dword ptr [rbx+64h], 0
jz short loc_65C79
cmp byte ptr [rbx+0E9h], 0
jz loc_65EE7
loc_65C79:
cmp eax, 3
jnz short loc_65C97
lea rax, _mysql_stmt_use_result
mov [rbx+358h], rax
mov rdi, rbx
call _mysql_stmt_use_result
mov eax, [rbx+50h]
loc_65C97:
and eax, 0FFFFFFFEh
cmp eax, 4
jnz short loc_65CE7
cmp qword ptr [rbx+80h], 0
jnz short loc_65CE7
cmp byte ptr [rbx+338h], 0
mov rax, [rbx+38h]
jnz short loc_65CD6
loc_65CB6:
mov rax, [rax+4D0h]
mov rdi, rbx
call qword ptr [rax+78h]
mov rax, [rbx+38h]
movzx ecx, word ptr [rax+380h]
test ecx, 1008h
jnz short loc_65CB6
loc_65CD6:
mov dword ptr [rbx+50h], 1
mov dword ptr [rax+488h], 0
loc_65CE7:
cmp qword ptr [rbx+80h], 0
jz short loc_65D12
lea rdi, [rbx+90h]
mov esi, 1
call ma_free_root
xor eax, eax
mov [rbx+80h], rax
mov [rbx+0E0h], rax
loc_65D12:
mov qword ptr [rbx+0C8h], 0
lea rsi, [rbp+var_30]
mov rdi, rbx
xor edx, edx
call ma_stmt_execute_generate_request
test rax, rax
jz loc_65ECF
mov r12, rax
mov rax, [rbx+38h]
mov rax, [rax+4D0h]
cmp dword ptr [rbx+368h], 0
mov ecx, 17h
mov esi, 0FAh
cmovz esi, ecx
mov rcx, [rbp+var_30]
mov r15d, 1
mov rdi, r14
mov rdx, r12
mov r8d, 1
mov r9, rbx
call qword ptr [rax+10h]
mov r13d, eax
mov rdi, r12
call _free
test r13d, r13d
jz loc_65F30
mov rsi, [rbx+38h]
mov eax, [rsi+90h]
mov [rbx+108h], eax
lea rdi, [rbx+30Dh]
add rsi, 297h
mov edx, 5
call _strncpy
xor r14d, r14d
mov [rbx+312h], r14b
lea rdi, [rbx+10Ch]
mov esi, 97h
add rsi, [rbx+38h]
mov edx, 200h
call _strncpy
mov [rbx+30Bh], r14b
jmp loc_65ED5
loc_65DDE:
mov dword ptr [rbx+108h], 7DDh
lea rdi, [rbx+30Dh]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
xor r14d, r14d
mov [rbx+312h], r14b
lea rdi, [rbx+10Ch]
lea rax, client_errors
mov rsi, [rax+68h]
loc_65E1F:
mov edx, 200h
call _strncpy
mov [rbx+30Bh], r14b
jmp loc_65ECF
loc_65E35:
mov eax, 7DEh
mov [r14+90h], eax
lea rdi, [r14+297h]
lea r13, SQLSTATE_UNKNOWN
mov rsi, [r13+0]
mov edx, 5
call _strncpy
xor r15d, r15d
mov [r14+29Ch], r15b
lea rdi, [r14+97h]
lea r12, client_errors
mov rsi, [r12+70h]
mov edx, 1FFh
call _strncpy
mov [r14+296h], r15b
mov eax, 7DEh
mov [rbx+108h], eax
lea rdi, [rbx+30Dh]
mov rsi, [r13+0]
mov edx, 5
call _strncpy
mov [rbx+312h], r15b
lea rdi, [rbx+10Ch]
mov rsi, [r12+70h]
mov edx, 200h
call _strncpy
mov [rbx+30Bh], r15b
loc_65ECF:
mov r15d, 1
loc_65ED5:
mov eax, r15d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_65EE7:
mov dword ptr [rbx+108h], 7EFh
lea rdi, [rbx+30Dh]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
xor r14d, r14d
mov [rbx+312h], r14b
lea rdi, [rbx+10Ch]
lea rax, client_errors
mov rsi, [rax+0F8h]
jmp loc_65E1F
loc_65F30:
mov rax, [r14+2A0h]
xor r15d, r15d
cmp dword ptr [rax], 0
jnz short loc_65ED5
mov rax, [r14+480h]
cmp byte ptr [rax+148h], 0
jnz short loc_65ED5
mov rdi, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp mthd_stmt_read_execute_response
| long long mysql_stmt_execute(long long a1)
{
long long v1; // rax
long long v3; // r14
int v4; // eax
long long v5; // rax
_BYTE *request; // rax
_BYTE *v7; // r12
long long v8; // rsi
unsigned int v9; // r15d
int v10; // r13d
long long v11; // rsi
long long v12; // rdi
char *v13; // rsi
long long v15[6]; // [rsp+0h] [rbp-30h] BYREF
v15[0] = v1;
v3 = *(_QWORD *)(a1 + 56);
v15[0] = 0LL;
if ( !v3 )
{
*(_DWORD *)(a1 + 264) = 2013;
strncpy(a1 + 781, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 786) = 0;
v12 = a1 + 268;
v13 = client_errors[13];
LABEL_20:
strncpy(v12, v13, 512LL);
*(_BYTE *)(a1 + 779) = 0;
return 1;
}
v4 = *(_DWORD *)(a1 + 80);
if ( !v4 )
{
*(_DWORD *)(v3 + 144) = 2014;
strncpy(v3 + 663, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(v3 + 668) = 0;
strncpy(v3 + 151, client_errors[14], 511LL);
*(_BYTE *)(v3 + 662) = 0;
*(_DWORD *)(a1 + 264) = 2014;
strncpy(a1 + 781, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 786) = 0;
strncpy(a1 + 268, client_errors[14], 512LL);
*(_BYTE *)(a1 + 779) = 0;
return 1;
}
if ( *(_DWORD *)(a1 + 100) && !*(_BYTE *)(a1 + 233) )
{
*(_DWORD *)(a1 + 264) = 2031;
strncpy(a1 + 781, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 786) = 0;
v12 = a1 + 268;
v13 = client_errors[31];
goto LABEL_20;
}
if ( v4 == 3 )
{
*(_QWORD *)(a1 + 856) = mysql_stmt_use_result;
mysql_stmt_use_result(a1);
v4 = *(_DWORD *)(a1 + 80);
}
if ( (v4 & 0xFFFFFFFE) == 4 && !*(_QWORD *)(a1 + 128) )
{
v5 = *(_QWORD *)(a1 + 56);
if ( !*(_BYTE *)(a1 + 824) )
{
do
{
(*(void ( **)(long long))(*(_QWORD *)(v5 + 1232) + 120LL))(a1);
v5 = *(_QWORD *)(a1 + 56);
}
while ( (*(_WORD *)(v5 + 896) & 0x1008) != 0 );
}
*(_DWORD *)(a1 + 80) = 1;
*(_DWORD *)(v5 + 1160) = 0;
}
if ( *(_QWORD *)(a1 + 128) )
{
ma_free_root(a1 + 144, 1);
*(_QWORD *)(a1 + 128) = 0LL;
*(_QWORD *)(a1 + 224) = 0LL;
}
*(_QWORD *)(a1 + 200) = 0LL;
request = ma_stmt_execute_generate_request(a1, v15, 0);
if ( !request )
return 1;
v7 = request;
v8 = 250LL;
if ( !*(_DWORD *)(a1 + 872) )
v8 = 23LL;
v9 = 1;
v10 = (*(long long ( **)(long long, long long, _BYTE *, long long, long long, long long))(*(_QWORD *)(*(_QWORD *)(a1 + 56) + 1232LL)
+ 16LL))(
v3,
v8,
request,
v15[0],
1LL,
a1);
free(v7);
if ( v10 )
{
v11 = *(_QWORD *)(a1 + 56);
*(_DWORD *)(a1 + 264) = *(_DWORD *)(v11 + 144);
strncpy(a1 + 781, v11 + 663, 5LL);
*(_BYTE *)(a1 + 786) = 0;
strncpy(a1 + 268, *(_QWORD *)(a1 + 56) + 151LL, 512LL);
*(_BYTE *)(a1 + 779) = 0;
return v9;
}
v9 = 0;
if ( **(_DWORD **)(v3 + 672) || *(_BYTE *)(*(_QWORD *)(v3 + 1152) + 328LL) )
return v9;
return mthd_stmt_read_execute_response(a1);
}
| mysql_stmt_execute:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV R14,qword ptr [RDI + 0x38]
MOV qword ptr [RBP + -0x30],0x0
TEST R14,R14
JZ 0x00165dde
MOV EAX,dword ptr [RBX + 0x50]
TEST EAX,EAX
JZ 0x00165e35
CMP dword ptr [RBX + 0x64],0x0
JZ 0x00165c79
CMP byte ptr [RBX + 0xe9],0x0
JZ 0x00165ee7
LAB_00165c79:
CMP EAX,0x3
JNZ 0x00165c97
LEA RAX,[0x162ad4]
MOV qword ptr [RBX + 0x358],RAX
MOV RDI,RBX
CALL 0x00162ad4
MOV EAX,dword ptr [RBX + 0x50]
LAB_00165c97:
AND EAX,0xfffffffe
CMP EAX,0x4
JNZ 0x00165ce7
CMP qword ptr [RBX + 0x80],0x0
JNZ 0x00165ce7
CMP byte ptr [RBX + 0x338],0x0
MOV RAX,qword ptr [RBX + 0x38]
JNZ 0x00165cd6
LAB_00165cb6:
MOV RAX,qword ptr [RAX + 0x4d0]
MOV RDI,RBX
CALL qword ptr [RAX + 0x78]
MOV RAX,qword ptr [RBX + 0x38]
MOVZX ECX,word ptr [RAX + 0x380]
TEST ECX,0x1008
JNZ 0x00165cb6
LAB_00165cd6:
MOV dword ptr [RBX + 0x50],0x1
MOV dword ptr [RAX + 0x488],0x0
LAB_00165ce7:
CMP qword ptr [RBX + 0x80],0x0
JZ 0x00165d12
LEA RDI,[RBX + 0x90]
MOV ESI,0x1
CALL 0x00161f23
XOR EAX,EAX
MOV qword ptr [RBX + 0x80],RAX
MOV qword ptr [RBX + 0xe0],RAX
LAB_00165d12:
MOV qword ptr [RBX + 0xc8],0x0
LEA RSI,[RBP + -0x30]
MOV RDI,RBX
XOR EDX,EDX
CALL 0x00163b2b
TEST RAX,RAX
JZ 0x00165ecf
MOV R12,RAX
MOV RAX,qword ptr [RBX + 0x38]
MOV RAX,qword ptr [RAX + 0x4d0]
CMP dword ptr [RBX + 0x368],0x0
MOV ECX,0x17
MOV ESI,0xfa
CMOVZ ESI,ECX
MOV RCX,qword ptr [RBP + -0x30]
MOV R15D,0x1
MOV RDI,R14
MOV RDX,R12
MOV R8D,0x1
MOV R9,RBX
CALL qword ptr [RAX + 0x10]
MOV R13D,EAX
MOV RDI,R12
CALL 0x0013a210
TEST R13D,R13D
JZ 0x00165f30
MOV RSI,qword ptr [RBX + 0x38]
MOV EAX,dword ptr [RSI + 0x90]
MOV dword ptr [RBX + 0x108],EAX
LEA RDI,[RBX + 0x30d]
ADD RSI,0x297
MOV EDX,0x5
CALL 0x0013a1a0
XOR R14D,R14D
MOV byte ptr [RBX + 0x312],R14B
LEA RDI,[RBX + 0x10c]
MOV ESI,0x97
ADD RSI,qword ptr [RBX + 0x38]
MOV EDX,0x200
CALL 0x0013a1a0
MOV byte ptr [RBX + 0x30b],R14B
JMP 0x00165ed5
LAB_00165dde:
MOV dword ptr [RBX + 0x108],0x7dd
LEA RDI,[RBX + 0x30d]
LEA RAX,[0x46dab0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x0013a1a0
XOR R14D,R14D
MOV byte ptr [RBX + 0x312],R14B
LEA RDI,[RBX + 0x10c]
LEA RAX,[0x46dac0]
MOV RSI,qword ptr [RAX + 0x68]
LAB_00165e1f:
MOV EDX,0x200
CALL 0x0013a1a0
MOV byte ptr [RBX + 0x30b],R14B
JMP 0x00165ecf
LAB_00165e35:
MOV EAX,0x7de
MOV dword ptr [R14 + 0x90],EAX
LEA RDI,[R14 + 0x297]
LEA R13,[0x46dab0]
MOV RSI,qword ptr [R13]
MOV EDX,0x5
CALL 0x0013a1a0
XOR R15D,R15D
MOV byte ptr [R14 + 0x29c],R15B
LEA RDI,[R14 + 0x97]
LEA R12,[0x46dac0]
MOV RSI,qword ptr [R12 + 0x70]
MOV EDX,0x1ff
CALL 0x0013a1a0
MOV byte ptr [R14 + 0x296],R15B
MOV EAX,0x7de
MOV dword ptr [RBX + 0x108],EAX
LEA RDI,[RBX + 0x30d]
MOV RSI,qword ptr [R13]
MOV EDX,0x5
CALL 0x0013a1a0
MOV byte ptr [RBX + 0x312],R15B
LEA RDI,[RBX + 0x10c]
MOV RSI,qword ptr [R12 + 0x70]
MOV EDX,0x200
CALL 0x0013a1a0
MOV byte ptr [RBX + 0x30b],R15B
LAB_00165ecf:
MOV R15D,0x1
LAB_00165ed5:
MOV EAX,R15D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00165ee7:
MOV dword ptr [RBX + 0x108],0x7ef
LEA RDI,[RBX + 0x30d]
LEA RAX,[0x46dab0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x0013a1a0
XOR R14D,R14D
MOV byte ptr [RBX + 0x312],R14B
LEA RDI,[RBX + 0x10c]
LEA RAX,[0x46dac0]
MOV RSI,qword ptr [RAX + 0xf8]
JMP 0x00165e1f
LAB_00165f30:
MOV RAX,qword ptr [R14 + 0x2a0]
XOR R15D,R15D
CMP dword ptr [RAX],0x0
JNZ 0x00165ed5
MOV RAX,qword ptr [R14 + 0x480]
CMP byte ptr [RAX + 0x148],0x0
JNZ 0x00165ed5
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00165637
|
int8 mysql_stmt_execute(long param_1)
{
long lVar1;
uint uVar2;
int iVar3;
long lVar4;
void *__ptr;
int8 uVar5;
char *__src;
int8 local_38;
lVar1 = *(long *)(param_1 + 0x38);
local_38 = 0;
if (lVar1 == 0) {
*(int4 *)(param_1 + 0x108) = 0x7dd;
strncpy((char *)(param_1 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x312) = 0;
__src = PTR_s_Lost_connection_to_server_during_0046db28;
}
else {
uVar2 = *(uint *)(param_1 + 0x50);
if (uVar2 == 0) {
*(int4 *)(lVar1 + 0x90) = 0x7de;
strncpy((char *)(lVar1 + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(lVar1 + 0x29c) = 0;
strncpy((char *)(lVar1 + 0x97),PTR_s_Commands_out_of_sync__you_can_t_r_0046db30,0x1ff);
*(int1 *)(lVar1 + 0x296) = 0;
*(int4 *)(param_1 + 0x108) = 0x7de;
strncpy((char *)(param_1 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x312) = 0;
strncpy((char *)(param_1 + 0x10c),PTR_s_Commands_out_of_sync__you_can_t_r_0046db30,0x200);
*(int1 *)(param_1 + 0x30b) = 0;
return 1;
}
if ((*(int *)(param_1 + 100) == 0) || (*(char *)(param_1 + 0xe9) != '\0')) {
if (uVar2 == 3) {
*(code **)(param_1 + 0x358) = _mysql_stmt_use_result;
_mysql_stmt_use_result(param_1);
uVar2 = *(uint *)(param_1 + 0x50);
}
if (((uVar2 & 0xfffffffe) == 4) && (*(long *)(param_1 + 0x80) == 0)) {
lVar4 = *(long *)(param_1 + 0x38);
if (*(char *)(param_1 + 0x338) == '\0') {
do {
(**(code **)(*(long *)(lVar4 + 0x4d0) + 0x78))(param_1);
lVar4 = *(long *)(param_1 + 0x38);
} while ((*(ushort *)(lVar4 + 0x380) & 0x1008) != 0);
}
*(int4 *)(param_1 + 0x50) = 1;
*(int4 *)(lVar4 + 0x488) = 0;
}
if (*(long *)(param_1 + 0x80) != 0) {
ma_free_root(param_1 + 0x90,1);
*(int8 *)(param_1 + 0x80) = 0;
*(int8 *)(param_1 + 0xe0) = 0;
}
*(int8 *)(param_1 + 200) = 0;
__ptr = (void *)ma_stmt_execute_generate_request(param_1,&local_38,0);
if (__ptr == (void *)0x0) {
return 1;
}
uVar5 = 0xfa;
if (*(int *)(param_1 + 0x368) == 0) {
uVar5 = 0x17;
}
iVar3 = (**(code **)(*(long *)(*(long *)(param_1 + 0x38) + 0x4d0) + 0x10))
(lVar1,uVar5,__ptr,local_38,1,param_1);
free(__ptr);
if (iVar3 != 0) {
*(int4 *)(param_1 + 0x108) = *(int4 *)(*(long *)(param_1 + 0x38) + 0x90);
strncpy((char *)(param_1 + 0x30d),(char *)(*(long *)(param_1 + 0x38) + 0x297),5);
*(int1 *)(param_1 + 0x312) = 0;
strncpy((char *)(param_1 + 0x10c),(char *)(*(long *)(param_1 + 0x38) + 0x97),0x200);
*(int1 *)(param_1 + 0x30b) = 0;
return 1;
}
if (**(int **)(lVar1 + 0x2a0) != 0) {
return 0;
}
if (*(char *)(*(long *)(lVar1 + 0x480) + 0x148) == '\0') {
uVar5 = mthd_stmt_read_execute_response(param_1);
return uVar5;
}
return 0;
}
*(int4 *)(param_1 + 0x108) = 0x7ef;
strncpy((char *)(param_1 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x312) = 0;
__src = PTR_s_No_data_supplied_for_parameters_i_0046dbb8;
}
strncpy((char *)(param_1 + 0x10c),__src,0x200);
*(int1 *)(param_1 + 0x30b) = 0;
return 1;
}
|
|
901 | PlayAutomationEvent | csit-sgu[P]mit-game-2025-team-tyler/Libraries/raylib/src/rcore.c | void PlayAutomationEvent(AutomationEvent event)
{
#if defined(SUPPORT_AUTOMATION_EVENTS)
// WARNING: When should event be played? After/before/replace PollInputEvents()? -> Up to the user!
if (!automationEventRecording) // TODO: Allow recording events while playing?
{
switch (event.type)
{
// Input event
case INPUT_KEY_UP: CORE.Input.Keyboard.currentKeyState[event.params[0]] = false; break; // param[0]: key
case INPUT_KEY_DOWN: { // param[0]: key
CORE.Input.Keyboard.currentKeyState[event.params[0]] = true;
if (CORE.Input.Keyboard.previousKeyState[event.params[0]] == false)
{
if (CORE.Input.Keyboard.keyPressedQueueCount < MAX_KEY_PRESSED_QUEUE)
{
// Add character to the queue
CORE.Input.Keyboard.keyPressedQueue[CORE.Input.Keyboard.keyPressedQueueCount] = event.params[0];
CORE.Input.Keyboard.keyPressedQueueCount++;
}
}
} break;
case INPUT_MOUSE_BUTTON_UP: CORE.Input.Mouse.currentButtonState[event.params[0]] = false; break; // param[0]: key
case INPUT_MOUSE_BUTTON_DOWN: CORE.Input.Mouse.currentButtonState[event.params[0]] = true; break; // param[0]: key
case INPUT_MOUSE_POSITION: // param[0]: x, param[1]: y
{
CORE.Input.Mouse.currentPosition.x = (float)event.params[0];
CORE.Input.Mouse.currentPosition.y = (float)event.params[1];
} break;
case INPUT_MOUSE_WHEEL_MOTION: // param[0]: x delta, param[1]: y delta
{
CORE.Input.Mouse.currentWheelMove.x = (float)event.params[0];
CORE.Input.Mouse.currentWheelMove.y = (float)event.params[1];
} break;
case INPUT_TOUCH_UP: CORE.Input.Touch.currentTouchState[event.params[0]] = false; break; // param[0]: id
case INPUT_TOUCH_DOWN: CORE.Input.Touch.currentTouchState[event.params[0]] = true; break; // param[0]: id
case INPUT_TOUCH_POSITION: // param[0]: id, param[1]: x, param[2]: y
{
CORE.Input.Touch.position[event.params[0]].x = (float)event.params[1];
CORE.Input.Touch.position[event.params[0]].y = (float)event.params[2];
} break;
case INPUT_GAMEPAD_CONNECT: CORE.Input.Gamepad.ready[event.params[0]] = true; break; // param[0]: gamepad
case INPUT_GAMEPAD_DISCONNECT: CORE.Input.Gamepad.ready[event.params[0]] = false; break; // param[0]: gamepad
case INPUT_GAMEPAD_BUTTON_UP: CORE.Input.Gamepad.currentButtonState[event.params[0]][event.params[1]] = false; break; // param[0]: gamepad, param[1]: button
case INPUT_GAMEPAD_BUTTON_DOWN: CORE.Input.Gamepad.currentButtonState[event.params[0]][event.params[1]] = true; break; // param[0]: gamepad, param[1]: button
case INPUT_GAMEPAD_AXIS_MOTION: // param[0]: gamepad, param[1]: axis, param[2]: delta
{
CORE.Input.Gamepad.axisState[event.params[0]][event.params[1]] = ((float)event.params[2]/32768.0f);
} break;
#if defined(SUPPORT_GESTURES_SYSTEM)
case INPUT_GESTURE: GESTURES.current = event.params[0]; break; // param[0]: gesture (enum Gesture) -> rgestures.h: GESTURES.current
#endif
// Window event
case WINDOW_CLOSE: CORE.Window.shouldClose = true; break;
case WINDOW_MAXIMIZE: MaximizeWindow(); break;
case WINDOW_MINIMIZE: MinimizeWindow(); break;
case WINDOW_RESIZE: SetWindowSize(event.params[0], event.params[1]); break;
// Custom event
#if defined(SUPPORT_SCREEN_CAPTURE)
case ACTION_TAKE_SCREENSHOT:
{
TakeScreenshot(TextFormat("screenshot%03i.png", screenshotCounter));
screenshotCounter++;
} break;
#endif
case ACTION_SETTARGETFPS: SetTargetFPS(event.params[0]); break;
default: break;
}
TRACELOG(LOG_INFO, "AUTOMATION PLAY: Frame: %i | Event type: %i | Event parameters: %i, %i, %i", event.frame, event.type, event.params[0], event.params[1], event.params[2]);
}
#endif
} | O3 | c | PlayAutomationEvent:
cmpb $0x0, 0xc539c(%rip) # 0x13c73c
jne 0x7767c
pushq %r14
pushq %rbx
pushq %rax
leaq 0x20(%rsp), %r14
movl 0x4(%r14), %ebx
leal -0x1(%rbx), %eax
cmpl $0x16, %eax
ja 0x7764e
leaq 0x6629e(%rip), %rcx # 0xdd664
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movslq 0x8(%r14), %rax
leaq 0xc47e6(%rip), %rcx # 0x13bbc0
movb $0x0, 0xc4(%rax,%rcx)
jmp 0x7764e
movl 0x8(%r14), %esi
movl 0xc(%r14), %edx
movl %esi, 0xc47f7(%rip) # 0x13bbec
movl %edx, 0xc47f5(%rip) # 0x13bbf0
movq 0xc52a6(%rip), %rdi # 0x13c6a8
callq 0xc1017
jmp 0x7764e
movslq 0x8(%r14), %rax
leaq 0xc47a9(%rip), %rcx # 0x13bbc0
movsd 0xc(%r14), %xmm0
cvtdq2ps %xmm0, %xmm0
movlps %xmm0, 0x7b8(%rcx,%rax,8)
jmp 0x7764e
cvtsi2ssl 0x10(%r14), %xmm0
mulss 0x5c6d9(%rip), %xmm0 # 0xd3b14
movslq 0x8(%r14), %rax
movslq 0xc(%r14), %rcx
shlq $0x5, %rax
leaq 0xc4772(%rip), %rdx # 0x13bbc0
addq %rax, %rdx
movss %xmm0, 0xa20(%rdx,%rcx,4)
jmp 0x7764e
movslq 0x8(%r14), %rax
leaq 0xc4756(%rip), %rcx # 0x13bbc0
movb $0x1, 0x7f8(%rax,%rcx)
jmp 0x7764e
movl 0xc52c3(%rip), %esi # 0x13c740
leaq 0x68bdb(%rip), %rdi # 0xe005f
xorl %eax, %eax
callq 0x84d97
movq %rax, %rdi
callq 0x72e87
incl 0xc52a7(%rip) # 0x13c740
jmp 0x7764e
movslq 0x8(%r14), %rax
leaq 0xc4717(%rip), %rcx # 0x13bbc0
movb $0x0, 0x772(%rax,%rcx)
jmp 0x7764e
movsd 0x8(%r14), %xmm0
cvtdq2ps %xmm0, %xmm0
movlps %xmm0, 0xc4e7e(%rip) # 0x13c344
jmp 0x7764e
movslq 0x8(%r14), %rax
leaq 0xc46ea(%rip), %rcx # 0x13bbc0
movb $0x0, 0x7f8(%rax,%rcx)
jmp 0x7764e
movslq 0x8(%r14), %rax
leaq 0xc46d2(%rip), %rcx # 0x13bbc0
movb $0x1, 0xc4(%rax,%rcx)
cmpb $0x0, 0x2c4(%rax,%rcx)
sete %sil
movl 0xc4dbc(%rip), %edx # 0x13c2c4
cmpl $0x10, %edx
setl %dil
andb %sil, %dil
cmpb $0x1, %dil
jne 0x7764e
movslq %edx, %rdx
movl %eax, 0x6c4(%rcx,%rdx,4)
incl 0xc4d98(%rip) # 0x13c2c4
jmp 0x7764e
movslq 0x8(%r14), %rax
leaq 0xc4684(%rip), %rcx # 0x13bbc0
movb $0x1, 0x81c(%rax,%rcx)
jmp 0x7764e
movslq 0x8(%r14), %rax
leaq 0xc466c(%rip), %rcx # 0x13bbc0
movb $0x0, 0x81c(%rax,%rcx)
jmp 0x7764e
movl 0x8(%r14), %eax
movl %eax, 0xbf265(%rip) # 0x1367d0
jmp 0x7764e
movb $0x1, 0xc4657(%rip) # 0x13bbce
jmp 0x7764e
movslq 0x8(%r14), %rax
leaq 0xc4639(%rip), %rcx # 0x13bbc0
movb $0x1, 0x772(%rax,%rcx)
jmp 0x7764e
movsd 0x8(%r14), %xmm0
cvtdq2ps %xmm0, %xmm0
movlps %xmm0, 0xc4d78(%rip) # 0x13c31c
jmp 0x7764e
movslq 0x8(%r14), %rax
movslq 0xc(%r14), %rcx
shlq $0x5, %rax
leaq 0xc4604(%rip), %rdx # 0x13bbc0
addq %rax, %rdx
movb $0x1, 0x920(%rcx,%rdx)
jmp 0x7764e
movslq 0x8(%r14), %rax
movslq 0xc(%r14), %rcx
shlq $0x5, %rax
leaq 0xc45e1(%rip), %rdx # 0x13bbc0
addq %rax, %rdx
movb $0x0, 0x920(%rcx,%rdx)
jmp 0x7764e
movq 0xc50b5(%rip), %rdi # 0x13c6a8
callq 0xc14e6
jmp 0x7764e
callq 0x6fa25
jmp 0x7764e
movl 0x8(%r14), %eax
xorpd %xmm0, %xmm0
testl %eax, %eax
jle 0x7761d
cvtsi2sd %eax, %xmm1
movsd 0x5c64f(%rip), %xmm0 # 0xd3c68
divsd %xmm1, %xmm0
xorps %xmm1, %xmm1
cvtsd2ss %xmm0, %xmm1
movsd %xmm0, 0xc505c(%rip) # 0x13c688
mulss 0x57a1c(%rip), %xmm1 # 0xcf050
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
leaq 0x68ac0(%rip), %rsi # 0xe0102
movl $0x3, %edi
movb $0x1, %al
callq 0xb9e53
movl (%r14), %edx
movl 0x8(%r14), %r8d
movl 0xc(%r14), %r9d
movl 0x10(%r14), %eax
movl %eax, (%rsp)
leaq 0x68f81(%rip), %rsi # 0xe05e8
movl $0x3, %edi
movl %ebx, %ecx
xorl %eax, %eax
callq 0xb9e53
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| PlayAutomationEvent:
cmp cs:automationEventRecording, 0
jnz locret_7767C
push r14
push rbx
push rax
lea r14, [rsp+18h+arg_0]
mov ebx, [r14+4]
lea eax, [rbx-1]; switch 23 cases
cmp eax, 16h
ja def_773CD; jumptable 00000000000773CD default case, cases 3,4
lea rcx, jpt_773CD
movsxd rax, ds:(jpt_773CD - 0DD664h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_773CF:
movsxd rax, dword ptr [r14+8]; jumptable 00000000000773CD case 1
lea rcx, CORE
mov byte ptr [rax+rcx+0C4h], 0
jmp def_773CD; jumptable 00000000000773CD default case, cases 3,4
loc_773E7:
mov esi, [r14+8]; jumptable 00000000000773CD case 21
mov edx, [r14+0Ch]
mov dword ptr cs:qword_13BBEC, esi
mov dword ptr cs:qword_13BBEC+4, edx
mov rdi, cs:platform_0
call glfwSetWindowSize
jmp def_773CD; jumptable 00000000000773CD default case, cases 3,4
loc_7740C:
movsxd rax, dword ptr [r14+8]; jumptable 00000000000773CD case 16
lea rcx, CORE
movsd xmm0, qword ptr [r14+0Ch]
cvtdq2ps xmm0, xmm0
movlps qword ptr [rcx+rax*8+7B8h], xmm0
jmp def_773CD; jumptable 00000000000773CD default case, cases 3,4
loc_7742D:
cvtsi2ss xmm0, dword ptr [r14+10h]; jumptable 00000000000773CD case 13
mulss xmm0, cs:dword_D3B14
movsxd rax, dword ptr [r14+8]
movsxd rcx, dword ptr [r14+0Ch]
shl rax, 5
lea rdx, CORE
add rdx, rax
movss dword ptr [rdx+rcx*4+0A20h], xmm0
jmp def_773CD; jumptable 00000000000773CD default case, cases 3,4
loc_7745F:
movsxd rax, dword ptr [r14+8]; jumptable 00000000000773CD case 15
lea rcx, CORE
mov byte ptr [rax+rcx+7F8h], 1
jmp def_773CD; jumptable 00000000000773CD default case, cases 3,4
loc_77477:
mov esi, cs:screenshotCounter; jumptable 00000000000773CD case 22
lea rdi, aScreenshot03iP; "screenshot%03i.png"
xor eax, eax
call TextFormat
mov rdi, rax
call TakeScreenshot
inc cs:screenshotCounter
jmp def_773CD; jumptable 00000000000773CD default case, cases 3,4
loc_7749E:
movsxd rax, dword ptr [r14+8]; jumptable 00000000000773CD case 5
lea rcx, CORE
mov byte ptr [rax+rcx+772h], 0
jmp def_773CD; jumptable 00000000000773CD default case, cases 3,4
loc_774B6:
movsd xmm0, qword ptr [r14+8]; jumptable 00000000000773CD case 8
cvtdq2ps xmm0, xmm0
movlps cs:qword_13C344, xmm0
jmp def_773CD; jumptable 00000000000773CD default case, cases 3,4
loc_774CB:
movsxd rax, dword ptr [r14+8]; jumptable 00000000000773CD case 14
lea rcx, CORE
mov byte ptr [rax+rcx+7F8h], 0
jmp def_773CD; jumptable 00000000000773CD default case, cases 3,4
loc_774E3:
movsxd rax, dword ptr [r14+8]; jumptable 00000000000773CD case 2
lea rcx, CORE
mov byte ptr [rax+rcx+0C4h], 1
cmp byte ptr [rax+rcx+2C4h], 0
setz sil
mov edx, cs:dword_13C2C4
cmp edx, 10h
setl dil
and dil, sil
cmp dil, 1
jnz def_773CD; jumptable 00000000000773CD default case, cases 3,4
movsxd rdx, edx
mov [rcx+rdx*4+6C4h], eax
inc cs:dword_13C2C4
jmp def_773CD; jumptable 00000000000773CD default case, cases 3,4
loc_77531:
movsxd rax, dword ptr [r14+8]; jumptable 00000000000773CD case 9
lea rcx, CORE
mov byte ptr [rax+rcx+81Ch], 1
jmp def_773CD; jumptable 00000000000773CD default case, cases 3,4
loc_77549:
movsxd rax, dword ptr [r14+8]; jumptable 00000000000773CD case 10
lea rcx, CORE
mov byte ptr [rax+rcx+81Ch], 0
jmp def_773CD; jumptable 00000000000773CD default case, cases 3,4
loc_77561:
mov eax, [r14+8]; jumptable 00000000000773CD case 17
mov cs:GESTURES, eax
jmp def_773CD; jumptable 00000000000773CD default case, cases 3,4
loc_77570:
mov cs:byte_13BBCE, 1; jumptable 00000000000773CD case 18
jmp def_773CD; jumptable 00000000000773CD default case, cases 3,4
loc_7757C:
movsxd rax, dword ptr [r14+8]; jumptable 00000000000773CD case 6
lea rcx, CORE
mov byte ptr [rax+rcx+772h], 1
jmp def_773CD; jumptable 00000000000773CD default case, cases 3,4
loc_77594:
movsd xmm0, qword ptr [r14+8]; jumptable 00000000000773CD case 7
cvtdq2ps xmm0, xmm0
movlps qword ptr cs:xmmword_13C31C, xmm0
jmp def_773CD; jumptable 00000000000773CD default case, cases 3,4
loc_775A9:
movsxd rax, dword ptr [r14+8]; jumptable 00000000000773CD case 12
movsxd rcx, dword ptr [r14+0Ch]
shl rax, 5
lea rdx, CORE
add rdx, rax
mov byte ptr [rcx+rdx+920h], 1
jmp def_773CD; jumptable 00000000000773CD default case, cases 3,4
loc_775CC:
movsxd rax, dword ptr [r14+8]; jumptable 00000000000773CD case 11
movsxd rcx, dword ptr [r14+0Ch]
shl rax, 5
lea rdx, CORE
add rdx, rax
mov byte ptr [rcx+rdx+920h], 0
jmp short def_773CD; jumptable 00000000000773CD default case, cases 3,4
loc_775EC:
mov rdi, cs:platform_0; jumptable 00000000000773CD case 20
call glfwIconifyWindow
jmp short def_773CD; jumptable 00000000000773CD default case, cases 3,4
loc_775FA:
call MaximizeWindow; jumptable 00000000000773CD case 19
jmp short def_773CD; jumptable 00000000000773CD default case, cases 3,4
loc_77601:
mov eax, [r14+8]; jumptable 00000000000773CD case 23
xorpd xmm0, xmm0
test eax, eax
jle short loc_7761D
cvtsi2sd xmm1, eax
movsd xmm0, cs:qword_D3C68
divsd xmm0, xmm1
loc_7761D:
xorps xmm1, xmm1
cvtsd2ss xmm1, xmm0
movsd cs:qword_13C688, xmm0
mulss xmm1, cs:dword_CF050
xorps xmm0, xmm0
cvtss2sd xmm0, xmm1
lea rsi, aTimerTargetTim; "TIMER: Target time per frame: %02.03f m"...
mov edi, 3
mov al, 1
call TraceLog
def_773CD:
mov edx, [r14]; jumptable 00000000000773CD default case, cases 3,4
mov r8d, [r14+8]
mov r9d, [r14+0Ch]
mov eax, [r14+10h]
mov [rsp+18h+var_18], eax
lea rsi, aAutomationPlay; "AUTOMATION PLAY: Frame: %i | Event type"...
mov edi, 3
mov ecx, ebx
xor eax, eax
call TraceLog
add rsp, 8
pop rbx
pop r14
locret_7767C:
retn
| long long PlayAutomationEvent(long long a1, long long a2, int a3, int a4, int a5, int a6, long long a7, __int128 a8)
{
long long v8; // rax
double v9; // xmm0_8
long long result; // rax
if ( !automationEventRecording )
{
switch ( HIDWORD(a7) )
{
case 1:
*((_BYTE *)&CORE[24] + (int)a8 + 4) = 0;
break;
case 2:
*((_BYTE *)&CORE[24] + (int)a8 + 4) = 1;
if ( *((_BYTE *)&CORE[88] + (int)a8 + 4) == 0 && dword_13C2C4 < 16 )
*((_DWORD *)&CORE[216] + ++dword_13C2C4) = a8;
break;
case 5:
*((_BYTE *)&CORE[238] + (int)a8 + 2) = 0;
break;
case 6:
*((_BYTE *)&CORE[238] + (int)a8 + 2) = 1;
break;
case 7:
_mm_storel_ps((double *)&xmmword_13C31C, _mm_cvtepi32_ps((__m128i)(unsigned long long)a8));
break;
case 8:
_mm_storel_ps((double *)&qword_13C344, _mm_cvtepi32_ps((__m128i)(unsigned long long)a8));
break;
case 9:
*((_BYTE *)&CORE[259] + (int)a8 + 4) = 1;
break;
case 0xA:
*((_BYTE *)&CORE[259] + (int)a8 + 4) = 0;
break;
case 0xB:
*((_BYTE *)&CORE[4 * (int)a8 + 292] + SDWORD1(a8)) = 0;
break;
case 0xC:
*((_BYTE *)&CORE[4 * (int)a8 + 292] + SDWORD1(a8)) = 1;
break;
case 0xD:
*((float *)&CORE[4 * (int)a8 + 324] + SDWORD1(a8)) = (float)SDWORD2(a8) * 0.000030517578;
break;
case 0xE:
*((_BYTE *)&CORE[255] + (int)a8) = 0;
break;
case 0xF:
*((_BYTE *)&CORE[255] + (int)a8) = 1;
break;
case 0x10:
_mm_storel_ps((double *)&CORE[(int)a8 + 247], _mm_cvtepi32_ps((__m128i)*(unsigned long long *)((char *)&a8 + 4)));
break;
case 0x11:
GESTURES = a8;
break;
case 0x12:
byte_13BBCE = 1;
break;
case 0x13:
MaximizeWindow();
break;
case 0x14:
glfwIconifyWindow(platform_0);
break;
case 0x15:
qword_13BBEC = a8;
glfwSetWindowSize(platform_0, (unsigned int)a8, DWORD1(a8));
break;
case 0x16:
v8 = TextFormat((unsigned int)"screenshot%03i.png", screenshotCounter, a3, a4, a5, a6);
TakeScreenshot(v8);
++screenshotCounter;
break;
case 0x17:
v9 = 0.0;
if ( (int)a8 > 0 )
v9 = 1.0 / (double)(int)a8;
qword_13C688 = *(_QWORD *)&v9;
TraceLog(3, (unsigned int)"TIMER: Target time per frame: %02.03f milliseconds", a3, a4, a5, a6);
break;
default:
return TraceLog(
3,
(unsigned int)"AUTOMATION PLAY: Frame: %i | Event type: %i | Event parameters: %i, %i, %i",
a7,
HIDWORD(a7),
a8,
DWORD1(a8));
}
return TraceLog(
3,
(unsigned int)"AUTOMATION PLAY: Frame: %i | Event type: %i | Event parameters: %i, %i, %i",
a7,
HIDWORD(a7),
a8,
DWORD1(a8));
}
return result;
}
| PlayAutomationEvent:
CMP byte ptr [0x0023c73c],0x0
JNZ 0x0017767c
PUSH R14
PUSH RBX
PUSH RAX
LEA R14,[RSP + 0x20]
MOV EBX,dword ptr [R14 + 0x4]
LEA EAX,[RBX + -0x1]
CMP EAX,0x16
JA 0x0017764e
LEA RCX,[0x1dd664]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
MOVSXD RAX,dword ptr [R14 + 0x8]
LEA RCX,[0x23bbc0]
MOV byte ptr [RAX + RCX*0x1 + 0xc4],0x0
JMP 0x0017764e
caseD_15:
MOV ESI,dword ptr [R14 + 0x8]
MOV EDX,dword ptr [R14 + 0xc]
MOV dword ptr [0x0023bbec],ESI
MOV dword ptr [0x0023bbf0],EDX
MOV RDI,qword ptr [0x0023c6a8]
CALL 0x001c1017
JMP 0x0017764e
caseD_10:
MOVSXD RAX,dword ptr [R14 + 0x8]
LEA RCX,[0x23bbc0]
MOVSD XMM0,qword ptr [R14 + 0xc]
CVTDQ2PS XMM0,XMM0
MOVLPS qword ptr [RCX + RAX*0x8 + 0x7b8],XMM0
JMP 0x0017764e
caseD_d:
CVTSI2SS XMM0,dword ptr [R14 + 0x10]
MULSS XMM0,dword ptr [0x001d3b14]
MOVSXD RAX,dword ptr [R14 + 0x8]
MOVSXD RCX,dword ptr [R14 + 0xc]
SHL RAX,0x5
LEA RDX,[0x23bbc0]
ADD RDX,RAX
MOVSS dword ptr [RDX + RCX*0x4 + 0xa20],XMM0
JMP 0x0017764e
caseD_f:
MOVSXD RAX,dword ptr [R14 + 0x8]
LEA RCX,[0x23bbc0]
MOV byte ptr [RAX + RCX*0x1 + 0x7f8],0x1
JMP 0x0017764e
caseD_16:
MOV ESI,dword ptr [0x0023c740]
LEA RDI,[0x1e005f]
XOR EAX,EAX
CALL 0x00184d97
MOV RDI,RAX
CALL 0x00172e87
INC dword ptr [0x0023c740]
JMP 0x0017764e
caseD_5:
MOVSXD RAX,dword ptr [R14 + 0x8]
LEA RCX,[0x23bbc0]
MOV byte ptr [RAX + RCX*0x1 + 0x772],0x0
JMP 0x0017764e
caseD_8:
MOVSD XMM0,qword ptr [R14 + 0x8]
CVTDQ2PS XMM0,XMM0
MOVLPS qword ptr [0x0023c344],XMM0
JMP 0x0017764e
caseD_e:
MOVSXD RAX,dword ptr [R14 + 0x8]
LEA RCX,[0x23bbc0]
MOV byte ptr [RAX + RCX*0x1 + 0x7f8],0x0
JMP 0x0017764e
caseD_2:
MOVSXD RAX,dword ptr [R14 + 0x8]
LEA RCX,[0x23bbc0]
MOV byte ptr [RAX + RCX*0x1 + 0xc4],0x1
CMP byte ptr [RAX + RCX*0x1 + 0x2c4],0x0
SETZ SIL
MOV EDX,dword ptr [0x0023c2c4]
CMP EDX,0x10
SETL DIL
AND DIL,SIL
CMP DIL,0x1
JNZ 0x0017764e
MOVSXD RDX,EDX
MOV dword ptr [RCX + RDX*0x4 + 0x6c4],EAX
INC dword ptr [0x0023c2c4]
JMP 0x0017764e
caseD_9:
MOVSXD RAX,dword ptr [R14 + 0x8]
LEA RCX,[0x23bbc0]
MOV byte ptr [RAX + RCX*0x1 + 0x81c],0x1
JMP 0x0017764e
caseD_a:
MOVSXD RAX,dword ptr [R14 + 0x8]
LEA RCX,[0x23bbc0]
MOV byte ptr [RAX + RCX*0x1 + 0x81c],0x0
JMP 0x0017764e
caseD_11:
MOV EAX,dword ptr [R14 + 0x8]
MOV dword ptr [0x002367d0],EAX
JMP 0x0017764e
caseD_12:
MOV byte ptr [0x0023bbce],0x1
JMP 0x0017764e
caseD_6:
MOVSXD RAX,dword ptr [R14 + 0x8]
LEA RCX,[0x23bbc0]
MOV byte ptr [RAX + RCX*0x1 + 0x772],0x1
JMP 0x0017764e
caseD_7:
MOVSD XMM0,qword ptr [R14 + 0x8]
CVTDQ2PS XMM0,XMM0
MOVLPS qword ptr [0x0023c31c],XMM0
JMP 0x0017764e
caseD_c:
MOVSXD RAX,dword ptr [R14 + 0x8]
MOVSXD RCX,dword ptr [R14 + 0xc]
SHL RAX,0x5
LEA RDX,[0x23bbc0]
ADD RDX,RAX
MOV byte ptr [RCX + RDX*0x1 + 0x920],0x1
JMP 0x0017764e
caseD_b:
MOVSXD RAX,dword ptr [R14 + 0x8]
MOVSXD RCX,dword ptr [R14 + 0xc]
SHL RAX,0x5
LEA RDX,[0x23bbc0]
ADD RDX,RAX
MOV byte ptr [RCX + RDX*0x1 + 0x920],0x0
JMP 0x0017764e
caseD_14:
MOV RDI,qword ptr [0x0023c6a8]
CALL 0x001c14e6
JMP 0x0017764e
caseD_13:
CALL 0x0016fa25
JMP 0x0017764e
caseD_17:
MOV EAX,dword ptr [R14 + 0x8]
XORPD XMM0,XMM0
TEST EAX,EAX
JLE 0x0017761d
CVTSI2SD XMM1,EAX
MOVSD XMM0,qword ptr [0x001d3c68]
DIVSD XMM0,XMM1
LAB_0017761d:
XORPS XMM1,XMM1
CVTSD2SS XMM1,XMM0
MOVSD qword ptr [0x0023c688],XMM0
MULSS XMM1,dword ptr [0x001cf050]
XORPS XMM0,XMM0
CVTSS2SD XMM0,XMM1
LEA RSI,[0x1e0102]
MOV EDI,0x3
MOV AL,0x1
CALL 0x001b9e53
caseD_3:
MOV EDX,dword ptr [R14]
MOV R8D,dword ptr [R14 + 0x8]
MOV R9D,dword ptr [R14 + 0xc]
MOV EAX,dword ptr [R14 + 0x10]
MOV dword ptr [RSP],EAX
LEA RSI,[0x1e05e8]
MOV EDI,0x3
MOV ECX,EBX
XOR EAX,EAX
CALL 0x001b9e53
ADD RSP,0x8
POP RBX
POP R14
LAB_0017767c:
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void PlayAutomationEvent(void)
{
int8 in_RAX;
int8 uVar1;
int4 uStack0000000000000008;
int4 uStack000000000000000c;
int iStack0000000000000010;
int iStack0000000000000014;
int in_stack_00000018;
int4 uVar2;
uVar2 = (int4)((ulong)in_RAX >> 0x20);
if (automationEventRecording == '\0') {
switch(uStack000000000000000c) {
case 1:
(&DAT_0023bc84)[iStack0000000000000010] = 0;
break;
case 2:
(&DAT_0023bc84)[iStack0000000000000010] = 1;
if (_DAT_0023c2c4 < 0x10 && (&DAT_0023be84)[iStack0000000000000010] == '\0') {
*(int *)(&DAT_0023c284 + (long)_DAT_0023c2c4 * 4) = iStack0000000000000010;
_DAT_0023c2c4 = _DAT_0023c2c4 + 1;
}
break;
case 5:
(&DAT_0023c332)[iStack0000000000000010] = 0;
break;
case 6:
(&DAT_0023c332)[iStack0000000000000010] = 1;
break;
case 7:
DAT_0023c31c = CONCAT44((float)iStack0000000000000014,(float)iStack0000000000000010);
break;
case 8:
DAT_0023c344 = CONCAT44((float)iStack0000000000000014,(float)iStack0000000000000010);
break;
case 9:
(&DAT_0023c3dc)[iStack0000000000000010] = 1;
break;
case 10:
(&DAT_0023c3dc)[iStack0000000000000010] = 0;
break;
case 0xb:
(&DAT_0023c4e0)[(long)iStack0000000000000014 + (long)iStack0000000000000010 * 0x20] = 0;
break;
case 0xc:
(&DAT_0023c4e0)[(long)iStack0000000000000014 + (long)iStack0000000000000010 * 0x20] = 1;
break;
case 0xd:
(&DAT_0023c5e0)[(long)iStack0000000000000010 * 8 + (long)iStack0000000000000014] =
(float)in_stack_00000018 * DAT_001d3b14;
break;
case 0xe:
(&DAT_0023c3b8)[iStack0000000000000010] = 0;
break;
case 0xf:
(&DAT_0023c3b8)[iStack0000000000000010] = 1;
break;
case 0x10:
*(ulong *)(&DAT_0023c378 + (long)iStack0000000000000010 * 8) =
CONCAT44((float)in_stack_00000018,(float)iStack0000000000000014);
break;
case 0x11:
GESTURES = iStack0000000000000010;
break;
case 0x12:
DAT_0023bbce = 1;
break;
case 0x13:
MaximizeWindow();
break;
case 0x14:
glfwIconifyWindow(platform_0);
break;
case 0x15:
DAT_0023bbec = iStack0000000000000010;
DAT_0023bbf0 = iStack0000000000000014;
glfwSetWindowSize(platform_0);
break;
case 0x16:
uVar1 = TextFormat("screenshot%03i.png",screenshotCounter);
TakeScreenshot(uVar1);
screenshotCounter = screenshotCounter + 1;
break;
case 0x17:
DAT_0023c688 = 0.0;
if (0 < iStack0000000000000010) {
DAT_0023c688 = DAT_001d3c68 / (double)iStack0000000000000010;
}
TraceLog((double)((float)DAT_0023c688 * _DAT_001cf050),3,
"TIMER: Target time per frame: %02.03f milliseconds");
}
TraceLog(3,"AUTOMATION PLAY: Frame: %i | Event type: %i | Event parameters: %i, %i, %i",
uStack0000000000000008,uStack000000000000000c,iStack0000000000000010,
iStack0000000000000014,CONCAT44(uVar2,in_stack_00000018));
}
return;
}
|
|
902 | google::protobuf::DescriptorBuilder::BuildService(google::protobuf::ServiceDescriptorProto const&, void const*, google::protobuf::ServiceDescriptor*, google::protobuf::internal::FlatAllocator&) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.cc | void DescriptorBuilder::BuildService(const ServiceDescriptorProto& proto,
const void* /* dummy */,
ServiceDescriptor* result,
internal::FlatAllocator& alloc) {
result->all_names_ =
AllocateNameStrings(file_->package(), proto.name(), alloc);
result->file_ = file_;
ValidateSymbolName(proto.name(), result->full_name(), proto);
BUILD_ARRAY(proto, result, method, BuildMethod, result);
// Copy options.
result->options_ = nullptr; // Set to default_instance later if necessary.
if (proto.has_options()) {
AllocateOptions(proto.options(), result,
ServiceDescriptorProto::kOptionsFieldNumber,
"google.protobuf.ServiceOptions", alloc);
}
AddSymbol(result->full_name(), nullptr, result->name(), proto,
Symbol(result));
} | O0 | cpp | google::protobuf::DescriptorBuilder::BuildService(google::protobuf::ServiceDescriptorProto const&, void const*, google::protobuf::ServiceDescriptor*, google::protobuf::internal::FlatAllocator&):
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movq %rcx, 0xa8(%rsp)
movq %r8, 0xa0(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x58(%rax), %rdi
callq 0x2835a0
movq %rax, 0x38(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x286810
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdi
movq %rax, %rdx
movq 0xa0(%rsp), %rcx
callq 0x25f8a0
movq %rax, %rdx
movq 0x40(%rsp), %rax
movq 0xa8(%rsp), %rcx
movq %rdx, 0x8(%rcx)
movq 0x58(%rax), %rcx
movq 0xa8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0xb8(%rsp), %rdi
callq 0x286810
movq %rax, 0x48(%rsp)
movq 0xa8(%rsp), %rdi
callq 0x286820
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq %rax, %rdx
movq 0xb8(%rsp), %rcx
callq 0x255200
movq 0xb8(%rsp), %rdi
callq 0x286840
movl %eax, %ecx
movq 0xa8(%rsp), %rax
movl %ecx, 0x28(%rax)
movq 0xa0(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x286840
movq 0x50(%rsp), %rdi
movl %eax, %esi
callq 0x263fa0
movq %rax, %rcx
movq 0xa8(%rsp), %rax
movq %rcx, 0x20(%rax)
movl $0x0, 0x9c(%rsp)
movl 0x9c(%rsp), %eax
movl %eax, 0x34(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x286840
movl %eax, %ecx
movl 0x34(%rsp), %eax
cmpl %ecx, %eax
jge 0x25ca3c
movq 0xb8(%rsp), %rdi
movl 0x9c(%rsp), %esi
callq 0x286850
movq 0x40(%rsp), %rdi
movq %rax, %rsi
movq 0xa8(%rsp), %rdx
movq 0xa8(%rsp), %rax
movq 0x20(%rax), %rcx
movslq 0x9c(%rsp), %rax
shlq $0x6, %rax
addq %rax, %rcx
movq 0xa0(%rsp), %r8
callq 0x2641c0
movl 0x9c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x9c(%rsp)
jmp 0x25c9b8
movq 0xa8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0xb8(%rsp), %rdi
callq 0x286870
testb $0x1, %al
jne 0x25ca62
jmp 0x25cb1a
movq 0xb8(%rsp), %rdi
callq 0x286980
movq %rax, 0x18(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x77(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x94520
movq 0x28(%rsp), %rdx
leaq 0x190924(%rip), %rsi # 0x3ed3c0
leaq 0x78(%rsp), %rdi
callq 0x92ea0
jmp 0x25caa8
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rsi
movq 0x40(%rsp), %rdi
movq 0xa0(%rsp), %r9
movl $0x3, %ecx
leaq 0x78(%rsp), %r8
callq 0x286890
jmp 0x25cad0
leaq 0x78(%rsp), %rdi
callq 0x921e0
leaq 0x77(%rsp), %rdi
callq 0x96fa0
jmp 0x25cb1a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x25cb0e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x921e0
leaq 0x77(%rsp), %rdi
callq 0x96fa0
jmp 0x25cb85
movq 0xa8(%rsp), %rdi
callq 0x286820
movq %rax, (%rsp)
movq 0xa8(%rsp), %rdi
callq 0x283f10
movq %rax, 0x8(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xa8(%rsp), %rsi
leaq 0x58(%rsp), %rdi
callq 0x286990
movq 0x40(%rsp), %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %r8
movq 0x58(%rsp), %r9
xorl %eax, %eax
movl %eax, %edx
callq 0x254270
addq $0xc8, %rsp
retq
movq 0x68(%rsp), %rdi
callq 0x90db0
nop
| _ZN6google8protobuf17DescriptorBuilder12BuildServiceERKNS0_22ServiceDescriptorProtoEPKvPNS0_17ServiceDescriptorERNS0_8internal13FlatAllocatorE:
sub rsp, 0C8h
mov [rsp+0C8h+var_8], rdi
mov [rsp+0C8h+var_10], rsi
mov [rsp+0C8h+var_18], rdx
mov [rsp+0C8h+var_20], rcx
mov [rsp+0C8h+var_28], r8
mov rax, [rsp+0C8h+var_8]
mov [rsp+0C8h+var_88], rax
mov rdi, [rax+58h]
call _ZNK6google8protobuf14FileDescriptor7packageB5cxx11Ev; google::protobuf::FileDescriptor::package(void)
mov [rsp+0C8h+var_90], rax
mov rdi, [rsp+0C8h+var_10]
call _ZNK6google8protobuf22ServiceDescriptorProto4nameB5cxx11Ev; google::protobuf::ServiceDescriptorProto::name(void)
mov rsi, [rsp+0C8h+var_90]
mov rdi, [rsp+0C8h+var_88]
mov rdx, rax
mov rcx, [rsp+0C8h+var_28]
call _ZN6google8protobuf17DescriptorBuilder19AllocateNameStringsERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES9_RNS0_8internal13FlatAllocatorE; google::protobuf::DescriptorBuilder::AllocateNameStrings(std::string const&,std::string const&,google::protobuf::internal::FlatAllocator &)
mov rdx, rax
mov rax, [rsp+0C8h+var_88]
mov rcx, [rsp+0C8h+var_20]
mov [rcx+8], rdx
mov rcx, [rax+58h]
mov rax, [rsp+0C8h+var_20]
mov [rax+10h], rcx
mov rdi, [rsp+0C8h+var_10]
call _ZNK6google8protobuf22ServiceDescriptorProto4nameB5cxx11Ev; google::protobuf::ServiceDescriptorProto::name(void)
mov [rsp+0C8h+var_80], rax
mov rdi, [rsp+0C8h+var_20]
call _ZNK6google8protobuf17ServiceDescriptor9full_nameB5cxx11Ev; google::protobuf::ServiceDescriptor::full_name(void)
mov rdi, [rsp+0C8h+var_88]
mov rsi, [rsp+0C8h+var_80]
mov rdx, rax
mov rcx, [rsp+0C8h+var_10]
call _ZN6google8protobuf17DescriptorBuilder18ValidateSymbolNameERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES9_RKNS0_7MessageE; google::protobuf::DescriptorBuilder::ValidateSymbolName(std::string const&,std::string const&,google::protobuf::Message const&)
mov rdi, [rsp+0C8h+var_10]; this
call _ZNK6google8protobuf22ServiceDescriptorProto11method_sizeEv; google::protobuf::ServiceDescriptorProto::method_size(void)
mov ecx, eax
mov rax, [rsp+0C8h+var_20]
mov [rax+28h], ecx
mov rax, [rsp+0C8h+var_28]
mov [rsp+0C8h+var_78], rax
mov rdi, [rsp+0C8h+var_10]; this
call _ZNK6google8protobuf22ServiceDescriptorProto11method_sizeEv; google::protobuf::ServiceDescriptorProto::method_size(void)
mov rdi, [rsp+0C8h+var_78]
mov esi, eax
call _ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE13AllocateArrayINS0_16MethodDescriptorEEEPT_i; google::protobuf::`anonymous namespace'::FlatAllocatorImpl<char,std::string,google::protobuf::SourceCodeInfo,google::protobuf::FileDescriptorTables,google::protobuf::MessageOptions,google::protobuf::FieldOptions,google::protobuf::EnumOptions,google::protobuf::EnumValueOptions,google::protobuf::ExtensionRangeOptions,google::protobuf::OneofOptions,google::protobuf::ServiceOptions,google::protobuf::MethodOptions,google::protobuf::FileOptions>::AllocateArray<google::protobuf::MethodDescriptor>(int)
mov rcx, rax
mov rax, [rsp+0C8h+var_20]
mov [rax+20h], rcx
mov [rsp+0C8h+var_2C], 0
loc_25C9B8:
mov eax, [rsp+0C8h+var_2C]
mov [rsp+0C8h+var_94], eax
mov rdi, [rsp+0C8h+var_10]; this
call _ZNK6google8protobuf22ServiceDescriptorProto11method_sizeEv; google::protobuf::ServiceDescriptorProto::method_size(void)
mov ecx, eax
mov eax, [rsp+0C8h+var_94]
cmp eax, ecx
jge short loc_25CA3C
mov rdi, [rsp+0C8h+var_10]; this
mov esi, [rsp+0C8h+var_2C]; int
call _ZNK6google8protobuf22ServiceDescriptorProto6methodEi; google::protobuf::ServiceDescriptorProto::method(int)
mov rdi, [rsp+0C8h+var_88]; this
mov rsi, rax; google::protobuf::MethodDescriptorProto *
mov rdx, [rsp+0C8h+var_20]; google::protobuf::ServiceDescriptor *
mov rax, [rsp+0C8h+var_20]
mov rcx, [rax+20h]
movsxd rax, [rsp+0C8h+var_2C]
shl rax, 6
add rcx, rax; google::protobuf::MethodDescriptor *
mov r8, [rsp+0C8h+var_28]; google::protobuf::internal::FlatAllocator *
call _ZN6google8protobuf17DescriptorBuilder11BuildMethodERKNS0_21MethodDescriptorProtoEPKNS0_17ServiceDescriptorEPNS0_16MethodDescriptorERNS0_8internal13FlatAllocatorE; google::protobuf::DescriptorBuilder::BuildMethod(google::protobuf::MethodDescriptorProto const&,google::protobuf::ServiceDescriptor const*,google::protobuf::MethodDescriptor *,google::protobuf::internal::FlatAllocator &)
mov eax, [rsp+0C8h+var_2C]
add eax, 1
mov [rsp+0C8h+var_2C], eax
jmp loc_25C9B8
loc_25CA3C:
mov rax, [rsp+0C8h+var_20]
mov qword ptr [rax+18h], 0
mov rdi, [rsp+0C8h+var_10]; this
call _ZNK6google8protobuf22ServiceDescriptorProto11has_optionsEv; google::protobuf::ServiceDescriptorProto::has_options(void)
test al, 1
jnz short loc_25CA62
jmp loc_25CB1A
loc_25CA62:
mov rdi, [rsp+0C8h+var_10]; this
call _ZNK6google8protobuf22ServiceDescriptorProto7optionsEv; google::protobuf::ServiceDescriptorProto::options(void)
mov [rsp+0C8h+var_B0], rax
mov rax, [rsp+0C8h+var_20]
mov [rsp+0C8h+var_A8], rax
lea rdi, [rsp+0C8h+var_51]
mov [rsp+0C8h+var_A0], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdx, [rsp+0C8h+var_A0]
lea rsi, aGoogleProtobuf_20; "google.protobuf.ServiceOptions"
lea rdi, [rsp+0C8h+var_50]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1EPKcRKS3_; std::string::basic_string(char const*,std::allocator<char> const&)
jmp short $+2
loc_25CAA8:
mov rdx, [rsp+0C8h+var_A8]
mov rsi, [rsp+0C8h+var_B0]
mov rdi, [rsp+0C8h+var_88]
mov r9, [rsp+0C8h+var_28]
mov ecx, 3
lea r8, [rsp+0C8h+var_50]
call _ZN6google8protobuf17DescriptorBuilder15AllocateOptionsINS0_17ServiceDescriptorEEEvRKNT_11OptionsTypeEPS4_iRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERNS0_8internal13FlatAllocatorE; google::protobuf::DescriptorBuilder::AllocateOptions<google::protobuf::ServiceDescriptor>(google::protobuf::ServiceDescriptor::OptionsType const&,google::protobuf::ServiceDescriptor::OptionsType*,int,std::string const&,google::protobuf::internal::FlatAllocator &)
jmp short $+2
loc_25CAD0:
lea rdi, [rsp+0C8h+var_50]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+0C8h+var_51]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp short loc_25CB1A
mov rcx, rax
mov eax, edx
mov [rsp+arg_60], rcx
mov [rsp+arg_5C], eax
jmp short loc_25CB0E
mov rcx, rax
mov eax, edx
mov [rsp+arg_60], rcx
mov [rsp+arg_5C], eax
lea rdi, [rsp+arg_70]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_25CB0E:
lea rdi, [rsp+arg_6F]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp short loc_25CB85
loc_25CB1A:
mov rdi, [rsp+0C8h+var_20]
call _ZNK6google8protobuf17ServiceDescriptor9full_nameB5cxx11Ev; google::protobuf::ServiceDescriptor::full_name(void)
mov [rsp+0C8h+var_C8], rax
mov rdi, [rsp+0C8h+var_20]
call _ZNK6google8protobuf17ServiceDescriptor4nameB5cxx11Ev; google::protobuf::ServiceDescriptor::name(void)
mov [rsp+0C8h+var_C0], rax
mov rax, [rsp+0C8h+var_10]
mov [rsp+0C8h+var_B8], rax
mov rsi, [rsp+0C8h+var_20]; google::protobuf::ServiceDescriptor *
lea rdi, [rsp+0C8h+var_70]; this
call _ZN6google8protobuf6SymbolC2EPNS0_17ServiceDescriptorE; google::protobuf::Symbol::Symbol(google::protobuf::ServiceDescriptor *)
mov rdi, [rsp+0C8h+var_88]
mov rsi, [rsp+0C8h+var_C8]
mov rcx, [rsp+0C8h+var_C0]
mov r8, [rsp+0C8h+var_B8]
mov r9, [rsp+0C8h+var_70]
xor eax, eax
mov edx, eax
call _ZN6google8protobuf17DescriptorBuilder9AddSymbolERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPKvS9_RKNS0_7MessageENS0_6SymbolE; google::protobuf::DescriptorBuilder::AddSymbol(std::string const&,void const*,std::string const&,google::protobuf::Message const&,google::protobuf::Symbol)
add rsp, 0C8h
retn
loc_25CB85:
mov rdi, [rsp+arg_60]
call __Unwind_Resume
| char google::protobuf::DescriptorBuilder::BuildService(
google::protobuf::DescriptorBuilder *this,
const google::protobuf::ServiceDescriptorProto *a2,
const void *a3,
google::protobuf::ServiceDescriptor *a4,
google::protobuf::internal::FlatAllocator *a5)
{
int v5; // eax
int v6; // r8d
int v7; // r9d
long long v8; // rax
unsigned int v9; // eax
unsigned long long v10; // rsi
int v11; // edx
int v12; // ecx
int v13; // r8d
int v14; // r9d
void *v16; // [rsp+0h] [rbp-C8h]
long long v17; // [rsp+8h] [rbp-C0h]
google::protobuf::ServiceDescriptorProto *v18; // [rsp+10h] [rbp-B8h]
int v19; // [rsp+18h] [rbp-B0h]
int v20; // [rsp+20h] [rbp-A8h]
int v21; // [rsp+38h] [rbp-90h]
long long v22; // [rsp+48h] [rbp-80h]
long long v23[3]; // [rsp+58h] [rbp-70h] BYREF
char v24; // [rsp+77h] [rbp-51h] BYREF
_BYTE v25[36]; // [rsp+78h] [rbp-50h] BYREF
int i; // [rsp+9Ch] [rbp-2Ch]
google::protobuf::internal::FlatAllocator *v27; // [rsp+A0h] [rbp-28h]
google::protobuf::ServiceDescriptor *v28; // [rsp+A8h] [rbp-20h]
const void *v29; // [rsp+B0h] [rbp-18h]
google::protobuf::ServiceDescriptorProto *v30; // [rsp+B8h] [rbp-10h]
google::protobuf::DescriptorBuilder *v31; // [rsp+C0h] [rbp-8h]
v31 = this;
v30 = a2;
v29 = a3;
v28 = a4;
v27 = a5;
v21 = google::protobuf::FileDescriptor::package[abi:cxx11](*((_QWORD *)this + 11));
v5 = google::protobuf::ServiceDescriptorProto::name[abi:cxx11](a2);
*((_QWORD *)v28 + 1) = google::protobuf::DescriptorBuilder::AllocateNameStrings(
(_DWORD)this,
v21,
v5,
(_DWORD)v27,
v6,
v7);
*((_QWORD *)v28 + 2) = *((_QWORD *)this + 11);
v22 = google::protobuf::ServiceDescriptorProto::name[abi:cxx11](v30);
v8 = google::protobuf::ServiceDescriptor::full_name[abi:cxx11](v28);
google::protobuf::DescriptorBuilder::ValidateSymbolName((long long)this, v22, v8, v30);
*((_DWORD *)v28 + 10) = google::protobuf::ServiceDescriptorProto::method_size(v30);
v9 = google::protobuf::ServiceDescriptorProto::method_size(v30);
v10 = v9;
*((_QWORD *)v28 + 4) = google::protobuf::`anonymous namespace'::FlatAllocatorImpl<char,std::string,google::protobuf::SourceCodeInfo,google::protobuf::FileDescriptorTables,google::protobuf::MessageOptions,google::protobuf::FieldOptions,google::protobuf::EnumOptions,google::protobuf::EnumValueOptions,google::protobuf::ExtensionRangeOptions,google::protobuf::OneofOptions,google::protobuf::ServiceOptions,google::protobuf::MethodOptions,google::protobuf::FileOptions>::AllocateArray<google::protobuf::MethodDescriptor>(
(_DWORD)v27,
v9,
v11,
v12,
v13,
v14);
for ( i = 0; i < (int)google::protobuf::ServiceDescriptorProto::method_size(v30); ++i )
{
v10 = google::protobuf::ServiceDescriptorProto::method(v30, i);
google::protobuf::DescriptorBuilder::BuildMethod(
this,
(const google::protobuf::MethodDescriptorProto *)v10,
v28,
(google::protobuf::MethodDescriptor *)(((long long)i << 6) + *((_QWORD *)v28 + 4)),
v27);
}
*((_QWORD *)v28 + 3) = 0LL;
if ( (google::protobuf::ServiceDescriptorProto::has_options(v30) & 1) != 0 )
{
v19 = google::protobuf::ServiceDescriptorProto::options(v30);
v20 = (int)v28;
std::allocator<char>::allocator(&v24, v10);
std::string::basic_string(v25, "google.protobuf.ServiceOptions", &v24);
google::protobuf::DescriptorBuilder::AllocateOptions<google::protobuf::ServiceDescriptor>(
(_DWORD)this,
v19,
v20,
3,
(unsigned int)v25,
(_DWORD)v27);
std::string::~string(v25);
std::allocator<char>::~allocator(&v24);
}
v16 = (void *)google::protobuf::ServiceDescriptor::full_name[abi:cxx11](v28);
v17 = google::protobuf::ServiceDescriptor::name[abi:cxx11](v28);
v18 = v30;
google::protobuf::Symbol::Symbol((google::protobuf::Symbol *)v23, v28);
return google::protobuf::DescriptorBuilder::AddSymbol((long long)this, v16, 0LL, v17, (long long)v18, v23[0]);
}
| GetClassData:
MOV qword ptr [RSP + -0x8],RDI
LEA RAX,[0x5fb410]
RET
|
/* aimrt::protocols::sensor::TouchSensorStateArray::GetClassData() const */
int1 * aimrt::protocols::sensor::TouchSensorStateArray::GetClassData(void)
{
return _class_data_;
}
|
|
903 | POINTonE2_times_minus_z | corpus-core[P]colibri-stateless/build_O0/_deps/blst-src/src/map_to_g2.c | static void POINTonE2_times_minus_z(POINTonE2 *out, const POINTonE2 *in)
{
POINTonE2_double(out, in); /* 1: 0x2 */
POINTonE2_add_n_dbl(out, in, 2); /* 2..4: 0x3..0xc */
POINTonE2_add_n_dbl(out, in, 3); /* 5..8: 0xd..0x68 */
POINTonE2_add_n_dbl(out, in, 9); /* 9..18: 0x69..0xd200 */
POINTonE2_add_n_dbl(out, in, 32); /* 19..51: ..0xd20100000000 */
POINTonE2_add_n_dbl(out, in, 16); /* 52..68: ..0xd201000000010000 */
} | O0 | c | POINTonE2_times_minus_z:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x280b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x2, %edx
callq 0x380b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x3, %edx
callq 0x380b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x9, %edx
callq 0x380b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x20, %edx
callq 0x380b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x10, %edx
callq 0x380b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| POINTonE2_times_minus_z:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
call POINTonE2_double
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov edx, 2
call POINTonE2_add_n_dbl
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov edx, 3
call POINTonE2_add_n_dbl
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov edx, 9
call POINTonE2_add_n_dbl
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov edx, 20h ; ' '
call POINTonE2_add_n_dbl
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov edx, 10h
call POINTonE2_add_n_dbl
add rsp, 10h
pop rbp
retn
| long long POINTonE2_times_minus_z(long long a1, long long a2)
{
POINTonE2_double(a1, a2);
POINTonE2_add_n_dbl(a1, a2, 2LL);
POINTonE2_add_n_dbl(a1, a2, 3LL);
POINTonE2_add_n_dbl(a1, a2, 9LL);
POINTonE2_add_n_dbl(a1, a2, 32LL);
return POINTonE2_add_n_dbl(a1, a2, 16LL);
}
| POINTonE2_times_minus_z:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x001280b0
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,0x2
CALL 0x001380b0
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,0x3
CALL 0x001380b0
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,0x9
CALL 0x001380b0
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,0x20
CALL 0x001380b0
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,0x10
CALL 0x001380b0
ADD RSP,0x10
POP RBP
RET
|
void POINTonE2_times_minus_z(int8 param_1,int8 param_2)
{
POINTonE2_double(param_1,param_2);
POINTonE2_add_n_dbl(param_1,param_2,2);
POINTonE2_add_n_dbl(param_1,param_2,3);
POINTonE2_add_n_dbl(param_1,param_2,9);
POINTonE2_add_n_dbl(param_1,param_2,0x20);
POINTonE2_add_n_dbl(param_1,param_2,0x10);
return;
}
|
|
904 | json_schema_to_grammar(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, bool) | monkey531[P]llama/common/json-schema-to-grammar.cpp | std::string json_schema_to_grammar(const json & schema, bool force_gbnf) {
#ifdef LLAMA_USE_LLGUIDANCE
if (!force_gbnf) {
return "%llguidance {}\nstart: %json " + schema.dump();
}
#else
(void)force_gbnf;
#endif // LLAMA_USE_LLGUIDANCE
return build_grammar([&](const common_grammar_builder & callbacks) {
auto copy = schema;
callbacks.resolve_refs(copy);
callbacks.add_schema("", copy);
});
} | O3 | cpp | json_schema_to_grammar(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, bool):
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
movq $0x0, 0x8(%rax)
movq %rsi, (%rax)
leaq 0x267(%rip), %rcx # 0xbb5be
movq %rcx, 0x18(%rax)
leaq 0x356(%rip), %rcx # 0xbb6b8
movq %rcx, 0x10(%rax)
leaq 0xe(%rsp), %rdx
movw $0x0, (%rdx)
movq %rax, %rsi
callq 0xbb3c8
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0xbb391
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq
jmp 0xbb3c0
movq %rax, %rbx
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0xbb3b8
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x1afb0
movq %rax, %rdi
callq 0x21a05
| _Z22json_schema_to_grammarRKN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEb:
push rbx
sub rsp, 30h
mov rbx, rdi
lea rax, [rsp+38h+var_28]
mov qword ptr [rax+8], 0
mov [rax], rsi
lea rcx, _ZNSt17_Function_handlerIFvRK22common_grammar_builderEZ22json_schema_to_grammarRKN8nlohmann16json_abi_v3_11_310basic_jsonINS5_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS5_14adl_serializerES8_IhSaIhEEvEEbE3$_0E9_M_invokeERKSt9_Any_dataS2_; std::_Function_handler<void ()(common_grammar_builder const&),json_schema_to_grammar(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,bool)::$_0>::_M_invoke(std::_Any_data const&,common_grammar_builder const&)
mov [rax+18h], rcx
lea rcx, _ZNSt17_Function_handlerIFvRK22common_grammar_builderEZ22json_schema_to_grammarRKN8nlohmann16json_abi_v3_11_310basic_jsonINS5_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS5_14adl_serializerES8_IhSaIhEEvEEbE3$_0E10_M_managerERSt9_Any_dataRKSN_St18_Manager_operation; std::_Function_handler<void ()(common_grammar_builder const&),json_schema_to_grammar(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,bool)::$_0>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov [rax+10h], rcx
lea rdx, [rsp+38h+var_2A]
mov word ptr [rdx], 0
mov rsi, rax
call _Z13build_grammarB5cxx11RKSt8functionIFvRK22common_grammar_builderEERK22common_grammar_options; build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)
mov rax, [rsp+38h+var_18]
test rax, rax
jz short loc_BB391
lea rdi, [rsp+38h+var_28]
mov rsi, rdi
mov edx, 3
call rax
loc_BB391:
mov rax, rbx
add rsp, 30h
pop rbx
retn
jmp short loc_BB3C0
mov rbx, rax
mov rax, [rsp+38h+var_18]
test rax, rax
jz short loc_BB3B8
lea rdi, [rsp+38h+var_28]
mov rsi, rdi
mov edx, 3
call rax
loc_BB3B8:
mov rdi, rbx
call __Unwind_Resume
loc_BB3C0:
mov rdi, rax
call __clang_call_terminate
| long long json_schema_to_grammar(long long a1, long long a2)
{
__int16 v3; // [rsp+Eh] [rbp-2Ah] BYREF
_QWORD v4[2]; // [rsp+10h] [rbp-28h] BYREF
long long ( *v5)(); // [rsp+20h] [rbp-18h]
long long ( *v6)(); // [rsp+28h] [rbp-10h]
v4[1] = 0LL;
v4[0] = a2;
v6 = std::_Function_handler<void ()(common_grammar_builder const&),json_schema_to_grammar(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const&,bool)::$_0>::_M_invoke;
v5 = std::_Function_handler<void ()(common_grammar_builder const&),json_schema_to_grammar(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const&,bool)::$_0>::_M_manager;
v3 = 0;
build_grammar[abi:cxx11](a1, v4, &v3);
if ( v5 )
((void ( *)(_QWORD *, _QWORD *, long long))v5)(v4, v4, 3LL);
return a1;
}
| json_schema_to_grammar:
PUSH RBX
SUB RSP,0x30
MOV RBX,RDI
LEA RAX,[RSP + 0x10]
MOV qword ptr [RAX + 0x8],0x0
MOV qword ptr [RAX],RSI
LEA RCX,[0x1bb5be]
MOV qword ptr [RAX + 0x18],RCX
LEA RCX,[0x1bb6b8]
MOV qword ptr [RAX + 0x10],RCX
LEA RDX,[RSP + 0xe]
MOV word ptr [RDX],0x0
LAB_001bb370:
MOV RSI,RAX
CALL 0x001bb3c8
MOV RAX,qword ptr [RSP + 0x20]
TEST RAX,RAX
JZ 0x001bb391
LAB_001bb382:
LEA RDI,[RSP + 0x10]
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_001bb391:
MOV RAX,RBX
ADD RSP,0x30
POP RBX
RET
|
/* json_schema_to_grammar(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const&, bool) */
basic_json * json_schema_to_grammar(basic_json *param_1,bool param_2)
{
int7 in_register_00000031;
int8 local_28;
int8 local_20;
code *local_18;
code *local_10;
local_28 = CONCAT71(in_register_00000031,param_2);
local_20 = 0;
local_10 = std::
_Function_handler<void(common_grammar_builder_const&),json_schema_to_grammar(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const&,bool)::$_0>
::_M_invoke;
local_18 = std::
_Function_handler<void(common_grammar_builder_const&),json_schema_to_grammar(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const&,bool)::$_0>
::_M_manager;
/* try { // try from 001bb370 to 001bb377 has its CatchHandler @ 001bb39c */
build_grammar_abi_cxx11_(param_1,(common_grammar_options *)&local_28);
if (local_18 != (code *)0x0) {
/* try { // try from 001bb382 to 001bb390 has its CatchHandler @ 001bb39a */
(*local_18)(&local_28,&local_28,3);
}
return param_1;
}
|
|
905 | testing::internal::TypeParameterizedTestSuiteRegistry::RegisterInstantiation(char const*) | AlayaLite/build_O0/_deps/googletest-src/googletest/src/gtest.cc | void TypeParameterizedTestSuiteRegistry::RegisterInstantiation(
const char* test_suite_name) {
auto it = suites_.find(std::string(test_suite_name));
if (it != suites_.end()) {
it->second.instantiated = true;
} else {
GTEST_LOG_(ERROR) << "Unknown type parameterized test suit '"
<< test_suite_name << "'";
}
} | O0 | cpp | testing::internal::TypeParameterizedTestSuiteRegistry::RegisterInstantiation(char const*):
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x28(%rsp)
movq %rax, 0x30(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x6f(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x14c90
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
leaq 0x70(%rsp), %rdi
callq 0x1a6a0
jmp 0xbd5ab
movq 0x28(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0xe4fd0
movq %rax, 0x20(%rsp)
jmp 0xbd5c1
movq 0x20(%rsp), %rax
movq %rax, 0x90(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x1aac0
leaq 0x6f(%rsp), %rdi
callq 0x14750
movq 0x30(%rsp), %rdi
callq 0xe5020
movq %rax, 0x50(%rsp)
leaq 0x90(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xe5000
xorb $-0x1, %al
testb $0x1, %al
jne 0xbd60b
jmp 0xbd658
leaq 0x90(%rsp), %rdi
callq 0xe5050
movb $0x1, 0x48(%rax)
jmp 0xbd6f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0xbd649
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x1aac0
leaq 0x6f(%rsp), %rdi
callq 0x14750
jmp 0xbd6f9
leaq 0x55847(%rip), %rdx # 0x112ea6
leaq 0x4c(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0x2, %esi
movl $0x259, %ecx # imm = 0x259
callq 0xb9070
movq 0x10(%rsp), %rdi
callq 0x1ea10
movq %rax, 0x18(%rsp)
jmp 0xbd689
movq 0x18(%rsp), %rdi
leaq 0x55999(%rip), %rsi # 0x11302e
callq 0x146a0
movq %rax, 0x8(%rsp)
jmp 0xbd6a1
movq 0x8(%rsp), %rdi
movq 0x98(%rsp), %rsi
callq 0x146a0
movq %rax, (%rsp)
jmp 0xbd6b9
movq (%rsp), %rdi
leaq 0x4ff4b(%rip), %rsi # 0x10d60f
callq 0x146a0
jmp 0xbd6cb
leaq 0x4c(%rsp), %rdi
callq 0xb91e0
jmp 0xbd6f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x4c(%rsp), %rdi
callq 0xb91e0
jmp 0xbd6f9
addq $0xa8, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x14c80
nopw %cs:(%rax,%rax)
| _ZN7testing8internal34TypeParameterizedTestSuiteRegistry21RegisterInstantiationEPKc:
sub rsp, 0A8h
mov qword ptr [rsp+0A8h+var_8], rdi
mov qword ptr [rsp+0A8h+var_10], rsi
mov rax, qword ptr [rsp+0A8h+var_8]
mov qword ptr [rsp+0A8h+var_80], rax; int
mov qword ptr [rsp+0A8h+var_78], rax; int
mov rax, qword ptr [rsp+0A8h+var_10]
mov qword ptr [rsp+0A8h+var_70], rax; int
lea rdi, [rsp+0A8h+var_39]
mov [rsp+0A8h+var_68], rdi; __int64
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rsi, qword ptr [rsp+0A8h+var_70]
mov rdx, [rsp+0A8h+var_68]
lea rdi, [rsp+0A8h+var_39+1]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_BD5AB:
mov rdi, qword ptr [rsp+0A8h+var_80]
lea rsi, [rsp+0A8h+var_39+1]
call _ZNSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN7testing8internal34TypeParameterizedTestSuiteRegistry30TypeParameterizedTestSuiteInfoESt4lessIS5_ESaISt4pairIKS5_S9_EEE4findERSD_; std::map<std::string,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo>::find(std::string const&)
mov qword ptr [rsp+0A8h+var_88], rax; int
jmp short $+2
loc_BD5C1:
mov rax, qword ptr [rsp+0A8h+var_88]
mov [rsp+0A8h+var_18], rax
lea rdi, [rsp+0A8h+var_39+1]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+0A8h+var_39]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
mov rdi, qword ptr [rsp+0A8h+var_78]
call _ZNSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN7testing8internal34TypeParameterizedTestSuiteRegistry30TypeParameterizedTestSuiteInfoESt4lessIS5_ESaISt4pairIKS5_S9_EEE3endEv; std::map<std::string,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo>::end(void)
mov [rsp+0A8h+var_58], rax
lea rdi, [rsp+0A8h+var_18]
lea rsi, [rsp+0A8h+var_58]
call _ZSteqRKSt17_Rb_tree_iteratorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN7testing8internal34TypeParameterizedTestSuiteRegistry30TypeParameterizedTestSuiteInfoEEESF_; std::operator==(std::_Rb_tree_iterator<std::pair<std::string const,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo>> const&,std::_Rb_tree_iterator<std::pair<std::string const,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo>> const&)
xor al, 0FFh
test al, 1
jnz short loc_BD60B
jmp short loc_BD658
loc_BD60B:
lea rdi, [rsp+0A8h+var_18]
call _ZNKSt17_Rb_tree_iteratorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN7testing8internal34TypeParameterizedTestSuiteRegistry30TypeParameterizedTestSuiteInfoEEEptEv; std::_Rb_tree_iterator<std::pair<std::string const,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo>>::operator->(void)
mov byte ptr [rax+48h], 1
jmp loc_BD6F1
mov rcx, rax
mov eax, edx
mov [rsp+arg_58], rcx
mov [rsp+arg_54], eax
jmp short loc_BD649
mov rcx, rax
mov eax, edx
mov [rsp+arg_58], rcx
mov [rsp+arg_54], eax
lea rdi, [rsp+arg_68]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_BD649:
lea rdi, [rsp+arg_67]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp loc_BD6F9
loc_BD658:
lea rdx, aWorkspaceLlm4b_9; "/workspace/llm4binary/github2025/AlayaL"...
lea rdi, [rsp+0A8h+var_5C]; int
mov [rsp+0A8h+var_98], rdi; int
mov esi, 2
mov ecx, 259h
call _ZN7testing8internal8GTestLogC2ENS0_16GTestLogSeverityEPKci; testing::internal::GTestLog::GTestLog(testing::internal::GTestLogSeverity,char const*,int)
mov rdi, [rsp+0A8h+var_98]; this
call _ZN7testing8internal8GTestLog9GetStreamEv; testing::internal::GTestLog::GetStream(void)
mov [rsp+0A8h+var_90], rax
jmp short $+2
loc_BD689:
mov rdi, [rsp+0A8h+var_90]
lea rsi, aUnknownTypePar; "Unknown type parameterized test suit '"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rsp+0A8h+var_A0], rax
jmp short $+2
loc_BD6A1:
mov rdi, [rsp+0A8h+var_A0]
mov rsi, qword ptr [rsp+0A8h+var_10]
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rsp+0A8h+var_A8], rax
jmp short $+2
loc_BD6B9:
mov rdi, [rsp+0A8h+var_A8]
lea rsi, aLoggerWithName+11h; "'"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
jmp short $+2
loc_BD6CB:
lea rdi, [rsp+0A8h+var_5C]; this
call _ZN7testing8internal8GTestLogD2Ev; testing::internal::GTestLog::~GTestLog()
jmp short loc_BD6F1
mov rcx, rax
mov eax, edx
mov [rsp+arg_58], rcx
mov [rsp+arg_54], eax
lea rdi, [rsp+arg_44]; this
call _ZN7testing8internal8GTestLogD2Ev; testing::internal::GTestLog::~GTestLog()
jmp short loc_BD6F9
loc_BD6F1:
add rsp, 0A8h
retn
loc_BD6F9:
mov rdi, [rsp+arg_58]
call __Unwind_Resume
| void testing::internal::TypeParameterizedTestSuiteRegistry::RegisterInstantiation(
testing::internal::TypeParameterizedTestSuiteRegistry *this,
const char *a2)
{
long long v2; // [rsp+0h] [rbp-A8h]
long long v3; // [rsp+8h] [rbp-A0h]
void *Stream; // [rsp+18h] [rbp-90h]
int v5; // [rsp+4Ch] [rbp-5Ch] BYREF
long long v6[3]; // [rsp+50h] [rbp-58h] BYREF
char v7; // [rsp+6Fh] [rbp-39h] BYREF
char v8[32]; // [rsp+70h] [rbp-38h] BYREF
long long v9; // [rsp+90h] [rbp-18h] BYREF
int v10[2]; // [rsp+98h] [rbp-10h]
int v11[2]; // [rsp+A0h] [rbp-8h]
*(_QWORD *)v11 = this;
*(_QWORD *)v10 = a2;
std::allocator<char>::allocator();
std::string::basic_string<std::allocator<char>>((long long)v8, (long long)a2, (long long)&v7);
v9 = std::map<std::string,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo>::find(
this,
v8);
std::string::~string(v8);
std::allocator<char>::~allocator(&v7, v8);
v6[0] = std::map<std::string,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo>::end(this);
if ( (std::operator==(&v9, v6) & 1) != 0 )
{
testing::internal::GTestLog::GTestLog(
(testing::internal::GTestLog *)&v5,
2,
(long long)"/workspace/llm4binary/github2025/AlayaLite/build_O0/_deps/googletest-src/googletest/src/gtest.cc",
601);
Stream = testing::internal::GTestLog::GetStream((testing::internal::GTestLog *)&v5);
v3 = std::operator<<<std::char_traits<char>>(Stream, "Unknown type parameterized test suit '");
v2 = std::operator<<<std::char_traits<char>>(v3, *(_QWORD *)v10);
std::operator<<<std::char_traits<char>>(v2, "'");
testing::internal::GTestLog::~GTestLog((testing::internal::GTestLog *)&v5);
}
else
{
*(_BYTE *)(std::_Rb_tree_iterator<std::pair<std::string const,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo>>::operator->(&v9)
+ 72) = 1;
}
}
| RegisterInstantiation:
SUB RSP,0xa8
MOV qword ptr [RSP + 0xa0],RDI
MOV qword ptr [RSP + 0x98],RSI
MOV RAX,qword ptr [RSP + 0xa0]
MOV qword ptr [RSP + 0x28],RAX
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RSP + 0x98]
MOV qword ptr [RSP + 0x38],RAX
LEA RDI,[RSP + 0x6f]
MOV qword ptr [RSP + 0x40],RDI
CALL 0x00114c90
MOV RSI,qword ptr [RSP + 0x38]
MOV RDX,qword ptr [RSP + 0x40]
LAB_001bd59f:
LEA RDI,[RSP + 0x70]
CALL 0x0011a6a0
JMP 0x001bd5ab
LAB_001bd5ab:
MOV RDI,qword ptr [RSP + 0x28]
LEA RSI,[RSP + 0x70]
CALL 0x001e4fd0
LAB_001bd5ba:
MOV qword ptr [RSP + 0x20],RAX
JMP 0x001bd5c1
LAB_001bd5c1:
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x90],RAX
LEA RDI,[RSP + 0x70]
CALL 0x0011aac0
LEA RDI,[RSP + 0x6f]
CALL 0x00114750
MOV RDI,qword ptr [RSP + 0x30]
CALL 0x001e5020
MOV qword ptr [RSP + 0x50],RAX
LEA RDI,[RSP + 0x90]
LEA RSI,[RSP + 0x50]
CALL 0x001e5000
XOR AL,0xff
TEST AL,0x1
JNZ 0x001bd60b
JMP 0x001bd658
LAB_001bd60b:
LEA RDI,[RSP + 0x90]
CALL 0x001e5050
MOV byte ptr [RAX + 0x48],0x1
JMP 0x001bd6f1
LAB_001bd658:
LEA RDX,[0x212ea6]
LEA RDI,[RSP + 0x4c]
MOV qword ptr [RSP + 0x10],RDI
MOV ESI,0x2
MOV ECX,0x259
CALL 0x001b9070
MOV RDI,qword ptr [RSP + 0x10]
LAB_001bd67d:
CALL 0x0011ea10
MOV qword ptr [RSP + 0x18],RAX
JMP 0x001bd689
LAB_001bd689:
MOV RDI,qword ptr [RSP + 0x18]
LEA RSI,[0x21302e]
CALL 0x001146a0
MOV qword ptr [RSP + 0x8],RAX
JMP 0x001bd6a1
LAB_001bd6a1:
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x98]
CALL 0x001146a0
MOV qword ptr [RSP],RAX
JMP 0x001bd6b9
LAB_001bd6b9:
MOV RDI,qword ptr [RSP]
LEA RSI,[0x20d60f]
CALL 0x001146a0
LAB_001bd6c9:
JMP 0x001bd6cb
LAB_001bd6cb:
LEA RDI,[RSP + 0x4c]
CALL 0x001b91e0
JMP 0x001bd6f1
LAB_001bd6f1:
ADD RSP,0xa8
RET
|
/* testing::internal::TypeParameterizedTestSuiteRegistry::RegisterInstantiation(char const*) */
void __thiscall
testing::internal::TypeParameterizedTestSuiteRegistry::RegisterInstantiation
(TypeParameterizedTestSuiteRegistry *this,char *param_1)
{
byte bVar1;
long lVar2;
ostream *poVar3;
GTestLog local_5c [4];
int8 local_58 [3];
allocator local_39;
string local_38 [32];
int8 local_18;
char *local_10;
TypeParameterizedTestSuiteRegistry *local_8;
local_10 = param_1;
local_8 = this;
std::allocator<char>::allocator();
/* try { // try from 001bd59f to 001bd5a8 has its CatchHandler @ 001bd621 */
std::__cxx11::string::string<std::allocator<char>>(local_38,param_1,&local_39);
/* try { // try from 001bd5ab to 001bd5b9 has its CatchHandler @ 001bd631 */
local_18 = std::
map<std::__cxx11::string,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo>>>
::find((map<std::__cxx11::string,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo>>>
*)this,local_38);
std::__cxx11::string::~string(local_38);
std::allocator<char>::~allocator((allocator<char> *)&local_39);
local_58[0] = std::
map<std::__cxx11::string,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo>>>
::end((map<std::__cxx11::string,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo>>>
*)this);
bVar1 = std::operator==((_Rb_tree_iterator *)&local_18,(_Rb_tree_iterator *)local_58);
if (((bVar1 ^ 0xff) & 1) == 0) {
GTestLog::GTestLog(local_5c,2,
"/workspace/llm4binary/github2025/AlayaLite/build_O0/_deps/googletest-src/googletest/src/gtest.cc"
,0x259);
/* try { // try from 001bd67d to 001bd6c8 has its CatchHandler @ 001bd6d7 */
poVar3 = (ostream *)GTestLog::GetStream();
poVar3 = std::operator<<(poVar3,"Unknown type parameterized test suit \'");
poVar3 = std::operator<<(poVar3,local_10);
std::operator<<(poVar3,"\'");
GTestLog::~GTestLog(local_5c);
}
else {
lVar2 = std::
_Rb_tree_iterator<std::pair<std::__cxx11::string_const,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo>>
::operator->((_Rb_tree_iterator<std::pair<std::__cxx11::string_const,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo>>
*)&local_18);
*(int1 *)(lVar2 + 0x48) = 1;
}
return;
}
|
|
906 | my_strtod | eloqsql/strings/dtoa.c | double my_strtod(const char *str, char **end, int *error)
{
char buf[DTOA_BUFF_SIZE];
double res;
DBUG_ASSERT(end != NULL && ((str != NULL && *end != NULL) ||
(str == NULL && *end == NULL)) &&
error != NULL);
res= my_strtod_int(str, end, error, buf, sizeof(buf));
return (*error == 0) ? res : (res < 0 ? -DBL_MAX : DBL_MAX);
} | O0 | c | my_strtod:
pushq %rbp
movq %rsp, %rbp
subq $0xea0, %rsp # imm = 0xEA0
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0xe78(%rbp)
movq %rsi, -0xe80(%rbp)
movq %rdx, -0xe88(%rbp)
jmp 0x70c0f
movq -0xe78(%rbp), %rdi
movq -0xe80(%rbp), %rsi
movq -0xe88(%rbp), %rdx
leaq -0xe70(%rbp), %rcx
movl $0xe60, %r8d # imm = 0xE60
callq 0x70cd0
movsd %xmm0, -0xe90(%rbp)
movq -0xe88(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x70c5c
movsd -0xe90(%rbp), %xmm0
movsd %xmm0, -0xe98(%rbp)
jmp 0x70c93
movsd -0xe90(%rbp), %xmm0
movsd 0x842c(%rip), %xmm3 # 0x79098
movsd 0x842c(%rip), %xmm2 # 0x790a0
xorps %xmm1, %xmm1
cmpltsd %xmm1, %xmm0
movaps %xmm0, %xmm1
andpd %xmm3, %xmm1
andnpd %xmm2, %xmm0
orpd %xmm1, %xmm0
movsd %xmm0, -0xe98(%rbp)
movsd -0xe98(%rbp), %xmm0
movsd %xmm0, -0xea0(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x70cc6
movsd -0xea0(%rbp), %xmm0
addq $0xea0, %rsp # imm = 0xEA0
popq %rbp
retq
callq 0x24320
nopl (%rax,%rax)
| my_strtod:
push rbp
mov rbp, rsp
sub rsp, 0EA0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_E78], rdi
mov [rbp+var_E80], rsi
mov [rbp+var_E88], rdx
jmp short $+2
loc_70C0F:
mov rdi, [rbp+var_E78]
mov rsi, [rbp+var_E80]
mov rdx, [rbp+var_E88]
lea rcx, [rbp+var_E70]
mov r8d, 0E60h
call my_strtod_int
movsd [rbp+var_E90], xmm0
mov rax, [rbp+var_E88]
cmp dword ptr [rax], 0
jnz short loc_70C5C
movsd xmm0, [rbp+var_E90]
movsd [rbp+var_E98], xmm0
jmp short loc_70C93
loc_70C5C:
movsd xmm0, [rbp+var_E90]
movsd xmm3, cs:qword_79098
movsd xmm2, cs:qword_790A0
xorps xmm1, xmm1
cmpltsd xmm0, xmm1
movaps xmm1, xmm0
andpd xmm1, xmm3
andnpd xmm0, xmm2
orpd xmm0, xmm1
movsd [rbp+var_E98], xmm0
loc_70C93:
movsd xmm0, [rbp+var_E98]
movsd [rbp+var_EA0], xmm0
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_70CC6
movsd xmm0, [rbp+var_EA0]
add rsp, 0EA0h
pop rbp
retn
loc_70CC6:
call ___stack_chk_fail
| double my_strtod(long long a1, long long a2, _DWORD *a3)
{
__m128d v3; // xmm1
double v4; // xmm0_8
double v6; // [rsp+8h] [rbp-E98h]
double v7; // [rsp+10h] [rbp-E90h]
_BYTE v9[3688]; // [rsp+30h] [rbp-E70h] BYREF
unsigned long long v10; // [rsp+E98h] [rbp-8h]
v10 = __readfsqword(0x28u);
v7 = my_strtod_int(a1, a2, a3, v9, 3680LL);
if ( !*a3 )
return v7;
v3.m128d_f64[0] = 0.0;
v4 = _mm_cmplt_sd((__m128d)*(unsigned long long *)&v7, v3).m128d_f64[0];
*(_QWORD *)&v6 = ~*(_QWORD *)&v4 & 0x7FEFFFFFFFFFFFFFLL | *(_QWORD *)&v4 & 0xFFEFFFFFFFFFFFFFLL;
return v6;
}
| my_strtod:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xea0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0xe78],RDI
MOV qword ptr [RBP + -0xe80],RSI
MOV qword ptr [RBP + -0xe88],RDX
JMP 0x00170c0f
LAB_00170c0f:
MOV RDI,qword ptr [RBP + -0xe78]
MOV RSI,qword ptr [RBP + -0xe80]
MOV RDX,qword ptr [RBP + -0xe88]
LEA RCX,[RBP + -0xe70]
MOV R8D,0xe60
CALL 0x00170cd0
MOVSD qword ptr [RBP + -0xe90],XMM0
MOV RAX,qword ptr [RBP + -0xe88]
CMP dword ptr [RAX],0x0
JNZ 0x00170c5c
MOVSD XMM0,qword ptr [RBP + -0xe90]
MOVSD qword ptr [RBP + -0xe98],XMM0
JMP 0x00170c93
LAB_00170c5c:
MOVSD XMM0,qword ptr [RBP + -0xe90]
MOVSD XMM3,qword ptr [0x00179098]
MOVSD XMM2,qword ptr [0x001790a0]
XORPS XMM1,XMM1
CMPLTSD XMM0,XMM1
MOVAPS XMM1,XMM0
ANDPD XMM1,XMM3
ANDNPD XMM0,XMM2
ORPD XMM0,XMM1
MOVSD qword ptr [RBP + -0xe98],XMM0
LAB_00170c93:
MOVSD XMM0,qword ptr [RBP + -0xe98]
MOVSD qword ptr [RBP + -0xea0],XMM0
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00170cc6
MOVSD XMM0,qword ptr [RBP + -0xea0]
ADD RSP,0xea0
POP RBP
RET
LAB_00170cc6:
CALL 0x00124320
|
double my_strtod(int8 param_1,int8 param_2,int *param_3)
{
long in_FS_OFFSET;
double local_ea0;
int1 local_e78 [3688];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_ea0 = (double)my_strtod_int(param_1,param_2,param_3,local_e78,0xe60);
if (*param_3 != 0) {
local_ea0 = (double)(~-(ulong)(local_ea0 < 0.0) & DAT_001790a0 |
-(ulong)(local_ea0 < 0.0) & DAT_00179098);
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_ea0;
}
|
|
907 | func_uni_gbk_onechar | eloqsql/strings/ctype-gbk.c | static int func_uni_gbk_onechar(int code){
if ((code>=0x00A4)&&(code<=0x0451))
return(tab_uni_gbk0[code-0x00A4]);
if ((code>=0x2010)&&(code<=0x2312))
return(tab_uni_gbk1[code-0x2010]);
if ((code>=0x2460)&&(code<=0x2642))
return(tab_uni_gbk2[code-0x2460]);
if ((code>=0x3000)&&(code<=0x3129))
return(tab_uni_gbk3[code-0x3000]);
if ((code>=0x3220)&&(code<=0x32A3))
return(tab_uni_gbk4[code-0x3220]);
if ((code>=0x338E)&&(code<=0x33D5))
return(tab_uni_gbk5[code-0x338E]);
if ((code>=0x4E00)&&(code<=0x9FA5))
return(tab_uni_gbk6[code-0x4E00]);
if ((code>=0xF92C)&&(code<=0xFA29))
return(tab_uni_gbk7[code-0xF92C]);
if ((code>=0xFE30)&&(code<=0xFFE5))
return(tab_uni_gbk8[code-0xFE30]);
return(0);
} | O0 | c | func_uni_gbk_onechar:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0xa4, -0x8(%rbp)
jl 0x4e557
cmpl $0x451, -0x8(%rbp) # imm = 0x451
jg 0x4e557
movl -0x8(%rbp), %eax
subl $0xa4, %eax
movslq %eax, %rcx
leaq 0xec575(%rip), %rax # 0x13aac0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x4e6d5
cmpl $0x2010, -0x8(%rbp) # imm = 0x2010
jl 0x4e587
cmpl $0x2312, -0x8(%rbp) # imm = 0x2312
jg 0x4e587
movl -0x8(%rbp), %eax
subl $0x2010, %eax # imm = 0x2010
movslq %eax, %rcx
leaq 0xecca5(%rip), %rax # 0x13b220
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x4e6d5
cmpl $0x2460, -0x8(%rbp) # imm = 0x2460
jl 0x4e5b7
cmpl $0x2642, -0x8(%rbp) # imm = 0x2642
jg 0x4e5b7
movl -0x8(%rbp), %eax
subl $0x2460, %eax # imm = 0x2460
movslq %eax, %rcx
leaq 0xed285(%rip), %rax # 0x13b830
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x4e6d5
cmpl $0x3000, -0x8(%rbp) # imm = 0x3000
jl 0x4e5e7
cmpl $0x3129, -0x8(%rbp) # imm = 0x3129
jg 0x4e5e7
movl -0x8(%rbp), %eax
subl $0x3000, %eax # imm = 0x3000
movslq %eax, %rcx
leaq 0xed625(%rip), %rax # 0x13bc00
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x4e6d5
cmpl $0x3220, -0x8(%rbp) # imm = 0x3220
jl 0x4e617
cmpl $0x32a3, -0x8(%rbp) # imm = 0x32A3
jg 0x4e617
movl -0x8(%rbp), %eax
subl $0x3220, %eax # imm = 0x3220
movslq %eax, %rcx
leaq 0xed855(%rip), %rax # 0x13be60
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x4e6d5
cmpl $0x338e, -0x8(%rbp) # imm = 0x338E
jl 0x4e647
cmpl $0x33d5, -0x8(%rbp) # imm = 0x33D5
jg 0x4e647
movl -0x8(%rbp), %eax
subl $0x338e, %eax # imm = 0x338E
movslq %eax, %rcx
leaq 0xed935(%rip), %rax # 0x13bf70
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x4e6d5
cmpl $0x4e00, -0x8(%rbp) # imm = 0x4E00
jl 0x4e674
cmpl $0x9fa5, -0x8(%rbp) # imm = 0x9FA5
jg 0x4e674
movl -0x8(%rbp), %eax
subl $0x4e00, %eax # imm = 0x4E00
movslq %eax, %rcx
leaq 0xed995(%rip), %rax # 0x13c000
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x4e6d5
cmpl $0xf92c, -0x8(%rbp) # imm = 0xF92C
jl 0x4e6a1
cmpl $0xfa29, -0x8(%rbp) # imm = 0xFA29
jg 0x4e6a1
movl -0x8(%rbp), %eax
subl $0xf92c, %eax # imm = 0xF92C
movslq %eax, %rcx
leaq 0xf7cb8(%rip), %rax # 0x146350
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x4e6d5
cmpl $0xfe30, -0x8(%rbp) # imm = 0xFE30
jl 0x4e6ce
cmpl $0xffe5, -0x8(%rbp) # imm = 0xFFE5
jg 0x4e6ce
movl -0x8(%rbp), %eax
subl $0xfe30, %eax # imm = 0xFE30
movslq %eax, %rcx
leaq 0xf7e8b(%rip), %rax # 0x146550
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x4e6d5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
| func_uni_gbk_onechar:
push rbp
mov rbp, rsp
mov [rbp+var_8], edi
cmp [rbp+var_8], 0A4h
jl short loc_4E557
cmp [rbp+var_8], 451h
jg short loc_4E557
mov eax, [rbp+var_8]
sub eax, 0A4h
movsxd rcx, eax
lea rax, tab_uni_gbk0
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_4E6D5
loc_4E557:
cmp [rbp+var_8], 2010h
jl short loc_4E587
cmp [rbp+var_8], 2312h
jg short loc_4E587
mov eax, [rbp+var_8]
sub eax, 2010h
movsxd rcx, eax
lea rax, tab_uni_gbk1
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_4E6D5
loc_4E587:
cmp [rbp+var_8], 2460h
jl short loc_4E5B7
cmp [rbp+var_8], 2642h
jg short loc_4E5B7
mov eax, [rbp+var_8]
sub eax, 2460h
movsxd rcx, eax
lea rax, tab_uni_gbk2
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_4E6D5
loc_4E5B7:
cmp [rbp+var_8], 3000h
jl short loc_4E5E7
cmp [rbp+var_8], 3129h
jg short loc_4E5E7
mov eax, [rbp+var_8]
sub eax, 3000h
movsxd rcx, eax
lea rax, tab_uni_gbk3
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_4E6D5
loc_4E5E7:
cmp [rbp+var_8], 3220h
jl short loc_4E617
cmp [rbp+var_8], 32A3h
jg short loc_4E617
mov eax, [rbp+var_8]
sub eax, 3220h
movsxd rcx, eax
lea rax, tab_uni_gbk4
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_4E6D5
loc_4E617:
cmp [rbp+var_8], 338Eh
jl short loc_4E647
cmp [rbp+var_8], 33D5h
jg short loc_4E647
mov eax, [rbp+var_8]
sub eax, 338Eh
movsxd rcx, eax
lea rax, tab_uni_gbk5
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_4E6D5
loc_4E647:
cmp [rbp+var_8], 4E00h
jl short loc_4E674
cmp [rbp+var_8], 9FA5h
jg short loc_4E674
mov eax, [rbp+var_8]
sub eax, 4E00h
movsxd rcx, eax
lea rax, tab_uni_gbk6
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_4E6D5
loc_4E674:
cmp [rbp+var_8], 0F92Ch
jl short loc_4E6A1
cmp [rbp+var_8], 0FA29h
jg short loc_4E6A1
mov eax, [rbp+var_8]
sub eax, 0F92Ch
movsxd rcx, eax
lea rax, tab_uni_gbk7
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_4E6D5
loc_4E6A1:
cmp [rbp+var_8], 0FE30h
jl short loc_4E6CE
cmp [rbp+var_8], 0FFE5h
jg short loc_4E6CE
mov eax, [rbp+var_8]
sub eax, 0FE30h
movsxd rcx, eax
lea rax, tab_uni_gbk8
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_4E6D5
loc_4E6CE:
mov [rbp+var_4], 0
loc_4E6D5:
mov eax, [rbp+var_4]
pop rbp
retn
| long long func_uni_gbk_onechar(int a1)
{
if ( a1 < 164 || a1 > 1105 )
{
if ( a1 < 8208 || a1 > 8978 )
{
if ( a1 < 9312 || a1 > 9794 )
{
if ( a1 < 12288 || a1 > 12585 )
{
if ( a1 < 12832 || a1 > 12963 )
{
if ( a1 < 13198 || a1 > 13269 )
{
if ( a1 < 19968 || a1 > 40869 )
{
if ( a1 < 63788 || a1 > 64041 )
{
if ( a1 < 65072 || a1 > 65509 )
return 0;
else
return tab_uni_gbk8[a1 - 65072];
}
else
{
return tab_uni_gbk7[a1 - 63788];
}
}
else
{
return tab_uni_gbk6[a1 - 19968];
}
}
else
{
return tab_uni_gbk5[a1 - 13198];
}
}
else
{
return tab_uni_gbk4[a1 - 12832];
}
}
else
{
return tab_uni_gbk3[a1 - 12288];
}
}
else
{
return tab_uni_gbk2[a1 - 9312];
}
}
else
{
return tab_uni_gbk1[a1 - 8208];
}
}
else
{
return tab_uni_gbk0[a1 - 164];
}
}
| func_uni_gbk_onechar:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x8],EDI
CMP dword ptr [RBP + -0x8],0xa4
JL 0x0014e557
CMP dword ptr [RBP + -0x8],0x451
JG 0x0014e557
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0xa4
MOVSXD RCX,EAX
LEA RAX,[0x23aac0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0014e6d5
LAB_0014e557:
CMP dword ptr [RBP + -0x8],0x2010
JL 0x0014e587
CMP dword ptr [RBP + -0x8],0x2312
JG 0x0014e587
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2010
MOVSXD RCX,EAX
LEA RAX,[0x23b220]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0014e6d5
LAB_0014e587:
CMP dword ptr [RBP + -0x8],0x2460
JL 0x0014e5b7
CMP dword ptr [RBP + -0x8],0x2642
JG 0x0014e5b7
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2460
MOVSXD RCX,EAX
LEA RAX,[0x23b830]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0014e6d5
LAB_0014e5b7:
CMP dword ptr [RBP + -0x8],0x3000
JL 0x0014e5e7
CMP dword ptr [RBP + -0x8],0x3129
JG 0x0014e5e7
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x3000
MOVSXD RCX,EAX
LEA RAX,[0x23bc00]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0014e6d5
LAB_0014e5e7:
CMP dword ptr [RBP + -0x8],0x3220
JL 0x0014e617
CMP dword ptr [RBP + -0x8],0x32a3
JG 0x0014e617
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x3220
MOVSXD RCX,EAX
LEA RAX,[0x23be60]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0014e6d5
LAB_0014e617:
CMP dword ptr [RBP + -0x8],0x338e
JL 0x0014e647
CMP dword ptr [RBP + -0x8],0x33d5
JG 0x0014e647
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x338e
MOVSXD RCX,EAX
LEA RAX,[0x23bf70]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0014e6d5
LAB_0014e647:
CMP dword ptr [RBP + -0x8],0x4e00
JL 0x0014e674
CMP dword ptr [RBP + -0x8],0x9fa5
JG 0x0014e674
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x4e00
MOVSXD RCX,EAX
LEA RAX,[0x23c000]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0014e6d5
LAB_0014e674:
CMP dword ptr [RBP + -0x8],0xf92c
JL 0x0014e6a1
CMP dword ptr [RBP + -0x8],0xfa29
JG 0x0014e6a1
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0xf92c
MOVSXD RCX,EAX
LEA RAX,[0x246350]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0014e6d5
LAB_0014e6a1:
CMP dword ptr [RBP + -0x8],0xfe30
JL 0x0014e6ce
CMP dword ptr [RBP + -0x8],0xffe5
JG 0x0014e6ce
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0xfe30
MOVSXD RCX,EAX
LEA RAX,[0x246550]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0014e6d5
LAB_0014e6ce:
MOV dword ptr [RBP + -0x4],0x0
LAB_0014e6d5:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int2 func_uni_gbk_onechar(int param_1)
{
int2 uVar1;
if ((param_1 < 0xa4) || (0x451 < param_1)) {
if ((param_1 < 0x2010) || (0x2312 < param_1)) {
if ((param_1 < 0x2460) || (0x2642 < param_1)) {
if ((param_1 < 0x3000) || (0x3129 < param_1)) {
if ((param_1 < 0x3220) || (0x32a3 < param_1)) {
if ((param_1 < 0x338e) || (0x33d5 < param_1)) {
if ((param_1 < 0x4e00) || (0x9fa5 < param_1)) {
if ((param_1 < 0xf92c) || (0xfa29 < param_1)) {
if ((param_1 < 0xfe30) || (0xffe5 < param_1)) {
uVar1 = 0;
}
else {
uVar1 = *(int2 *)(tab_uni_gbk8 + (long)(param_1 + -0xfe30) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gbk7 + (long)(param_1 + -0xf92c) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gbk6 + (long)(param_1 + -0x4e00) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gbk5 + (long)(param_1 + -0x338e) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gbk4 + (long)(param_1 + -0x3220) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gbk3 + (long)(param_1 + -0x3000) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gbk2 + (long)(param_1 + -0x2460) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gbk1 + (long)(param_1 + -0x2010) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gbk0 + (long)(param_1 + -0xa4) * 2);
}
return uVar1;
}
|
|
908 | uf_endspace_selected | eloqsql/storage/maria/ma_packrec.c | static void uf_endspace_selected(MARIA_COLUMNDEF *rec,
MARIA_BIT_BUFF *bit_buff,
uchar *to, uchar *end)
{
uint spaces;
if (get_bit(bit_buff))
{
if ((spaces=get_bits(bit_buff,rec->space_length_bits))+to > end)
{
bit_buff->error=1;
return;
}
if (to+spaces != end)
decode_bytes(rec,bit_buff,to,end-spaces);
bfill(end - spaces, spaces, ' ');
}
else
decode_bytes(rec,bit_buff,to,end);
} | O3 | c | uf_endspace_selected:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movl 0x4(%rsi), %eax
testl %eax, %eax
je 0x3caa8
movl (%r15), %r14d
decl %eax
movl %eax, 0x4(%r15)
btl %eax, %r14d
jb 0x3cae7
jmp 0x3cac6
movq %r15, %rdi
movq %rdx, %r14
callq 0x3c3fc
movq %r14, %rdx
movl $0x1f, 0x4(%r15)
movl (%r15), %r14d
testl %r14d, %r14d
js 0x3cae2
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3c5b9
movl $0x1f, %eax
movl 0x24(%r12), %r13d
movl %eax, %ecx
subl %r13d, %ecx
jae 0x3cb3b
subl %eax, %r13d
movl %eax, %eax
leaq 0x89491(%rip), %rcx # 0xc5f90
andl (%rcx,%rax,4), %r14d
movl %r13d, %ecx
shll %cl, %r14d
movq %r15, %rdi
movq %r12, -0x30(%rbp)
movq %rdx, %r12
callq 0x3c3fc
movq %r12, %rdx
movq -0x30(%rbp), %r12
movl $0x20, %eax
subl %r13d, %eax
movl %eax, 0x4(%r15)
movl (%r15), %eax
negl %r13d
movl %r13d, %ecx
shrl %cl, %eax
addl %eax, %r14d
jmp 0x3cb52
movl %ecx, 0x4(%r15)
shrl %cl, %r14d
movl 0x24(%r12), %eax
leaq 0x89442(%rip), %rcx # 0xc5f90
andl (%rcx,%rax,4), %r14d
movl %r14d, %r13d
leaq (%rdx,%r13), %rax
cmpq %rbx, %rax
jbe 0x3cb75
movl $0x1, 0x28(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %r14
negq %r14
cmpq %rbx, %rax
je 0x3cb8f
leaq (%rbx,%r14), %rcx
movq %r12, %rdi
movq %r15, %rsi
callq 0x3c5b9
addq %r14, %rbx
movq %rbx, %rdi
movl $0x20, %esi
movq %r13, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x27320
| uf_endspace_selected:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rcx
mov r15, rsi
mov r12, rdi
mov eax, [rsi+4]
test eax, eax
jz short loc_3CAA8
mov r14d, [r15]
dec eax
mov [r15+4], eax
bt r14d, eax
jb short loc_3CAE7
jmp short loc_3CAC6
loc_3CAA8:
mov rdi, r15
mov r14, rdx
call fill_buffer
mov rdx, r14
mov dword ptr [r15+4], 1Fh
mov r14d, [r15]
test r14d, r14d
js short loc_3CAE2
loc_3CAC6:
mov rdi, r12
mov rsi, r15
mov rcx, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp decode_bytes
loc_3CAE2:
mov eax, 1Fh
loc_3CAE7:
mov r13d, [r12+24h]
mov ecx, eax
sub ecx, r13d
jnb short loc_3CB3B
sub r13d, eax
mov eax, eax
lea rcx, mask
and r14d, [rcx+rax*4]
mov ecx, r13d
shl r14d, cl
mov rdi, r15
mov [rbp+var_30], r12
mov r12, rdx
call fill_buffer
mov rdx, r12
mov r12, [rbp+var_30]
mov eax, 20h ; ' '
sub eax, r13d
mov [r15+4], eax
mov eax, [r15]
neg r13d
mov ecx, r13d
shr eax, cl
add r14d, eax
jmp short loc_3CB52
loc_3CB3B:
mov [r15+4], ecx
shr r14d, cl
mov eax, [r12+24h]
lea rcx, mask
and r14d, [rcx+rax*4]
loc_3CB52:
mov r13d, r14d
lea rax, [rdx+r13]
cmp rax, rbx
jbe short loc_3CB75
mov dword ptr [r15+28h], 1
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3CB75:
mov r14, r13
neg r14
cmp rax, rbx
jz short loc_3CB8F
lea rcx, [rbx+r14]
mov rdi, r12
mov rsi, r15
call decode_bytes
loc_3CB8F:
add rbx, r14
mov rdi, rbx
mov esi, 20h ; ' '
mov rdx, r13
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _memset
| _BYTE * uf_endspace_selected(long long a1, unsigned int *a2, _BYTE *a3, _BYTE *a4)
{
long long v5; // r12
unsigned int v6; // eax
unsigned int v7; // r14d
unsigned int v8; // eax
_BYTE *v9; // r14
_BYTE *result; // rax
unsigned int v11; // r13d
unsigned int v12; // ecx
int v13; // r13d
int v14; // r14d
_BYTE *v15; // r12
unsigned int v16; // r14d
v5 = a1;
v6 = a2[1];
if ( v6 )
{
v7 = *a2;
v8 = v6 - 1;
a2[1] = v8;
if ( !_bittest((const int *)&v7, v8) )
return decode_bytes(a1, (long long)a2, a3, a4);
}
else
{
v9 = a3;
fill_buffer((long long)a2);
a3 = v9;
a2[1] = 31;
v7 = *a2;
if ( (*a2 & 0x80000000) == 0 )
return decode_bytes(a1, (long long)a2, a3, a4);
v8 = 31;
}
v11 = *(_DWORD *)(a1 + 36);
v12 = v8 - v11;
if ( v8 >= v11 )
{
a2[1] = v12;
v16 = mask[*(unsigned int *)(a1 + 36)] & (v7 >> v12);
}
else
{
v13 = v11 - v8;
v14 = (mask[v8] & v7) << v13;
v15 = a3;
fill_buffer((long long)a2);
a3 = v15;
v5 = a1;
a2[1] = 32 - v13;
v16 = (*a2 >> -(char)v13) + v14;
}
result = &a3[v16];
if ( result <= a4 )
{
if ( result != a4 )
decode_bytes(v5, (long long)a2, a3, &a4[-v16]);
return (_BYTE *)memset(&a4[-v16], 32LL, v16);
}
else
{
a2[10] = 1;
}
return result;
}
| uf_endspace_selected:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RCX
MOV R15,RSI
MOV R12,RDI
MOV EAX,dword ptr [RSI + 0x4]
TEST EAX,EAX
JZ 0x0013caa8
MOV R14D,dword ptr [R15]
DEC EAX
MOV dword ptr [R15 + 0x4],EAX
BT R14D,EAX
JC 0x0013cae7
JMP 0x0013cac6
LAB_0013caa8:
MOV RDI,R15
MOV R14,RDX
CALL 0x0013c3fc
MOV RDX,R14
MOV dword ptr [R15 + 0x4],0x1f
MOV R14D,dword ptr [R15]
TEST R14D,R14D
JS 0x0013cae2
LAB_0013cac6:
MOV RDI,R12
MOV RSI,R15
MOV RCX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0013c5b9
LAB_0013cae2:
MOV EAX,0x1f
LAB_0013cae7:
MOV R13D,dword ptr [R12 + 0x24]
MOV ECX,EAX
SUB ECX,R13D
JNC 0x0013cb3b
SUB R13D,EAX
MOV EAX,EAX
LEA RCX,[0x1c5f90]
AND R14D,dword ptr [RCX + RAX*0x4]
MOV ECX,R13D
SHL R14D,CL
MOV RDI,R15
MOV qword ptr [RBP + -0x30],R12
MOV R12,RDX
CALL 0x0013c3fc
MOV RDX,R12
MOV R12,qword ptr [RBP + -0x30]
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 R14D,EAX
JMP 0x0013cb52
LAB_0013cb3b:
MOV dword ptr [R15 + 0x4],ECX
SHR R14D,CL
MOV EAX,dword ptr [R12 + 0x24]
LEA RCX,[0x1c5f90]
AND R14D,dword ptr [RCX + RAX*0x4]
LAB_0013cb52:
MOV R13D,R14D
LEA RAX,[RDX + R13*0x1]
CMP RAX,RBX
JBE 0x0013cb75
MOV dword ptr [R15 + 0x28],0x1
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013cb75:
MOV R14,R13
NEG R14
CMP RAX,RBX
JZ 0x0013cb8f
LEA RCX,[RBX + R14*0x1]
MOV RDI,R12
MOV RSI,R15
CALL 0x0013c5b9
LAB_0013cb8f:
ADD RBX,R14
MOV RDI,RBX
MOV ESI,0x20
MOV RDX,R13
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00127320
|
void uf_endspace_selected(long param_1,uint *param_2,long param_3,ulong param_4)
{
uint uVar1;
uint uVar2;
uint uVar3;
byte bVar4;
ulong __n;
uint uVar5;
if (param_2[1] == 0) {
fill_buffer(param_2);
param_2[1] = 0x1f;
uVar5 = *param_2;
if ((int)uVar5 < 0) {
uVar3 = 0x1f;
goto LAB_0013cae7;
}
}
else {
uVar5 = *param_2;
uVar3 = param_2[1] - 1;
param_2[1] = uVar3;
if ((uVar5 >> (uVar3 & 0x1f) & 1) != 0) {
LAB_0013cae7:
uVar1 = *(uint *)(param_1 + 0x24);
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 + 0x24)];
}
__n = (ulong)uVar5;
if (param_3 + __n <= param_4) {
if (param_3 + __n != param_4) {
decode_bytes(param_1,param_2,param_3,param_4 + -__n);
}
memset((void *)(param_4 + -__n),0x20,__n);
return;
}
param_2[10] = 1;
return;
}
}
decode_bytes(param_1,param_2,param_3,param_4);
return;
}
|
|
909 | stbi__resample_row_hv_2_simd(unsigned char*, unsigned char*, unsigned char*, int, int) | monkey531[P]llama/examples/llava/../../common/stb_image.h | static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
{
// need to generate 2x2 samples for every one in input
int i=0,t0,t1;
if (w == 1) {
out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2);
return out;
}
t1 = 3*in_near[0] + in_far[0];
// process groups of 8 pixels for as long as we can.
// note we can't handle the last pixel in a row in this loop
// because we need to handle the filter boundary conditions.
for (; i < ((w-1) & ~7); i += 8) {
#if defined(STBI_SSE2)
// load and perform the vertical filtering pass
// this uses 3*x + y = 4*x + (y - x)
__m128i zero = _mm_setzero_si128();
__m128i farb = _mm_loadl_epi64((__m128i *) (in_far + i));
__m128i nearb = _mm_loadl_epi64((__m128i *) (in_near + i));
__m128i farw = _mm_unpacklo_epi8(farb, zero);
__m128i nearw = _mm_unpacklo_epi8(nearb, zero);
__m128i diff = _mm_sub_epi16(farw, nearw);
__m128i nears = _mm_slli_epi16(nearw, 2);
__m128i curr = _mm_add_epi16(nears, diff); // current row
// horizontal filter works the same based on shifted vers of current
// row. "prev" is current row shifted right by 1 pixel; we need to
// insert the previous pixel value (from t1).
// "next" is current row shifted left by 1 pixel, with first pixel
// of next block of 8 pixels added in.
__m128i prv0 = _mm_slli_si128(curr, 2);
__m128i nxt0 = _mm_srli_si128(curr, 2);
__m128i prev = _mm_insert_epi16(prv0, t1, 0);
__m128i next = _mm_insert_epi16(nxt0, 3*in_near[i+8] + in_far[i+8], 7);
// horizontal filter, polyphase implementation since it's convenient:
// even pixels = 3*cur + prev = cur*4 + (prev - cur)
// odd pixels = 3*cur + next = cur*4 + (next - cur)
// note the shared term.
__m128i bias = _mm_set1_epi16(8);
__m128i curs = _mm_slli_epi16(curr, 2);
__m128i prvd = _mm_sub_epi16(prev, curr);
__m128i nxtd = _mm_sub_epi16(next, curr);
__m128i curb = _mm_add_epi16(curs, bias);
__m128i even = _mm_add_epi16(prvd, curb);
__m128i odd = _mm_add_epi16(nxtd, curb);
// interleave even and odd pixels, then undo scaling.
__m128i int0 = _mm_unpacklo_epi16(even, odd);
__m128i int1 = _mm_unpackhi_epi16(even, odd);
__m128i de0 = _mm_srli_epi16(int0, 4);
__m128i de1 = _mm_srli_epi16(int1, 4);
// pack and write output
__m128i outv = _mm_packus_epi16(de0, de1);
_mm_storeu_si128((__m128i *) (out + i*2), outv);
#elif defined(STBI_NEON)
// load and perform the vertical filtering pass
// this uses 3*x + y = 4*x + (y - x)
uint8x8_t farb = vld1_u8(in_far + i);
uint8x8_t nearb = vld1_u8(in_near + i);
int16x8_t diff = vreinterpretq_s16_u16(vsubl_u8(farb, nearb));
int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2));
int16x8_t curr = vaddq_s16(nears, diff); // current row
// horizontal filter works the same based on shifted vers of current
// row. "prev" is current row shifted right by 1 pixel; we need to
// insert the previous pixel value (from t1).
// "next" is current row shifted left by 1 pixel, with first pixel
// of next block of 8 pixels added in.
int16x8_t prv0 = vextq_s16(curr, curr, 7);
int16x8_t nxt0 = vextq_s16(curr, curr, 1);
int16x8_t prev = vsetq_lane_s16(t1, prv0, 0);
int16x8_t next = vsetq_lane_s16(3*in_near[i+8] + in_far[i+8], nxt0, 7);
// horizontal filter, polyphase implementation since it's convenient:
// even pixels = 3*cur + prev = cur*4 + (prev - cur)
// odd pixels = 3*cur + next = cur*4 + (next - cur)
// note the shared term.
int16x8_t curs = vshlq_n_s16(curr, 2);
int16x8_t prvd = vsubq_s16(prev, curr);
int16x8_t nxtd = vsubq_s16(next, curr);
int16x8_t even = vaddq_s16(curs, prvd);
int16x8_t odd = vaddq_s16(curs, nxtd);
// undo scaling and round, then store with even/odd phases interleaved
uint8x8x2_t o;
o.val[0] = vqrshrun_n_s16(even, 4);
o.val[1] = vqrshrun_n_s16(odd, 4);
vst2_u8(out + i*2, o);
#endif
// "previous" value for next iter
t1 = 3*in_near[i+7] + in_far[i+7];
}
t0 = t1;
t1 = 3*in_near[i] + in_far[i];
out[i*2] = stbi__div16(3*t1 + t0 + 8);
for (++i; i < w; ++i) {
t0 = t1;
t1 = 3*in_near[i]+in_far[i];
out[i*2-1] = stbi__div16(3*t0 + t1 + 8);
out[i*2 ] = stbi__div16(3*t1 + t0 + 8);
}
out[w*2-1] = stbi__div4(t1+2);
STBI_NOTUSED(hs);
return out;
} | O2 | c | stbi__resample_row_hv_2_simd(unsigned char*, unsigned char*, unsigned char*, int, int):
movq %rdi, %rax
movzbl (%rsi), %r8d
movzbl (%rdx), %edi
cmpl $0x1, %ecx
jne 0x407d9
movzwl %r8w, %ecx
leal (%rcx,%rcx,2), %ecx
movzwl %di, %edx
addl %edx, %ecx
addl $0x2, %ecx
shrl $0x2, %ecx
movb %cl, 0x1(%rax)
movb %cl, (%rax)
retq
movzwl %r8w, %r8d
leal (%r8,%r8,2), %r8d
movzwl %di, %r9d
addl %r8d, %r9d
leal -0x1(%rcx), %edi
andl $-0x8, %edi
movslq %edi, %r8
xorl %edi, %edi
pxor %xmm0, %xmm0
movdqa 0x85511(%rip), %xmm1 # 0xc5d10
cmpq %r8, %rdi
jge 0x408ac
movq (%rdx,%rdi), %xmm2
movq (%rsi,%rdi), %xmm3
punpcklbw %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1],xmm2[2],xmm0[2],xmm2[3],xmm0[3],xmm2[4],xmm0[4],xmm2[5],xmm0[5],xmm2[6],xmm0[6],xmm2[7],xmm0[7]
punpcklbw %xmm0, %xmm3 # xmm3 = xmm3[0],xmm0[0],xmm3[1],xmm0[1],xmm3[2],xmm0[2],xmm3[3],xmm0[3],xmm3[4],xmm0[4],xmm3[5],xmm0[5],xmm3[6],xmm0[6],xmm3[7],xmm0[7]
psubw %xmm3, %xmm2
psllw $0x2, %xmm3
paddw %xmm2, %xmm3
movdqa %xmm3, %xmm2
pslldq $0x2, %xmm2 # xmm2 = zero,zero,xmm2[0,1,2,3,4,5,6,7,8,9,10,11,12,13]
pinsrw $0x0, %r9d, %xmm2
movdqa %xmm3, %xmm4
psrldq $0x2, %xmm4 # xmm4 = xmm4[2,3,4,5,6,7,8,9,10,11,12,13,14,15],zero,zero
movzbl 0x8(%rsi,%rdi), %r9d
leal (%r9,%r9,2), %r9d
movzbl 0x8(%rdx,%rdi), %r10d
addl %r9d, %r10d
pinsrw $0x7, %r10d, %xmm4
psubw %xmm3, %xmm2
psubw %xmm3, %xmm4
psllw $0x2, %xmm3
paddw %xmm1, %xmm3
paddw %xmm3, %xmm2
paddw %xmm3, %xmm4
movdqa %xmm2, %xmm3
punpcklwd %xmm4, %xmm3 # xmm3 = xmm3[0],xmm4[0],xmm3[1],xmm4[1],xmm3[2],xmm4[2],xmm3[3],xmm4[3]
punpckhwd %xmm4, %xmm2 # xmm2 = xmm2[4],xmm4[4],xmm2[5],xmm4[5],xmm2[6],xmm4[6],xmm2[7],xmm4[7]
psrlw $0x4, %xmm3
psrlw $0x4, %xmm2
packuswb %xmm2, %xmm3
movdqu %xmm3, (%rax,%rdi,2)
movzbl 0x7(%rsi,%rdi), %r10d
movzbl 0x7(%rdx,%rdi), %r9d
addq $0x8, %rdi
leal (%r10,%r10,2), %r10d
addl %r10d, %r9d
jmp 0x407ff
movzbl (%rsi,%rdi), %r8d
leal (%r8,%r8,2), %r10d
movzbl (%rdx,%rdi), %r8d
addl %r10d, %r8d
leal (%r8,%r8,2), %r10d
addl %r10d, %r9d
addl $0x8, %r9d
shrl $0x4, %r9d
movb %r9b, (%rax,%rdi,2)
movslq %ecx, %rcx
incq %rdi
cmpq %rcx, %rdi
jge 0x4091b
movzbl (%rsi,%rdi), %r9d
leal (%r9,%r9,2), %r9d
movzbl (%rdx,%rdi), %r10d
addl %r9d, %r10d
leal (%r8,%r8,2), %r9d
addl %r10d, %r9d
addl $0x8, %r9d
shrl $0x4, %r9d
movb %r9b, -0x1(%rax,%rdi,2)
leal (%r10,%r10,2), %r9d
addl %r9d, %r8d
addl $0x8, %r8d
shrl $0x4, %r8d
movb %r8b, (%rax,%rdi,2)
incq %rdi
movl %r10d, %r8d
jmp 0x408d6
addl $0x2, %r8d
shrl $0x2, %r8d
movb %r8b, -0x1(%rax,%rcx,2)
retq
| _ZL28stbi__resample_row_hv_2_simdPhS_S_ii:
mov rax, rdi
movzx r8d, byte ptr [rsi]
movzx edi, byte ptr [rdx]
cmp ecx, 1
jnz short loc_407D9
movzx ecx, r8w
lea ecx, [rcx+rcx*2]
movzx edx, di
add ecx, edx
add ecx, 2
shr ecx, 2
mov [rax+1], cl
mov [rax], cl
retn
loc_407D9:
movzx r8d, r8w
lea r8d, [r8+r8*2]
movzx r9d, di
add r9d, r8d
lea edi, [rcx-1]
and edi, 0FFFFFFF8h
movsxd r8, edi
xor edi, edi
pxor xmm0, xmm0
movdqa xmm1, cs:xmmword_C5D10
loc_407FF:
cmp rdi, r8
jge loc_408AC
movq xmm2, qword ptr [rdx+rdi]
movq xmm3, qword ptr [rsi+rdi]
punpcklbw xmm2, xmm0
punpcklbw xmm3, xmm0
psubw xmm2, xmm3
psllw xmm3, 2
paddw xmm3, xmm2
movdqa xmm2, xmm3
pslldq xmm2, 2
pinsrw xmm2, r9d, 0
movdqa xmm4, xmm3
psrldq xmm4, 2
movzx r9d, byte ptr [rsi+rdi+8]
lea r9d, [r9+r9*2]
movzx r10d, byte ptr [rdx+rdi+8]
add r10d, r9d
pinsrw xmm4, r10d, 7
psubw xmm2, xmm3
psubw xmm4, xmm3
psllw xmm3, 2
paddw xmm3, xmm1
paddw xmm2, xmm3
paddw xmm4, xmm3
movdqa xmm3, xmm2
punpcklwd xmm3, xmm4
punpckhwd xmm2, xmm4
psrlw xmm3, 4
psrlw xmm2, 4
packuswb xmm3, xmm2
movdqu xmmword ptr [rax+rdi*2], xmm3
movzx r10d, byte ptr [rsi+rdi+7]
movzx r9d, byte ptr [rdx+rdi+7]
add rdi, 8
lea r10d, [r10+r10*2]
add r9d, r10d
jmp loc_407FF
loc_408AC:
movzx r8d, byte ptr [rsi+rdi]
lea r10d, [r8+r8*2]
movzx r8d, byte ptr [rdx+rdi]
add r8d, r10d
lea r10d, [r8+r8*2]
add r9d, r10d
add r9d, 8
shr r9d, 4
mov [rax+rdi*2], r9b
movsxd rcx, ecx
inc rdi
loc_408D6:
cmp rdi, rcx
jge short loc_4091B
movzx r9d, byte ptr [rsi+rdi]
lea r9d, [r9+r9*2]
movzx r10d, byte ptr [rdx+rdi]
add r10d, r9d
lea r9d, [r8+r8*2]
add r9d, r10d
add r9d, 8
shr r9d, 4
mov [rax+rdi*2-1], r9b
lea r9d, [r10+r10*2]
add r8d, r9d
add r8d, 8
shr r8d, 4
mov [rax+rdi*2], r8b
inc rdi
mov r8d, r10d
jmp short loc_408D6
loc_4091B:
add r8d, 2
shr r8d, 2
mov [rax+rcx*2-1], r8b
retn
| unsigned __int8 * stbi__resample_row_hv_2_simd(
unsigned __int8 *a1,
unsigned __int8 *a2,
unsigned __int8 *a3,
int a4)
{
unsigned __int8 *result; // rax
unsigned int v5; // ecx
unsigned int v6; // r9d
long long v7; // rdi
__m128i si128; // xmm1
__m128i v9; // xmm3
__m128i v10; // xmm3
__m128i v11; // xmm2
__m128i v12; // xmm4
__m128i v13; // xmm3
__m128i v14; // xmm2
__m128i v15; // xmm4
int v16; // r10d
int v17; // r9d
int v18; // r8d
long long i; // rdi
int v20; // r10d
result = a1;
if ( a4 == 1 )
{
v5 = (*a3 + 3 * (unsigned int)*a2 + 2) >> 2;
a1[1] = v5;
*a1 = v5;
}
else
{
v6 = 3 * *a2 + *a3;
v7 = 0LL;
si128 = _mm_load_si128((const __m128i *)&xmmword_C5D10);
while ( v7 < (int)((a4 - 1) & 0xFFFFFFF8) )
{
v9 = _mm_unpacklo_epi8(_mm_loadl_epi64((const __m128i *)&a2[v7]), (__m128i)0LL);
v10 = _mm_add_epi16(
_mm_slli_epi16(v9, 2u),
_mm_sub_epi16(_mm_unpacklo_epi8(_mm_loadl_epi64((const __m128i *)&a3[v7]), (__m128i)0LL), v9));
v11 = _mm_sub_epi16(_mm_insert_epi16(_mm_slli_si128(v10, 2), v6, 0), v10);
v12 = _mm_sub_epi16(_mm_insert_epi16(_mm_srli_si128(v10, 2), 3 * a2[v7 + 8] + (unsigned int)a3[v7 + 8], 7), v10);
v13 = _mm_add_epi16(_mm_slli_epi16(v10, 2u), si128);
v14 = _mm_add_epi16(v11, v13);
v15 = _mm_add_epi16(v12, v13);
*(__m128i *)&result[2 * v7] = _mm_packus_epi16(
_mm_srli_epi16(_mm_unpacklo_epi16(v14, v15), 4u),
_mm_srli_epi16(_mm_unpackhi_epi16(v14, v15), 4u));
v16 = a2[v7 + 7];
v17 = a3[v7 + 7];
v7 += 8LL;
v6 = 3 * v16 + v17;
}
v18 = 3 * a2[v7] + a3[v7];
result[2 * v7] = (3 * v18 + v6 + 8) >> 4;
for ( i = v7 + 1; i < a4; ++i )
{
v20 = 3 * a2[i] + a3[i];
result[2 * i - 1] = (unsigned int)(v20 + 3 * v18 + 8) >> 4;
result[2 * i] = (unsigned int)(3 * v20 + v18 + 8) >> 4;
v18 = v20;
}
result[2 * a4 - 1] = (unsigned int)(v18 + 2) >> 2;
}
return result;
}
| stbi__resample_row_hv_2_simd:
MOV RAX,RDI
MOVZX R8D,byte ptr [RSI]
MOVZX EDI,byte ptr [RDX]
CMP ECX,0x1
JNZ 0x001407d9
MOVZX ECX,R8W
LEA ECX,[RCX + RCX*0x2]
MOVZX EDX,DI
ADD ECX,EDX
ADD ECX,0x2
SHR ECX,0x2
MOV byte ptr [RAX + 0x1],CL
MOV byte ptr [RAX],CL
RET
LAB_001407d9:
MOVZX R8D,R8W
LEA R8D,[R8 + R8*0x2]
MOVZX R9D,DI
ADD R9D,R8D
LEA EDI,[RCX + -0x1]
AND EDI,0xfffffff8
MOVSXD R8,EDI
XOR EDI,EDI
PXOR XMM0,XMM0
MOVDQA XMM1,xmmword ptr [0x001c5d10]
LAB_001407ff:
CMP RDI,R8
JGE 0x001408ac
MOVQ XMM2,qword ptr [RDX + RDI*0x1]
MOVQ XMM3,qword ptr [RSI + RDI*0x1]
PUNPCKLBW XMM2,XMM0
PUNPCKLBW XMM3,XMM0
PSUBW XMM2,XMM3
PSLLW XMM3,0x2
PADDW XMM3,XMM2
MOVDQA XMM2,XMM3
PSLLDQ XMM2,0x2
PINSRW XMM2,R9D,0x0
MOVDQA XMM4,XMM3
PSRLDQ XMM4,0x2
MOVZX R9D,byte ptr [RSI + RDI*0x1 + 0x8]
LEA R9D,[R9 + R9*0x2]
MOVZX R10D,byte ptr [RDX + RDI*0x1 + 0x8]
ADD R10D,R9D
PINSRW XMM4,R10D,0x7
PSUBW XMM2,XMM3
PSUBW XMM4,XMM3
PSLLW XMM3,0x2
PADDW XMM3,XMM1
PADDW XMM2,XMM3
PADDW XMM4,XMM3
MOVDQA XMM3,XMM2
PUNPCKLWD XMM3,XMM4
PUNPCKHWD XMM2,XMM4
PSRLW XMM3,0x4
PSRLW XMM2,0x4
PACKUSWB XMM3,XMM2
MOVDQU xmmword ptr [RAX + RDI*0x2],XMM3
MOVZX R10D,byte ptr [RSI + RDI*0x1 + 0x7]
MOVZX R9D,byte ptr [RDX + RDI*0x1 + 0x7]
ADD RDI,0x8
LEA R10D,[R10 + R10*0x2]
ADD R9D,R10D
JMP 0x001407ff
LAB_001408ac:
MOVZX R8D,byte ptr [RSI + RDI*0x1]
LEA R10D,[R8 + R8*0x2]
MOVZX R8D,byte ptr [RDX + RDI*0x1]
ADD R8D,R10D
LEA R10D,[R8 + R8*0x2]
ADD R9D,R10D
ADD R9D,0x8
SHR R9D,0x4
MOV byte ptr [RAX + RDI*0x2],R9B
MOVSXD RCX,ECX
INC RDI
LAB_001408d6:
CMP RDI,RCX
JGE 0x0014091b
MOVZX R9D,byte ptr [RSI + RDI*0x1]
LEA R9D,[R9 + R9*0x2]
MOVZX R10D,byte ptr [RDX + RDI*0x1]
ADD R10D,R9D
LEA R9D,[R8 + R8*0x2]
ADD R9D,R10D
ADD R9D,0x8
SHR R9D,0x4
MOV byte ptr [RAX + RDI*0x2 + -0x1],R9B
LEA R9D,[R10 + R10*0x2]
ADD R8D,R9D
ADD R8D,0x8
SHR R8D,0x4
MOV byte ptr [RAX + RDI*0x2],R8B
INC RDI
MOV R8D,R10D
JMP 0x001408d6
LAB_0014091b:
ADD R8D,0x2
SHR R8D,0x2
MOV byte ptr [RAX + RCX*0x2 + -0x1],R8B
RET
|
/* WARNING: Removing unreachable block (ram,0x0014082b) */
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* stbi__resample_row_hv_2_simd(unsigned char*, unsigned char*, unsigned char*, int, int) */
void stbi__resample_row_hv_2_simd
(uchar *param_1,uchar *param_2,uchar *param_3,int param_4,int param_5)
{
uchar *puVar1;
ulong uVar2;
ulong uVar3;
byte bVar4;
int1 auVar5 [15];
int1 auVar6 [15];
int1 auVar7 [15];
int1 auVar8 [15];
int1 auVar9 [15];
int1 auVar10 [15];
int1 auVar11 [15];
int1 auVar12 [15];
int1 auVar13 [15];
int1 auVar14 [15];
int1 auVar15 [15];
int1 auVar16 [15];
int1 auVar17 [15];
int1 auVar18 [15];
int1 auVar19 [15];
unkuint9 Var20;
int1 auVar21 [11];
int1 auVar22 [15];
unkuint9 Var23;
int1 auVar24 [11];
int1 auVar25 [15];
int1 auVar26 [15];
int1 auVar27 [15];
int1 auVar28 [15];
short sVar29;
short sVar30;
short sVar31;
short sVar32;
short sVar33;
short sVar34;
short sVar35;
short sVar36;
uchar uVar37;
long lVar38;
int iVar39;
int iVar40;
ushort uVar41;
ushort uVar42;
ushort uVar43;
ushort uVar44;
ushort uVar45;
ushort uVar46;
ushort uVar47;
ushort uVar48;
short sVar49;
ushort uVar50;
short sVar54;
ushort uVar55;
short sVar56;
ushort uVar57;
short sVar58;
ushort uVar59;
short sVar60;
ushort uVar61;
short sVar62;
ushort uVar63;
short sVar64;
ushort uVar65;
int1 auVar51 [16];
int1 auVar52 [16];
int1 auVar53 [16];
short sVar66;
ushort uVar67;
sVar36 = _UNK_001c5d1e;
sVar35 = _UNK_001c5d1c;
sVar34 = _UNK_001c5d1a;
sVar33 = _UNK_001c5d18;
sVar32 = _UNK_001c5d16;
sVar31 = _UNK_001c5d14;
sVar30 = _UNK_001c5d12;
sVar29 = _DAT_001c5d10;
bVar4 = *param_2;
if (param_4 == 1) {
uVar37 = (uchar)((uint)bVar4 + (uint)bVar4 * 2 + (uint)*param_3 + 2 >> 2);
param_1[1] = uVar37;
*param_1 = uVar37;
return;
}
iVar40 = (uint)*param_3 + (uint)bVar4 + (uint)bVar4 * 2;
for (lVar38 = 0; lVar38 < (int)(param_4 - 1U & 0xfffffff8); lVar38 = lVar38 + 8) {
uVar2 = *(ulong *)(param_3 + lVar38);
uVar3 = *(ulong *)(param_2 + lVar38);
auVar5._8_6_ = 0;
auVar5._0_8_ = uVar2;
auVar5[0xe] = (char)(uVar2 >> 0x38);
auVar7._8_4_ = 0;
auVar7._0_8_ = uVar2;
auVar7[0xc] = (char)(uVar2 >> 0x30);
auVar7._13_2_ = auVar5._13_2_;
auVar9._8_4_ = 0;
auVar9._0_8_ = uVar2;
auVar9._12_3_ = auVar7._12_3_;
auVar11._8_2_ = 0;
auVar11._0_8_ = uVar2;
auVar11[10] = (char)(uVar2 >> 0x28);
auVar11._11_4_ = auVar9._11_4_;
auVar13._8_2_ = 0;
auVar13._0_8_ = uVar2;
auVar13._10_5_ = auVar11._10_5_;
auVar15[8] = (char)(uVar2 >> 0x20);
auVar15._0_8_ = uVar2;
auVar15._9_6_ = auVar13._9_6_;
auVar19._7_8_ = 0;
auVar19._0_7_ = auVar15._8_7_;
Var20 = CONCAT81(SUB158(auVar19 << 0x40,7),(char)(uVar2 >> 0x18));
auVar25._9_6_ = 0;
auVar25._0_9_ = Var20;
auVar21._1_10_ = SUB1510(auVar25 << 0x30,5);
auVar21[0] = (char)(uVar2 >> 0x10);
auVar26._11_4_ = 0;
auVar26._0_11_ = auVar21;
auVar17[2] = (char)(uVar2 >> 8);
auVar17._0_2_ = (ushort)uVar2;
auVar17._3_12_ = SUB1512(auVar26 << 0x20,3);
auVar6._8_6_ = 0;
auVar6._0_8_ = uVar3;
auVar6[0xe] = (char)(uVar3 >> 0x38);
auVar8._8_4_ = 0;
auVar8._0_8_ = uVar3;
auVar8[0xc] = (char)(uVar3 >> 0x30);
auVar8._13_2_ = auVar6._13_2_;
auVar10._8_4_ = 0;
auVar10._0_8_ = uVar3;
auVar10._12_3_ = auVar8._12_3_;
auVar12._8_2_ = 0;
auVar12._0_8_ = uVar3;
auVar12[10] = (char)(uVar3 >> 0x28);
auVar12._11_4_ = auVar10._11_4_;
auVar14._8_2_ = 0;
auVar14._0_8_ = uVar3;
auVar14._10_5_ = auVar12._10_5_;
auVar16[8] = (char)(uVar3 >> 0x20);
auVar16._0_8_ = uVar3;
auVar16._9_6_ = auVar14._9_6_;
auVar22._7_8_ = 0;
auVar22._0_7_ = auVar16._8_7_;
Var23 = CONCAT81(SUB158(auVar22 << 0x40,7),(char)(uVar3 >> 0x18));
auVar27._9_6_ = 0;
auVar27._0_9_ = Var23;
auVar24._1_10_ = SUB1510(auVar27 << 0x30,5);
auVar24[0] = (char)(uVar3 >> 0x10);
auVar28._11_4_ = 0;
auVar28._0_11_ = auVar24;
auVar18[2] = (char)(uVar3 >> 8);
auVar18._0_2_ = (ushort)uVar3;
auVar18._3_12_ = SUB1512(auVar28 << 0x20,3);
auVar53._0_2_ = (ushort)uVar3 & 0xff;
auVar53._2_13_ = auVar18._2_13_;
auVar53[0xf] = 0;
auVar51 = psllw(auVar53,2);
auVar52._0_2_ = auVar51._0_2_ + (((ushort)uVar2 & 0xff) - auVar53._0_2_);
auVar52._2_2_ = auVar51._2_2_ + (auVar17._2_2_ - auVar18._2_2_);
auVar52._4_2_ = auVar51._4_2_ + (auVar21._0_2_ - auVar24._0_2_);
auVar52._6_2_ = auVar51._6_2_ + ((short)Var20 - (short)Var23);
auVar52._8_2_ = auVar51._8_2_ + (auVar15._8_2_ - auVar16._8_2_);
auVar52._10_2_ = auVar51._10_2_ + (auVar11._10_2_ - auVar12._10_2_);
auVar52._12_2_ = auVar51._12_2_ + (auVar7._12_2_ - auVar8._12_2_);
auVar52._14_2_ = auVar51._14_2_ + ((auVar5._13_2_ >> 8) - (auVar6._13_2_ >> 8));
auVar53 = psllw(auVar52,2);
sVar49 = auVar53._0_2_ + sVar29;
sVar54 = auVar53._2_2_ + sVar30;
sVar56 = auVar53._4_2_ + sVar31;
sVar58 = auVar53._6_2_ + sVar32;
sVar60 = auVar53._8_2_ + sVar33;
sVar62 = auVar53._10_2_ + sVar34;
sVar64 = auVar53._12_2_ + sVar35;
sVar66 = auVar53._14_2_ + sVar36;
uVar50 = (ushort)(((short)iVar40 - auVar52._0_2_) + sVar49) >> 4;
uVar55 = (ushort)((auVar52._2_2_ - auVar52._0_2_) + sVar49) >> 4;
uVar57 = (ushort)((auVar52._0_2_ - auVar52._2_2_) + sVar54) >> 4;
uVar59 = (ushort)((auVar52._4_2_ - auVar52._2_2_) + sVar54) >> 4;
uVar61 = (ushort)((auVar52._2_2_ - auVar52._4_2_) + sVar56) >> 4;
uVar63 = (ushort)((auVar52._6_2_ - auVar52._4_2_) + sVar56) >> 4;
uVar65 = (ushort)((auVar52._4_2_ - auVar52._6_2_) + sVar58) >> 4;
uVar67 = (ushort)((auVar52._8_2_ - auVar52._6_2_) + sVar58) >> 4;
uVar41 = (ushort)((auVar52._6_2_ - auVar52._8_2_) + sVar60) >> 4;
uVar42 = (ushort)((auVar52._10_2_ - auVar52._8_2_) + sVar60) >> 4;
uVar43 = (ushort)((auVar52._8_2_ - auVar52._10_2_) + sVar62) >> 4;
uVar44 = (ushort)((auVar52._12_2_ - auVar52._10_2_) + sVar62) >> 4;
uVar45 = (ushort)((auVar52._10_2_ - auVar52._12_2_) + sVar64) >> 4;
uVar46 = (ushort)((auVar52._14_2_ - auVar52._12_2_) + sVar64) >> 4;
uVar47 = (ushort)((auVar52._12_2_ - auVar52._14_2_) + sVar66) >> 4;
uVar48 = (ushort)((((ushort)param_3[lVar38 + 8] +
(ushort)param_2[lVar38 + 8] + (ushort)param_2[lVar38 + 8] * 2) -
auVar52._14_2_) + sVar66) >> 4;
puVar1 = param_1 + lVar38 * 2;
*puVar1 = (uVar50 != 0) * (uVar50 < 0x100) * (char)uVar50 - (0xff < uVar50);
puVar1[1] = (uVar55 != 0) * (uVar55 < 0x100) * (char)uVar55 - (0xff < uVar55);
puVar1[2] = (uVar57 != 0) * (uVar57 < 0x100) * (char)uVar57 - (0xff < uVar57);
puVar1[3] = (uVar59 != 0) * (uVar59 < 0x100) * (char)uVar59 - (0xff < uVar59);
puVar1[4] = (uVar61 != 0) * (uVar61 < 0x100) * (char)uVar61 - (0xff < uVar61);
puVar1[5] = (uVar63 != 0) * (uVar63 < 0x100) * (char)uVar63 - (0xff < uVar63);
puVar1[6] = (uVar65 != 0) * (uVar65 < 0x100) * (char)uVar65 - (0xff < uVar65);
puVar1[7] = (uVar67 != 0) * (uVar67 < 0x100) * (char)uVar67 - (0xff < uVar67);
puVar1[8] = (uVar41 != 0) * (uVar41 < 0x100) * (char)uVar41 - (0xff < uVar41);
puVar1[9] = (uVar42 != 0) * (uVar42 < 0x100) * (char)uVar42 - (0xff < uVar42);
puVar1[10] = (uVar43 != 0) * (uVar43 < 0x100) * (char)uVar43 - (0xff < uVar43);
puVar1[0xb] = (uVar44 != 0) * (uVar44 < 0x100) * (char)uVar44 - (0xff < uVar44);
puVar1[0xc] = (uVar45 != 0) * (uVar45 < 0x100) * (char)uVar45 - (0xff < uVar45);
puVar1[0xd] = (uVar46 != 0) * (uVar46 < 0x100) * (char)uVar46 - (0xff < uVar46);
puVar1[0xe] = (uVar47 != 0) * (uVar47 < 0x100) * (char)uVar47 - (0xff < uVar47);
puVar1[0xf] = (uVar48 != 0) * (uVar48 < 0x100) * (char)uVar48 - (0xff < uVar48);
iVar40 = (uint)param_3[lVar38 + 7] + (uint)param_2[lVar38 + 7] + (uint)param_2[lVar38 + 7] * 2;
}
iVar39 = (uint)param_3[lVar38] + (uint)param_2[lVar38] + (uint)param_2[lVar38] * 2;
param_1[lVar38 * 2] = (uchar)(iVar40 + iVar39 * 3 + 8U >> 4);
while (lVar38 = lVar38 + 1, lVar38 < param_4) {
iVar40 = (uint)param_3[lVar38] + (uint)param_2[lVar38] + (uint)param_2[lVar38] * 2;
param_1[lVar38 * 2 + -1] = (uchar)(iVar39 * 3 + iVar40 + 8U >> 4);
param_1[lVar38 * 2] = (uchar)(iVar39 + iVar40 * 3 + 8U >> 4);
iVar39 = iVar40;
}
param_1[(long)param_4 * 2 + -1] = (uchar)(iVar39 + 2U >> 2);
return;
}
|
|
910 | partitioned_key_cache_read | eloqsql/mysys/mf_keycache.c | static
uchar *partitioned_key_cache_read(PARTITIONED_KEY_CACHE_CB *keycache,
File file, my_off_t filepos, int level,
uchar *buff, uint length,
uint block_length __attribute__((unused)),
int return_buffer __attribute__((unused)))
{
uint r_length;
uint offset= (uint) (filepos % keycache->key_cache_block_size);
uchar *start= buff;
DBUG_ENTER("partitioned_key_cache_read");
DBUG_PRINT("enter", ("fd: %u pos: %lu length: %u",
(uint) file, (ulong) filepos, length));
/* Read data in key_cache_block_size increments */
do
{
SIMPLE_KEY_CACHE_CB *partition= get_key_cache_partition(keycache,
file, filepos);
uchar *ret_buff= 0;
r_length= length;
set_if_smaller(r_length, keycache->key_cache_block_size - offset);
ret_buff= simple_key_cache_read((void *) partition,
file, filepos, level,
buff, r_length,
block_length, return_buffer);
if (ret_buff == 0)
DBUG_RETURN(0);
filepos+= r_length;
buff+= r_length;
offset= 0;
} while ((length-= r_length));
DBUG_RETURN(start);
} | O3 | c | partitioned_key_cache_read:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, %r14d
movq %r8, %r15
movl %ecx, -0x2c(%rbp)
movq %rdx, %r12
movq %rdi, %r13
movl 0x18(%rdi), %ecx
movq $0x0, -0x38(%rbp)
movq %rdx, %rax
xorl %edx, %edx
divq %rcx
movq %rdx, %rcx
movslq %esi, %rax
movq %rax, -0x48(%rbp)
movq %r8, -0x40(%rbp)
movl 0x18(%r13), %ebx
movq %r12, %rax
xorl %edx, %edx
divq %rbx
movq -0x48(%rbp), %rsi
addq %rsi, %rax
movl 0x1c(%r13), %edi
xorl %edx, %edx
divq %rdi
movq 0x8(%r13), %rax
movq (%rax,%rdx,8), %rdi
subl %ecx, %ebx
cmpl %ebx, %r14d
cmovbl %r14d, %ebx
movq %r12, %rdx
movl -0x2c(%rbp), %ecx
movq %r15, %r8
movl %ebx, %r9d
callq 0x9818c
testq %rax, %rax
je 0x9b975
movl %ebx, %eax
addq %rax, %r15
addq %rax, %r12
xorl %ecx, %ecx
subl %ebx, %r14d
jne 0x9b91b
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| partitioned_key_cache_read:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r14d, r9d
mov r15, r8
mov [rbp+var_2C], ecx
mov r12, rdx
mov r13, rdi
mov ecx, [rdi+18h]
mov [rbp+var_38], 0
mov rax, rdx
xor edx, edx
div rcx
mov rcx, rdx
movsxd rax, esi
mov [rbp+var_48], rax
mov [rbp+var_40], r8
loc_9B91B:
mov ebx, [r13+18h]
mov rax, r12
xor edx, edx
div rbx
mov rsi, [rbp+var_48]
add rax, rsi
mov edi, [r13+1Ch]
xor edx, edx
div rdi
mov rax, [r13+8]
mov rdi, [rax+rdx*8]
sub ebx, ecx
cmp r14d, ebx
cmovb ebx, r14d
mov rdx, r12
mov ecx, [rbp+var_2C]
mov r8, r15
mov r9d, ebx
call simple_key_cache_read
test rax, rax
jz short loc_9B975
mov eax, ebx
add r15, rax
add r12, rax
xor ecx, ecx
sub r14d, ebx
jnz short loc_9B91B
mov rax, [rbp+var_40]
mov [rbp+var_38], rax
loc_9B975:
mov rax, [rbp+var_38]
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long partitioned_key_cache_read(
long long a1,
signed int a2,
unsigned long long a3,
unsigned int a4,
long long a5,
unsigned int a6)
{
long long v7; // r15
unsigned long long v8; // r12
unsigned long long v9; // rcx
unsigned int v10; // ebx
long long v13; // [rsp+28h] [rbp-38h]
v7 = a5;
v8 = a3;
v13 = 0LL;
v9 = a3 % *(unsigned int *)(a1 + 24);
while ( 1 )
{
v10 = *(_DWORD *)(a1 + 24) - v9;
if ( a6 < v10 )
v10 = a6;
if ( !simple_key_cache_read(
*(const __m128i **)(*(_QWORD *)(a1 + 8)
+ 8 * ((a2 + v8 / *(unsigned int *)(a1 + 24)) % *(unsigned int *)(a1 + 28))),
a2,
v8,
a4,
v7,
v10) )
break;
v7 += v10;
v8 += v10;
LODWORD(v9) = 0;
a6 -= v10;
if ( !a6 )
return a5;
}
return v13;
}
| partitioned_key_cache_read:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R14D,R9D
MOV R15,R8
MOV dword ptr [RBP + -0x2c],ECX
MOV R12,RDX
MOV R13,RDI
MOV ECX,dword ptr [RDI + 0x18]
MOV qword ptr [RBP + -0x38],0x0
MOV RAX,RDX
XOR EDX,EDX
DIV RCX
MOV RCX,RDX
MOVSXD RAX,ESI
MOV qword ptr [RBP + -0x48],RAX
MOV qword ptr [RBP + -0x40],R8
LAB_0019b91b:
MOV EBX,dword ptr [R13 + 0x18]
MOV RAX,R12
XOR EDX,EDX
DIV RBX
MOV RSI,qword ptr [RBP + -0x48]
ADD RAX,RSI
MOV EDI,dword ptr [R13 + 0x1c]
XOR EDX,EDX
DIV RDI
MOV RAX,qword ptr [R13 + 0x8]
MOV RDI,qword ptr [RAX + RDX*0x8]
SUB EBX,ECX
CMP R14D,EBX
CMOVC EBX,R14D
MOV RDX,R12
MOV ECX,dword ptr [RBP + -0x2c]
MOV R8,R15
MOV R9D,EBX
CALL 0x0019818c
TEST RAX,RAX
JZ 0x0019b975
MOV EAX,EBX
ADD R15,RAX
ADD R12,RAX
XOR ECX,ECX
SUB R14D,EBX
JNZ 0x0019b91b
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x38],RAX
LAB_0019b975:
MOV RAX,qword ptr [RBP + -0x38]
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long partitioned_key_cache_read
(long param_1,int param_2,ulong param_3,int4 param_4,long param_5,uint param_6)
{
long lVar1;
ulong uVar2;
uint uVar3;
long lVar4;
uVar2 = param_3 % (ulong)*(uint *)(param_1 + 0x18);
lVar4 = param_5;
while( true ) {
uVar3 = *(uint *)(param_1 + 0x18) - (int)uVar2;
if (param_6 < uVar3) {
uVar3 = param_6;
}
lVar1 = simple_key_cache_read
(*(int8 *)
(*(long *)(param_1 + 8) +
((param_3 / *(uint *)(param_1 + 0x18) + (long)param_2) %
(ulong)*(uint *)(param_1 + 0x1c)) * 8),(long)param_2,param_3,param_4,lVar4,
uVar3);
if (lVar1 == 0) break;
lVar4 = lVar4 + (ulong)uVar3;
param_3 = param_3 + uVar3;
uVar2 = 0;
param_6 = param_6 - uVar3;
if (param_6 == 0) {
return param_5;
}
}
return 0;
}
|
|
911 | my_strndup | eloqsql/mysys/my_malloc.c | char *my_strndup(PSI_memory_key key, const char *from, size_t length, myf my_flags)
{
char *ptr;
DBUG_ENTER("my_strndup");
if ((ptr= (char*) my_malloc(key, length+1, my_flags)))
{
memcpy(ptr, from, length);
ptr[length]= 0;
}
DBUG_RETURN(ptr);
} | O0 | c | my_strndup:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl -0x4(%rbp), %edi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
movq -0x20(%rbp), %rdx
callq 0xf3830
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xf3d72
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2a090
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0xf3d74
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_strndup:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov edi, [rbp+var_4]
mov rsi, [rbp+var_18]
add rsi, 1
mov rdx, [rbp+var_20]
call my_malloc
mov [rbp+var_28], rax
cmp rax, 0
jz short loc_F3D72
mov rdi, [rbp+var_28]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
call _memcpy
mov rax, [rbp+var_28]
mov rcx, [rbp+var_18]
mov byte ptr [rax+rcx], 0
loc_F3D72:
jmp short $+2
loc_F3D74:
mov rax, [rbp+var_28]
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
add rsp, 30h
pop rbp
retn
| long long my_strndup(unsigned int a1, long long a2, long long a3, int a4)
{
long long v5; // [rsp+8h] [rbp-28h]
v5 = my_malloc(a1, (const char *)(a3 + 1), a4);
if ( v5 )
{
memcpy(v5, a2, a3);
*(_BYTE *)(v5 + a3) = 0;
}
return v5;
}
| my_strndup:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV EDI,dword ptr [RBP + -0x4]
MOV RSI,qword ptr [RBP + -0x18]
ADD RSI,0x1
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x001f3830
MOV qword ptr [RBP + -0x28],RAX
CMP RAX,0x0
JZ 0x001f3d72
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x0012a090
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + RCX*0x1],0x0
LAB_001f3d72:
JMP 0x001f3d74
LAB_001f3d74:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RSP,0x30
POP RBP
RET
|
void * my_strndup(int4 param_1,void *param_2,size_t param_3,int8 param_4)
{
void *__dest;
__dest = (void *)my_malloc(param_1,param_3 + 1,param_4);
if (__dest != (void *)0x0) {
memcpy(__dest,param_2,param_3);
*(int1 *)((long)__dest + param_3) = 0;
}
return __dest;
}
|
|
912 | ft_linearize | eloqsql/storage/myisam/ft_parser.c | FT_WORD * ft_linearize(TREE *wtree, MEM_ROOT *mem_root)
{
FT_WORD *wlist,*p;
FT_DOCSTAT docstat;
DBUG_ENTER("ft_linearize");
if ((wlist=(FT_WORD *) alloc_root(mem_root, sizeof(FT_WORD)*
(1+wtree->elements_in_tree))))
{
docstat.list=wlist;
docstat.uniq=wtree->elements_in_tree;
docstat.sum=0;
tree_walk(wtree,(tree_walk_action)&walk_and_copy,&docstat,left_root_right);
}
delete_tree(wtree, 0);
if (!wlist)
DBUG_RETURN(NULL);
docstat.list->pos=NULL;
for (p=wlist;p->pos;p++)
{
p->weight=PRENORM_IN_USE;
}
for (p=wlist;p->pos;p++)
{
p->weight/=NORM_IN_USE;
}
DBUG_RETURN(wlist);
} | O0 | c | ft_linearize:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x20c(%rax), %eax
addl $0x1, %eax
movl %eax, %eax
imulq $0x18, %rax, %rsi
callq 0xeca30
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xa10f9
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movl 0x20c(%rax), %eax
movl %eax, -0x38(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xf2(%rip), %rsi # 0xa11e0
leaq -0x40(%rbp), %rdx
xorl %ecx, %ecx
callq 0xfb260
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0xf9af0
cmpq $0x0, -0x20(%rbp)
jne 0xa111a
jmp 0xa110d
movq $0x0, -0x8(%rbp)
jmp 0xa11c8
movq -0x40(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
je 0xa116c
movq -0x28(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd -0x30(%rbp), %xmm1
divsd %xmm1, %xmm0
movl -0x38(%rbp), %eax
cvtsi2sd %rax, %xmm1
mulsd %xmm1, %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x28(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x28(%rbp)
jmp 0xa112d
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
je 0xa11be
movl -0x38(%rbp), %eax
cvtsi2sd %rax, %xmm1
movsd 0xaeea2(%rip), %xmm0 # 0x150030
mulsd %xmm0, %xmm1
movsd 0xaee8e(%rip), %xmm0 # 0x150028
addsd %xmm0, %xmm1
movq -0x28(%rbp), %rax
movsd 0x8(%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x28(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x28(%rbp)
jmp 0xa1174
jmp 0xa11c0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| ft_linearize:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rdi, [rbp+var_18]
mov rax, [rbp+var_10]
mov eax, [rax+20Ch]
add eax, 1
mov eax, eax
imul rsi, rax, 18h
call alloc_root
mov [rbp+var_20], rax
cmp rax, 0
jz short loc_A10F9
mov rax, [rbp+var_20]
mov [rbp+var_40], rax
mov rax, [rbp+var_10]
mov eax, [rax+20Ch]
mov [rbp+var_38], eax
xorps xmm0, xmm0
movsd [rbp+var_30], xmm0
mov rdi, [rbp+var_10]
lea rsi, walk_and_copy_1
lea rdx, [rbp+var_40]
xor ecx, ecx
call tree_walk
loc_A10F9:
mov rdi, [rbp+var_10]
xor esi, esi
call delete_tree
cmp [rbp+var_20], 0
jnz short loc_A111A
jmp short $+2
loc_A110D:
mov [rbp+var_8], 0
jmp loc_A11C8
loc_A111A:
mov rax, [rbp+var_40]
mov qword ptr [rax], 0
mov rax, [rbp+var_20]
mov [rbp+var_28], rax
loc_A112D:
mov rax, [rbp+var_28]
cmp qword ptr [rax], 0
jz short loc_A116C
mov rax, [rbp+var_28]
movsd xmm0, qword ptr [rax+8]
movsd xmm1, [rbp+var_30]
divsd xmm0, xmm1
mov eax, [rbp+var_38]
cvtsi2sd xmm1, rax
mulsd xmm0, xmm1
mov rax, [rbp+var_28]
movsd qword ptr [rax+8], xmm0
mov rax, [rbp+var_28]
add rax, 18h
mov [rbp+var_28], rax
jmp short loc_A112D
loc_A116C:
mov rax, [rbp+var_20]
mov [rbp+var_28], rax
loc_A1174:
mov rax, [rbp+var_28]
cmp qword ptr [rax], 0
jz short loc_A11BE
mov eax, [rbp+var_38]
cvtsi2sd xmm1, rax
movsd xmm0, cs:qword_150030
mulsd xmm1, xmm0
movsd xmm0, cs:qword_150028
addsd xmm1, xmm0
mov rax, [rbp+var_28]
movsd xmm0, qword ptr [rax+8]
divsd xmm0, xmm1
movsd qword ptr [rax+8], xmm0
mov rax, [rbp+var_28]
add rax, 18h
mov [rbp+var_28], rax
jmp short loc_A1174
loc_A11BE:
jmp short $+2
loc_A11C0:
mov rax, [rbp+var_20]
mov [rbp+var_8], rax
loc_A11C8:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
| long long ft_linearize(long long a1, long long a2)
{
_QWORD *v3; // [rsp+0h] [rbp-40h] BYREF
int v4; // [rsp+8h] [rbp-38h]
double v5; // [rsp+10h] [rbp-30h]
long long i; // [rsp+18h] [rbp-28h]
long long v7; // [rsp+20h] [rbp-20h]
long long v8; // [rsp+28h] [rbp-18h]
long long v9; // [rsp+30h] [rbp-10h]
v9 = a1;
v8 = a2;
v7 = alloc_root(a2, 24LL * (unsigned int)(*(_DWORD *)(a1 + 524) + 1));
if ( v7 )
{
v3 = (_QWORD *)v7;
v4 = *(_DWORD *)(v9 + 524);
v5 = 0.0;
tree_walk(v9, walk_and_copy_1, &v3, 0LL);
}
delete_tree(v9, 0LL);
if ( !v7 )
return 0LL;
*v3 = 0LL;
for ( i = v7; *(_QWORD *)i; i += 24LL )
*(double *)(i + 8) = *(double *)(i + 8) / v5 * (double)v4;
for ( i = v7; *(_QWORD *)i; i += 24LL )
*(double *)(i + 8) = *(double *)(i + 8) / ((double)v4 * 0.0115 + 1.0);
return v7;
}
| ft_linearize:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x20c]
ADD EAX,0x1
MOV EAX,EAX
IMUL RSI,RAX,0x18
CALL 0x001eca30
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JZ 0x001a10f9
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x20c]
MOV dword ptr [RBP + -0x38],EAX
XORPS XMM0,XMM0
MOVSD qword ptr [RBP + -0x30],XMM0
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x1a11e0]
LEA RDX,[RBP + -0x40]
XOR ECX,ECX
CALL 0x001fb260
LAB_001a10f9:
MOV RDI,qword ptr [RBP + -0x10]
XOR ESI,ESI
CALL 0x001f9af0
CMP qword ptr [RBP + -0x20],0x0
JNZ 0x001a111a
JMP 0x001a110d
LAB_001a110d:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001a11c8
LAB_001a111a:
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x28],RAX
LAB_001a112d:
MOV RAX,qword ptr [RBP + -0x28]
CMP qword ptr [RAX],0x0
JZ 0x001a116c
MOV RAX,qword ptr [RBP + -0x28]
MOVSD XMM0,qword ptr [RAX + 0x8]
MOVSD XMM1,qword ptr [RBP + -0x30]
DIVSD XMM0,XMM1
MOV EAX,dword ptr [RBP + -0x38]
CVTSI2SD XMM1,RAX
MULSD XMM0,XMM1
MOV RAX,qword ptr [RBP + -0x28]
MOVSD qword ptr [RAX + 0x8],XMM0
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x18
MOV qword ptr [RBP + -0x28],RAX
JMP 0x001a112d
LAB_001a116c:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x28],RAX
LAB_001a1174:
MOV RAX,qword ptr [RBP + -0x28]
CMP qword ptr [RAX],0x0
JZ 0x001a11be
MOV EAX,dword ptr [RBP + -0x38]
CVTSI2SD XMM1,RAX
MOVSD XMM0,qword ptr [0x00250030]
MULSD XMM1,XMM0
MOVSD XMM0,qword ptr [0x00250028]
ADDSD XMM1,XMM0
MOV RAX,qword ptr [RBP + -0x28]
MOVSD XMM0,qword ptr [RAX + 0x8]
DIVSD XMM0,XMM1
MOVSD qword ptr [RAX + 0x8],XMM0
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x18
MOV qword ptr [RBP + -0x28],RAX
JMP 0x001a1174
LAB_001a11be:
JMP 0x001a11c0
LAB_001a11c0:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x8],RAX
LAB_001a11c8:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
long * ft_linearize(long param_1,int8 param_2)
{
long *local_48;
uint local_40;
double local_38;
long *local_30;
long *local_28;
int8 local_20;
long local_18;
long *local_10;
local_20 = param_2;
local_18 = param_1;
local_28 = (long *)alloc_root(param_2,(ulong)(*(int *)(param_1 + 0x20c) + 1) * 0x18);
if (local_28 != (long *)0x0) {
local_40 = *(uint *)(local_18 + 0x20c);
local_38 = 0.0;
local_48 = local_28;
tree_walk(local_18,walk_and_copy,&local_48,0);
}
delete_tree(local_18,0);
if (local_28 == (long *)0x0) {
local_10 = (long *)0x0;
}
else {
*local_48 = 0;
for (local_30 = local_28; *local_30 != 0; local_30 = local_30 + 3) {
local_30[1] = (long)(((double)local_30[1] / local_38) * (double)local_40);
}
for (local_30 = local_28; *local_30 != 0; local_30 = local_30 + 3) {
local_30[1] = (long)((double)local_30[1] / ((double)local_40 * DAT_00250030 + DAT_00250028));
}
local_10 = local_28;
}
return local_10;
}
|
|
913 | ft_linearize | eloqsql/storage/myisam/ft_parser.c | FT_WORD * ft_linearize(TREE *wtree, MEM_ROOT *mem_root)
{
FT_WORD *wlist,*p;
FT_DOCSTAT docstat;
DBUG_ENTER("ft_linearize");
if ((wlist=(FT_WORD *) alloc_root(mem_root, sizeof(FT_WORD)*
(1+wtree->elements_in_tree))))
{
docstat.list=wlist;
docstat.uniq=wtree->elements_in_tree;
docstat.sum=0;
tree_walk(wtree,(tree_walk_action)&walk_and_copy,&docstat,left_root_right);
}
delete_tree(wtree, 0);
if (!wlist)
DBUG_RETURN(NULL);
docstat.list->pos=NULL;
for (p=wlist;p->pos;p++)
{
p->weight=PRENORM_IN_USE;
}
for (p=wlist;p->pos;p++)
{
p->weight/=NORM_IN_USE;
}
DBUG_RETURN(wlist);
} | O3 | c | ft_linearize:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rax
movq %rdi, %r14
movl 0x20c(%rdi), %ecx
incl %ecx
shlq $0x3, %rcx
leaq (%rcx,%rcx,2), %rsi
movq %rax, %rdi
callq 0x9c5cb
movq %rax, %rbx
testq %rax, %rax
je 0x73124
leaq -0x38(%rbp), %r15
movq %rbx, (%r15)
movl 0x20c(%r14), %eax
movl %eax, 0x8(%r15)
xorl %r12d, %r12d
movq %r12, 0x10(%r15)
leaq 0xa9(%rip), %rsi # 0x7313e
movq %r14, %rdi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0xa4b93
movq %r14, %rdi
xorl %esi, %esi
callq 0xa402e
movq (%r15), %rax
movq %r12, (%rax)
cmpq %r12, (%rbx)
je 0x7312e
movsd -0x28(%rbp), %xmm0
movl -0x30(%rbp), %eax
cvtsi2sd %rax, %xmm1
leaq 0x8(%rbx), %rax
movsd (%rax), %xmm2
divsd %xmm0, %xmm2
mulsd %xmm1, %xmm2
movsd %xmm2, (%rax)
cmpq $0x0, 0x10(%rax)
leaq 0x18(%rax), %rax
jne 0x730c8
cmpq $0x0, (%rbx)
je 0x7312e
movl -0x30(%rbp), %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
mulsd 0x650b4(%rip), %xmm0 # 0xd81b0
addsd 0x650b4(%rip), %xmm0 # 0xd81b8
movq %rbx, %rax
addq $0x8, %rax
movsd (%rax), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rax)
cmpq $0x0, 0x10(%rax)
leaq 0x18(%rax), %rax
jne 0x7310b
jmp 0x7312e
movq %r14, %rdi
xorl %esi, %esi
callq 0xa402e
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| ft_linearize:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 20h
mov rax, rsi
mov r14, rdi
mov ecx, [rdi+20Ch]
inc ecx
shl rcx, 3
lea rsi, [rcx+rcx*2]
mov rdi, rax
call alloc_root
mov rbx, rax
test rax, rax
jz loc_73124
lea r15, [rbp+var_38]
mov [r15], rbx
mov eax, [r14+20Ch]
mov [r15+8], eax
xor r12d, r12d
mov [r15+10h], r12
lea rsi, walk_and_copy_1
mov rdi, r14
mov rdx, r15
xor ecx, ecx
call tree_walk
mov rdi, r14
xor esi, esi
call delete_tree
mov rax, [r15]
mov [rax], r12
cmp [rbx], r12
jz short loc_7312E
movsd xmm0, [rbp+var_28]
mov eax, [rbp+var_30]
cvtsi2sd xmm1, rax
lea rax, [rbx+8]
loc_730C8:
movsd xmm2, qword ptr [rax]
divsd xmm2, xmm0
mulsd xmm2, xmm1
movsd qword ptr [rax], xmm2
cmp qword ptr [rax+10h], 0
lea rax, [rax+18h]
jnz short loc_730C8
cmp qword ptr [rbx], 0
jz short loc_7312E
mov eax, [rbp+var_30]
xorps xmm0, xmm0
cvtsi2sd xmm0, rax
mulsd xmm0, cs:qword_D81B0
addsd xmm0, cs:qword_D81B8
mov rax, rbx
add rax, 8
loc_7310B:
movsd xmm1, qword ptr [rax]
divsd xmm1, xmm0
movsd qword ptr [rax], xmm1
cmp qword ptr [rax+10h], 0
lea rax, [rax+18h]
jnz short loc_7310B
jmp short loc_7312E
loc_73124:
mov rdi, r14
xor esi, esi
call delete_tree
loc_7312E:
mov rax, rbx
add rsp, 20h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| _QWORD * ft_linearize(long long a1, long long a2)
{
long long v2; // rax
_QWORD *v3; // rbx
double v4; // xmm0_8
double v5; // xmm1_8
double *v6; // rax
bool v7; // zf
double v8; // xmm0_8
double *v9; // rax
_QWORD *v11; // [rsp+8h] [rbp-38h] BYREF
int v12; // [rsp+10h] [rbp-30h]
double v13; // [rsp+18h] [rbp-28h]
v2 = alloc_root(a2, 24LL * (unsigned int)(*(_DWORD *)(a1 + 524) + 1));
v3 = (_QWORD *)v2;
if ( v2 )
{
v11 = (_QWORD *)v2;
v12 = *(_DWORD *)(a1 + 524);
v13 = 0.0;
tree_walk(a1, walk_and_copy_1, &v11, 0LL);
delete_tree(a1, 0LL);
*v11 = 0LL;
if ( *v3 )
{
v4 = v13;
v5 = (double)v12;
v6 = (double *)(v3 + 1);
do
{
*v6 = *v6 / v4 * v5;
v7 = *((_QWORD *)v6 + 2) == 0LL;
v6 += 3;
}
while ( !v7 );
if ( *v3 )
{
v8 = (double)v12 * 0.0115 + 1.0;
v9 = (double *)(v3 + 1);
do
{
*v9 = *v9 / v8;
v7 = *((_QWORD *)v9 + 2) == 0LL;
v9 += 3;
}
while ( !v7 );
}
}
}
else
{
delete_tree(a1, 0LL);
}
return v3;
}
| ft_linearize:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x20
MOV RAX,RSI
MOV R14,RDI
MOV ECX,dword ptr [RDI + 0x20c]
INC ECX
SHL RCX,0x3
LEA RSI,[RCX + RCX*0x2]
MOV RDI,RAX
CALL 0x0019c5cb
MOV RBX,RAX
TEST RAX,RAX
JZ 0x00173124
LEA R15,[RBP + -0x38]
MOV qword ptr [R15],RBX
MOV EAX,dword ptr [R14 + 0x20c]
MOV dword ptr [R15 + 0x8],EAX
XOR R12D,R12D
MOV qword ptr [R15 + 0x10],R12
LEA RSI,[0x17313e]
MOV RDI,R14
MOV RDX,R15
XOR ECX,ECX
CALL 0x001a4b93
MOV RDI,R14
XOR ESI,ESI
CALL 0x001a402e
MOV RAX,qword ptr [R15]
MOV qword ptr [RAX],R12
CMP qword ptr [RBX],R12
JZ 0x0017312e
MOVSD XMM0,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RBP + -0x30]
CVTSI2SD XMM1,RAX
LEA RAX,[RBX + 0x8]
LAB_001730c8:
MOVSD XMM2,qword ptr [RAX]
DIVSD XMM2,XMM0
MULSD XMM2,XMM1
MOVSD qword ptr [RAX],XMM2
CMP qword ptr [RAX + 0x10],0x0
LEA RAX,[RAX + 0x18]
JNZ 0x001730c8
CMP qword ptr [RBX],0x0
JZ 0x0017312e
MOV EAX,dword ptr [RBP + -0x30]
XORPS XMM0,XMM0
CVTSI2SD XMM0,RAX
MULSD XMM0,qword ptr [0x001d81b0]
ADDSD XMM0,qword ptr [0x001d81b8]
MOV RAX,RBX
ADD RAX,0x8
LAB_0017310b:
MOVSD XMM1,qword ptr [RAX]
DIVSD XMM1,XMM0
MOVSD qword ptr [RAX],XMM1
CMP qword ptr [RAX + 0x10],0x0
LEA RAX,[RAX + 0x18]
JNZ 0x0017310b
JMP 0x0017312e
LAB_00173124:
MOV RDI,R14
XOR ESI,ESI
CALL 0x001a402e
LAB_0017312e:
MOV RAX,RBX
ADD RSP,0x20
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
long * ft_linearize(long param_1,int8 param_2)
{
double *pdVar1;
long *plVar2;
double *pdVar3;
double dVar4;
long *local_40;
uint local_38;
double local_30;
plVar2 = (long *)alloc_root(param_2,(ulong)(*(int *)(param_1 + 0x20c) + 1) * 0x18);
if (plVar2 == (long *)0x0) {
delete_tree(param_1,0);
}
else {
local_38 = *(uint *)(param_1 + 0x20c);
local_30 = 0.0;
local_40 = plVar2;
tree_walk(param_1,walk_and_copy,&local_40,0);
delete_tree(param_1,0);
*local_40 = 0;
if (*plVar2 != 0) {
pdVar3 = (double *)(plVar2 + 1);
do {
*pdVar3 = (*pdVar3 / local_30) * (double)local_38;
pdVar1 = pdVar3 + 2;
pdVar3 = pdVar3 + 3;
} while (*pdVar1 != 0.0);
if (*plVar2 != 0) {
dVar4 = (double)local_38 * _DAT_001d81b0 + DAT_001d81b8;
pdVar3 = (double *)(plVar2 + 1);
do {
*pdVar3 = *pdVar3 / dVar4;
pdVar1 = pdVar3 + 2;
pdVar3 = pdVar3 + 3;
} while (*pdVar1 != 0.0);
}
}
}
return plVar2;
}
|
|
914 | void OpenSubdiv::v3_6_0::Far::internal::(anonymous namespace)::evalBSplineCurve<float>(float, float*, float*, float*) | NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/patchBasis.cpp | void
evalBSplineCurve(REAL t, REAL wP[4], REAL wDP[4], REAL wDP2[4]) {
REAL const one6th = (REAL)(1.0 / 6.0);
REAL t2 = t * t;
REAL t3 = t * t2;
wP[0] = one6th * (1.0f - 3.0f*(t - t2) - t3);
wP[1] = one6th * (4.0f - 6.0f*t2 + 3.0f*t3);
wP[2] = one6th * (1.0f + 3.0f*(t + t2 - t3));
wP[3] = one6th * ( t3);
if (wDP) {
wDP[0] = -0.5f*t2 + t - 0.5f;
wDP[1] = 1.5f*t2 - 2.0f*t;
wDP[2] = -1.5f*t2 + t + 0.5f;
wDP[3] = 0.5f*t2;
}
if (wDP2) {
wDP2[0] = - t + 1.0f;
wDP2[1] = 3.0f * t - 2.0f;
wDP2[2] = -3.0f * t + 1.0f;
wDP2[3] = t;
}
} | O0 | cpp | void OpenSubdiv::v3_6_0::Far::internal::(anonymous namespace)::evalBSplineCurve<float>(float, float*, float*, float*):
pushq %rbp
movq %rsp, %rbp
movss %xmm0, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movss 0xc20d3(%rip), %xmm0 # 0x1ec560
movss %xmm0, -0x24(%rbp)
movss -0x4(%rbp), %xmm0
mulss -0x4(%rbp), %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x4(%rbp), %xmm0
mulss -0x28(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x4(%rbp), %xmm1
subss -0x28(%rbp), %xmm1
movss 0xc3b1a(%rip), %xmm0 # 0x1edfdc
mulss %xmm0, %xmm1
movss 0xbfb32(%rip), %xmm0 # 0x1ea000
addss %xmm0, %xmm1
subss -0x2c(%rbp), %xmm1
movss 0xc2081(%rip), %xmm0 # 0x1ec560
mulss %xmm1, %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, (%rax)
movss -0x28(%rbp), %xmm0
movss 0xc3ae0(%rip), %xmm1 # 0x1edfd8
mulss %xmm1, %xmm0
movss 0xc207c(%rip), %xmm1 # 0x1ec580
addss %xmm1, %xmm0
movss -0x2c(%rbp), %xmm1
movss 0xc2063(%rip), %xmm2 # 0x1ec578
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movss 0xc203b(%rip), %xmm0 # 0x1ec560
mulss %xmm1, %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x4(%rax)
movss -0x4(%rbp), %xmm1
addss -0x28(%rbp), %xmm1
subss -0x2c(%rbp), %xmm1
movss 0xc202f(%rip), %xmm0 # 0x1ec578
mulss %xmm0, %xmm1
movss 0xbfaab(%rip), %xmm0 # 0x1ea000
addss %xmm0, %xmm1
movss 0xc1fff(%rip), %xmm0 # 0x1ec560
mulss %xmm1, %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x8(%rax)
movss 0xc1fea(%rip), %xmm0 # 0x1ec560
mulss -0x2c(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0xc(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x12a63a
movss -0x28(%rbp), %xmm0
movss -0x4(%rbp), %xmm1
movss 0xc3a2b(%rip), %xmm2 # 0x1edfcc
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss 0xc3a0b(%rip), %xmm1 # 0x1edfbc
subss %xmm1, %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, (%rax)
movss -0x28(%rbp), %xmm0
movss 0xc1fb2(%rip), %xmm1 # 0x1ec57c
mulss -0x4(%rbp), %xmm1
movd %xmm1, %eax
xorl $0x80000000, %eax # imm = 0x80000000
movd %eax, %xmm1
movss 0xc39f0(%rip), %xmm2 # 0x1edfd4
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x4(%rax)
movss -0x28(%rbp), %xmm0
movss -0x4(%rbp), %xmm1
movss 0xc39c9(%rip), %xmm2 # 0x1edfd0
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss 0xc39a5(%rip), %xmm1 # 0x1edfbc
addss %xmm1, %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x8(%rax)
movss 0xc3990(%rip), %xmm0 # 0x1edfbc
mulss -0x28(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0xc(%rax)
cmpq $0x0, -0x20(%rbp)
je 0x12a6c5
movss -0x4(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax # imm = 0x80000000
movd %eax, %xmm0
movss 0xbf9a1(%rip), %xmm1 # 0x1ea000
addss %xmm1, %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, (%rax)
movss -0x4(%rbp), %xmm0
movss 0xc1f00(%rip), %xmm1 # 0x1ec578
mulss %xmm1, %xmm0
movss 0xc52b0(%rip), %xmm1 # 0x1ef934
addss %xmm1, %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x4(%rax)
movss -0x4(%rbp), %xmm0
movss 0xc393e(%rip), %xmm1 # 0x1edfdc
mulss %xmm1, %xmm0
movss 0xbf956(%rip), %xmm1 # 0x1ea000
addss %xmm1, %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x8(%rax)
movss -0x4(%rbp), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0xc(%rax)
popq %rbp
retq
nopw (%rax,%rax)
| _ZN10OpenSubdiv6v3_6_03Far8internal12_GLOBAL__N_116evalBSplineCurveIfEEvT_PS5_S6_S6_:
push rbp
mov rbp, rsp
movss [rbp+var_4], xmm0
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
movss xmm0, cs:dword_1EC560
movss [rbp+var_24], xmm0
movss xmm0, [rbp+var_4]
mulss xmm0, [rbp+var_4]
movss [rbp+var_28], xmm0
movss xmm0, [rbp+var_4]
mulss xmm0, [rbp+var_28]
movss [rbp+var_2C], xmm0
movss xmm1, [rbp+var_4]
subss xmm1, [rbp+var_28]
movss xmm0, cs:dword_1EDFDC
mulss xmm1, xmm0
movss xmm0, cs:dword_1EA000
addss xmm1, xmm0
subss xmm1, [rbp+var_2C]
movss xmm0, cs:dword_1EC560
mulss xmm0, xmm1
mov rax, [rbp+var_10]
movss dword ptr [rax], xmm0
movss xmm0, [rbp+var_28]
movss xmm1, cs:dword_1EDFD8
mulss xmm0, xmm1
movss xmm1, cs:dword_1EC580
addss xmm0, xmm1
movss xmm1, [rbp+var_2C]
movss xmm2, cs:dword_1EC578
mulss xmm1, xmm2
addss xmm1, xmm0
movss xmm0, cs:dword_1EC560
mulss xmm0, xmm1
mov rax, [rbp+var_10]
movss dword ptr [rax+4], xmm0
movss xmm1, [rbp+var_4]
addss xmm1, [rbp+var_28]
subss xmm1, [rbp+var_2C]
movss xmm0, cs:dword_1EC578
mulss xmm1, xmm0
movss xmm0, cs:dword_1EA000
addss xmm1, xmm0
movss xmm0, cs:dword_1EC560
mulss xmm0, xmm1
mov rax, [rbp+var_10]
movss dword ptr [rax+8], xmm0
movss xmm0, cs:dword_1EC560
mulss xmm0, [rbp+var_2C]
mov rax, [rbp+var_10]
movss dword ptr [rax+0Ch], xmm0
cmp [rbp+var_18], 0
jz loc_12A63A
movss xmm0, [rbp+var_28]
movss xmm1, [rbp+var_4]
movss xmm2, cs:dword_1EDFCC
mulss xmm0, xmm2
addss xmm0, xmm1
movss xmm1, cs:dword_1EDFBC
subss xmm0, xmm1
mov rax, [rbp+var_18]
movss dword ptr [rax], xmm0
movss xmm0, [rbp+var_28]
movss xmm1, cs:dword_1EC57C
mulss xmm1, [rbp+var_4]
movd eax, xmm1
xor eax, 80000000h
movd xmm1, eax
movss xmm2, cs:dword_1EDFD4
mulss xmm0, xmm2
addss xmm0, xmm1
mov rax, [rbp+var_18]
movss dword ptr [rax+4], xmm0
movss xmm0, [rbp+var_28]
movss xmm1, [rbp+var_4]
movss xmm2, cs:dword_1EDFD0
mulss xmm0, xmm2
addss xmm0, xmm1
movss xmm1, cs:dword_1EDFBC
addss xmm0, xmm1
mov rax, [rbp+var_18]
movss dword ptr [rax+8], xmm0
movss xmm0, cs:dword_1EDFBC
mulss xmm0, [rbp+var_28]
mov rax, [rbp+var_18]
movss dword ptr [rax+0Ch], xmm0
loc_12A63A:
cmp [rbp+var_20], 0
jz loc_12A6C5
movss xmm0, [rbp+var_4]
movd eax, xmm0
xor eax, 80000000h
movd xmm0, eax
movss xmm1, cs:dword_1EA000
addss xmm0, xmm1
mov rax, [rbp+var_20]
movss dword ptr [rax], xmm0
movss xmm0, [rbp+var_4]
movss xmm1, cs:dword_1EC578
mulss xmm0, xmm1
movss xmm1, cs:dword_1EF934
addss xmm0, xmm1
mov rax, [rbp+var_20]
movss dword ptr [rax+4], xmm0
movss xmm0, [rbp+var_4]
movss xmm1, cs:dword_1EDFDC
mulss xmm0, xmm1
movss xmm1, cs:dword_1EA000
addss xmm0, xmm1
mov rax, [rbp+var_20]
movss dword ptr [rax+8], xmm0
movss xmm0, [rbp+var_4]
mov rax, [rbp+var_20]
movss dword ptr [rax+0Ch], xmm0
loc_12A6C5:
pop rbp
retn
| float * OpenSubdiv::v3_6_0::Far::internal::`anonymous namespace'::evalBSplineCurve<float>(
float *a1,
float *a2,
float *a3,
float a4)
{
float *result; // rax
__m128i v5; // xmm1
float v6; // [rsp+0h] [rbp-2Ch]
float v7; // [rsp+4h] [rbp-28h]
v7 = a4 * a4;
v6 = a4 * (float)(a4 * a4);
*a1 = 0.16666667 * (float)((float)((float)((float)(a4 - (float)(a4 * a4)) * -3.0) + 1.0) - v6);
a1[1] = 0.16666667 * (float)((float)(v6 * 3.0) + (float)((float)((float)(a4 * a4) * -6.0) + 4.0));
a1[2] = 0.16666667 * (float)((float)((float)((float)(a4 + (float)(a4 * a4)) - v6) * 3.0) + 1.0);
result = a1;
a1[3] = 0.16666667 * v6;
if ( a2 )
{
*a2 = (float)((float)(v7 * -0.5) + a4) - 0.5;
v5 = (__m128i)0x40000000u;
*(float *)v5.m128i_i32 = 2.0 * a4;
a2[1] = (float)(v7 * 1.5) + COERCE_FLOAT(_mm_cvtsi128_si32(v5) ^ 0x80000000);
a2[2] = (float)((float)(v7 * -1.5) + a4) + 0.5;
result = a2;
a2[3] = 0.5 * v7;
}
if ( a3 )
{
*a3 = COERCE_FLOAT(_mm_cvtsi128_si32((__m128i)LODWORD(a4)) ^ 0x80000000) + 1.0;
a3[1] = (float)(a4 * 3.0) + -2.0;
a3[2] = (float)(a4 * -3.0) + 1.0;
result = a3;
a3[3] = a4;
}
return result;
}
| |||
915 | void OpenSubdiv::v3_6_0::Far::internal::(anonymous namespace)::evalBSplineCurve<float>(float, float*, float*, float*) | NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/patchBasis.cpp | void
evalBSplineCurve(REAL t, REAL wP[4], REAL wDP[4], REAL wDP2[4]) {
REAL const one6th = (REAL)(1.0 / 6.0);
REAL t2 = t * t;
REAL t3 = t * t2;
wP[0] = one6th * (1.0f - 3.0f*(t - t2) - t3);
wP[1] = one6th * (4.0f - 6.0f*t2 + 3.0f*t3);
wP[2] = one6th * (1.0f + 3.0f*(t + t2 - t3));
wP[3] = one6th * ( t3);
if (wDP) {
wDP[0] = -0.5f*t2 + t - 0.5f;
wDP[1] = 1.5f*t2 - 2.0f*t;
wDP[2] = -1.5f*t2 + t + 0.5f;
wDP[3] = 0.5f*t2;
}
if (wDP2) {
wDP2[0] = - t + 1.0f;
wDP2[1] = 3.0f * t - 2.0f;
wDP2[2] = -3.0f * t + 1.0f;
wDP2[3] = t;
}
} | O1 | cpp | void OpenSubdiv::v3_6_0::Far::internal::(anonymous namespace)::evalBSplineCurve<float>(float, float*, float*, float*):
movapd %xmm0, %xmm2
mulsd %xmm0, %xmm2
movapd %xmm2, %xmm3
mulsd %xmm0, %xmm3
movapd %xmm0, %xmm4
subsd %xmm2, %xmm4
mulsd 0x56ae0(%rip), %xmm4 # 0xb5f20
movsd 0x550a0(%rip), %xmm1 # 0xb44e8
addsd %xmm1, %xmm4
subsd %xmm3, %xmm4
movsd 0x550e8(%rip), %xmm5 # 0xb4540
mulsd %xmm5, %xmm4
movsd %xmm4, (%rdi)
movsd 0x56ac0(%rip), %xmm4 # 0xb5f28
mulsd %xmm2, %xmm4
addsd 0x550a4(%rip), %xmm4 # 0xb4518
movsd 0x550ac(%rip), %xmm6 # 0xb4528
movapd %xmm3, %xmm7
mulsd %xmm6, %xmm7
addsd %xmm4, %xmm7
mulsd %xmm5, %xmm7
movsd %xmm7, 0x8(%rdi)
movapd %xmm2, %xmm4
addsd %xmm0, %xmm4
subsd %xmm3, %xmm4
mulsd %xmm6, %xmm4
addsd %xmm1, %xmm4
mulsd %xmm5, %xmm4
movsd %xmm4, 0x10(%rdi)
mulsd %xmm5, %xmm3
movsd %xmm3, 0x18(%rdi)
testq %rsi, %rsi
je 0x5f51f
movsd 0x5833c(%rip), %xmm3 # 0xb7800
movapd %xmm2, %xmm4
mulsd %xmm3, %xmm4
addsd %xmm0, %xmm4
addsd %xmm3, %xmm4
movsd %xmm4, (%rsi)
movapd %xmm0, %xmm3
addsd %xmm0, %xmm3
movsd 0x58320(%rip), %xmm4 # 0xb7808
mulsd %xmm2, %xmm4
subsd %xmm3, %xmm4
movsd %xmm4, 0x8(%rsi)
movsd 0x58313(%rip), %xmm3 # 0xb7810
mulsd %xmm2, %xmm3
addsd %xmm0, %xmm3
movsd 0x55003(%rip), %xmm4 # 0xb4510
addsd %xmm4, %xmm3
movsd %xmm3, 0x10(%rsi)
mulsd %xmm4, %xmm2
movsd %xmm2, 0x18(%rsi)
testq %rdx, %rdx
je 0x5f563
movapd %xmm1, %xmm2
subsd %xmm0, %xmm2
movsd %xmm2, (%rdx)
movsd 0x54ff0(%rip), %xmm2 # 0xb4528
mulsd %xmm0, %xmm2
addsd 0x582d4(%rip), %xmm2 # 0xb7818
movsd %xmm2, 0x8(%rdx)
movsd 0x569cf(%rip), %xmm2 # 0xb5f20
mulsd %xmm0, %xmm2
addsd %xmm1, %xmm2
movsd %xmm2, 0x10(%rdx)
movsd %xmm0, 0x18(%rdx)
retq
| _ZN10OpenSubdiv6v3_6_03Far8internal12_GLOBAL__N_116evalBSplineCurveIdEEvT_PS5_S6_S6_:
movapd xmm2, xmm0
mulsd xmm2, xmm0
movapd xmm3, xmm2
mulsd xmm3, xmm0
movapd xmm4, xmm0
subsd xmm4, xmm2
mulsd xmm4, cs:qword_B5F20
movsd xmm1, cs:qword_B44E8
addsd xmm4, xmm1
subsd xmm4, xmm3
movsd xmm5, cs:qword_B4540
mulsd xmm4, xmm5
movsd qword ptr [rdi], xmm4
movsd xmm4, cs:qword_B5F28
mulsd xmm4, xmm2
addsd xmm4, cs:qword_B4518
movsd xmm6, cs:qword_B4528
movapd xmm7, xmm3
mulsd xmm7, xmm6
addsd xmm7, xmm4
mulsd xmm7, xmm5
movsd qword ptr [rdi+8], xmm7
movapd xmm4, xmm2
addsd xmm4, xmm0
subsd xmm4, xmm3
mulsd xmm4, xmm6
addsd xmm4, xmm1
mulsd xmm4, xmm5
movsd qword ptr [rdi+10h], xmm4
mulsd xmm3, xmm5
movsd qword ptr [rdi+18h], xmm3
test rsi, rsi
jz short loc_5F51F
movsd xmm3, cs:qword_B7800
movapd xmm4, xmm2
mulsd xmm4, xmm3
addsd xmm4, xmm0
addsd xmm4, xmm3
movsd qword ptr [rsi], xmm4
movapd xmm3, xmm0
addsd xmm3, xmm0
movsd xmm4, cs:qword_B7808
mulsd xmm4, xmm2
subsd xmm4, xmm3
movsd qword ptr [rsi+8], xmm4
movsd xmm3, cs:qword_B7810
mulsd xmm3, xmm2
addsd xmm3, xmm0
movsd xmm4, cs:qword_B4510
addsd xmm3, xmm4
movsd qword ptr [rsi+10h], xmm3
mulsd xmm2, xmm4
movsd qword ptr [rsi+18h], xmm2
loc_5F51F:
test rdx, rdx
jz short locret_5F563
movapd xmm2, xmm1
subsd xmm2, xmm0
movsd qword ptr [rdx], xmm2
movsd xmm2, cs:qword_B4528
mulsd xmm2, xmm0
addsd xmm2, cs:qword_B7818
movsd qword ptr [rdx+8], xmm2
movsd xmm2, cs:qword_B5F20
mulsd xmm2, xmm0
addsd xmm2, xmm1
movsd qword ptr [rdx+10h], xmm2
movsd qword ptr [rdx+18h], xmm0
locret_5F563:
retn
| void OpenSubdiv::v3_6_0::Far::internal::`anonymous namespace'::evalBSplineCurve<double>(
double *a1,
double *a2,
double *a3,
double a4)
{
double v4; // xmm2_8
double v5; // xmm3_8
v4 = a4 * a4;
v5 = a4 * a4 * a4;
*a1 = ((a4 - a4 * a4) * -3.0 + 1.0 - v5) * 0.1666666666666667;
a1[1] = (v5 * 3.0 + -6.0 * (a4 * a4) + 4.0) * 0.1666666666666667;
a1[2] = ((a4 * a4 + a4 - v5) * 3.0 + 1.0) * 0.1666666666666667;
a1[3] = v5 * 0.1666666666666667;
if ( a2 )
{
*a2 = v4 * -0.5 + a4 + -0.5;
a2[1] = 1.5 * v4 - (a4 + a4);
a2[2] = -1.5 * v4 + a4 + 0.5;
a2[3] = v4 * 0.5;
}
if ( a3 )
{
*a3 = 1.0 - a4;
a3[1] = 3.0 * a4 + -2.0;
a3[2] = -3.0 * a4 + 1.0;
a3[3] = a4;
}
}
| evalBSplineCurve<double>:
MOVAPD XMM2,XMM0
MULSD XMM2,XMM0
MOVAPD XMM3,XMM2
MULSD XMM3,XMM0
MOVAPD XMM4,XMM0
SUBSD XMM4,XMM2
MULSD XMM4,qword ptr [0x001b5f20]
MOVSD XMM1,qword ptr [0x001b44e8]
ADDSD XMM4,XMM1
SUBSD XMM4,XMM3
MOVSD XMM5,qword ptr [0x001b4540]
MULSD XMM4,XMM5
MOVSD qword ptr [RDI],XMM4
MOVSD XMM4,qword ptr [0x001b5f28]
MULSD XMM4,XMM2
ADDSD XMM4,qword ptr [0x001b4518]
MOVSD XMM6,qword ptr [0x001b4528]
MOVAPD XMM7,XMM3
MULSD XMM7,XMM6
ADDSD XMM7,XMM4
MULSD XMM7,XMM5
MOVSD qword ptr [RDI + 0x8],XMM7
MOVAPD XMM4,XMM2
ADDSD XMM4,XMM0
SUBSD XMM4,XMM3
MULSD XMM4,XMM6
ADDSD XMM4,XMM1
MULSD XMM4,XMM5
MOVSD qword ptr [RDI + 0x10],XMM4
MULSD XMM3,XMM5
MOVSD qword ptr [RDI + 0x18],XMM3
TEST RSI,RSI
JZ 0x0015f51f
MOVSD XMM3,qword ptr [0x001b7800]
MOVAPD XMM4,XMM2
MULSD XMM4,XMM3
ADDSD XMM4,XMM0
ADDSD XMM4,XMM3
MOVSD qword ptr [RSI],XMM4
MOVAPD XMM3,XMM0
ADDSD XMM3,XMM0
MOVSD XMM4,qword ptr [0x001b7808]
MULSD XMM4,XMM2
SUBSD XMM4,XMM3
MOVSD qword ptr [RSI + 0x8],XMM4
MOVSD XMM3,qword ptr [0x001b7810]
MULSD XMM3,XMM2
ADDSD XMM3,XMM0
MOVSD XMM4,qword ptr [0x001b4510]
ADDSD XMM3,XMM4
MOVSD qword ptr [RSI + 0x10],XMM3
MULSD XMM2,XMM4
MOVSD qword ptr [RSI + 0x18],XMM2
LAB_0015f51f:
TEST RDX,RDX
JZ 0x0015f563
MOVAPD XMM2,XMM1
SUBSD XMM2,XMM0
MOVSD qword ptr [RDX],XMM2
MOVSD XMM2,qword ptr [0x001b4528]
MULSD XMM2,XMM0
ADDSD XMM2,qword ptr [0x001b7818]
MOVSD qword ptr [RDX + 0x8],XMM2
MOVSD XMM2,qword ptr [0x001b5f20]
MULSD XMM2,XMM0
ADDSD XMM2,XMM1
MOVSD qword ptr [RDX + 0x10],XMM2
MOVSD qword ptr [RDX + 0x18],XMM0
LAB_0015f563:
RET
|
/* void OpenSubdiv::v3_6_0::Far::internal::(anonymous namespace)::evalBSplineCurve<double>(double,
double*, double*, double*) */
void OpenSubdiv::v3_6_0::Far::internal::(anonymous_namespace)::evalBSplineCurve<double>
(double param_1,double *param_2,double *param_3,double *param_4)
{
double dVar1;
double dVar2;
double dVar3;
double dVar4;
double dVar5;
dVar3 = DAT_001b4540;
dVar1 = DAT_001b44e8;
dVar4 = param_1 * param_1;
dVar5 = dVar4 * param_1;
*param_2 = (((param_1 - dVar4) * DAT_001b5f20 + DAT_001b44e8) - dVar5) * DAT_001b4540;
dVar2 = DAT_001b4528;
param_2[1] = (dVar5 * DAT_001b4528 + DAT_001b5f28 * dVar4 + DAT_001b4518) * dVar3;
param_2[2] = (((dVar4 + param_1) - dVar5) * dVar2 + dVar1) * dVar3;
param_2[3] = dVar5 * dVar3;
if (param_3 != (double *)0x0) {
*param_3 = dVar4 * DAT_001b7800 + param_1 + DAT_001b7800;
param_3[1] = DAT_001b7808 * dVar4 - (param_1 + param_1);
dVar2 = DAT_001b4510;
param_3[2] = DAT_001b7810 * dVar4 + param_1 + DAT_001b4510;
param_3[3] = dVar4 * dVar2;
}
if (param_4 != (double *)0x0) {
*param_4 = dVar1 - param_1;
param_4[1] = DAT_001b4528 * param_1 + DAT_001b7818;
param_4[2] = DAT_001b5f20 * param_1 + dVar1;
param_4[3] = param_1;
}
return;
}
|
|
916 | void OpenSubdiv::v3_6_0::Far::internal::(anonymous namespace)::evalBSplineCurve<float>(float, float*, float*, float*) | NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/patchBasis.cpp | void
evalBSplineCurve(REAL t, REAL wP[4], REAL wDP[4], REAL wDP2[4]) {
REAL const one6th = (REAL)(1.0 / 6.0);
REAL t2 = t * t;
REAL t3 = t * t2;
wP[0] = one6th * (1.0f - 3.0f*(t - t2) - t3);
wP[1] = one6th * (4.0f - 6.0f*t2 + 3.0f*t3);
wP[2] = one6th * (1.0f + 3.0f*(t + t2 - t3));
wP[3] = one6th * ( t3);
if (wDP) {
wDP[0] = -0.5f*t2 + t - 0.5f;
wDP[1] = 1.5f*t2 - 2.0f*t;
wDP[2] = -1.5f*t2 + t + 0.5f;
wDP[3] = 0.5f*t2;
}
if (wDP2) {
wDP2[0] = - t + 1.0f;
wDP2[1] = 3.0f * t - 2.0f;
wDP2[2] = -3.0f * t + 1.0f;
wDP2[3] = t;
}
} | O2 | cpp | void OpenSubdiv::v3_6_0::Far::internal::(anonymous namespace)::evalBSplineCurve<float>(float, float*, float*, float*):
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm4
mulsd %xmm0, %xmm4
movapd %xmm0, %xmm3
subsd %xmm1, %xmm3
mulsd 0x4bf7e(%rip), %xmm3 # 0xc0070
movsd 0x4a40e(%rip), %xmm2 # 0xbe508
addsd %xmm2, %xmm3
subsd %xmm4, %xmm3
movsd 0x4bf6e(%rip), %xmm5 # 0xc0078
mulsd %xmm1, %xmm5
addsd 0x4a3ea(%rip), %xmm5 # 0xbe500
movsd 0x4a40a(%rip), %xmm6 # 0xbe528
movapd %xmm1, %xmm7
addsd %xmm0, %xmm7
subsd %xmm4, %xmm7
mulsd %xmm6, %xmm7
addsd %xmm2, %xmm7
unpcklpd %xmm4, %xmm7 # xmm7 = xmm7[0],xmm4[0]
mulsd %xmm6, %xmm4
addsd %xmm5, %xmm4
unpcklpd %xmm4, %xmm3 # xmm3 = xmm3[0],xmm4[0]
movapd 0x4c1a6(%rip), %xmm4 # 0xc02f0
mulpd %xmm4, %xmm3
movupd %xmm3, (%rdi)
mulpd %xmm4, %xmm7
movupd %xmm7, 0x10(%rdi)
testq %rsi, %rsi
je 0x741c3
movsd 0x4dd10(%rip), %xmm3 # 0xc1e78
movapd %xmm1, %xmm4
mulsd %xmm3, %xmm4
addsd %xmm0, %xmm4
addsd %xmm3, %xmm4
movsd %xmm4, (%rsi)
movapd %xmm0, %xmm3
addsd %xmm0, %xmm3
movsd 0x4dcf4(%rip), %xmm4 # 0xc1e80
mulsd %xmm1, %xmm4
subsd %xmm3, %xmm4
movsd %xmm4, 0x8(%rsi)
movsd 0x4dce7(%rip), %xmm3 # 0xc1e88
mulsd %xmm1, %xmm3
addsd %xmm0, %xmm3
movsd 0x4a33f(%rip), %xmm4 # 0xbe4f0
addsd %xmm4, %xmm3
movsd %xmm3, 0x10(%rsi)
mulsd %xmm4, %xmm1
movsd %xmm1, 0x18(%rsi)
testq %rdx, %rdx
je 0x741f2
subsd %xmm0, %xmm2
movsd %xmm2, (%rdx)
movapd %xmm0, %xmm1
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
mulpd 0x4dc30(%rip), %xmm1 # 0xc1e10
addpd 0x4dc38(%rip), %xmm1 # 0xc1e20
movupd %xmm1, 0x8(%rdx)
movsd %xmm0, 0x18(%rdx)
retq
| _ZN10OpenSubdiv6v3_6_03Far8internal12_GLOBAL__N_116evalBSplineCurveIdEEvT_PS5_S6_S6_:
movapd xmm1, xmm0
mulsd xmm1, xmm0
movapd xmm4, xmm1
mulsd xmm4, xmm0
movapd xmm3, xmm0
subsd xmm3, xmm1
mulsd xmm3, cs:qword_C0070
movsd xmm2, cs:qword_BE508
addsd xmm3, xmm2
subsd xmm3, xmm4
movsd xmm5, cs:qword_C0078
mulsd xmm5, xmm1
addsd xmm5, cs:qword_BE500
movsd xmm6, cs:qword_BE528
movapd xmm7, xmm1
addsd xmm7, xmm0
subsd xmm7, xmm4
mulsd xmm7, xmm6
addsd xmm7, xmm2
unpcklpd xmm7, xmm4
mulsd xmm4, xmm6
addsd xmm4, xmm5
unpcklpd xmm3, xmm4
movapd xmm4, cs:xmmword_C02F0
mulpd xmm3, xmm4
movupd xmmword ptr [rdi], xmm3
mulpd xmm7, xmm4
movupd xmmword ptr [rdi+10h], xmm7
test rsi, rsi
jz short loc_741C3
movsd xmm3, cs:qword_C1E78
movapd xmm4, xmm1
mulsd xmm4, xmm3
addsd xmm4, xmm0
addsd xmm4, xmm3
movsd qword ptr [rsi], xmm4
movapd xmm3, xmm0
addsd xmm3, xmm0
movsd xmm4, cs:qword_C1E80
mulsd xmm4, xmm1
subsd xmm4, xmm3
movsd qword ptr [rsi+8], xmm4
movsd xmm3, cs:qword_C1E88
mulsd xmm3, xmm1
addsd xmm3, xmm0
movsd xmm4, cs:qword_BE4F0
addsd xmm3, xmm4
movsd qword ptr [rsi+10h], xmm3
mulsd xmm1, xmm4
movsd qword ptr [rsi+18h], xmm1
loc_741C3:
test rdx, rdx
jz short locret_741F2
subsd xmm2, xmm0
movsd qword ptr [rdx], xmm2
movapd xmm1, xmm0
unpcklpd xmm1, xmm0
mulpd xmm1, cs:xmmword_C1E10
addpd xmm1, cs:xmmword_C1E20
movupd xmmword ptr [rdx+8], xmm1
movsd qword ptr [rdx+18h], xmm0
locret_741F2:
retn
| void OpenSubdiv::v3_6_0::Far::internal::`anonymous namespace'::evalBSplineCurve<double>(
__m128d *a1,
double *a2,
long long a3,
__m128d a4)
{
double v4; // xmm1_8
__m128d v5; // xmm4
__m128d v6; // xmm3
__m128d v7; // xmm7
__m128d v8; // xmm7
v4 = a4.m128d_f64[0] * a4.m128d_f64[0];
v5.m128d_f64[1] = a4.m128d_f64[1];
v5.m128d_f64[0] = a4.m128d_f64[0] * a4.m128d_f64[0] * a4.m128d_f64[0];
v6.m128d_f64[1] = a4.m128d_f64[1];
v6.m128d_f64[0] = (a4.m128d_f64[0] - a4.m128d_f64[0] * a4.m128d_f64[0]) * -3.0 + 1.0 - v5.m128d_f64[0];
v7.m128d_f64[1] = a4.m128d_f64[1];
v7.m128d_f64[0] = (a4.m128d_f64[0] * a4.m128d_f64[0] + a4.m128d_f64[0] - v5.m128d_f64[0]) * 3.0 + 1.0;
v8 = _mm_unpacklo_pd(v7, v5);
v5.m128d_f64[0] = v5.m128d_f64[0] * 3.0 + -6.0 * (a4.m128d_f64[0] * a4.m128d_f64[0]) + 4.0;
*a1 = _mm_mul_pd(_mm_unpacklo_pd(v6, v5), (__m128d)xmmword_C02F0);
a1[1] = _mm_mul_pd(v8, (__m128d)xmmword_C02F0);
if ( a2 )
{
*a2 = v4 * -0.5 + a4.m128d_f64[0] + -0.5;
a2[1] = 1.5 * v4 - (a4.m128d_f64[0] + a4.m128d_f64[0]);
a2[2] = -1.5 * v4 + a4.m128d_f64[0] + 0.5;
a2[3] = v4 * 0.5;
}
if ( a3 )
{
*(double *)a3 = 1.0 - a4.m128d_f64[0];
*(__m128d *)(a3 + 8) = _mm_add_pd(
_mm_mul_pd(_mm_unpacklo_pd(a4, a4), (__m128d)xmmword_C1E10),
(__m128d)xmmword_C1E20);
*(double *)(a3 + 24) = a4.m128d_f64[0];
}
}
| evalBSplineCurve<double>:
MOVAPD XMM1,XMM0
MULSD XMM1,XMM0
MOVAPD XMM4,XMM1
MULSD XMM4,XMM0
MOVAPD XMM3,XMM0
SUBSD XMM3,XMM1
MULSD XMM3,qword ptr [0x001c0070]
MOVSD XMM2,qword ptr [0x001be508]
ADDSD XMM3,XMM2
SUBSD XMM3,XMM4
MOVSD XMM5,qword ptr [0x001c0078]
MULSD XMM5,XMM1
ADDSD XMM5,qword ptr [0x001be500]
MOVSD XMM6,qword ptr [0x001be528]
MOVAPD XMM7,XMM1
ADDSD XMM7,XMM0
SUBSD XMM7,XMM4
MULSD XMM7,XMM6
ADDSD XMM7,XMM2
UNPCKLPD XMM7,XMM4
MULSD XMM4,XMM6
ADDSD XMM4,XMM5
UNPCKLPD XMM3,XMM4
MOVAPD XMM4,xmmword ptr [0x001c02f0]
MULPD XMM3,XMM4
MOVUPD xmmword ptr [RDI],XMM3
MULPD XMM7,XMM4
MOVUPD xmmword ptr [RDI + 0x10],XMM7
TEST RSI,RSI
JZ 0x001741c3
MOVSD XMM3,qword ptr [0x001c1e78]
MOVAPD XMM4,XMM1
MULSD XMM4,XMM3
ADDSD XMM4,XMM0
ADDSD XMM4,XMM3
MOVSD qword ptr [RSI],XMM4
MOVAPD XMM3,XMM0
ADDSD XMM3,XMM0
MOVSD XMM4,qword ptr [0x001c1e80]
MULSD XMM4,XMM1
SUBSD XMM4,XMM3
MOVSD qword ptr [RSI + 0x8],XMM4
MOVSD XMM3,qword ptr [0x001c1e88]
MULSD XMM3,XMM1
ADDSD XMM3,XMM0
MOVSD XMM4,qword ptr [0x001be4f0]
ADDSD XMM3,XMM4
MOVSD qword ptr [RSI + 0x10],XMM3
MULSD XMM1,XMM4
MOVSD qword ptr [RSI + 0x18],XMM1
LAB_001741c3:
TEST RDX,RDX
JZ 0x001741f2
SUBSD XMM2,XMM0
MOVSD qword ptr [RDX],XMM2
MOVAPD XMM1,XMM0
UNPCKLPD XMM1,XMM0
MULPD XMM1,xmmword ptr [0x001c1e10]
ADDPD XMM1,xmmword ptr [0x001c1e20]
MOVUPD xmmword ptr [RDX + 0x8],XMM1
MOVSD qword ptr [RDX + 0x18],XMM0
LAB_001741f2:
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* void OpenSubdiv::v3_6_0::Far::internal::(anonymous namespace)::evalBSplineCurve<double>(double,
double*, double*, double*) */
void OpenSubdiv::v3_6_0::Far::internal::(anonymous_namespace)::evalBSplineCurve<double>
(double param_1,double *param_2,double *param_3,double *param_4)
{
double dVar1;
double dVar2;
double dVar3;
double dVar4;
double dVar5;
double dVar6;
double dVar7;
dVar2 = _UNK_001c02f8;
dVar1 = _DAT_001c02f0;
dVar4 = DAT_001be508;
dVar3 = param_1 * param_1;
dVar6 = dVar3 * param_1;
dVar7 = ((dVar3 + param_1) - dVar6) * DAT_001be528 + DAT_001be508;
dVar5 = (dVar6 * DAT_001be528 + DAT_001c0078 * dVar3 + DAT_001be500) * _UNK_001c02f8;
*param_2 = (((param_1 - dVar3) * DAT_001c0070 + DAT_001be508) - dVar6) * _DAT_001c02f0;
param_2[1] = dVar5;
param_2[2] = dVar7 * dVar1;
param_2[3] = dVar6 * dVar2;
if (param_3 != (double *)0x0) {
*param_3 = dVar3 * DAT_001c1e78 + param_1 + DAT_001c1e78;
param_3[1] = DAT_001c1e80 * dVar3 - (param_1 + param_1);
dVar1 = DAT_001be4f0;
param_3[2] = DAT_001c1e88 * dVar3 + param_1 + DAT_001be4f0;
param_3[3] = dVar3 * dVar1;
}
if (param_4 != (double *)0x0) {
*param_4 = dVar4 - param_1;
dVar4 = param_1 * _UNK_001c1e18 + _UNK_001c1e28;
param_4[1] = param_1 * _DAT_001c1e10 + _DAT_001c1e20;
param_4[2] = dVar4;
param_4[3] = param_1;
}
return;
}
|
|
917 | void OpenSubdiv::v3_6_0::Far::internal::(anonymous namespace)::evalBSplineCurve<float>(float, float*, float*, float*) | NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/patchBasis.cpp | void
evalBSplineCurve(REAL t, REAL wP[4], REAL wDP[4], REAL wDP2[4]) {
REAL const one6th = (REAL)(1.0 / 6.0);
REAL t2 = t * t;
REAL t3 = t * t2;
wP[0] = one6th * (1.0f - 3.0f*(t - t2) - t3);
wP[1] = one6th * (4.0f - 6.0f*t2 + 3.0f*t3);
wP[2] = one6th * (1.0f + 3.0f*(t + t2 - t3));
wP[3] = one6th * ( t3);
if (wDP) {
wDP[0] = -0.5f*t2 + t - 0.5f;
wDP[1] = 1.5f*t2 - 2.0f*t;
wDP[2] = -1.5f*t2 + t + 0.5f;
wDP[3] = 0.5f*t2;
}
if (wDP2) {
wDP2[0] = - t + 1.0f;
wDP2[1] = 3.0f * t - 2.0f;
wDP2[2] = -3.0f * t + 1.0f;
wDP2[3] = t;
}
} | O3 | cpp | void OpenSubdiv::v3_6_0::Far::internal::(anonymous namespace)::evalBSplineCurve<float>(float, float*, float*, float*):
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm4
mulsd %xmm0, %xmm4
movapd %xmm0, %xmm3
subsd %xmm1, %xmm3
mulsd 0x578ce(%rip), %xmm3 # 0xb93e0
movsd 0x55a7e(%rip), %xmm2 # 0xb7598
addsd %xmm2, %xmm3
subsd %xmm4, %xmm3
movsd 0x578be(%rip), %xmm5 # 0xb93e8
mulsd %xmm1, %xmm5
addsd 0x55a92(%rip), %xmm5 # 0xb75c8
movsd 0x55a9a(%rip), %xmm6 # 0xb75d8
movapd %xmm1, %xmm7
addsd %xmm0, %xmm7
subsd %xmm4, %xmm7
mulsd %xmm6, %xmm7
addsd %xmm2, %xmm7
unpcklpd %xmm4, %xmm7 # xmm7 = xmm7[0],xmm4[0]
mulsd %xmm6, %xmm4
addsd %xmm5, %xmm4
unpcklpd %xmm4, %xmm3 # xmm3 = xmm3[0],xmm4[0]
movapd 0x577f6(%rip), %xmm4 # 0xb9360
mulpd %xmm4, %xmm3
movupd %xmm3, (%rdi)
mulpd %xmm4, %xmm7
movupd %xmm7, 0x10(%rdi)
testq %rsi, %rsi
je 0x61be3
movsd 0x593e0(%rip), %xmm3 # 0xbaf68
movapd %xmm1, %xmm4
mulsd %xmm3, %xmm4
addsd %xmm0, %xmm4
addsd %xmm3, %xmm4
movsd %xmm4, (%rsi)
movapd %xmm0, %xmm3
addsd %xmm0, %xmm3
movsd 0x593c4(%rip), %xmm4 # 0xbaf70
mulsd %xmm1, %xmm4
subsd %xmm3, %xmm4
movsd %xmm4, 0x8(%rsi)
movsd 0x593b7(%rip), %xmm3 # 0xbaf78
mulsd %xmm1, %xmm3
addsd %xmm0, %xmm3
movsd 0x559ef(%rip), %xmm4 # 0xb75c0
addsd %xmm4, %xmm3
movsd %xmm3, 0x10(%rsi)
mulsd %xmm4, %xmm1
movsd %xmm1, 0x18(%rsi)
testq %rdx, %rdx
je 0x61c12
subsd %xmm0, %xmm2
movsd %xmm2, (%rdx)
movapd %xmm0, %xmm1
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
mulpd 0x59300(%rip), %xmm1 # 0xbaf00
addpd 0x59308(%rip), %xmm1 # 0xbaf10
movupd %xmm1, 0x8(%rdx)
movsd %xmm0, 0x18(%rdx)
retq
| _ZN10OpenSubdiv6v3_6_03Far8internal12_GLOBAL__N_116evalBSplineCurveIdEEvT_PS5_S6_S6_:
movapd xmm1, xmm0
mulsd xmm1, xmm0
movapd xmm4, xmm1
mulsd xmm4, xmm0
movapd xmm3, xmm0
subsd xmm3, xmm1
mulsd xmm3, cs:qword_B93E0
movsd xmm2, cs:qword_B7598
addsd xmm3, xmm2
subsd xmm3, xmm4
movsd xmm5, cs:qword_B93E8
mulsd xmm5, xmm1
addsd xmm5, cs:qword_B75C8
movsd xmm6, cs:qword_B75D8
movapd xmm7, xmm1
addsd xmm7, xmm0
subsd xmm7, xmm4
mulsd xmm7, xmm6
addsd xmm7, xmm2
unpcklpd xmm7, xmm4
mulsd xmm4, xmm6
addsd xmm4, xmm5
unpcklpd xmm3, xmm4
movapd xmm4, cs:xmmword_B9360
mulpd xmm3, xmm4
movupd xmmword ptr [rdi], xmm3
mulpd xmm7, xmm4
movupd xmmword ptr [rdi+10h], xmm7
test rsi, rsi
jz short loc_61BE3
movsd xmm3, cs:qword_BAF68
movapd xmm4, xmm1
mulsd xmm4, xmm3
addsd xmm4, xmm0
addsd xmm4, xmm3
movsd qword ptr [rsi], xmm4
movapd xmm3, xmm0
addsd xmm3, xmm0
movsd xmm4, cs:qword_BAF70
mulsd xmm4, xmm1
subsd xmm4, xmm3
movsd qword ptr [rsi+8], xmm4
movsd xmm3, cs:qword_BAF78
mulsd xmm3, xmm1
addsd xmm3, xmm0
movsd xmm4, cs:qword_B75C0
addsd xmm3, xmm4
movsd qword ptr [rsi+10h], xmm3
mulsd xmm1, xmm4
movsd qword ptr [rsi+18h], xmm1
loc_61BE3:
test rdx, rdx
jz short locret_61C12
subsd xmm2, xmm0
movsd qword ptr [rdx], xmm2
movapd xmm1, xmm0
unpcklpd xmm1, xmm0
mulpd xmm1, cs:xmmword_BAF00
addpd xmm1, cs:xmmword_BAF10
movupd xmmword ptr [rdx+8], xmm1
movsd qword ptr [rdx+18h], xmm0
locret_61C12:
retn
| void OpenSubdiv::v3_6_0::Far::internal::`anonymous namespace'::evalBSplineCurve<double>(
__m128d *a1,
double *a2,
long long a3,
__m128d a4)
{
double v4; // xmm1_8
__m128d v5; // xmm4
__m128d v6; // xmm3
__m128d v7; // xmm7
__m128d v8; // xmm7
v4 = a4.m128d_f64[0] * a4.m128d_f64[0];
v5.m128d_f64[1] = a4.m128d_f64[1];
v5.m128d_f64[0] = a4.m128d_f64[0] * a4.m128d_f64[0] * a4.m128d_f64[0];
v6.m128d_f64[1] = a4.m128d_f64[1];
v6.m128d_f64[0] = (a4.m128d_f64[0] - a4.m128d_f64[0] * a4.m128d_f64[0]) * -3.0 + 1.0 - v5.m128d_f64[0];
v7.m128d_f64[1] = a4.m128d_f64[1];
v7.m128d_f64[0] = (a4.m128d_f64[0] * a4.m128d_f64[0] + a4.m128d_f64[0] - v5.m128d_f64[0]) * 3.0 + 1.0;
v8 = _mm_unpacklo_pd(v7, v5);
v5.m128d_f64[0] = v5.m128d_f64[0] * 3.0 + -6.0 * (a4.m128d_f64[0] * a4.m128d_f64[0]) + 4.0;
*a1 = _mm_mul_pd(_mm_unpacklo_pd(v6, v5), (__m128d)xmmword_B9360);
a1[1] = _mm_mul_pd(v8, (__m128d)xmmword_B9360);
if ( a2 )
{
*a2 = v4 * -0.5 + a4.m128d_f64[0] + -0.5;
a2[1] = 1.5 * v4 - (a4.m128d_f64[0] + a4.m128d_f64[0]);
a2[2] = -1.5 * v4 + a4.m128d_f64[0] + 0.5;
a2[3] = v4 * 0.5;
}
if ( a3 )
{
*(double *)a3 = 1.0 - a4.m128d_f64[0];
*(__m128d *)(a3 + 8) = _mm_add_pd(
_mm_mul_pd(_mm_unpacklo_pd(a4, a4), (__m128d)xmmword_BAF00),
(__m128d)xmmword_BAF10);
*(double *)(a3 + 24) = a4.m128d_f64[0];
}
}
| evalBSplineCurve<double>:
MOVAPD XMM1,XMM0
MULSD XMM1,XMM0
MOVAPD XMM4,XMM1
MULSD XMM4,XMM0
MOVAPD XMM3,XMM0
SUBSD XMM3,XMM1
MULSD XMM3,qword ptr [0x001b93e0]
MOVSD XMM2,qword ptr [0x001b7598]
ADDSD XMM3,XMM2
SUBSD XMM3,XMM4
MOVSD XMM5,qword ptr [0x001b93e8]
MULSD XMM5,XMM1
ADDSD XMM5,qword ptr [0x001b75c8]
MOVSD XMM6,qword ptr [0x001b75d8]
MOVAPD XMM7,XMM1
ADDSD XMM7,XMM0
SUBSD XMM7,XMM4
MULSD XMM7,XMM6
ADDSD XMM7,XMM2
UNPCKLPD XMM7,XMM4
MULSD XMM4,XMM6
ADDSD XMM4,XMM5
UNPCKLPD XMM3,XMM4
MOVAPD XMM4,xmmword ptr [0x001b9360]
MULPD XMM3,XMM4
MOVUPD xmmword ptr [RDI],XMM3
MULPD XMM7,XMM4
MOVUPD xmmword ptr [RDI + 0x10],XMM7
TEST RSI,RSI
JZ 0x00161be3
MOVSD XMM3,qword ptr [0x001baf68]
MOVAPD XMM4,XMM1
MULSD XMM4,XMM3
ADDSD XMM4,XMM0
ADDSD XMM4,XMM3
MOVSD qword ptr [RSI],XMM4
MOVAPD XMM3,XMM0
ADDSD XMM3,XMM0
MOVSD XMM4,qword ptr [0x001baf70]
MULSD XMM4,XMM1
SUBSD XMM4,XMM3
MOVSD qword ptr [RSI + 0x8],XMM4
MOVSD XMM3,qword ptr [0x001baf78]
MULSD XMM3,XMM1
ADDSD XMM3,XMM0
MOVSD XMM4,qword ptr [0x001b75c0]
ADDSD XMM3,XMM4
MOVSD qword ptr [RSI + 0x10],XMM3
MULSD XMM1,XMM4
MOVSD qword ptr [RSI + 0x18],XMM1
LAB_00161be3:
TEST RDX,RDX
JZ 0x00161c12
SUBSD XMM2,XMM0
MOVSD qword ptr [RDX],XMM2
MOVAPD XMM1,XMM0
UNPCKLPD XMM1,XMM0
MULPD XMM1,xmmword ptr [0x001baf00]
ADDPD XMM1,xmmword ptr [0x001baf10]
MOVUPD xmmword ptr [RDX + 0x8],XMM1
MOVSD qword ptr [RDX + 0x18],XMM0
LAB_00161c12:
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* void OpenSubdiv::v3_6_0::Far::internal::(anonymous namespace)::evalBSplineCurve<double>(double,
double*, double*, double*) */
void OpenSubdiv::v3_6_0::Far::internal::(anonymous_namespace)::evalBSplineCurve<double>
(double param_1,double *param_2,double *param_3,double *param_4)
{
double dVar1;
double dVar2;
double dVar3;
double dVar4;
double dVar5;
double dVar6;
double dVar7;
dVar2 = _UNK_001b9368;
dVar1 = _DAT_001b9360;
dVar4 = DAT_001b7598;
dVar3 = param_1 * param_1;
dVar6 = dVar3 * param_1;
dVar7 = ((dVar3 + param_1) - dVar6) * DAT_001b75d8 + DAT_001b7598;
dVar5 = (dVar6 * DAT_001b75d8 + DAT_001b93e8 * dVar3 + DAT_001b75c8) * _UNK_001b9368;
*param_2 = (((param_1 - dVar3) * DAT_001b93e0 + DAT_001b7598) - dVar6) * _DAT_001b9360;
param_2[1] = dVar5;
param_2[2] = dVar7 * dVar1;
param_2[3] = dVar6 * dVar2;
if (param_3 != (double *)0x0) {
*param_3 = dVar3 * DAT_001baf68 + param_1 + DAT_001baf68;
param_3[1] = DAT_001baf70 * dVar3 - (param_1 + param_1);
dVar1 = DAT_001b75c0;
param_3[2] = DAT_001baf78 * dVar3 + param_1 + DAT_001b75c0;
param_3[3] = dVar3 * dVar1;
}
if (param_4 != (double *)0x0) {
*param_4 = dVar4 - param_1;
dVar4 = param_1 * _UNK_001baf08 + _UNK_001baf18;
param_4[1] = param_1 * _DAT_001baf00 + _DAT_001baf10;
param_4[2] = dVar4;
param_4[3] = param_1;
}
return;
}
|
|
918 | escape_quotes_for_mysql | eloqsql/mysys/charset.c | size_t escape_quotes_for_mysql(CHARSET_INFO *charset_info,
char *to, size_t to_length,
const char *from, size_t length,
my_bool *overflow)
{
const char *to_start= to;
const char *end, *to_end=to_start + (to_length ? to_length-1 : 2*length);
#ifdef USE_MB
my_bool use_mb_flag= my_ci_use_mb(charset_info);
#endif
*overflow= FALSE;
for (end= from + length; from < end; from++)
{
#ifdef USE_MB
int tmp_length;
if (use_mb_flag && (tmp_length= my_ismbchar(charset_info, from, end)))
{
if (to + tmp_length > to_end)
{
*overflow= TRUE;
break;
}
while (tmp_length--)
*to++= *from++;
from--;
continue;
}
/*
We don't have the same issue here with a non-multi-byte character being
turned into a multi-byte character by the addition of an escaping
character, because we are only escaping the ' character with itself.
*/
#endif
if (*from == '\'')
{
if (to + 2 > to_end)
{
*overflow= TRUE;
break;
}
*to++= '\'';
*to++= '\'';
}
else
{
if (to + 1 > to_end)
{
*overflow= TRUE;
break;
}
*to++= *from;
}
}
*to= 0;
return (size_t) (to - to_start);
} | O3 | c | escape_quotes_for_mysql:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
leaq (%r8,%r8), %rax
subq $0x1, %r12
cmovbq %rax, %r12
movq %rdi, -0x40(%rbp)
movl 0x9c(%rdi), %r13d
movq %r9, -0x38(%rbp)
movb $0x0, (%r9)
movq %rsi, -0x30(%rbp)
movq %rsi, %rax
testq %r8, %r8
jle 0x4cc1f
movq %r8, %r15
movq %rcx, %r14
movq -0x30(%rbp), %rbx
addq %rbx, %r12
addq %rcx, %r15
cmpl $0x2, %r13d
jb 0x4cbba
movq -0x40(%rbp), %rdi
movq 0xb8(%rdi), %rax
movq %r14, %rsi
movq %r15, %rdx
callq *0xc0(%rax)
cmpl $0x2, %eax
jge 0x4cbdf
movb (%r14), %cl
cmpb $0x27, %cl
jne 0x4cbd2
leaq 0x2(%rbx), %rax
cmpq %r12, %rax
ja 0x4cc15
movw $0x2727, (%rbx) # imm = 0x2727
jmp 0x4cc08
leaq 0x1(%rbx), %rax
cmpq %r12, %rax
ja 0x4cc15
movb %cl, (%rbx)
jmp 0x4cc08
movl %eax, %ecx
movl %eax, %eax
addq %rbx, %rax
cmpq %r12, %rax
ja 0x4cc15
decq %r14
movq %r14, %rdx
leaq 0x1(%rdx), %r14
leaq 0x1(%rbx), %rax
movb 0x1(%rdx), %dl
movb %dl, (%rbx)
movq %r14, %rdx
movq %rax, %rbx
decl %ecx
jne 0x4cbf1
incq %r14
movq %rax, %rbx
cmpq %r15, %r14
jb 0x4cb98
jmp 0x4cc1f
movq -0x38(%rbp), %rax
movb $0x1, (%rax)
movq %rbx, %rax
movb $0x0, (%rax)
subq -0x30(%rbp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| escape_quotes_for_mysql:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r12, rdx
lea rax, [r8+r8]
sub r12, 1
cmovb r12, rax
mov [rbp+var_40], rdi
mov r13d, [rdi+9Ch]
mov [rbp+var_38], r9
mov byte ptr [r9], 0
mov [rbp+var_30], rsi
mov rax, rsi
test r8, r8
jle loc_4CC1F
mov r15, r8
mov r14, rcx
mov rbx, [rbp+var_30]
add r12, rbx
add r15, rcx
loc_4CB98:
cmp r13d, 2
jb short loc_4CBBA
mov rdi, [rbp+var_40]
mov rax, [rdi+0B8h]
mov rsi, r14
mov rdx, r15
call qword ptr [rax+0C0h]
cmp eax, 2
jge short loc_4CBDF
loc_4CBBA:
mov cl, [r14]
cmp cl, 27h ; '''
jnz short loc_4CBD2
lea rax, [rbx+2]
cmp rax, r12
ja short loc_4CC15
mov word ptr [rbx], 2727h
jmp short loc_4CC08
loc_4CBD2:
lea rax, [rbx+1]
cmp rax, r12
ja short loc_4CC15
mov [rbx], cl
jmp short loc_4CC08
loc_4CBDF:
mov ecx, eax
mov eax, eax
add rax, rbx
cmp rax, r12
ja short loc_4CC15
dec r14
mov rdx, r14
loc_4CBF1:
lea r14, [rdx+1]
lea rax, [rbx+1]
mov dl, [rdx+1]
mov [rbx], dl
mov rdx, r14
mov rbx, rax
dec ecx
jnz short loc_4CBF1
loc_4CC08:
inc r14
mov rbx, rax
cmp r14, r15
jb short loc_4CB98
jmp short loc_4CC1F
loc_4CC15:
mov rax, [rbp+var_38]
mov byte ptr [rax], 1
mov rax, rbx
loc_4CC1F:
mov byte ptr [rax], 0
sub rax, [rbp+var_30]
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| _BYTE * escape_quotes_for_mysql(long long a1, _BYTE *a2, long long a3, _BYTE *a4, long long a5, _BYTE *a6)
{
long long v6; // r12
unsigned int v7; // r13d
_BYTE *v8; // rax
_BYTE *v9; // r14
_WORD *v10; // rbx
unsigned long long v11; // r12
unsigned long long v12; // r15
int v13; // eax
int v14; // ecx
_BYTE *v15; // rdx
v6 = a3 - 1;
if ( !a3 )
v6 = 2 * a5;
v7 = *(_DWORD *)(a1 + 156);
*a6 = 0;
v8 = a2;
if ( a5 > 0 )
{
v9 = a4;
v10 = a2;
v11 = (unsigned long long)&a2[v6];
v12 = (unsigned long long)&a4[a5];
do
{
if ( v7 >= 2
&& (v13 = (*(long long ( **)(long long, _BYTE *, unsigned long long))(*(_QWORD *)(a1 + 184) + 192LL))(
a1,
v9,
v12),
v13 >= 2) )
{
v14 = v13;
if ( (unsigned long long)v10 + (unsigned int)v13 > v11 )
{
LABEL_17:
*a6 = 1;
v8 = v10;
break;
}
v15 = v9 - 1;
do
{
v9 = v15 + 1;
v8 = (char *)v10 + 1;
*(_BYTE *)v10 = *++v15;
v10 = (_WORD *)((char *)v10 + 1);
--v14;
}
while ( v14 );
}
else if ( *v9 == 39 )
{
v8 = v10 + 1;
if ( (unsigned long long)(v10 + 1) > v11 )
goto LABEL_17;
*v10 = 10023;
}
else
{
v8 = (char *)v10 + 1;
if ( (unsigned long long)v10 + 1 > v11 )
goto LABEL_17;
*(_BYTE *)v10 = *v9;
}
++v9;
v10 = v8;
}
while ( (unsigned long long)v9 < v12 );
}
*v8 = 0;
return (_BYTE *)(v8 - a2);
}
| escape_quotes_for_mysql:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R12,RDX
LEA RAX,[R8 + R8*0x1]
SUB R12,0x1
CMOVC R12,RAX
MOV qword ptr [RBP + -0x40],RDI
MOV R13D,dword ptr [RDI + 0x9c]
MOV qword ptr [RBP + -0x38],R9
MOV byte ptr [R9],0x0
MOV qword ptr [RBP + -0x30],RSI
MOV RAX,RSI
TEST R8,R8
JLE 0x0014cc1f
MOV R15,R8
MOV R14,RCX
MOV RBX,qword ptr [RBP + -0x30]
ADD R12,RBX
ADD R15,RCX
LAB_0014cb98:
CMP R13D,0x2
JC 0x0014cbba
MOV RDI,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RDI + 0xb8]
MOV RSI,R14
MOV RDX,R15
CALL qword ptr [RAX + 0xc0]
CMP EAX,0x2
JGE 0x0014cbdf
LAB_0014cbba:
MOV CL,byte ptr [R14]
CMP CL,0x27
JNZ 0x0014cbd2
LEA RAX,[RBX + 0x2]
CMP RAX,R12
JA 0x0014cc15
MOV word ptr [RBX],0x2727
JMP 0x0014cc08
LAB_0014cbd2:
LEA RAX,[RBX + 0x1]
CMP RAX,R12
JA 0x0014cc15
MOV byte ptr [RBX],CL
JMP 0x0014cc08
LAB_0014cbdf:
MOV ECX,EAX
MOV EAX,EAX
ADD RAX,RBX
CMP RAX,R12
JA 0x0014cc15
DEC R14
MOV RDX,R14
LAB_0014cbf1:
LEA R14,[RDX + 0x1]
LEA RAX,[RBX + 0x1]
MOV DL,byte ptr [RDX + 0x1]
MOV byte ptr [RBX],DL
MOV RDX,R14
MOV RBX,RAX
DEC ECX
JNZ 0x0014cbf1
LAB_0014cc08:
INC R14
MOV RBX,RAX
CMP R14,R15
JC 0x0014cb98
JMP 0x0014cc1f
LAB_0014cc15:
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX],0x1
MOV RAX,RBX
LAB_0014cc1f:
MOV byte ptr [RAX],0x0
SUB RAX,qword ptr [RBP + -0x30]
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long escape_quotes_for_mysql
(long param_1,char *param_2,long param_3,char *param_4,long param_5,
int1 *param_6)
{
uint uVar1;
uint uVar2;
char *pcVar3;
char *pcVar4;
char *pcVar5;
long lVar6;
char *pcVar7;
char *pcVar8;
lVar6 = param_3 + -1;
if (param_3 == 0) {
lVar6 = param_5 * 2;
}
uVar1 = *(uint *)(param_1 + 0x9c);
*param_6 = 0;
pcVar3 = param_2;
if (0 < param_5) {
pcVar7 = param_2 + lVar6;
pcVar8 = param_4 + param_5;
pcVar5 = param_2;
do {
if ((uVar1 < 2) ||
(uVar2 = (**(code **)(*(long *)(param_1 + 0xb8) + 0xc0))(param_1,param_4,pcVar8),
(int)uVar2 < 2)) {
if (*param_4 == '\'') {
pcVar3 = pcVar5 + 2;
if (pcVar7 < pcVar3) {
LAB_0014cc15:
*param_6 = 1;
pcVar3 = pcVar5;
break;
}
pcVar5[0] = '\'';
pcVar5[1] = '\'';
}
else {
pcVar3 = pcVar5 + 1;
if (pcVar7 < pcVar3) goto LAB_0014cc15;
*pcVar5 = *param_4;
}
}
else {
if (pcVar7 < pcVar5 + uVar2) goto LAB_0014cc15;
pcVar4 = param_4 + -1;
do {
param_4 = pcVar4 + 1;
pcVar3 = pcVar5 + 1;
*pcVar5 = pcVar4[1];
uVar2 = uVar2 - 1;
pcVar4 = param_4;
pcVar5 = pcVar3;
} while (uVar2 != 0);
}
param_4 = param_4 + 1;
pcVar5 = pcVar3;
} while (param_4 < pcVar8);
}
*pcVar3 = '\0';
return (long)pcVar3 - (long)param_2;
}
|
|
919 | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::basic_json(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>, bool, nlohmann::json_abi_v3_11_3::detail::value_t) | llama.cpp/common/json.hpp | basic_json(initializer_list_t init,
bool type_deduction = true,
value_t manual_type = value_t::array)
{
// check if each element is an array with two elements whose first
// element is a string
bool is_an_object = std::all_of(init.begin(), init.end(),
[](const detail::json_ref<basic_json>& element_ref)
{
// The cast is to ensure op[size_type] is called, bearing in mind size_type may not be int;
// (many string types can be constructed from 0 via its null-pointer guise, so we get a
// broken call to op[key_type], the wrong semantics and a 4804 warning on Windows)
return element_ref->is_array() && element_ref->size() == 2 && (*element_ref)[static_cast<size_type>(0)].is_string();
});
// adjust type if type deduction is not wanted
if (!type_deduction)
{
// if array is wanted, do not create an object though possible
if (manual_type == value_t::array)
{
is_an_object = false;
}
// if object is wanted but impossible, throw an exception
if (JSON_HEDLEY_UNLIKELY(manual_type == value_t::object && !is_an_object))
{
JSON_THROW(type_error::create(301, "cannot create object from initializer list", nullptr));
}
}
if (is_an_object)
{
// the initializer list is a list of pairs -> create object
m_data.m_type = value_t::object;
m_data.m_value = value_t::object;
for (auto& element_ref : init)
{
auto element = element_ref.moved_or_copied();
m_data.m_value.object->emplace(
std::move(*((*element.m_data.m_value.array)[0].m_data.m_value.string)),
std::move((*element.m_data.m_value.array)[1]));
}
}
else
{
// the initializer list describes an array -> create array
m_data.m_type = value_t::array;
m_data.m_value.array = create<array_t>(init.begin(), init.end());
}
set_parents();
assert_invariant();
} | O3 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::basic_json(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>, bool, nlohmann::json_abi_v3_11_3::detail::value_t):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebp
movl %ecx, %r13d
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq (%rdx,%rdx,2), %rax
leaq (%rsi,%rax,8), %r12
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rsi, %rdi
movq %r12, %rsi
callq 0xf5c5e
cmpq %r12, %rax
sete %cl
testb %r13b, %r13b
jne 0xd661b
cmpq %r12, %rax
sete %al
cmpb $0x2, %bpl
setne %cl
cmpb $0x1, %bpl
setne %dl
orb %al, %dl
je 0xd66c6
andb %al, %cl
testb %cl, %cl
je 0xd6690
movb $0x1, (%rbx)
movl $0x20, %edi
callq 0x23290
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x8(%rbx)
testq %r15, %r15
je 0xd66aa
shlq $0x3, %r15
leaq (%r15,%r15,2), %r12
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xf5bb8
movq 0x8(%rbx), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rdx
movq 0x8(%rdx), %rsi
addq $0x10, %rdx
callq 0xb02d6
movq %r15, %rdi
xorl %esi, %esi
callq 0xaa5c4
movq %r15, %rdi
callq 0xaecde
addq $0x18, %r14
addq $-0x18, %r12
jne 0xd664e
jmp 0xd66aa
movb $0x2, (%rbx)
movq %rsp, %rdi
movq %r14, (%rdi)
leaq 0x20(%rsp), %rsi
movq %r12, (%rsi)
callq 0xf5c0a
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
callq 0xaa5c4
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x23850
movq %rax, %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x6c3fd(%rip), %rsi # 0x142ae1
leaq 0x6c420(%rip), %rdx # 0x142b0b
movq %rsp, %rdi
callq 0x2cd14
movb $0x1, %bpl
movq %rsp, %rdx
movq %r14, %rdi
movl $0x12d, %esi # imm = 0x12D
xorl %ecx, %ecx
callq 0xa406e
xorl %ebp, %ebp
leaq 0xb692f(%rip), %rsi # 0x18d040
leaq -0x3ab98(%rip), %rdx # 0x9bb80
movq %r14, %rdi
callq 0x23e00
jmp 0xd6726
jmp 0xd6726
jmp 0xd6726
movq %rax, %r15
jmp 0xd6770
movq %rax, %r15
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0xaa5c4
movq %r14, %rdi
callq 0xaecde
jmp 0xd6770
movq %rax, %r15
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xd675e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x231f0
testb %bpl, %bpl
jne 0xd6768
jmp 0xd6770
movq %rax, %r15
movq %r14, %rdi
callq 0x24440
movq %rbx, %rdi
callq 0xaecde
movq %r15, %rdi
callq 0x23ee0
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ESt16initializer_listINS0_6detail8json_refISD_EEEbNSF_7value_tE:
push rbp; __int64
push r15; int
push r14; void *
push r13; int
push r12; __int64
push rbx; int
sub rsp, 28h
mov ebp, r8d
mov r13d, ecx
mov r15, rdx
mov r14, rsi
mov rbx, rdi
lea rax, [rdx+rdx*2]
lea r12, [rsi+rax*8]
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov rdi, rsi
mov rsi, r12
call _ZSt9__find_ifIPKN8nlohmann16json_abi_v3_11_36detail8json_refINS1_10basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEEN9__gnu_cxx5__ops12_Iter_negateIZNSG_C1ESt16initializer_listISH_EbNS2_7value_tEEUlRSI_E_EEET_ST_ST_T0_St26random_access_iterator_tag; std::__find_if<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const*,__gnu_cxx::__ops::_Iter_negate<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>,bool,nlohmann::json_abi_v3_11_3::detail::value_t)::{lambda(nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const&)#1}>>(nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const*,nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const*,__gnu_cxx::__ops::_Iter_negate<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>,bool,nlohmann::json_abi_v3_11_3::detail::value_t)::{lambda(nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const&)#1}>,std::random_access_iterator_tag)
cmp rax, r12
setz cl
test r13b, r13b
jnz short loc_D661B
cmp rax, r12
setz al
cmp bpl, 2
setnz cl
cmp bpl, 1
setnz dl
or dl, al
jz loc_D66C6
and cl, al
loc_D661B:
test cl, cl
jz short loc_D6690
mov byte ptr [rbx], 1
mov edi, 20h ; ' '; unsigned __int64
call __Znwm; operator new(ulong)
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
mov qword ptr [rax+10h], 0
mov [rbx+8], rax
test r15, r15
jz short loc_D66AA
shl r15, 3
lea r12, [r15+r15*2]
mov r15, rsp
loc_D664E:
mov rdi, r15
mov rsi, r14
call _ZNK8nlohmann16json_abi_v3_11_36detail8json_refINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE15moved_or_copiedEv; nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::moved_or_copied(void)
mov rdi, [rbx+8]
mov rax, [rsp+58h+var_50]
mov rdx, [rax]
mov rsi, [rdx+8]
add rdx, 10h
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE7emplaceERSH_OSD_; nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::emplace(std::string const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&&)
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
add r14, 18h
add r12, 0FFFFFFFFFFFFFFE8h
jnz short loc_D664E
jmp short loc_D66AA
loc_D6690:
mov byte ptr [rbx], 2
mov rdi, rsp
mov [rdi], r14
lea rsi, [rsp+58h+var_38]
mov [rsi], r12
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6createIS3_ISD_SaISD_EEJPKNS0_6detail8json_refISD_EESL_EEEPT_DpOT0_; 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>::create<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const*,nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const*>(nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const*,nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const* &&)
mov [rbx+8], rax
loc_D66AA:
mov rdi, rbx
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_D66C6:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea r12, [rsp+58h+var_48]
mov [r12-10h], r12
lea rsi, aCannotCreateOb; "cannot create object from initializer l"...
lea rdx, aCannotCreateOb+2Ah; ""
mov rdi, rsp
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov bpl, 1
mov rdx, rsp
mov rdi, r14; this
mov esi, 12Dh; int
xor ecx, ecx
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIDnTnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp short loc_D6726
jmp short loc_D6726
jmp short $+2
loc_D6726:
mov r15, rax
jmp short loc_D6770
mov r15, rax
mov r14, rsp
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
jmp short loc_D6770
mov r15, rax
mov rdi, [rsp+58h+var_58]; void *
cmp rdi, r12
jz short loc_D675E
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_D675E:
test bpl, bpl
jnz short loc_D6768
jmp short loc_D6770
mov r15, rax
loc_D6768:
mov rdi, r14; void *
call ___cxa_free_exception
loc_D6770:
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, r15
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(
long long a1,
char *a2,
long long a3,
char a4,
char a5)
{
char *v8; // r14
char *v9; // r12
long long v10; // rax
bool v11; // cl
bool v12; // al
long long result; // rax
long long v14; // r12
nlohmann::json_abi_v3_11_3::detail::exception *exception; // r14
void *v16; // [rsp+0h] [rbp-58h] BYREF
long long v17; // [rsp+8h] [rbp-50h]
_QWORD v18[9]; // [rsp+10h] [rbp-48h] BYREF
v8 = a2;
v9 = &a2[24 * a3];
*(_OWORD *)a1 = 0LL;
v10 = std::__find_if<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> const*,__gnu_cxx::__ops::_Iter_negate<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>,bool,nlohmann::json_abi_v3_11_3::detail::value_t)::{lambda(nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> const&)#1}>>(
a2,
v9);
v11 = v10 == (_QWORD)v9;
if ( !a4 )
{
v12 = v10 == (_QWORD)v9;
if ( !v12 && a5 == 1 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v16 = v18;
std::string::_M_construct<char const*>((long long)&v16, "cannot create object from initializer list", (long long)"");
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIDnTnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_(
exception,
301,
&v16);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
v11 = v12 && a5 != 2;
}
if ( v11 )
{
*(_BYTE *)a1 = 1;
result = operator new(0x20uLL);
*(_OWORD *)result = 0LL;
*(_QWORD *)(result + 16) = 0LL;
*(_QWORD *)(a1 + 8) = result;
if ( a3 )
{
v14 = 24 * a3;
do
{
nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::moved_or_copied(
&v16,
v8);
nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::emplace(
*(_QWORD **)(a1 + 8),
*(long long **)(*(_QWORD *)v17 + 8LL),
*(_QWORD *)v17 + 16LL);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)&v16);
result = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(&v16);
v8 += 24;
v14 -= 24LL;
}
while ( v14 );
}
}
else
{
*(_BYTE *)a1 = 2;
v16 = a2;
v18[2] = v9;
result = 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>::create<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> const*,nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> const*>(&v16);
*(_QWORD *)(a1 + 8) = result;
}
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)a1);
return result;
}
| basic_json:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV EBP,R8D
MOV R13D,ECX
MOV R15,RDX
MOV R14,RSI
MOV RBX,RDI
LEA RAX,[RDX + RDX*0x2]
LEA R12,[RSI + RAX*0x8]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
LAB_001d65e7:
MOV RDI,RSI
MOV RSI,R12
CALL 0x001f5c5e
CMP RAX,R12
SETZ CL
TEST R13B,R13B
JNZ 0x001d661b
CMP RAX,R12
SETZ AL
CMP BPL,0x2
SETNZ CL
CMP BPL,0x1
SETNZ DL
OR DL,AL
JZ 0x001d66c6
AND CL,AL
LAB_001d661b:
TEST CL,CL
JZ 0x001d6690
MOV byte ptr [RBX],0x1
LAB_001d6622:
MOV EDI,0x20
CALL 0x00123290
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOV qword ptr [RAX + 0x10],0x0
MOV qword ptr [RBX + 0x8],RAX
TEST R15,R15
JZ 0x001d66aa
SHL R15,0x3
LEA R12,[R15 + R15*0x2]
MOV R15,RSP
LAB_001d664e:
MOV RDI,R15
MOV RSI,R14
CALL 0x001f5bb8
MOV RDI,qword ptr [RBX + 0x8]
MOV RAX,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RAX]
MOV RSI,qword ptr [RDX + 0x8]
ADD RDX,0x10
LAB_001d666d:
CALL 0x001b02d6
MOV RDI,R15
XOR ESI,ESI
CALL 0x001aa5c4
MOV RDI,R15
CALL 0x001aecde
ADD R14,0x18
ADD R12,-0x18
JNZ 0x001d664e
JMP 0x001d66aa
LAB_001d6690:
MOV byte ptr [RBX],0x2
MOV RDI,RSP
MOV qword ptr [RDI],R14
LEA RSI,[RSP + 0x20]
MOV qword ptr [RSI],R12
LAB_001d66a1:
CALL 0x001f5c0a
LAB_001d66a6:
MOV qword ptr [RBX + 0x8],RAX
LAB_001d66aa:
MOV RDI,RBX
MOV ESI,0x1
CALL 0x001aa5c4
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001d66c6:
MOV EDI,0x20
CALL 0x00123850
MOV R14,RAX
LEA R12,[RSP + 0x10]
MOV qword ptr [R12 + -0x10],R12
LAB_001d66dd:
LEA RSI,[0x242ae1]
LEA RDX,[0x242b0b]
MOV RDI,RSP
CALL 0x0012cd14
MOV BPL,0x1
LAB_001d66f6:
MOV RDX,RSP
MOV RDI,R14
MOV ESI,0x12d
XOR ECX,ECX
CALL 0x001a406e
XOR EBP,EBP
LEA RSI,[0x28d040]
LEA RDX,[0x19bb80]
MOV RDI,R14
CALL 0x00123e00
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >,
void>::basic_json(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> > >, bool, nlohmann::json_abi_v3_11_3::detail::value_t) */
void nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json(int8 *param_1,json_ref *param_2,long param_3,char param_4,char param_5)
{
json_ref *pjVar1;
json_ref *pjVar2;
int8 *puVar3;
vector *pvVar4;
int8 uVar5;
bool bVar6;
json_ref *local_58;
long *local_50;
json_ref local_48 [16];
json_ref *local_38;
pjVar1 = param_2 + param_3 * 0x18;
*param_1 = 0;
param_1[1] = 0;
/* try { // try from 001d65e7 to 001d65f1 has its CatchHandler @ 001d6724 */
pjVar2 = std::
__find_if<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>const*,__gnu_cxx::__ops::_Iter_negate<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>::_Iter_negate(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>,bool,nlohmann::json_abi_v3_11_3::detail::value_t)::_lambda(nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>const&)_1_>>
(param_2,pjVar1);
bVar6 = pjVar2 == pjVar1;
if (param_4 == '\0') {
if (param_5 == '\x01' && pjVar2 != pjVar1) {
uVar5 = __cxa_allocate_exception(0x20);
local_58 = local_48;
/* try { // try from 001d66dd to 001d66f2 has its CatchHandler @ 001d6765 */
std::__cxx11::string::_M_construct<char_const*>
(&local_58,"cannot create object from initializer list","");
/* try { // try from 001d66f6 to 001d671f has its CatchHandler @ 001d6745 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIDnTnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_
(uVar5,0x12d,&local_58,0);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar5,&detail::type_error::typeinfo,detail::exception::~exception);
}
bVar6 = param_5 != '\x02' && pjVar2 == pjVar1;
}
if (bVar6) {
*(int1 *)param_1 = 1;
/* try { // try from 001d6622 to 001d662b has its CatchHandler @ 001d6722 */
puVar3 = (int8 *)operator_new(0x20);
*puVar3 = 0;
puVar3[1] = 0;
puVar3[2] = 0;
param_1[1] = puVar3;
if (param_3 != 0) {
param_3 = param_3 * 0x18;
do {
/* try { // try from 001d664e to 001d6658 has its CatchHandler @ 001d6726 */
detail::
json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::moved_or_copied();
/* try { // try from 001d666d to 001d6671 has its CatchHandler @ 001d672b */
ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::emplace((ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*)param_1[1],*(string **)(*local_50 + 8),(basic_json *)(*local_50 + 0x10));
assert_invariant(SUB81(&local_58,0));
data::~data((data *)&local_58);
param_3 = param_3 + -0x18;
} while (param_3 != 0);
}
}
else {
*(int1 *)param_1 = 2;
local_58 = param_2;
local_38 = pjVar1;
/* try { // try from 001d66a1 to 001d66a5 has its CatchHandler @ 001d6720 */
pvVar4 = create<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>,nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>const*,nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>const*>
(&local_58,&local_38);
param_1[1] = pvVar4;
}
assert_invariant(SUB81(param_1,0));
return;
}
|
|
920 | LefDefParser::lefwLayerDCCurrentDensity(char const*, double) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefwWriter.cpp | int
lefwLayerDCCurrentDensity(const char *type,
double value)
{
if (!lefwFile)
return LEFW_UNINITIALIZED;
if (lefwState != LEFW_LAYERROUTING_START && lefwState != LEFW_LAYERROUTING
&& lefwState != LEFW_LAYER_START && lefwState != LEFW_LAYER)
return LEFW_BAD_ORDER;
if (strcmp(type, "AVERAGE"))
return LEFW_BAD_DATA; // type is AVERAGE
if (lefwWriteEncrypt) {
encPrint(lefwFile, (char*) " DCCURRENTDENSITY %s", type);
lefwLines++;
lefwTableLen = 5;
if (value)
encPrint(lefwFile, (char*) " %.11g\n", value);
// that's it for accurrentdensity
else {
encPrint(lefwFile, (char*) "\n");
// expect to have frequency & tableentries
lefwOldState = lefwState; // save the previous state
lefwState = LEFW_LAYERDCCURRENT;
}
} else {
fprintf(lefwFile, " DCCURRENTDENSITY %s", type);
lefwLines++;
lefwTableLen = 5;
if (value)
fprintf(lefwFile, " %.11g\n", value); // that's it for accurrentdensity
else {
fprintf(lefwFile, "\n"); // expect to have frequency & tableentries
lefwOldState = lefwState; // save the previous state
lefwState = LEFW_LAYERDCCURRENT;
}
}
return LEFW_OK;
} | O0 | cpp | LefDefParser::lefwLayerDCCurrentDensity(char const*, double):
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movsd %xmm0, (%rsp)
leaq 0x1ed0b(%rip), %rax # 0x32e00
cmpq $0x0, (%rax)
jne 0x14108
movl $0x1, 0x14(%rsp)
jmp 0x142d2
leaq 0x1ef41(%rip), %rax # 0x33050
cmpl $0x7, (%rax)
je 0x14145
leaq 0x1ef35(%rip), %rax # 0x33050
cmpl $0x1f, (%rax)
je 0x14145
leaq 0x1ef29(%rip), %rax # 0x33050
cmpl $0x6, (%rax)
je 0x14145
leaq 0x1ef1d(%rip), %rax # 0x33050
cmpl $0x1c, (%rax)
je 0x14145
movl $0x2, 0x14(%rsp)
jmp 0x142d2
movq 0x8(%rsp), %rdi
leaq 0x15720(%rip), %rsi # 0x29871
callq 0x10f0
cmpl $0x0, %eax
je 0x14168
movl $0x3, 0x14(%rsp)
jmp 0x142d2
cmpl $0x0, 0x1ef7d(%rip) # 0x330ec
je 0x14221
leaq 0x1ec84(%rip), %rax # 0x32e00
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
leaq 0x168d9(%rip), %rsi # 0x2aa64
movb $0x0, %al
callq 0x289b0
leaq 0x1eeb3(%rip), %rax # 0x3304c
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x1eea7(%rip), %rax # 0x3304c
movl %ecx, (%rax)
leaq 0x1ef32(%rip), %rax # 0x330e0
movl $0x5, (%rax)
movsd (%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x141c6
jp 0x141c6
jmp 0x141e5
leaq 0x1ec33(%rip), %rax # 0x32e00
movq (%rax), %rdi
movsd (%rsp), %xmm0
leaq 0x17b66(%rip), %rsi # 0x2bd42
movb $0x1, %al
callq 0x289b0
jmp 0x1421c
leaq 0x1ec14(%rip), %rax # 0x32e00
movq (%rax), %rdi
leaq 0x174bf(%rip), %rsi # 0x2b6b5
movb $0x0, %al
callq 0x289b0
leaq 0x1ee4c(%rip), %rax # 0x33050
movl (%rax), %ecx
leaq 0x1eecf(%rip), %rax # 0x330dc
movl %ecx, (%rax)
leaq 0x1ee3a(%rip), %rax # 0x33050
movl $0x1e, (%rax)
jmp 0x142ca
leaq 0x1ebd8(%rip), %rax # 0x32e00
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
leaq 0x1682d(%rip), %rsi # 0x2aa64
movb $0x0, %al
callq 0x1100
leaq 0x1ee07(%rip), %rax # 0x3304c
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x1edfb(%rip), %rax # 0x3304c
movl %ecx, (%rax)
leaq 0x1ee86(%rip), %rax # 0x330e0
movl $0x5, (%rax)
movsd (%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x14272
jp 0x14272
jmp 0x14291
leaq 0x1eb87(%rip), %rax # 0x32e00
movq (%rax), %rdi
movsd (%rsp), %xmm0
leaq 0x17aba(%rip), %rsi # 0x2bd42
movb $0x1, %al
callq 0x1100
jmp 0x142c8
leaq 0x1eb68(%rip), %rax # 0x32e00
movq (%rax), %rdi
leaq 0x17413(%rip), %rsi # 0x2b6b5
movb $0x0, %al
callq 0x1100
leaq 0x1eda0(%rip), %rax # 0x33050
movl (%rax), %ecx
leaq 0x1ee23(%rip), %rax # 0x330dc
movl %ecx, (%rax)
leaq 0x1ed8e(%rip), %rax # 0x33050
movl $0x1e, (%rax)
jmp 0x142ca
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
| _ZN12LefDefParser25lefwLayerDCCurrentDensityEPKcd:
sub rsp, 18h
mov [rsp+18h+var_10], rdi
movsd [rsp+18h+var_18], xmm0
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
cmp qword ptr [rax], 0
jnz short loc_14108
mov [rsp+18h+var_4], 1
jmp loc_142D2
loc_14108:
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
cmp dword ptr [rax], 7
jz short loc_14145
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
cmp dword ptr [rax], 1Fh
jz short loc_14145
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
cmp dword ptr [rax], 6
jz short loc_14145
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
cmp dword ptr [rax], 1Ch
jz short loc_14145
mov [rsp+18h+var_4], 2
jmp loc_142D2
loc_14145:
mov rdi, [rsp+18h+var_10]
lea rsi, aAverage; "AVERAGE"
call _strcmp
cmp eax, 0
jz short loc_14168
mov [rsp+18h+var_4], 3
jmp loc_142D2
loc_14168:
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 0; LefDefParser::lefwWriteEncrypt
jz loc_14221
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
mov rdx, [rsp+18h+var_10]
lea rsi, aDccurrentdensi; " DCCURRENTDENSITY %s"
mov al, 0
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov ecx, [rax]
add ecx, 1
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov [rax], ecx
lea rax, _ZN12LefDefParser12lefwTableLenE; LefDefParser::lefwTableLen
mov dword ptr [rax], 5
movsd xmm0, [rsp+18h+var_18]
xorps xmm1, xmm1
ucomisd xmm0, xmm1
jnz short loc_141C6
jp short loc_141C6
jmp short loc_141E5
loc_141C6:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
movsd xmm0, [rsp+18h+var_18]
lea rsi, a11g11g_3+14h; " %.11g\n"
mov al, 1
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp short loc_1421C
loc_141E5:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
lea rsi, aEnd+7; "\n"
mov al, 0
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
mov ecx, [rax]
lea rax, _ZN12LefDefParser12lefwOldStateE; LefDefParser::lefwOldState
mov [rax], ecx
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
mov dword ptr [rax], 1Eh
loc_1421C:
jmp loc_142CA
loc_14221:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
mov rdx, [rsp+18h+var_10]
lea rsi, aDccurrentdensi; " DCCURRENTDENSITY %s"
mov al, 0
call _fprintf
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov ecx, [rax]
add ecx, 1
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov [rax], ecx
lea rax, _ZN12LefDefParser12lefwTableLenE; LefDefParser::lefwTableLen
mov dword ptr [rax], 5
movsd xmm0, [rsp+18h+var_18]
xorps xmm1, xmm1
ucomisd xmm0, xmm1
jnz short loc_14272
jp short loc_14272
jmp short loc_14291
loc_14272:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
movsd xmm0, [rsp+18h+var_18]
lea rsi, a11g11g_3+14h; " %.11g\n"
mov al, 1
call _fprintf
jmp short loc_142C8
loc_14291:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
lea rsi, aEnd+7; "\n"
mov al, 0
call _fprintf
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
mov ecx, [rax]
lea rax, _ZN12LefDefParser12lefwOldStateE; LefDefParser::lefwOldState
mov [rax], ecx
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
mov dword ptr [rax], 1Eh
loc_142C8:
jmp short $+2
loc_142CA:
mov [rsp+18h+var_4], 0
loc_142D2:
mov eax, [rsp+18h+var_4]
add rsp, 18h
retn
| long long LefDefParser::lefwLayerDCCurrentDensity(LefDefParser *this, const char *a2, double a3)
{
int v3; // ecx
int v4; // r8d
int v5; // r9d
int v6; // edx
int v7; // r8d
int v8; // r9d
int v9; // ecx
if ( *(_QWORD *)&LefDefParser::lefwFile )
{
if ( LefDefParser::lefwState == 7
|| LefDefParser::lefwState == 31
|| LefDefParser::lefwState == 6
|| LefDefParser::lefwState == 28 )
{
if ( !(unsigned int)strcmp(this, "AVERAGE") )
{
if ( LefDefParser::lefwWriteEncrypt )
{
LefDefParser::encPrint(
LefDefParser::lefwFile,
(unsigned int)" DCCURRENTDENSITY %s",
(_DWORD)this,
v3,
v4,
v5);
v9 = ++LefDefParser::lefwLines;
LefDefParser::lefwTableLen = 5;
if ( a3 == 0.0 )
{
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)"\n", v6, v9, v7, v8);
LefDefParser::lefwOldState = LefDefParser::lefwState;
LefDefParser::lefwState = 30;
}
else
{
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)" %.11g\n", v6, v9, v7, v8);
}
}
else
{
fprintf(*(_QWORD *)&LefDefParser::lefwFile, " DCCURRENTDENSITY %s", (const char *)this);
++LefDefParser::lefwLines;
LefDefParser::lefwTableLen = 5;
if ( a3 == 0.0 )
{
fprintf(*(_QWORD *)&LefDefParser::lefwFile, "\n");
LefDefParser::lefwOldState = LefDefParser::lefwState;
LefDefParser::lefwState = 30;
}
else
{
fprintf(*(_QWORD *)&LefDefParser::lefwFile, " %.11g\n", a3);
}
}
return 0;
}
else
{
return 3;
}
}
else
{
return 2;
}
}
else
{
return 1;
}
}
| lefwLayerDCCurrentDensity:
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RDI
MOVSD qword ptr [RSP],XMM0
LEA RAX,[0x132e00]
CMP qword ptr [RAX],0x0
JNZ 0x00114108
MOV dword ptr [RSP + 0x14],0x1
JMP 0x001142d2
LAB_00114108:
LEA RAX,[0x133050]
CMP dword ptr [RAX],0x7
JZ 0x00114145
LEA RAX,[0x133050]
CMP dword ptr [RAX],0x1f
JZ 0x00114145
LEA RAX,[0x133050]
CMP dword ptr [RAX],0x6
JZ 0x00114145
LEA RAX,[0x133050]
CMP dword ptr [RAX],0x1c
JZ 0x00114145
MOV dword ptr [RSP + 0x14],0x2
JMP 0x001142d2
LAB_00114145:
MOV RDI,qword ptr [RSP + 0x8]
LEA RSI,[0x129871]
CALL 0x001010f0
CMP EAX,0x0
JZ 0x00114168
MOV dword ptr [RSP + 0x14],0x3
JMP 0x001142d2
LAB_00114168:
CMP dword ptr [0x001330ec],0x0
JZ 0x00114221
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
MOV RDX,qword ptr [RSP + 0x8]
LEA RSI,[0x12aa64]
MOV AL,0x0
CALL 0x001289b0
LEA RAX,[0x13304c]
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
LEA RAX,[0x13304c]
MOV dword ptr [RAX],ECX
LEA RAX,[0x1330e0]
MOV dword ptr [RAX],0x5
MOVSD XMM0,qword ptr [RSP]
XORPS XMM1,XMM1
UCOMISD XMM0,XMM1
JNZ 0x001141c6
JP 0x001141c6
JMP 0x001141e5
LAB_001141c6:
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
MOVSD XMM0,qword ptr [RSP]
LEA RSI,[0x12bd42]
MOV AL,0x1
CALL 0x001289b0
JMP 0x0011421c
LAB_001141e5:
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x12b6b5]
MOV AL,0x0
CALL 0x001289b0
LEA RAX,[0x133050]
MOV ECX,dword ptr [RAX]
LEA RAX,[0x1330dc]
MOV dword ptr [RAX],ECX
LEA RAX,[0x133050]
MOV dword ptr [RAX],0x1e
LAB_0011421c:
JMP 0x001142ca
LAB_00114221:
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
MOV RDX,qword ptr [RSP + 0x8]
LEA RSI,[0x12aa64]
MOV AL,0x0
CALL 0x00101100
LEA RAX,[0x13304c]
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
LEA RAX,[0x13304c]
MOV dword ptr [RAX],ECX
LEA RAX,[0x1330e0]
MOV dword ptr [RAX],0x5
MOVSD XMM0,qword ptr [RSP]
XORPS XMM1,XMM1
UCOMISD XMM0,XMM1
JNZ 0x00114272
JP 0x00114272
JMP 0x00114291
LAB_00114272:
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
MOVSD XMM0,qword ptr [RSP]
LEA RSI,[0x12bd42]
MOV AL,0x1
CALL 0x00101100
JMP 0x001142c8
LAB_00114291:
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x12b6b5]
MOV AL,0x0
CALL 0x00101100
LEA RAX,[0x133050]
MOV ECX,dword ptr [RAX]
LEA RAX,[0x1330dc]
MOV dword ptr [RAX],ECX
LEA RAX,[0x133050]
MOV dword ptr [RAX],0x1e
LAB_001142c8:
JMP 0x001142ca
LAB_001142ca:
MOV dword ptr [RSP + 0x14],0x0
LAB_001142d2:
MOV EAX,dword ptr [RSP + 0x14]
ADD RSP,0x18
RET
|
/* LefDefParser::lefwLayerDCCurrentDensity(char const*, double) */
int4 LefDefParser::lefwLayerDCCurrentDensity(char *param_1,double param_2)
{
int iVar1;
int4 local_4;
if (lefwFile == (_IO_FILE *)0x0) {
local_4 = 1;
}
else if ((((lefwState == 7) || (lefwState == 0x1f)) || (lefwState == 6)) || (lefwState == 0x1c)) {
iVar1 = strcmp(param_1,"AVERAGE");
if (iVar1 == 0) {
if (lefwWriteEncrypt == 0) {
fprintf(lefwFile," DCCURRENTDENSITY %s",param_1);
lefwLines = lefwLines + 1;
lefwTableLen = 5;
if ((param_2 != 0.0) || (NAN(param_2))) {
fprintf(lefwFile," %.11g\n",param_2);
}
else {
fprintf(lefwFile,"\n");
lefwOldState = lefwState;
lefwState = 0x1e;
}
}
else {
encPrint(lefwFile," DCCURRENTDENSITY %s",param_1);
lefwLines = lefwLines + 1;
lefwTableLen = 5;
if ((param_2 != 0.0) || (NAN(param_2))) {
encPrint(lefwFile," %.11g\n",param_2);
}
else {
encPrint(lefwFile,"\n");
lefwOldState = lefwState;
lefwState = 0x1e;
}
}
local_4 = 0;
}
else {
local_4 = 3;
}
}
else {
local_4 = 2;
}
return local_4;
}
|
|
921 | LefDefParser::lefwLayerDCCurrentDensity(char const*, double) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefwWriter.cpp | int
lefwLayerDCCurrentDensity(const char *type,
double value)
{
if (!lefwFile)
return LEFW_UNINITIALIZED;
if (lefwState != LEFW_LAYERROUTING_START && lefwState != LEFW_LAYERROUTING
&& lefwState != LEFW_LAYER_START && lefwState != LEFW_LAYER)
return LEFW_BAD_ORDER;
if (strcmp(type, "AVERAGE"))
return LEFW_BAD_DATA; // type is AVERAGE
if (lefwWriteEncrypt) {
encPrint(lefwFile, (char*) " DCCURRENTDENSITY %s", type);
lefwLines++;
lefwTableLen = 5;
if (value)
encPrint(lefwFile, (char*) " %.11g\n", value);
// that's it for accurrentdensity
else {
encPrint(lefwFile, (char*) "\n");
// expect to have frequency & tableentries
lefwOldState = lefwState; // save the previous state
lefwState = LEFW_LAYERDCCURRENT;
}
} else {
fprintf(lefwFile, " DCCURRENTDENSITY %s", type);
lefwLines++;
lefwTableLen = 5;
if (value)
fprintf(lefwFile, " %.11g\n", value); // that's it for accurrentdensity
else {
fprintf(lefwFile, "\n"); // expect to have frequency & tableentries
lefwOldState = lefwState; // save the previous state
lefwState = LEFW_LAYERDCCURRENT;
}
}
return LEFW_OK;
} | O3 | cpp | LefDefParser::lefwLayerDCCurrentDensity(char const*, double):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
leaq 0x18ec2(%rip), %r13 # 0x24e00
movq (%r13), %r15
testq %r15, %r15
je 0xbff3
leaq 0x190fe(%rip), %r12 # 0x25050
movl (%r12), %eax
movl $0x2, %ebx
cmpl $0x1f, %eax
ja 0xbff8
movsd %xmm0, 0x8(%rsp)
movl $0x900000c0, %ecx # imm = 0x900000C0
btl %eax, %ecx
jae 0xbff8
movq %rdi, %r14
leaq 0xdbae(%rip), %rsi # 0x19b30
callq 0x10e0
movl $0x3, %ebx
testl %eax, %eax
jne 0xbff8
cmpb $0x1, 0x19155(%rip) # 0x250ec
jne 0xc008
leaq 0xed80(%rip), %rsi # 0x1ad20
xorl %ebx, %ebx
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x18c35
leaq 0x19096(%rip), %rax # 0x2504c
incl (%rax)
xorpd %xmm0, %xmm0
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
leaq 0x19113(%rip), %rax # 0x250e0
movl $0x5, (%rax)
movq (%r13), %rdi
jne 0xbfdf
jnp 0xc061
movapd %xmm1, %xmm0
leaq 0x10014(%rip), %rsi # 0x1bffe
movb $0x1, %al
callq 0x18c35
jmp 0xbff8
movl $0x1, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xed11(%rip), %rsi # 0x1ad20
xorl %ebx, %ebx
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x10f0
leaq 0x19027(%rip), %rax # 0x2504c
incl (%rax)
xorpd %xmm0, %xmm0
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
leaq 0x190a4(%rip), %rax # 0x250e0
movl $0x5, (%rax)
movq (%r13), %rax
jne 0xc04a
jnp 0xc071
movapd %xmm1, %xmm0
leaq 0xffa9(%rip), %rsi # 0x1bffe
movq %rax, %rdi
movb $0x1, %al
callq 0x10f0
jmp 0xbff8
leaq 0xf909(%rip), %rsi # 0x1b971
xorl %eax, %eax
callq 0x18c35
jmp 0xc07e
movl $0xa, %edi
movq %rax, %rsi
callq 0x10b0
movl (%r12), %eax
leaq 0x19053(%rip), %rcx # 0x250dc
movl %eax, (%rcx)
movl $0x1e, (%r12)
jmp 0xbff8
| _ZN12LefDefParser25lefwLayerDCCurrentDensityEPKcd:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 10h
lea r13, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov r15, [r13+0]
test r15, r15
jz loc_BFF3
lea r12, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
mov eax, [r12]
mov ebx, 2
cmp eax, 1Fh
ja loc_BFF8
movsd [rsp+38h+var_30], xmm0
mov ecx, 900000C0h
bt ecx, eax
jnb loc_BFF8
mov r14, rdi
lea rsi, aAverage; "AVERAGE"
call _strcmp
mov ebx, 3
test eax, eax
jnz short loc_BFF8
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 1; LefDefParser::lefwWriteEncrypt
jnz short loc_C008
lea rsi, aDccurrentdensi; " DCCURRENTDENSITY %s"
xor ebx, ebx
mov rdi, r15
mov rdx, r14
xor eax, eax
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
inc dword ptr [rax]
xorpd xmm0, xmm0
movsd xmm1, [rsp+38h+var_30]
ucomisd xmm1, xmm0
lea rax, _ZN12LefDefParser12lefwTableLenE; LefDefParser::lefwTableLen
mov dword ptr [rax], 5
mov rdi, [r13+0]
jnz short loc_BFDF
jnp loc_C061
loc_BFDF:
movapd xmm0, xmm1
lea rsi, a11g11g_3+14h; " %.11g\n"
mov al, 1
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp short loc_BFF8
loc_BFF3:
mov ebx, 1
loc_BFF8:
mov eax, ebx
add rsp, 10h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
loc_C008:
lea rsi, aDccurrentdensi; " DCCURRENTDENSITY %s"
xor ebx, ebx
mov rdi, r15
mov rdx, r14
xor eax, eax
call _fprintf
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
inc dword ptr [rax]
xorpd xmm0, xmm0
movsd xmm1, [rsp+38h+var_30]
ucomisd xmm1, xmm0
lea rax, _ZN12LefDefParser12lefwTableLenE; LefDefParser::lefwTableLen
mov dword ptr [rax], 5
mov rax, [r13+0]
jnz short loc_C04A
jnp short loc_C071
loc_C04A:
movapd xmm0, xmm1
lea rsi, a11g11g_3+14h; " %.11g\n"
mov rdi, rax
mov al, 1
call _fprintf
jmp short loc_BFF8
loc_C061:
lea rsi, aEnd+7; "\n"
xor eax, eax
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp short loc_C07E
loc_C071:
mov edi, 0Ah
mov rsi, rax
call _fputc
loc_C07E:
mov eax, [r12]
lea rcx, _ZN12LefDefParser12lefwOldStateE; LefDefParser::lefwOldState
mov [rcx], eax
mov dword ptr [r12], 1Eh
jmp loc_BFF8
| long long LefDefParser::lefwLayerDCCurrentDensity(LefDefParser *this, const char *a2, double a3)
{
long long v3; // r15
unsigned int v4; // ebx
int v5; // ecx
int v6; // ecx
int v7; // r8d
int v8; // r9d
int v9; // edx
int v10; // ecx
int v11; // r8d
int v12; // r9d
v3 = *(_QWORD *)&LefDefParser::lefwFile;
if ( *(_QWORD *)&LefDefParser::lefwFile )
{
v4 = 2;
if ( LefDefParser::lefwState <= 0x1F )
{
v5 = -1879048000;
if ( _bittest(&v5, LefDefParser::lefwState) )
{
v4 = 3;
if ( !(unsigned int)strcmp(this, "AVERAGE") )
{
if ( LefDefParser::lefwWriteEncrypt == 1 )
{
v4 = 0;
LefDefParser::encPrint(v3, (unsigned int)" DCCURRENTDENSITY %s", (_DWORD)this, v6, v7, v8);
++LefDefParser::lefwLines;
LefDefParser::lefwTableLen = 5;
if ( a3 == 0.0 )
{
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)"\n", v9, v10, v11, v12);
LABEL_14:
LefDefParser::lefwOldState = LefDefParser::lefwState;
LefDefParser::lefwState = 30;
return v4;
}
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)" %.11g\n", v9, v10, v11, v12);
}
else
{
v4 = 0;
fprintf(v3, " DCCURRENTDENSITY %s", (const char *)this);
++LefDefParser::lefwLines;
LefDefParser::lefwTableLen = 5;
if ( a3 == 0.0 )
{
fputc(10LL, *(_QWORD *)&LefDefParser::lefwFile);
goto LABEL_14;
}
fprintf(*(_QWORD *)&LefDefParser::lefwFile, " %.11g\n", a3);
}
}
}
}
}
else
{
return 1;
}
return v4;
}
| lefwLayerDCCurrentDensity:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
LEA R13,[0x124e00]
MOV R15,qword ptr [R13]
TEST R15,R15
JZ 0x0010bff3
LEA R12,[0x125050]
MOV EAX,dword ptr [R12]
MOV EBX,0x2
CMP EAX,0x1f
JA 0x0010bff8
MOVSD qword ptr [RSP + 0x8],XMM0
MOV ECX,0x900000c0
BT ECX,EAX
JNC 0x0010bff8
MOV R14,RDI
LEA RSI,[0x119b30]
CALL 0x001010e0
MOV EBX,0x3
TEST EAX,EAX
JNZ 0x0010bff8
CMP byte ptr [0x001250ec],0x1
JNZ 0x0010c008
LEA RSI,[0x11ad20]
XOR EBX,EBX
MOV RDI,R15
MOV RDX,R14
XOR EAX,EAX
CALL 0x00118c35
LEA RAX,[0x12504c]
INC dword ptr [RAX]
XORPD XMM0,XMM0
MOVSD XMM1,qword ptr [RSP + 0x8]
UCOMISD XMM1,XMM0
LEA RAX,[0x1250e0]
MOV dword ptr [RAX],0x5
MOV RDI,qword ptr [R13]
JNZ 0x0010bfdf
JNP 0x0010c061
LAB_0010bfdf:
MOVAPD XMM0,XMM1
LEA RSI,[0x11bffe]
MOV AL,0x1
CALL 0x00118c35
JMP 0x0010bff8
LAB_0010bff3:
MOV EBX,0x1
LAB_0010bff8:
MOV EAX,EBX
ADD RSP,0x10
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
LAB_0010c008:
LEA RSI,[0x11ad20]
XOR EBX,EBX
MOV RDI,R15
MOV RDX,R14
XOR EAX,EAX
CALL 0x001010f0
LEA RAX,[0x12504c]
INC dword ptr [RAX]
XORPD XMM0,XMM0
MOVSD XMM1,qword ptr [RSP + 0x8]
UCOMISD XMM1,XMM0
LEA RAX,[0x1250e0]
MOV dword ptr [RAX],0x5
MOV RAX,qword ptr [R13]
JNZ 0x0010c04a
JNP 0x0010c071
LAB_0010c04a:
MOVAPD XMM0,XMM1
LEA RSI,[0x11bffe]
MOV RDI,RAX
MOV AL,0x1
CALL 0x001010f0
JMP 0x0010bff8
LAB_0010c061:
LEA RSI,[0x11b971]
XOR EAX,EAX
CALL 0x00118c35
JMP 0x0010c07e
LAB_0010c071:
MOV EDI,0xa
MOV RSI,RAX
CALL 0x001010b0
LAB_0010c07e:
MOV EAX,dword ptr [R12]
LEA RCX,[0x1250dc]
MOV dword ptr [RCX],EAX
MOV dword ptr [R12],0x1e
JMP 0x0010bff8
|
/* LefDefParser::lefwLayerDCCurrentDensity(char const*, double) */
int8 LefDefParser::lefwLayerDCCurrentDensity(char *param_1,double param_2)
{
_IO_FILE *__stream;
int iVar1;
int8 uVar2;
__stream = lefwFile;
if (lefwFile == (_IO_FILE *)0x0) {
uVar2 = 1;
}
else {
uVar2 = 2;
if ((lefwState < 0x20) && ((0x900000c0U >> (lefwState & 0x1f) & 1) != 0)) {
iVar1 = strcmp(param_1,"AVERAGE");
uVar2 = 3;
if (iVar1 == 0) {
if (lefwWriteEncrypt == '\x01') {
encPrint(__stream," DCCURRENTDENSITY %s",param_1);
lefwLines = lefwLines + 1;
lefwTableLen = 5;
if ((param_2 != 0.0) || (NAN(param_2))) {
encPrint(lefwFile," %.11g\n",param_2);
return 0;
}
encPrint(lefwFile,"\n");
}
else {
fprintf(__stream," DCCURRENTDENSITY %s",param_1);
lefwLines = lefwLines + 1;
lefwTableLen = 5;
if ((param_2 != 0.0) || (NAN(param_2))) {
fprintf(lefwFile," %.11g\n",param_2);
return 0;
}
fputc(10,lefwFile);
}
uVar2 = 0;
lefwOldState = lefwState;
lefwState = 0x1e;
}
}
}
return uVar2;
}
|
|
922 | ftxui::(anonymous namespace)::UpdatePixelStyle(ftxui::Screen const*, std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>&, ftxui::Pixel const&, ftxui::Pixel const&) | Andrewchistyakov[P]flashcards_lyc/build_O1/_deps/ftxui-src/src/ftxui/screen/screen.cpp | void UpdatePixelStyle(const Screen* screen,
std::stringstream& ss,
const Pixel& prev,
const Pixel& next) {
// See https://gist.github.com/egmontkob/eb114294efbcd5adb1944c9f3cb5feda
if (FTXUI_UNLIKELY(next.hyperlink != prev.hyperlink)) {
ss << "\x1B]8;;" << screen->Hyperlink(next.hyperlink) << "\x1B\\";
}
// Bold
if (FTXUI_UNLIKELY((next.bold ^ prev.bold) | (next.dim ^ prev.dim))) {
// BOLD_AND_DIM_RESET:
ss << ((prev.bold && !next.bold) || (prev.dim && !next.dim) ? "\x1B[22m"
: "");
ss << (next.bold ? "\x1B[1m" : ""); // BOLD_SET
ss << (next.dim ? "\x1B[2m" : ""); // DIM_SET
}
// Underline
if (FTXUI_UNLIKELY(next.underlined != prev.underlined ||
next.underlined_double != prev.underlined_double)) {
ss << (next.underlined ? "\x1B[4m" // UNDERLINE
: next.underlined_double ? "\x1B[21m" // UNDERLINE_DOUBLE
: "\x1B[24m"); // UNDERLINE_RESET
}
// Blink
if (FTXUI_UNLIKELY(next.blink != prev.blink)) {
ss << (next.blink ? "\x1B[5m" // BLINK_SET
: "\x1B[25m"); // BLINK_RESET
}
// Inverted
if (FTXUI_UNLIKELY(next.inverted != prev.inverted)) {
ss << (next.inverted ? "\x1B[7m" // INVERTED_SET
: "\x1B[27m"); // INVERTED_RESET
}
// StrikeThrough
if (FTXUI_UNLIKELY(next.strikethrough != prev.strikethrough)) {
ss << (next.strikethrough ? "\x1B[9m" // CROSSED_OUT
: "\x1B[29m"); // CROSSED_OUT_RESET
}
if (FTXUI_UNLIKELY(next.foreground_color != prev.foreground_color ||
next.background_color != prev.background_color)) {
ss << "\x1B[" + next.foreground_color.Print(false) + "m";
ss << "\x1B[" + next.background_color.Print(true) + "m";
}
} | O1 | cpp | ftxui::(anonymous namespace)::UpdatePixelStyle(ftxui::Screen const*, std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>&, ftxui::Pixel const&, ftxui::Pixel const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movb 0x1(%rcx), %al
cmpb 0x1(%rdx), %al
jne 0x3a171
movb (%r14), %al
movl %eax, %edx
andb $0x2, %dl
movb (%r15), %cl
movl %ecx, %esi
andb $0x2, %sil
movl %esi, %edi
xorb %dl, %dil
shrb %dil
movl %ecx, %r8d
xorb %al, %r8b
shrb $0x2, %r8b
andb $0x1, %r8b
orb %dil, %r8b
jne 0x3a185
movb (%r14), %al
movb (%r15), %cl
xorb %al, %cl
testb $0x30, %cl
jne 0x3a1ca
movb (%r14), %al
movb (%r15), %cl
xorb %al, %cl
testb $0x1, %cl
jne 0x3a1da
movb (%r14), %al
andb $0x8, %al
movl %eax, %ecx
shrb $0x3, %cl
btl $0x3, (%r15)
sbbb $0x0, %cl
jne 0x3a206
movb (%r14), %al
andb $0x40, %al
movl %eax, %ecx
shrb $0x6, %cl
btl $0x6, (%r15)
sbbb $0x0, %cl
jne 0x3a216
leaq 0x2c(%r14), %r12
leaq 0x2c(%r15), %rsi
movq %r12, %rdi
callq 0x2040c
testb %al, %al
jne 0x3a108
leaq 0x28(%r14), %rdi
addq $0x28, %r15
movq %r15, %rsi
callq 0x2040c
testb %al, %al
jne 0x3a108
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x48(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x2042e
leaq 0x5d47(%rip), %rsi # 0x3fe68
leaq 0x28(%rsp), %rdi
movq %r15, %rdx
callq 0x1d28f
leaq 0x6950(%rip), %rsi # 0x40a85
leaq 0x28(%rsp), %rdi
callq 0xb7f0
addq $0x10, %rbx
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x3a226
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x3a22e
movq %rdi, %rdx
leaq 0x1(%r14), %rsi
movq %rbx, %rdi
callq 0xbc08
jmp 0x3a04f
testb %dl, %dl
sete %dl
testb %sil, %sil
setne %sil
leaq 0x10(%rbx), %r12
leaq 0x3a45(%rip), %rbp # 0x3dbe1
testb %sil, %dl
jne 0x3a387
movq %rbp, %r13
testb $0x4, %cl
je 0x3a38e
testb $0x4, %al
leaq 0x68b2(%rip), %rax # 0x40a6c
leaq 0x3a20(%rip), %r13 # 0x3dbe1
cmoveq %rax, %r13
jmp 0x3a38e
movzbl %al, %esi
movq %rbx, %rdi
callq 0xbc72
jmp 0x3a090
leaq 0x68ac(%rip), %rcx # 0x40a8d
leaq 0x68aa(%rip), %rsi # 0x40a92
testb $0x1, %al
cmovneq %rcx, %rsi
leaq 0x10(%rbx), %rdi
movzbl %al, %edx
andl $0x1, %edx
xorq $0x5, %rdx
callq 0xb490
jmp 0x3a0a1
movzbl %al, %edi
movq %rbx, %rsi
callq 0xbca9
jmp 0x3a0b9
movzbl %al, %edi
movq %rbx, %rsi
callq 0xbcd3
jmp 0x3a0d1
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0xb490
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x3a26f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb400
leaq 0x38(%rsp), %rbp
movq -0x10(%rbp), %rdi
cmpq %rbp, %rdi
je 0x3a28a
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb400
leaq 0x58(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x3a2a6
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xb400
addq $0x28, %r14
leaq 0x48(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x2042e
leaq 0x5ba2(%rip), %rsi # 0x3fe68
leaq 0x28(%rsp), %rdi
movq %r15, %rdx
callq 0x1d28f
leaq 0x67ab(%rip), %rsi # 0x40a85
leaq 0x28(%rsp), %rdi
callq 0xb7f0
movq %r13, 0x8(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x3a307
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x3a30f
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0xb490
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x3a350
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb400
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x3a367
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb400
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x3a0f9
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xb400
jmp 0x3a0f9
leaq 0x66de(%rip), %r13 # 0x40a6c
movq %r13, %rdi
callq 0xb170
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0xb490
movzbl (%r14), %edx
andl $0x2, %edx
leaq 0x66c0(%rip), %rsi # 0x40a72
cmoveq %rbp, %rsi
addl %edx, %edx
movq %r12, %rdi
callq 0xb490
movzbl (%r14), %edx
andq $0x4, %rdx
leaq 0x66a8(%rip), %rsi # 0x40a77
cmoveq %rbp, %rsi
movq %r12, %rdi
callq 0xb490
jmp 0x3a07f
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x3a3ff
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb400
jmp 0x3a3ff
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x3a41b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb400
jmp 0x3a41b
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
jne 0x3a474
jmp 0x3a481
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x3a446
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb400
jmp 0x3a446
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3a466
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb400
jmp 0x3a466
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3a481
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xb400
movq %rbx, %rdi
callq 0xb780
nop
| _ZN5ftxui12_GLOBAL__N_116UpdatePixelStyleEPKNS_6ScreenERNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEERKNS_5PixelESD_:
push rbp; __int64
push r15; int
push r14; void *
push r13; int
push r12; __int64
push rbx; int
sub rsp, 68h
mov r14, rcx
mov r15, rdx
mov rbx, rsi
mov al, [rcx+1]
cmp al, [rdx+1]
jnz loc_3A171
loc_3A04F:
mov al, [r14]
mov edx, eax
and dl, 2
mov cl, [r15]
mov esi, ecx
and sil, 2
mov edi, esi
xor dil, dl
shr dil, 1
mov r8d, ecx
xor r8b, al
shr r8b, 2
and r8b, 1
or r8b, dil
jnz loc_3A185
loc_3A07F:
mov al, [r14]
mov cl, [r15]
xor cl, al
test cl, 30h
jnz loc_3A1CA
loc_3A090:
mov al, [r14]
mov cl, [r15]
xor cl, al
test cl, 1
jnz loc_3A1DA
loc_3A0A1:
mov al, [r14]
and al, 8
mov ecx, eax
shr cl, 3
bt dword ptr [r15], 3
sbb cl, 0
jnz loc_3A206
loc_3A0B9:
mov al, [r14]
and al, 40h
mov ecx, eax
shr cl, 6
bt dword ptr [r15], 6
sbb cl, 0
jnz loc_3A216
loc_3A0D1:
lea r12, [r14+2Ch]
lea rsi, [r15+2Ch]
mov rdi, r12
call _ZNK5ftxui5ColorneERKS0_; ftxui::Color::operator!=(ftxui::Color const&)
test al, al
jnz short loc_3A108
lea rdi, [r14+28h]
add r15, 28h ; '('
mov rsi, r15
call _ZNK5ftxui5ColorneERKS0_; ftxui::Color::operator!=(ftxui::Color const&)
test al, al
jnz short loc_3A108
loc_3A0F9:
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3A108:
lea r15, [rsp+98h+var_50]
mov rdi, r15; int
mov rsi, r12; int
xor edx, edx; int
call _ZNK5ftxui5Color5PrintB5cxx11Eb; ftxui::Color::Print(bool)
lea rsi, unk_3FE68
lea rdi, [rsp+98h+var_70]
mov rdx, r15
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
lea rsi, a21m+4; "m"
lea rdi, [rsp+98h+var_70]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
add rbx, 10h
lea r13, [rsp+98h+var_80]
mov [r13-10h], r13
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz loc_3A226
mov [rsp+98h+var_90], rdx
mov rdx, [rcx]
mov [rsp+98h+var_80], rdx
jmp loc_3A22E
loc_3A171:
mov rdx, rdi
lea rsi, [r14+1]
mov rdi, rbx
call _ZN5ftxui12_GLOBAL__N_116UpdatePixelStyleEPKNS_6ScreenERNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEERKNS_5PixelESD__cold_1; ftxui::`anonymous namespace'::UpdatePixelStyle(ftxui::Screen const*,std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>> &,ftxui::Pixel const&,ftxui::Pixel const&) [clone]
jmp loc_3A04F
loc_3A185:
test dl, dl
setz dl
test sil, sil
setnz sil
lea r12, [rbx+10h]
lea rbp, asc_3DBDF+2; ""
test dl, sil
jnz loc_3A387
mov r13, rbp
test cl, 4
jz loc_3A38E
test al, 4
lea rax, a22m; "\x1B[22m"
lea r13, asc_3DBDF+2; ""
cmovz r13, rax
jmp loc_3A38E
loc_3A1CA:
movzx esi, al
mov rdi, rbx
call _ZN5ftxui12_GLOBAL__N_116UpdatePixelStyleEPKNS_6ScreenERNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEERKNS_5PixelESD__cold_2; ftxui::`anonymous namespace'::UpdatePixelStyle(ftxui::Screen const*,std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>> &,ftxui::Pixel const&,ftxui::Pixel const&) [clone]
jmp loc_3A090
loc_3A1DA:
lea rcx, a5m; "\x1B[5m"
lea rsi, a25m; "\x1B[25m"
test al, 1
cmovnz rsi, rcx
lea rdi, [rbx+10h]
movzx edx, al
and edx, 1
xor rdx, 5
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
jmp loc_3A0A1
loc_3A206:
movzx edi, al
mov rsi, rbx
call _ZN5ftxui12_GLOBAL__N_116UpdatePixelStyleEPKNS_6ScreenERNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEERKNS_5PixelESD__cold_3; ftxui::`anonymous namespace'::UpdatePixelStyle(ftxui::Screen const*,std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>> &,ftxui::Pixel const&,ftxui::Pixel const&) [clone]
jmp loc_3A0B9
loc_3A216:
movzx edi, al
mov rsi, rbx
call _ZN5ftxui12_GLOBAL__N_116UpdatePixelStyleEPKNS_6ScreenERNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEERKNS_5PixelESD__cold_4; ftxui::`anonymous namespace'::UpdatePixelStyle(ftxui::Screen const*,std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>> &,ftxui::Pixel const&,ftxui::Pixel const&) [clone]
jmp loc_3A0D1
loc_3A226:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r13+0], xmm0
loc_3A22E:
mov rdx, [rax+8]
mov [rsp+98h+var_88], rdx; __int64
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
mov rsi, [rsp+98h+var_90]
mov rdx, [rsp+98h+var_88]
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, [rsp+98h+var_90]; void *
cmp rdi, r13
jz short loc_3A26F
mov rsi, [rsp+98h+var_80]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3A26F:
lea rbp, [rsp+98h+var_60]
mov rdi, [rbp-10h]; void *
cmp rdi, rbp
jz short loc_3A28A
mov rsi, [rsp+98h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3A28A:
lea r12, [rsp+98h+var_40]
mov rdi, [r12-10h]; void *
cmp rdi, r12
jz short loc_3A2A6
mov rsi, [rsp+98h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3A2A6:
add r14, 28h ; '('
lea r15, [rsp+98h+var_50]
mov rdi, r15; int
mov rsi, r14; int
mov edx, 1; int
call _ZNK5ftxui5Color5PrintB5cxx11Eb; ftxui::Color::Print(bool)
lea rsi, unk_3FE68
lea rdi, [rsp+98h+var_70]
mov rdx, r15
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
lea rsi, a21m+4; "m"
lea rdi, [rsp+98h+var_70]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov [rsp+98h+var_90], r13
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_3A307
mov [rsp+98h+var_90], rdx
mov rdx, [rcx]
mov [rsp+98h+var_80], rdx
jmp short loc_3A30F
loc_3A307:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r13+0], xmm0
loc_3A30F:
mov rdx, [rax+8]
mov [rsp+98h+var_88], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
mov rsi, [rsp+98h+var_90]
mov rdx, [rsp+98h+var_88]
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, [rsp+98h+var_90]; void *
cmp rdi, r13
jz short loc_3A350
mov rsi, [rsp+98h+var_80]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3A350:
mov rdi, [rsp+98h+var_70]; void *
cmp rdi, rbp
jz short loc_3A367
mov rsi, [rsp+98h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3A367:
mov rdi, [rsp+98h+var_50]; void *
cmp rdi, r12
jz loc_3A0F9
mov rsi, [rsp+98h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp loc_3A0F9
loc_3A387:
lea r13, a22m; "\x1B[22m"
loc_3A38E:
mov rdi, r13
call _strlen
mov rdi, r12
mov rsi, r13
mov rdx, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
movzx edx, byte ptr [r14]
and edx, 2
lea rsi, a1m; "\x1B[1m"
cmovz rsi, rbp
add edx, edx
mov rdi, r12
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
movzx edx, byte ptr [r14]
and rdx, 4
lea rsi, a2m; "\x1B[2m"
cmovz rsi, rbp
mov rdi, r12
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
jmp loc_3A07F
mov rbx, rax
mov rdi, [rsp+arg_0]; void *
cmp rdi, r13
jz short loc_3A3FF
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_3A3FF
mov rbx, rax
loc_3A3FF:
mov rdi, [rsp+arg_20]; void *
cmp rdi, rbp
jz short loc_3A41B
mov rsi, [rsp+arg_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_3A41B
mov rbx, rax
loc_3A41B:
mov rdi, [rsp+arg_40]
cmp rdi, r12
jnz short loc_3A474
jmp short loc_3A481
mov rbx, rax
mov rdi, [rsp+arg_0]; void *
cmp rdi, r13
jz short loc_3A446
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_3A446
mov rbx, rax
loc_3A446:
lea rax, [rsp+arg_30]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_3A466
mov rsi, [rsp+arg_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_3A466
mov rbx, rax
loc_3A466:
lea rax, [rsp+arg_50]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_3A481
loc_3A474:
mov rsi, [rsp+arg_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3A481:
mov rdi, rbx
call __Unwind_Resume
| void ftxui::`anonymous namespace'::UpdatePixelStyle(long long a1, long long a2, long long a3, long long a4)
{
char v7; // dl
char v8; // si
char v9; // al
unsigned __int8 v10; // al
unsigned __int8 v11; // al
long long v12; // rax
long long v13; // rbx
__int128 *v14; // rcx
char *v15; // r13
const char *v16; // rsi
long long v17; // rax
__int128 *v18; // rcx
long long v19; // rax
char *v20; // rsi
char *v21; // rsi
__int128 *v22; // [rsp+8h] [rbp-90h]
__int128 *v23; // [rsp+8h] [rbp-90h]
long long v24; // [rsp+10h] [rbp-88h]
long long v25; // [rsp+10h] [rbp-88h]
__int128 v26; // [rsp+18h] [rbp-80h] BYREF
void *v27[2]; // [rsp+28h] [rbp-70h] BYREF
_QWORD v28[2]; // [rsp+38h] [rbp-60h] BYREF
void *v29[2]; // [rsp+48h] [rbp-50h] BYREF
_QWORD v30[8]; // [rsp+58h] [rbp-40h] BYREF
if ( *(_BYTE *)(a4 + 1) != *(_BYTE *)(a3 + 1) )
ftxui::`anonymous namespace'::UpdatePixelStyle(a2, (unsigned __int8 *)(a4 + 1), a1);
v7 = *(_BYTE *)a4 & 2;
v8 = *(_BYTE *)a3 & 2;
if ( ((unsigned __int8)(v7 ^ v8) >> 1) | (((*(_BYTE *)a4 ^ *(_BYTE *)a3) & 4) != 0) )
{
if ( v8 != 0 && v7 == 0 )
{
v15 = "\x1B[22m";
}
else
{
v15 = "";
if ( (*(_BYTE *)a3 & 4) != 0 )
{
v15 = "";
if ( (*(_BYTE *)a4 & 4) == 0 )
v15 = "\x1B[22m";
}
}
v19 = strlen(v15);
std::__ostream_insert<char,std::char_traits<char>>(a2 + 16, v15, v19);
v20 = "\x1B[1m";
if ( (*(_BYTE *)a4 & 2) == 0 )
v20 = "";
std::__ostream_insert<char,std::char_traits<char>>(a2 + 16, v20, 2 * (*(_BYTE *)a4 & 2u));
v21 = "\x1B[2m";
if ( (*(_BYTE *)a4 & 4) == 0 )
v21 = "";
std::__ostream_insert<char,std::char_traits<char>>(a2 + 16, v21, *(_BYTE *)a4 & 4);
}
if ( ((*(_BYTE *)a4 ^ *(_BYTE *)a3) & 0x30) != 0 )
ftxui::`anonymous namespace'::UpdatePixelStyle(a2, *(_BYTE *)a4);
v9 = *(_BYTE *)a4;
if ( ((*(_BYTE *)a4 ^ *(_BYTE *)a3) & 1) != 0 )
{
v16 = "\x1B[25m";
if ( (v9 & 1) != 0 )
v16 = "\x1B[5m";
std::__ostream_insert<char,std::char_traits<char>>(a2 + 16, v16, v9 & 1 ^ 5LL);
}
v10 = *(_BYTE *)a4 & 8;
if ( v10 >> 3 != _bittest((const signed __int32 *)a3, 3u) )
ftxui::`anonymous namespace'::UpdatePixelStyle(v10, a2);
v11 = *(_BYTE *)a4 & 0x40;
if ( v11 >> 6 != _bittest((const signed __int32 *)a3, 6u) )
ftxui::`anonymous namespace'::UpdatePixelStyle(v11, a2);
if ( ftxui::Color::operator!=((_BYTE *)(a4 + 44), (_BYTE *)(a3 + 44))
|| ftxui::Color::operator!=((_BYTE *)(a4 + 40), (_BYTE *)(a3 + 40)) )
{
ftxui::Color::Print[abi:cxx11]((long long)v29, (unsigned __int8 *)(a4 + 44), 0);
std::operator+<char>((long long)v27, (long long)&unk_3FE68, (long long)v29);
v12 = std::string::append(v27, "m");
v13 = a2 + 16;
v22 = &v26;
v14 = (__int128 *)(v12 + 16);
if ( *(_QWORD *)v12 == v12 + 16 )
{
v26 = *v14;
}
else
{
v22 = *(__int128 **)v12;
*(_QWORD *)&v26 = *(_QWORD *)v14;
}
v24 = *(_QWORD *)(v12 + 8);
*(_QWORD *)v12 = v14;
*(_QWORD *)(v12 + 8) = 0LL;
*(_BYTE *)(v12 + 16) = 0;
std::__ostream_insert<char,std::char_traits<char>>(v13, v22, v24);
if ( v22 != &v26 )
operator delete(v22, v26 + 1);
if ( v27[0] != v28 )
operator delete(v27[0], v28[0] + 1LL);
if ( v29[0] != v30 )
operator delete(v29[0], v30[0] + 1LL);
ftxui::Color::Print[abi:cxx11]((long long)v29, (unsigned __int8 *)(a4 + 40), 1u);
std::operator+<char>((long long)v27, (long long)&unk_3FE68, (long long)v29);
v17 = std::string::append(v27, "m");
v23 = &v26;
v18 = (__int128 *)(v17 + 16);
if ( *(_QWORD *)v17 == v17 + 16 )
{
v26 = *v18;
}
else
{
v23 = *(__int128 **)v17;
*(_QWORD *)&v26 = *(_QWORD *)v18;
}
v25 = *(_QWORD *)(v17 + 8);
*(_QWORD *)v17 = v18;
*(_QWORD *)(v17 + 8) = 0LL;
*(_BYTE *)(v17 + 16) = 0;
std::__ostream_insert<char,std::char_traits<char>>(v13, v23, v25);
if ( v23 != &v26 )
operator delete(v23, v26 + 1);
if ( v27[0] != v28 )
operator delete(v27[0], v28[0] + 1LL);
if ( v29[0] != v30 )
operator delete(v29[0], v30[0] + 1LL);
}
}
| UpdatePixelStyle:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R14,RCX
MOV R15,RDX
MOV RBX,RSI
MOV AL,byte ptr [RCX + 0x1]
CMP AL,byte ptr [RDX + 0x1]
JNZ 0x0013a171
LAB_0013a04f:
MOV AL,byte ptr [R14]
MOV EDX,EAX
AND DL,0x2
MOV CL,byte ptr [R15]
MOV ESI,ECX
AND SIL,0x2
MOV EDI,ESI
XOR DIL,DL
SHR DIL,0x1
MOV R8D,ECX
XOR R8B,AL
SHR R8B,0x2
AND R8B,0x1
OR R8B,DIL
JNZ 0x0013a185
LAB_0013a07f:
MOV AL,byte ptr [R14]
MOV CL,byte ptr [R15]
XOR CL,AL
TEST CL,0x30
JNZ 0x0013a1ca
LAB_0013a090:
MOV AL,byte ptr [R14]
MOV CL,byte ptr [R15]
XOR CL,AL
TEST CL,0x1
JNZ 0x0013a1da
LAB_0013a0a1:
MOV AL,byte ptr [R14]
AND AL,0x8
MOV ECX,EAX
SHR CL,0x3
BT dword ptr [R15],0x3
SBB CL,0x0
JNZ 0x0013a206
LAB_0013a0b9:
MOV AL,byte ptr [R14]
AND AL,0x40
MOV ECX,EAX
SHR CL,0x6
BT dword ptr [R15],0x6
SBB CL,0x0
JNZ 0x0013a216
LAB_0013a0d1:
LEA R12,[R14 + 0x2c]
LEA RSI,[R15 + 0x2c]
MOV RDI,R12
CALL 0x0012040c
TEST AL,AL
JNZ 0x0013a108
LEA RDI,[R14 + 0x28]
ADD R15,0x28
MOV RSI,R15
CALL 0x0012040c
TEST AL,AL
JNZ 0x0013a108
LAB_0013a0f9:
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013a108:
LEA R15,[RSP + 0x48]
MOV RDI,R15
MOV RSI,R12
XOR EDX,EDX
CALL 0x0012042e
LAB_0013a11a:
LEA RSI,[0x13fe68]
LEA RDI,[RSP + 0x28]
MOV RDX,R15
CALL 0x0011d28f
LAB_0013a12e:
LEA RSI,[0x140a85]
LEA RDI,[RSP + 0x28]
CALL 0x0010b7f0
LAB_0013a13f:
ADD RBX,0x10
LEA R13,[RSP + 0x18]
MOV qword ptr [R13 + -0x10],R13
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x0013a226
MOV qword ptr [RSP + 0x8],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x18],RDX
JMP 0x0013a22e
LAB_0013a171:
MOV RDX,RDI
LEA RSI,[R14 + 0x1]
MOV RDI,RBX
CALL 0x0010bc08
JMP 0x0013a04f
LAB_0013a185:
TEST DL,DL
SETZ DL
TEST SIL,SIL
SETNZ SIL
LEA R12,[RBX + 0x10]
LEA RBP,[0x13dbe1]
TEST DL,SIL
JNZ 0x0013a387
MOV R13,RBP
TEST CL,0x4
JZ 0x0013a38e
TEST AL,0x4
LEA RAX,[0x140a6c]
LEA R13,[0x13dbe1]
CMOVZ R13,RAX
JMP 0x0013a38e
LAB_0013a1ca:
MOVZX ESI,AL
MOV RDI,RBX
CALL 0x0010bc72
JMP 0x0013a090
LAB_0013a1da:
LEA RCX,[0x140a8d]
LEA RSI,[0x140a92]
TEST AL,0x1
CMOVNZ RSI,RCX
LEA RDI,[RBX + 0x10]
MOVZX EDX,AL
AND EDX,0x1
XOR RDX,0x5
CALL 0x0010b490
JMP 0x0013a0a1
LAB_0013a206:
MOVZX EDI,AL
MOV RSI,RBX
CALL 0x0010bca9
JMP 0x0013a0b9
LAB_0013a216:
MOVZX EDI,AL
MOV RSI,RBX
CALL 0x0010bcd3
JMP 0x0013a0d1
LAB_0013a226:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [R13],XMM0
LAB_0013a22e:
MOV RDX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x10],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
LAB_0013a250:
MOV RDI,RBX
CALL 0x0010b490
LAB_0013a258:
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R13
JZ 0x0013a26f
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0010b400
LAB_0013a26f:
LEA RBP,[RSP + 0x38]
MOV RDI,qword ptr [RBP + -0x10]
CMP RDI,RBP
JZ 0x0013a28a
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x0010b400
LAB_0013a28a:
LEA R12,[RSP + 0x58]
MOV RDI,qword ptr [R12 + -0x10]
CMP RDI,R12
JZ 0x0013a2a6
MOV RSI,qword ptr [RSP + 0x58]
INC RSI
CALL 0x0010b400
LAB_0013a2a6:
ADD R14,0x28
LEA R15,[RSP + 0x48]
MOV RDI,R15
MOV RSI,R14
MOV EDX,0x1
CALL 0x0012042e
LAB_0013a2bf:
LEA RSI,[0x13fe68]
LEA RDI,[RSP + 0x28]
MOV RDX,R15
CALL 0x0011d28f
LAB_0013a2d3:
LEA RSI,[0x140a85]
LEA RDI,[RSP + 0x28]
CALL 0x0010b7f0
MOV qword ptr [RSP + 0x8],R13
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x0013a307
MOV qword ptr [RSP + 0x8],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x18],RDX
JMP 0x0013a30f
LAB_0013a307:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [R13],XMM0
LAB_0013a30f:
MOV RDX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x10],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
LAB_0013a331:
MOV RDI,RBX
CALL 0x0010b490
LAB_0013a339:
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R13
JZ 0x0013a350
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0010b400
LAB_0013a350:
MOV RDI,qword ptr [RSP + 0x28]
CMP RDI,RBP
JZ 0x0013a367
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x0010b400
LAB_0013a367:
MOV RDI,qword ptr [RSP + 0x48]
CMP RDI,R12
JZ 0x0013a0f9
MOV RSI,qword ptr [RSP + 0x58]
INC RSI
CALL 0x0010b400
JMP 0x0013a0f9
LAB_0013a387:
LEA R13,[0x140a6c]
LAB_0013a38e:
MOV RDI,R13
CALL 0x0010b170
MOV RDI,R12
MOV RSI,R13
MOV RDX,RAX
CALL 0x0010b490
MOVZX EDX,byte ptr [R14]
AND EDX,0x2
LEA RSI,[0x140a72]
CMOVZ RSI,RBP
ADD EDX,EDX
MOV RDI,R12
CALL 0x0010b490
MOVZX EDX,byte ptr [R14]
AND RDX,0x4
LEA RSI,[0x140a77]
CMOVZ RSI,RBP
MOV RDI,R12
CALL 0x0010b490
JMP 0x0013a07f
|
/* ftxui::(anonymous namespace)::UpdatePixelStyle(ftxui::Screen const*, std::__cxx11::stringstream&,
ftxui::Pixel const&, ftxui::Pixel const&) */
void ftxui::(anonymous_namespace)::UpdatePixelStyle
(Screen *param_1,stringstream *param_2,Pixel *param_3,Pixel *param_4)
{
Pixel PVar1;
Pixel PVar2;
long lVar3;
int1 auVar4 [15];
int8 in_RAX;
int7 uVar8;
int7 uVar9;
long *plVar5;
int7 extraout_var;
int7 extraout_var_00;
ostream *poVar6;
size_t sVar7;
byte bVar10;
char cVar11;
ulong uVar12;
long *plVar13;
Pixel *pPVar14;
Pixel *pPVar15;
Pixel *extraout_RDX;
Pixel *extraout_RDX_00;
Pixel *extraout_RDX_01;
char *pcVar16;
int1 auVar17 [16];
long *local_90;
long local_80;
long lStack_78;
long *local_70 [2];
long local_60 [2];
long *local_50 [2];
long local_40 [2];
uVar8 = (int7)((ulong)in_RAX >> 8);
pPVar14 = param_4;
if (param_4[1] != param_3[1]) {
UpdatePixelStyle((Screen *)param_2,(stringstream *)(param_4 + 1),(Pixel *)param_1,param_4);
uVar8 = extraout_var;
}
PVar1 = *param_4;
poVar6 = (ostream *)CONCAT71(uVar8,PVar1);
pPVar15 = (Pixel *)((ulong)poVar6 & 0xffffff02);
PVar2 = *param_3;
uVar8 = (int7)((ulong)pPVar14 >> 8);
if ((((byte)PVar2 ^ (byte)PVar1) >> 2 & 1) != 0 || ((byte)PVar2 & 2) != (byte)pPVar15) {
poVar6 = (ostream *)(param_2 + 0x10);
if ((byte)pPVar15 == 0 && ((byte)PVar2 & 2) != 0) {
pcVar16 = "\x1b[22m";
}
else {
pcVar16 = "";
if ((((byte)PVar2 & 4) != 0) && (pcVar16 = "", ((byte)PVar1 & 4) == 0)) {
pcVar16 = "\x1b[22m";
}
}
sVar7 = strlen(pcVar16);
std::__ostream_insert<char,std::char_traits<char>>(poVar6,pcVar16,sVar7);
pcVar16 = "\x1b[1m";
if (((byte)*param_4 & 2) == 0) {
pcVar16 = "";
}
std::__ostream_insert<char,std::char_traits<char>>
(poVar6,pcVar16,(ulong)(((byte)*param_4 & 2) * 2));
pcVar16 = "\x1b[2m";
if (((byte)*param_4 & 4) == 0) {
pcVar16 = "";
}
poVar6 = std::__ostream_insert<char,std::char_traits<char>>
(poVar6,pcVar16,(ulong)(byte)*param_4 & 4);
pPVar15 = extraout_RDX_01;
}
uVar9 = (int7)((ulong)poVar6 >> 8);
bVar10 = (byte)*param_3 ^ (byte)*param_4;
if ((bVar10 & 0x30) != 0) {
UpdatePixelStyle((Screen *)param_2,(stringstream *)(ulong)(byte)*param_4,pPVar15,
(Pixel *)CONCAT71(uVar8,bVar10));
pPVar15 = extraout_RDX;
uVar9 = extraout_var_00;
}
PVar1 = *param_4;
poVar6 = (ostream *)CONCAT71(uVar9,PVar1);
if ((((byte)*param_3 ^ (byte)PVar1) & 1) != 0) {
pcVar16 = "\x1b[25m";
if (((byte)PVar1 & 1) != 0) {
pcVar16 = "\x1b[5m";
}
poVar6 = std::__ostream_insert<char,std::char_traits<char>>
((ostream *)(param_2 + 0x10),pcVar16,(ulong)((byte)PVar1 & 1) ^ 5);
pPVar15 = extraout_RDX_00;
}
uVar12 = CONCAT71((int7)((ulong)poVar6 >> 8),*param_4);
auVar17._8_8_ = pPVar15;
auVar17._0_8_ = uVar12 & 0xffffffffffffff08;
auVar4 = auVar17._1_15_;
uVar12 = uVar12 & 0xffffff08;
cVar11 = ((byte)uVar12 >> 3) - ((*(uint *)param_3 >> 3 & 1) != 0);
if (cVar11 != '\0') {
auVar17 = UpdatePixelStyle((Screen *)((ulong)(byte)*param_4 & 8),param_2,pPVar15,
(Pixel *)CONCAT71((int7)(uVar12 >> 8),cVar11));
auVar4 = auVar17._1_15_;
}
uVar12 = CONCAT71(auVar4._0_7_,*param_4) & 0xffffff40;
cVar11 = ((byte)uVar12 >> 6) - ((*(uint *)param_3 >> 6 & 1) != 0);
if (cVar11 != '\0') {
UpdatePixelStyle((Screen *)((ulong)(byte)*param_4 & 0x40),param_2,auVar4._7_8_,
(Pixel *)CONCAT71((int7)(uVar12 >> 8),cVar11));
}
cVar11 = Color::operator!=((Color *)(param_4 + 0x2c),(Color *)(param_3 + 0x2c));
if ((cVar11 != '\0') ||
(cVar11 = Color::operator!=((Color *)(param_4 + 0x28),(Color *)(param_3 + 0x28)),
cVar11 != '\0')) {
Color::Print_abi_cxx11_(SUB81(local_50,0));
/* try { // try from 0013a11a to 0013a12d has its CatchHandler @ 0013a463 */
std::operator+((char *)local_70,(string *)&DAT_0013fe68);
/* try { // try from 0013a12e to 0013a13e has its CatchHandler @ 0013a443 */
plVar5 = (long *)std::__cxx11::string::append((char *)local_70);
plVar13 = plVar5 + 2;
if ((long *)*plVar5 == plVar13) {
local_80 = *plVar13;
lStack_78 = plVar5[3];
local_90 = &local_80;
}
else {
local_80 = *plVar13;
local_90 = (long *)*plVar5;
}
lVar3 = plVar5[1];
*plVar5 = (long)plVar13;
plVar5[1] = 0;
*(int1 *)(plVar5 + 2) = 0;
/* try { // try from 0013a250 to 0013a257 has its CatchHandler @ 0013a427 */
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)(param_2 + 0x10),(char *)local_90,lVar3);
if (local_90 != &local_80) {
operator_delete(local_90,local_80 + 1);
}
if (local_70[0] != local_60) {
operator_delete(local_70[0],local_60[0] + 1);
}
if (local_50[0] != local_40) {
operator_delete(local_50[0],local_40[0] + 1);
}
Color::Print_abi_cxx11_(SUB81(local_50,0));
/* try { // try from 0013a2bf to 0013a2d2 has its CatchHandler @ 0013a418 */
std::operator+((char *)local_70,(string *)&DAT_0013fe68);
/* try { // try from 0013a2d3 to 0013a2e3 has its CatchHandler @ 0013a3fc */
plVar5 = (long *)std::__cxx11::string::append((char *)local_70);
plVar13 = plVar5 + 2;
if ((long *)*plVar5 == plVar13) {
local_80 = *plVar13;
lStack_78 = plVar5[3];
local_90 = &local_80;
}
else {
local_80 = *plVar13;
local_90 = (long *)*plVar5;
}
lVar3 = plVar5[1];
*plVar5 = (long)plVar13;
plVar5[1] = 0;
*(int1 *)(plVar5 + 2) = 0;
/* try { // try from 0013a331 to 0013a338 has its CatchHandler @ 0013a3e0 */
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)(param_2 + 0x10),(char *)local_90,lVar3);
if (local_90 != &local_80) {
operator_delete(local_90,local_80 + 1);
}
if (local_70[0] != local_60) {
operator_delete(local_70[0],local_60[0] + 1);
}
if (local_50[0] != local_40) {
operator_delete(local_50[0],local_40[0] + 1);
}
}
return;
}
|
|
923 | pagecache_delete_internal | eloqsql/storage/maria/ma_pagecache.c | static my_bool pagecache_delete_internal(PAGECACHE *pagecache,
PAGECACHE_BLOCK_LINK *block,
PAGECACHE_HASH_LINK *page_link,
my_bool flush)
{
my_bool error= 0;
if (block->status & PCBLOCK_IN_FLUSH)
{
/*
this call is just 'hint' for the cache to free the page so we will
not interferes with flushing process but must return success
*/
goto out;
}
if (block->status & PCBLOCK_CHANGED)
{
flush= (flush || (block->status & PCBLOCK_DEL_WRITE));
if (flush)
{
/* The block contains a dirty page - push it out of the cache */
KEYCACHE_DBUG_PRINT("find_block", ("block is dirty"));
/*
The call is thread safe because only the current
thread might change the block->hash_link value
*/
DBUG_ASSERT(block->pins == 1);
pagecache_pthread_mutex_unlock(&pagecache->cache_lock);
error= pagecache_fwrite(pagecache,
&block->hash_link->file,
block->buffer,
block->hash_link->pageno,
block->type,
pagecache->readwrite_flags);
pagecache_pthread_mutex_lock(&pagecache->cache_lock);
pagecache->global_cache_write++;
if (error)
{
block->status|= PCBLOCK_ERROR;
block->error= (int16) my_errno;
my_debug_put_break_here();
goto out;
}
}
else
{
PAGECACHE_IO_HOOK_ARGS args;
PAGECACHE_FILE *filedesc= &block->hash_link->file;
args.page= block->buffer;
args.pageno= block->hash_link->pageno;
args.data= filedesc->callback_data;
/* We are not going to write the page but have to call callbacks */
DBUG_PRINT("info", ("flush_callback: %p data: %p",
filedesc->flush_log_callback,
filedesc->callback_data));
if ((*filedesc->flush_log_callback)(&args))
{
DBUG_PRINT("error", ("flush or write callback problem"));
error= 1;
goto out;
}
}
pagecache->blocks_changed--;
pagecache->global_blocks_changed--;
/*
free_block() will change the status and rec_lsn of the block so no
need to change them here.
*/
}
/* Cache is locked, so we can relese page before freeing it */
if (make_lock_and_pin(pagecache, block,
PAGECACHE_LOCK_WRITE_UNLOCK,
PAGECACHE_UNPIN, FALSE))
DBUG_ASSERT(0);
DBUG_ASSERT(block->hash_link->requests > 0);
page_link->requests--;
/* See NOTE for pagecache_unlock() about registering requests. */
free_block(pagecache, block, 0);
dec_counter_for_resize_op(pagecache);
return 0;
out:
/* Cache is locked, so we can relese page before freeing it */
if (make_lock_and_pin(pagecache, block,
PAGECACHE_LOCK_WRITE_UNLOCK,
PAGECACHE_UNPIN, FALSE))
DBUG_ASSERT(0);
page_link->requests--;
unreg_request(pagecache, block, 1);
dec_counter_for_resize_op(pagecache);
return error;
} | O3 | c | pagecache_delete_internal:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movzwl 0x74(%rsi), %eax
testb $0x10, %al
jne 0x3ef6b
testb $0x20, %al
je 0x3f04a
testb %cl, %cl
sete %cl
testb %al, %al
setns %al
testb %al, %cl
je 0x3efc5
movq 0x20(%r14), %rax
movq 0x30(%r14), %rcx
leaq -0x48(%rbp), %rdi
movq %rcx, (%rdi)
movq 0x60(%rax), %rcx
movq %rcx, 0x8(%rdi)
movq 0x58(%rax), %rcx
movq %rcx, 0x10(%rdi)
callq *0x50(%rax)
movb $0x1, %r12b
testb %al, %al
jne 0x3ef6e
jmp 0x3f03f
xorl %r12d, %r12d
movq %rbx, %rdi
movq %r14, %rsi
movl $0x6, %edx
movl $0x3, %ecx
callq 0x3d95f
decl 0x68(%r15)
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x3dacf
decq 0x68(%rbx)
jne 0x3f0a4
movq 0x110(%rbx), %rax
testq %rax, %rax
je 0x3f0a4
movq 0x88(%rax), %rbx
movq 0x38(%rbx), %rdi
addq $0x8, %rbx
jmp 0x3f097
leaq 0xc8(%rbx), %r13
movq 0x108(%rbx), %rdi
testq %rdi, %rdi
jne 0x3f0cd
movq %r13, %rdi
callq 0x2a1e0
movq 0x20(%r14), %rsi
movq 0x30(%r14), %rdx
movq 0x60(%rsi), %rcx
addq $0x18, %rsi
movq 0x198(%rbx), %r8
movq %rbx, %rdi
callq 0x3fae0
movl %eax, %r12d
cmpq $0x0, 0x108(%rbx)
jne 0x3f0e2
movq %r13, %rdi
callq 0x2a220
incq 0x178(%rbx)
testb %r12b, %r12b
je 0x3f03f
orb $0x1, 0x74(%r14)
callq 0xa8156
movzwl (%rax), %eax
movw %ax, 0x76(%r14)
jmp 0x3ef6e
decq 0x58(%rbx)
decq 0x168(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movl $0x6, %edx
movl $0x3, %ecx
callq 0x3d95f
decl 0x68(%r15)
xorl %r12d, %r12d
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x40681
decq 0x68(%rbx)
jne 0x3f0a4
movq 0x110(%rbx), %rax
testq %rax, %rax
je 0x3f0b6
movq 0x88(%rax), %rbx
movq 0x38(%rbx), %rdi
addq $0x8, %rbx
xorl %r12d, %r12d
testq %rdi, %rdi
jne 0x3f0bb
movq %rbx, %rdi
callq 0x2a630
movl %r12d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r12d, %r12d
jmp 0x3f0a4
leaq 0x350196(%rip), %rax # 0x38f258
movq (%rax), %rax
callq *0x170(%rax)
jmp 0x3f09c
leaq 0x350184(%rip), %rax # 0x38f258
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x3efdc
leaq 0xa2a34(%rip), %rsi # 0xe1b1d
movq %r13, %rdi
movl $0xfa2, %edx # imm = 0xFA2
callq 0x30603
jmp 0x3f01c
| pagecache_delete_internal:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r15, rdx
mov r14, rsi
mov rbx, rdi
movzx eax, word ptr [rsi+74h]
test al, 10h
jnz short loc_3EF6B
test al, 20h
jz loc_3F04A
test cl, cl
setz cl
test al, al
setns al
test cl, al
jz loc_3EFC5
mov rax, [r14+20h]
mov rcx, [r14+30h]
lea rdi, [rbp+var_48]
mov [rdi], rcx
mov rcx, [rax+60h]
mov [rdi+8], rcx
mov rcx, [rax+58h]
mov [rdi+10h], rcx
call qword ptr [rax+50h]
mov r12b, 1
test al, al
jnz short loc_3EF6E
jmp loc_3F03F
loc_3EF6B:
xor r12d, r12d
loc_3EF6E:
mov rdi, rbx
mov rsi, r14
mov edx, 6
mov ecx, 3
call make_lock_and_pin
dec dword ptr [r15+68h]
mov rdi, rbx
mov rsi, r14
mov edx, 1
call unreg_request
dec qword ptr [rbx+68h]
jnz loc_3F0A4
mov rax, [rbx+110h]
test rax, rax
jz loc_3F0A4
mov rbx, [rax+88h]
mov rdi, [rbx+38h]
add rbx, 8
jmp loc_3F097
loc_3EFC5:
lea r13, [rbx+0C8h]
mov rdi, [rbx+108h]
test rdi, rdi
jnz loc_3F0CD
loc_3EFDC:
mov rdi, r13
call _pthread_mutex_unlock
mov rsi, [r14+20h]
mov rdx, [r14+30h]
mov rcx, [rsi+60h]
add rsi, 18h
mov r8, [rbx+198h]
mov rdi, rbx
call pagecache_fwrite
mov r12d, eax
cmp qword ptr [rbx+108h], 0
jnz loc_3F0E2
mov rdi, r13
call _pthread_mutex_lock
loc_3F01C:
inc qword ptr [rbx+178h]
test r12b, r12b
jz short loc_3F03F
or byte ptr [r14+74h], 1
call _my_thread_var
movzx eax, word ptr [rax]
mov [r14+76h], ax
jmp loc_3EF6E
loc_3F03F:
dec qword ptr [rbx+58h]
dec qword ptr [rbx+168h]
loc_3F04A:
mov rdi, rbx
mov rsi, r14
mov edx, 6
mov ecx, 3
call make_lock_and_pin
dec dword ptr [r15+68h]
xor r12d, r12d
mov rdi, rbx
mov rsi, r14
xor edx, edx
call free_block
dec qword ptr [rbx+68h]
jnz short loc_3F0A4
mov rax, [rbx+110h]
test rax, rax
jz short loc_3F0B6
mov rbx, [rax+88h]
mov rdi, [rbx+38h]
add rbx, 8
xor r12d, r12d
loc_3F097:
test rdi, rdi
jnz short loc_3F0BB
loc_3F09C:
mov rdi, rbx
call _pthread_cond_signal
loc_3F0A4:
mov eax, r12d
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3F0B6:
xor r12d, r12d
jmp short loc_3F0A4
loc_3F0BB:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+170h]
jmp short loc_3F09C
loc_3F0CD:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp loc_3EFDC
loc_3F0E2:
lea rsi, aWorkspaceLlm4b_26; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r13
mov edx, 0FA2h
call psi_mutex_lock
jmp loc_3F01C
| long long pagecache_delete_internal(_QWORD *a1, long long a2, long long a3, char a4)
{
unsigned int v4; // r12d
__int16 v7; // ax
bool v8; // zf
long long v9; // rax
long long v10; // rbx
long long v11; // rdi
long long v12; // rbx
_QWORD *v13; // rdi
long long v14; // rax
long long v15; // rbx
v7 = *(_WORD *)(a2 + 116);
if ( (v7 & 0x10) != 0 )
{
v4 = 0;
}
else
{
if ( (v7 & 0x20) == 0 )
{
LABEL_17:
make_lock_and_pin((long long)a1, a2, 6, 3);
--*(_DWORD *)(a3 + 104);
v4 = 0;
free_block(a1, a2, 0LL);
v8 = a1[13]-- == 1LL;
if ( !v8 )
return v4;
v14 = a1[34];
if ( !v14 )
return 0;
v15 = *(_QWORD *)(v14 + 136);
v11 = *(_QWORD *)(v15 + 56);
v12 = v15 + 8;
v4 = 0;
goto LABEL_20;
}
if ( (v7 & 0x80u) == 0 && a4 == 0 )
{
LOBYTE(v4) = 1;
if ( !(*(unsigned __int8 (**)(void))(*(_QWORD *)(a2 + 32) + 80LL))() )
{
LABEL_16:
--a1[11];
--a1[45];
goto LABEL_17;
}
}
else
{
if ( a1[33] )
PSI_server[44]();
pthread_mutex_unlock(a1 + 25);
v4 = pagecache_fwrite(
a1,
*(_QWORD *)(a2 + 32) + 24LL,
*(_QWORD *)(a2 + 48),
*(_QWORD *)(*(_QWORD *)(a2 + 32) + 96LL),
a1[51]);
v13 = a1 + 25;
if ( a1[33] )
psi_mutex_lock(
(long long)(a1 + 25),
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",
0xFA2u);
else
pthread_mutex_lock(a1 + 25);
++a1[47];
if ( !(_BYTE)v4 )
goto LABEL_16;
*(_BYTE *)(a2 + 116) |= 1u;
*(_WORD *)(a2 + 118) = *(_WORD *)my_thread_var(v13);
}
}
make_lock_and_pin((long long)a1, a2, 6, 3);
--*(_DWORD *)(a3 + 104);
unreg_request(a1, a2, 1);
v8 = a1[13]-- == 1LL;
if ( !v8 )
return v4;
v9 = a1[34];
if ( !v9 )
return v4;
v10 = *(_QWORD *)(v9 + 136);
v11 = *(_QWORD *)(v10 + 56);
v12 = v10 + 8;
LABEL_20:
if ( v11 )
PSI_server[46]();
pthread_cond_signal(v12);
return v4;
}
| pagecache_delete_internal:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R15,RDX
MOV R14,RSI
MOV RBX,RDI
MOVZX EAX,word ptr [RSI + 0x74]
TEST AL,0x10
JNZ 0x0013ef6b
TEST AL,0x20
JZ 0x0013f04a
TEST CL,CL
SETZ CL
TEST AL,AL
SETNS AL
TEST CL,AL
JZ 0x0013efc5
MOV RAX,qword ptr [R14 + 0x20]
MOV RCX,qword ptr [R14 + 0x30]
LEA RDI,[RBP + -0x48]
MOV qword ptr [RDI],RCX
MOV RCX,qword ptr [RAX + 0x60]
MOV qword ptr [RDI + 0x8],RCX
MOV RCX,qword ptr [RAX + 0x58]
MOV qword ptr [RDI + 0x10],RCX
CALL qword ptr [RAX + 0x50]
MOV R12B,0x1
TEST AL,AL
JNZ 0x0013ef6e
JMP 0x0013f03f
LAB_0013ef6b:
XOR R12D,R12D
LAB_0013ef6e:
MOV RDI,RBX
MOV RSI,R14
MOV EDX,0x6
MOV ECX,0x3
CALL 0x0013d95f
DEC dword ptr [R15 + 0x68]
MOV RDI,RBX
MOV RSI,R14
MOV EDX,0x1
CALL 0x0013dacf
DEC qword ptr [RBX + 0x68]
JNZ 0x0013f0a4
MOV RAX,qword ptr [RBX + 0x110]
TEST RAX,RAX
JZ 0x0013f0a4
MOV RBX,qword ptr [RAX + 0x88]
MOV RDI,qword ptr [RBX + 0x38]
ADD RBX,0x8
JMP 0x0013f097
LAB_0013efc5:
LEA R13,[RBX + 0xc8]
MOV RDI,qword ptr [RBX + 0x108]
TEST RDI,RDI
JNZ 0x0013f0cd
LAB_0013efdc:
MOV RDI,R13
CALL 0x0012a1e0
MOV RSI,qword ptr [R14 + 0x20]
MOV RDX,qword ptr [R14 + 0x30]
MOV RCX,qword ptr [RSI + 0x60]
ADD RSI,0x18
MOV R8,qword ptr [RBX + 0x198]
MOV RDI,RBX
CALL 0x0013fae0
MOV R12D,EAX
CMP qword ptr [RBX + 0x108],0x0
JNZ 0x0013f0e2
MOV RDI,R13
CALL 0x0012a220
LAB_0013f01c:
INC qword ptr [RBX + 0x178]
TEST R12B,R12B
JZ 0x0013f03f
OR byte ptr [R14 + 0x74],0x1
CALL 0x001a8156
MOVZX EAX,word ptr [RAX]
MOV word ptr [R14 + 0x76],AX
JMP 0x0013ef6e
LAB_0013f03f:
DEC qword ptr [RBX + 0x58]
DEC qword ptr [RBX + 0x168]
LAB_0013f04a:
MOV RDI,RBX
MOV RSI,R14
MOV EDX,0x6
MOV ECX,0x3
CALL 0x0013d95f
DEC dword ptr [R15 + 0x68]
XOR R12D,R12D
MOV RDI,RBX
MOV RSI,R14
XOR EDX,EDX
CALL 0x00140681
DEC qword ptr [RBX + 0x68]
JNZ 0x0013f0a4
MOV RAX,qword ptr [RBX + 0x110]
TEST RAX,RAX
JZ 0x0013f0b6
MOV RBX,qword ptr [RAX + 0x88]
MOV RDI,qword ptr [RBX + 0x38]
ADD RBX,0x8
XOR R12D,R12D
LAB_0013f097:
TEST RDI,RDI
JNZ 0x0013f0bb
LAB_0013f09c:
MOV RDI,RBX
CALL 0x0012a630
LAB_0013f0a4:
MOV EAX,R12D
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013f0b6:
XOR R12D,R12D
JMP 0x0013f0a4
LAB_0013f0bb:
LEA RAX,[0x48f258]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x170]
JMP 0x0013f09c
LAB_0013f0cd:
LEA RAX,[0x48f258]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x0013efdc
LAB_0013f0e2:
LEA RSI,[0x1e1b1d]
MOV RDI,R13
MOV EDX,0xfa2
CALL 0x00130603
JMP 0x0013f01c
|
ulong pagecache_delete_internal(long param_1,long param_2,long param_3,char param_4)
{
long *plVar1;
pthread_mutex_t *__mutex;
ushort uVar2;
long lVar3;
char cVar4;
uint uVar5;
int2 *puVar6;
long lVar7;
int8 unaff_R12;
ulong uVar8;
uVar2 = *(ushort *)(param_2 + 0x74);
if ((uVar2 & 0x10) != 0) {
uVar8 = 0;
goto LAB_0013ef6e;
}
if ((uVar2 & 0x20) == 0) {
LAB_0013f04a:
make_lock_and_pin(param_1,param_2,6,3);
*(int *)(param_3 + 0x68) = *(int *)(param_3 + 0x68) + -1;
uVar8 = 0;
free_block(param_1,param_2,0);
plVar1 = (long *)(param_1 + 0x68);
*plVar1 = *plVar1 + -1;
if (*plVar1 != 0) goto LAB_0013f0a4;
if (*(long *)(param_1 + 0x110) == 0) {
uVar8 = 0;
goto LAB_0013f0a4;
}
lVar3 = *(long *)(*(long *)(param_1 + 0x110) + 0x88);
lVar7 = *(long *)(lVar3 + 0x38);
uVar8 = 0;
}
else {
if (param_4 == '\0' && -1 < (char)uVar2) {
cVar4 = (**(code **)(*(long *)(param_2 + 0x20) + 0x50))();
uVar8 = CONCAT71((int7)((ulong)unaff_R12 >> 8),1);
if (cVar4 == '\0') {
LAB_0013f03f:
*(long *)(param_1 + 0x58) = *(long *)(param_1 + 0x58) + -1;
*(long *)(param_1 + 0x168) = *(long *)(param_1 + 0x168) + -1;
goto LAB_0013f04a;
}
}
else {
__mutex = (pthread_mutex_t *)(param_1 + 200);
if (*(long *)(param_1 + 0x108) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
uVar5 = pagecache_fwrite(param_1,*(long *)(param_2 + 0x20) + 0x18,
*(int8 *)(param_2 + 0x30),
*(int8 *)(*(long *)(param_2 + 0x20) + 0x60),
*(int8 *)(param_1 + 0x198));
uVar8 = (ulong)uVar5;
if (*(long *)(param_1 + 0x108) == 0) {
pthread_mutex_lock(__mutex);
}
else {
psi_mutex_lock(__mutex,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",0xfa2
);
}
*(long *)(param_1 + 0x178) = *(long *)(param_1 + 0x178) + 1;
if ((char)uVar5 == '\0') goto LAB_0013f03f;
*(byte *)(param_2 + 0x74) = *(byte *)(param_2 + 0x74) | 1;
puVar6 = (int2 *)_my_thread_var();
*(int2 *)(param_2 + 0x76) = *puVar6;
}
LAB_0013ef6e:
make_lock_and_pin(param_1,param_2,6,3);
*(int *)(param_3 + 0x68) = *(int *)(param_3 + 0x68) + -1;
unreg_request(param_1,param_2,1);
plVar1 = (long *)(param_1 + 0x68);
*plVar1 = *plVar1 + -1;
if ((*plVar1 != 0) || (*(long *)(param_1 + 0x110) == 0)) goto LAB_0013f0a4;
lVar3 = *(long *)(*(long *)(param_1 + 0x110) + 0x88);
lVar7 = *(long *)(lVar3 + 0x38);
}
if (lVar7 != 0) {
(**(code **)(PSI_server + 0x170))();
}
pthread_cond_signal((pthread_cond_t *)(lVar3 + 8));
LAB_0013f0a4:
return uVar8 & 0xffffffff;
}
|
|
924 | LefDefParser::defiGeometries::points(int, int*, int*) const | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defiMisc.cpp | void defiGeometries::points(int index, int* x, int* y) const {
char msg[160];
if ((index < 0) || (index >= numPoints_)) {
sprintf (msg, "ERROR (LEFPARS-6070): The index number %d given for GEOMETRY POINTS is invalid.\nValid index is from 0 to %d", index, numPoints_);
defiError(0, 6070, msg, defData);
return;
}
*x = x_[index];
*y = y_[index];
return;
} | O0 | cpp | LefDefParser::defiGeometries::points(int, int*, int*) const:
subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movl %esi, 0xcc(%rsp)
movq %rdx, 0xc0(%rsp)
movq %rcx, 0xb8(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0xcc(%rsp)
jl 0x27b6d
movq 0x8(%rsp), %rcx
movl 0xcc(%rsp), %eax
cmpl (%rcx), %eax
jl 0x27baa
movq 0x8(%rsp), %rax
leaq 0x10(%rsp), %rdi
movl 0xcc(%rsp), %edx
movl (%rax), %ecx
leaq 0x498db(%rip), %rsi # 0x71462
movb $0x0, %al
callq 0x7060
movq 0x8(%rsp), %rax
leaq 0x10(%rsp), %rdx
movq 0x18(%rax), %rcx
xorl %edi, %edi
movl $0x17b6, %esi # imm = 0x17B6
callq 0x277e0
jmp 0x27be1
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movslq 0xcc(%rsp), %rdx
movl (%rcx,%rdx,4), %edx
movq 0xc0(%rsp), %rcx
movl %edx, (%rcx)
movq 0x10(%rax), %rax
movslq 0xcc(%rsp), %rcx
movl (%rax,%rcx,4), %ecx
movq 0xb8(%rsp), %rax
movl %ecx, (%rax)
addq $0xd8, %rsp
retq
nopl (%rax)
| _ZNK12LefDefParser14defiGeometries6pointsEiPiS1_:
sub rsp, 0D8h
mov [rsp+0D8h+var_8], rdi
mov [rsp+0D8h+var_C], esi
mov [rsp+0D8h+var_18], rdx
mov [rsp+0D8h+var_20], rcx
mov rax, [rsp+0D8h+var_8]
mov [rsp+0D8h+var_D0], rax
cmp [rsp+0D8h+var_C], 0
jl short loc_27B6D
mov rcx, [rsp+0D8h+var_D0]
mov eax, [rsp+0D8h+var_C]
cmp eax, [rcx]
jl short loc_27BAA
loc_27B6D:
mov rax, [rsp+0D8h+var_D0]
lea rdi, [rsp+0D8h+var_C8]
mov edx, [rsp+0D8h+var_C]
mov ecx, [rax]
lea rsi, aErrorLefpars60; "ERROR (LEFPARS-6070): The index number "...
mov al, 0
call _sprintf
mov rax, [rsp+0D8h+var_D0]
lea rdx, [rsp+0D8h+var_C8]; int
mov rcx, [rax+18h]; char *
xor edi, edi; this
mov esi, 17B6h; int
call _ZN12LefDefParser9defiErrorEiiPKcPNS_8defrDataE; LefDefParser::defiError(int,int,char const*,LefDefParser::defrData *)
jmp short loc_27BE1
loc_27BAA:
mov rax, [rsp+0D8h+var_D0]
mov rcx, [rax+8]
movsxd rdx, [rsp+0D8h+var_C]
mov edx, [rcx+rdx*4]
mov rcx, [rsp+0D8h+var_18]
mov [rcx], edx
mov rax, [rax+10h]
movsxd rcx, [rsp+0D8h+var_C]
mov ecx, [rax+rcx*4]
mov rax, [rsp+0D8h+var_20]
mov [rax], ecx
loc_27BE1:
add rsp, 0D8h
retn
| int * LefDefParser::defiGeometries::points(LefDefParser::defrData **this, int a2, int *a3, int *a4)
{
LefDefParser::defrData *v4; // r8
int *result; // rax
char v6[168]; // [rsp+10h] [rbp-C8h] BYREF
int *v7; // [rsp+B8h] [rbp-20h]
int *v8; // [rsp+C0h] [rbp-18h]
int v9; // [rsp+CCh] [rbp-Ch]
LefDefParser::defiGeometries *v10; // [rsp+D0h] [rbp-8h]
v10 = (LefDefParser::defiGeometries *)this;
v9 = a2;
v8 = a3;
v7 = a4;
if ( a2 >= 0 && v9 < *(_DWORD *)this )
{
*v8 = *((_DWORD *)this[1] + v9);
result = v7;
*v7 = *((_DWORD *)this[2] + v9);
}
else
{
sprintf(
v6,
"ERROR (LEFPARS-6070): The index number %d given for GEOMETRY POINTS is invalid.\nValid index is from 0 to %d",
v9,
*(_DWORD *)this);
return (int *)LefDefParser::defiError(0LL, 6070, v6, this[3], v4);
}
return result;
}
| points:
SUB RSP,0xd8
MOV qword ptr [RSP + 0xd0],RDI
MOV dword ptr [RSP + 0xcc],ESI
MOV qword ptr [RSP + 0xc0],RDX
MOV qword ptr [RSP + 0xb8],RCX
MOV RAX,qword ptr [RSP + 0xd0]
MOV qword ptr [RSP + 0x8],RAX
CMP dword ptr [RSP + 0xcc],0x0
JL 0x00127b6d
MOV RCX,qword ptr [RSP + 0x8]
MOV EAX,dword ptr [RSP + 0xcc]
CMP EAX,dword ptr [RCX]
JL 0x00127baa
LAB_00127b6d:
MOV RAX,qword ptr [RSP + 0x8]
LEA RDI,[RSP + 0x10]
MOV EDX,dword ptr [RSP + 0xcc]
MOV ECX,dword ptr [RAX]
LEA RSI,[0x171462]
MOV AL,0x0
CALL 0x00107060
MOV RAX,qword ptr [RSP + 0x8]
LEA RDX,[RSP + 0x10]
MOV RCX,qword ptr [RAX + 0x18]
XOR EDI,EDI
MOV ESI,0x17b6
CALL 0x001277e0
JMP 0x00127be1
LAB_00127baa:
MOV RAX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RAX + 0x8]
MOVSXD RDX,dword ptr [RSP + 0xcc]
MOV EDX,dword ptr [RCX + RDX*0x4]
MOV RCX,qword ptr [RSP + 0xc0]
MOV dword ptr [RCX],EDX
MOV RAX,qword ptr [RAX + 0x10]
MOVSXD RCX,dword ptr [RSP + 0xcc]
MOV ECX,dword ptr [RAX + RCX*0x4]
MOV RAX,qword ptr [RSP + 0xb8]
MOV dword ptr [RAX],ECX
LAB_00127be1:
ADD RSP,0xd8
RET
|
/* LefDefParser::defiGeometries::points(int, int*, int*) const */
void __thiscall
LefDefParser::defiGeometries::points(defiGeometries *this,int param_1,int *param_2,int *param_3)
{
char local_c8 [168];
int *local_20;
int *local_18;
int local_c;
defiGeometries *local_8;
if ((param_1 < 0) || (*(int *)this <= param_1)) {
local_20 = param_3;
local_18 = param_2;
local_c = param_1;
local_8 = this;
sprintf(local_c8,
"ERROR (LEFPARS-6070): The index number %d given for GEOMETRY POINTS is invalid.\nValid index is from 0 to %d"
,(ulong)(uint)param_1,(ulong)*(uint *)this);
defiError(0,0x17b6,local_c8,*(defrData **)(this + 0x18));
}
else {
*param_2 = *(int *)(*(long *)(this + 8) + (long)param_1 * 4);
*param_3 = *(int *)(*(long *)(this + 0x10) + (long)param_1 * 4);
}
return;
}
|
|
925 | my_wc_mb_latin1 | eloqsql/strings/ctype-latin1.c | static
int my_wc_mb_latin1(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc,
uchar *str,
uchar *end __attribute__((unused)))
{
const uchar *pl;
if (str >= end)
return MY_CS_TOOSMALL;
if (wc > 0xFFFF)
return MY_CS_ILUNI;
pl= uni_to_cs[wc >> 8];
str[0]= pl ? pl[wc & 0xFF] : '\0';
return (!str[0] && wc) ? MY_CS_ILUNI : 1;
} | O3 | c | my_wc_mb_latin1:
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0x578b0
xorl %eax, %eax
cmpq $0xffff, %rsi # imm = 0xFFFF
ja 0x578b0
pushq %rbp
movq %rsp, %rbp
movq %rsi, %rax
shrq $0x8, %rax
leaq 0x2bba07(%rip), %rcx # 0x313290
movq (%rcx,%rax,8), %rax
testq %rax, %rax
je 0x5789b
movzbl %sil, %ecx
movb (%rax,%rcx), %al
jmp 0x5789d
xorl %eax, %eax
movb %al, (%rdx)
testb %al, %al
setne %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
movzbl %cl, %eax
popq %rbp
retq
| my_wc_mb_latin1:
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short locret_578B0
xor eax, eax
cmp rsi, 0FFFFh
ja short locret_578B0
push rbp
mov rbp, rsp
mov rax, rsi
shr rax, 8
lea rcx, uni_to_cs
mov rax, [rcx+rax*8]
test rax, rax
jz short loc_5789B
movzx ecx, sil
mov al, [rax+rcx]
jmp short loc_5789D
loc_5789B:
xor eax, eax
loc_5789D:
mov [rdx], al
test al, al
setnz al
test rsi, rsi
setz cl
or cl, al
movzx eax, cl
pop rbp
locret_578B0:
retn
| long long my_wc_mb_latin1(long long a1, unsigned long long a2, _BYTE *a3, unsigned long long a4)
{
long long result; // rax
long long v5; // rax
char v6; // al
result = 4294967195LL;
if ( (unsigned long long)a3 < a4 )
{
result = 0LL;
if ( a2 <= 0xFFFF )
{
v5 = (long long)*(&uni_to_cs + (a2 >> 8));
if ( v5 )
v6 = *(_BYTE *)(v5 + (unsigned __int8)a2);
else
v6 = 0;
*a3 = v6;
return (v6 != 0) | (unsigned __int8)(a2 == 0);
}
}
return result;
}
| my_wc_mb_latin1:
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x001578b0
XOR EAX,EAX
CMP RSI,0xffff
JA 0x001578b0
PUSH RBP
MOV RBP,RSP
MOV RAX,RSI
SHR RAX,0x8
LEA RCX,[0x413290]
MOV RAX,qword ptr [RCX + RAX*0x8]
TEST RAX,RAX
JZ 0x0015789b
MOVZX ECX,SIL
MOV AL,byte ptr [RAX + RCX*0x1]
JMP 0x0015789d
LAB_0015789b:
XOR EAX,EAX
LAB_0015789d:
MOV byte ptr [RDX],AL
TEST AL,AL
SETNZ AL
TEST RSI,RSI
SETZ CL
OR CL,AL
MOVZX EAX,CL
POP RBP
LAB_001578b0:
RET
|
ulong my_wc_mb_latin1(int8 param_1,ulong param_2,char *param_3,char *param_4)
{
char cVar1;
ulong uVar2;
uVar2 = 0xffffff9b;
if ((param_3 < param_4) && (uVar2 = 0, param_2 < 0x10000)) {
if (*(long *)(uni_to_cs + (param_2 >> 8) * 8) == 0) {
cVar1 = '\0';
}
else {
cVar1 = *(char *)(*(long *)(uni_to_cs + (param_2 >> 8) * 8) + (param_2 & 0xff));
}
*param_3 = cVar1;
uVar2 = (ulong)(param_2 == 0 || cVar1 != '\0');
}
return uVar2;
}
|
|
926 | JS_FreeRuntime | bluesky950520[P]quickjs/quickjs.c | void JS_FreeRuntime(JSRuntime *rt)
{
struct list_head *el, *el1;
int i;
rt->in_free = TRUE;
JS_FreeValueRT(rt, rt->current_exception);
list_for_each_safe(el, el1, &rt->job_list) {
JSJobEntry *e = list_entry(el, JSJobEntry, link);
for(i = 0; i < e->argc; i++)
JS_FreeValueRT(rt, e->argv[i]);
js_free_rt(rt, e);
}
init_list_head(&rt->job_list);
JS_RunGC(rt);
#ifdef DUMP_LEAKS
/* leaking objects */
if (check_dump_flag(rt, DUMP_LEAKS)) {
BOOL header_done;
JSGCObjectHeader *p;
int count;
/* remove the internal refcounts to display only the object
referenced externally */
list_for_each(el, &rt->gc_obj_list) {
p = list_entry(el, JSGCObjectHeader, link);
p->mark = 0;
}
gc_decref(rt);
header_done = FALSE;
list_for_each(el, &rt->gc_obj_list) {
p = list_entry(el, JSGCObjectHeader, link);
if (p->ref_count != 0) {
if (!header_done) {
printf("Object leaks:\n");
JS_DumpObjectHeader(rt);
header_done = TRUE;
}
JS_DumpGCObject(rt, p);
}
}
count = 0;
list_for_each(el, &rt->gc_obj_list) {
p = list_entry(el, JSGCObjectHeader, link);
if (p->ref_count == 0) {
count++;
}
}
if (count != 0)
printf("Secondary object leaks: %d\n", count);
}
#endif
assert(list_empty(&rt->gc_obj_list));
/* free the classes */
for(i = 0; i < rt->class_count; i++) {
JSClass *cl = &rt->class_array[i];
if (cl->class_id != 0) {
JS_FreeAtomRT(rt, cl->class_name);
}
}
js_free_rt(rt, rt->class_array);
bf_context_end(&rt->bf_ctx);
#ifdef DUMP_ATOM_LEAKS
/* only the atoms defined in JS_InitAtoms() should be left */
if (check_dump_flag(rt, DUMP_ATOM_LEAKS)) {
BOOL header_done = FALSE;
for(i = 0; i < rt->atom_size; i++) {
JSAtomStruct *p = rt->atom_array[i];
if (!atom_is_free(p) /* && p->str*/) {
if (i >= JS_ATOM_END || p->header.ref_count != 1) {
if (!header_done) {
header_done = TRUE;
if (rt->rt_info) {
printf("%s:1: atom leakage:", rt->rt_info);
} else {
printf("Atom leaks:\n"
" %6s %6s %s\n",
"ID", "REFCNT", "NAME");
}
}
if (rt->rt_info) {
printf(" ");
} else {
printf(" %6u %6u ", i, p->header.ref_count);
}
switch (p->atom_type) {
case JS_ATOM_TYPE_STRING:
JS_DumpString(rt, p);
break;
case JS_ATOM_TYPE_GLOBAL_SYMBOL:
printf("Symbol.for(");
JS_DumpString(rt, p);
printf(")");
break;
case JS_ATOM_TYPE_SYMBOL:
if (p->hash == JS_ATOM_HASH_SYMBOL) {
printf("Symbol(");
JS_DumpString(rt, p);
printf(")");
} else {
printf("Private(");
JS_DumpString(rt, p);
printf(")");
}
break;
}
if (rt->rt_info) {
printf(":%u", p->header.ref_count);
} else {
printf("\n");
}
}
}
}
if (rt->rt_info && header_done)
printf("\n");
}
#endif
/* free the atoms */
for(i = 0; i < rt->atom_size; i++) {
JSAtomStruct *p = rt->atom_array[i];
if (!atom_is_free(p)) {
#ifdef DUMP_LEAKS
list_del(&p->link);
#endif
js_free_rt(rt, p);
}
}
js_free_rt(rt, rt->atom_array);
js_free_rt(rt, rt->atom_hash);
js_free_rt(rt, rt->shape_hash);
#ifdef DUMP_LEAKS
if (check_dump_flag(rt, DUMP_LEAKS) && !list_empty(&rt->string_list)) {
if (rt->rt_info) {
printf("%s:1: string leakage:", rt->rt_info);
} else {
printf("String leaks:\n"
" %6s %s\n",
"REFCNT", "VALUE");
}
list_for_each_safe(el, el1, &rt->string_list) {
JSString *str = list_entry(el, JSString, link);
if (rt->rt_info) {
printf(" ");
} else {
printf(" %6u ", str->header.ref_count);
}
JS_DumpString(rt, str);
if (rt->rt_info) {
printf(":%u", str->header.ref_count);
} else {
printf("\n");
}
list_del(&str->link);
js_free_rt(rt, str);
}
if (rt->rt_info)
printf("\n");
}
#endif
while (rt->finalizers) {
JSRuntimeFinalizerState *fs = rt->finalizers;
rt->finalizers = fs->next;
fs->finalizer(rt, fs->arg);
js_free_rt(rt, fs);
}
#ifdef DUMP_LEAKS
if (check_dump_flag(rt, DUMP_LEAKS)) {
JSMallocState *s = &rt->malloc_state;
if (s->malloc_count > 1) {
if (rt->rt_info)
printf("%s:1: ", rt->rt_info);
printf("Memory leak: %"PRIu64" bytes lost in %"PRIu64" block%s\n",
(uint64_t)(s->malloc_size - sizeof(JSRuntime)),
(uint64_t)(s->malloc_count - 1), &"s"[s->malloc_count == 2]);
}
}
#endif
{
JSMallocState *ms = &rt->malloc_state;
rt->mf.js_free(ms->opaque, rt);
}
} | O1 | c | JS_FreeRuntime:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x1, 0x102(%rdi)
movq 0xf0(%rdi), %rsi
movq 0xf8(%rdi), %rdx
callq 0x1ccb2
leaq 0x130(%rbx), %r15
movq 0x138(%rbx), %r14
cmpq %r15, %r14
je 0x1c992
movq 0x8(%r14), %r12
cmpl $0x0, 0x20(%r14)
jle 0x1c962
leaq 0x30(%r14), %r13
xorl %ebp, %ebp
movq -0x8(%r13), %rsi
movq (%r13), %rdx
movq %rbx, %rdi
callq 0x1ccb2
incq %rbp
movslq 0x20(%r14), %rax
addq $0x10, %r13
cmpq %rax, %rbp
jl 0x1c942
testq %r14, %r14
je 0x1c98a
decq 0x28(%rbx)
movq %r14, %rdi
callq *0x20(%rbx)
movq 0x30(%rbx), %rcx
movq 0x40(%rbx), %rdi
subq %rax, %rcx
addq $-0x8, %rcx
movq %rcx, 0x30(%rbx)
movq %r14, %rsi
callq *0x10(%rbx)
movq %r12, %r14
cmpq %r15, %r12
jne 0x1c931
movq %r15, 0x130(%rbx)
movq %r15, 0x138(%rbx)
movq %rbx, %rdi
callq 0x1ccd8
cmpl $0x0, 0x78(%rbx)
jle 0x1c9fe
movl $0x4, %r14d
xorl %r15d, %r15d
movq 0x80(%rbx), %rax
cmpl $0x0, -0x4(%rax,%r14)
je 0x1c9ee
movslq (%rax,%r14), %rax
cmpq $0xe0, %rax
jl 0x1c9ee
movq 0x68(%rbx), %rcx
movq (%rcx,%rax,8), %rsi
movl (%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rsi)
cmpl $0x1, %eax
jg 0x1c9ee
movq %rbx, %rdi
callq 0x3ac4f
incq %r15
movslq 0x78(%rbx), %rax
addq $0x28, %r14
cmpq %rax, %r15
jl 0x1c9b7
movq 0x80(%rbx), %r14
testq %r14, %r14
je 0x1ca2d
decq 0x28(%rbx)
movq %r14, %rdi
callq *0x20(%rbx)
movq 0x30(%rbx), %rcx
movq 0x40(%rbx), %rdi
subq %rax, %rcx
addq $-0x8, %rcx
movq %rcx, 0x30(%rbx)
movq %r14, %rsi
callq *0x10(%rbx)
leaq 0x198(%rbx), %rdi
callq 0x83d42
cmpl $0x0, 0x58(%rbx)
jle 0x1ca86
xorl %r15d, %r15d
movq 0x68(%rbx), %rax
movq (%rax,%r15,8), %r14
testq %r14, %r14
sete %al
orb %r14b, %al
testb $0x1, %al
jne 0x1ca7a
decq 0x28(%rbx)
movq %r14, %rdi
callq *0x20(%rbx)
movq 0x30(%rbx), %rcx
movq 0x40(%rbx), %rdi
subq %rax, %rcx
addq $-0x8, %rcx
movq %rcx, 0x30(%rbx)
movq %r14, %rsi
callq *0x10(%rbx)
incq %r15
movslq 0x58(%rbx), %rax
cmpq %rax, %r15
jl 0x1ca42
movq 0x68(%rbx), %r14
testq %r14, %r14
je 0x1cab2
decq 0x28(%rbx)
movq %r14, %rdi
callq *0x20(%rbx)
movq 0x30(%rbx), %rcx
movq 0x40(%rbx), %rdi
subq %rax, %rcx
addq $-0x8, %rcx
movq %rcx, 0x30(%rbx)
movq %r14, %rsi
callq *0x10(%rbx)
movq 0x60(%rbx), %r14
testq %r14, %r14
je 0x1cade
decq 0x28(%rbx)
movq %r14, %rdi
callq *0x20(%rbx)
movq 0x30(%rbx), %rcx
movq 0x40(%rbx), %rdi
subq %rax, %rcx
addq $-0x8, %rcx
movq %rcx, 0x30(%rbx)
movq %r14, %rsi
callq *0x10(%rbx)
movq 0x190(%rbx), %r14
testq %r14, %r14
jne 0x1cb01
jmp 0x1cb24
movq (%r14), %rax
movq %rax, 0x220(%rbx)
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq *0x8(%r14)
decq 0x28(%rbx)
movq %r14, %rdi
callq *0x20(%rbx)
movq 0x30(%rbx), %rcx
movq 0x40(%rbx), %rdi
subq %rax, %rcx
addq $-0x8, %rcx
movq %rcx, 0x30(%rbx)
movq %r14, %rsi
callq *0x10(%rbx)
movq 0x220(%rbx), %r14
testq %r14, %r14
jne 0x1caec
movq 0x10(%rbx), %rax
movq 0x40(%rbx), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
| JS_FreeRuntime:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
mov byte ptr [rdi+102h], 1
mov rsi, [rdi+0F0h]
mov rdx, [rdi+0F8h]
call JS_FreeValueRT
lea r15, [rbx+130h]
mov r14, [rbx+138h]
cmp r14, r15
jz short loc_1C992
loc_1C931:
mov r12, [r14+8]
cmp dword ptr [r14+20h], 0
jle short loc_1C962
lea r13, [r14+30h]
xor ebp, ebp
loc_1C942:
mov rsi, [r13-8]
mov rdx, [r13+0]
mov rdi, rbx
call JS_FreeValueRT
inc rbp
movsxd rax, dword ptr [r14+20h]
add r13, 10h
cmp rbp, rax
jl short loc_1C942
loc_1C962:
test r14, r14
jz short loc_1C98A
dec qword ptr [rbx+28h]
mov rdi, r14
call qword ptr [rbx+20h]
mov rcx, [rbx+30h]
mov rdi, [rbx+40h]
sub rcx, rax
add rcx, 0FFFFFFFFFFFFFFF8h
mov [rbx+30h], rcx
mov rsi, r14
call qword ptr [rbx+10h]
loc_1C98A:
mov r14, r12
cmp r12, r15
jnz short loc_1C931
loc_1C992:
mov [rbx+130h], r15
mov [rbx+138h], r15
mov rdi, rbx
call JS_RunGC
cmp dword ptr [rbx+78h], 0
jle short loc_1C9FE
mov r14d, 4
xor r15d, r15d
loc_1C9B7:
mov rax, [rbx+80h]
cmp dword ptr [rax+r14-4], 0
jz short loc_1C9EE
movsxd rax, dword ptr [rax+r14]
cmp rax, 0E0h
jl short loc_1C9EE
mov rcx, [rbx+68h]
mov rsi, [rcx+rax*8]
mov eax, [rsi]
lea ecx, [rax-1]
mov [rsi], ecx
cmp eax, 1
jg short loc_1C9EE
mov rdi, rbx
call JS_FreeAtomStruct
loc_1C9EE:
inc r15
movsxd rax, dword ptr [rbx+78h]
add r14, 28h ; '('
cmp r15, rax
jl short loc_1C9B7
loc_1C9FE:
mov r14, [rbx+80h]
test r14, r14
jz short loc_1CA2D
dec qword ptr [rbx+28h]
mov rdi, r14
call qword ptr [rbx+20h]
mov rcx, [rbx+30h]
mov rdi, [rbx+40h]
sub rcx, rax
add rcx, 0FFFFFFFFFFFFFFF8h
mov [rbx+30h], rcx
mov rsi, r14
call qword ptr [rbx+10h]
loc_1CA2D:
lea rdi, [rbx+198h]
call bf_context_end
cmp dword ptr [rbx+58h], 0
jle short loc_1CA86
xor r15d, r15d
loc_1CA42:
mov rax, [rbx+68h]
mov r14, [rax+r15*8]
test r14, r14
setz al
or al, r14b
test al, 1
jnz short loc_1CA7A
dec qword ptr [rbx+28h]
mov rdi, r14
call qword ptr [rbx+20h]
mov rcx, [rbx+30h]
mov rdi, [rbx+40h]
sub rcx, rax
add rcx, 0FFFFFFFFFFFFFFF8h
mov [rbx+30h], rcx
mov rsi, r14
call qword ptr [rbx+10h]
loc_1CA7A:
inc r15
movsxd rax, dword ptr [rbx+58h]
cmp r15, rax
jl short loc_1CA42
loc_1CA86:
mov r14, [rbx+68h]
test r14, r14
jz short loc_1CAB2
dec qword ptr [rbx+28h]
mov rdi, r14
call qword ptr [rbx+20h]
mov rcx, [rbx+30h]
mov rdi, [rbx+40h]
sub rcx, rax
add rcx, 0FFFFFFFFFFFFFFF8h
mov [rbx+30h], rcx
mov rsi, r14
call qword ptr [rbx+10h]
loc_1CAB2:
mov r14, [rbx+60h]
test r14, r14
jz short loc_1CADE
dec qword ptr [rbx+28h]
mov rdi, r14
call qword ptr [rbx+20h]
mov rcx, [rbx+30h]
mov rdi, [rbx+40h]
sub rcx, rax
add rcx, 0FFFFFFFFFFFFFFF8h
mov [rbx+30h], rcx
mov rsi, r14
call qword ptr [rbx+10h]
loc_1CADE:
mov r14, [rbx+190h]
test r14, r14
jnz short loc_1CB01
jmp short loc_1CB24
loc_1CAEC:
mov rax, [r14]
mov [rbx+220h], rax
mov rsi, [r14+10h]
mov rdi, rbx
call qword ptr [r14+8]
loc_1CB01:
dec qword ptr [rbx+28h]
mov rdi, r14
call qword ptr [rbx+20h]
mov rcx, [rbx+30h]
mov rdi, [rbx+40h]
sub rcx, rax
add rcx, 0FFFFFFFFFFFFFFF8h
mov [rbx+30h], rcx
mov rsi, r14
call qword ptr [rbx+10h]
loc_1CB24:
mov r14, [rbx+220h]
test r14, r14
jnz short loc_1CAEC
mov rax, [rbx+10h]
mov rdi, [rbx+40h]
mov rsi, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp rax
| long long JS_FreeRuntime(long long a1)
{
long long v2; // r15
long long v3; // r14
long long v4; // r12
long long v5; // r13
long long v6; // rbp
long long v7; // rax
long long v8; // rdi
long long v9; // r14
long long v10; // r15
long long v11; // rax
long long v12; // rax
_DWORD *v13; // rsi
int v14; // eax
long long v15; // r14
long long v16; // rax
long long v17; // rdi
long long v18; // r15
long long v19; // r14
long long v20; // rax
long long v21; // rdi
long long v22; // r14
long long v23; // rax
long long v24; // rdi
long long v25; // r14
long long v26; // rax
long long v27; // rdi
long long v28; // r14
long long v29; // rax
long long v30; // rdi
*(_BYTE *)(a1 + 258) = 1;
JS_FreeValueRT(a1, *(_QWORD *)(a1 + 240));
v2 = a1 + 304;
v3 = *(_QWORD *)(a1 + 312);
if ( v3 != a1 + 304 )
{
do
{
v4 = *(_QWORD *)(v3 + 8);
if ( *(int *)(v3 + 32) > 0 )
{
v5 = v3 + 48;
v6 = 0LL;
do
{
JS_FreeValueRT(a1, *(_QWORD *)(v5 - 8));
++v6;
v5 += 16LL;
}
while ( v6 < *(int *)(v3 + 32) );
}
if ( v3 )
{
--*(_QWORD *)(a1 + 40);
v7 = (*(long long ( **)(long long))(a1 + 32))(v3);
v8 = *(_QWORD *)(a1 + 64);
*(_QWORD *)(a1 + 48) = *(_QWORD *)(a1 + 48) - v7 - 8;
(*(void ( **)(long long, long long))(a1 + 16))(v8, v3);
}
v3 = v4;
}
while ( v4 != v2 );
}
*(_QWORD *)(a1 + 304) = v2;
*(_QWORD *)(a1 + 312) = v2;
JS_RunGC(a1);
if ( *(int *)(a1 + 120) > 0 )
{
v9 = 4LL;
v10 = 0LL;
do
{
v11 = *(_QWORD *)(a1 + 128);
if ( *(_DWORD *)(v11 + v9 - 4) )
{
v12 = *(int *)(v11 + v9);
if ( v12 >= 224 )
{
v13 = *(_DWORD **)(*(_QWORD *)(a1 + 104) + 8 * v12);
v14 = (*v13)--;
if ( v14 <= 1 )
JS_FreeAtomStruct(a1);
}
}
++v10;
v9 += 40LL;
}
while ( v10 < *(int *)(a1 + 120) );
}
v15 = *(_QWORD *)(a1 + 128);
if ( v15 )
{
--*(_QWORD *)(a1 + 40);
v16 = (*(long long ( **)(long long))(a1 + 32))(v15);
v17 = *(_QWORD *)(a1 + 64);
*(_QWORD *)(a1 + 48) = *(_QWORD *)(a1 + 48) - v16 - 8;
(*(void ( **)(long long, long long))(a1 + 16))(v17, v15);
}
bf_context_end(a1 + 408);
if ( *(int *)(a1 + 88) > 0 )
{
v18 = 0LL;
do
{
v19 = *(_QWORD *)(*(_QWORD *)(a1 + 104) + 8 * v18);
if ( !(v19 & 1 | (v19 == 0)) )
{
--*(_QWORD *)(a1 + 40);
v20 = (*(long long ( **)(long long))(a1 + 32))(v19);
v21 = *(_QWORD *)(a1 + 64);
*(_QWORD *)(a1 + 48) = *(_QWORD *)(a1 + 48) - v20 - 8;
(*(void ( **)(long long, long long))(a1 + 16))(v21, v19);
}
++v18;
}
while ( v18 < *(int *)(a1 + 88) );
}
v22 = *(_QWORD *)(a1 + 104);
if ( v22 )
{
--*(_QWORD *)(a1 + 40);
v23 = (*(long long ( **)(long long))(a1 + 32))(v22);
v24 = *(_QWORD *)(a1 + 64);
*(_QWORD *)(a1 + 48) = *(_QWORD *)(a1 + 48) - v23 - 8;
(*(void ( **)(long long, long long))(a1 + 16))(v24, v22);
}
v25 = *(_QWORD *)(a1 + 96);
if ( v25 )
{
--*(_QWORD *)(a1 + 40);
v26 = (*(long long ( **)(long long))(a1 + 32))(v25);
v27 = *(_QWORD *)(a1 + 64);
*(_QWORD *)(a1 + 48) = *(_QWORD *)(a1 + 48) - v26 - 8;
(*(void ( **)(long long, long long))(a1 + 16))(v27, v25);
}
v28 = *(_QWORD *)(a1 + 400);
if ( v28 )
goto LABEL_29;
while ( 1 )
{
v28 = *(_QWORD *)(a1 + 544);
if ( !v28 )
break;
*(_QWORD *)(a1 + 544) = *(_QWORD *)v28;
(*(void ( **)(long long, _QWORD))(v28 + 8))(a1, *(_QWORD *)(v28 + 16));
LABEL_29:
--*(_QWORD *)(a1 + 40);
v29 = (*(long long ( **)(long long))(a1 + 32))(v28);
v30 = *(_QWORD *)(a1 + 64);
*(_QWORD *)(a1 + 48) = *(_QWORD *)(a1 + 48) - v29 - 8;
(*(void ( **)(long long, long long))(a1 + 16))(v30, v28);
}
return (*(long long ( **)(_QWORD, long long))(a1 + 16))(*(_QWORD *)(a1 + 64), a1);
}
| JS_FreeRuntime:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV byte ptr [RDI + 0x102],0x1
MOV RSI,qword ptr [RDI + 0xf0]
MOV RDX,qword ptr [RDI + 0xf8]
CALL 0x0011ccb2
LEA R15,[RBX + 0x130]
MOV R14,qword ptr [RBX + 0x138]
CMP R14,R15
JZ 0x0011c992
LAB_0011c931:
MOV R12,qword ptr [R14 + 0x8]
CMP dword ptr [R14 + 0x20],0x0
JLE 0x0011c962
LEA R13,[R14 + 0x30]
XOR EBP,EBP
LAB_0011c942:
MOV RSI,qword ptr [R13 + -0x8]
MOV RDX,qword ptr [R13]
MOV RDI,RBX
CALL 0x0011ccb2
INC RBP
MOVSXD RAX,dword ptr [R14 + 0x20]
ADD R13,0x10
CMP RBP,RAX
JL 0x0011c942
LAB_0011c962:
TEST R14,R14
JZ 0x0011c98a
DEC qword ptr [RBX + 0x28]
MOV RDI,R14
CALL qword ptr [RBX + 0x20]
MOV RCX,qword ptr [RBX + 0x30]
MOV RDI,qword ptr [RBX + 0x40]
SUB RCX,RAX
ADD RCX,-0x8
MOV qword ptr [RBX + 0x30],RCX
MOV RSI,R14
CALL qword ptr [RBX + 0x10]
LAB_0011c98a:
MOV R14,R12
CMP R12,R15
JNZ 0x0011c931
LAB_0011c992:
MOV qword ptr [RBX + 0x130],R15
MOV qword ptr [RBX + 0x138],R15
MOV RDI,RBX
CALL 0x0011ccd8
CMP dword ptr [RBX + 0x78],0x0
JLE 0x0011c9fe
MOV R14D,0x4
XOR R15D,R15D
LAB_0011c9b7:
MOV RAX,qword ptr [RBX + 0x80]
CMP dword ptr [RAX + R14*0x1 + -0x4],0x0
JZ 0x0011c9ee
MOVSXD RAX,dword ptr [RAX + R14*0x1]
CMP RAX,0xe0
JL 0x0011c9ee
MOV RCX,qword ptr [RBX + 0x68]
MOV RSI,qword ptr [RCX + RAX*0x8]
MOV EAX,dword ptr [RSI]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RSI],ECX
CMP EAX,0x1
JG 0x0011c9ee
MOV RDI,RBX
CALL 0x0013ac4f
LAB_0011c9ee:
INC R15
MOVSXD RAX,dword ptr [RBX + 0x78]
ADD R14,0x28
CMP R15,RAX
JL 0x0011c9b7
LAB_0011c9fe:
MOV R14,qword ptr [RBX + 0x80]
TEST R14,R14
JZ 0x0011ca2d
DEC qword ptr [RBX + 0x28]
MOV RDI,R14
CALL qword ptr [RBX + 0x20]
MOV RCX,qword ptr [RBX + 0x30]
MOV RDI,qword ptr [RBX + 0x40]
SUB RCX,RAX
ADD RCX,-0x8
MOV qword ptr [RBX + 0x30],RCX
MOV RSI,R14
CALL qword ptr [RBX + 0x10]
LAB_0011ca2d:
LEA RDI,[RBX + 0x198]
CALL 0x00183d42
CMP dword ptr [RBX + 0x58],0x0
JLE 0x0011ca86
XOR R15D,R15D
LAB_0011ca42:
MOV RAX,qword ptr [RBX + 0x68]
MOV R14,qword ptr [RAX + R15*0x8]
TEST R14,R14
SETZ AL
OR AL,R14B
TEST AL,0x1
JNZ 0x0011ca7a
DEC qword ptr [RBX + 0x28]
MOV RDI,R14
CALL qword ptr [RBX + 0x20]
MOV RCX,qword ptr [RBX + 0x30]
MOV RDI,qword ptr [RBX + 0x40]
SUB RCX,RAX
ADD RCX,-0x8
MOV qword ptr [RBX + 0x30],RCX
MOV RSI,R14
CALL qword ptr [RBX + 0x10]
LAB_0011ca7a:
INC R15
MOVSXD RAX,dword ptr [RBX + 0x58]
CMP R15,RAX
JL 0x0011ca42
LAB_0011ca86:
MOV R14,qword ptr [RBX + 0x68]
TEST R14,R14
JZ 0x0011cab2
DEC qword ptr [RBX + 0x28]
MOV RDI,R14
CALL qword ptr [RBX + 0x20]
MOV RCX,qword ptr [RBX + 0x30]
MOV RDI,qword ptr [RBX + 0x40]
SUB RCX,RAX
ADD RCX,-0x8
MOV qword ptr [RBX + 0x30],RCX
MOV RSI,R14
CALL qword ptr [RBX + 0x10]
LAB_0011cab2:
MOV R14,qword ptr [RBX + 0x60]
TEST R14,R14
JZ 0x0011cade
DEC qword ptr [RBX + 0x28]
MOV RDI,R14
CALL qword ptr [RBX + 0x20]
MOV RCX,qword ptr [RBX + 0x30]
MOV RDI,qword ptr [RBX + 0x40]
SUB RCX,RAX
ADD RCX,-0x8
MOV qword ptr [RBX + 0x30],RCX
MOV RSI,R14
CALL qword ptr [RBX + 0x10]
LAB_0011cade:
MOV R14,qword ptr [RBX + 0x190]
TEST R14,R14
JNZ 0x0011cb01
JMP 0x0011cb24
LAB_0011caec:
MOV RAX,qword ptr [R14]
MOV qword ptr [RBX + 0x220],RAX
MOV RSI,qword ptr [R14 + 0x10]
MOV RDI,RBX
CALL qword ptr [R14 + 0x8]
LAB_0011cb01:
DEC qword ptr [RBX + 0x28]
MOV RDI,R14
CALL qword ptr [RBX + 0x20]
MOV RCX,qword ptr [RBX + 0x30]
MOV RDI,qword ptr [RBX + 0x40]
SUB RCX,RAX
ADD RCX,-0x8
MOV qword ptr [RBX + 0x30],RCX
MOV RSI,R14
CALL qword ptr [RBX + 0x10]
LAB_0011cb24:
MOV R14,qword ptr [RBX + 0x220]
TEST R14,R14
JNZ 0x0011caec
MOV RAX,qword ptr [RBX + 0x10]
MOV RDI,qword ptr [RBX + 0x40]
MOV RSI,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP RAX
|
void JS_FreeRuntime(long param_1)
{
int iVar1;
int *piVar2;
ulong uVar3;
long lVar4;
long lVar5;
int8 *puVar6;
long lVar7;
long lVar8;
*(int1 *)(param_1 + 0x102) = 1;
JS_FreeValueRT(param_1,*(int8 *)(param_1 + 0xf0),*(int8 *)(param_1 + 0xf8));
lVar7 = param_1 + 0x130;
lVar8 = *(long *)(param_1 + 0x138);
while (lVar4 = lVar8, lVar4 != lVar7) {
lVar8 = *(long *)(lVar4 + 8);
if (0 < *(int *)(lVar4 + 0x20)) {
puVar6 = (int8 *)(lVar4 + 0x30);
lVar5 = 0;
do {
JS_FreeValueRT(param_1,puVar6[-1],*puVar6);
lVar5 = lVar5 + 1;
puVar6 = puVar6 + 2;
} while (lVar5 < *(int *)(lVar4 + 0x20));
}
if (lVar4 != 0) {
*(long *)(param_1 + 0x28) = *(long *)(param_1 + 0x28) + -1;
lVar5 = (**(code **)(param_1 + 0x20))(lVar4);
*(long *)(param_1 + 0x30) = (*(long *)(param_1 + 0x30) - lVar5) + -8;
(**(code **)(param_1 + 0x10))(*(int8 *)(param_1 + 0x40),lVar4);
}
}
*(long *)(param_1 + 0x130) = lVar7;
*(long *)(param_1 + 0x138) = lVar7;
JS_RunGC(param_1);
if (0 < *(int *)(param_1 + 0x78)) {
lVar7 = 4;
lVar8 = 0;
do {
if (((*(int *)(*(long *)(param_1 + 0x80) + -4 + lVar7) != 0) &&
(lVar4 = (long)*(int *)(*(long *)(param_1 + 0x80) + lVar7), 0xdf < lVar4)) &&
(piVar2 = *(int **)(*(long *)(param_1 + 0x68) + lVar4 * 8), iVar1 = *piVar2,
*piVar2 = iVar1 + -1, iVar1 < 2)) {
JS_FreeAtomStruct(param_1);
}
lVar8 = lVar8 + 1;
lVar7 = lVar7 + 0x28;
} while (lVar8 < *(int *)(param_1 + 0x78));
}
lVar7 = *(long *)(param_1 + 0x80);
if (lVar7 != 0) {
*(long *)(param_1 + 0x28) = *(long *)(param_1 + 0x28) + -1;
lVar8 = (**(code **)(param_1 + 0x20))(lVar7);
*(long *)(param_1 + 0x30) = (*(long *)(param_1 + 0x30) - lVar8) + -8;
(**(code **)(param_1 + 0x10))(*(int8 *)(param_1 + 0x40),lVar7);
}
bf_context_end(param_1 + 0x198);
if (0 < *(int *)(param_1 + 0x58)) {
lVar7 = 0;
do {
uVar3 = *(ulong *)(*(long *)(param_1 + 0x68) + lVar7 * 8);
if (uVar3 != 0 && (uVar3 & 1) == 0) {
*(long *)(param_1 + 0x28) = *(long *)(param_1 + 0x28) + -1;
lVar8 = (**(code **)(param_1 + 0x20))(uVar3);
*(long *)(param_1 + 0x30) = (*(long *)(param_1 + 0x30) - lVar8) + -8;
(**(code **)(param_1 + 0x10))(*(int8 *)(param_1 + 0x40),uVar3);
}
lVar7 = lVar7 + 1;
} while (lVar7 < *(int *)(param_1 + 0x58));
}
lVar7 = *(long *)(param_1 + 0x68);
if (lVar7 != 0) {
*(long *)(param_1 + 0x28) = *(long *)(param_1 + 0x28) + -1;
lVar8 = (**(code **)(param_1 + 0x20))(lVar7);
*(long *)(param_1 + 0x30) = (*(long *)(param_1 + 0x30) - lVar8) + -8;
(**(code **)(param_1 + 0x10))(*(int8 *)(param_1 + 0x40),lVar7);
}
lVar7 = *(long *)(param_1 + 0x60);
if (lVar7 != 0) {
*(long *)(param_1 + 0x28) = *(long *)(param_1 + 0x28) + -1;
lVar8 = (**(code **)(param_1 + 0x20))(lVar7);
*(long *)(param_1 + 0x30) = (*(long *)(param_1 + 0x30) - lVar8) + -8;
(**(code **)(param_1 + 0x10))(*(int8 *)(param_1 + 0x40),lVar7);
}
puVar6 = *(int8 **)(param_1 + 400);
if (puVar6 != (int8 *)0x0) goto LAB_0011cb01;
while (puVar6 = *(int8 **)(param_1 + 0x220), puVar6 != (int8 *)0x0) {
*(int8 *)(param_1 + 0x220) = *puVar6;
(*(code *)puVar6[1])(param_1,puVar6[2]);
LAB_0011cb01:
*(long *)(param_1 + 0x28) = *(long *)(param_1 + 0x28) + -1;
lVar7 = (**(code **)(param_1 + 0x20))(puVar6);
*(long *)(param_1 + 0x30) = (*(long *)(param_1 + 0x30) - lVar7) + -8;
(**(code **)(param_1 + 0x10))(*(int8 *)(param_1 + 0x40),puVar6);
}
/* WARNING: Could not recover jumptable at 0x0011cb49. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(param_1 + 0x10))(*(int8 *)(param_1 + 0x40),param_1);
return;
}
|
|
927 | JS_FreeRuntime | bluesky950520[P]quickjs/quickjs.c | void JS_FreeRuntime(JSRuntime *rt)
{
struct list_head *el, *el1;
int i;
rt->in_free = TRUE;
JS_FreeValueRT(rt, rt->current_exception);
list_for_each_safe(el, el1, &rt->job_list) {
JSJobEntry *e = list_entry(el, JSJobEntry, link);
for(i = 0; i < e->argc; i++)
JS_FreeValueRT(rt, e->argv[i]);
js_free_rt(rt, e);
}
init_list_head(&rt->job_list);
JS_RunGC(rt);
#ifdef DUMP_LEAKS
/* leaking objects */
if (check_dump_flag(rt, DUMP_LEAKS)) {
BOOL header_done;
JSGCObjectHeader *p;
int count;
/* remove the internal refcounts to display only the object
referenced externally */
list_for_each(el, &rt->gc_obj_list) {
p = list_entry(el, JSGCObjectHeader, link);
p->mark = 0;
}
gc_decref(rt);
header_done = FALSE;
list_for_each(el, &rt->gc_obj_list) {
p = list_entry(el, JSGCObjectHeader, link);
if (p->ref_count != 0) {
if (!header_done) {
printf("Object leaks:\n");
JS_DumpObjectHeader(rt);
header_done = TRUE;
}
JS_DumpGCObject(rt, p);
}
}
count = 0;
list_for_each(el, &rt->gc_obj_list) {
p = list_entry(el, JSGCObjectHeader, link);
if (p->ref_count == 0) {
count++;
}
}
if (count != 0)
printf("Secondary object leaks: %d\n", count);
}
#endif
assert(list_empty(&rt->gc_obj_list));
/* free the classes */
for(i = 0; i < rt->class_count; i++) {
JSClass *cl = &rt->class_array[i];
if (cl->class_id != 0) {
JS_FreeAtomRT(rt, cl->class_name);
}
}
js_free_rt(rt, rt->class_array);
bf_context_end(&rt->bf_ctx);
#ifdef DUMP_ATOM_LEAKS
/* only the atoms defined in JS_InitAtoms() should be left */
if (check_dump_flag(rt, DUMP_ATOM_LEAKS)) {
BOOL header_done = FALSE;
for(i = 0; i < rt->atom_size; i++) {
JSAtomStruct *p = rt->atom_array[i];
if (!atom_is_free(p) /* && p->str*/) {
if (i >= JS_ATOM_END || p->header.ref_count != 1) {
if (!header_done) {
header_done = TRUE;
if (rt->rt_info) {
printf("%s:1: atom leakage:", rt->rt_info);
} else {
printf("Atom leaks:\n"
" %6s %6s %s\n",
"ID", "REFCNT", "NAME");
}
}
if (rt->rt_info) {
printf(" ");
} else {
printf(" %6u %6u ", i, p->header.ref_count);
}
switch (p->atom_type) {
case JS_ATOM_TYPE_STRING:
JS_DumpString(rt, p);
break;
case JS_ATOM_TYPE_GLOBAL_SYMBOL:
printf("Symbol.for(");
JS_DumpString(rt, p);
printf(")");
break;
case JS_ATOM_TYPE_SYMBOL:
if (p->hash == JS_ATOM_HASH_SYMBOL) {
printf("Symbol(");
JS_DumpString(rt, p);
printf(")");
} else {
printf("Private(");
JS_DumpString(rt, p);
printf(")");
}
break;
}
if (rt->rt_info) {
printf(":%u", p->header.ref_count);
} else {
printf("\n");
}
}
}
}
if (rt->rt_info && header_done)
printf("\n");
}
#endif
/* free the atoms */
for(i = 0; i < rt->atom_size; i++) {
JSAtomStruct *p = rt->atom_array[i];
if (!atom_is_free(p)) {
#ifdef DUMP_LEAKS
list_del(&p->link);
#endif
js_free_rt(rt, p);
}
}
js_free_rt(rt, rt->atom_array);
js_free_rt(rt, rt->atom_hash);
js_free_rt(rt, rt->shape_hash);
#ifdef DUMP_LEAKS
if (check_dump_flag(rt, DUMP_LEAKS) && !list_empty(&rt->string_list)) {
if (rt->rt_info) {
printf("%s:1: string leakage:", rt->rt_info);
} else {
printf("String leaks:\n"
" %6s %s\n",
"REFCNT", "VALUE");
}
list_for_each_safe(el, el1, &rt->string_list) {
JSString *str = list_entry(el, JSString, link);
if (rt->rt_info) {
printf(" ");
} else {
printf(" %6u ", str->header.ref_count);
}
JS_DumpString(rt, str);
if (rt->rt_info) {
printf(":%u", str->header.ref_count);
} else {
printf("\n");
}
list_del(&str->link);
js_free_rt(rt, str);
}
if (rt->rt_info)
printf("\n");
}
#endif
while (rt->finalizers) {
JSRuntimeFinalizerState *fs = rt->finalizers;
rt->finalizers = fs->next;
fs->finalizer(rt, fs->arg);
js_free_rt(rt, fs);
}
#ifdef DUMP_LEAKS
if (check_dump_flag(rt, DUMP_LEAKS)) {
JSMallocState *s = &rt->malloc_state;
if (s->malloc_count > 1) {
if (rt->rt_info)
printf("%s:1: ", rt->rt_info);
printf("Memory leak: %"PRIu64" bytes lost in %"PRIu64" block%s\n",
(uint64_t)(s->malloc_size - sizeof(JSRuntime)),
(uint64_t)(s->malloc_count - 1), &"s"[s->malloc_count == 2]);
}
}
#endif
{
JSMallocState *ms = &rt->malloc_state;
rt->mf.js_free(ms->opaque, rt);
}
} | O2 | c | JS_FreeRuntime:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x1, 0x102(%rdi)
movq 0xf0(%rdi), %rsi
movq 0xf8(%rdi), %rdx
callq 0x174b5
leaq 0x130(%rbx), %r15
movq 0x138(%rbx), %r14
cmpq %r15, %r14
je 0x1718d
movq 0x8(%r14), %r12
leaq 0x30(%r14), %r13
xorl %ebp, %ebp
movslq 0x20(%r14), %rax
cmpq %rax, %rbp
jge 0x1717d
movq -0x8(%r13), %rsi
movq (%r13), %rdx
movq %rbx, %rdi
callq 0x174b5
incq %rbp
addq $0x10, %r13
jmp 0x1715b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1654f
movq %r12, %r14
jmp 0x1714c
movq %r15, 0x130(%rbx)
movq %r15, 0x138(%rbx)
movq %rbx, %rdi
callq 0x175c1
pushq $0x4
popq %r14
xorl %r15d, %r15d
movslq 0x78(%rbx), %rax
movq 0x80(%rbx), %rsi
cmpq %rax, %r15
jge 0x171d7
cmpl $0x0, -0x4(%rsi,%r14)
je 0x171ce
movl (%rsi,%r14), %esi
movq %rbx, %rdi
callq 0x17754
incq %r15
addq $0x28, %r14
jmp 0x171aa
movq %rbx, %rdi
callq 0x1654f
leaq 0x198(%rbx), %rdi
callq 0x6e8c4
xorl %r14d, %r14d
movslq 0x58(%rbx), %rax
movq 0x68(%rbx), %rsi
cmpq %rax, %r14
jge 0x17212
movq (%rsi,%r14,8), %rsi
testb $0x1, %sil
jne 0x1720d
movq %rbx, %rdi
callq 0x1654f
incq %r14
jmp 0x171ee
movq %rbx, %rdi
callq 0x1654f
movq 0x60(%rbx), %rsi
movq %rbx, %rdi
callq 0x1654f
movq 0x190(%rbx), %rsi
movq %rbx, %rdi
callq 0x1654f
movq 0x220(%rbx), %r14
testq %r14, %r14
je 0x1725e
movq (%r14), %rax
movq %rax, 0x220(%rbx)
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq *0x8(%r14)
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x17230
movq 0x10(%rbx), %rax
movq 0x40(%rbx), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
| JS_FreeRuntime:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
mov byte ptr [rdi+102h], 1
mov rsi, [rdi+0F0h]
mov rdx, [rdi+0F8h]
call JS_FreeValueRT
lea r15, [rbx+130h]
mov r14, [rbx+138h]
loc_1714C:
cmp r14, r15
jz short loc_1718D
mov r12, [r14+8]
lea r13, [r14+30h]
xor ebp, ebp
loc_1715B:
movsxd rax, dword ptr [r14+20h]
cmp rbp, rax
jge short loc_1717D
mov rsi, [r13-8]
mov rdx, [r13+0]
mov rdi, rbx
call JS_FreeValueRT
inc rbp
add r13, 10h
jmp short loc_1715B
loc_1717D:
mov rdi, rbx
mov rsi, r14
call js_free_rt
mov r14, r12
jmp short loc_1714C
loc_1718D:
mov [rbx+130h], r15
mov [rbx+138h], r15
mov rdi, rbx
call JS_RunGC
push 4
pop r14
xor r15d, r15d
loc_171AA:
movsxd rax, dword ptr [rbx+78h]
mov rsi, [rbx+80h]
cmp r15, rax
jge short loc_171D7
cmp dword ptr [rsi+r14-4], 0
jz short loc_171CE
mov esi, [rsi+r14]
mov rdi, rbx
call JS_FreeAtomRT
loc_171CE:
inc r15
add r14, 28h ; '('
jmp short loc_171AA
loc_171D7:
mov rdi, rbx
call js_free_rt
lea rdi, [rbx+198h]
call bf_context_end
xor r14d, r14d
loc_171EE:
movsxd rax, dword ptr [rbx+58h]
mov rsi, [rbx+68h]
cmp r14, rax
jge short loc_17212
mov rsi, [rsi+r14*8]
test sil, 1
jnz short loc_1720D
mov rdi, rbx
call js_free_rt
loc_1720D:
inc r14
jmp short loc_171EE
loc_17212:
mov rdi, rbx
call js_free_rt
mov rsi, [rbx+60h]
mov rdi, rbx
call js_free_rt
mov rsi, [rbx+190h]
mov rdi, rbx
loc_17230:
call js_free_rt
mov r14, [rbx+220h]
test r14, r14
jz short loc_1725E
mov rax, [r14]
mov [rbx+220h], rax
mov rsi, [r14+10h]
mov rdi, rbx
call qword ptr [r14+8]
mov rdi, rbx
mov rsi, r14
jmp short loc_17230
loc_1725E:
mov rax, [rbx+10h]
mov rdi, [rbx+40h]
mov rsi, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp rax
| long long JS_FreeRuntime(long long a1)
{
long long v1; // rbx
long long v2; // r15
long long i; // r14
long long v4; // r12
_QWORD *v5; // r13
long long j; // rbp
long long v7; // r14
long long k; // r15
long long v9; // rsi
long long m; // r14
long long v11; // rsi
long long v12; // rsi
long long n; // rsi
long long v14; // r14
v1 = a1;
*(_BYTE *)(a1 + 258) = 1;
JS_FreeValueRT(a1, *(_QWORD *)(a1 + 240), *(_QWORD *)(a1 + 248));
v2 = a1 + 304;
for ( i = *(_QWORD *)(a1 + 312); i != v2; i = v4 )
{
v4 = *(_QWORD *)(i + 8);
v5 = (_QWORD *)(i + 48);
for ( j = 0LL; j < *(int *)(i + 32); ++j )
{
JS_FreeValueRT(a1, *(v5 - 1), *v5);
v5 += 2;
}
js_free_rt(a1, i);
}
*(_QWORD *)(a1 + 304) = v2;
*(_QWORD *)(a1 + 312) = v2;
JS_RunGC(a1);
v7 = 4LL;
for ( k = 0LL; ; ++k )
{
v9 = *(_QWORD *)(a1 + 128);
if ( k >= *(int *)(a1 + 120) )
break;
if ( *(_DWORD *)(v9 + v7 - 4) )
JS_FreeAtomRT(a1, *(unsigned int *)(v9 + v7));
v7 += 40LL;
}
js_free_rt(a1, v9);
bf_context_end(a1 + 408);
for ( m = 0LL; ; ++m )
{
v11 = *(_QWORD *)(a1 + 104);
if ( m >= *(int *)(a1 + 88) )
break;
v12 = *(_QWORD *)(v11 + 8 * m);
if ( (v12 & 1) == 0 )
js_free_rt(a1, v12);
}
js_free_rt(a1, v11);
js_free_rt(a1, *(_QWORD *)(a1 + 96));
for ( n = *(_QWORD *)(a1 + 400); ; n = v14 )
{
js_free_rt(a1, n);
v14 = *(_QWORD *)(v1 + 544);
if ( !v14 )
break;
*(_QWORD *)(v1 + 544) = *(_QWORD *)v14;
(*(void ( **)(long long, _QWORD))(v14 + 8))(v1, *(_QWORD *)(v14 + 16));
a1 = v1;
}
return (*(long long ( **)(_QWORD, long long))(v1 + 16))(*(_QWORD *)(v1 + 64), v1);
}
| JS_FreeRuntime:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV byte ptr [RDI + 0x102],0x1
MOV RSI,qword ptr [RDI + 0xf0]
MOV RDX,qword ptr [RDI + 0xf8]
CALL 0x001174b5
LEA R15,[RBX + 0x130]
MOV R14,qword ptr [RBX + 0x138]
LAB_0011714c:
CMP R14,R15
JZ 0x0011718d
MOV R12,qword ptr [R14 + 0x8]
LEA R13,[R14 + 0x30]
XOR EBP,EBP
LAB_0011715b:
MOVSXD RAX,dword ptr [R14 + 0x20]
CMP RBP,RAX
JGE 0x0011717d
MOV RSI,qword ptr [R13 + -0x8]
MOV RDX,qword ptr [R13]
MOV RDI,RBX
CALL 0x001174b5
INC RBP
ADD R13,0x10
JMP 0x0011715b
LAB_0011717d:
MOV RDI,RBX
MOV RSI,R14
CALL 0x0011654f
MOV R14,R12
JMP 0x0011714c
LAB_0011718d:
MOV qword ptr [RBX + 0x130],R15
MOV qword ptr [RBX + 0x138],R15
MOV RDI,RBX
CALL 0x001175c1
PUSH 0x4
POP R14
XOR R15D,R15D
LAB_001171aa:
MOVSXD RAX,dword ptr [RBX + 0x78]
MOV RSI,qword ptr [RBX + 0x80]
CMP R15,RAX
JGE 0x001171d7
CMP dword ptr [RSI + R14*0x1 + -0x4],0x0
JZ 0x001171ce
MOV ESI,dword ptr [RSI + R14*0x1]
MOV RDI,RBX
CALL 0x00117754
LAB_001171ce:
INC R15
ADD R14,0x28
JMP 0x001171aa
LAB_001171d7:
MOV RDI,RBX
CALL 0x0011654f
LEA RDI,[RBX + 0x198]
CALL 0x0016e8c4
XOR R14D,R14D
LAB_001171ee:
MOVSXD RAX,dword ptr [RBX + 0x58]
MOV RSI,qword ptr [RBX + 0x68]
CMP R14,RAX
JGE 0x00117212
MOV RSI,qword ptr [RSI + R14*0x8]
TEST SIL,0x1
JNZ 0x0011720d
MOV RDI,RBX
CALL 0x0011654f
LAB_0011720d:
INC R14
JMP 0x001171ee
LAB_00117212:
MOV RDI,RBX
CALL 0x0011654f
MOV RSI,qword ptr [RBX + 0x60]
MOV RDI,RBX
CALL 0x0011654f
MOV RSI,qword ptr [RBX + 0x190]
MOV RDI,RBX
LAB_00117230:
CALL 0x0011654f
MOV R14,qword ptr [RBX + 0x220]
TEST R14,R14
JZ 0x0011725e
MOV RAX,qword ptr [R14]
MOV qword ptr [RBX + 0x220],RAX
MOV RSI,qword ptr [R14 + 0x10]
MOV RDI,RBX
CALL qword ptr [R14 + 0x8]
MOV RDI,RBX
MOV RSI,R14
JMP 0x00117230
LAB_0011725e:
MOV RAX,qword ptr [RBX + 0x10]
MOV RDI,qword ptr [RBX + 0x40]
MOV RSI,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP RAX
|
void JS_FreeRuntime(long param_1)
{
long lVar1;
long lVar2;
int8 *puVar3;
long lVar4;
long lVar5;
*(int1 *)(param_1 + 0x102) = 1;
JS_FreeValueRT(param_1,*(int8 *)(param_1 + 0xf0),*(int8 *)(param_1 + 0xf8));
lVar4 = param_1 + 0x130;
lVar5 = *(long *)(param_1 + 0x138);
while (lVar5 != lVar4) {
lVar1 = *(long *)(lVar5 + 8);
puVar3 = (int8 *)(lVar5 + 0x30);
for (lVar2 = 0; lVar2 < *(int *)(lVar5 + 0x20); lVar2 = lVar2 + 1) {
JS_FreeValueRT(param_1,puVar3[-1],*puVar3);
puVar3 = puVar3 + 2;
}
js_free_rt(param_1,lVar5);
lVar5 = lVar1;
}
*(long *)(param_1 + 0x130) = lVar4;
*(long *)(param_1 + 0x138) = lVar4;
JS_RunGC(param_1);
lVar4 = 4;
for (lVar5 = 0; lVar5 < *(int *)(param_1 + 0x78); lVar5 = lVar5 + 1) {
if (*(int *)(*(long *)(param_1 + 0x80) + -4 + lVar4) != 0) {
JS_FreeAtomRT(param_1,*(int4 *)(*(long *)(param_1 + 0x80) + lVar4));
}
lVar4 = lVar4 + 0x28;
}
js_free_rt(param_1);
bf_context_end(param_1 + 0x198);
for (lVar4 = 0; lVar4 < *(int *)(param_1 + 0x58); lVar4 = lVar4 + 1) {
if ((*(ulong *)(*(long *)(param_1 + 0x68) + lVar4 * 8) & 1) == 0) {
js_free_rt(param_1);
}
}
js_free_rt(param_1);
js_free_rt(param_1,*(int8 *)(param_1 + 0x60));
puVar3 = *(int8 **)(param_1 + 400);
while( true ) {
js_free_rt(param_1,puVar3);
puVar3 = *(int8 **)(param_1 + 0x220);
if (puVar3 == (int8 *)0x0) break;
*(int8 *)(param_1 + 0x220) = *puVar3;
(*(code *)puVar3[1])(param_1,puVar3[2]);
}
/* WARNING: Could not recover jumptable at 0x00117277. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(param_1 + 0x10))(*(int8 *)(param_1 + 0x40),param_1);
return;
}
|
|
928 | rlSetBlendFactors | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rlgl.h | void rlSetBlendFactors(int glSrcFactor, int glDstFactor, int glEquation)
{
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
if ((RLGL.State.glBlendSrcFactor != glSrcFactor) ||
(RLGL.State.glBlendDstFactor != glDstFactor) ||
(RLGL.State.glBlendEquation != glEquation))
{
RLGL.State.glBlendSrcFactor = glSrcFactor;
RLGL.State.glBlendDstFactor = glDstFactor;
RLGL.State.glBlendEquation = glEquation;
RLGL.State.glCustomBlendModeModified = true;
}
#endif
} | O0 | c | rlSetBlendFactors:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl 0x1678dd(%rip), %eax # 0x21ac30
cmpl -0x4(%rbp), %eax
jne 0xb336e
movl 0x1678d6(%rip), %eax # 0x21ac34
cmpl -0x8(%rbp), %eax
jne 0xb336e
movl 0x1678cf(%rip), %eax # 0x21ac38
cmpl -0xc(%rbp), %eax
je 0xb3390
movl -0x4(%rbp), %eax
movl %eax, 0x1678b9(%rip) # 0x21ac30
movl -0x8(%rbp), %eax
movl %eax, 0x1678b4(%rip) # 0x21ac34
movl -0xc(%rbp), %eax
movl %eax, 0x1678af(%rip) # 0x21ac38
movb $0x1, 0x1678c4(%rip) # 0x21ac54
popq %rbp
retq
nopw %cs:(%rax,%rax)
| rlSetBlendFactors:
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov [rbp+var_C], edx
mov eax, cs:dword_21AC30
cmp eax, [rbp+var_4]
jnz short loc_B336E
mov eax, cs:dword_21AC34
cmp eax, [rbp+var_8]
jnz short loc_B336E
mov eax, cs:dword_21AC38
cmp eax, [rbp+var_C]
jz short loc_B3390
loc_B336E:
mov eax, [rbp+var_4]
mov cs:dword_21AC30, eax
mov eax, [rbp+var_8]
mov cs:dword_21AC34, eax
mov eax, [rbp+var_C]
mov cs:dword_21AC38, eax
mov cs:byte_21AC54, 1
loc_B3390:
pop rbp
retn
| long long rlSetBlendFactors(int a1, int a2, unsigned int a3)
{
long long result; // rax
if ( dword_21AC30 != a1 || dword_21AC34 != a2 || (result = (unsigned int)dword_21AC38, dword_21AC38 != a3) )
{
dword_21AC30 = a1;
dword_21AC34 = a2;
result = a3;
dword_21AC38 = a3;
byte_21AC54 = 1;
}
return result;
}
| rlSetBlendFactors:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV dword ptr [RBP + -0xc],EDX
MOV EAX,dword ptr [0x0031ac30]
CMP EAX,dword ptr [RBP + -0x4]
JNZ 0x001b336e
MOV EAX,dword ptr [0x0031ac34]
CMP EAX,dword ptr [RBP + -0x8]
JNZ 0x001b336e
MOV EAX,dword ptr [0x0031ac38]
CMP EAX,dword ptr [RBP + -0xc]
JZ 0x001b3390
LAB_001b336e:
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [0x0031ac30],EAX
MOV EAX,dword ptr [RBP + -0x8]
MOV dword ptr [0x0031ac34],EAX
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [0x0031ac38],EAX
MOV byte ptr [0x0031ac54],0x1
LAB_001b3390:
POP RBP
RET
|
void rlSetBlendFactors(int param_1,int param_2,int param_3)
{
if (((DAT_0031ac30 != param_1) || (DAT_0031ac34 != param_2)) || (DAT_0031ac38 != param_3)) {
DAT_0031ac54 = 1;
DAT_0031ac30 = param_1;
DAT_0031ac34 = param_2;
DAT_0031ac38 = param_3;
}
return;
}
|
|
929 | rlSetBlendFactors | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rlgl.h | void rlSetBlendFactors(int glSrcFactor, int glDstFactor, int glEquation)
{
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
if ((RLGL.State.glBlendSrcFactor != glSrcFactor) ||
(RLGL.State.glBlendDstFactor != glDstFactor) ||
(RLGL.State.glBlendEquation != glEquation))
{
RLGL.State.glBlendSrcFactor = glSrcFactor;
RLGL.State.glBlendDstFactor = glDstFactor;
RLGL.State.glBlendEquation = glEquation;
RLGL.State.glCustomBlendModeModified = true;
}
#endif
} | O2 | c | rlSetBlendFactors:
cmpl %edi, 0xd47fc(%rip) # 0x127b90
jne 0x533a7
cmpl %esi, 0xd47f8(%rip) # 0x127b94
jne 0x533a7
cmpl %edx, 0xd47f4(%rip) # 0x127b98
jne 0x533a7
retq
movl %edi, 0xd47e3(%rip) # 0x127b90
movl %esi, 0xd47e1(%rip) # 0x127b94
movl %edx, 0xd47df(%rip) # 0x127b98
movb $0x1, 0xd47f4(%rip) # 0x127bb4
retq
| rlSetBlendFactors:
cmp cs:dword_127B90, edi
jnz short loc_533A7
cmp cs:dword_127B94, esi
jnz short loc_533A7
cmp cs:dword_127B98, edx
jnz short loc_533A7
retn
loc_533A7:
mov cs:dword_127B90, edi
mov cs:dword_127B94, esi
mov cs:dword_127B98, edx
mov cs:byte_127BB4, 1
retn
| void rlSetBlendFactors(int a1, int a2, int a3)
{
if ( dword_127B90 != a1 || dword_127B94 != a2 || dword_127B98 != a3 )
{
dword_127B90 = a1;
dword_127B94 = a2;
dword_127B98 = a3;
byte_127BB4 = 1;
}
}
| rlSetBlendFactors:
CMP dword ptr [0x00227b90],EDI
JNZ 0x001533a7
CMP dword ptr [0x00227b94],ESI
JNZ 0x001533a7
CMP dword ptr [0x00227b98],EDX
JNZ 0x001533a7
RET
LAB_001533a7:
MOV dword ptr [0x00227b90],EDI
MOV dword ptr [0x00227b94],ESI
MOV dword ptr [0x00227b98],EDX
MOV byte ptr [0x00227bb4],0x1
RET
|
void rlSetBlendFactors(int param_1,int param_2,int param_3)
{
if (((DAT_00227b90 == param_1) && (DAT_00227b94 == param_2)) && (DAT_00227b98 == param_3)) {
return;
}
DAT_00227b90 = param_1;
DAT_00227b94 = param_2;
DAT_00227b98 = param_3;
DAT_00227bb4 = 1;
return;
}
|
|
930 | rlSetBlendFactors | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rlgl.h | void rlSetBlendFactors(int glSrcFactor, int glDstFactor, int glEquation)
{
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
if ((RLGL.State.glBlendSrcFactor != glSrcFactor) ||
(RLGL.State.glBlendDstFactor != glDstFactor) ||
(RLGL.State.glBlendEquation != glEquation))
{
RLGL.State.glBlendSrcFactor = glSrcFactor;
RLGL.State.glBlendDstFactor = glDstFactor;
RLGL.State.glBlendEquation = glEquation;
RLGL.State.glCustomBlendModeModified = true;
}
#endif
} | O3 | c | rlSetBlendFactors:
cmpl %edi, 0xd8a14(%rip) # 0x13bb70
jne 0x6316f
cmpl %esi, 0xd8a10(%rip) # 0x13bb74
jne 0x6316f
cmpl %edx, 0xd8a0c(%rip) # 0x13bb78
jne 0x6316f
retq
movl %edi, 0xd89fb(%rip) # 0x13bb70
movl %esi, 0xd89f9(%rip) # 0x13bb74
movl %edx, 0xd89f7(%rip) # 0x13bb78
movb $0x1, 0xd8a0c(%rip) # 0x13bb94
retq
| rlSetBlendFactors:
cmp cs:dword_13BB70, edi
jnz short loc_6316F
cmp cs:dword_13BB74, esi
jnz short loc_6316F
cmp cs:dword_13BB78, edx
jnz short loc_6316F
retn
loc_6316F:
mov cs:dword_13BB70, edi
mov cs:dword_13BB74, esi
mov cs:dword_13BB78, edx
mov cs:byte_13BB94, 1
retn
| void rlSetBlendFactors(int a1, int a2, int a3)
{
if ( dword_13BB70 != a1 || dword_13BB74 != a2 || dword_13BB78 != a3 )
{
dword_13BB70 = a1;
dword_13BB74 = a2;
dword_13BB78 = a3;
byte_13BB94 = 1;
}
}
| rlSetBlendFactors:
CMP dword ptr [0x0023bb70],EDI
JNZ 0x0016316f
CMP dword ptr [0x0023bb74],ESI
JNZ 0x0016316f
CMP dword ptr [0x0023bb78],EDX
JNZ 0x0016316f
RET
LAB_0016316f:
MOV dword ptr [0x0023bb70],EDI
MOV dword ptr [0x0023bb74],ESI
MOV dword ptr [0x0023bb78],EDX
MOV byte ptr [0x0023bb94],0x1
RET
|
void rlSetBlendFactors(int param_1,int param_2,int param_3)
{
if (((DAT_0023bb70 == param_1) && (DAT_0023bb74 == param_2)) && (DAT_0023bb78 == param_3)) {
return;
}
DAT_0023bb70 = param_1;
DAT_0023bb74 = param_2;
DAT_0023bb78 = param_3;
DAT_0023bb94 = 1;
return;
}
|
|
931 | my_utf16le_uni | eloqsql/strings/ctype-ucs2.c | static int
my_utf16le_uni(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t *pwc, const uchar *s, const uchar *e)
{
my_wc_t lo;
if (s + 2 > e)
return MY_CS_TOOSMALL2;
if ((*pwc= uint2korr(s)) < MY_UTF16_SURROGATE_HIGH_FIRST ||
(*pwc > MY_UTF16_SURROGATE_LOW_LAST))
return 2; /* [0000-D7FF,E000-FFFF] */
if (*pwc >= MY_UTF16_SURROGATE_LOW_FIRST)
return MY_CS_ILSEQ; /* [DC00-DFFF] Low surrogate part without high part */
if (s + 4 > e)
return MY_CS_TOOSMALL4;
s+= 2;
if ((lo= uint2korr(s)) < MY_UTF16_SURROGATE_LOW_FIRST ||
lo > MY_UTF16_SURROGATE_LOW_LAST)
return MY_CS_ILSEQ; /* Expected low surrogate part, got something else */
*pwc= 0x10000 + (((*pwc & 0x3FF) << 10) | (lo & 0x3FF));
return 4;
} | O3 | c | my_utf16le_uni:
pushq %rbp
movq %rsp, %rbp
leaq 0x2(%rdx), %r8
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %r8
ja 0x4d6c9
movzwl (%rdx), %edi
movq %rdi, (%rsi)
leal 0x2000(%rdi), %eax
movzwl %ax, %r9d
movl $0x2, %eax
cmpl $0xf800, %r9d # imm = 0xF800
jb 0x4d6c9
xorl %eax, %eax
cmpl $0xdbff, %edi # imm = 0xDBFF
ja 0x4d6c9
addq $0x4, %rdx
movl $0xffffff98, %eax # imm = 0xFFFFFF98
cmpq %rcx, %rdx
ja 0x4d6c9
movzwl (%r8), %ecx
leal 0x2000(%rcx), %eax
movzwl %ax, %edx
movl $0x0, %eax
cmpl $0xfc00, %edx # imm = 0xFC00
jb 0x4d6c9
shll $0xa, %edi
andl $0xffc00, %edi # imm = 0xFFC00
andl $0x3ff, %ecx # imm = 0x3FF
leaq (%rdi,%rcx), %rax
addq $0x10000, %rax # imm = 0x10000
movq %rax, (%rsi)
movl $0x4, %eax
popq %rbp
retq
| my_utf16le_uni:
push rbp
mov rbp, rsp
lea r8, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp r8, rcx
ja short loc_4D6C9
movzx edi, word ptr [rdx]
mov [rsi], rdi
lea eax, [rdi+2000h]
movzx r9d, ax
mov eax, 2
cmp r9d, 0F800h
jb short loc_4D6C9
xor eax, eax
cmp edi, 0DBFFh
ja short loc_4D6C9
add rdx, 4
mov eax, 0FFFFFF98h
cmp rdx, rcx
ja short loc_4D6C9
movzx ecx, word ptr [r8]
lea eax, [rcx+2000h]
movzx edx, ax
mov eax, 0
cmp edx, 0FC00h
jb short loc_4D6C9
shl edi, 0Ah
and edi, 0FFC00h
and ecx, 3FFh
lea rax, [rdi+rcx]
add rax, 10000h
mov [rsi], rax
mov eax, 4
loc_4D6C9:
pop rbp
retn
| long long my_utf16le_uni(long long a1, _QWORD *a2, unsigned __int16 *a3, unsigned long long a4)
{
_WORD *v4; // r8
long long result; // rax
long long v6; // rdi
v4 = a3 + 1;
result = 4294967194LL;
if ( (unsigned long long)(a3 + 1) <= a4 )
{
v6 = *a3;
*a2 = v6;
result = 2LL;
if ( (unsigned __int16)(v6 + 0x2000) >= 0xF800u )
{
result = 0LL;
if ( (unsigned int)v6 <= 0xDBFF )
{
result = 4294967192LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
result = 0LL;
if ( (unsigned __int16)(*v4 + 0x2000) >= 0xFC00u )
{
*a2 = (((_DWORD)v6 << 10) & 0xFFC00) + (unsigned long long)(*v4 & 0x3FF) + 0x10000;
return 4LL;
}
}
}
}
}
return result;
}
| my_utf16le_uni:
PUSH RBP
MOV RBP,RSP
LEA R8,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP R8,RCX
JA 0x0014d6c9
MOVZX EDI,word ptr [RDX]
MOV qword ptr [RSI],RDI
LEA EAX,[RDI + 0x2000]
MOVZX R9D,AX
MOV EAX,0x2
CMP R9D,0xf800
JC 0x0014d6c9
XOR EAX,EAX
CMP EDI,0xdbff
JA 0x0014d6c9
ADD RDX,0x4
MOV EAX,0xffffff98
CMP RDX,RCX
JA 0x0014d6c9
MOVZX ECX,word ptr [R8]
LEA EAX,[RCX + 0x2000]
MOVZX EDX,AX
MOV EAX,0x0
CMP EDX,0xfc00
JC 0x0014d6c9
SHL EDI,0xa
AND EDI,0xffc00
AND ECX,0x3ff
LEA RAX,[RDI + RCX*0x1]
ADD RAX,0x10000
MOV qword ptr [RSI],RAX
MOV EAX,0x4
LAB_0014d6c9:
POP RBP
RET
|
int8 my_utf16le_uni(int8 param_1,ulong *param_2,ushort *param_3,ushort *param_4)
{
ushort uVar1;
ushort uVar2;
int8 uVar3;
uVar3 = 0xffffff9a;
if (param_3 + 1 <= param_4) {
uVar1 = *param_3;
*param_2 = (ulong)uVar1;
uVar3 = 2;
if (((0xf7ff < (ushort)(uVar1 + 0x2000)) && (uVar3 = 0, uVar1 < 0xdc00)) &&
(uVar3 = 0xffffff98, param_3 + 2 <= param_4)) {
uVar2 = param_3[1];
uVar3 = 0;
if (0xfbff < (ushort)(uVar2 + 0x2000)) {
*param_2 = (ulong)((uVar1 & 0x3ff) << 10) + (ulong)(uVar2 & 0x3ff) + 0x10000;
uVar3 = 4;
}
}
}
return uVar3;
}
|
|
932 | PFS_buffer_scalable_container<PFS_table, 1024, 1024, PFS_buffer_default_array<PFS_table>, PFS_buffer_default_allocator<PFS_table>>::init(long) | eloqsql/storage/perfschema/pfs_buffer_container.h | int init(long max_size)
{
int i;
m_initialized= true;
m_full= true;
m_max= PFS_PAGE_COUNT * PFS_PAGE_SIZE;
m_max_page_count= PFS_PAGE_COUNT;
m_last_page_size= PFS_PAGE_SIZE;
m_lost= 0;
m_monotonic.m_u32= 0;
m_max_page_index.m_u32= 0;
for (i=0 ; i < PFS_PAGE_COUNT; i++)
{
m_pages[i]= NULL;
}
if (max_size == 0)
{
/* No allocation. */
m_max_page_count= 0;
}
else if (max_size > 0)
{
if (max_size % PFS_PAGE_SIZE == 0)
{
m_max_page_count= max_size / PFS_PAGE_SIZE;
}
else
{
m_max_page_count= max_size / PFS_PAGE_SIZE + 1;
m_last_page_size= max_size % PFS_PAGE_SIZE;
}
/* Bounded allocation. */
m_full= false;
if (m_max_page_count > PFS_PAGE_COUNT)
{
m_max_page_count= PFS_PAGE_COUNT;
m_last_page_size= PFS_PAGE_SIZE;
}
}
else
{
/* max_size = -1 means unbounded allocation */
m_full= false;
}
assert(m_max_page_count <= PFS_PAGE_COUNT);
assert(0 < m_last_page_size);
assert(m_last_page_size <= PFS_PAGE_SIZE);
pthread_mutex_init(& m_critical_section, NULL);
return 0;
} | O0 | c | PFS_buffer_scalable_container<PFS_table, 1024, 1024, PFS_buffer_default_array<PFS_table>, PFS_buffer_default_allocator<PFS_table>>::init(long):
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movb $0x1, 0x8(%rax)
movb $0x1, 0x9(%rax)
movq $0x1000000, 0x10(%rax) # imm = 0x1000000
movq $0x1000, 0x98(%rax) # imm = 0x1000
movq $0x1000, 0xa0(%rax) # imm = 0x1000
movq $0x0, (%rax)
movl $0x0, 0x18(%rax)
movl $0x0, 0x58(%rax)
movl $0x0, -0x14(%rbp)
cmpl $0x1000, -0x14(%rbp) # imm = 0x1000
jge 0x44962
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq $0x0, 0xa8(%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4493a
cmpq $0x0, -0x10(%rbp)
jne 0x4497d
movq -0x20(%rbp), %rax
movq $0x0, 0x98(%rax)
jmp 0x44a2e
cmpq $0x0, -0x10(%rbp)
jle 0x44a24
movq -0x10(%rbp), %rax
movl $0x1000, %ecx # imm = 0x1000
cqto
idivq %rcx
cmpq $0x0, %rdx
jne 0x449ba
movq -0x10(%rbp), %rax
movl $0x1000, %ecx # imm = 0x1000
cqto
idivq %rcx
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x98(%rax)
jmp 0x449f3
movq -0x10(%rbp), %rax
movl $0x1000, %ecx # imm = 0x1000
cqto
idivq %rcx
movq %rax, %rcx
movq -0x20(%rbp), %rax
addq $0x1, %rcx
movq %rcx, 0x98(%rax)
movq -0x10(%rbp), %rax
movl $0x1000, %ecx # imm = 0x1000
cqto
idivq %rcx
movq -0x20(%rbp), %rax
movq %rdx, 0xa0(%rax)
movq -0x20(%rbp), %rax
movb $0x0, 0x9(%rax)
cmpq $0x1000, 0x98(%rax) # imm = 0x1000
jbe 0x44a22
movq -0x20(%rbp), %rax
movq $0x1000, 0x98(%rax) # imm = 0x1000
movq $0x1000, 0xa0(%rax) # imm = 0x1000
jmp 0x44a2c
movq -0x20(%rbp), %rax
movb $0x0, 0x9(%rax)
jmp 0x44a2e
movq -0x20(%rbp), %rdi
addq $0x80b0, %rdi # imm = 0x80B0
xorl %eax, %eax
movl %eax, %esi
callq 0x264f0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| _ZN29PFS_buffer_scalable_containerI15PFS_table_shareLi4096ELi4096E24PFS_buffer_default_arrayIS0_E28PFS_buffer_default_allocatorIS0_EE4initEl:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov [rbp+var_20], rax
mov byte ptr [rax+8], 1
mov byte ptr [rax+9], 1
mov qword ptr [rax+10h], 1000000h
mov qword ptr [rax+98h], 1000h
mov qword ptr [rax+0A0h], 1000h
mov qword ptr [rax], 0
mov dword ptr [rax+18h], 0
mov dword ptr [rax+58h], 0
mov [rbp+var_14], 0
loc_4493A:
cmp [rbp+var_14], 1000h
jge short loc_44962
mov rax, [rbp+var_20]
movsxd rcx, [rbp+var_14]
mov qword ptr [rax+rcx*8+0A8h], 0
mov eax, [rbp+var_14]
add eax, 1
mov [rbp+var_14], eax
jmp short loc_4493A
loc_44962:
cmp [rbp+var_10], 0
jnz short loc_4497D
mov rax, [rbp+var_20]
mov qword ptr [rax+98h], 0
jmp loc_44A2E
loc_4497D:
cmp [rbp+var_10], 0
jle loc_44A24
mov rax, [rbp+var_10]
mov ecx, 1000h
cqo
idiv rcx
cmp rdx, 0
jnz short loc_449BA
mov rax, [rbp+var_10]
mov ecx, 1000h
cqo
idiv rcx
mov rcx, rax
mov rax, [rbp+var_20]
mov [rax+98h], rcx
jmp short loc_449F3
loc_449BA:
mov rax, [rbp+var_10]
mov ecx, 1000h
cqo
idiv rcx
mov rcx, rax
mov rax, [rbp+var_20]
add rcx, 1
mov [rax+98h], rcx
mov rax, [rbp+var_10]
mov ecx, 1000h
cqo
idiv rcx
mov rax, [rbp+var_20]
mov [rax+0A0h], rdx
loc_449F3:
mov rax, [rbp+var_20]
mov byte ptr [rax+9], 0
cmp qword ptr [rax+98h], 1000h
jbe short loc_44A22
mov rax, [rbp+var_20]
mov qword ptr [rax+98h], 1000h
mov qword ptr [rax+0A0h], 1000h
loc_44A22:
jmp short loc_44A2C
loc_44A24:
mov rax, [rbp+var_20]
mov byte ptr [rax+9], 0
loc_44A2C:
jmp short $+2
loc_44A2E:
mov rdi, [rbp+var_20]
add rdi, 80B0h
xor eax, eax
mov esi, eax
call _pthread_mutex_init
xor eax, eax
add rsp, 20h
pop rbp
retn
| long long PFS_buffer_scalable_container<PFS_table_share,4096,4096,PFS_buffer_default_array<PFS_table_share>,PFS_buffer_default_allocator<PFS_table_share>>::init(
long long a1,
long long a2)
{
int i; // [rsp+Ch] [rbp-14h]
*(_BYTE *)(a1 + 8) = 1;
*(_BYTE *)(a1 + 9) = 1;
*(_QWORD *)(a1 + 16) = 0x1000000LL;
*(_QWORD *)(a1 + 152) = 4096LL;
*(_QWORD *)(a1 + 160) = 4096LL;
*(_QWORD *)a1 = 0LL;
*(_DWORD *)(a1 + 24) = 0;
*(_DWORD *)(a1 + 88) = 0;
for ( i = 0; i < 4096; ++i )
*(_QWORD *)(a1 + 8LL * i + 168) = 0LL;
if ( a2 )
{
if ( a2 <= 0 )
{
*(_BYTE *)(a1 + 9) = 0;
}
else
{
if ( a2 % 4096 )
{
*(_QWORD *)(a1 + 152) = a2 / 4096 + 1;
*(_QWORD *)(a1 + 160) = a2 % 4096;
}
else
{
*(_QWORD *)(a1 + 152) = a2 / 4096;
}
*(_BYTE *)(a1 + 9) = 0;
if ( *(_QWORD *)(a1 + 152) > 0x1000uLL )
{
*(_QWORD *)(a1 + 152) = 4096LL;
*(_QWORD *)(a1 + 160) = 4096LL;
}
}
}
else
{
*(_QWORD *)(a1 + 152) = 0LL;
}
pthread_mutex_init(a1 + 32944, 0LL);
return 0LL;
}
| init:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x20],RAX
MOV byte ptr [RAX + 0x8],0x1
MOV byte ptr [RAX + 0x9],0x1
MOV qword ptr [RAX + 0x10],0x1000000
MOV qword ptr [RAX + 0x98],0x1000
MOV qword ptr [RAX + 0xa0],0x1000
MOV qword ptr [RAX],0x0
MOV dword ptr [RAX + 0x18],0x0
MOV dword ptr [RAX + 0x58],0x0
MOV dword ptr [RBP + -0x14],0x0
LAB_0014493a:
CMP dword ptr [RBP + -0x14],0x1000
JGE 0x00144962
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RCX,dword ptr [RBP + -0x14]
MOV qword ptr [RAX + RCX*0x8 + 0xa8],0x0
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
JMP 0x0014493a
LAB_00144962:
CMP qword ptr [RBP + -0x10],0x0
JNZ 0x0014497d
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x98],0x0
JMP 0x00144a2e
LAB_0014497d:
CMP qword ptr [RBP + -0x10],0x0
JLE 0x00144a24
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,0x1000
CQO
IDIV RCX
CMP RDX,0x0
JNZ 0x001449ba
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,0x1000
CQO
IDIV RCX
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x98],RCX
JMP 0x001449f3
LAB_001449ba:
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,0x1000
CQO
IDIV RCX
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RCX,0x1
MOV qword ptr [RAX + 0x98],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,0x1000
CQO
IDIV RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0xa0],RDX
LAB_001449f3:
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x9],0x0
CMP qword ptr [RAX + 0x98],0x1000
JBE 0x00144a22
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x98],0x1000
MOV qword ptr [RAX + 0xa0],0x1000
LAB_00144a22:
JMP 0x00144a2c
LAB_00144a24:
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x9],0x0
LAB_00144a2c:
JMP 0x00144a2e
LAB_00144a2e:
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x80b0
XOR EAX,EAX
MOV ESI,EAX
CALL 0x001264f0
XOR EAX,EAX
ADD RSP,0x20
POP RBP
RET
|
/* PFS_buffer_scalable_container<PFS_table_share, 4096, 4096,
PFS_buffer_default_array<PFS_table_share>, PFS_buffer_default_allocator<PFS_table_share>
>::init(long) */
int8 __thiscall
PFS_buffer_scalable_container<PFS_table_share,4096,4096,PFS_buffer_default_array<PFS_table_share>,PFS_buffer_default_allocator<PFS_table_share>>
::init(PFS_buffer_scalable_container<PFS_table_share,4096,4096,PFS_buffer_default_array<PFS_table_share>,PFS_buffer_default_allocator<PFS_table_share>>
*this,long param_1)
{
int local_1c;
this[8] = (PFS_buffer_scalable_container<PFS_table_share,4096,4096,PFS_buffer_default_array<PFS_table_share>,PFS_buffer_default_allocator<PFS_table_share>>
)0x1;
this[9] = (PFS_buffer_scalable_container<PFS_table_share,4096,4096,PFS_buffer_default_array<PFS_table_share>,PFS_buffer_default_allocator<PFS_table_share>>
)0x1;
*(int8 *)(this + 0x10) = 0x1000000;
*(int8 *)(this + 0x98) = 0x1000;
*(int8 *)(this + 0xa0) = 0x1000;
*(int8 *)this = 0;
*(int4 *)(this + 0x18) = 0;
*(int4 *)(this + 0x58) = 0;
for (local_1c = 0; local_1c < 0x1000; local_1c = local_1c + 1) {
*(int8 *)(this + (long)local_1c * 8 + 0xa8) = 0;
}
if (param_1 == 0) {
*(int8 *)(this + 0x98) = 0;
}
else if (param_1 < 1) {
this[9] = (PFS_buffer_scalable_container<PFS_table_share,4096,4096,PFS_buffer_default_array<PFS_table_share>,PFS_buffer_default_allocator<PFS_table_share>>
)0x0;
}
else {
if (param_1 % 0x1000 == 0) {
*(long *)(this + 0x98) = param_1 / 0x1000;
}
else {
*(long *)(this + 0x98) = param_1 / 0x1000 + 1;
*(long *)(this + 0xa0) = param_1 % 0x1000;
}
this[9] = (PFS_buffer_scalable_container<PFS_table_share,4096,4096,PFS_buffer_default_array<PFS_table_share>,PFS_buffer_default_allocator<PFS_table_share>>
)0x0;
if (0x1000 < *(ulong *)(this + 0x98)) {
*(int8 *)(this + 0x98) = 0x1000;
*(int8 *)(this + 0xa0) = 0x1000;
}
}
pthread_mutex_init((pthread_mutex_t *)(this + 0x80b0),(pthread_mutexattr_t *)0x0);
return 0;
}
|
|
933 | js_for_of_start | bluesky950520[P]quickjs/quickjs.c | static __exception int js_for_of_start(JSContext *ctx, JSValue *sp,
BOOL is_async)
{
JSValue op1, obj, method;
op1 = sp[-1];
obj = JS_GetIterator(ctx, op1, is_async);
if (JS_IsException(obj))
return -1;
JS_FreeValue(ctx, op1);
sp[-1] = obj;
method = JS_GetProperty(ctx, obj, JS_ATOM_next);
if (JS_IsException(method))
return -1;
sp[0] = method;
return 0;
} | O0 | c | js_for_of_start:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movl %edx, 0x5c(%rsp)
movq 0x60(%rsp), %rax
movq -0x10(%rax), %rcx
movq %rcx, 0x48(%rsp)
movq -0x8(%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x68(%rsp), %rdi
movl 0x5c(%rsp), %ecx
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
callq 0x74aa0
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
je 0x6de90
movl $0xffffffff, 0x74(%rsp) # imm = 0xFFFFFFFF
jmp 0x6df2e
movq 0x68(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
callq 0x29f80
movq 0x60(%rsp), %rax
movq 0x38(%rsp), %rcx
movq %rcx, -0x10(%rax)
movq 0x40(%rsp), %rcx
movq %rcx, -0x8(%rax)
movq 0x68(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
movl $0x6b, %ecx
callq 0x30070
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
je 0x6df10
movl $0xffffffff, 0x74(%rsp) # imm = 0xFFFFFFFF
jmp 0x6df2e
movq 0x60(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
movq 0x30(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x0, 0x74(%rsp)
movl 0x74(%rsp), %eax
addq $0x78, %rsp
retq
nopw (%rax,%rax)
| js_for_of_start:
sub rsp, 78h
mov [rsp+78h+var_10], rdi
mov [rsp+78h+var_18], rsi
mov [rsp+78h+var_1C], edx
mov rax, [rsp+78h+var_18]
mov rcx, [rax-10h]
mov [rsp+78h+var_30], rcx
mov rax, [rax-8]
mov [rsp+78h+var_28], rax
mov rdi, [rsp+78h+var_10]
mov ecx, [rsp+78h+var_1C]
mov rsi, [rsp+78h+var_30]
mov rdx, [rsp+78h+var_28]
call JS_GetIterator
mov [rsp+78h+var_60], rax
mov [rsp+78h+var_58], rdx
mov rax, [rsp+78h+var_60]
mov [rsp+78h+var_40], rax
mov rax, [rsp+78h+var_58]
mov [rsp+78h+var_38], rax
mov rdi, [rsp+78h+var_40]
mov rsi, [rsp+78h+var_38]
call JS_IsException_1
cmp eax, 0
jz short loc_6DE90
mov [rsp+78h+var_4], 0FFFFFFFFh
jmp loc_6DF2E
loc_6DE90:
mov rdi, [rsp+78h+var_10]
mov rsi, [rsp+78h+var_30]
mov rdx, [rsp+78h+var_28]
call JS_FreeValue
mov rax, [rsp+78h+var_18]
mov rcx, [rsp+78h+var_40]
mov [rax-10h], rcx
mov rcx, [rsp+78h+var_38]
mov [rax-8], rcx
mov rdi, [rsp+78h+var_10]
mov rsi, [rsp+78h+var_40]
mov rdx, [rsp+78h+var_38]
mov ecx, 6Bh ; 'k'
call JS_GetProperty
mov [rsp+78h+var_70], rax
mov [rsp+78h+var_68], rdx
mov rax, [rsp+78h+var_70]
mov [rsp+78h+var_50], rax
mov rax, [rsp+78h+var_68]
mov [rsp+78h+var_48], rax
mov rdi, [rsp+78h+var_50]
mov rsi, [rsp+78h+var_48]
call JS_IsException_1
cmp eax, 0
jz short loc_6DF10
mov [rsp+78h+var_4], 0FFFFFFFFh
jmp short loc_6DF2E
loc_6DF10:
mov rax, [rsp+78h+var_18]
mov rcx, [rsp+78h+var_50]
mov [rax], rcx
mov rcx, [rsp+78h+var_48]
mov [rax+8], rcx
mov [rsp+78h+var_4], 0
loc_6DF2E:
mov eax, [rsp+78h+var_4]
add rsp, 78h
retn
| long long js_for_of_start(long long a1, long long *a2, unsigned int a3)
{
long long v3; // rdx
long long v4; // rdx
long long Property; // [rsp+8h] [rbp-70h]
long long Iterator; // [rsp+18h] [rbp-60h]
long long v8; // [rsp+30h] [rbp-48h]
long long v9; // [rsp+40h] [rbp-38h]
long long v10; // [rsp+48h] [rbp-30h]
long long v11; // [rsp+50h] [rbp-28h]
v10 = *(a2 - 2);
v11 = *(a2 - 1);
Iterator = JS_GetIterator(a1, v10, v11, a3);
v9 = v3;
if ( JS_IsException_1(Iterator, v3) )
{
return (unsigned int)-1;
}
else
{
JS_FreeValue(a1, v10, v11);
*(a2 - 2) = Iterator;
*(a2 - 1) = v9;
Property = JS_GetProperty(a1, Iterator, v9, 107);
v8 = v4;
if ( JS_IsException_1(Property, v4) )
{
return (unsigned int)-1;
}
else
{
*a2 = Property;
a2[1] = v8;
return 0;
}
}
}
| js_for_of_start:
SUB RSP,0x78
MOV qword ptr [RSP + 0x68],RDI
MOV qword ptr [RSP + 0x60],RSI
MOV dword ptr [RSP + 0x5c],EDX
MOV RAX,qword ptr [RSP + 0x60]
MOV RCX,qword ptr [RAX + -0x10]
MOV qword ptr [RSP + 0x48],RCX
MOV RAX,qword ptr [RAX + -0x8]
MOV qword ptr [RSP + 0x50],RAX
MOV RDI,qword ptr [RSP + 0x68]
MOV ECX,dword ptr [RSP + 0x5c]
MOV RSI,qword ptr [RSP + 0x48]
MOV RDX,qword ptr [RSP + 0x50]
CALL 0x00174aa0
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x20],RDX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x38],RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x40],RAX
MOV RDI,qword ptr [RSP + 0x38]
MOV RSI,qword ptr [RSP + 0x40]
CALL 0x00129fb0
CMP EAX,0x0
JZ 0x0016de90
MOV dword ptr [RSP + 0x74],0xffffffff
JMP 0x0016df2e
LAB_0016de90:
MOV RDI,qword ptr [RSP + 0x68]
MOV RSI,qword ptr [RSP + 0x48]
MOV RDX,qword ptr [RSP + 0x50]
CALL 0x00129f80
MOV RAX,qword ptr [RSP + 0x60]
MOV RCX,qword ptr [RSP + 0x38]
MOV qword ptr [RAX + -0x10],RCX
MOV RCX,qword ptr [RSP + 0x40]
MOV qword ptr [RAX + -0x8],RCX
MOV RDI,qword ptr [RSP + 0x68]
MOV RSI,qword ptr [RSP + 0x38]
MOV RDX,qword ptr [RSP + 0x40]
MOV ECX,0x6b
CALL 0x00130070
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],RDX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x28],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x30],RAX
MOV RDI,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RSP + 0x30]
CALL 0x00129fb0
CMP EAX,0x0
JZ 0x0016df10
MOV dword ptr [RSP + 0x74],0xffffffff
JMP 0x0016df2e
LAB_0016df10:
MOV RAX,qword ptr [RSP + 0x60]
MOV RCX,qword ptr [RSP + 0x28]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RSP + 0x30]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RSP + 0x74],0x0
LAB_0016df2e:
MOV EAX,dword ptr [RSP + 0x74]
ADD RSP,0x78
RET
|
int4 js_for_of_start(int8 param_1,int1 (*param_2) [16],int4 param_3)
{
int8 uVar1;
int8 uVar2;
int iVar3;
int1 auVar4 [16];
int4 local_4;
uVar1 = *(int8 *)param_2[-1];
uVar2 = *(int8 *)(param_2[-1] + 8);
auVar4 = JS_GetIterator(param_1,uVar1,uVar2,param_3);
iVar3 = JS_IsException(auVar4._0_8_,auVar4._8_8_);
if (iVar3 == 0) {
JS_FreeValue(param_1,uVar1,uVar2);
param_2[-1] = auVar4;
auVar4 = JS_GetProperty(param_1,auVar4._0_8_,auVar4._8_8_,0x6b);
iVar3 = JS_IsException(auVar4._0_8_,auVar4._8_8_);
if (iVar3 == 0) {
*param_2 = auVar4;
local_4 = 0;
}
else {
local_4 = 0xffffffff;
}
}
else {
local_4 = 0xffffffff;
}
return local_4;
}
|
|
934 | js_for_of_start | bluesky950520[P]quickjs/quickjs.c | static __exception int js_for_of_start(JSContext *ctx, JSValue *sp,
BOOL is_async)
{
JSValue op1, obj, method;
op1 = sp[-1];
obj = JS_GetIterator(ctx, op1, is_async);
if (JS_IsException(obj))
return -1;
JS_FreeValue(ctx, op1);
sp[-1] = obj;
method = JS_GetProperty(ctx, obj, JS_ATOM_next);
if (JS_IsException(method))
return -1;
sp[0] = method;
return 0;
} | O2 | c | js_for_of_start:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ecx
movq %rsi, %rbx
movq %rdi, %r14
movq -0x10(%rsi), %r15
movq -0x8(%rsi), %r12
movq %r15, %rsi
movq %r12, %rdx
callq 0x3d237
movq %rdx, %rbp
pushq $-0x1
popq %rcx
cmpl $0x6, %ebp
je 0x3b8e0
movq %rax, %r13
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movl %ecx, %r15d
callq 0x1bbce
movq %r13, -0x10(%rbx)
movq %rbp, -0x8(%rbx)
pushq $0x6b
popq %rcx
movq %r14, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x1ebf3
movl %r15d, %ecx
cmpl $0x6, %edx
je 0x3b8e0
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| js_for_of_start:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov ecx, edx
mov rbx, rsi
mov r14, rdi
mov r15, [rsi-10h]
mov r12, [rsi-8]
mov rsi, r15
mov rdx, r12
call JS_GetIterator
mov rbp, rdx
push 0FFFFFFFFFFFFFFFFh
pop rcx
cmp ebp, 6
jz short loc_3B8E0
mov r13, rax
mov rdi, r14
mov rsi, r15
mov rdx, r12
mov r15d, ecx
call JS_FreeValue
mov [rbx-10h], r13
mov [rbx-8], rbp
push 6Bh ; 'k'
pop rcx
mov rdi, r14
mov rsi, r13
mov rdx, rbp
call JS_GetProperty
mov ecx, r15d
cmp edx, 6
jz short loc_3B8E0
mov [rbx], rax
mov [rbx+8], rdx
xor ecx, ecx
loc_3B8E0:
mov eax, ecx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long js_for_of_start(long long a1, long long *a2, unsigned int a3)
{
long long v3; // r15
long long v4; // r12
long long Iterator; // rax
long long v6; // rdx
long long v7; // rbp
unsigned int v8; // ecx
long long v9; // r13
long long Property; // rax
long long v11; // rdx
v3 = *(a2 - 2);
v4 = *(a2 - 1);
Iterator = JS_GetIterator(a1, v3, v4, a3);
v7 = v6;
v8 = -1;
if ( (_DWORD)v6 != 6 )
{
v9 = Iterator;
JS_FreeValue(a1, v3, v4);
*(a2 - 2) = v9;
*(a2 - 1) = v7;
Property = JS_GetProperty(a1, v9, v7, 107);
v8 = -1;
if ( (_DWORD)v11 != 6 )
{
*a2 = Property;
a2[1] = v11;
return 0;
}
}
return v8;
}
| js_for_of_start:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV ECX,EDX
MOV RBX,RSI
MOV R14,RDI
MOV R15,qword ptr [RSI + -0x10]
MOV R12,qword ptr [RSI + -0x8]
MOV RSI,R15
MOV RDX,R12
CALL 0x0013d237
MOV RBP,RDX
PUSH -0x1
POP RCX
CMP EBP,0x6
JZ 0x0013b8e0
MOV R13,RAX
MOV RDI,R14
MOV RSI,R15
MOV RDX,R12
MOV R15D,ECX
CALL 0x0011bbce
MOV qword ptr [RBX + -0x10],R13
MOV qword ptr [RBX + -0x8],RBP
PUSH 0x6b
POP RCX
MOV RDI,R14
MOV RSI,R13
MOV RDX,RBP
CALL 0x0011ebf3
MOV ECX,R15D
CMP EDX,0x6
JZ 0x0013b8e0
MOV qword ptr [RBX],RAX
MOV qword ptr [RBX + 0x8],RDX
XOR ECX,ECX
LAB_0013b8e0:
MOV EAX,ECX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int4 js_for_of_start(int8 param_1,int1 (*param_2) [16],int4 param_3)
{
int8 uVar1;
int8 uVar2;
int4 uVar3;
int1 auVar4 [16];
uVar1 = *(int8 *)param_2[-1];
uVar2 = *(int8 *)(param_2[-1] + 8);
auVar4 = JS_GetIterator(param_1,uVar1,uVar2,param_3);
uVar3 = 0xffffffff;
if (auVar4._8_4_ != 6) {
uVar3 = 0xffffffff;
JS_FreeValue(param_1,uVar1,uVar2);
param_2[-1] = auVar4;
auVar4 = JS_GetProperty(param_1,auVar4._0_8_,auVar4._8_8_,0x6b);
if (auVar4._8_4_ != 6) {
*param_2 = auVar4;
uVar3 = 0;
}
}
return uVar3;
}
|
|
935 | minja::Parser::parseLogicalNot() | monkey531[P]llama/common/minja.hpp | std::shared_ptr<Expression> parseLogicalNot() {
static std::regex not_tok(R"(not\b)");
auto location = get_location();
if (!consumeToken(not_tok).empty()) {
auto sub = parseLogicalNot();
if (!sub) throw std::runtime_error("Expected expression after 'not' keyword");
return std::make_shared<UnaryOpExpr>(location, std::move(sub), UnaryOpExpr::Op::LogicalNot);
}
return parseLogicalCompare();
} | O2 | cpp | minja::Parser::parseLogicalNot():
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x9c9c2(%rip), %rax # 0x1000c0
movb (%rax), %al
testb %al, %al
je 0x637bf
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x619f6
leaq 0x9c984(%rip), %rdx # 0x1000a0
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %rcx
movq %r14, %rsi
callq 0x61e1a
leaq 0x8(%rsp), %rdi
movq 0x8(%rdi), %r15
callq 0x242a8
testq %r15, %r15
je 0x6379d
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x636e8
cmpq $0x0, 0x8(%rsp)
je 0x63814
leaq 0x4(%rsp), %rcx
movl $0x2, (%rcx)
leaq 0x40(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x6388c
leaq 0x48(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movups %xmm0, (%rbx)
andq $0x0, -0x8(%rdi)
callq 0x51272
leaq 0x10(%rsp), %rdi
callq 0x51272
jmp 0x637a8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x638b0
leaq 0x30(%rsp), %rdi
callq 0x51272
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x9c8fa(%rip), %rdi # 0x1000c0
callq 0x240b0
testl %eax, %eax
je 0x63708
leaq 0x9c8c6(%rip), %rdi # 0x1000a0
leaq 0x5196d(%rip), %rsi # 0xb514e
pushq $0x10
popq %rdx
callq 0x47dc4
leaq -0x1b806(%rip), %rdi # 0x47fea
leaq 0x9c8a9(%rip), %rsi # 0x1000a0
leaq 0x9c15a(%rip), %rdx # 0xff958
callq 0x237c0
leaq 0x9c8b6(%rip), %rdi # 0x1000c0
callq 0x235e0
jmp 0x63708
pushq $0x10
popq %rdi
callq 0x23470
movq %rax, %r14
leaq 0x5192e(%rip), %rsi # 0xb5154
movq %rax, %rdi
callq 0x23330
movq 0x9b7b3(%rip), %rsi # 0xfefe8
movq 0x9b70c(%rip), %rdx # 0xfef48
movq %r14, %rdi
callq 0x23fb0
movq %rax, %rbx
leaq 0x9c872(%rip), %rdi # 0x1000c0
callq 0x235d0
jmp 0x63884
jmp 0x63866
movq %rax, %rbx
movq %r14, %rdi
callq 0x23690
jmp 0x63869
jmp 0x63877
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x51272
jmp 0x6387a
jmp 0x63877
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x51272
movq %rbx, %rdi
callq 0x24030
| _ZN5minja6Parser15parseLogicalNotEv:
push r15
push r14
push rbx
sub rsp, 50h
mov r14, rsi
mov rbx, rdi
lea rax, _ZGVZN5minja6Parser15parseLogicalNotEvE7not_tokB5cxx11; `guard variable for'minja::Parser::parseLogicalNot(void)::not_tok
mov al, [rax]
test al, al
jz loc_637BF
loc_63708:
lea rdi, [rsp+68h+var_40]; this
mov rsi, r14
call _ZNK5minja6Parser12get_locationEv; minja::Parser::get_location(void)
lea rdx, _ZZN5minja6Parser15parseLogicalNotEvE7not_tokB5cxx11; minja::Parser::parseLogicalNot(void)::not_tok
lea rdi, [rsp+68h+var_60]
push 1
pop rcx
mov rsi, r14
call _ZN5minja6Parser12consumeTokenERKNSt7__cxx1111basic_regexIcNS1_12regex_traitsIcEEEENS_13SpaceHandlingE; minja::Parser::consumeToken(std::basic_regex<char,std::regex_traits<char>> const&,minja::SpaceHandling)
lea rdi, [rsp+68h+var_60]; void *
mov r15, [rdi+8]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test r15, r15
jz short loc_6379D
lea rdi, [rsp+68h+var_60]; this
mov rsi, r14
call _ZN5minja6Parser15parseLogicalNotEv; minja::Parser::parseLogicalNot(void)
cmp [rsp+68h+var_60], 0
jz loc_63814
lea rcx, [rsp+68h+var_64]
mov dword ptr [rcx], 2
lea rdi, [rsp+68h+var_28]
lea rsi, [rsp+68h+var_40]
lea rdx, [rsp+68h+var_60]
call _ZSt11make_sharedIN5minja11UnaryOpExprEJRNS0_8LocationESt10shared_ptrINS0_10ExpressionEENS1_2OpEEES4_IT_EDpOT0_; std::make_shared<minja::UnaryOpExpr,minja::Location &,std::shared_ptr<minja::Expression>,minja::UnaryOpExpr::Op>(minja::Location &,std::shared_ptr<minja::Expression>,minja::UnaryOpExpr::Op &&)
lea rdi, [rsp+68h+var_20]
movaps xmm0, xmmword ptr [rdi-8]
and qword ptr [rdi], 0
movups xmmword ptr [rbx], xmm0
and qword ptr [rdi-8], 0
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea rdi, [rsp+68h+var_58]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
jmp short loc_637A8
loc_6379D:
mov rdi, rbx; this
mov rsi, r14
call _ZN5minja6Parser19parseLogicalCompareEv; minja::Parser::parseLogicalCompare(void)
loc_637A8:
lea rdi, [rsp+68h+var_38]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rax, rbx
add rsp, 50h
pop rbx
pop r14
pop r15
retn
loc_637BF:
lea rdi, _ZGVZN5minja6Parser15parseLogicalNotEvE7not_tokB5cxx11; __guard *
call ___cxa_guard_acquire
test eax, eax
jz loc_63708
lea rdi, _ZZN5minja6Parser15parseLogicalNotEvE7not_tokB5cxx11; minja::Parser::parseLogicalNot(void)::not_tok
lea rsi, aNotB; "not\\b"
push 10h
pop rdx
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEEC2EPKcNSt15regex_constants18syntax_option_typeE; std::basic_regex<char,std::regex_traits<char>>::basic_regex(char const*,std::regex_constants::syntax_option_type)
lea rdi, _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; lpfunc
lea rsi, _ZZN5minja6Parser15parseLogicalNotEvE7not_tokB5cxx11; obj
lea rdx, __dso_handle; lpdso_handle
call ___cxa_atexit
lea rdi, _ZGVZN5minja6Parser15parseLogicalNotEvE7not_tokB5cxx11; __guard *
call ___cxa_guard_release
jmp loc_63708
loc_63814:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aExpectedExpres_2; "Expected expression after 'not' keyword"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
mov rbx, rax
lea rdi, _ZGVZN5minja6Parser15parseLogicalNotEvE7not_tokB5cxx11; __guard *
call ___cxa_guard_abort
jmp short loc_63884
jmp short loc_63866
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_63869
jmp short loc_63877
loc_63866:
mov rbx, rax
loc_63869:
lea rdi, [rsp+68h+var_58]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
jmp short loc_6387A
jmp short $+2
loc_63877:
mov rbx, rax
loc_6387A:
lea rdi, [rsp+68h+var_38]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
loc_63884:
mov rdi, rbx
call __Unwind_Resume
| minja::Parser * minja::Parser::parseLogicalNot(minja::Parser *this, _QWORD *a2)
{
long long v2; // r15
__int128 v3; // xmm0
std::runtime_error *exception; // r14
int v6; // [rsp+4h] [rbp-64h] BYREF
long long v7; // [rsp+8h] [rbp-60h] BYREF
_QWORD v8[3]; // [rsp+10h] [rbp-58h] BYREF
_BYTE v9[8]; // [rsp+28h] [rbp-40h] BYREF
long long v10; // [rsp+30h] [rbp-38h] BYREF
_OWORD v11[2]; // [rsp+40h] [rbp-28h] BYREF
if ( !(_BYTE)`guard variable for'minja::Parser::parseLogicalNot(void)::not_tok[abi:cxx11]
&& __cxa_guard_acquire(&`guard variable for'minja::Parser::parseLogicalNot(void)::not_tok[abi:cxx11]) )
{
std::basic_regex<char,std::regex_traits<char>>::basic_regex(
(long long)&minja::Parser::parseLogicalNot(void)::not_tok[abi:cxx11],
(long long)"not\\b",
0x10u);
__cxa_atexit(
(void (*)(void *))std::basic_regex<char,std::regex_traits<char>>::~basic_regex,
&minja::Parser::parseLogicalNot(void)::not_tok[abi:cxx11],
&_dso_handle);
__cxa_guard_release(&`guard variable for'minja::Parser::parseLogicalNot(void)::not_tok[abi:cxx11]);
}
minja::Parser::get_location((minja::Parser *)v9, a2);
minja::Parser::consumeToken(&v7, (long long)a2, (long long)&minja::Parser::parseLogicalNot(void)::not_tok[abi:cxx11], 1u);
v2 = v8[0];
std::string::~string(&v7);
if ( v2 )
{
minja::Parser::parseLogicalNot((minja::Parser *)&v7);
if ( !v7 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Expected expression after 'not' keyword");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v6 = 2;
std::make_shared<minja::UnaryOpExpr,minja::Location &,std::shared_ptr<minja::Expression>,minja::UnaryOpExpr::Op>(
v11,
v9,
&v7,
&v6);
v3 = v11[0];
*((_QWORD *)&v11[0] + 1) = 0LL;
*(_OWORD *)this = v3;
*(_QWORD *)&v11[0] = 0LL;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count((_QWORD *)v11 + 1);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(v8);
}
else
{
minja::Parser::parseLogicalCompare(this);
}
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v10);
return this;
}
| parseLogicalNot:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x50
MOV R14,RSI
MOV RBX,RDI
LEA RAX,[0x2000c0]
MOV AL,byte ptr [RAX]
TEST AL,AL
JZ 0x001637bf
LAB_00163708:
LEA RDI,[RSP + 0x28]
MOV RSI,R14
CALL 0x001619f6
LAB_00163715:
LEA RDX,[0x2000a0]
LEA RDI,[RSP + 0x8]
PUSH 0x1
POP RCX
MOV RSI,R14
CALL 0x00161e1a
LEA RDI,[RSP + 0x8]
MOV R15,qword ptr [RDI + 0x8]
CALL 0x001242a8
TEST R15,R15
JZ 0x0016379d
LAB_0016373f:
LEA RDI,[RSP + 0x8]
MOV RSI,R14
CALL 0x001636e8
CMP qword ptr [RSP + 0x8],0x0
JZ 0x00163814
LEA RCX,[RSP + 0x4]
MOV dword ptr [RCX],0x2
LAB_00163763:
LEA RDI,[RSP + 0x40]
LEA RSI,[RSP + 0x28]
LEA RDX,[RSP + 0x8]
CALL 0x0016388c
LEA RDI,[RSP + 0x48]
MOVAPS XMM0,xmmword ptr [RDI + -0x8]
AND qword ptr [RDI],0x0
MOVUPS xmmword ptr [RBX],XMM0
AND qword ptr [RDI + -0x8],0x0
CALL 0x00151272
LEA RDI,[RSP + 0x10]
CALL 0x00151272
JMP 0x001637a8
LAB_0016379d:
MOV RDI,RBX
MOV RSI,R14
CALL 0x001638b0
LAB_001637a8:
LEA RDI,[RSP + 0x30]
CALL 0x00151272
MOV RAX,RBX
ADD RSP,0x50
POP RBX
POP R14
POP R15
RET
LAB_001637bf:
LEA RDI,[0x2000c0]
CALL 0x001240b0
TEST EAX,EAX
JZ 0x00163708
LAB_001637d3:
LEA RDI,[0x2000a0]
LEA RSI,[0x1b514e]
PUSH 0x10
POP RDX
CALL 0x00147dc4
LAB_001637e9:
LEA RDI,[0x147fea]
LEA RSI,[0x2000a0]
LEA RDX,[0x1ff958]
CALL 0x001237c0
LEA RDI,[0x2000c0]
CALL 0x001235e0
JMP 0x00163708
LAB_00163814:
PUSH 0x10
POP RDI
CALL 0x00123470
MOV R14,RAX
LAB_0016381f:
LEA RSI,[0x1b5154]
MOV RDI,RAX
CALL 0x00123330
LAB_0016382e:
MOV RSI,qword ptr [0x001fefe8]
MOV RDX,qword ptr [0x001fef48]
MOV RDI,R14
CALL 0x00123fb0
|
/* minja::Parser::parseLogicalNot() */
void minja::Parser::parseLogicalNot(void)
{
int8 uVar1;
int iVar2;
runtime_error *this;
int8 *in_RDI;
long local_60;
long local_58 [3];
shared_ptr local_40 [8];
__shared_count<(__gnu_cxx::_Lock_policy)2> local_38 [16];
int8 local_28;
int8 uStack_20;
if (parseLogicalNot()::not_tok_abi_cxx11_ == '\0') {
iVar2 = __cxa_guard_acquire(&parseLogicalNot()::not_tok_abi_cxx11_);
if (iVar2 != 0) {
/* try { // try from 001637d3 to 001637e8 has its CatchHandler @ 00163844 */
std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::basic_regex
((basic_regex<char,std::__cxx11::regex_traits<char>> *)
parseLogicalNot()::not_tok_abi_cxx11_,"not\\b",0x10);
__cxa_atexit(std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::~basic_regex,
parseLogicalNot()::not_tok_abi_cxx11_,&__dso_handle);
__cxa_guard_release(&parseLogicalNot()::not_tok_abi_cxx11_);
}
}
get_location();
/* try { // try from 00163715 to 0016372b has its CatchHandler @ 00163877 */
consumeToken(&local_60);
std::__cxx11::string::~string((string *)&local_60);
if (local_58[0] == 0) {
/* try { // try from 0016379d to 001637a7 has its CatchHandler @ 00163864 */
parseLogicalCompare();
}
else {
/* try { // try from 0016373f to 0016374b has its CatchHandler @ 00163875 */
parseLogicalNot();
if (local_60 == 0) {
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0016381f to 0016382d has its CatchHandler @ 00163857 */
std::runtime_error::runtime_error(this,"Expected expression after \'not\' keyword");
/* try { // try from 0016382e to 00163843 has its CatchHandler @ 00163855 */
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_001fefe8,PTR__runtime_error_001fef48);
}
/* try { // try from 00163763 to 00163776 has its CatchHandler @ 00163866 */
std::
make_shared<minja::UnaryOpExpr,minja::Location&,std::shared_ptr<minja::Expression>,minja::UnaryOpExpr::Op>
((Location *)&local_28,local_40,(Op *)&local_60);
uVar1 = uStack_20;
uStack_20 = 0;
*in_RDI = local_28;
in_RDI[1] = uVar1;
local_28 = 0;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)&uStack_20);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)local_58);
}
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_38);
return;
}
|
|
936 | mthd_my_read_rows | eloqsql/libmariadb/libmariadb/mariadb_lib.c | MYSQL_DATA *mthd_my_read_rows(MYSQL *mysql,MYSQL_FIELD *mysql_fields,
uint fields)
{
uint field;
ulong pkt_len;
ulong len;
uchar *cp;
char *to, *end_to;
MYSQL_DATA *result;
MYSQL_ROWS **prev_ptr,*cur;
NET *net = &mysql->net;
if ((pkt_len= ma_net_safe_read(mysql)) == packet_error)
return(0);
if (!(result=(MYSQL_DATA*) calloc(1, sizeof(MYSQL_DATA))))
{
SET_CLIENT_ERROR(mysql, CR_OUT_OF_MEMORY, SQLSTATE_UNKNOWN, 0);
return(0);
}
ma_init_alloc_root(&result->alloc,8192,0); /* Assume rowlength < 8192 */
result->alloc.min_malloc=sizeof(MYSQL_ROWS);
prev_ptr= &result->data;
result->rows=0;
result->fields=fields;
while (*(cp=net->read_pos) != 254 || pkt_len >= 8)
{
result->rows++;
if (!(cur= (MYSQL_ROWS*) ma_alloc_root(&result->alloc,
sizeof(MYSQL_ROWS))) ||
!(cur->data= ((MYSQL_ROW)
ma_alloc_root(&result->alloc,
(fields+1)*sizeof(char *)+fields+pkt_len))))
{
free_rows(result);
SET_CLIENT_ERROR(mysql, CR_OUT_OF_MEMORY, SQLSTATE_UNKNOWN, 0);
return(0);
}
*prev_ptr=cur;
prev_ptr= &cur->next;
to= (char*) (cur->data+fields+1);
end_to=to+fields+pkt_len-1;
for (field=0 ; field < fields ; field++)
{
if ((len=(ulong) net_field_length(&cp)) == NULL_LENGTH)
{ /* null field */
cur->data[field] = 0;
}
else
{
cur->data[field] = to;
if (len > (ulong)(end_to - to) || to > end_to)
{
free_rows(result);
SET_CLIENT_ERROR(mysql, CR_UNKNOWN_ERROR, SQLSTATE_UNKNOWN, 0);
return(0);
}
memcpy(to,(char*) cp,len); to[len]=0;
to+=len+1;
cp+=len;
if (mysql_fields)
{
if (mysql_fields[field].max_length < len)
mysql_fields[field].max_length=len;
}
}
}
cur->data[field]=to; /* End of last field */
if ((pkt_len=ma_net_safe_read(mysql)) == packet_error)
{
free_rows(result);
return(0);
}
}
*prev_ptr=0; /* last pointer is null */
/* save status */
if (pkt_len > 1)
{
cp++;
mysql->warning_count= uint2korr(cp);
cp+= 2;
mysql->server_status= uint2korr(cp);
}
return(result);
} | O0 | c | mthd_my_read_rows:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7a730
movq %rax, -0x28(%rbp)
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
cmpq %rcx, %rax
jne 0x7ed1f
movq $0x0, -0x8(%rbp)
jmp 0x7f166
movl $0x1, %edi
movl $0x60, %esi
callq 0x60a00
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
jne 0x7edaa
jmp 0x7ed3a
movq -0x10(%rbp), %rax
movl $0x7d8, 0x90(%rax) # imm = 0x7D8
movq -0x10(%rbp), %rdi
addq $0x297, %rdi # imm = 0x297
leaq 0x282626(%rip), %rax # 0x301380
movq (%rax), %rsi
movl $0x5, %edx
callq 0x60180
movq -0x10(%rbp), %rax
movb $0x0, 0x29c(%rax)
movq -0x10(%rbp), %rdi
addq $0x97, %rdi
leaq 0x28260c(%rip), %rax # 0x301390
movq 0x40(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x60180
movq -0x10(%rbp), %rax
movb $0x0, 0x296(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x7f166
movq -0x50(%rbp), %rdi
addq $0x10, %rdi
movl $0x2000, %esi # imm = 0x2000
xorl %eax, %eax
movl %eax, %edx
callq 0x89350
movq -0x50(%rbp), %rax
movq $0x18, 0x28(%rax)
movq -0x50(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rax
movq $0x0, 0x48(%rax)
movl -0x1c(%rbp), %ecx
movq -0x50(%rbp), %rax
movl %ecx, 0x50(%rax)
movq -0x68(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
movzbl (%rax), %ecx
movb $0x1, %al
cmpl $0xfe, %ecx
movb %al, -0x69(%rbp)
jne 0x7ee11
cmpq $0x8, -0x28(%rbp)
setae %al
movb %al, -0x69(%rbp)
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x7ee1d
jmp 0x7f0e6
movq -0x50(%rbp), %rax
movq 0x48(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x48(%rax)
movq -0x50(%rbp), %rdi
addq $0x10, %rdi
movl $0x18, %esi
callq 0x89430
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0x7ee7c
movq -0x50(%rbp), %rdi
addq $0x10, %rdi
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
shlq $0x3, %rsi
movl -0x1c(%rbp), %eax
addq %rax, %rsi
addq -0x28(%rbp), %rsi
callq 0x89430
movq -0x60(%rbp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x7eef5
movq -0x50(%rbp), %rdi
callq 0x7ae90
movq -0x10(%rbp), %rax
movl $0x7d8, 0x90(%rax) # imm = 0x7D8
movq -0x10(%rbp), %rdi
addq $0x297, %rdi # imm = 0x297
leaq 0x2824db(%rip), %rax # 0x301380
movq (%rax), %rsi
movl $0x5, %edx
callq 0x60180
movq -0x10(%rbp), %rax
movb $0x0, 0x29c(%rax)
movq -0x10(%rbp), %rdi
addq $0x97, %rdi
leaq 0x2824c1(%rip), %rax # 0x301390
movq 0x40(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x60180
movq -0x10(%rbp), %rax
movb $0x0, 0x296(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x7f166
movq -0x60(%rbp), %rcx
movq -0x58(%rbp), %rax
movq %rcx, (%rax)
movq -0x60(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x60(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x1c(%rbp), %ecx
shlq $0x3, %rcx
addq %rcx, %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl -0x1c(%rbp), %ecx
addq %rcx, %rax
addq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x7f0a1
leaq -0x38(%rbp), %rdi
callq 0x7ad50
movq %rax, -0x30(%rbp)
cmpq $-0x1, %rax
jne 0x7ef76
movq -0x60(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x20(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
jmp 0x7f091
movq -0x40(%rbp), %rdx
movq -0x60(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x20(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movq -0x30(%rbp), %rax
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
ja 0x7efa7
movq -0x40(%rbp), %rax
cmpq -0x48(%rbp), %rax
jbe 0x7f01f
movq -0x50(%rbp), %rdi
callq 0x7ae90
movq -0x10(%rbp), %rax
movl $0x7d0, 0x90(%rax) # imm = 0x7D0
movq -0x10(%rbp), %rdi
addq $0x297, %rdi # imm = 0x297
leaq 0x2823b0(%rip), %rax # 0x301380
movq (%rax), %rsi
movl $0x5, %edx
callq 0x60180
movq -0x10(%rbp), %rax
movb $0x0, 0x29c(%rax)
movq -0x10(%rbp), %rdi
addq $0x97, %rdi
leaq 0x282396(%rip), %rax # 0x301390
movq (%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x60180
movq -0x10(%rbp), %rax
movb $0x0, 0x296(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x7f166
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x600e0
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x30(%rbp), %rax
addq $0x1, %rax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x7f08f
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
shlq $0x7, %rcx
addq %rcx, %rax
movq 0x40(%rax), %rax
cmpq -0x30(%rbp), %rax
jae 0x7f08d
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %edx
shlq $0x7, %rdx
addq %rdx, %rax
movq %rcx, 0x40(%rax)
jmp 0x7f08f
jmp 0x7f091
jmp 0x7f093
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x7ef3f
movq -0x40(%rbp), %rdx
movq -0x60(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x20(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rdi
callq 0x7a730
movq %rax, -0x28(%rbp)
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
cmpq %rcx, %rax
jne 0x7f0e1
movq -0x50(%rbp), %rdi
callq 0x7ae90
movq $0x0, -0x8(%rbp)
jmp 0x7f166
jmp 0x7edea
movq -0x58(%rbp), %rax
movq $0x0, (%rax)
cmpq $0x1, -0x28(%rbp)
jbe 0x7f15e
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movzbl (%rax), %eax
movzwl %ax, %eax
movq -0x38(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
addl %ecx, %eax
movzwl %ax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x388(%rax)
movq -0x38(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movzbl (%rax), %eax
movzwl %ax, %eax
movq -0x38(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
addl %ecx, %eax
movzwl %ax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x380(%rax)
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
| mthd_my_read_rows:
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov rax, [rbp+var_10]
mov [rbp+var_68], rax
mov rdi, [rbp+var_10]
call ma_net_safe_read
mov [rbp+var_28], rax
mov ecx, 0FFFFFFFFh
cmp rax, rcx
jnz short loc_7ED1F
mov [rbp+var_8], 0
jmp loc_7F166
loc_7ED1F:
mov edi, 1
mov esi, 60h ; '`'
call _calloc
mov [rbp+var_50], rax
cmp rax, 0
jnz short loc_7EDAA
jmp short $+2
loc_7ED3A:
mov rax, [rbp+var_10]
mov dword ptr [rax+90h], 7D8h
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+40h]
mov edx, 1FFh
call _strncpy
mov rax, [rbp+var_10]
mov byte ptr [rax+296h], 0
mov [rbp+var_8], 0
jmp loc_7F166
loc_7EDAA:
mov rdi, [rbp+var_50]
add rdi, 10h
mov esi, 2000h
xor eax, eax
mov edx, eax
call ma_init_alloc_root
mov rax, [rbp+var_50]
mov qword ptr [rax+28h], 18h
mov rax, [rbp+var_50]
mov [rbp+var_58], rax
mov rax, [rbp+var_50]
mov qword ptr [rax+48h], 0
mov ecx, [rbp+var_1C]
mov rax, [rbp+var_50]
mov [rax+50h], ecx
loc_7EDEA:
mov rax, [rbp+var_68]
mov rax, [rax+20h]
mov [rbp+var_38], rax
movzx ecx, byte ptr [rax]
mov al, 1
cmp ecx, 0FEh
mov [rbp+var_69], al
jnz short loc_7EE11
cmp [rbp+var_28], 8
setnb al
mov [rbp+var_69], al
loc_7EE11:
mov al, [rbp+var_69]
test al, 1
jnz short loc_7EE1D
jmp loc_7F0E6
loc_7EE1D:
mov rax, [rbp+var_50]
mov rcx, [rax+48h]
add rcx, 1
mov [rax+48h], rcx
mov rdi, [rbp+var_50]
add rdi, 10h
mov esi, 18h
call ma_alloc_root
mov [rbp+var_60], rax
cmp rax, 0
jz short loc_7EE7C
mov rdi, [rbp+var_50]
add rdi, 10h
mov eax, [rbp+var_1C]
add eax, 1
mov eax, eax
mov esi, eax
shl rsi, 3
mov eax, [rbp+var_1C]
add rsi, rax
add rsi, [rbp+var_28]
call ma_alloc_root
mov rcx, [rbp+var_60]
mov [rcx+8], rax
cmp rax, 0
jnz short loc_7EEF5
loc_7EE7C:
mov rdi, [rbp+var_50]
call free_rows
mov rax, [rbp+var_10]
mov dword ptr [rax+90h], 7D8h
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+40h]
mov edx, 1FFh
call _strncpy
mov rax, [rbp+var_10]
mov byte ptr [rax+296h], 0
mov [rbp+var_8], 0
jmp loc_7F166
loc_7EEF5:
mov rcx, [rbp+var_60]
mov rax, [rbp+var_58]
mov [rax], rcx
mov rax, [rbp+var_60]
mov [rbp+var_58], rax
mov rax, [rbp+var_60]
mov rax, [rax+8]
mov ecx, [rbp+var_1C]
shl rcx, 3
add rax, rcx
add rax, 8
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
mov ecx, [rbp+var_1C]
add rax, rcx
add rax, [rbp+var_28]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_48], rax
mov [rbp+var_20], 0
loc_7EF3F:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_1C]
jnb loc_7F0A1
lea rdi, [rbp+var_38]
call net_field_length
mov [rbp+var_30], rax
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_7EF76
mov rax, [rbp+var_60]
mov rax, [rax+8]
mov ecx, [rbp+var_20]
mov qword ptr [rax+rcx*8], 0
jmp loc_7F091
loc_7EF76:
mov rdx, [rbp+var_40]
mov rax, [rbp+var_60]
mov rax, [rax+8]
mov ecx, [rbp+var_20]
mov [rax+rcx*8], rdx
mov rax, [rbp+var_30]
mov rcx, [rbp+var_48]
mov rdx, [rbp+var_40]
sub rcx, rdx
cmp rax, rcx
ja short loc_7EFA7
mov rax, [rbp+var_40]
cmp rax, [rbp+var_48]
jbe short loc_7F01F
loc_7EFA7:
mov rdi, [rbp+var_50]
call free_rows
mov rax, [rbp+var_10]
mov dword ptr [rax+90h], 7D0h
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]
mov edx, 1FFh
call _strncpy
mov rax, [rbp+var_10]
mov byte ptr [rax+296h], 0
mov [rbp+var_8], 0
jmp loc_7F166
loc_7F01F:
mov rdi, [rbp+var_40]
mov rsi, [rbp+var_38]
mov rdx, [rbp+var_30]
call _memcpy
mov rax, [rbp+var_40]
mov rcx, [rbp+var_30]
mov byte ptr [rax+rcx], 0
mov rax, [rbp+var_30]
add rax, 1
add rax, [rbp+var_40]
mov [rbp+var_40], rax
mov rax, [rbp+var_30]
add rax, [rbp+var_38]
mov [rbp+var_38], rax
cmp [rbp+var_18], 0
jz short loc_7F08F
mov rax, [rbp+var_18]
mov ecx, [rbp+var_20]
shl rcx, 7
add rax, rcx
mov rax, [rax+40h]
cmp rax, [rbp+var_30]
jnb short loc_7F08D
mov rcx, [rbp+var_30]
mov rax, [rbp+var_18]
mov edx, [rbp+var_20]
shl rdx, 7
add rax, rdx
mov [rax+40h], rcx
loc_7F08D:
jmp short $+2
loc_7F08F:
jmp short $+2
loc_7F091:
jmp short $+2
loc_7F093:
mov eax, [rbp+var_20]
add eax, 1
mov [rbp+var_20], eax
jmp loc_7EF3F
loc_7F0A1:
mov rdx, [rbp+var_40]
mov rax, [rbp+var_60]
mov rax, [rax+8]
mov ecx, [rbp+var_20]
mov [rax+rcx*8], rdx
mov rdi, [rbp+var_10]
call ma_net_safe_read
mov [rbp+var_28], rax
mov ecx, 0FFFFFFFFh
cmp rax, rcx
jnz short loc_7F0E1
mov rdi, [rbp+var_50]
call free_rows
mov [rbp+var_8], 0
jmp loc_7F166
loc_7F0E1:
jmp loc_7EDEA
loc_7F0E6:
mov rax, [rbp+var_58]
mov qword ptr [rax], 0
cmp [rbp+var_28], 1
jbe short loc_7F15E
mov rax, [rbp+var_38]
add rax, 1
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
movzx eax, byte ptr [rax]
movzx eax, ax
mov rcx, [rbp+var_38]
movzx ecx, byte ptr [rcx+1]
movzx ecx, cx
shl ecx, 8
add eax, ecx
movzx ecx, ax
mov rax, [rbp+var_10]
mov [rax+388h], ecx
mov rax, [rbp+var_38]
add rax, 2
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
movzx eax, byte ptr [rax]
movzx eax, ax
mov rcx, [rbp+var_38]
movzx ecx, byte ptr [rcx+1]
movzx ecx, cx
shl ecx, 8
add eax, ecx
movzx ecx, ax
mov rax, [rbp+var_10]
mov [rax+380h], ecx
loc_7F15E:
mov rax, [rbp+var_50]
mov [rbp+var_8], rax
loc_7F166:
mov rax, [rbp+var_8]
add rsp, 70h
pop rbp
retn
| long long mthd_my_read_rows(long long a1, long long a2, long long a3, long long a4, int a5, int a6)
{
unsigned __int8 *v6; // rsi
long long v7; // rax
int v8; // r8d
int v9; // r9d
long long v10; // rcx
bool v12; // [rsp+7h] [rbp-69h]
long long v13; // [rsp+10h] [rbp-60h]
_QWORD *v14; // [rsp+18h] [rbp-58h]
long long v15; // [rsp+20h] [rbp-50h]
unsigned long long v16; // [rsp+28h] [rbp-48h]
unsigned long long v17; // [rsp+30h] [rbp-40h]
unsigned __int8 *v18; // [rsp+38h] [rbp-38h] BYREF
unsigned long long v19; // [rsp+40h] [rbp-30h]
unsigned long long v20; // [rsp+48h] [rbp-28h]
unsigned int i; // [rsp+50h] [rbp-20h]
unsigned int v22; // [rsp+54h] [rbp-1Ch]
long long v23; // [rsp+58h] [rbp-18h]
long long v24; // [rsp+60h] [rbp-10h]
v24 = a1;
v23 = a2;
v22 = a3;
v20 = ma_net_safe_read(a1, a2, a3, a4, a5, a6);
if ( v20 == 0xFFFFFFFF )
return 0LL;
v15 = calloc(1LL, 96LL);
if ( v15 )
{
ma_init_alloc_root(v15 + 16, 0x2000LL, 0LL);
*(_QWORD *)(v15 + 40) = 24LL;
v14 = (_QWORD *)v15;
*(_QWORD *)(v15 + 72) = 0LL;
*(_DWORD *)(v15 + 80) = v22;
while ( 1 )
{
v18 = *(unsigned __int8 **)(a1 + 32);
v12 = 1;
if ( *v18 == 254 )
v12 = v20 >= 8;
if ( !v12 )
break;
++*(_QWORD *)(v15 + 72);
v13 = ma_alloc_root(v15 + 16, 24LL);
if ( !v13
|| (v6 = (unsigned __int8 *)(v20 + v22 + 8LL * (v22 + 1)),
v7 = ma_alloc_root(v15 + 16, v6),
(*(_QWORD *)(v13 + 8) = v7) == 0LL) )
{
free_rows(v15);
*(_DWORD *)(v24 + 144) = 2008;
strncpy(v24 + 663, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(v24 + 668) = 0;
strncpy(v24 + 151, client_errors[8], 511LL);
*(_BYTE *)(v24 + 662) = 0;
return 0LL;
}
*v14 = v13;
v14 = (_QWORD *)v13;
v17 = 8LL * v22 + *(_QWORD *)(v13 + 8) + 8;
v16 = v20 + v22 + v17 - 1;
for ( i = 0; i < v22; ++i )
{
v19 = net_field_length(&v18);
if ( v19 == -1LL )
{
*(_QWORD *)(*(_QWORD *)(v13 + 8) + 8LL * i) = 0LL;
}
else
{
*(_QWORD *)(*(_QWORD *)(v13 + 8) + 8LL * i) = v17;
if ( v19 > v16 - v17 || v17 > v16 )
{
free_rows(v15);
*(_DWORD *)(v24 + 144) = 2000;
strncpy(v24 + 663, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(v24 + 668) = 0;
strncpy(v24 + 151, client_errors[0], 511LL);
*(_BYTE *)(v24 + 662) = 0;
return 0LL;
}
v6 = v18;
memcpy(v17, v18, v19);
*(_BYTE *)(v17 + v19) = 0;
v17 += v19 + 1;
v18 += v19;
if ( v23 && *(_QWORD *)(((unsigned long long)i << 7) + v23 + 64) < v19 )
*(_QWORD *)(((unsigned long long)i << 7) + v23 + 64) = v19;
}
}
v10 = i;
*(_QWORD *)(*(_QWORD *)(v13 + 8) + 8LL * i) = v17;
v20 = ma_net_safe_read(v24, (long long)v6, v17, v10, v8, v9);
if ( v20 == 0xFFFFFFFF )
{
free_rows(v15);
return 0LL;
}
}
*v14 = 0LL;
if ( v20 > 1 )
{
++v18;
*(_DWORD *)(v24 + 904) = (unsigned __int16)((v18[1] << 8) + *v18);
v18 += 2;
*(_DWORD *)(v24 + 896) = (unsigned __int16)((v18[1] << 8) + *v18);
}
return v15;
}
else
{
*(_DWORD *)(v24 + 144) = 2008;
strncpy(v24 + 663, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(v24 + 668) = 0;
strncpy(v24 + 151, client_errors[8], 511LL);
*(_BYTE *)(v24 + 662) = 0;
return 0LL;
}
}
| mthd_my_read_rows:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x68],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0017a730
MOV qword ptr [RBP + -0x28],RAX
MOV ECX,0xffffffff
CMP RAX,RCX
JNZ 0x0017ed1f
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0017f166
LAB_0017ed1f:
MOV EDI,0x1
MOV ESI,0x60
CALL 0x00160a00
MOV qword ptr [RBP + -0x50],RAX
CMP RAX,0x0
JNZ 0x0017edaa
JMP 0x0017ed3a
LAB_0017ed3a:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x90],0x7d8
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x297
LEA RAX,[0x401380]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00160180
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x29c],0x0
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x97
LEA RAX,[0x401390]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x1ff
CALL 0x00160180
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x296],0x0
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0017f166
LAB_0017edaa:
MOV RDI,qword ptr [RBP + -0x50]
ADD RDI,0x10
MOV ESI,0x2000
XOR EAX,EAX
MOV EDX,EAX
CALL 0x00189350
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RAX + 0x28],0x18
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RAX + 0x48],0x0
MOV ECX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x50]
MOV dword ptr [RAX + 0x50],ECX
LAB_0017edea:
MOV RAX,qword ptr [RBP + -0x68]
MOV RAX,qword ptr [RAX + 0x20]
MOV qword ptr [RBP + -0x38],RAX
MOVZX ECX,byte ptr [RAX]
MOV AL,0x1
CMP ECX,0xfe
MOV byte ptr [RBP + -0x69],AL
JNZ 0x0017ee11
CMP qword ptr [RBP + -0x28],0x8
SETNC AL
MOV byte ptr [RBP + -0x69],AL
LAB_0017ee11:
MOV AL,byte ptr [RBP + -0x69]
TEST AL,0x1
JNZ 0x0017ee1d
JMP 0x0017f0e6
LAB_0017ee1d:
MOV RAX,qword ptr [RBP + -0x50]
MOV RCX,qword ptr [RAX + 0x48]
ADD RCX,0x1
MOV qword ptr [RAX + 0x48],RCX
MOV RDI,qword ptr [RBP + -0x50]
ADD RDI,0x10
MOV ESI,0x18
CALL 0x00189430
MOV qword ptr [RBP + -0x60],RAX
CMP RAX,0x0
JZ 0x0017ee7c
MOV RDI,qword ptr [RBP + -0x50]
ADD RDI,0x10
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,0x1
MOV EAX,EAX
MOV ESI,EAX
SHL RSI,0x3
MOV EAX,dword ptr [RBP + -0x1c]
ADD RSI,RAX
ADD RSI,qword ptr [RBP + -0x28]
CALL 0x00189430
MOV RCX,qword ptr [RBP + -0x60]
MOV qword ptr [RCX + 0x8],RAX
CMP RAX,0x0
JNZ 0x0017eef5
LAB_0017ee7c:
MOV RDI,qword ptr [RBP + -0x50]
CALL 0x0017ae90
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x90],0x7d8
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x297
LEA RAX,[0x401380]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00160180
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x29c],0x0
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x97
LEA RAX,[0x401390]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x1ff
CALL 0x00160180
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x296],0x0
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0017f166
LAB_0017eef5:
MOV RCX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RAX + 0x8]
MOV ECX,dword ptr [RBP + -0x1c]
SHL RCX,0x3
ADD RAX,RCX
ADD RAX,0x8
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV ECX,dword ptr [RBP + -0x1c]
ADD RAX,RCX
ADD RAX,qword ptr [RBP + -0x28]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x48],RAX
MOV dword ptr [RBP + -0x20],0x0
LAB_0017ef3f:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x1c]
JNC 0x0017f0a1
LEA RDI,[RBP + -0x38]
CALL 0x0017ad50
MOV qword ptr [RBP + -0x30],RAX
CMP RAX,-0x1
JNZ 0x0017ef76
MOV RAX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RAX + 0x8]
MOV ECX,dword ptr [RBP + -0x20]
MOV qword ptr [RAX + RCX*0x8],0x0
JMP 0x0017f091
LAB_0017ef76:
MOV RDX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RAX + 0x8]
MOV ECX,dword ptr [RBP + -0x20]
MOV qword ptr [RAX + RCX*0x8],RDX
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RBP + -0x40]
SUB RCX,RDX
CMP RAX,RCX
JA 0x0017efa7
MOV RAX,qword ptr [RBP + -0x40]
CMP RAX,qword ptr [RBP + -0x48]
JBE 0x0017f01f
LAB_0017efa7:
MOV RDI,qword ptr [RBP + -0x50]
CALL 0x0017ae90
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x90],0x7d0
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x297
LEA RAX,[0x401380]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00160180
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x29c],0x0
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x97
LEA RAX,[0x401390]
MOV RSI,qword ptr [RAX]
MOV EDX,0x1ff
CALL 0x00160180
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x296],0x0
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0017f166
LAB_0017f01f:
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x30]
CALL 0x001600e0
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x30]
MOV byte ptr [RAX + RCX*0x1],0x0
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x1
ADD RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x38],RAX
CMP qword ptr [RBP + -0x18],0x0
JZ 0x0017f08f
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x20]
SHL RCX,0x7
ADD RAX,RCX
MOV RAX,qword ptr [RAX + 0x40]
CMP RAX,qword ptr [RBP + -0x30]
JNC 0x0017f08d
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x20]
SHL RDX,0x7
ADD RAX,RDX
MOV qword ptr [RAX + 0x40],RCX
LAB_0017f08d:
JMP 0x0017f08f
LAB_0017f08f:
JMP 0x0017f091
LAB_0017f091:
JMP 0x0017f093
LAB_0017f093:
MOV EAX,dword ptr [RBP + -0x20]
ADD EAX,0x1
MOV dword ptr [RBP + -0x20],EAX
JMP 0x0017ef3f
LAB_0017f0a1:
MOV RDX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RAX + 0x8]
MOV ECX,dword ptr [RBP + -0x20]
MOV qword ptr [RAX + RCX*0x8],RDX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0017a730
MOV qword ptr [RBP + -0x28],RAX
MOV ECX,0xffffffff
CMP RAX,RCX
JNZ 0x0017f0e1
MOV RDI,qword ptr [RBP + -0x50]
CALL 0x0017ae90
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0017f166
LAB_0017f0e1:
JMP 0x0017edea
LAB_0017f0e6:
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RAX],0x0
CMP qword ptr [RBP + -0x28],0x1
JBE 0x0017f15e
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x1
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOVZX EAX,byte ptr [RAX]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x38]
MOVZX ECX,byte ptr [RCX + 0x1]
MOVZX ECX,CX
SHL ECX,0x8
ADD EAX,ECX
MOVZX ECX,AX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x388],ECX
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x2
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOVZX EAX,byte ptr [RAX]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x38]
MOVZX ECX,byte ptr [RCX + 0x1]
MOVZX ECX,CX
SHL ECX,0x8
ADD EAX,ECX
MOVZX ECX,AX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x380],ECX
LAB_0017f15e:
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x8],RAX
LAB_0017f166:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x70
POP RBP
RET
|
int8 * mthd_my_read_rows(long param_1,long param_2,uint param_3)
{
int8 *puVar1;
int8 *puVar2;
long lVar3;
void *pvVar4;
int8 *local_60;
void *local_48;
char *local_40;
ulong local_38;
ulong local_30;
uint local_28;
uint local_24;
long local_20;
long local_18;
local_24 = param_3;
local_20 = param_2;
local_18 = param_1;
local_30 = ma_net_safe_read(param_1);
if (local_30 != 0xffffffff) {
puVar1 = (int8 *)calloc(1,0x60);
if (puVar1 == (int8 *)0x0) {
*(int4 *)(local_18 + 0x90) = 0x7d8;
strncpy((char *)(local_18 + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(local_18 + 0x29c) = 0;
strncpy((char *)(local_18 + 0x97),PTR_s_Client_run_out_of_memory_004013d0,0x1ff);
*(int1 *)(local_18 + 0x296) = 0;
}
else {
ma_init_alloc_root(puVar1 + 2,0x2000,0);
puVar1[5] = 0x18;
puVar1[9] = 0;
*(uint *)(puVar1 + 10) = local_24;
local_60 = puVar1;
do {
local_40 = *(char **)(param_1 + 0x20);
if (*local_40 == -2 && local_30 < 8) {
*local_60 = 0;
if (1 < local_30) {
*(uint *)(local_18 + 0x388) =
(uint)(byte)local_40[1] + (uint)(byte)local_40[2] * 0x100 & 0xffff;
*(uint *)(local_18 + 0x380) =
(uint)(byte)local_40[3] + (uint)(byte)local_40[4] * 0x100 & 0xffff;
return puVar1;
}
return puVar1;
}
puVar1[9] = puVar1[9] + 1;
puVar2 = (int8 *)ma_alloc_root(puVar1 + 2,0x18);
if (puVar2 == (int8 *)0x0) {
LAB_0017ee7c:
free_rows(puVar1);
*(int4 *)(local_18 + 0x90) = 0x7d8;
strncpy((char *)(local_18 + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(local_18 + 0x29c) = 0;
strncpy((char *)(local_18 + 0x97),PTR_s_Client_run_out_of_memory_004013d0,0x1ff);
*(int1 *)(local_18 + 0x296) = 0;
return (int8 *)0x0;
}
lVar3 = ma_alloc_root(puVar1 + 2,(ulong)(local_24 + 1) * 8 + (ulong)local_24 + local_30);
puVar2[1] = lVar3;
if (lVar3 == 0) goto LAB_0017ee7c;
*local_60 = puVar2;
local_48 = (void *)(puVar2[1] + (ulong)local_24 * 8 + 8);
pvVar4 = (void *)((long)local_48 + local_30 + local_24 + -1);
for (local_28 = 0; local_28 < local_24; local_28 = local_28 + 1) {
local_38 = net_field_length(&local_40);
if (local_38 == 0xffffffffffffffff) {
*(int8 *)(puVar2[1] + (ulong)local_28 * 8) = 0;
}
else {
*(void **)(puVar2[1] + (ulong)local_28 * 8) = local_48;
if (((ulong)((long)pvVar4 - (long)local_48) < local_38) || (pvVar4 < local_48)) {
free_rows(puVar1);
*(int4 *)(local_18 + 0x90) = 2000;
strncpy((char *)(local_18 + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(local_18 + 0x29c) = 0;
strncpy((char *)(local_18 + 0x97),client_errors,0x1ff);
*(int1 *)(local_18 + 0x296) = 0;
return (int8 *)0x0;
}
memcpy(local_48,local_40,local_38);
*(int1 *)((long)local_48 + local_38) = 0;
local_48 = (void *)(local_38 + 1 + (long)local_48);
local_40 = local_40 + local_38;
if ((local_20 != 0) && (*(ulong *)(local_20 + (ulong)local_28 * 0x80 + 0x40) < local_38)
) {
*(ulong *)(local_20 + (ulong)local_28 * 0x80 + 0x40) = local_38;
}
}
}
*(void **)(puVar2[1] + (ulong)local_28 * 8) = local_48;
local_30 = ma_net_safe_read(local_18);
local_60 = puVar2;
} while (local_30 != 0xffffffff);
free_rows(puVar1);
}
}
return (int8 *)0x0;
}
|
|
937 | stbi__bitcount(unsigned int) | llama.cpp/examples/llava/../../common/stb_image.h | static int stbi__bitcount(unsigned int a)
{
a = (a & 0x55555555) + ((a >> 1) & 0x55555555); // max 2
a = (a & 0x33333333) + ((a >> 2) & 0x33333333); // max 4
a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits
a = (a + (a >> 8)); // max 16 per 8 bits
a = (a + (a >> 16)); // max 32 per 8 bits
return a & 0xff;
} | O3 | c | stbi__bitcount(unsigned int):
movl $0x55555555, %eax # imm = 0x55555555
movl %edi, %ecx
andl %eax, %ecx
shrl %edi
andl %eax, %edi
addl %ecx, %edi
movl $0x33333333, %eax # imm = 0x33333333
movl %edi, %ecx
andl %eax, %ecx
shrl $0x2, %edi
andl %eax, %edi
addl %ecx, %edi
movl %edi, %eax
shrl $0x4, %eax
addl %edi, %eax
andl $0xf0f0f0f, %eax # imm = 0xF0F0F0F
movl %eax, %ecx
shrl $0x8, %ecx
addl %eax, %ecx
movl %ecx, %eax
shrl $0x10, %eax
addl %ecx, %eax
movzbl %al, %eax
retq
| _ZL14stbi__bitcountj:
mov eax, 55555555h
mov ecx, edi
and ecx, eax
shr edi, 1
and edi, eax
add edi, ecx
mov eax, 33333333h
mov ecx, edi
and ecx, eax
shr edi, 2
and edi, eax
add edi, ecx
mov eax, edi
shr eax, 4
add eax, edi
and eax, 0F0F0F0Fh
mov ecx, eax
shr ecx, 8
add ecx, eax
mov eax, ecx
shr eax, 10h
add eax, ecx
movzx eax, al
retn
| long long stbi__bitcount(unsigned int a1)
{
unsigned int v1; // edi
v1 = (((a1 & 0x55555555) + ((a1 >> 1) & 0x55555555)) & 0x33333333)
+ ((((a1 & 0x55555555) + ((a1 >> 1) & 0x55555555)) >> 2) & 0x33333333);
return (unsigned __int8)(((v1 + (v1 >> 4)) & 0xF)
+ ((unsigned __int16)((v1 + (v1 >> 4)) & 0xF0F) >> 8)
+ ((((v1 + (v1 >> 4)) & 0xF0F0F0F) + (((v1 + (v1 >> 4)) & 0xF0F0F0F) >> 8)) >> 16));
}
| stbi__bitcount:
MOV EAX,0x55555555
MOV ECX,EDI
AND ECX,EAX
SHR EDI,0x1
AND EDI,EAX
ADD EDI,ECX
MOV EAX,0x33333333
MOV ECX,EDI
AND ECX,EAX
SHR EDI,0x2
AND EDI,EAX
ADD EDI,ECX
MOV EAX,EDI
SHR EAX,0x4
ADD EAX,EDI
AND EAX,0xf0f0f0f
MOV ECX,EAX
SHR ECX,0x8
ADD ECX,EAX
MOV EAX,ECX
SHR EAX,0x10
ADD EAX,ECX
MOVZX EAX,AL
RET
|
/* stbi__bitcount(unsigned int) */
uint stbi__bitcount(uint param_1)
{
uint uVar1;
uVar1 = (param_1 >> 1 & 0x55555555) + (param_1 & 0x55555555);
uVar1 = (uVar1 >> 2 & 0x33333333) + (uVar1 & 0x33333333);
uVar1 = (uVar1 >> 4) + uVar1 & 0xf0f0f0f;
uVar1 = (uVar1 >> 8) + uVar1;
return (uVar1 >> 0x10) + uVar1 & 0xff;
}
|
|
938 | fromfp16 | bluesky950520[P]quickjs/cutils.h | static inline double fromfp16(uint16_t v) {
double d, s;
int e;
if ((v & 0x7C00) == 0x7C00) {
d = (v & 0x3FF) ? NAN : INFINITY;
} else {
d = (v & 0x3FF) / 1024.;
e = (v & 0x7C00) >> 10;
if (e == 0) {
e = -14;
} else {
d += 1;
e -= 15;
}
d = scalbn(d, e);
}
s = (v & 0x8000) ? -1.0 : 1.0;
return d * s;
} | O0 | c | fromfp16:
subq $0x38, %rsp
movw %di, %ax
movw %ax, 0x36(%rsp)
movzwl 0x36(%rsp), %eax
andl $0x7c00, %eax # imm = 0x7C00
cmpl $0x7c00, %eax # imm = 0x7C00
jne 0x5f8a6
movzwl 0x36(%rsp), %eax
andl $0x3ff, %eax # imm = 0x3FF
movss 0xac9e1(%rip), %xmm0 # 0x10c250
movss 0xac9dd(%rip), %xmm1 # 0x10c254
movss %xmm1, 0x14(%rsp)
cmpl $0x0, %eax
movss %xmm0, 0x18(%rsp)
jne 0x5f894
movss 0x14(%rsp), %xmm0
movss %xmm0, 0x18(%rsp)
movss 0x18(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
jmp 0x5f91c
movzwl 0x36(%rsp), %eax
andl $0x3ff, %eax # imm = 0x3FF
cvtsi2sd %eax, %xmm0
movsd 0xac864(%rip), %xmm1 # 0x10c120
divsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
movzwl 0x36(%rsp), %eax
andl $0x7c00, %eax # imm = 0x7C00
sarl $0xa, %eax
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
jne 0x5f8e8
movl $0xfffffff2, 0x1c(%rsp) # imm = 0xFFFFFFF2
jmp 0x5f907
movsd 0xac7c0(%rip), %xmm0 # 0x10c0b0
addsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movl 0x1c(%rsp), %eax
subl $0xf, %eax
movl %eax, 0x1c(%rsp)
movsd 0x28(%rsp), %xmm0
movl 0x1c(%rsp), %edi
callq 0xe660
movsd %xmm0, 0x28(%rsp)
movzwl 0x36(%rsp), %eax
andl $0x8000, %eax # imm = 0x8000
movsd 0xac7fa(%rip), %xmm0 # 0x10c128
movsd 0xac77a(%rip), %xmm1 # 0x10c0b0
movsd %xmm1, (%rsp)
cmpl $0x0, %eax
movsd %xmm0, 0x8(%rsp)
jne 0x5f951
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x28(%rsp), %xmm0
mulsd 0x20(%rsp), %xmm0
addq $0x38, %rsp
retq
nop
| fromfp16:
sub rsp, 38h
mov ax, di
mov [rsp+38h+var_2], ax
movzx eax, [rsp+38h+var_2]
and eax, 7C00h
cmp eax, 7C00h
jnz short loc_5F8A6
movzx eax, [rsp+38h+var_2]
and eax, 3FFh
movss xmm0, cs:dword_10C250
movss xmm1, cs:dword_10C254
movss [rsp+38h+var_24], xmm1
cmp eax, 0
movss [rsp+38h+var_20], xmm0
jnz short loc_5F894
movss xmm0, [rsp+38h+var_24]
movss [rsp+38h+var_20], xmm0
loc_5F894:
movss xmm0, [rsp+38h+var_20]
cvtss2sd xmm0, xmm0
movsd [rsp+38h+var_10], xmm0
jmp short loc_5F91C
loc_5F8A6:
movzx eax, [rsp+38h+var_2]
and eax, 3FFh
cvtsi2sd xmm0, eax
movsd xmm1, cs:qword_10C120
divsd xmm0, xmm1
movsd [rsp+38h+var_10], xmm0
movzx eax, [rsp+38h+var_2]
and eax, 7C00h
sar eax, 0Ah
mov [rsp+38h+var_1C], eax
cmp [rsp+38h+var_1C], 0
jnz short loc_5F8E8
mov [rsp+38h+var_1C], 0FFFFFFF2h
jmp short loc_5F907
loc_5F8E8:
movsd xmm0, cs:qword_10C0B0
addsd xmm0, [rsp+38h+var_10]
movsd [rsp+38h+var_10], xmm0
mov eax, [rsp+38h+var_1C]
sub eax, 0Fh
mov [rsp+38h+var_1C], eax
loc_5F907:
movsd xmm0, [rsp+38h+var_10]
mov edi, [rsp+38h+var_1C]
call _scalbn
movsd [rsp+38h+var_10], xmm0
loc_5F91C:
movzx eax, [rsp+38h+var_2]
and eax, 8000h
movsd xmm0, cs:qword_10C128
movsd xmm1, cs:qword_10C0B0
movsd [rsp+38h+var_38], xmm1
cmp eax, 0
movsd [rsp+38h+var_30], xmm0
jnz short loc_5F951
movsd xmm0, [rsp+38h+var_38]
movsd [rsp+38h+var_30], xmm0
loc_5F951:
movsd xmm0, [rsp+38h+var_30]
movsd [rsp+38h+var_18], xmm0
movsd xmm0, [rsp+38h+var_10]
mulsd xmm0, [rsp+38h+var_18]
add rsp, 38h
retn
| double fromfp16(__int16 a1)
{
double v2; // [rsp+8h] [rbp-30h]
float v3; // [rsp+18h] [rbp-20h]
int v4; // [rsp+1Ch] [rbp-1Ch]
unsigned int v5; // [rsp+1Ch] [rbp-1Ch]
double v6; // [rsp+28h] [rbp-10h]
double v7; // [rsp+28h] [rbp-10h]
if ( (a1 & 0x7C00) == 0x7C00 )
{
v3 = NAN;
if ( (a1 & 0x3FF) == 0 )
v3 = INFINITY;
v6 = v3;
}
else
{
v7 = (double)(a1 & 0x3FF) / 1024.0;
v4 = (a1 & 0x7C00) >> 10;
if ( v4 )
{
v7 = v7 + 1.0;
v5 = v4 - 15;
}
else
{
v5 = -14;
}
v6 = scalbn(v5, v7);
}
v2 = -1.0;
if ( (a1 & 0x8000) == 0 )
v2 = 1.0;
return v6 * v2;
}
| fromfp16:
SUB RSP,0x38
MOV AX,DI
MOV word ptr [RSP + 0x36],AX
MOVZX EAX,word ptr [RSP + 0x36]
AND EAX,0x7c00
CMP EAX,0x7c00
JNZ 0x0015f8a6
MOVZX EAX,word ptr [RSP + 0x36]
AND EAX,0x3ff
MOVSS XMM0,dword ptr [0x0020c250]
MOVSS XMM1,dword ptr [0x0020c254]
MOVSS dword ptr [RSP + 0x14],XMM1
CMP EAX,0x0
MOVSS dword ptr [RSP + 0x18],XMM0
JNZ 0x0015f894
MOVSS XMM0,dword ptr [RSP + 0x14]
MOVSS dword ptr [RSP + 0x18],XMM0
LAB_0015f894:
MOVSS XMM0,dword ptr [RSP + 0x18]
CVTSS2SD XMM0,XMM0
MOVSD qword ptr [RSP + 0x28],XMM0
JMP 0x0015f91c
LAB_0015f8a6:
MOVZX EAX,word ptr [RSP + 0x36]
AND EAX,0x3ff
CVTSI2SD XMM0,EAX
MOVSD XMM1,qword ptr [0x0020c120]
DIVSD XMM0,XMM1
MOVSD qword ptr [RSP + 0x28],XMM0
MOVZX EAX,word ptr [RSP + 0x36]
AND EAX,0x7c00
SAR EAX,0xa
MOV dword ptr [RSP + 0x1c],EAX
CMP dword ptr [RSP + 0x1c],0x0
JNZ 0x0015f8e8
MOV dword ptr [RSP + 0x1c],0xfffffff2
JMP 0x0015f907
LAB_0015f8e8:
MOVSD XMM0,qword ptr [0x0020c0b0]
ADDSD XMM0,qword ptr [RSP + 0x28]
MOVSD qword ptr [RSP + 0x28],XMM0
MOV EAX,dword ptr [RSP + 0x1c]
SUB EAX,0xf
MOV dword ptr [RSP + 0x1c],EAX
LAB_0015f907:
MOVSD XMM0,qword ptr [RSP + 0x28]
MOV EDI,dword ptr [RSP + 0x1c]
CALL 0x0010e660
MOVSD qword ptr [RSP + 0x28],XMM0
LAB_0015f91c:
MOVZX EAX,word ptr [RSP + 0x36]
AND EAX,0x8000
MOVSD XMM0,qword ptr [0x0020c128]
MOVSD XMM1,qword ptr [0x0020c0b0]
MOVSD qword ptr [RSP],XMM1
CMP EAX,0x0
MOVSD qword ptr [RSP + 0x8],XMM0
JNZ 0x0015f951
MOVSD XMM0,qword ptr [RSP]
MOVSD qword ptr [RSP + 0x8],XMM0
LAB_0015f951:
MOVSD XMM0,qword ptr [RSP + 0x8]
MOVSD qword ptr [RSP + 0x20],XMM0
MOVSD XMM0,qword ptr [RSP + 0x28]
MULSD XMM0,qword ptr [RSP + 0x20]
ADD RSP,0x38
RET
|
double fromfp16(ushort param_1)
{
int8 local_30;
int4 local_20;
int4 local_1c;
int8 local_10;
if ((param_1 & 0x7c00) == 0x7c00) {
local_20 = DAT_0020c250;
if ((param_1 & 0x3ff) == 0) {
local_20 = DAT_0020c254;
}
local_10 = (double)local_20;
}
else {
local_10 = (double)(param_1 & 0x3ff) / DAT_0020c120;
local_1c = (int)(param_1 & 0x7c00) >> 10;
if (local_1c == 0) {
local_1c = -0xe;
}
else {
local_10 = DAT_0020c0b0 + local_10;
local_1c = local_1c + -0xf;
}
local_10 = scalbn(local_10,local_1c);
}
local_30 = DAT_0020c128;
if ((param_1 & 0x8000) == 0) {
local_30 = DAT_0020c0b0;
}
return local_10 * local_30;
}
|
|
939 | fromfp16 | bluesky950520[P]quickjs/cutils.h | static inline double fromfp16(uint16_t v) {
double d, s;
int e;
if ((v & 0x7C00) == 0x7C00) {
d = (v & 0x3FF) ? NAN : INFINITY;
} else {
d = (v & 0x3FF) / 1024.;
e = (v & 0x7C00) >> 10;
if (e == 0) {
e = -14;
} else {
d += 1;
e -= 15;
}
d = scalbn(d, e);
}
s = (v & 0x8000) ? -1.0 : 1.0;
return d * s;
} | O3 | c | fromfp16:
pushq %rbx
movl %edi, %ebx
movl $0x7c00, %edx # imm = 0x7C00
movl %edi, %eax
andl %edx, %eax
movl %edi, %ecx
andl $0x3ff, %ecx # imm = 0x3FF
cmpl %edx, %eax
jne 0x3e319
xorl %eax, %eax
testl %ecx, %ecx
sete %al
leaq 0x61cce(%rip), %rcx # 0x9ffe0
movsd (%rcx,%rax,8), %xmm0
jmp 0x3e346
cvtsi2sd %ecx, %xmm0
mulsd 0x61e1b(%rip), %xmm0 # 0xa0140
movl %eax, %edi
shrl $0xa, %edi
addl $-0xf, %edi
testl %eax, %eax
je 0x3e339
addsd 0x61def(%rip), %xmm0 # 0xa0128
movl $0xfffffff2, %eax # imm = 0xFFFFFFF2
cmovel %eax, %edi
callq 0xe660
testw %bx, %bx
jns 0x3e353
xorpd 0x61c9d(%rip), %xmm0 # 0x9fff0
popq %rbx
retq
| fromfp16:
push rbx
mov ebx, edi
mov edx, 7C00h
mov eax, edi
and eax, edx
mov ecx, edi
and ecx, 3FFh
cmp eax, edx
jnz short loc_3E319
xor eax, eax
test ecx, ecx
setz al
lea rcx, dbl_9FFE0
movsd xmm0, qword ptr [rcx+rax*8]
jmp short loc_3E346
loc_3E319:
cvtsi2sd xmm0, ecx
mulsd xmm0, cs:qword_A0140
mov edi, eax
shr edi, 0Ah
add edi, 0FFFFFFF1h
test eax, eax
jz short loc_3E339
addsd xmm0, cs:qword_A0128
loc_3E339:
mov eax, 0FFFFFFF2h
cmovz edi, eax
call _scalbn
loc_3E346:
test bx, bx
jns short loc_3E353
xorpd xmm0, cs:xmmword_9FFF0
loc_3E353:
pop rbx
retn
| long long fromfp16(__int16 a1)
{
unsigned int v1; // eax
int v2; // ecx
double v4; // xmm0_8
long long v5; // rdi
v1 = a1 & 0x7C00;
v2 = a1 & 0x3FF;
if ( v1 == 31744 )
return v2 == 0;
v4 = (double)v2 * 0.0009765625;
v5 = (v1 >> 10) - 15;
if ( v1 )
v4 = v4 + 1.0;
else
v5 = 4294967282LL;
return scalbn(v5, v4);
}
| fromfp16:
PUSH RBX
MOV EBX,EDI
MOV EDX,0x7c00
MOV EAX,EDI
AND EAX,EDX
MOV ECX,EDI
AND ECX,0x3ff
CMP EAX,EDX
JNZ 0x0013e319
XOR EAX,EAX
TEST ECX,ECX
SETZ AL
LEA RCX,[0x19ffe0]
MOVSD XMM0,qword ptr [RCX + RAX*0x8]
JMP 0x0013e346
LAB_0013e319:
CVTSI2SD XMM0,ECX
MULSD XMM0,qword ptr [0x001a0140]
MOV EDI,EAX
SHR EDI,0xa
ADD EDI,-0xf
TEST EAX,EAX
JZ 0x0013e339
ADDSD XMM0,qword ptr [0x001a0128]
LAB_0013e339:
MOV EAX,0xfffffff2
CMOVZ EDI,EAX
CALL 0x0010e660
LAB_0013e346:
TEST BX,BX
JNS 0x0013e353
XORPD XMM0,xmmword ptr [0x0019fff0]
LAB_0013e353:
POP RBX
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double fromfp16(uint param_1)
{
uint uVar1;
int __n;
double dVar2;
uVar1 = param_1 & 0x7c00;
if (uVar1 == 0x7c00) {
dVar2 = *(double *)(&DAT_0019ffe0 + (ulong)((param_1 & 0x3ff) == 0) * 8);
}
else {
dVar2 = (double)(param_1 & 0x3ff) * _DAT_001a0140;
__n = (uVar1 >> 10) - 0xf;
if (uVar1 == 0) {
__n = -0xe;
}
else {
dVar2 = dVar2 + DAT_001a0128;
}
dVar2 = scalbn(dVar2,__n);
}
if ((short)param_1 < 0) {
dVar2 = (double)((ulong)dVar2 ^ _DAT_0019fff0);
}
return dVar2;
}
|
|
940 | lunasvg::SVGLayoutState::SVGLayoutState() | dmazzella[P]pylunasvg/lunasvg/source/svglayoutstate.h | SVGLayoutState() = default; | O0 | c | lunasvg::SVGLayoutState::SVGLayoutState():
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq $0x0, (%rdi)
movq $0x0, 0x8(%rdi)
addq $0x10, %rdi
movq %rdi, -0x30(%rbp)
leaq 0x6b08a(%rip), %rsi # 0x8c14c
callq 0x22ed0
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0x20(%rbp)
leaq 0x6b07a(%rip), %rsi # 0x8c154
callq 0x22ed0
jmp 0x210e1
movq -0x28(%rbp), %rdi
leaq 0x6b060(%rip), %rax # 0x8c14c
movl (%rax), %ecx
movl %ecx, 0x60(%rdi)
movl (%rax), %eax
movl %eax, 0x64(%rdi)
movl $0x3f800000, 0x68(%rdi) # imm = 0x3F800000
movl $0x3f800000, 0x6c(%rdi) # imm = 0x3F800000
movl $0x3f800000, 0x70(%rdi) # imm = 0x3F800000
movl $0x3f800000, 0x74(%rdi) # imm = 0x3F800000
movl $0x40800000, 0x78(%rdi) # imm = 0x40800000
movl $0x41400000, 0x7c(%rdi) # imm = 0x41400000
subq $-0x80, %rdi
callq 0x22f00
movq -0x28(%rbp), %rdi
addq $0x8c, %rdi
movss 0x6af8c(%rip), %xmm0 # 0x8c0c8
xorl %esi, %esi
callq 0x22d90
jmp 0x21145
movq -0x28(%rbp), %rdi
addq $0x94, %rdi
xorps %xmm0, %xmm0
xorl %esi, %esi
callq 0x22d90
jmp 0x2115c
movq -0x28(%rbp), %rdi
addq $0xa0, %rdi
callq 0x22f30
movq -0x28(%rbp), %rdi
movb $0x0, 0xb8(%rdi)
movb $0x0, 0xb9(%rdi)
movb $0x0, 0xba(%rdi)
movb $0x0, 0xbb(%rdi)
movb $0x0, 0xbc(%rdi)
movb $0x0, 0xbd(%rdi)
movb $0x0, 0xbe(%rdi)
movb $0x0, 0xbf(%rdi)
movb $0x0, 0xc0(%rdi)
movb $0x0, 0xc1(%rdi)
movb $0x0, 0xc2(%rdi)
movb $0x0, 0xc3(%rdi)
movb $0x0, 0xc4(%rdi)
movb $0x0, 0xc5(%rdi)
movb $0x0, 0xc6(%rdi)
addq $0xc8, %rdi
callq 0xb520
movq -0x28(%rbp), %rdi
addq $0xe8, %rdi
callq 0xb520
movq -0x28(%rbp), %rdi
addq $0x108, %rdi # imm = 0x108
callq 0xb520
movq -0x28(%rbp), %rdi
addq $0x128, %rdi # imm = 0x128
callq 0xb520
movq -0x28(%rbp), %rdi
addq $0x148, %rdi # imm = 0x148
callq 0xb520
movq -0x28(%rbp), %rdi
addq $0x168, %rdi # imm = 0x168
callq 0xb520
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x2125e
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x22630
movq -0x30(%rbp), %rdi
callq 0x22630
movq -0x10(%rbp), %rdi
callq 0xb6c0
| _ZN7lunasvg14SVGLayoutStateC2Ev:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]
mov [rbp+var_28], rdi
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
add rdi, 10h; this
mov [rbp+var_30], rdi
lea rsi, _ZN7lunasvg5Color5BlackE; lunasvg::Color *
call _ZN7lunasvg5PaintC2ERKNS_5ColorE; lunasvg::Paint::Paint(lunasvg::Color const&)
mov rdi, [rbp+var_28]
add rdi, 38h ; '8'; this
mov [rbp+var_20], rdi
lea rsi, _ZN7lunasvg5Color11TransparentE; lunasvg::Color *
call _ZN7lunasvg5PaintC2ERKNS_5ColorE; lunasvg::Paint::Paint(lunasvg::Color const&)
jmp short $+2
loc_210E1:
mov rdi, [rbp+var_28]
lea rax, _ZN7lunasvg5Color5BlackE; lunasvg::Color::Black
mov ecx, [rax]
mov [rdi+60h], ecx
mov eax, [rax]
mov [rdi+64h], eax
mov dword ptr [rdi+68h], 3F800000h
mov dword ptr [rdi+6Ch], 3F800000h
mov dword ptr [rdi+70h], 3F800000h
mov dword ptr [rdi+74h], 3F800000h
mov dword ptr [rdi+78h], 40800000h
mov dword ptr [rdi+7Ch], 41400000h
sub rdi, 0FFFFFFFFFFFFFF80h; this
call _ZN7lunasvg13BaselineShiftC2Ev; lunasvg::BaselineShift::BaselineShift(void)
mov rdi, [rbp+var_28]
add rdi, 8Ch
movss xmm0, cs:flt_8C0C8
xor esi, esi
call _ZN7lunasvg6LengthC2EfNS_11LengthUnitsE; lunasvg::Length::Length(float,lunasvg::LengthUnits)
jmp short $+2
loc_21145:
mov rdi, [rbp+var_28]
add rdi, 94h
xorps xmm0, xmm0
xor esi, esi
call _ZN7lunasvg6LengthC2EfNS_11LengthUnitsE; lunasvg::Length::Length(float,lunasvg::LengthUnits)
jmp short $+2
loc_2115C:
mov rdi, [rbp+var_28]
add rdi, 0A0h
call _ZNSt6vectorIN7lunasvg6LengthESaIS1_EEC2Ev; std::vector<lunasvg::Length>::vector(void)
mov rdi, [rbp+var_28]
mov byte ptr [rdi+0B8h], 0
mov byte ptr [rdi+0B9h], 0
mov byte ptr [rdi+0BAh], 0
mov byte ptr [rdi+0BBh], 0
mov byte ptr [rdi+0BCh], 0
mov byte ptr [rdi+0BDh], 0
mov byte ptr [rdi+0BEh], 0
mov byte ptr [rdi+0BFh], 0
mov byte ptr [rdi+0C0h], 0
mov byte ptr [rdi+0C1h], 0
mov byte ptr [rdi+0C2h], 0
mov byte ptr [rdi+0C3h], 0
mov byte ptr [rdi+0C4h], 0
mov byte ptr [rdi+0C5h], 0
mov byte ptr [rdi+0C6h], 0
add rdi, 0C8h
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev; std::string::basic_string(void)
mov rdi, [rbp+var_28]
add rdi, 0E8h
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev; std::string::basic_string(void)
mov rdi, [rbp+var_28]
add rdi, 108h
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev; std::string::basic_string(void)
mov rdi, [rbp+var_28]
add rdi, 128h
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev; std::string::basic_string(void)
mov rdi, [rbp+var_28]
add rdi, 148h
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev; std::string::basic_string(void)
mov rdi, [rbp+var_28]
add rdi, 168h
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev; std::string::basic_string(void)
add rsp, 30h
pop rbp
retn
mov rcx, rax
mov eax, edx
mov [rbp+var_10], rcx
mov [rbp+var_14], eax
jmp short loc_2125E
mov rdi, [rbp+var_20]; this
mov rcx, rax
mov eax, edx
mov [rbp+var_10], rcx
mov [rbp+var_14], eax
call _ZN7lunasvg5PaintD2Ev; lunasvg::Paint::~Paint()
loc_2125E:
mov rdi, [rbp+var_30]; this
call _ZN7lunasvg5PaintD2Ev; lunasvg::Paint::~Paint()
mov rdi, [rbp+var_10]
call __Unwind_Resume
| long long lunasvg::SVGLayoutState::SVGLayoutState(lunasvg::SVGLayoutState *this)
{
*(_QWORD *)this = 0LL;
*((_QWORD *)this + 1) = 0LL;
lunasvg::Paint::Paint((lunasvg::SVGLayoutState *)((char *)this + 16), (const lunasvg::Color *)&lunasvg::Color::Black);
lunasvg::Paint::Paint(
(lunasvg::SVGLayoutState *)((char *)this + 56),
(const lunasvg::Color *)&lunasvg::Color::Transparent);
*((_DWORD *)this + 24) = lunasvg::Color::Black;
*((_DWORD *)this + 25) = lunasvg::Color::Black;
*((_DWORD *)this + 26) = 1065353216;
*((_DWORD *)this + 27) = 1065353216;
*((_DWORD *)this + 28) = 1065353216;
*((_DWORD *)this + 29) = 1065353216;
*((_DWORD *)this + 30) = 1082130432;
*((_DWORD *)this + 31) = 1094713344;
lunasvg::BaselineShift::BaselineShift((lunasvg::SVGLayoutState *)((char *)this + 128));
lunasvg::Length::Length((char *)this + 140, 0LL, 1.0);
lunasvg::Length::Length((char *)this + 148, 0LL, 0.0);
std::vector<lunasvg::Length>::vector((char *)this + 160);
*((_BYTE *)this + 184) = 0;
*((_BYTE *)this + 185) = 0;
*((_BYTE *)this + 186) = 0;
*((_BYTE *)this + 187) = 0;
*((_BYTE *)this + 188) = 0;
*((_BYTE *)this + 189) = 0;
*((_BYTE *)this + 190) = 0;
*((_BYTE *)this + 191) = 0;
*((_BYTE *)this + 192) = 0;
*((_BYTE *)this + 193) = 0;
*((_BYTE *)this + 194) = 0;
*((_BYTE *)this + 195) = 0;
*((_BYTE *)this + 196) = 0;
*((_BYTE *)this + 197) = 0;
*((_BYTE *)this + 198) = 0;
std::string::basic_string((char *)this + 200);
std::string::basic_string((char *)this + 232);
std::string::basic_string((char *)this + 264);
std::string::basic_string((char *)this + 296);
std::string::basic_string((char *)this + 328);
return std::string::basic_string((char *)this + 360);
}
| SVGLayoutState:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
ADD RDI,0x10
MOV qword ptr [RBP + -0x30],RDI
LEA RSI,[0x18c14c]
CALL 0x00122ed0
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x38
MOV qword ptr [RBP + -0x20],RDI
LAB_001210d3:
LEA RSI,[0x18c154]
CALL 0x00122ed0
JMP 0x001210e1
LAB_001210e1:
MOV RDI,qword ptr [RBP + -0x28]
LEA RAX,[0x18c14c]
MOV ECX,dword ptr [RAX]
MOV dword ptr [RDI + 0x60],ECX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDI + 0x64],EAX
MOV dword ptr [RDI + 0x68],0x3f800000
MOV dword ptr [RDI + 0x6c],0x3f800000
MOV dword ptr [RDI + 0x70],0x3f800000
MOV dword ptr [RDI + 0x74],0x3f800000
MOV dword ptr [RDI + 0x78],0x40800000
MOV dword ptr [RDI + 0x7c],0x41400000
SUB RDI,-0x80
CALL 0x00122f00
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x8c
LAB_00121134:
MOVSS XMM0,dword ptr [0x0018c0c8]
XOR ESI,ESI
CALL 0x00122d90
JMP 0x00121145
LAB_00121145:
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x94
XORPS XMM0,XMM0
XOR ESI,ESI
CALL 0x00122d90
LAB_0012115a:
JMP 0x0012115c
LAB_0012115c:
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0xa0
CALL 0x00122f30
MOV RDI,qword ptr [RBP + -0x28]
MOV byte ptr [RDI + 0xb8],0x0
MOV byte ptr [RDI + 0xb9],0x0
MOV byte ptr [RDI + 0xba],0x0
MOV byte ptr [RDI + 0xbb],0x0
MOV byte ptr [RDI + 0xbc],0x0
MOV byte ptr [RDI + 0xbd],0x0
MOV byte ptr [RDI + 0xbe],0x0
MOV byte ptr [RDI + 0xbf],0x0
MOV byte ptr [RDI + 0xc0],0x0
MOV byte ptr [RDI + 0xc1],0x0
MOV byte ptr [RDI + 0xc2],0x0
MOV byte ptr [RDI + 0xc3],0x0
MOV byte ptr [RDI + 0xc4],0x0
MOV byte ptr [RDI + 0xc5],0x0
MOV byte ptr [RDI + 0xc6],0x0
ADD RDI,0xc8
CALL 0x0010b520
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0xe8
CALL 0x0010b520
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x108
CALL 0x0010b520
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x128
CALL 0x0010b520
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x148
CALL 0x0010b520
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x168
CALL 0x0010b520
ADD RSP,0x30
POP RBP
RET
| ||
941 | lunasvg::SVGLayoutState::SVGLayoutState() | dmazzella[P]pylunasvg/lunasvg/source/svglayoutstate.h | SVGLayoutState() = default; | O3 | c | lunasvg::SVGLayoutState::SVGLayoutState():
pushq %rbx
movq %rdi, %rbx
movq 0x168(%rdi), %rdi
leaq 0x178(%rbx), %rax
cmpq %rax, %rdi
je 0x128d4
movq (%rax), %rsi
incq %rsi
callq 0xa2f0
movq 0x148(%rbx), %rdi
leaq 0x158(%rbx), %rax
cmpq %rax, %rdi
je 0x128f2
movq (%rax), %rsi
incq %rsi
callq 0xa2f0
movq 0x128(%rbx), %rdi
leaq 0x138(%rbx), %rax
cmpq %rax, %rdi
je 0x12910
movq (%rax), %rsi
incq %rsi
callq 0xa2f0
movq 0x108(%rbx), %rdi
leaq 0x118(%rbx), %rax
cmpq %rax, %rdi
je 0x1292e
movq (%rax), %rsi
incq %rsi
callq 0xa2f0
movq 0xe8(%rbx), %rdi
leaq 0xf8(%rbx), %rax
cmpq %rax, %rdi
je 0x1294c
movq (%rax), %rsi
incq %rsi
callq 0xa2f0
movq 0xc8(%rbx), %rdi
leaq 0xd8(%rbx), %rax
cmpq %rax, %rdi
je 0x1296a
movq (%rax), %rsi
incq %rsi
callq 0xa2f0
movq 0xa0(%rbx), %rdi
testq %rdi, %rdi
je 0x12985
movq 0xb0(%rbx), %rsi
subq %rdi, %rsi
callq 0xa2f0
movq 0x38(%rbx), %rdi
leaq 0x48(%rbx), %rax
cmpq %rax, %rdi
je 0x1299d
movq (%rax), %rsi
incq %rsi
callq 0xa2f0
movq 0x10(%rbx), %rdi
addq $0x20, %rbx
cmpq %rbx, %rdi
je 0x129b6
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0xa2f0
popq %rbx
retq
| _ZN7lunasvg14SVGLayoutStateD2Ev:
push rbx
mov rbx, rdi
mov rdi, [rdi+168h]; void *
lea rax, [rbx+178h]
cmp rdi, rax
jz short loc_128D4
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_128D4:
mov rdi, [rbx+148h]; void *
lea rax, [rbx+158h]
cmp rdi, rax
jz short loc_128F2
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_128F2:
mov rdi, [rbx+128h]; void *
lea rax, [rbx+138h]
cmp rdi, rax
jz short loc_12910
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_12910:
mov rdi, [rbx+108h]; void *
lea rax, [rbx+118h]
cmp rdi, rax
jz short loc_1292E
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1292E:
mov rdi, [rbx+0E8h]; void *
lea rax, [rbx+0F8h]
cmp rdi, rax
jz short loc_1294C
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1294C:
mov rdi, [rbx+0C8h]; void *
lea rax, [rbx+0D8h]
cmp rdi, rax
jz short loc_1296A
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1296A:
mov rdi, [rbx+0A0h]; void *
test rdi, rdi
jz short loc_12985
mov rsi, [rbx+0B0h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_12985:
mov rdi, [rbx+38h]; void *
lea rax, [rbx+48h]
cmp rdi, rax
jz short loc_1299D
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1299D:
mov rdi, [rbx+10h]; void *
add rbx, 20h ; ' '
cmp rdi, rbx
jz short loc_129B6
mov rsi, [rbx]
inc rsi; unsigned __int64
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
loc_129B6:
pop rbx
retn
| void lunasvg::SVGLayoutState::~SVGLayoutState(lunasvg::SVGLayoutState *this)
{
char *v2; // rdi
char *v3; // rdi
char *v4; // rdi
char *v5; // rdi
char *v6; // rdi
char *v7; // rdi
void *v8; // rdi
char *v9; // rdi
_QWORD *v10; // rdi
_QWORD *v11; // rbx
v2 = (char *)*((_QWORD *)this + 45);
if ( v2 != (char *)this + 376 )
operator delete(v2, *((_QWORD *)this + 47) + 1LL);
v3 = (char *)*((_QWORD *)this + 41);
if ( v3 != (char *)this + 344 )
operator delete(v3, *((_QWORD *)this + 43) + 1LL);
v4 = (char *)*((_QWORD *)this + 37);
if ( v4 != (char *)this + 312 )
operator delete(v4, *((_QWORD *)this + 39) + 1LL);
v5 = (char *)*((_QWORD *)this + 33);
if ( v5 != (char *)this + 280 )
operator delete(v5, *((_QWORD *)this + 35) + 1LL);
v6 = (char *)*((_QWORD *)this + 29);
if ( v6 != (char *)this + 248 )
operator delete(v6, *((_QWORD *)this + 31) + 1LL);
v7 = (char *)*((_QWORD *)this + 25);
if ( v7 != (char *)this + 216 )
operator delete(v7, *((_QWORD *)this + 27) + 1LL);
v8 = (void *)*((_QWORD *)this + 20);
if ( v8 )
operator delete(v8, *((_QWORD *)this + 22) - (_QWORD)v8);
v9 = (char *)*((_QWORD *)this + 7);
if ( v9 != (char *)this + 72 )
operator delete(v9, *((_QWORD *)this + 9) + 1LL);
v10 = (_QWORD *)*((_QWORD *)this + 2);
v11 = (_QWORD *)((char *)this + 32);
if ( v10 != v11 )
operator delete(v10, *v11 + 1LL);
}
| ~SVGLayoutState:
PUSH RBX
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x168]
LEA RAX,[RBX + 0x178]
CMP RDI,RAX
JZ 0x001128d4
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x0010a2f0
LAB_001128d4:
MOV RDI,qword ptr [RBX + 0x148]
LEA RAX,[RBX + 0x158]
CMP RDI,RAX
JZ 0x001128f2
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x0010a2f0
LAB_001128f2:
MOV RDI,qword ptr [RBX + 0x128]
LEA RAX,[RBX + 0x138]
CMP RDI,RAX
JZ 0x00112910
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x0010a2f0
LAB_00112910:
MOV RDI,qword ptr [RBX + 0x108]
LEA RAX,[RBX + 0x118]
CMP RDI,RAX
JZ 0x0011292e
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x0010a2f0
LAB_0011292e:
MOV RDI,qword ptr [RBX + 0xe8]
LEA RAX,[RBX + 0xf8]
CMP RDI,RAX
JZ 0x0011294c
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x0010a2f0
LAB_0011294c:
MOV RDI,qword ptr [RBX + 0xc8]
LEA RAX,[RBX + 0xd8]
CMP RDI,RAX
JZ 0x0011296a
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x0010a2f0
LAB_0011296a:
MOV RDI,qword ptr [RBX + 0xa0]
TEST RDI,RDI
JZ 0x00112985
MOV RSI,qword ptr [RBX + 0xb0]
SUB RSI,RDI
CALL 0x0010a2f0
LAB_00112985:
MOV RDI,qword ptr [RBX + 0x38]
LEA RAX,[RBX + 0x48]
CMP RDI,RAX
JZ 0x0011299d
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x0010a2f0
LAB_0011299d:
MOV RDI,qword ptr [RBX + 0x10]
ADD RBX,0x20
CMP RDI,RBX
JZ 0x001129b6
MOV RSI,qword ptr [RBX]
INC RSI
POP RBX
JMP 0x0010a2f0
LAB_001129b6:
POP RBX
RET
|
/* lunasvg::SVGLayoutState::~SVGLayoutState() */
void __thiscall lunasvg::SVGLayoutState::~SVGLayoutState(SVGLayoutState *this)
{
void *pvVar1;
if (*(SVGLayoutState **)(this + 0x168) != this + 0x178) {
operator_delete(*(SVGLayoutState **)(this + 0x168),*(long *)(this + 0x178) + 1);
}
if (*(SVGLayoutState **)(this + 0x148) != this + 0x158) {
operator_delete(*(SVGLayoutState **)(this + 0x148),*(long *)(this + 0x158) + 1);
}
if (*(SVGLayoutState **)(this + 0x128) != this + 0x138) {
operator_delete(*(SVGLayoutState **)(this + 0x128),*(long *)(this + 0x138) + 1);
}
if (*(SVGLayoutState **)(this + 0x108) != this + 0x118) {
operator_delete(*(SVGLayoutState **)(this + 0x108),*(long *)(this + 0x118) + 1);
}
if (*(SVGLayoutState **)(this + 0xe8) != this + 0xf8) {
operator_delete(*(SVGLayoutState **)(this + 0xe8),*(long *)(this + 0xf8) + 1);
}
if (*(SVGLayoutState **)(this + 200) != this + 0xd8) {
operator_delete(*(SVGLayoutState **)(this + 200),*(long *)(this + 0xd8) + 1);
}
pvVar1 = *(void **)(this + 0xa0);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0xb0) - (long)pvVar1);
}
if (*(SVGLayoutState **)(this + 0x38) != this + 0x48) {
operator_delete(*(SVGLayoutState **)(this + 0x38),*(long *)(this + 0x48) + 1);
}
if (*(SVGLayoutState **)(this + 0x10) != this + 0x20) {
operator_delete(*(SVGLayoutState **)(this + 0x10),*(long *)(this + 0x20) + 1);
return;
}
return;
}
|
|
942 | MainWindow::qt_static_metacall(QObject*, QMetaObject::Call, int, void**) | MarsToPluto[P]llmstudio/build_O2/llmstudio_autogen/UVLADIE3JM/moc_mainwindow.cpp | void MainWindow::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
auto *_t = static_cast<MainWindow *>(_o);
(void)_t;
switch (_id) {
case 0: _t->onChatSelectionChanged(); break;
default: ;
}
}
(void)_a;
} | O2 | cpp | MainWindow::qt_static_metacall(QObject*, QMetaObject::Call, int, void**):
orl %edx, %esi
je 0x783a
retq
nop
| _ZN10MainWindow18qt_static_metacallEP7QObjectN11QMetaObject4CallEiPPv:
or esi, edx
jz _ZN10MainWindow22onChatSelectionChangedEv; MainWindow::onChatSelectionChanged(void)
retn
| long long MainWindow::qt_static_metacall(MainWindow *a1, int a2, int a3)
{
long long result; // rax
if ( !(a3 | a2) )
return MainWindow::onChatSelectionChanged(a1);
return result;
}
| qt_static_metacall:
OR ESI,EDX
JZ 0x0010783a
RET
|
/* MainWindow::qt_static_metacall(QObject*, QMetaObject::Call, int, void**) */
void MainWindow::qt_static_metacall(long param_1,int param_2,int param_3)
{
QString *pQVar1;
long lVar2;
QArrayDataPointer<char16_t> aQStack_60 [24];
QString aQStack_48 [24];
QArrayDataPointer<char16_t> aQStack_30 [24];
if (param_2 != 0 || param_3 != 0) {
return;
}
lVar2 = QListWidget::currentItem();
pQVar1 = *(QString **)(param_1 + 0xe8);
if (lVar2 != 0) {
QString::QString(aQStack_48,"Chat history for: %1\n\n(Load actual content here)");
QListWidgetItem::text();
QString::arg(aQStack_30,aQStack_48,aQStack_60,0,0x20);
QTextEdit::setPlainText(pQVar1);
QArrayDataPointer<char16_t>::~QArrayDataPointer(aQStack_30);
QArrayDataPointer<char16_t>::~QArrayDataPointer(aQStack_60);
QArrayDataPointer<char16_t>::~QArrayDataPointer((QArrayDataPointer<char16_t> *)aQStack_48);
QWidget::setFocus(*(QWidget **)(param_1 + 0x100));
return;
}
QTextEdit::clear();
return;
}
|
|
943 | mi_ft_parse | eloqsql/storage/myisam/ft_update.c | uint _mi_ft_parse(TREE *parsed, MI_INFO *info, uint keynr, const uchar *record,
MYSQL_FTPARSER_PARAM *param, MEM_ROOT *mem_root)
{
FT_SEG_ITERATOR ftsi;
struct st_mysql_ftparser *parser;
DBUG_ENTER("_mi_ft_parse");
_mi_ft_segiterator_init(info, keynr, record, &ftsi);
ft_parse_init(parsed, info->s->keyinfo[keynr].seg->charset);
parser= info->s->keyinfo[keynr].parser;
while (_mi_ft_segiterator(&ftsi))
{
if (ftsi.pos)
if (ft_parse(parsed, (uchar *)ftsi.pos, ftsi.len, parser, param, mem_root))
DBUG_RETURN(1);
}
DBUG_RETURN(0);
} | O3 | c | mi_ft_parse:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rsi, -0x30(%rbp)
movq %rdi, %r15
movq (%rsi), %rax
movq 0x218(%rax), %rax
movl %edx, %edx
imulq $0x70, %rdx, %r13
movzwl 0x8(%rax,%r13), %edx
leaq -0x50(%rbp), %r12
movl %edx, (%r12)
movq 0x28(%rax,%r13), %rax
movq %rax, 0x8(%r12)
movq %rcx, 0x10(%r12)
movq $0x0, 0x18(%r12)
movl $0x0, 0x4(%r12)
movq (%rax), %rsi
callq 0x738da
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq 0x218(%rax), %rax
movq 0x38(%rax,%r13), %r13
movq %r12, %rdi
callq 0x73cae
xorl %ecx, %ecx
testl %eax, %eax
je 0x73e22
movq -0x38(%rbp), %rsi
testq %rsi, %rsi
je 0x73e0d
movl -0x4c(%rbp), %edx
movq %r15, %rdi
movq %r13, %rcx
movq %r14, %r8
movq %rbx, %r9
callq 0x7392a
testl %eax, %eax
jne 0x73e1d
movq %r12, %rdi
callq 0x73cae
testl %eax, %eax
jne 0x73dec
xorl %ecx, %ecx
jmp 0x73e22
movl $0x1, %ecx
movl %ecx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _mi_ft_parse:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rbx, r9
mov r14, r8
mov [rbp+var_30], rsi
mov r15, rdi
mov rax, [rsi]
mov rax, [rax+218h]
mov edx, edx
imul r13, rdx, 70h ; 'p'
movzx edx, word ptr [rax+r13+8]
lea r12, [rbp+var_50]
mov [r12], edx
mov rax, [rax+r13+28h]
mov [r12+8], rax
mov [r12+10h], rcx
mov qword ptr [r12+18h], 0
mov dword ptr [r12+4], 0
mov rsi, [rax]
call ft_parse_init
mov rax, [rbp+var_30]
mov rax, [rax]
mov rax, [rax+218h]
mov r13, [rax+r13+38h]
mov rdi, r12
call _mi_ft_segiterator
xor ecx, ecx
test eax, eax
jz short loc_73E22
loc_73DEC:
mov rsi, [rbp+var_38]
test rsi, rsi
jz short loc_73E0D
mov edx, [rbp+var_4C]
mov rdi, r15
mov rcx, r13
mov r8, r14
mov r9, rbx
call ft_parse
test eax, eax
jnz short loc_73E1D
loc_73E0D:
mov rdi, r12
call _mi_ft_segiterator
test eax, eax
jnz short loc_73DEC
xor ecx, ecx
jmp short loc_73E22
loc_73E1D:
mov ecx, 1
loc_73E22:
mov eax, ecx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long mi_ft_parse(_QWORD *a1, long long a2, unsigned int a3, long long a4, long long a5, long long a6)
{
long long v8; // rax
long long v9; // r13
long long v10; // r13
int v11; // eax
unsigned int v12; // ecx
int v14; // [rsp+0h] [rbp-50h] BYREF
int v15; // [rsp+4h] [rbp-4Ch]
long long *v16; // [rsp+8h] [rbp-48h]
long long v17; // [rsp+10h] [rbp-40h]
long long v18; // [rsp+18h] [rbp-38h]
long long v19; // [rsp+20h] [rbp-30h]
v19 = a2;
v8 = *(_QWORD *)(*(_QWORD *)a2 + 536LL);
v9 = 112LL * a3;
v14 = *(unsigned __int16 *)(v8 + v9 + 8);
v16 = *(long long **)(v8 + v9 + 40);
v17 = a4;
v18 = 0LL;
v15 = 0;
ft_parse_init(a1, *v16);
v10 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)a2 + 536LL) + v9 + 56);
v11 = mi_ft_segiterator((long long)&v14);
v12 = 0;
if ( v11 )
{
while ( !v18 || !(unsigned int)ft_parse((long long)a1, v18, v15, v10, a5, a6) )
{
if ( !(unsigned int)mi_ft_segiterator((long long)&v14) )
return 0;
}
return 1;
}
return v12;
}
| _mi_ft_parse:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RBX,R9
MOV R14,R8
MOV qword ptr [RBP + -0x30],RSI
MOV R15,RDI
MOV RAX,qword ptr [RSI]
MOV RAX,qword ptr [RAX + 0x218]
MOV EDX,EDX
IMUL R13,RDX,0x70
MOVZX EDX,word ptr [RAX + R13*0x1 + 0x8]
LEA R12,[RBP + -0x50]
MOV dword ptr [R12],EDX
MOV RAX,qword ptr [RAX + R13*0x1 + 0x28]
MOV qword ptr [R12 + 0x8],RAX
MOV qword ptr [R12 + 0x10],RCX
MOV qword ptr [R12 + 0x18],0x0
MOV dword ptr [R12 + 0x4],0x0
MOV RSI,qword ptr [RAX]
CALL 0x001738da
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x218]
MOV R13,qword ptr [RAX + R13*0x1 + 0x38]
MOV RDI,R12
CALL 0x00173cae
XOR ECX,ECX
TEST EAX,EAX
JZ 0x00173e22
LAB_00173dec:
MOV RSI,qword ptr [RBP + -0x38]
TEST RSI,RSI
JZ 0x00173e0d
MOV EDX,dword ptr [RBP + -0x4c]
MOV RDI,R15
MOV RCX,R13
MOV R8,R14
MOV R9,RBX
CALL 0x0017392a
TEST EAX,EAX
JNZ 0x00173e1d
LAB_00173e0d:
MOV RDI,R12
CALL 0x00173cae
TEST EAX,EAX
JNZ 0x00173dec
XOR ECX,ECX
JMP 0x00173e22
LAB_00173e1d:
MOV ECX,0x1
LAB_00173e22:
MOV EAX,ECX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8
_mi_ft_parse(int8 param_1,long *param_2,uint param_3,int8 param_4,int8 param_5,
int8 param_6)
{
int8 uVar1;
int iVar2;
long lVar3;
uint local_58;
int4 local_54;
int8 *local_50;
int8 local_48;
long local_40;
long *local_38;
lVar3 = (ulong)param_3 * 0x70;
local_58 = (uint)*(ushort *)(*(long *)(*param_2 + 0x218) + 8 + lVar3);
local_50 = *(int8 **)(*(long *)(*param_2 + 0x218) + 0x28 + lVar3);
local_40 = 0;
local_54 = 0;
local_48 = param_4;
local_38 = param_2;
ft_parse_init(param_1,*local_50);
uVar1 = *(int8 *)(*(long *)(*local_38 + 0x218) + 0x38 + lVar3);
iVar2 = _mi_ft_segiterator(&local_58);
while( true ) {
if (iVar2 == 0) {
return 0;
}
if ((local_40 != 0) &&
(iVar2 = ft_parse(param_1,local_40,local_54,uVar1,param_5,param_6), iVar2 != 0)) break;
iVar2 = _mi_ft_segiterator(&local_58);
}
return 1;
}
|
|
944 | my_wildcmp_8bit_impl | eloqsql/strings/ctype-simple.c | static
int my_wildcmp_8bit_impl(CHARSET_INFO *cs,
const char *str,const char *str_end,
const char *wildstr,const char *wildend,
int escape, int w_one, int w_many, int recurse_level)
{
int result= -1; /* Not found, using wildcards */
if (my_string_stack_guard && my_string_stack_guard(recurse_level))
return 1;
while (wildstr != wildend)
{
while (*wildstr != w_many && *wildstr != w_one)
{
if (*wildstr == escape && wildstr+1 != wildend)
wildstr++;
if (str == str_end || likeconv(cs,*wildstr++) != likeconv(cs,*str++))
return(1); /* No match */
if (wildstr == wildend)
return(str != str_end); /* Match if both are at end */
result=1; /* Found an anchor char */
}
if (*wildstr == w_one)
{
do
{
if (str == str_end) /* Skip one char if possible */
return(result);
INC_PTR(cs,str,str_end);
} while (++wildstr < wildend && *wildstr == w_one);
if (wildstr == wildend)
break;
}
if (*wildstr == w_many)
{ /* Found w_many */
uchar cmp;
wildstr++;
/* Remove any '%' and '_' from the wild search string */
for (; wildstr != wildend ; wildstr++)
{
if (*wildstr == w_many)
continue;
if (*wildstr == w_one)
{
if (str == str_end)
return(-1);
INC_PTR(cs,str,str_end);
continue;
}
break; /* Not a wild character */
}
if (wildstr == wildend)
return(0); /* Ok if w_many is last */
if (str == str_end)
return(-1);
if ((cmp= *wildstr) == escape && wildstr+1 != wildend)
cmp= *++wildstr;
INC_PTR(cs,wildstr,wildend); /* This is compared trough cmp */
cmp=likeconv(cs,cmp);
do
{
/*
Find the next character in the subject string equal to 'cmp', then
check recursively my_wildcmp_8bit_impl() for the pattern remainder.
*/
while (str != str_end && (uchar) likeconv(cs,*str) != cmp)
str++;
if (str++ == str_end)
return(-1); /* 'cmp' was not found in the subject string */
{
int tmp=my_wildcmp_8bit_impl(cs,str,str_end,
wildstr,wildend,escape,w_one,
w_many, recurse_level+1);
if (tmp <= 0)
return(tmp);
}
/*
The recursion call did not match. But it returned 1, which means
the pattern remainder has some non-special characters.
Continue, there is a chance that we'll find another 'cmp'
at a different position in the subject string.
*/
} while (str != str_end);
return(-1);
}
}
return(str != str_end ? 1 : 0);
} | O0 | c | my_wildcmp_8bit_impl:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
movl $0xffffffff, -0x38(%rbp) # imm = 0xFFFFFFFF
leaq 0x39fb31(%rip), %rax # 0x418fe8
cmpq $0x0, (%rax)
je 0x794dd
leaq 0x39fb24(%rip), %rax # 0x418fe8
movq (%rax), %rax
movl 0x20(%rbp), %edi
callq *%rax
cmpl $0x0, %eax
je 0x794dd
movl $0x1, -0x4(%rbp)
jmp 0x7980a
jmp 0x794df
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0x797f2
jmp 0x794ef
movq -0x28(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl 0x18(%rbp), %ecx
movb %al, -0x41(%rbp)
je 0x79510
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl 0x10(%rbp), %eax
setne %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x7951c
jmp 0x795c6
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl -0x34(%rbp), %eax
jne 0x79542
movq -0x28(%rbp), %rax
addq $0x1, %rax
cmpq -0x30(%rbp), %rax
je 0x79542
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x7958c
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x28(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movzbl (%rcx), %ecx
movzbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movq 0x58(%rcx), %rcx
movq -0x18(%rbp), %rdx
movq %rdx, %rsi
addq $0x1, %rsi
movq %rsi, -0x18(%rbp)
movzbl (%rdx), %edx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x79598
movl $0x1, -0x4(%rbp)
jmp 0x7980a
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jne 0x795ba
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x7980a
movl $0x1, -0x38(%rbp)
jmp 0x794ef
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl 0x10(%rbp), %eax
jne 0x79634
jmp 0x795d4
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x795e9
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7980a
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x30(%rbp), %rcx
movb %al, -0x42(%rbp)
jae 0x7961c
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl 0x10(%rbp), %eax
sete %al
movb %al, -0x42(%rbp)
movb -0x42(%rbp), %al
testb $0x1, %al
jne 0x795d4
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jne 0x79632
jmp 0x797f2
jmp 0x79634
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl 0x18(%rbp), %eax
jne 0x797ed
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0x796a8
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl 0x18(%rbp), %eax
jne 0x79668
jmp 0x7969a
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl 0x10(%rbp), %eax
jne 0x79698
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x7968a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7980a
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x7969a
jmp 0x796a8
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x79650
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jne 0x796be
movl $0x0, -0x4(%rbp)
jmp 0x7980a
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x796d4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7980a
movq -0x28(%rbp), %rax
movb (%rax), %al
movb %al, -0x39(%rbp)
movzbl %al, %eax
cmpl -0x34(%rbp), %eax
jne 0x79708
movq -0x28(%rbp), %rax
addq $0x1, %rax
cmpq -0x30(%rbp), %rax
je 0x79708
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb 0x1(%rax), %al
movb %al, -0x39(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movzbl -0x39(%rbp), %ecx
movb (%rax,%rcx), %al
movb %al, -0x39(%rbp)
jmp 0x79728
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x43(%rbp)
je 0x79756
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x18(%rbp), %rcx
movzbl (%rcx), %ecx
movzbl (%rax,%rcx), %eax
movzbl -0x39(%rbp), %ecx
cmpl %ecx, %eax
setne %al
movb %al, -0x43(%rbp)
movb -0x43(%rbp), %al
testb $0x1, %al
jne 0x7975f
jmp 0x7976d
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x79728
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
cmpq -0x20(%rbp), %rax
jne 0x7978b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7980a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movl -0x34(%rbp), %r9d
movl 0x10(%rbp), %r11d
movl 0x18(%rbp), %r10d
movl 0x20(%rbp), %eax
addl $0x1, %eax
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movl %eax, 0x10(%rsp)
callq 0x79480
movl %eax, -0x40(%rbp)
cmpl $0x0, -0x40(%rbp)
jg 0x797d4
movl -0x40(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7980a
jmp 0x797d6
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x79726
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7980a
jmp 0x794df
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rsi
xorl %eax, %eax
movl $0x1, %ecx
cmpq %rsi, %rdx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_wildcmp_8bit_impl:
push rbp
mov rbp, rsp
sub rsp, 60h
mov eax, [rbp+arg_10]
mov eax, [rbp+arg_8]
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_34], r9d
mov [rbp+var_38], 0FFFFFFFFh
lea rax, my_string_stack_guard
cmp qword ptr [rax], 0
jz short loc_794DD
lea rax, my_string_stack_guard
mov rax, [rax]
mov edi, [rbp+arg_10]
call rax
cmp eax, 0
jz short loc_794DD
mov [rbp+var_4], 1
jmp loc_7980A
loc_794DD:
jmp short $+2
loc_794DF:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_30]
jz loc_797F2
jmp short $+2
loc_794EF:
mov rax, [rbp+var_28]
movsx ecx, byte ptr [rax]
xor eax, eax
cmp ecx, [rbp+arg_8]
mov [rbp+var_41], al
jz short loc_79510
mov rax, [rbp+var_28]
movsx eax, byte ptr [rax]
cmp eax, [rbp+arg_0]
setnz al
mov [rbp+var_41], al
loc_79510:
mov al, [rbp+var_41]
test al, 1
jnz short loc_7951C
jmp loc_795C6
loc_7951C:
mov rax, [rbp+var_28]
movsx eax, byte ptr [rax]
cmp eax, [rbp+var_34]
jnz short loc_79542
mov rax, [rbp+var_28]
add rax, 1
cmp rax, [rbp+var_30]
jz short loc_79542
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
loc_79542:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jz short loc_7958C
mov rax, [rbp+var_10]
mov rax, [rax+58h]
mov rcx, [rbp+var_28]
mov rdx, rcx
add rdx, 1
mov [rbp+var_28], rdx
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx]
mov rcx, [rbp+var_10]
mov rcx, [rcx+58h]
mov rdx, [rbp+var_18]
mov rsi, rdx
add rsi, 1
mov [rbp+var_18], rsi
movzx edx, byte ptr [rdx]
movzx ecx, byte ptr [rcx+rdx]
cmp eax, ecx
jz short loc_79598
loc_7958C:
mov [rbp+var_4], 1
jmp loc_7980A
loc_79598:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_30]
jnz short loc_795BA
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
setnz al
and al, 1
movzx eax, al
mov [rbp+var_4], eax
jmp loc_7980A
loc_795BA:
mov [rbp+var_38], 1
jmp loc_794EF
loc_795C6:
mov rax, [rbp+var_28]
movsx eax, byte ptr [rax]
cmp eax, [rbp+arg_0]
jnz short loc_79634
jmp short $+2
loc_795D4:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jnz short loc_795E9
mov eax, [rbp+var_38]
mov [rbp+var_4], eax
jmp loc_7980A
loc_795E9:
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
mov rcx, [rbp+var_28]
add rcx, 1
mov [rbp+var_28], rcx
xor eax, eax
cmp rcx, [rbp+var_30]
mov [rbp+var_42], al
jnb short loc_7961C
mov rax, [rbp+var_28]
movsx eax, byte ptr [rax]
cmp eax, [rbp+arg_0]
setz al
mov [rbp+var_42], al
loc_7961C:
mov al, [rbp+var_42]
test al, 1
jnz short loc_795D4
mov rax, [rbp+var_28]
cmp rax, [rbp+var_30]
jnz short loc_79632
jmp loc_797F2
loc_79632:
jmp short $+2
loc_79634:
mov rax, [rbp+var_28]
movsx eax, byte ptr [rax]
cmp eax, [rbp+arg_8]
jnz loc_797ED
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
loc_79650:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_30]
jz short loc_796A8
mov rax, [rbp+var_28]
movsx eax, byte ptr [rax]
cmp eax, [rbp+arg_8]
jnz short loc_79668
jmp short loc_7969A
loc_79668:
mov rax, [rbp+var_28]
movsx eax, byte ptr [rax]
cmp eax, [rbp+arg_0]
jnz short loc_79698
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jnz short loc_7968A
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_7980A
loc_7968A:
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
jmp short loc_7969A
loc_79698:
jmp short loc_796A8
loc_7969A:
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
jmp short loc_79650
loc_796A8:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_30]
jnz short loc_796BE
mov [rbp+var_4], 0
jmp loc_7980A
loc_796BE:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jnz short loc_796D4
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_7980A
loc_796D4:
mov rax, [rbp+var_28]
mov al, [rax]
mov [rbp+var_39], al
movzx eax, al
cmp eax, [rbp+var_34]
jnz short loc_79708
mov rax, [rbp+var_28]
add rax, 1
cmp rax, [rbp+var_30]
jz short loc_79708
mov rax, [rbp+var_28]
mov rcx, rax
add rcx, 1
mov [rbp+var_28], rcx
mov al, [rax+1]
mov [rbp+var_39], al
loc_79708:
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
mov rax, [rbp+var_10]
mov rax, [rax+58h]
movzx ecx, [rbp+var_39]
mov al, [rax+rcx]
mov [rbp+var_39], al
loc_79726:
jmp short $+2
loc_79728:
mov rcx, [rbp+var_18]
xor eax, eax
cmp rcx, [rbp+var_20]
mov [rbp+var_43], al
jz short loc_79756
mov rax, [rbp+var_10]
mov rax, [rax+58h]
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx]
movzx ecx, [rbp+var_39]
cmp eax, ecx
setnz al
mov [rbp+var_43], al
loc_79756:
mov al, [rbp+var_43]
test al, 1
jnz short loc_7975F
jmp short loc_7976D
loc_7975F:
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
jmp short loc_79728
loc_7976D:
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 1
mov [rbp+var_18], rcx
cmp rax, [rbp+var_20]
jnz short loc_7978B
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_7980A
loc_7978B:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_28]
mov r8, [rbp+var_30]
mov r9d, [rbp+var_34]
mov r11d, [rbp+arg_0]
mov r10d, [rbp+arg_8]
mov eax, [rbp+arg_10]
add eax, 1
mov [rsp+60h+var_60], r11d
mov [rsp+60h+var_58], r10d
mov [rsp+60h+var_50], eax
call my_wildcmp_8bit_impl
mov [rbp+var_40], eax
cmp [rbp+var_40], 0
jg short loc_797D4
mov eax, [rbp+var_40]
mov [rbp+var_4], eax
jmp short loc_7980A
loc_797D4:
jmp short $+2
loc_797D6:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jnz loc_79726
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_7980A
loc_797ED:
jmp loc_794DF
loc_797F2:
mov rdx, [rbp+var_18]
mov rsi, [rbp+var_20]
xor eax, eax
mov ecx, 1
cmp rdx, rsi
cmovnz eax, ecx
mov [rbp+var_4], eax
loc_7980A:
mov eax, [rbp+var_4]
add rsp, 60h
pop rbp
retn
| long long my_wildcmp_8bit_impl(
long long a1,
unsigned __int8 *a2,
unsigned __int8 *a3,
char *a4,
char *a5,
int a6,
int a7,
int a8,
unsigned int a9)
{
char *v9; // rcx
unsigned __int8 *v10; // rdx
char *v11; // rax
unsigned __int8 *v12; // rax
bool v14; // [rsp+1Dh] [rbp-43h]
bool v15; // [rsp+1Eh] [rbp-42h]
bool v16; // [rsp+1Fh] [rbp-41h]
int v17; // [rsp+20h] [rbp-40h]
unsigned __int8 v18; // [rsp+27h] [rbp-39h]
unsigned __int8 v19; // [rsp+27h] [rbp-39h]
unsigned int v20; // [rsp+28h] [rbp-38h]
char *i; // [rsp+38h] [rbp-28h]
int v25; // [rsp+38h] [rbp-28h]
v20 = -1;
if ( my_string_stack_guard && (unsigned int)my_string_stack_guard(a9) )
{
return 1;
}
else
{
do
{
if ( a4 != a5 )
{
while ( 1 )
{
v16 = 0;
if ( *a4 != a8 )
v16 = *a4 != a7;
if ( !v16 )
break;
if ( *a4 == a6 && a4 + 1 != a5 )
++a4;
if ( a2 == a3 )
return 1;
v9 = a4++;
v10 = a2++;
if ( *(unsigned __int8 *)(*(_QWORD *)(a1 + 88) + (unsigned __int8)*v9) != *(unsigned __int8 *)(*(_QWORD *)(a1 + 88) + *v10) )
return 1;
if ( a4 == a5 )
return a2 != a3;
v20 = 1;
}
if ( *a4 != a7 )
continue;
do
{
if ( a2 == a3 )
return v20;
++a2;
++a4;
v15 = 0;
if ( a4 < a5 )
v15 = *a4 == a7;
}
while ( v15 );
if ( a4 != a5 )
continue;
}
return a2 != a3;
}
while ( *a4 != a8 );
for ( i = a4 + 1; i != a5; ++i )
{
if ( *i != a8 )
{
if ( *i != a7 )
break;
if ( a2 == a3 )
return (unsigned int)-1;
++a2;
}
}
if ( i == a5 )
{
return 0;
}
else if ( a2 == a3 )
{
return (unsigned int)-1;
}
else
{
v18 = *i;
if ( (unsigned __int8)*i == a6 && i + 1 != a5 )
{
v11 = i;
LODWORD(i) = (_DWORD)i + 1;
v18 = v11[1];
}
v25 = (_DWORD)i + 1;
v19 = *(_BYTE *)(*(_QWORD *)(a1 + 88) + v18);
do
{
while ( 1 )
{
v14 = 0;
if ( a2 != a3 )
v14 = *(unsigned __int8 *)(*(_QWORD *)(a1 + 88) + *a2) != v19;
if ( !v14 )
break;
++a2;
}
v12 = a2++;
if ( v12 == a3 )
return (unsigned int)-1;
v17 = my_wildcmp_8bit_impl(a1, (_DWORD)a2, (_DWORD)a3, v25, (_DWORD)a5, a6, a7, a8, a9 + 1);
if ( v17 <= 0 )
return (unsigned int)v17;
}
while ( a2 != a3 );
return (unsigned int)-1;
}
}
}
| my_wildcmp_8bit_impl:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV EAX,dword ptr [RBP + 0x20]
MOV EAX,dword ptr [RBP + 0x18]
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 dword ptr [RBP + -0x34],R9D
MOV dword ptr [RBP + -0x38],0xffffffff
LEA RAX,[0x518fe8]
CMP qword ptr [RAX],0x0
JZ 0x001794dd
LEA RAX,[0x518fe8]
MOV RAX,qword ptr [RAX]
MOV EDI,dword ptr [RBP + 0x20]
CALL RAX
CMP EAX,0x0
JZ 0x001794dd
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0017980a
LAB_001794dd:
JMP 0x001794df
LAB_001794df:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x30]
JZ 0x001797f2
JMP 0x001794ef
LAB_001794ef:
MOV RAX,qword ptr [RBP + -0x28]
MOVSX ECX,byte ptr [RAX]
XOR EAX,EAX
CMP ECX,dword ptr [RBP + 0x18]
MOV byte ptr [RBP + -0x41],AL
JZ 0x00179510
MOV RAX,qword ptr [RBP + -0x28]
MOVSX EAX,byte ptr [RAX]
CMP EAX,dword ptr [RBP + 0x10]
SETNZ AL
MOV byte ptr [RBP + -0x41],AL
LAB_00179510:
MOV AL,byte ptr [RBP + -0x41]
TEST AL,0x1
JNZ 0x0017951c
JMP 0x001795c6
LAB_0017951c:
MOV RAX,qword ptr [RBP + -0x28]
MOVSX EAX,byte ptr [RAX]
CMP EAX,dword ptr [RBP + -0x34]
JNZ 0x00179542
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
CMP RAX,qword ptr [RBP + -0x30]
JZ 0x00179542
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
LAB_00179542:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JZ 0x0017958c
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x58]
MOV RCX,qword ptr [RBP + -0x28]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x28],RDX
MOVZX ECX,byte ptr [RCX]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x58]
MOV RDX,qword ptr [RBP + -0x18]
MOV RSI,RDX
ADD RSI,0x1
MOV qword ptr [RBP + -0x18],RSI
MOVZX EDX,byte ptr [RDX]
MOVZX ECX,byte ptr [RCX + RDX*0x1]
CMP EAX,ECX
JZ 0x00179598
LAB_0017958c:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0017980a
LAB_00179598:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001795ba
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0017980a
LAB_001795ba:
MOV dword ptr [RBP + -0x38],0x1
JMP 0x001794ef
LAB_001795c6:
MOV RAX,qword ptr [RBP + -0x28]
MOVSX EAX,byte ptr [RAX]
CMP EAX,dword ptr [RBP + 0x10]
JNZ 0x00179634
JMP 0x001795d4
LAB_001795d4:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x001795e9
MOV EAX,dword ptr [RBP + -0x38]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0017980a
LAB_001795e9:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
MOV RCX,qword ptr [RBP + -0x28]
ADD RCX,0x1
MOV qword ptr [RBP + -0x28],RCX
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x30]
MOV byte ptr [RBP + -0x42],AL
JNC 0x0017961c
MOV RAX,qword ptr [RBP + -0x28]
MOVSX EAX,byte ptr [RAX]
CMP EAX,dword ptr [RBP + 0x10]
SETZ AL
MOV byte ptr [RBP + -0x42],AL
LAB_0017961c:
MOV AL,byte ptr [RBP + -0x42]
TEST AL,0x1
JNZ 0x001795d4
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00179632
JMP 0x001797f2
LAB_00179632:
JMP 0x00179634
LAB_00179634:
MOV RAX,qword ptr [RBP + -0x28]
MOVSX EAX,byte ptr [RAX]
CMP EAX,dword ptr [RBP + 0x18]
JNZ 0x001797ed
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
LAB_00179650:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x30]
JZ 0x001796a8
MOV RAX,qword ptr [RBP + -0x28]
MOVSX EAX,byte ptr [RAX]
CMP EAX,dword ptr [RBP + 0x18]
JNZ 0x00179668
JMP 0x0017969a
LAB_00179668:
MOV RAX,qword ptr [RBP + -0x28]
MOVSX EAX,byte ptr [RAX]
CMP EAX,dword ptr [RBP + 0x10]
JNZ 0x00179698
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x0017968a
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x0017980a
LAB_0017968a:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0017969a
LAB_00179698:
JMP 0x001796a8
LAB_0017969a:
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00179650
LAB_001796a8:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001796be
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0017980a
LAB_001796be:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x001796d4
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x0017980a
LAB_001796d4:
MOV RAX,qword ptr [RBP + -0x28]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x39],AL
MOVZX EAX,AL
CMP EAX,dword ptr [RBP + -0x34]
JNZ 0x00179708
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
CMP RAX,qword ptr [RBP + -0x30]
JZ 0x00179708
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x28],RCX
MOV AL,byte ptr [RAX + 0x1]
MOV byte ptr [RBP + -0x39],AL
LAB_00179708:
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x58]
MOVZX ECX,byte ptr [RBP + -0x39]
MOV AL,byte ptr [RAX + RCX*0x1]
MOV byte ptr [RBP + -0x39],AL
LAB_00179726:
JMP 0x00179728
LAB_00179728:
MOV RCX,qword ptr [RBP + -0x18]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x20]
MOV byte ptr [RBP + -0x43],AL
JZ 0x00179756
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x58]
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOVZX ECX,byte ptr [RBP + -0x39]
CMP EAX,ECX
SETNZ AL
MOV byte ptr [RBP + -0x43],AL
LAB_00179756:
MOV AL,byte ptr [RBP + -0x43]
TEST AL,0x1
JNZ 0x0017975f
JMP 0x0017976d
LAB_0017975f:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
JMP 0x00179728
LAB_0017976d:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x18],RCX
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x0017978b
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x0017980a
LAB_0017978b:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x28]
MOV R8,qword ptr [RBP + -0x30]
MOV R9D,dword ptr [RBP + -0x34]
MOV R11D,dword ptr [RBP + 0x10]
MOV R10D,dword ptr [RBP + 0x18]
MOV EAX,dword ptr [RBP + 0x20]
ADD EAX,0x1
MOV dword ptr [RSP],R11D
MOV dword ptr [RSP + 0x8],R10D
MOV dword ptr [RSP + 0x10],EAX
CALL 0x00179480
MOV dword ptr [RBP + -0x40],EAX
CMP dword ptr [RBP + -0x40],0x0
JG 0x001797d4
MOV EAX,dword ptr [RBP + -0x40]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0017980a
LAB_001797d4:
JMP 0x001797d6
LAB_001797d6:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x00179726
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x0017980a
LAB_001797ed:
JMP 0x001794df
LAB_001797f2:
MOV RDX,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
XOR EAX,EAX
MOV ECX,0x1
CMP RDX,RSI
CMOVNZ EAX,ECX
MOV dword ptr [RBP + -0x4],EAX
LAB_0017980a:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x60
POP RBP
RET
|
uint my_wildcmp_8bit_impl
(long param_1,byte *param_2,byte *param_3,byte *param_4,byte *param_5,uint param_6,
int param_7,int param_8,int param_9)
{
char cVar1;
int iVar2;
uint uVar3;
byte *pbVar4;
bool bVar5;
byte local_41;
uint local_40;
byte *local_30;
byte *local_20;
uint local_c;
local_40 = 0xffffffff;
local_30 = param_4;
local_20 = param_2;
if ((my_string_stack_guard == (code *)0x0) ||
(iVar2 = (*my_string_stack_guard)(param_9), iVar2 == 0)) {
do {
if (local_30 == param_5) {
LAB_001797f2:
return (uint)(local_20 != param_3);
}
while( true ) {
bVar5 = false;
if ((char)*local_30 != param_8) {
bVar5 = (char)*local_30 != param_7;
}
if (!bVar5) break;
if (((int)(char)*local_30 == param_6) && (local_30 + 1 != param_5)) {
local_30 = local_30 + 1;
}
if (local_20 == param_3) {
return 1;
}
if (*(char *)(*(long *)(param_1 + 0x58) + (ulong)*local_30) !=
*(char *)(*(long *)(param_1 + 0x58) + (ulong)*local_20)) {
return 1;
}
if (local_30 + 1 == param_5) {
return (uint)(local_20 + 1 != param_3);
}
local_40 = 1;
local_30 = local_30 + 1;
local_20 = local_20 + 1;
}
if ((char)*local_30 == param_7) {
do {
if (local_20 == param_3) {
return local_40;
}
local_20 = local_20 + 1;
local_30 = local_30 + 1;
bVar5 = false;
if (local_30 < param_5) {
bVar5 = (char)*local_30 == param_7;
}
} while (bVar5);
if (local_30 == param_5) goto LAB_001797f2;
}
} while ((char)*local_30 != param_8);
while (pbVar4 = local_30, local_30 = pbVar4 + 1, local_30 != param_5) {
if ((char)*local_30 != param_8) {
if ((char)*local_30 != param_7) break;
if (local_20 == param_3) {
return 0xffffffff;
}
local_20 = local_20 + 1;
}
}
if (local_30 == param_5) {
local_c = 0;
}
else if (local_20 == param_3) {
local_c = 0xffffffff;
}
else {
local_41 = *local_30;
if ((local_41 == param_6) && (pbVar4 + 2 != param_5)) {
local_30 = pbVar4 + 2;
local_41 = pbVar4[2];
}
cVar1 = *(char *)(*(long *)(param_1 + 0x58) + (ulong)local_41);
do {
while( true ) {
bVar5 = false;
if (local_20 != param_3) {
bVar5 = *(char *)(*(long *)(param_1 + 0x58) + (ulong)*local_20) != cVar1;
}
if (!bVar5) break;
local_20 = local_20 + 1;
}
pbVar4 = local_20 + 1;
if (local_20 == param_3) {
return 0xffffffff;
}
uVar3 = my_wildcmp_8bit_impl
(param_1,pbVar4,param_3,local_30 + 1,param_5,param_6,param_7,param_8,
param_9 + 1);
if ((int)uVar3 < 1) {
return uVar3;
}
local_20 = pbVar4;
} while (pbVar4 != param_3);
local_c = 0xffffffff;
}
}
else {
local_c = 1;
}
return local_c;
}
|
|
945 | nlohmann::json_abi_v3_11_3::detail::serializer<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>>::dump_float(double) | llama.cpp/common/json.hpp | void dump_float(number_float_t x)
{
// NaN / inf
if (!std::isfinite(x))
{
o->write_characters("null", 4);
return;
}
// If number_float_t is an IEEE-754 single or double precision number,
// use the Grisu2 algorithm to produce short numbers which are
// guaranteed to round-trip, using strtof and strtod, resp.
//
// NB: The test below works if <long double> == <double>.
static constexpr bool is_ieee_single_or_double
= (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 24 && std::numeric_limits<number_float_t>::max_exponent == 128) ||
(std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 53 && std::numeric_limits<number_float_t>::max_exponent == 1024);
dump_float(x, std::integral_constant<bool, is_ieee_single_or_double>());
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::serializer<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>>::dump_float(double):
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jl 0xd3dc1
movq (%rbx), %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
leaq 0x50ec3(%rip), %rsi # 0x124c76
movl $0x4, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
leaq 0x10(%rbx), %r14
leaq 0x50(%rbx), %rsi
movq %r14, %rdi
callq 0x8279f
movq (%rbx), %rdi
subq %r14, %rax
movq (%rdi), %rcx
movq 0x8(%rcx), %rcx
movq %r14, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rcx
nop
| _ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE10dump_floatEd:
push r14
push rbx
push rax
mov rbx, rdi
movq rax, xmm0
btr rax, 3Fh ; '?'
mov rcx, 7FF0000000000000h
cmp rax, rcx
jl short loc_D3DC1
mov rdi, [rbx]
mov rax, [rdi]
mov rax, [rax+8]
lea rsi, aOnNull_0+5; "null"
mov edx, 4
add rsp, 8
pop rbx
pop r14
jmp rax
loc_D3DC1:
lea r14, [rbx+10h]
lea rsi, [rbx+50h]
mov rdi, r14; this
call _ZN8nlohmann16json_abi_v3_11_36detail8to_charsIdEEPcS3_PKcT_; nlohmann::json_abi_v3_11_3::detail::to_chars<double>(char *,char const*,double)
mov rdi, [rbx]
sub rax, r14
mov rcx, [rdi]
mov rcx, [rcx+8]
mov rsi, r14
mov rdx, rax
add rsp, 8
pop rbx
pop r14
jmp rcx
| long long nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::dump_float(
_QWORD *a1,
__m128i a2)
{
long long v3; // rax
if ( (a2.m128i_i64[0] & 0x7FFFFFFFFFFFFFFFuLL) >= 0x7FF0000000000000LL )
return (*(long long ( **)(_QWORD, char *, long long))(*(_QWORD *)*a1 + 8LL))(*a1, "null", 4LL);
v3 = nlohmann::json_abi_v3_11_3::detail::to_chars<double>(
(nlohmann::json_abi_v3_11_3::detail::dtoa_impl *)(a1 + 2),
(long long)(a1 + 10),
a2);
return (*(long long ( **)(_QWORD, _QWORD *, long long))(*(_QWORD *)*a1 + 8LL))(
*a1,
a1 + 2,
v3 - (_QWORD)(a1 + 2));
}
| dump_float:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOVQ RAX,XMM0
BTR RAX,0x3f
MOV RCX,0x7ff0000000000000
CMP RAX,RCX
JL 0x001d3dc1
MOV RDI,qword ptr [RBX]
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x8]
LEA RSI,[0x224c76]
MOV EDX,0x4
ADD RSP,0x8
POP RBX
POP R14
JMP RAX
LAB_001d3dc1:
LEA R14,[RBX + 0x10]
LEA RSI,[RBX + 0x50]
MOV RDI,R14
CALL 0x0018279f
MOV RDI,qword ptr [RBX]
SUB RAX,R14
MOV RCX,qword ptr [RDI]
MOV RCX,qword ptr [RCX + 0x8]
MOV RSI,R14
MOV RDX,RAX
ADD RSP,0x8
POP RBX
POP R14
JMP RCX
|
/* nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::dump_float(double) */
void __thiscall
nlohmann::json_abi_v3_11_3::detail::
serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::dump_float(serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this,double param_1)
{
serializer<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>>
*psVar1;
code *UNRECOVERED_JUMPTABLE;
char *pcVar2;
if (0x7fefffffffffffff < (ulong)ABS(param_1)) {
/* WARNING: Could not recover jumptable at 0x001d3dbf. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(**(long **)this + 8))(*(long **)this,"null",4);
return;
}
psVar1 = this + 0x10;
pcVar2 = to_chars<double>((char *)psVar1,(char *)(this + 0x50),param_1);
UNRECOVERED_JUMPTABLE = *(code **)(**(long **)this + 8);
/* WARNING: Could not recover jumptable at 0x001d3deb. Too many branches */
/* WARNING: Treating indirect jump as call */
(*UNRECOVERED_JUMPTABLE)(*(long **)this,psVar1,(long)pcVar2 - (long)psVar1,UNRECOVERED_JUMPTABLE);
return;
}
|
|
946 | fmt::v10::detail::dragonbox::cache_accessor<double>::compute_mul_parity(unsigned long, fmt::v10::detail::uint128_fallback const&, int) | aimrt_mujoco_sim/_deps/fmt-src/include/fmt/format-inl.h | static auto compute_mul_parity(carrier_uint two_f,
const cache_entry_type& cache,
int beta) noexcept
-> compute_mul_parity_result {
FMT_ASSERT(beta >= 1, "");
FMT_ASSERT(beta < 64, "");
auto r = umul192_lower128(two_f, cache);
return {((r.high() >> (64 - beta)) & 1) != 0,
((r.high() << beta) | (r.low() >> (64 - beta))) == 0};
} | O0 | c | fmt::v10::detail::dragonbox::cache_accessor<double>::compute_mul_parity(unsigned long, fmt::v10::detail::uint128_fallback const&, int):
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movl %edx, 0x2c(%rsp)
cmpl $0x1, 0x2c(%rsp)
setge %al
andb $0x1, %al
movb %al, 0x2b(%rsp)
leaq 0x2b(%rsp), %rdi
leaq 0x331dcd(%rip), %rsi # 0x3e1fa9
callq 0xac150
cmpl $0x40, 0x2c(%rsp)
setl %al
andb $0x1, %al
movb %al, 0x2a(%rsp)
leaq 0x2a(%rsp), %rdi
leaq 0x331dae(%rip), %rsi # 0x3e1fa9
callq 0xac150
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0xb0650
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
leaq 0x18(%rsp), %rdi
callq 0xb04d0
movl $0x40, %ecx
subl 0x2c(%rsp), %ecx
movl %ecx, %ecx
shrq %cl, %rax
andq $0x1, %rax
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, 0x46(%rsp)
leaq 0x18(%rsp), %rdi
callq 0xb04d0
movl 0x2c(%rsp), %ecx
shlq %cl, %rax
movq %rax, (%rsp)
leaq 0x18(%rsp), %rdi
callq 0xb0540
movq %rax, %rdx
movq (%rsp), %rax
movl $0x40, %ecx
subl 0x2c(%rsp), %ecx
movl %ecx, %ecx
shrq %cl, %rdx
movq %rdx, %rcx
orq %rcx, %rax
cmpq $0x0, %rax
sete %al
andb $0x1, %al
movb %al, 0x47(%rsp)
movw 0x46(%rsp), %ax
addq $0x48, %rsp
retq
nop
| _ZN3fmt3v106detail9dragonbox14cache_accessorIdE18compute_mul_parityEmRKNS1_16uint128_fallbackEi:
sub rsp, 48h
mov [rsp+48h+var_10], rdi
mov [rsp+48h+var_18], rsi
mov [rsp+48h+var_1C], edx
cmp [rsp+48h+var_1C], 1
setnl al
and al, 1
mov [rsp+48h+var_1D], al
lea rdi, [rsp+48h+var_1D]
lea rsi, asc_3E1FA8+1; "ࠀ\u0B00"
call _ZN3fmt3v106detail13ignore_unusedIJbA1_cEEEvDpRKT_; fmt::v10::detail::ignore_unused<bool,char [1]>(bool,char [1] const&)
cmp [rsp+48h+var_1C], 40h ; '@'
setl al
and al, 1
mov [rsp+48h+var_1E], al
lea rdi, [rsp+48h+var_1E]
lea rsi, asc_3E1FA8+1; "ࠀ\u0B00"
call _ZN3fmt3v106detail13ignore_unusedIJbA1_cEEEvDpRKT_; fmt::v10::detail::ignore_unused<bool,char [1]>(bool,char [1] const&)
mov rdi, [rsp+48h+var_10]
mov rax, [rsp+48h+var_18]
mov rcx, [rax]
mov [rsp+48h+var_40], rcx
mov rax, [rax+8]
mov [rsp+48h+var_38], rax
mov rsi, [rsp+48h+var_40]
mov rdx, [rsp+48h+var_38]
call _ZN3fmt3v106detail9dragonbox16umul192_lower128EmNS1_16uint128_fallbackE; fmt::v10::detail::dragonbox::umul192_lower128(ulong,fmt::v10::detail::uint128_fallback)
mov [rsp+48h+var_30], rax
mov [rsp+48h+var_28], rdx
lea rdi, [rsp+48h+var_30]; this
call _ZNK3fmt3v106detail16uint128_fallback4highEv; fmt::v10::detail::uint128_fallback::high(void)
mov ecx, 40h ; '@'
sub ecx, [rsp+48h+var_1C]
mov ecx, ecx
shr rax, cl
and rax, 1
cmp rax, 0
setnz al
and al, 1
mov byte ptr [rsp+48h+var_2], al
lea rdi, [rsp+48h+var_30]; this
call _ZNK3fmt3v106detail16uint128_fallback4highEv; fmt::v10::detail::uint128_fallback::high(void)
mov ecx, [rsp+48h+var_1C]
shl rax, cl
mov [rsp+48h+var_48], rax
lea rdi, [rsp+48h+var_30]; this
call _ZNK3fmt3v106detail16uint128_fallback3lowEv; fmt::v10::detail::uint128_fallback::low(void)
mov rdx, rax
mov rax, [rsp+48h+var_48]
mov ecx, 40h ; '@'
sub ecx, [rsp+48h+var_1C]
mov ecx, ecx
shr rdx, cl
mov rcx, rdx
or rax, rcx
cmp rax, 0
setz al
and al, 1
mov byte ptr [rsp+48h+var_2+1], al
mov ax, [rsp+48h+var_2]
add rsp, 48h
retn
| __int16 fmt::v10::detail::dragonbox::cache_accessor<double>::compute_mul_parity(
long long a1,
_QWORD *a2,
int a3)
{
long long v3; // rdx
unsigned long long v4; // rax
long long v5; // rax
unsigned long long v6; // rax
long long v8; // [rsp+0h] [rbp-48h]
_QWORD v9[2]; // [rsp+18h] [rbp-30h] BYREF
bool v10; // [rsp+2Ah] [rbp-1Eh]
bool v11; // [rsp+2Bh] [rbp-1Dh]
int v12; // [rsp+2Ch] [rbp-1Ch]
_QWORD *v13; // [rsp+30h] [rbp-18h]
long long v14; // [rsp+38h] [rbp-10h]
__int16 v15; // [rsp+46h] [rbp-2h]
v14 = a1;
v13 = a2;
v12 = a3;
v11 = a3 >= 1;
fmt::v10::detail::ignore_unused<bool,char [1]>();
v10 = v12 < 64;
fmt::v10::detail::ignore_unused<bool,char [1]>();
v9[0] = fmt::v10::detail::dragonbox::umul192_lower128(a1, *v13, v13[1]);
v9[1] = v3;
v4 = fmt::v10::detail::uint128_fallback::high((fmt::v10::detail::uint128_fallback *)v9);
LOBYTE(v15) = ((v4 >> (64 - (unsigned __int8)v12)) & 1) != 0;
v5 = fmt::v10::detail::uint128_fallback::high((fmt::v10::detail::uint128_fallback *)v9);
v8 = v5 << v12;
v6 = fmt::v10::detail::uint128_fallback::low((fmt::v10::detail::uint128_fallback *)v9);
HIBYTE(v15) = ((v6 >> (64 - (unsigned __int8)v12)) | v8) == 0;
return v15;
}
| compute_mul_parity:
SUB RSP,0x48
MOV qword ptr [RSP + 0x38],RDI
MOV qword ptr [RSP + 0x30],RSI
MOV dword ptr [RSP + 0x2c],EDX
CMP dword ptr [RSP + 0x2c],0x1
SETGE AL
AND AL,0x1
MOV byte ptr [RSP + 0x2b],AL
LEA RDI,[RSP + 0x2b]
LEA RSI,[0x4e1fa9]
CALL 0x001ac150
CMP dword ptr [RSP + 0x2c],0x40
SETL AL
AND AL,0x1
MOV byte ptr [RSP + 0x2a],AL
LEA RDI,[RSP + 0x2a]
LEA RSI,[0x4e1fa9]
CALL 0x001ac150
MOV RDI,qword ptr [RSP + 0x38]
MOV RAX,qword ptr [RSP + 0x30]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RSP + 0x8],RCX
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x10],RAX
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
CALL 0x001b0650
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x20],RDX
LEA RDI,[RSP + 0x18]
CALL 0x001b04d0
MOV ECX,0x40
SUB ECX,dword ptr [RSP + 0x2c]
MOV ECX,ECX
SHR RAX,CL
AND RAX,0x1
CMP RAX,0x0
SETNZ AL
AND AL,0x1
MOV byte ptr [RSP + 0x46],AL
LEA RDI,[RSP + 0x18]
CALL 0x001b04d0
MOV ECX,dword ptr [RSP + 0x2c]
SHL RAX,CL
MOV qword ptr [RSP],RAX
LEA RDI,[RSP + 0x18]
CALL 0x001b0540
MOV RDX,RAX
MOV RAX,qword ptr [RSP]
MOV ECX,0x40
SUB ECX,dword ptr [RSP + 0x2c]
MOV ECX,ECX
SHR RDX,CL
MOV RCX,RDX
OR RAX,RCX
CMP RAX,0x0
SETZ AL
AND AL,0x1
MOV byte ptr [RSP + 0x47],AL
MOV AX,word ptr [RSP + 0x46]
ADD RSP,0x48
RET
|
/* fmt::v10::detail::dragonbox::cache_accessor<double>::compute_mul_parity(unsigned long,
fmt::v10::detail::uint128_fallback const&, int) */
int8
fmt::v10::detail::dragonbox::cache_accessor<double>::compute_mul_parity
(ulong param_1,uint128_fallback *param_2,int param_3)
{
ulong uVar1;
long lVar2;
byte bVar3;
uint128_fallback local_30 [18];
bool local_1e;
bool local_1d;
int local_1c;
uint128_fallback *local_18;
dragonbox *local_10;
int2 local_2;
local_1d = 0 < param_3;
local_1c = param_3;
local_18 = param_2;
local_10 = (dragonbox *)param_1;
ignore_unused<bool,char[1]>(&local_1d,"");
local_1e = local_1c < 0x40;
ignore_unused<bool,char[1]>(&local_1e,"");
local_30._0_16_ = umul192_lower128(local_10,*(int8 *)local_18,*(int8 *)(local_18 + 8))
;
uVar1 = uint128_fallback::high(local_30);
local_2 = CONCAT11(local_2._1_1_,(uVar1 >> (0x40U - (char)local_1c & 0x3f) & 1) != 0);
lVar2 = uint128_fallback::high(local_30);
bVar3 = (byte)local_1c;
uVar1 = uint128_fallback::low(local_30);
uVar1 = lVar2 << (bVar3 & 0x3f) | uVar1 >> (0x40U - (char)local_1c & 0x3f);
local_2 = CONCAT11(uVar1 == 0,(int1)local_2);
return CONCAT62((int6)(uVar1 >> 0x10),local_2);
}
|
|
947 | maria_lock_memory | eloqsql/storage/maria/ma_check.c | void maria_lock_memory(HA_CHECK *param __attribute__((unused)))
{
#ifdef SUN_OS /* Key-cacheing thrases on sun 4.1 */
if (param->opt_maria_lock_memory)
{
int success = mlockall(MCL_CURRENT); /* or plock(DATLOCK); */
if (geteuid() == 0 && success != 0)
_ma_check_print_warning(param,
"Failed to lock memory. errno %d",my_errno);
}
#endif
} | O0 | c | maria_lock_memory:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
popq %rbp
retq
nopw (%rax,%rax)
| maria_lock_memory:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
pop rbp
retn
| void maria_lock_memory()
{
;
}
| maria_lock_memory:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
POP RBP
RET
|
void maria_lock_memory(void)
{
return;
}
|
|
948 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> google::protobuf::compiler::objectivec::GetOptionalDeprecatedAttribute<google::protobuf::EnumDescriptor>(google::protobuf::EnumDescriptor const*, google::protobuf::FileDescriptor const*, bool, bool) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/compiler/objectivec/objectivec_helpers.h | std::string GetOptionalDeprecatedAttribute(const TDescriptor* descriptor,
const FileDescriptor* file = NULL,
bool preSpace = true,
bool postNewline = false) {
bool isDeprecated = descriptor->options().deprecated();
// The file is only passed when checking Messages & Enums, so those types
// get tagged. At the moment, it doesn't seem to make sense to tag every
// field or enum value with when the file is deprecated.
bool isFileLevelDeprecation = false;
if (!isDeprecated && file) {
isFileLevelDeprecation = file->options().deprecated();
isDeprecated = isFileLevelDeprecation;
}
if (isDeprecated) {
std::string message;
const FileDescriptor* sourceFile = descriptor->file();
if (isFileLevelDeprecation) {
message = sourceFile->name() + " is deprecated.";
} else {
message = descriptor->full_name() + " is deprecated (see " +
sourceFile->name() + ").";
}
std::string result = std::string("GPB_DEPRECATED_MSG(\"") + message + "\")";
if (preSpace) {
result.insert(0, " ");
}
if (postNewline) {
result.append("\n");
}
return result;
} else {
return "";
}
} | O0 | c | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> google::protobuf::compiler::objectivec::GetOptionalDeprecatedAttribute<google::protobuf::EnumDescriptor>(google::protobuf::EnumDescriptor const*, google::protobuf::FileDescriptor const*, bool, bool):
subq $0x158, %rsp # imm = 0x158
movq %rdi, 0x20(%rsp)
movb %r8b, %al
movq %rdi, %r8
movq %r8, 0x28(%rsp)
movq %rdi, 0x150(%rsp)
movq %rsi, 0x148(%rsp)
movq %rdx, 0x140(%rsp)
andb $0x1, %cl
movb %cl, 0x13f(%rsp)
andb $0x1, %al
movb %al, 0x13e(%rsp)
movq 0x148(%rsp), %rdi
callq 0xc0160
movq %rax, %rdi
callq 0x17d590
andb $0x1, %al
movb %al, 0x13d(%rsp)
movb $0x0, 0x13c(%rsp)
testb $0x1, 0x13d(%rsp)
jne 0x1cce9b
cmpq $0x0, 0x140(%rsp)
je 0x1cce9b
movq 0x140(%rsp), %rdi
callq 0x59690
movq %rax, %rdi
callq 0x1498d0
andb $0x1, %al
movb %al, 0x13c(%rsp)
movb 0x13c(%rsp), %al
andb $0x1, %al
movb %al, 0x13d(%rsp)
testb $0x1, 0x13d(%rsp)
je 0x1cd1ba
leaq 0x118(%rsp), %rdi
callq 0x21390
movq 0x148(%rsp), %rdi
callq 0x17e540
movq %rax, 0x18(%rsp)
jmp 0x1cceca
movq 0x18(%rsp), %rax
movq %rax, 0x110(%rsp)
testb $0x1, 0x13c(%rsp)
je 0x1ccf47
movq 0x110(%rsp), %rdi
callq 0x28990
movq %rax, %rsi
leaq 0x207f0d(%rip), %rdx # 0x3d4e05
leaq 0xe0(%rsp), %rdi
callq 0x28900
jmp 0x1ccf07
leaq 0x118(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
callq 0x215e0
leaq 0xe0(%rsp), %rdi
callq 0x21cc8
jmp 0x1cd042
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x108(%rsp)
movl %eax, 0x104(%rsp)
jmp 0x1cd1ab
movq 0x148(%rsp), %rdi
callq 0x1ce0e0
movq %rax, 0x10(%rsp)
jmp 0x1ccf5b
movq 0x10(%rsp), %rsi
leaq 0x207eae(%rip), %rdx # 0x3d4e15
leaq 0x80(%rsp), %rdi
callq 0x28900
jmp 0x1ccf76
movq 0x110(%rsp), %rdi
callq 0x28990
movq %rax, %rdx
leaq 0xa0(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x288b0
jmp 0x1ccf9d
leaq 0x232b59(%rip), %rdx # 0x3ffafd
leaq 0xc0(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x38840
jmp 0x1ccfbb
leaq 0x118(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x215e0
leaq 0xc0(%rsp), %rdi
callq 0x21cc8
leaq 0xa0(%rsp), %rdi
callq 0x21cc8
leaq 0x80(%rsp), %rdi
callq 0x21cc8
jmp 0x1cd042
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x108(%rsp)
movl %eax, 0x104(%rsp)
jmp 0x1cd030
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x108(%rsp)
movl %eax, 0x104(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x21cc8
leaq 0x80(%rsp), %rdi
callq 0x21cc8
jmp 0x1cd1ab
movb $0x0, 0x7f(%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x21a00
movq 0x8(%rsp), %rdx
leaq 0x207dc8(%rip), %rsi # 0x3d4e2a
leaq 0x38(%rsp), %rdi
callq 0x21890
jmp 0x1cd06e
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rsi
leaq 0x118(%rsp), %rdx
callq 0x288b0
jmp 0x1cd087
movq 0x20(%rsp), %rdi
leaq 0x1df074(%rip), %rdx # 0x3ac107
leaq 0x58(%rsp), %rsi
callq 0x38840
jmp 0x1cd09f
leaq 0x58(%rsp), %rdi
callq 0x21cc8
leaq 0x38(%rsp), %rdi
callq 0x21cc8
leaq 0x37(%rsp), %rdi
callq 0x21cb0
testb $0x1, 0x13f(%rsp)
je 0x1cd167
movq 0x20(%rsp), %rdi
leaq 0x1f757c(%rip), %rdx # 0x3c4653
xorl %eax, %eax
movl %eax, %esi
callq 0x21560
jmp 0x1cd0e2
jmp 0x1cd167
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x108(%rsp)
movl %eax, 0x104(%rsp)
jmp 0x1cd13b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x108(%rsp)
movl %eax, 0x104(%rsp)
jmp 0x1cd131
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x108(%rsp)
movl %eax, 0x104(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x21cc8
leaq 0x38(%rsp), %rdi
callq 0x21cc8
leaq 0x37(%rsp), %rdi
callq 0x21cb0
jmp 0x1cd1ab
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x108(%rsp)
movl %eax, 0x104(%rsp)
callq 0x21cc8
jmp 0x1cd1ab
testb $0x1, 0x13e(%rsp)
je 0x1cd186
movq 0x20(%rsp), %rdi
leaq 0x1f4c04(%rip), %rsi # 0x3c1d81
callq 0x21710
jmp 0x1cd184
jmp 0x1cd186
movb $0x1, 0x7f(%rsp)
testb $0x1, 0x7f(%rsp)
jne 0x1cd19c
movq 0x20(%rsp), %rdi
callq 0x21cc8
leaq 0x118(%rsp), %rdi
callq 0x21cc8
jmp 0x1cd20b
leaq 0x118(%rsp), %rdi
callq 0x21cc8
jmp 0x1cd218
leaq 0x36(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x21a00
movq 0x20(%rsp), %rdi
movq (%rsp), %rdx
leaq 0x1db391(%rip), %rsi # 0x3a8569
callq 0x21890
jmp 0x1cd1df
leaq 0x36(%rsp), %rdi
callq 0x21cb0
jmp 0x1cd20b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x108(%rsp)
movl %eax, 0x104(%rsp)
leaq 0x36(%rsp), %rdi
callq 0x21cb0
jmp 0x1cd218
movq 0x28(%rsp), %rax
addq $0x158, %rsp # imm = 0x158
retq
movq 0x108(%rsp), %rdi
callq 0x21700
nopw %cs:(%rax,%rax)
nop
| _ZN6google8protobuf8compiler10objectivec30GetOptionalDeprecatedAttributeINS0_19EnumValueDescriptorEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPKT_PKNS0_14FileDescriptorEbb:
sub rsp, 158h
mov [rsp+158h+var_138], rdi
mov al, r8b
mov r8, rdi
mov [rsp+158h+var_130], r8
mov [rsp+158h+var_8], rdi
mov [rsp+158h+var_10], rsi
mov [rsp+158h+var_18], rdx
and cl, 1
mov [rsp+158h+var_19], cl
and al, 1
mov [rsp+158h+var_1A], al
mov rdi, [rsp+158h+var_10]; this
call _ZNK6google8protobuf19EnumValueDescriptor7optionsEv; google::protobuf::EnumValueDescriptor::options(void)
mov rdi, rax; this
call _ZNK6google8protobuf16EnumValueOptions10deprecatedEv; google::protobuf::EnumValueOptions::deprecated(void)
and al, 1
mov [rsp+158h+var_1B], al
mov [rsp+158h+var_1C], 0
test [rsp+158h+var_1B], 1
jnz short loc_1CCE9B
cmp [rsp+158h+var_18], 0
jz short loc_1CCE9B
mov rdi, [rsp+158h+var_18]; this
call _ZNK6google8protobuf14FileDescriptor7optionsEv; google::protobuf::FileDescriptor::options(void)
mov rdi, rax; this
call _ZNK6google8protobuf11FileOptions10deprecatedEv; google::protobuf::FileOptions::deprecated(void)
and al, 1
mov [rsp+158h+var_1C], al
mov al, [rsp+158h+var_1C]
and al, 1
mov [rsp+158h+var_1B], al
loc_1CCE9B:
test [rsp+158h+var_1B], 1
jz loc_1CD1BA
lea rdi, [rsp+158h+var_40]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev; std::string::basic_string(void)
mov rdi, [rsp+158h+var_10]; this
call _ZNK6google8protobuf19EnumValueDescriptor4fileEv; google::protobuf::EnumValueDescriptor::file(void)
mov [rsp+158h+var_140], rax; __int64
jmp short $+2
loc_1CCECA:
mov rax, [rsp+158h+var_140]
mov [rsp+158h+var_48], rax
test [rsp+158h+var_1C], 1
jz short loc_1CCF47
mov rdi, [rsp+158h+var_48]
call _ZNK6google8protobuf14FileDescriptor4nameB5cxx11Ev; google::protobuf::FileDescriptor::name(void)
mov rsi, rax; int
lea rdx, aIsDeprecated; " is deprecated."
lea rdi, [rsp+158h+var_78]; int
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EERKS8_PKS5_; std::operator+<char>(std::string const&,char const*)
jmp short $+2
loc_1CCF07:
lea rdi, [rsp+158h+var_40]
lea rsi, [rsp+158h+var_78]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
lea rdi, [rsp+158h+var_78]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp loc_1CD042
mov rcx, rax
mov eax, edx
mov [rsp+arg_100], rcx
mov [rsp+arg_FC], eax
jmp loc_1CD1AB
loc_1CCF47:
mov rdi, [rsp+158h+var_10]
call _ZNK6google8protobuf19EnumValueDescriptor9full_nameB5cxx11Ev; google::protobuf::EnumValueDescriptor::full_name(void)
mov qword ptr [rsp+158h+var_148], rax; int
jmp short $+2
loc_1CCF5B:
mov rsi, qword ptr [rsp+158h+var_148]; int
lea rdx, aIsDeprecatedSe; " is deprecated (see "
lea rdi, [rsp+158h+var_D8]; int
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EERKS8_PKS5_; std::operator+<char>(std::string const&,char const*)
jmp short $+2
loc_1CCF76:
mov rdi, [rsp+158h+var_48]
call _ZNK6google8protobuf14FileDescriptor4nameB5cxx11Ev; google::protobuf::FileDescriptor::name(void)
mov rdx, rax
lea rdi, [rsp+158h+var_B8]
lea rsi, [rsp+158h+var_D8]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_RKS8_; std::operator+<char>(std::string&&,std::string const&)
jmp short $+2
loc_1CCF9D:
lea rdx, aExpectedTopLev+2Ch; ")."
lea rdi, [rsp+158h+var_98]
lea rsi, [rsp+158h+var_B8]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
jmp short $+2
loc_1CCFBB:
lea rdi, [rsp+158h+var_40]
lea rsi, [rsp+158h+var_98]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
lea rdi, [rsp+158h+var_98]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+158h+var_B8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+158h+var_D8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_1CD042
mov rcx, rax
mov eax, edx
mov [rsp+arg_100], rcx
mov [rsp+arg_FC], eax
jmp short loc_1CD030
mov rcx, rax
mov eax, edx
mov [rsp+arg_100], rcx
mov [rsp+arg_FC], eax
lea rdi, [rsp+arg_98]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_1CD030:
lea rdi, [rsp+arg_78]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp loc_1CD1AB
loc_1CD042:
mov [rsp+158h+var_D9], 0
lea rdi, [rsp+158h+var_121]
mov [rsp+158h+var_150], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdx, [rsp+158h+var_150]
lea rsi, aGpbDeprecatedM; "GPB_DEPRECATED_MSG(\""
lea rdi, [rsp+158h+var_120]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1EPKcRKS3_; std::string::basic_string(char const*,std::allocator<char> const&)
jmp short $+2
loc_1CD06E:
lea rdi, [rsp+158h+var_100]
lea rsi, [rsp+158h+var_120]
lea rdx, [rsp+158h+var_40]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_RKS8_; std::operator+<char>(std::string&&,std::string const&)
jmp short $+2
loc_1CD087:
mov rdi, [rsp+158h+var_138]
lea rdx, a1_1+4; "\")"
lea rsi, [rsp+158h+var_100]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
jmp short $+2
loc_1CD09F:
lea rdi, [rsp+158h+var_100]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+158h+var_120]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+158h+var_121]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
test [rsp+158h+var_19], 1
jz loc_1CD167
mov rdi, [rsp+158h+var_138]
lea rdx, aProtobufFieldO_9+36h; " "
xor eax, eax
mov esi, eax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6insertEmPKc; std::string::insert(ulong,char const*)
jmp short $+2
loc_1CD0E2:
jmp loc_1CD167
mov rcx, rax
mov eax, edx
mov [rsp+arg_100], rcx
mov [rsp+arg_FC], eax
jmp short loc_1CD13B
mov rcx, rax
mov eax, edx
mov [rsp+arg_100], rcx
mov [rsp+arg_FC], eax
jmp short loc_1CD131
mov rcx, rax
mov eax, edx
mov [rsp+arg_100], rcx
mov [rsp+arg_FC], eax
lea rdi, [rsp+arg_50]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_1CD131:
lea rdi, [rsp+arg_30]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_1CD13B:
lea rdi, [rsp+arg_2F]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp short loc_1CD1AB
mov rdi, [rsp+arg_18]; void *
mov rcx, rax
mov eax, edx
mov [rsp+arg_100], rcx
mov [rsp+arg_FC], eax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_1CD1AB
loc_1CD167:
test [rsp+158h+var_1A], 1
jz short loc_1CD186
mov rdi, [rsp+158h+var_138]
lea rsi, aConstProtoNsMe_0+0E5h; "\n"
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
jmp short $+2
loc_1CD184:
jmp short $+2
loc_1CD186:
mov [rsp+158h+var_D9], 1
test [rsp+158h+var_D9], 1
jnz short loc_1CD19C
mov rdi, [rsp+158h+var_138]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_1CD19C:
lea rdi, [rsp+158h+var_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_1CD20B
loc_1CD1AB:
lea rdi, [rsp+arg_110]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_1CD218
loc_1CD1BA:
lea rdi, [rsp+158h+var_122]
mov [rsp+158h+var_158], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdi, [rsp+158h+var_138]
mov rdx, [rsp+158h+var_158]
lea rsi, asc_3A8567+2; ""
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1EPKcRKS3_; std::string::basic_string(char const*,std::allocator<char> const&)
jmp short $+2
loc_1CD1DF:
lea rdi, [rsp+158h+var_122]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp short loc_1CD20B
mov rcx, rax
mov eax, edx
mov [rsp+arg_100], rcx
mov [rsp+arg_FC], eax
lea rdi, [rsp+arg_2E]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp short loc_1CD218
loc_1CD20B:
mov rax, [rsp+158h+var_130]
add rsp, 158h
retn
loc_1CD218:
mov rdi, [rsp+arg_100]
call __Unwind_Resume
| long long google::protobuf::compiler::objectivec::GetOptionalDeprecatedAttribute<google::protobuf::EnumValueDescriptor>(
long long a1,
google::protobuf::EnumValueDescriptor *a2,
google::protobuf::FileDescriptor *a3,
char a4,
char a5)
{
google::protobuf::EnumValueOptions *v5; // rax
google::protobuf::FileOptions *v6; // rax
long long v7; // rax
int *v8; // rsi
long long v9; // rax
long long v11; // [rsp+10h] [rbp-148h]
char v12; // [rsp+36h] [rbp-122h] BYREF
char v13; // [rsp+37h] [rbp-121h] BYREF
_BYTE v14[32]; // [rsp+38h] [rbp-120h] BYREF
_BYTE v15[39]; // [rsp+58h] [rbp-100h] BYREF
char v16; // [rsp+7Fh] [rbp-D9h]
int v17[8]; // [rsp+80h] [rbp-D8h] BYREF
_BYTE v18[32]; // [rsp+A0h] [rbp-B8h] BYREF
_BYTE v19[32]; // [rsp+C0h] [rbp-98h] BYREF
int v20[12]; // [rsp+E0h] [rbp-78h] BYREF
long long v21; // [rsp+110h] [rbp-48h]
_BYTE v22[36]; // [rsp+118h] [rbp-40h] BYREF
char v23; // [rsp+13Ch] [rbp-1Ch]
char v24; // [rsp+13Dh] [rbp-1Bh]
char v25; // [rsp+13Eh] [rbp-1Ah]
char v26; // [rsp+13Fh] [rbp-19h]
google::protobuf::FileDescriptor *v27; // [rsp+140h] [rbp-18h]
google::protobuf::EnumValueDescriptor *v28; // [rsp+148h] [rbp-10h]
long long v29; // [rsp+150h] [rbp-8h]
v29 = a1;
v28 = a2;
v27 = a3;
v26 = a4 & 1;
v25 = a5 & 1;
v5 = (google::protobuf::EnumValueOptions *)google::protobuf::EnumValueDescriptor::options(a2);
v24 = google::protobuf::EnumValueOptions::deprecated(v5) & 1;
v23 = 0;
if ( !v24 && v27 )
{
v6 = (google::protobuf::FileOptions *)google::protobuf::FileDescriptor::options(v27);
v23 = google::protobuf::FileOptions::deprecated(v6) & 1;
v24 = v23;
}
if ( (v24 & 1) != 0 )
{
std::string::basic_string(v22);
v21 = google::protobuf::EnumValueDescriptor::file(v28);
if ( (v23 & 1) != 0 )
{
v7 = google::protobuf::FileDescriptor::name[abi:cxx11](v21);
std::operator+<char>((long long)v20, v7, (long long)" is deprecated.");
v8 = v20;
std::string::operator=(v22, v20);
std::string::~string(v20);
}
else
{
v11 = google::protobuf::EnumValueDescriptor::full_name[abi:cxx11](v28);
std::operator+<char>((long long)v17, v11, (long long)" is deprecated (see ");
v9 = google::protobuf::FileDescriptor::name[abi:cxx11](v21);
std::operator+<char>((long long)v18, (long long)v17, v9);
std::operator+<char>((long long)v19, (long long)v18, (long long)").");
v8 = (int *)v19;
std::string::operator=(v22, v19);
std::string::~string(v19);
std::string::~string(v18);
std::string::~string(v17);
}
v16 = 0;
std::allocator<char>::allocator(&v13, v8);
std::string::basic_string(v14, "GPB_DEPRECATED_MSG(\"", &v13);
std::operator+<char>((long long)v15, (long long)v14, (long long)v22);
std::operator+<char>(a1, (long long)v15, (long long)"\")");
std::string::~string(v15);
std::string::~string(v14);
std::allocator<char>::~allocator(&v13);
if ( (v26 & 1) != 0 )
std::string::insert(a1, 0LL, " ");
if ( (v25 & 1) != 0 )
std::string::append(a1, "\n");
v16 = 1;
std::string::~string(v22);
}
else
{
std::allocator<char>::allocator(&v12, a2);
std::string::basic_string(a1, "", &v12);
std::allocator<char>::~allocator(&v12);
}
return a1;
}
| |||
949 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> google::protobuf::compiler::objectivec::GetOptionalDeprecatedAttribute<google::protobuf::EnumDescriptor>(google::protobuf::EnumDescriptor const*, google::protobuf::FileDescriptor const*, bool, bool) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/compiler/objectivec/objectivec_helpers.h | std::string GetOptionalDeprecatedAttribute(const TDescriptor* descriptor,
const FileDescriptor* file = NULL,
bool preSpace = true,
bool postNewline = false) {
bool isDeprecated = descriptor->options().deprecated();
// The file is only passed when checking Messages & Enums, so those types
// get tagged. At the moment, it doesn't seem to make sense to tag every
// field or enum value with when the file is deprecated.
bool isFileLevelDeprecation = false;
if (!isDeprecated && file) {
isFileLevelDeprecation = file->options().deprecated();
isDeprecated = isFileLevelDeprecation;
}
if (isDeprecated) {
std::string message;
const FileDescriptor* sourceFile = descriptor->file();
if (isFileLevelDeprecation) {
message = sourceFile->name() + " is deprecated.";
} else {
message = descriptor->full_name() + " is deprecated (see " +
sourceFile->name() + ").";
}
std::string result = std::string("GPB_DEPRECATED_MSG(\"") + message + "\")";
if (preSpace) {
result.insert(0, " ");
}
if (postNewline) {
result.append("\n");
}
return result;
} else {
return "";
}
} | O3 | c | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> google::protobuf::compiler::objectivec::GetOptionalDeprecatedAttribute<google::protobuf::EnumDescriptor>(google::protobuf::EnumDescriptor const*, google::protobuf::FileDescriptor const*, bool, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdi, %rbx
movq 0x18(%rsi), %rax
movb 0x48(%rax), %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
je 0xebcac
testb %al, %al
je 0xebd8e
leaq 0x78(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq 0x10(%rsi), %rax
movq 0x10(%rax), %r15
movq 0x8(%rsi), %rax
leaq 0x58(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %rdi
callq 0x2586a
leaq 0xda6d0(%rip), %rsi # 0x1c632b
leaq 0x48(%rsp), %rdi
callq 0x1f8e0
movl %ebp, 0x4(%rsp)
movq 0x8(%r15), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
leaq 0x48(%rsp), %rdi
callq 0x1f150
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xebe92
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0xebe9a
movq 0x78(%rdx), %rax
cmpb $0x0, 0x9f(%rax)
je 0xebd8e
movl %ebp, 0x4(%rsp)
leaq 0x78(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq 0x10(%rsi), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x2586a
leaq 0xda612(%rip), %rsi # 0x1c631b
leaq 0x8(%rsp), %rdi
callq 0x1f8e0
leaq 0x68(%rsp), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x1f5d0
movq (%r15), %rdi
cmpq %r13, %rdi
je 0xebd32
callq 0x1f4a0
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xda5fe(%rip), %rsi # 0x1c6340
leaq 0xda60b(%rip), %rdx # 0x1c6354
leaq 0x28(%rsp), %rdi
callq 0x250b2
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
leaq 0x28(%rsp), %rdi
callq 0x1f150
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xebdac
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0xebdb3
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xae80d(%rip), %rdx # 0x19a5a9
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x250b2
jmp 0xebe7d
movups (%rcx), %xmm0
movups %xmm0, (%rbp)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0xb2212(%rip), %rsi # 0x19dfe8
callq 0x1f8e0
leaq 0x10(%rbx), %r13
movq %r13, (%rbx)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xebdfd
movq %rdx, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0xebe05
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0xebe2b
callq 0x1f4a0
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0xebe3a
callq 0x1f4a0
testb %r14b, %r14b
je 0xebe58
leaq 0xc9dc8(%rip), %rcx # 0x1b5c0e
movl $0x1, %r8d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1f550
cmpb $0x0, 0x4(%rsp)
je 0xebe6e
leaq 0xc7517(%rip), %rsi # 0x1b337d
movq %rbx, %rdi
callq 0x1f8e0
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0xebe7d
callq 0x1f4a0
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
leaq 0x28(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x1032b8(%rip), %rsi # 0x1ef175
callq 0x1f8e0
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xebee9
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0xebef0
movups (%rcx), %xmm0
movups %xmm0, (%rbp)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %r15
movq %rdx, 0x8(%r15)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x68(%rsp), %rdi
movq %r15, %rsi
callq 0x1f5d0
movq (%r15), %rdi
cmpq %rbp, %rdi
je 0xebf26
callq 0x1f4a0
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0xebf35
callq 0x1f4a0
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
jne 0xebd2d
jmp 0xebd32
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0xebf64
callq 0x1f4a0
jmp 0xebf64
movq %rax, %r14
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
jne 0xebfbb
jmp 0xebfc5
movq %rax, %r14
movq 0x8(%rsp), %rdi
jmp 0xebf93
movq %rax, %r14
movq 0x48(%rsp), %rdi
jmp 0xebf93
jmp 0xebfc2
jmp 0xebfc2
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r13, %rdi
jne 0xebfbb
jmp 0xebfc5
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0xebfb1
callq 0x1f4a0
jmp 0xebfb1
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0xebfc5
callq 0x1f4a0
jmp 0xebfc5
movq %rax, %r14
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0xebfd4
callq 0x1f4a0
movq %r14, %rdi
callq 0x1f860
| _ZN6google8protobuf8compiler10objectivec30GetOptionalDeprecatedAttributeINS0_19EnumValueDescriptorEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPKT_PKNS0_14FileDescriptorEbb:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 88h
mov ebp, r8d
mov r14d, ecx
mov rbx, rdi
mov rax, [rsi+18h]
mov al, [rax+48h]
test rdx, rdx
setz cl
or cl, al
jz loc_EBCAC
test al, al
jz loc_EBD8E
lea r12, [rsp+0B8h+var_40]
mov [r12-10h], r12
mov qword ptr [r12-8], 0
mov byte ptr [r12], 0
mov rax, [rsi+10h]
mov r15, [rax+10h]
mov rax, [rsi+8]
lea r13, [rsp+0B8h+var_60]
mov [r13-10h], r13
mov rsi, [rax+20h]
mov rdx, [rax+28h]
add rdx, rsi
lea rdi, [rsp+0B8h+var_70]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
lea rsi, aIsDeprecatedSe; " is deprecated (see "
lea rdi, [rsp+0B8h+var_70]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov [rsp+0B8h+var_B4], ebp
mov rax, [r15+8]
mov rsi, [rax]
mov rdx, [rax+8]
lea rdi, [rsp+0B8h+var_70]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
lea r13, [rsp+0B8h+var_80]
mov [r13-10h], r13
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz loc_EBE92
mov [rsp+0B8h+var_90], rdx
mov rdx, [rcx]
mov [rsp+0B8h+var_80], rdx
jmp loc_EBE9A
loc_EBCAC:
mov rax, [rdx+78h]
cmp byte ptr [rax+9Fh], 0
jz loc_EBD8E
mov [rsp+0B8h+var_B4], ebp
lea r12, [rsp+0B8h+var_40]
mov [r12-10h], r12
mov qword ptr [r12-8], 0
mov byte ptr [r12], 0
mov rax, [rsi+10h]
mov rax, [rax+10h]
mov rax, [rax+8]
lea r13, [rsp+0B8h+var_A0]
mov [r13-10h], r13
mov rsi, [rax]
mov rdx, [rax+8]
add rdx, rsi
lea rdi, [rsp+0B8h+var_B0]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
lea rsi, aIsDeprecated; " is deprecated."
lea rdi, [rsp+0B8h+var_B0]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea rdi, [rsp+0B8h+var_50]
lea r15, [rsp+0B8h+var_B0]
mov rsi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, [r15]; void *
cmp rdi, r13
jz short loc_EBD32
loc_EBD2D:
call __ZdlPv; operator delete(void *)
loc_EBD32:
lea r15, [rsp+0B8h+var_80]
mov [r15-10h], r15
lea rsi, aGpbDeprecatedM; "GPB_DEPRECATED_MSG(\""
lea rdx, aGpbDeprecatedM+14h; ""
lea rdi, [rsp+0B8h+var_90]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rsi, [rsp+0B8h+var_50]
mov rdx, [rsp+0B8h+var_48]
lea rdi, [rsp+0B8h+var_90]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
lea rbp, [rsp+0B8h+var_A0]
mov [rbp-10h], rbp
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_EBDAC
mov [rsp+0B8h+var_B0], rdx
mov rdx, [rcx]
mov [rsp+0B8h+var_A0], rdx
jmp short loc_EBDB3
loc_EBD8E:
lea rax, [rbx+10h]
mov [rbx], rax
lea rdx, asc_19A5A7+2; ""
mov rdi, rbx
mov rsi, rdx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
jmp loc_EBE7D
loc_EBDAC:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [rbp+0], xmm0
loc_EBDB3:
mov rdx, [rax+8]
lea rdi, [rsp+0B8h+var_B0]
mov [rdi+8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
lea rsi, a1_1+4; "\")"
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea r13, [rbx+10h]
mov [rbx], r13
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_EBDFD
mov [rbx], rdx
mov rdx, [rcx]
mov [rbx+10h], rdx
jmp short loc_EBE05
loc_EBDFD:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r13+0], xmm0
loc_EBE05:
mov rdx, [rax+8]
mov [rbx+8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
mov rdi, [rsp+0B8h+var_B0]; void *
cmp rdi, rbp
jz short loc_EBE2B
call __ZdlPv; operator delete(void *)
loc_EBE2B:
mov rdi, [rsp+0B8h+var_90]; void *
cmp rdi, r15
jz short loc_EBE3A
call __ZdlPv; operator delete(void *)
loc_EBE3A:
test r14b, r14b
jz short loc_EBE58
lea rcx, aProtobufFieldO_9+36h; " "
mov r8d, 1
mov rdi, rbx
xor esi, esi
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7replaceEmmPKcm; std::string::replace(ulong,ulong,char const*,ulong)
loc_EBE58:
cmp byte ptr [rsp+0B8h+var_B4], 0
jz short loc_EBE6E
lea rsi, aConstProtoNsMe_0+0E5h; "\n"
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
loc_EBE6E:
mov rdi, [rsp+0B8h+var_50]; void *
cmp rdi, r12
jz short loc_EBE7D
call __ZdlPv; operator delete(void *)
loc_EBE7D:
mov rax, rbx
add rsp, 88h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_EBE92:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r13+0], xmm0
loc_EBE9A:
mov rdx, [rax+8]
lea rdi, [rsp+0B8h+var_90]
mov [rdi+8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
lea rsi, aExpectedTopLev+2Ch; ")."
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea rbp, [rsp+0B8h+var_A0]
mov [rbp-10h], rbp
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_EBEE9
mov [rsp+0B8h+var_B0], rdx
mov rdx, [rcx]
mov [rsp+0B8h+var_A0], rdx
jmp short loc_EBEF0
loc_EBEE9:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [rbp+0], xmm0
loc_EBEF0:
mov rdx, [rax+8]
lea r15, [rsp+0B8h+var_B0]
mov [r15+8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
lea rdi, [rsp+0B8h+var_50]
mov rsi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, [r15]; void *
cmp rdi, rbp
jz short loc_EBF26
call __ZdlPv; operator delete(void *)
loc_EBF26:
mov rdi, [rsp+0B8h+var_90]; void *
cmp rdi, r13
jz short loc_EBF35
call __ZdlPv; operator delete(void *)
loc_EBF35:
mov rdi, [rsp+0B8h+var_70]
lea rax, [rsp+0B8h+var_60]
cmp rdi, rax
jnz loc_EBD2D
jmp loc_EBD32
mov r14, rax
mov rdi, [rsp+arg_20]; void *
cmp rdi, r13
jz short loc_EBF64
call __ZdlPv; operator delete(void *)
jmp short loc_EBF64
mov r14, rax
loc_EBF64:
mov rdi, [rsp+arg_40]
lea rax, [rsp+arg_50]
cmp rdi, rax
jnz short loc_EBFBB
jmp short loc_EBFC5
mov r14, rax
mov rdi, [rsp+arg_0]
jmp short loc_EBF93
mov r14, rax
mov rdi, [rsp+arg_40]
jmp short loc_EBF93
jmp short loc_EBFC2
jmp short loc_EBFC2
mov r14, rax
mov rdi, [rbx]
loc_EBF93:
cmp rdi, r13
jnz short loc_EBFBB
jmp short loc_EBFC5
mov r14, rax
mov rdi, [rsp+arg_0]; void *
cmp rdi, rbp
jz short loc_EBFB1
call __ZdlPv; operator delete(void *)
jmp short loc_EBFB1
mov r14, rax
loc_EBFB1:
mov rdi, [rsp+arg_20]; void *
cmp rdi, r15
jz short loc_EBFC5
loc_EBFBB:
call __ZdlPv; operator delete(void *)
jmp short loc_EBFC5
loc_EBFC2:
mov r14, rax
loc_EBFC5:
mov rdi, [rsp+arg_60]; void *
cmp rdi, r12
jz short loc_EBFD4
call __ZdlPv; operator delete(void *)
loc_EBFD4:
mov rdi, r14
call __Unwind_Resume
| long long google::protobuf::compiler::objectivec::GetOptionalDeprecatedAttribute<google::protobuf::EnumValueDescriptor>(
long long a1,
_QWORD *a2,
long long a3,
char a4,
char a5)
{
unsigned __int8 v8; // al
long long v9; // r15
long long v10; // rax
long long v11; // rax
__int128 *v12; // rcx
long long v13; // rax
void *v14; // rdi
long long v15; // rax
__int128 *v16; // rcx
long long v17; // rax
_OWORD *v18; // rcx
long long v20; // rax
__int128 *v21; // rcx
char v22; // [rsp+4h] [rbp-B4h]
void *v23; // [rsp+8h] [rbp-B0h] BYREF
long long v24; // [rsp+10h] [rbp-A8h]
__int128 v25; // [rsp+18h] [rbp-A0h] BYREF
void *v26[2]; // [rsp+28h] [rbp-90h] BYREF
__int128 v27; // [rsp+38h] [rbp-80h] BYREF
_QWORD v28[2]; // [rsp+48h] [rbp-70h] BYREF
_BYTE v29[16]; // [rsp+58h] [rbp-60h] BYREF
void *v30; // [rsp+68h] [rbp-50h] BYREF
long long v31; // [rsp+70h] [rbp-48h]
_BYTE v32[64]; // [rsp+78h] [rbp-40h] BYREF
v8 = *(_BYTE *)(a2[3] + 72LL);
if ( v8 | (a3 == 0) )
{
if ( v8 )
{
v30 = v32;
v31 = 0LL;
v32[0] = 0;
v9 = *(_QWORD *)(a2[2] + 16LL);
v10 = a2[1];
v28[0] = v29;
std::string::_M_construct<char *>(
(long long)v28,
*(_BYTE **)(v10 + 32),
*(_QWORD *)(v10 + 32) + *(_QWORD *)(v10 + 40));
std::string::append(v28, " is deprecated (see ");
v22 = a5;
v11 = std::string::_M_append(v28, **(_QWORD **)(v9 + 8), *(_QWORD *)(*(_QWORD *)(v9 + 8) + 8LL));
v26[0] = &v27;
v12 = (__int128 *)(v11 + 16);
if ( *(_QWORD *)v11 == v11 + 16 )
{
v27 = *v12;
}
else
{
v26[0] = *(void **)v11;
*(_QWORD *)&v27 = *(_QWORD *)v12;
}
v26[1] = *(void **)(v11 + 8);
*(_QWORD *)v11 = v12;
*(_QWORD *)(v11 + 8) = 0LL;
*(_BYTE *)(v11 + 16) = 0;
v20 = std::string::append(v26, ").");
v23 = &v25;
v21 = (__int128 *)(v20 + 16);
if ( *(_QWORD *)v20 == v20 + 16 )
{
v25 = *v21;
}
else
{
v23 = *(void **)v20;
*(_QWORD *)&v25 = *(_QWORD *)v21;
}
v24 = *(_QWORD *)(v20 + 8);
*(_QWORD *)v20 = v21;
*(_QWORD *)(v20 + 8) = 0LL;
*(_BYTE *)(v20 + 16) = 0;
std::string::operator=(&v30, &v23);
if ( v23 != &v25 )
operator delete(v23);
if ( v26[0] != &v27 )
operator delete(v26[0]);
v14 = (void *)v28[0];
if ( (_BYTE *)v28[0] == v29 )
goto LABEL_8;
goto LABEL_7;
}
LABEL_10:
*(_QWORD *)a1 = a1 + 16;
std::string::_M_construct<char const*>(a1, "", (long long)"");
return a1;
}
if ( !*(_BYTE *)(*(_QWORD *)(a3 + 120) + 159LL) )
goto LABEL_10;
v22 = a5;
v30 = v32;
v31 = 0LL;
v32[0] = 0;
v13 = *(_QWORD *)(*(_QWORD *)(a2[2] + 16LL) + 8LL);
v23 = &v25;
std::string::_M_construct<char *>((long long)&v23, *(_BYTE **)v13, *(_QWORD *)v13 + *(_QWORD *)(v13 + 8));
std::string::append(&v23, " is deprecated.");
std::string::operator=(&v30, &v23);
v14 = v23;
if ( v23 != &v25 )
LABEL_7:
operator delete(v14);
LABEL_8:
v26[0] = &v27;
std::string::_M_construct<char const*>((long long)v26, "GPB_DEPRECATED_MSG(\"", (long long)"");
v15 = std::string::_M_append(v26, v30, v31);
v23 = &v25;
v16 = (__int128 *)(v15 + 16);
if ( *(_QWORD *)v15 == v15 + 16 )
{
v25 = *v16;
}
else
{
v23 = *(void **)v15;
*(_QWORD *)&v25 = *(_QWORD *)v16;
}
v24 = *(_QWORD *)(v15 + 8);
*(_QWORD *)v15 = v16;
*(_QWORD *)(v15 + 8) = 0LL;
*(_BYTE *)(v15 + 16) = 0;
v17 = std::string::append(&v23, "\")");
*(_QWORD *)a1 = a1 + 16;
v18 = (_OWORD *)(v17 + 16);
if ( *(_QWORD *)v17 == v17 + 16 )
{
*(_OWORD *)(a1 + 16) = *v18;
}
else
{
*(_QWORD *)a1 = *(_QWORD *)v17;
*(_QWORD *)(a1 + 16) = *(_QWORD *)v18;
}
*(_QWORD *)(a1 + 8) = *(_QWORD *)(v17 + 8);
*(_QWORD *)v17 = v18;
*(_QWORD *)(v17 + 8) = 0LL;
*(_BYTE *)(v17 + 16) = 0;
if ( v23 != &v25 )
operator delete(v23);
if ( v26[0] != &v27 )
operator delete(v26[0]);
if ( a4 )
std::string::replace(a1, 0LL, 0LL, " ", 1LL);
if ( v22 )
std::string::append(a1, "\n");
if ( v30 != v32 )
operator delete(v30);
return a1;
}
| GetOptionalDeprecatedAttribute<google::protobuf::EnumValueDescriptor>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x88
MOV EBP,R8D
MOV R14D,ECX
MOV RBX,RDI
MOV RAX,qword ptr [RSI + 0x18]
MOV AL,byte ptr [RAX + 0x48]
TEST RDX,RDX
SETZ CL
OR CL,AL
JZ 0x001ebcac
TEST AL,AL
JZ 0x001ebd8e
LEA R12,[RSP + 0x78]
MOV qword ptr [R12 + -0x10],R12
MOV qword ptr [R12 + -0x8],0x0
MOV byte ptr [R12],0x0
MOV RAX,qword ptr [RSI + 0x10]
MOV R15,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RSI + 0x8]
LEA R13,[RSP + 0x58]
MOV qword ptr [R13 + -0x10],R13
MOV RSI,qword ptr [RAX + 0x20]
MOV RDX,qword ptr [RAX + 0x28]
ADD RDX,RSI
LAB_001ebc4a:
LEA RDI,[RSP + 0x48]
CALL 0x0012586a
LAB_001ebc54:
LEA RSI,[0x2c632b]
LEA RDI,[RSP + 0x48]
CALL 0x0011f8e0
MOV dword ptr [RSP + 0x4],EBP
MOV RAX,qword ptr [R15 + 0x8]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
LAB_001ebc74:
LEA RDI,[RSP + 0x48]
CALL 0x0011f150
LEA R13,[RSP + 0x38]
MOV qword ptr [R13 + -0x10],R13
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x001ebe92
MOV qword ptr [RSP + 0x28],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x38],RDX
JMP 0x001ebe9a
LAB_001ebcac:
MOV RAX,qword ptr [RDX + 0x78]
CMP byte ptr [RAX + 0x9f],0x0
JZ 0x001ebd8e
MOV dword ptr [RSP + 0x4],EBP
LEA R12,[RSP + 0x78]
MOV qword ptr [R12 + -0x10],R12
MOV qword ptr [R12 + -0x8],0x0
MOV byte ptr [R12],0x0
MOV RAX,qword ptr [RSI + 0x10]
MOV RAX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RAX + 0x8]
LEA R13,[RSP + 0x18]
MOV qword ptr [R13 + -0x10],R13
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
ADD RDX,RSI
LAB_001ebcf8:
LEA RDI,[RSP + 0x8]
CALL 0x0012586a
LAB_001ebd02:
LEA RSI,[0x2c631b]
LEA RDI,[RSP + 0x8]
CALL 0x0011f8e0
LEA RDI,[RSP + 0x68]
LEA R15,[RSP + 0x8]
MOV RSI,R15
CALL 0x0011f5d0
MOV RDI,qword ptr [R15]
CMP RDI,R13
JZ 0x001ebd32
LAB_001ebd2d:
CALL 0x0011f4a0
LAB_001ebd32:
LEA R15,[RSP + 0x38]
MOV qword ptr [R15 + -0x10],R15
LAB_001ebd3b:
LEA RSI,[0x2c6340]
LEA RDX,[0x2c6354]
LEA RDI,[RSP + 0x28]
CALL 0x001250b2
MOV RSI,qword ptr [RSP + 0x68]
MOV RDX,qword ptr [RSP + 0x70]
LAB_001ebd5d:
LEA RDI,[RSP + 0x28]
CALL 0x0011f150
LAB_001ebd67:
LEA RBP,[RSP + 0x18]
MOV qword ptr [RBP + -0x10],RBP
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x001ebdac
MOV qword ptr [RSP + 0x8],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x18],RDX
JMP 0x001ebdb3
LAB_001ebd8e:
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
LEA RDX,[0x29a5a9]
MOV RDI,RBX
MOV RSI,RDX
CALL 0x001250b2
JMP 0x001ebe7d
LAB_001ebdac:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RBP],XMM0
LAB_001ebdb3:
MOV RDX,qword ptr [RAX + 0x8]
LEA RDI,[RSP + 0x8]
MOV qword ptr [RDI + 0x8],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
LAB_001ebdcf:
LEA RSI,[0x29dfe8]
CALL 0x0011f8e0
LEA R13,[RBX + 0x10]
MOV qword ptr [RBX],R13
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x001ebdfd
MOV qword ptr [RBX],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RBX + 0x10],RDX
JMP 0x001ebe05
LAB_001ebdfd:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [R13],XMM0
LAB_001ebe05:
MOV RDX,qword ptr [RAX + 0x8]
MOV qword ptr [RBX + 0x8],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,RBP
JZ 0x001ebe2b
CALL 0x0011f4a0
LAB_001ebe2b:
MOV RDI,qword ptr [RSP + 0x28]
CMP RDI,R15
JZ 0x001ebe3a
CALL 0x0011f4a0
LAB_001ebe3a:
TEST R14B,R14B
JZ 0x001ebe58
LAB_001ebe3f:
LEA RCX,[0x2b5c0e]
MOV R8D,0x1
MOV RDI,RBX
XOR ESI,ESI
XOR EDX,EDX
CALL 0x0011f550
LAB_001ebe58:
CMP byte ptr [RSP + 0x4],0x0
JZ 0x001ebe6e
LEA RSI,[0x2b337d]
MOV RDI,RBX
CALL 0x0011f8e0
LAB_001ebe6e:
MOV RDI,qword ptr [RSP + 0x68]
CMP RDI,R12
JZ 0x001ebe7d
CALL 0x0011f4a0
LAB_001ebe7d:
MOV RAX,RBX
ADD RSP,0x88
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001ebe92:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [R13],XMM0
LAB_001ebe9a:
MOV RDX,qword ptr [RAX + 0x8]
LEA RDI,[RSP + 0x28]
MOV qword ptr [RDI + 0x8],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
LAB_001ebeb6:
LEA RSI,[0x2ef175]
CALL 0x0011f8e0
LAB_001ebec2:
LEA RBP,[RSP + 0x18]
MOV qword ptr [RBP + -0x10],RBP
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x001ebee9
MOV qword ptr [RSP + 0x8],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x18],RDX
JMP 0x001ebef0
LAB_001ebee9:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RBP],XMM0
LAB_001ebef0:
MOV RDX,qword ptr [RAX + 0x8]
LEA R15,[RSP + 0x8]
MOV qword ptr [R15 + 0x8],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
LEA RDI,[RSP + 0x68]
MOV RSI,R15
CALL 0x0011f5d0
MOV RDI,qword ptr [R15]
CMP RDI,RBP
JZ 0x001ebf26
CALL 0x0011f4a0
LAB_001ebf26:
MOV RDI,qword ptr [RSP + 0x28]
CMP RDI,R13
JZ 0x001ebf35
CALL 0x0011f4a0
LAB_001ebf35:
MOV RDI,qword ptr [RSP + 0x48]
LEA RAX,[RSP + 0x58]
CMP RDI,RAX
JNZ 0x001ebd2d
JMP 0x001ebd32
|
/* std::__cxx11::string
google::protobuf::compiler::objectivec::GetOptionalDeprecatedAttribute<google::protobuf::EnumValueDescriptor>(google::protobuf::EnumValueDescriptor
const*, google::protobuf::FileDescriptor const*, bool, bool) */
objectivec * __thiscall
google::protobuf::compiler::objectivec::
GetOptionalDeprecatedAttribute<google::protobuf::EnumValueDescriptor>
(objectivec *this,EnumValueDescriptor *param_1,FileDescriptor *param_2,bool param_3,
bool param_4)
{
long lVar1;
long lVar2;
long *plVar3;
long *plVar4;
long *local_b0;
long local_a8;
long local_a0;
long lStack_98;
long *local_90;
long local_88;
long local_80;
long lStack_78;
long *local_70 [2];
long local_60 [2];
int1 *local_50;
int8 local_48;
int1 local_40 [16];
if (param_2 == (FileDescriptor *)0x0 || *(char *)(*(long *)(param_1 + 0x18) + 0x48) != '\0') {
if (*(char *)(*(long *)(param_1 + 0x18) + 0x48) == '\0') {
LAB_001ebd8e:
*(objectivec **)this = this + 0x10;
std::__cxx11::string::_M_construct<char_const*>(this,&DAT_0029a5a9);
return this;
}
local_50 = local_40;
local_48 = 0;
local_40[0] = 0;
lVar1 = *(long *)(*(long *)(param_1 + 0x10) + 0x10);
local_70[0] = local_60;
lVar2 = *(long *)(*(long *)(param_1 + 8) + 0x20);
/* try { // try from 001ebc4a to 001ebc53 has its CatchHandler @ 001ebf8b */
std::__cxx11::string::_M_construct<char*>
(local_70,lVar2,*(long *)(*(long *)(param_1 + 8) + 0x28) + lVar2);
/* try { // try from 001ebc54 to 001ebc64 has its CatchHandler @ 001ebf7f */
std::__cxx11::string::append((char *)local_70);
/* try { // try from 001ebc74 to 001ebc7d has its CatchHandler @ 001ebf61 */
plVar3 = (long *)std::__cxx11::string::_M_append((char *)local_70,**(ulong **)(lVar1 + 8));
plVar4 = plVar3 + 2;
if ((long *)*plVar3 == plVar4) {
local_80 = *plVar4;
lStack_78 = plVar3[3];
local_90 = &local_80;
}
else {
local_80 = *plVar4;
local_90 = (long *)*plVar3;
}
local_88 = plVar3[1];
*plVar3 = (long)plVar4;
plVar3[1] = 0;
*(int1 *)(plVar3 + 2) = 0;
/* try { // try from 001ebeb6 to 001ebec1 has its CatchHandler @ 001ebf4d */
plVar3 = (long *)std::__cxx11::string::append((char *)&local_90);
plVar4 = plVar3 + 2;
if ((long *)*plVar3 == plVar4) {
local_a0 = *plVar4;
lStack_98 = plVar3[3];
local_b0 = &local_a0;
}
else {
local_a0 = *plVar4;
local_b0 = (long *)*plVar3;
}
local_a8 = plVar3[1];
*plVar3 = (long)plVar4;
plVar3[1] = 0;
*(int1 *)(plVar3 + 2) = 0;
std::__cxx11::string::operator=((string *)&local_50,(string *)&local_b0);
if (local_b0 != &local_a0) {
operator_delete(local_b0);
}
if (local_90 != &local_80) {
operator_delete(local_90);
}
plVar3 = local_70[0];
if (local_70[0] == local_60) goto LAB_001ebd32;
}
else {
if (*(char *)(*(long *)(param_2 + 0x78) + 0x9f) == '\0') goto LAB_001ebd8e;
local_50 = local_40;
local_48 = 0;
local_40[0] = 0;
plVar3 = *(long **)(*(long *)(*(long *)(param_1 + 0x10) + 0x10) + 8);
lVar1 = *plVar3;
/* try { // try from 001ebcf8 to 001ebd01 has its CatchHandler @ 001ebf89 */
local_b0 = &local_a0;
std::__cxx11::string::_M_construct<char*>(&local_b0,lVar1,plVar3[1] + lVar1);
/* try { // try from 001ebd02 to 001ebd12 has its CatchHandler @ 001ebf75 */
std::__cxx11::string::append((char *)&local_b0);
std::__cxx11::string::operator=((string *)&local_50,(string *)&local_b0);
plVar3 = local_b0;
if (local_b0 == &local_a0) goto LAB_001ebd32;
}
operator_delete(plVar3);
LAB_001ebd32:
/* try { // try from 001ebd3b to 001ebd52 has its CatchHandler @ 001ebfc2 */
local_90 = &local_80;
std::__cxx11::string::_M_construct<char_const*>(&local_90,"GPB_DEPRECATED_MSG(\"","");
/* try { // try from 001ebd5d to 001ebd66 has its CatchHandler @ 001ebfae */
plVar3 = (long *)std::__cxx11::string::_M_append((char *)&local_90,(ulong)local_50);
plVar4 = plVar3 + 2;
if ((long *)*plVar3 == plVar4) {
local_a0 = *plVar4;
lStack_98 = plVar3[3];
local_b0 = &local_a0;
}
else {
local_a0 = *plVar4;
local_b0 = (long *)*plVar3;
}
local_a8 = plVar3[1];
*plVar3 = (long)plVar4;
plVar3[1] = 0;
*(int1 *)(plVar3 + 2) = 0;
/* try { // try from 001ebdcf to 001ebdda has its CatchHandler @ 001ebf9a */
plVar3 = (long *)std::__cxx11::string::append((char *)&local_b0);
*(objectivec **)this = this + 0x10;
plVar4 = plVar3 + 2;
if ((long *)*plVar3 == plVar4) {
lVar1 = plVar3[3];
*(long *)(this + 0x10) = *plVar4;
*(long *)(this + 0x18) = lVar1;
}
else {
*(long **)this = (long *)*plVar3;
*(long *)(this + 0x10) = *plVar4;
}
*(long *)(this + 8) = plVar3[1];
*plVar3 = (long)plVar4;
plVar3[1] = 0;
*(int1 *)(plVar3 + 2) = 0;
if (local_b0 != &local_a0) {
operator_delete(local_b0);
}
if (local_90 != &local_80) {
operator_delete(local_90);
}
if (param_3) {
/* try { // try from 001ebe3f to 001ebe6d has its CatchHandler @ 001ebf8d */
std::__cxx11::string::replace((ulong)this,0,(char *)0x0,0x2b5c0e);
}
if (param_4) {
std::__cxx11::string::append((char *)this);
}
if (local_50 != local_40) {
operator_delete(local_50);
}
return this;
}
|
|
950 | mysql_real_connect_start_internal | eloqsql/libmariadb/libmariadb/mariadb_async.c | static void
mysql_real_connect_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_real_connect,
(parms->mysql, parms->host, parms->user, parms->passwd, parms->db,
parms->port, parms->unix_socket, parms->client_flags),
parms->mysql,
MYSQL *,
r_ptr)
} | O3 | c | mysql_real_connect_start_internal:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq (%rdi), %rax
movq 0x8(%rdi), %rsi
movq 0x480(%rax), %rcx
movq 0x28(%rcx), %rbx
movq 0x10(%rdi), %rdx
movq 0x18(%rdi), %rcx
movq 0x20(%rdi), %r8
movl 0x28(%rdi), %r9d
movups 0x30(%rdi), %xmm0
movups %xmm0, (%rsp)
movq %rax, %rdi
callq 0x18c12
movq %rax, 0x8(%rbx)
movl $0x0, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
| mysql_real_connect_start_internal:
push rbp
mov rbp, rsp
push rbx
sub rsp, 18h
mov rax, [rdi]
mov rsi, [rdi+8]
mov rcx, [rax+480h]
mov rbx, [rcx+28h]
mov rdx, [rdi+10h]
mov rcx, [rdi+18h]
mov r8, [rdi+20h]
mov r9d, [rdi+28h]
movups xmm0, xmmword ptr [rdi+30h]
movups [rsp+20h+var_20], xmm0
mov rdi, rax
call mysql_real_connect
mov [rbx+8], rax
mov dword ptr [rbx], 0
add rsp, 18h
pop rbx
pop rbp
retn
| long long mysql_real_connect_start_internal(
__m128 *a1,
double a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9)
{
long long v9; // rbx
long long result; // rax
v9 = *(_QWORD *)(*(_QWORD *)(a1->m128_u64[0] + 1152) + 40LL);
result = mysql_real_connect(
a1->m128_u64[0],
a1->m128_i64[1],
a1[1].m128_i64[0],
a1[1].m128_i64[1],
a1[2].m128_i64[0],
a1[2].m128_u32[2],
a1[3],
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a1[3].m128_i64[0],
a1[3].m128_i64[1]);
*(_QWORD *)(v9 + 8) = result;
*(_DWORD *)v9 = 0;
return result;
}
| mysql_real_connect_start_internal:
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x18
MOV RAX,qword ptr [RDI]
MOV RSI,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RAX + 0x480]
MOV RBX,qword ptr [RCX + 0x28]
MOV RDX,qword ptr [RDI + 0x10]
MOV RCX,qword ptr [RDI + 0x18]
MOV R8,qword ptr [RDI + 0x20]
MOV R9D,dword ptr [RDI + 0x28]
MOVUPS XMM0,xmmword ptr [RDI + 0x30]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,RAX
CALL 0x00118c12
MOV qword ptr [RBX + 0x8],RAX
MOV dword ptr [RBX],0x0
ADD RSP,0x18
POP RBX
POP RBP
RET
|
void mysql_real_connect_start_internal(long *param_1)
{
int4 *puVar1;
int8 uVar2;
puVar1 = *(int4 **)(*(long *)(*param_1 + 0x480) + 0x28);
uVar2 = mysql_real_connect(*param_1,param_1[1],param_1[2],param_1[3],param_1[4],(int)param_1[5],
(int)param_1[6],(int)param_1[7]);
*(int8 *)(puVar1 + 2) = uVar2;
*puVar1 = 0;
return;
}
|
|
951 | HttpClient::human_readable_size[abi:cxx11](long) | llama.cpp/examples/run/run.cpp | static std::string human_readable_size(curl_off_t size) {
static const char * suffix[] = { "B", "KB", "MB", "GB", "TB" };
char length = sizeof(suffix) / sizeof(suffix[0]);
int i = 0;
double dbl_size = size;
if (size > 1024) {
for (i = 0; (size / 1024) > 0 && i < length - 1; i++, size /= 1024) {
dbl_size = size / 1024.0;
}
}
return string_format("%.2f %s", dbl_size, suffix[i]);
} | O3 | cpp | HttpClient::human_readable_size[abi:cxx11](long):
pushq %rbx
movq %rdi, %rbx
cmpq $0x401, %rsi # imm = 0x401
jl 0x304c9
xorl %ecx, %ecx
movq %rsi, %rdx
leaq 0x1(%rcx), %rax
cmpq $0x100000, %rsi # imm = 0x100000
jb 0x304ba
movq %rdx, %rsi
shrq $0xa, %rsi
cmpl $0x3, %ecx
movq %rax, %rcx
jb 0x3049b
cvtsi2sd %rdx, %xmm0
mulsd 0x99161(%rip), %xmm0 # 0xc9628
jmp 0x304d0
cvtsi2sd %rsi, %xmm0
xorl %eax, %eax
leaq 0xdb3b9(%rip), %rcx # 0x10b890
movq (%rcx,%rax,8), %rdx
leaq 0x9aa72(%rip), %rsi # 0xcaf54
movq %rbx, %rdi
movb $0x1, %al
callq 0xb1243
movq %rbx, %rax
popq %rbx
retq
nop
| _ZN10HttpClient19human_readable_sizeB5cxx11El:
push rbx
mov rbx, rdi
cmp rsi, 401h
jl short loc_304C9
xor ecx, ecx
loc_3049B:
mov rdx, rsi
lea rax, [rcx+1]
cmp rsi, offset unk_100000
jb short loc_304BA
mov rsi, rdx
shr rsi, 0Ah
cmp ecx, 3
mov rcx, rax
jb short loc_3049B
loc_304BA:
cvtsi2sd xmm0, rdx
mulsd xmm0, cs:qword_C9628
jmp short loc_304D0
loc_304C9:
cvtsi2sd xmm0, rsi
xor eax, eax
loc_304D0:
lea rcx, _ZZN10HttpClient19human_readable_sizeB5cxx11ElE6suffix; HttpClient::human_readable_size(long)::suffix
mov rdx, [rcx+rax*8]
lea rsi, a2fS; "%.2f %s"
mov rdi, rbx
mov al, 1
call _Z13string_formatB5cxx11PKcz; string_format(char const*,...)
mov rax, rbx
pop rbx
retn
| long long HttpClient::human_readable_size[abi:cxx11](
long long a1,
long long a2,
long long a3,
long long a4,
int a5,
int a6)
{
long long v6; // rcx
long long v7; // rax
if ( a2 < 1025 )
{
v7 = 0LL;
}
else
{
v6 = 0LL;
do
{
v7 = v6 + 1;
if ( a2 < (unsigned long long)&unk_100000 )
break;
a2 = (unsigned long long)a2 >> 10;
}
while ( (unsigned int)v6++ < 3 );
}
string_format[abi:cxx11](
a1,
(unsigned int)"%.2f %s",
(unsigned int)*(&HttpClient::human_readable_size[abi:cxx11](long)::suffix + v7),
(unsigned int)&HttpClient::human_readable_size[abi:cxx11](long)::suffix,
a5,
a6);
return a1;
}
| human_readable_size[abi:cxx11]:
PUSH RBX
MOV RBX,RDI
CMP RSI,0x401
JL 0x001304c9
XOR ECX,ECX
LAB_0013049b:
MOV RDX,RSI
LEA RAX,[RCX + 0x1]
CMP RSI,0x100000
JC 0x001304ba
MOV RSI,RDX
SHR RSI,0xa
CMP ECX,0x3
MOV RCX,RAX
JC 0x0013049b
LAB_001304ba:
CVTSI2SD XMM0,RDX
MULSD XMM0,qword ptr [0x001c9628]
JMP 0x001304d0
LAB_001304c9:
CVTSI2SD XMM0,RSI
XOR EAX,EAX
LAB_001304d0:
LEA RCX,[0x20b890]
MOV RDX,qword ptr [RCX + RAX*0x8]
LEA RSI,[0x1caf54]
MOV RDI,RBX
MOV AL,0x1
CALL 0x001b1243
MOV RAX,RBX
POP RBX
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* HttpClient::human_readable_size[abi:cxx11](long) */
HttpClient * __thiscall HttpClient::human_readable_size_abi_cxx11_(HttpClient *this,long param_1)
{
long lVar1;
uint uVar2;
long lVar3;
ulong uVar4;
double dVar5;
if (param_1 < 0x401) {
dVar5 = (double)param_1;
lVar1 = 0;
}
else {
lVar3 = 0;
do {
uVar4 = param_1;
lVar1 = lVar3 + 1;
if (uVar4 < 0x100000) break;
uVar2 = (uint)lVar3;
lVar3 = lVar1;
param_1 = uVar4 >> 10;
} while (uVar2 < 3);
dVar5 = (double)(long)uVar4 * _DAT_001c9628;
}
string_format_abi_cxx11_
((char *)this,dVar5,"%.2f %s",(&human_readable_size[abi:cxx11](long)::suffix)[lVar1]);
return this;
}
|
|
952 | my_fill_ucs2 | eloqsql/strings/ctype-ucs2.c | static void
my_fill_ucs2(CHARSET_INFO *cs __attribute__((unused)),
char *s, size_t l, int fill)
{
DBUG_ASSERT(fill <= 0xFFFF);
#ifdef WAITING_FOR_GCC_VECTORIZATION_BUG_TO_BE_FIXED
/*
This code with int2store() is known to be faster on some processors,
but crashes on other processors due to a possible bug in GCC's
-ftree-vectorization (which is enabled in -O3) in case of
a non-aligned memory. See here for details:
http://gcc.gnu.org/bugzilla/show_bug.cgi?id=58039
*/
char *last= s + l - 2;
uint16 tmp= (fill >> 8) + ((fill & 0xFF) << 8); /* swap bytes */
DBUG_ASSERT(fill <= 0xFFFF);
for ( ; s <= last; s+= 2)
int2store(s, tmp); /* store little-endian */
#else
for ( ; l >= 2; s[0]= (fill >> 8), s[1]= (fill & 0xFF), s+= 2, l-= 2);
#endif
} | O0 | c | my_fill_ucs2:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
jmp 0x930d5
jmp 0x930d7
cmpq $0x2, -0x18(%rbp)
jb 0x93119
jmp 0x930e0
movl -0x1c(%rbp), %eax
sarl $0x8, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl -0x1c(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
subq $0x2, %rax
movq %rax, -0x18(%rbp)
jmp 0x930d7
popq %rbp
retq
nopl (%rax,%rax)
| my_fill_ucs2:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
jmp short $+2
loc_930D5:
jmp short $+2
loc_930D7:
cmp [rbp+var_18], 2
jb short loc_93119
jmp short $+2
loc_930E0:
mov eax, [rbp+var_1C]
sar eax, 8
mov cl, al
mov rax, [rbp+var_10]
mov [rax], cl
mov eax, [rbp+var_1C]
and eax, 0FFh
mov cl, al
mov rax, [rbp+var_10]
mov [rax+1], cl
mov rax, [rbp+var_10]
add rax, 2
mov [rbp+var_10], rax
mov rax, [rbp+var_18]
sub rax, 2
mov [rbp+var_18], rax
jmp short loc_930D7
loc_93119:
pop rbp
retn
| unsigned long long my_fill_ucs2(long long a1, _BYTE *a2, unsigned long long a3, __int16 a4)
{
unsigned long long result; // rax
while ( a3 >= 2 )
{
*a2 = HIBYTE(a4);
a2[1] = a4;
a2 += 2;
result = a3 - 2;
a3 -= 2LL;
}
return result;
}
| my_fill_ucs2:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
JMP 0x001930d5
LAB_001930d5:
JMP 0x001930d7
LAB_001930d7:
CMP qword ptr [RBP + -0x18],0x2
JC 0x00193119
JMP 0x001930e0
LAB_001930e0:
MOV EAX,dword ptr [RBP + -0x1c]
SAR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],CL
MOV EAX,dword ptr [RBP + -0x1c]
AND EAX,0xff
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x1],CL
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x2
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,0x2
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001930d7
LAB_00193119:
POP RBP
RET
|
void my_fill_ucs2(int8 param_1,int1 *param_2,ulong param_3,int4 param_4)
{
ulong local_20;
int1 *local_18;
local_18 = param_2;
for (local_20 = param_3; 1 < local_20; local_20 = local_20 - 2) {
*local_18 = (char)((uint)param_4 >> 8);
local_18[1] = (char)param_4;
local_18 = local_18 + 2;
}
return;
}
|
|
953 | uf_space_endspace | eloqsql/storage/maria/ma_packrec.c | static void uf_space_endspace(MARIA_COLUMNDEF *rec, MARIA_BIT_BUFF *bit_buff,
uchar *to, uchar *end)
{
uint spaces;
if (get_bit(bit_buff))
bfill(to, (end-to), ' ');
else
{
if ((spaces=get_bits(bit_buff,rec->space_length_bits))+to > end)
{
bit_buff->error=1;
return;
}
if (to+spaces != end)
decode_bytes(rec,bit_buff,to,end-spaces);
bfill(end - spaces, spaces, ' ');
}
} | O3 | c | uf_space_endspace:
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 0x3bc79
movl (%r15), %r12d
decl %eax
movl %eax, 0x4(%r15)
btl %eax, %r12d
jae 0x3bc96
subq %r14, %rbx
movq %r14, %rdi
movl $0x20, %esi
movq %rbx, %rdx
jmp 0x3bd46
movq %r15, %rdi
callq 0x3b6dc
movl $0x1f, 0x4(%r15)
movl (%r15), %r12d
movl $0x1f, %eax
testl %r12d, %r12d
js 0x3bc66
movq %r13, %rdx
movl 0x24(%r13), %r13d
movl %eax, %ecx
subl %r13d, %ecx
movq %rdx, -0x30(%rbp)
jae 0x3bce2
subl %eax, %r13d
movl %eax, %eax
leaq 0xa675c(%rip), %rcx # 0xe2410
andl (%rcx,%rax,4), %r12d
movl %r13d, %ecx
shll %cl, %r12d
movq %r15, %rdi
callq 0x3b6dc
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 0x3bcf7
movl %ecx, 0x4(%r15)
shrl %cl, %r12d
movl 0x24(%rdx), %eax
leaq 0xa671d(%rip), %rcx # 0xe2410
andl (%rcx,%rax,4), %r12d
movl %r12d, %r13d
leaq (%r14,%r13), %rax
cmpq %rbx, %rax
jbe 0x3bd1a
movl $0x1, 0x28(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %r12
negq %r12
cmpq %rbx, %rax
je 0x3bd38
leaq (%rbx,%r12), %rcx
movq -0x30(%rbp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3b899
addq %r12, %rbx
movq %rbx, %rdi
movl $0x20, %esi
movq %r13, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x292c0
| uf_space_endspace:
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_3BC79
mov r12d, [r15]
dec eax
mov [r15+4], eax
bt r12d, eax
jnb short loc_3BC96
loc_3BC66:
sub rbx, r14
mov rdi, r14
mov esi, 20h ; ' '
mov rdx, rbx
jmp loc_3BD46
loc_3BC79:
mov rdi, r15
call fill_buffer
mov dword ptr [r15+4], 1Fh
mov r12d, [r15]
mov eax, 1Fh
test r12d, r12d
js short loc_3BC66
loc_3BC96:
mov rdx, r13
mov r13d, [r13+24h]
mov ecx, eax
sub ecx, r13d
mov [rbp+var_30], rdx
jnb short loc_3BCE2
sub r13d, eax
mov eax, eax
lea rcx, mask
and r12d, [rcx+rax*4]
mov ecx, r13d
shl r12d, cl
mov rdi, r15
call fill_buffer
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_3BCF7
loc_3BCE2:
mov [r15+4], ecx
shr r12d, cl
mov eax, [rdx+24h]
lea rcx, mask
and r12d, [rcx+rax*4]
loc_3BCF7:
mov r13d, r12d
lea rax, [r14+r13]
cmp rax, rbx
jbe short loc_3BD1A
mov dword ptr [r15+28h], 1
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3BD1A:
mov r12, r13
neg r12
cmp rax, rbx
jz short loc_3BD38
lea rcx, [rbx+r12]
mov rdi, [rbp+var_30]
mov rsi, r15
mov rdx, r14
call decode_bytes
loc_3BD38:
add rbx, r12
mov rdi, rbx
mov esi, 20h ; ' '
mov rdx, r13
loc_3BD46:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _memset
| unsigned long long uf_space_endspace(long long a1, unsigned int *a2, _BYTE *a3, unsigned long long a4)
{
unsigned int v6; // eax
unsigned int v7; // r12d
unsigned int v8; // eax
unsigned long long result; // rax
unsigned int v10; // r13d
unsigned int v11; // ecx
int v12; // r13d
int v13; // r12d
unsigned int v14; // r12d
v6 = a2[1];
if ( v6 )
{
v7 = *a2;
v8 = v6 - 1;
a2[1] = v8;
if ( _bittest((const int *)&v7, v8) )
return memset(a3, 32LL, a4 - (_QWORD)a3);
}
else
{
fill_buffer((long long)a2);
a2[1] = 31;
v7 = *a2;
v8 = 31;
if ( (*a2 & 0x80000000) != 0 )
return memset(a3, 32LL, a4 - (_QWORD)a3);
}
v10 = *(_DWORD *)(a1 + 36);
v11 = v8 - v10;
if ( v8 >= v10 )
{
a2[1] = v11;
v14 = mask[*(unsigned int *)(a1 + 36)] & (v7 >> v11);
}
else
{
v12 = v10 - v8;
v13 = (mask[v8] & v7) << v12;
fill_buffer((long long)a2);
a2[1] = 32 - v12;
v14 = (*a2 >> -(char)v12) + v13;
}
result = (unsigned long long)&a3[v14];
if ( result <= a4 )
{
if ( result != a4 )
decode_bytes(a1, (long long)a2, a3, (_BYTE *)(a4 - v14));
return memset(a4 - v14, 32LL, v14);
}
else
{
a2[10] = 1;
}
return result;
}
| uf_space_endspace:
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 0x0013bc79
MOV R12D,dword ptr [R15]
DEC EAX
MOV dword ptr [R15 + 0x4],EAX
BT R12D,EAX
JNC 0x0013bc96
LAB_0013bc66:
SUB RBX,R14
MOV RDI,R14
MOV ESI,0x20
MOV RDX,RBX
JMP 0x0013bd46
LAB_0013bc79:
MOV RDI,R15
CALL 0x0013b6dc
MOV dword ptr [R15 + 0x4],0x1f
MOV R12D,dword ptr [R15]
MOV EAX,0x1f
TEST R12D,R12D
JS 0x0013bc66
LAB_0013bc96:
MOV RDX,R13
MOV R13D,dword ptr [R13 + 0x24]
MOV ECX,EAX
SUB ECX,R13D
MOV qword ptr [RBP + -0x30],RDX
JNC 0x0013bce2
SUB R13D,EAX
MOV EAX,EAX
LEA RCX,[0x1e2410]
AND R12D,dword ptr [RCX + RAX*0x4]
MOV ECX,R13D
SHL R12D,CL
MOV RDI,R15
CALL 0x0013b6dc
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 0x0013bcf7
LAB_0013bce2:
MOV dword ptr [R15 + 0x4],ECX
SHR R12D,CL
MOV EAX,dword ptr [RDX + 0x24]
LEA RCX,[0x1e2410]
AND R12D,dword ptr [RCX + RAX*0x4]
LAB_0013bcf7:
MOV R13D,R12D
LEA RAX,[R14 + R13*0x1]
CMP RAX,RBX
JBE 0x0013bd1a
MOV dword ptr [R15 + 0x28],0x1
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013bd1a:
MOV R12,R13
NEG R12
CMP RAX,RBX
JZ 0x0013bd38
LEA RCX,[RBX + R12*0x1]
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,R15
MOV RDX,R14
CALL 0x0013b899
LAB_0013bd38:
ADD RBX,R12
MOV RDI,RBX
MOV ESI,0x20
MOV RDX,R13
LAB_0013bd46:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x001292c0
|
void uf_space_endspace(long param_1,uint *param_2,void *param_3,ulong param_4)
{
uint uVar1;
uint uVar2;
uint uVar3;
byte bVar4;
size_t __n;
uint uVar5;
if (param_2[1] == 0) {
fill_buffer(param_2);
param_2[1] = 0x1f;
uVar5 = *param_2;
uVar3 = 0x1f;
if (-1 < (int)uVar5) goto LAB_0013bc96;
}
else {
uVar5 = *param_2;
uVar3 = param_2[1] - 1;
param_2[1] = uVar3;
if ((uVar5 >> (uVar3 & 0x1f) & 1) == 0) {
LAB_0013bc96:
uVar1 = *(uint *)(param_1 + 0x24);
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 + 0x24)];
}
__n = (size_t)uVar5;
if (param_4 < (long)param_3 + __n) {
param_2[10] = 1;
return;
}
if ((long)param_3 + __n != param_4) {
decode_bytes(param_1,param_2,param_3,param_4 + -__n);
}
param_3 = (void *)(param_4 + -__n);
goto LAB_0013bd46;
}
}
__n = param_4 - (long)param_3;
LAB_0013bd46:
memset(param_3,0x20,__n);
return;
}
|
|
954 | cleanup_statement_class() | eloqsql/storage/perfschema/pfs_instr_class.cc | void cleanup_statement_class(void)
{
PFS_FREE_ARRAY(& builtin_memory_statement_class,
statement_class_max, sizeof(PFS_statement_class),
statement_class_array);
statement_class_array= NULL;
statement_class_dirty_count= statement_class_allocated_count= 0;
statement_class_max= 0;
} | O3 | cpp | cleanup_statement_class():
pushq %rbp
movq %rsp, %rbp
movq 0x39730e(%rip), %rsi # 0x3d28a0
movq 0x397b9f(%rip), %rcx # 0x3d3138
leaq 0x3950a0(%rip), %rdi # 0x3d0640
movl $0xc0, %edx
callq 0x2cd84
xorl %eax, %eax
movq %rax, 0x397b85(%rip) # 0x3d3138
movl %eax, 0x397b77(%rip) # 0x3d3130
movl %eax, 0x397b75(%rip) # 0x3d3134
movq %rax, 0x3972da(%rip) # 0x3d28a0
popq %rbp
retq
| _Z23cleanup_statement_classv:
push rbp
mov rbp, rsp
mov rsi, cs:statement_class_max
mov rcx, cs:_ZL21statement_class_array; statement_class_array
lea rdi, builtin_memory_statement_class
mov edx, 0C0h
call _Z14pfs_free_arrayP24PFS_builtin_memory_classmmPv; pfs_free_array(PFS_builtin_memory_class *,ulong,ulong,void *)
xor eax, eax
mov cs:_ZL21statement_class_array, rax; statement_class_array
mov cs:_ZL31statement_class_allocated_count, eax; statement_class_allocated_count
mov cs:_ZL27statement_class_dirty_count, eax; statement_class_dirty_count
mov cs:statement_class_max, rax
pop rbp
retn
| long long cleanup_statement_class(void)
{
long long result; // rax
pfs_free_array((long long)&builtin_memory_statement_class, statement_class_max, 192LL, statement_class_array);
result = 0LL;
statement_class_array = 0LL;
statement_class_allocated_count = 0;
statement_class_dirty_count = 0;
statement_class_max = 0LL;
return result;
}
| cleanup_statement_class:
PUSH RBP
MOV RBP,RSP
MOV RSI,qword ptr [0x004d28a0]
MOV RCX,qword ptr [0x004d3138]
LEA RDI,[0x4d0640]
MOV EDX,0xc0
CALL 0x0012cd84
XOR EAX,EAX
MOV qword ptr [0x004d3138],RAX
MOV dword ptr [0x004d3130],EAX
MOV dword ptr [0x004d3134],EAX
MOV qword ptr [0x004d28a0],RAX
POP RBP
RET
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* cleanup_statement_class() */
void cleanup_statement_class(void)
{
pfs_free_array((PFS_builtin_memory_class *)builtin_memory_statement_class,statement_class_max,0xc0
,statement_class_array);
statement_class_array = (void *)0x0;
statement_class_allocated_count = 0;
statement_class_dirty_count = 0;
statement_class_max = 0;
return;
}
|
|
955 | nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::json_sax_dom_callback_parser(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, std::function<bool (int, nlohmann::json_abi_v3_11_3::detail::parse_event_t, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__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) | monkey531[P]llama/common/./json.hpp | json_sax_dom_callback_parser(BasicJsonType& r,
const parser_callback_t cb,
const bool allow_exceptions_ = true)
: root(r), callback(cb), allow_exceptions(allow_exceptions_)
{
keep_stack.push_back(true);
} | O0 | cpp | nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::json_sax_dom_callback_parser(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, std::function<bool (int, nlohmann::json_abi_v3_11_3::detail::parse_event_t, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__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):
subq $0x88, %rsp
movq %rdx, 0x48(%rsp)
movb %cl, %al
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
andb $0x1, %al
movb %al, 0x6f(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x78(%rsp), %rcx
movq %rcx, (%rax)
movq %rax, %rdi
addq $0x8, %rdi
movq %rdi, 0x10(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movups %xmm0, 0x8(%rax)
movq $0x0, 0x18(%rax)
callq 0xb6020
movaps 0x20(%rsp), %xmm0
movq 0x40(%rsp), %rax
movq %rax, %rdi
addq $0x20, %rdi
movq %rdi, 0x18(%rsp)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movq $0x0, 0x40(%rax)
callq 0xb6030
movaps 0x20(%rsp), %xmm0
movq 0x40(%rsp), %rax
movq %rax, %rdi
addq $0x48, %rdi
movq %rdi, 0x38(%rsp)
movups %xmm0, 0x58(%rax)
movups %xmm0, 0x48(%rax)
movq $0x0, 0x68(%rax)
callq 0xb6030
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq $0x0, 0x70(%rdi)
movb $0x0, 0x78(%rdi)
subq $-0x80, %rdi
movq %rdi, 0x50(%rsp)
callq 0xae710
jmp 0xb150c
movq 0x40(%rsp), %rdi
movb 0x6f(%rsp), %al
andb $0x1, %al
movb %al, 0xa0(%rdi)
addq $0xa8, %rdi
movq %rdi, 0x8(%rsp)
movl $0x9, %esi
callq 0xb3dd0
jmp 0xb1535
movq 0x40(%rsp), %rdi
addq $0x20, %rdi
movl $0x1, %esi
callq 0xb6040
jmp 0xb154a
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0xb1594
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0xb158a
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
callq 0x6e0f0
movq 0x50(%rsp), %rdi
callq 0xae4b0
movq 0x38(%rsp), %rdi
callq 0xb6120
movq 0x18(%rsp), %rdi
callq 0xb6120
movq 0x10(%rsp), %rdi
callq 0xb6130
movq 0x60(%rsp), %rdi
callq 0x50940
nopl (%rax)
| _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEC2ERSF_St8functionIFbiNS1_13parse_event_tESH_EEb:
sub rsp, 88h
mov [rsp+88h+var_40], rdx
mov al, cl
mov [rsp+88h+var_8], rdi
mov [rsp+88h+var_10], rsi
mov [rsp+88h+var_18], rdx
and al, 1
mov [rsp+88h+var_19], al
mov rax, [rsp+88h+var_8]
mov [rsp+88h+var_48], rax
mov rcx, [rsp+88h+var_10]
mov [rax], rcx
mov rdi, rax
add rdi, 8
mov [rsp+88h+var_78], rdi
xorps xmm0, xmm0
movaps [rsp+88h+var_68], xmm0
movups xmmword ptr [rax+8], xmm0
mov qword ptr [rax+18h], 0
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EEC2Ev; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<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> *>>::vector(void)
movaps xmm0, [rsp+88h+var_68]
mov rax, [rsp+88h+var_48]
mov rdi, rax
add rdi, 20h ; ' '
mov [rsp+88h+var_70], rdi
movups xmmword ptr [rax+30h], xmm0
movups xmmword ptr [rax+20h], xmm0
mov qword ptr [rax+40h], 0
call _ZNSt6vectorIbSaIbEEC2Ev; std::vector<bool>::vector(void)
movaps xmm0, [rsp+88h+var_68]
mov rax, [rsp+88h+var_48]
mov rdi, rax
add rdi, 48h ; 'H'
mov [rsp+88h+var_50], rdi
movups xmmword ptr [rax+58h], xmm0
movups xmmword ptr [rax+48h], xmm0
mov qword ptr [rax+68h], 0
call _ZNSt6vectorIbSaIbEEC2Ev; std::vector<bool>::vector(void)
mov rdi, [rsp+88h+var_48]
mov rsi, [rsp+88h+var_40]
mov qword ptr [rdi+70h], 0
mov byte ptr [rdi+78h], 0
sub rdi, 0FFFFFFFFFFFFFF80h
mov [rsp+88h+var_38], rdi
call _ZNSt8functionIFbiN8nlohmann16json_abi_v3_11_36detail13parse_event_tERNS1_10basic_jsonINS1_11ordered_mapESt6vectorNSt7__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<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> &)>::function(std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)> const&)
jmp short $+2
loc_B150C:
mov rdi, [rsp+88h+var_48]
mov al, [rsp+88h+var_19]
and al, 1
mov [rdi+0A0h], al
add rdi, 0A8h
mov [rsp+88h+var_80], rdi
mov esi, 9
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ENS0_6detail7value_tE; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::detail::value_t)
jmp short $+2
loc_B1535:
mov rdi, [rsp+88h+var_48]
add rdi, 20h ; ' '
mov esi, 1
call _ZNSt6vectorIbSaIbEE9push_backEb; std::vector<bool>::push_back(bool)
jmp short $+2
loc_B154A:
add rsp, 88h
retn
mov rcx, rax
mov eax, edx
mov [rsp+arg_58], rcx
mov [rsp+arg_54], eax
jmp short loc_B1594
mov rcx, rax
mov eax, edx
mov [rsp+arg_58], rcx
mov [rsp+arg_54], eax
jmp short loc_B158A
mov rdi, [rsp+arg_0]
mov rcx, rax
mov eax, edx
mov [rsp+arg_58], rcx
mov [rsp+arg_54], eax
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
loc_B158A:
mov rdi, [rsp+arg_48]
call _ZNSt8functionIFbiN8nlohmann16json_abi_v3_11_36detail13parse_event_tERNS1_10basic_jsonINS1_11ordered_mapESt6vectorNSt7__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<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> &)>::~function()
loc_B1594:
mov rdi, [rsp+arg_30]
call _ZNSt6vectorIbSaIbEED2Ev; std::vector<bool>::~vector()
mov rdi, [rsp+arg_10]
call _ZNSt6vectorIbSaIbEED2Ev; std::vector<bool>::~vector()
mov rdi, [rsp+arg_8]
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EED2Ev; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<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> *>>::~vector()
mov rdi, [rsp+arg_58]
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::json_sax_dom_callback_parser(
long long a1,
long long a2,
long long a3,
char a4)
{
char v6; // [rsp+6Fh] [rbp-19h]
v6 = a4 & 1;
*(_QWORD *)a1 = a2;
*(_OWORD *)(a1 + 8) = 0LL;
*(_QWORD *)(a1 + 24) = 0LL;
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<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> *>>::vector();
*(_OWORD *)(a1 + 48) = 0LL;
*(_OWORD *)(a1 + 32) = 0LL;
*(_QWORD *)(a1 + 64) = 0LL;
std::vector<bool>::vector();
*(_OWORD *)(a1 + 88) = 0LL;
*(_OWORD *)(a1 + 72) = 0LL;
*(_QWORD *)(a1 + 104) = 0LL;
std::vector<bool>::vector();
*(_QWORD *)(a1 + 112) = 0LL;
*(_BYTE *)(a1 + 120) = 0;
std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> &)>::function(
(std::_Function_base *)(a1 + 128),
a3);
*(_BYTE *)(a1 + 160) = v6 & 1;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(
a1 + 168,
9LL);
return std::vector<bool>::push_back(a1 + 32, 1LL);
}
| json_sax_dom_callback_parser:
SUB RSP,0x88
MOV qword ptr [RSP + 0x48],RDX
MOV AL,CL
MOV qword ptr [RSP + 0x80],RDI
MOV qword ptr [RSP + 0x78],RSI
MOV qword ptr [RSP + 0x70],RDX
AND AL,0x1
MOV byte ptr [RSP + 0x6f],AL
MOV RAX,qword ptr [RSP + 0x80]
MOV qword ptr [RSP + 0x40],RAX
MOV RCX,qword ptr [RSP + 0x78]
MOV qword ptr [RAX],RCX
MOV RDI,RAX
ADD RDI,0x8
MOV qword ptr [RSP + 0x10],RDI
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOVUPS xmmword ptr [RAX + 0x8],XMM0
MOV qword ptr [RAX + 0x18],0x0
CALL 0x001b6020
MOVAPS XMM0,xmmword ptr [RSP + 0x20]
MOV RAX,qword ptr [RSP + 0x40]
MOV RDI,RAX
ADD RDI,0x20
MOV qword ptr [RSP + 0x18],RDI
MOVUPS xmmword ptr [RAX + 0x30],XMM0
MOVUPS xmmword ptr [RAX + 0x20],XMM0
MOV qword ptr [RAX + 0x40],0x0
CALL 0x001b6030
MOVAPS XMM0,xmmword ptr [RSP + 0x20]
MOV RAX,qword ptr [RSP + 0x40]
MOV RDI,RAX
ADD RDI,0x48
MOV qword ptr [RSP + 0x38],RDI
MOVUPS xmmword ptr [RAX + 0x58],XMM0
MOVUPS xmmword ptr [RAX + 0x48],XMM0
MOV qword ptr [RAX + 0x68],0x0
CALL 0x001b6030
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x48]
MOV qword ptr [RDI + 0x70],0x0
MOV byte ptr [RDI + 0x78],0x0
SUB RDI,-0x80
MOV qword ptr [RSP + 0x50],RDI
LAB_001b1505:
CALL 0x001ae710
JMP 0x001b150c
LAB_001b150c:
MOV RDI,qword ptr [RSP + 0x40]
MOV AL,byte ptr [RSP + 0x6f]
AND AL,0x1
MOV byte ptr [RDI + 0xa0],AL
ADD RDI,0xa8
MOV qword ptr [RSP + 0x8],RDI
LAB_001b1529:
MOV ESI,0x9
CALL 0x001b3dd0
JMP 0x001b1535
LAB_001b1535:
MOV RDI,qword ptr [RSP + 0x40]
ADD RDI,0x20
LAB_001b153e:
MOV ESI,0x1
CALL 0x001b6040
LAB_001b1548:
JMP 0x001b154a
LAB_001b154a:
ADD RSP,0x88
RET
|
/* nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>
>::json_sax_dom_callback_parser(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>&, std::function<bool (int, nlohmann::json_abi_v3_11_3::detail::parse_event_t,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__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) */
void __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::json_sax_dom_callback_parser
(json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this,int8 param_1,function *param_3,byte param_4)
{
*(int8 *)this = param_1;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::vector((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x40) = 0;
std::vector<bool,std::allocator<bool>>::vector((vector<bool,std::allocator<bool>> *)(this + 0x20))
;
*(int8 *)(this + 0x58) = 0;
*(int8 *)(this + 0x60) = 0;
*(int8 *)(this + 0x48) = 0;
*(int8 *)(this + 0x50) = 0;
*(int8 *)(this + 0x68) = 0;
std::vector<bool,std::allocator<bool>>::vector((vector<bool,std::allocator<bool>> *)(this + 0x48))
;
*(int8 *)(this + 0x70) = 0;
this[0x78] = (json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
)0x0;
/* try { // try from 001b1505 to 001b1509 has its CatchHandler @ 001b1552 */
std::
function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__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((function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__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 + 0x80),param_3);
this[0xa0] = (json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
)(param_4 & 1);
/* try { // try from 001b1529 to 001b1532 has its CatchHandler @ 001b1562 */
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)(this + 0xa8),9);
/* try { // try from 001b153e to 001b1547 has its CatchHandler @ 001b1572 */
std::vector<bool,std::allocator<bool>>::push_back
((vector<bool,std::allocator<bool>> *)(this + 0x20),true);
return;
}
|
|
956 | my_interval_timer | eloqsql/mysys/my_getsystime.c | ulonglong my_interval_timer()
{
#ifdef HAVE_CLOCK_GETTIME
struct timespec tp;
clock_gettime(CLOCK_MONOTONIC, &tp);
return tp.tv_sec*1000000000ULL+tp.tv_nsec;
#elif defined(HAVE_GETHRTIME)
return gethrtime();
#elif defined(_WIN32)
DBUG_ASSERT(query_performance_frequency);
LARGE_INTEGER t_cnt;
QueryPerformanceCounter(&t_cnt);
return (t_cnt.QuadPart / query_performance_frequency * 1000000000ULL) +
((t_cnt.QuadPart % query_performance_frequency) * 1000000000ULL /
query_performance_frequency);
#else
/* TODO: check for other possibilities for hi-res timestamping */
struct timeval tv;
gettimeofday(&tv,NULL);
return tv.tv_sec*1000000000ULL+tv.tv_usec*1000ULL;
#endif
} | O3 | c | my_interval_timer:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
leaq -0x18(%rbp), %rbx
movl $0x1, %edi
movq %rbx, %rsi
callq 0x28330
imulq $0x3b9aca00, (%rbx), %rax # imm = 0x3B9ACA00
addq 0x8(%rbx), %rax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
| my_interval_timer:
push rbp
mov rbp, rsp
push rbx
sub rsp, 18h
lea rbx, [rbp+var_18]
mov edi, 1
mov rsi, rbx
call _clock_gettime
imul rax, [rbx], 3B9ACA00h
add rax, [rbx+8]
add rsp, 18h
pop rbx
pop rbp
retn
| long long my_interval_timer()
{
_QWORD v1[3]; // [rsp+8h] [rbp-18h] BYREF
clock_gettime(1LL, v1);
return v1[1] + 1000000000LL * v1[0];
}
| my_interval_timer:
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x18
LEA RBX,[RBP + -0x18]
MOV EDI,0x1
MOV RSI,RBX
CALL 0x00128330
IMUL RAX,qword ptr [RBX],0x3b9aca00
ADD RAX,qword ptr [RBX + 0x8]
ADD RSP,0x18
POP RBX
POP RBP
RET
|
long my_interval_timer(void)
{
timespec local_20;
clock_gettime(1,&local_20);
return local_20.tv_sec * 1000000000 + local_20.tv_nsec;
}
|
|
957 | my_hash_sort_utf16_nopad_bin | eloqsql/strings/ctype-ucs2.c | static void
my_hash_sort_utf16_nopad_bin(CHARSET_INFO *cs __attribute__((unused)),
const uchar *pos, size_t len,
ulong *nr1, ulong *nr2)
{
const uchar *end= pos + len;
register ulong m1= *nr1, m2= *nr2;
for ( ; pos < end ; pos++)
{
MY_HASH_ADD(m1, m2, (uint)*pos);
}
*nr1= m1;
*nr2= m2;
} | O3 | c | my_hash_sort_utf16_nopad_bin:
movq (%rcx), %rax
movq (%r8), %rdi
testq %rdx, %rdx
jle 0x68f84
pushq %rbp
movq %rsp, %rbp
addq %rsi, %rdx
movl %eax, %r9d
andl $0x3f, %r9d
addq %rdi, %r9
movzbl (%rsi), %r10d
imulq %r9, %r10
movq %rax, %r9
shlq $0x8, %r9
addq %r10, %r9
xorq %r9, %rax
addq $0x3, %rdi
incq %rsi
cmpq %rdx, %rsi
jb 0x68f58
popq %rbp
movq %rax, (%rcx)
movq %rdi, (%r8)
retq
| my_hash_sort_utf16_nopad_bin:
mov rax, [rcx]
mov rdi, [r8]
test rdx, rdx
jle short loc_68F84
push rbp
mov rbp, rsp
add rdx, rsi
loc_68F58:
mov r9d, eax
and r9d, 3Fh
add r9, rdi
movzx r10d, byte ptr [rsi]
imul r10, r9
mov r9, rax
shl r9, 8
add r9, r10
xor rax, r9
add rdi, 3
inc rsi
cmp rsi, rdx
jb short loc_68F58
pop rbp
loc_68F84:
mov [rcx], rax
mov [r8], rdi
retn
| long long my_hash_sort_utf16_nopad_bin(long long a1, unsigned __int8 *a2, long long a3, long long *a4, long long *a5)
{
long long result; // rax
long long v6; // rdi
unsigned __int8 *v7; // rdx
result = *a4;
v6 = *a5;
if ( a3 > 0 )
{
v7 = &a2[a3];
do
{
result ^= (v6 + (result & 0x3F)) * *a2 + (result << 8);
v6 += 3LL;
++a2;
}
while ( a2 < v7 );
}
*a4 = result;
*a5 = v6;
return result;
}
| my_hash_sort_utf16_nopad_bin:
MOV RAX,qword ptr [RCX]
MOV RDI,qword ptr [R8]
TEST RDX,RDX
JLE 0x00168f84
PUSH RBP
MOV RBP,RSP
ADD RDX,RSI
LAB_00168f58:
MOV R9D,EAX
AND R9D,0x3f
ADD R9,RDI
MOVZX R10D,byte ptr [RSI]
IMUL R10,R9
MOV R9,RAX
SHL R9,0x8
ADD R9,R10
XOR RAX,R9
ADD RDI,0x3
INC RSI
CMP RSI,RDX
JC 0x00168f58
POP RBP
LAB_00168f84:
MOV qword ptr [RCX],RAX
MOV qword ptr [R8],RDI
RET
|
void my_hash_sort_utf16_nopad_bin
(int8 param_1,byte *param_2,long param_3,ulong *param_4,long *param_5)
{
ulong uVar1;
byte *pbVar2;
long lVar3;
uVar1 = *param_4;
lVar3 = *param_5;
if (0 < param_3) {
pbVar2 = param_2 + param_3;
do {
uVar1 = uVar1 ^ uVar1 * 0x100 + (ulong)*param_2 * ((ulong)((uint)uVar1 & 0x3f) + lVar3);
lVar3 = lVar3 + 3;
param_2 = param_2 + 1;
} while (param_2 < pbVar2);
}
*param_4 = uVar1;
*param_5 = lVar3;
return;
}
|
|
958 | string_repeat(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long) | monkey531[P]llama/common/common.cpp | std::string string_repeat(const std::string & str, size_t n) {
if (n == 0) {
return "";
}
std::string result;
result.reserve(str.length() * n);
for (size_t i = 0; i < n; ++i) {
result += str;
}
return result;
} | O3 | cpp | string_repeat(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
testq %rdx, %rdx
je 0x1df1e
movq %rdx, %r14
movq %rsi, %r15
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq 0x8(%rsi), %rsi
imulq %rdx, %rsi
movq %rbx, %rdi
callq 0x18a20
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x181d0
decq %r14
jne 0x1df08
jmp 0x1df30
leaq 0x89ec0(%rip), %rdx # 0xa7de5
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x1ca72
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x1df41
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x1df58
movq (%r12), %rsi
incq %rsi
callq 0x186a0
movq %r14, %rdi
callq 0x18bb0
| _Z13string_repeatRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEm:
push r15
push r14
push r12
push rbx
push rax
mov rbx, rdi
lea r12, [rdi+10h]
mov [rdi], r12
test rdx, rdx
jz short loc_1DF1E
mov r14, rdx
mov r15, rsi
mov qword ptr [rbx+8], 0
mov byte ptr [rbx+10h], 0
mov rsi, [rsi+8]
imul rsi, rdx
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
loc_1DF08:
mov rsi, [r15]
mov rdx, [r15+8]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
dec r14
jnz short loc_1DF08
jmp short loc_1DF30
loc_1DF1E:
lea rdx, aEndIndexOutOfB+19h; ""
mov rdi, rbx
mov rsi, rdx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
loc_1DF30:
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
jmp short $+2
loc_1DF41:
mov r14, rax
mov rdi, [rbx]; void *
cmp rdi, r12
jz short loc_1DF58
mov rsi, [r12]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1DF58:
mov rdi, r14
call __Unwind_Resume
| long long string_repeat(long long a1, _QWORD *a2, long long a3)
{
long long v3; // r14
*(_QWORD *)a1 = a1 + 16;
if ( a3 )
{
v3 = a3;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
std::string::reserve(a1, a3 * a2[1]);
do
{
std::string::_M_append(a1, *a2);
--v3;
}
while ( v3 );
}
else
{
std::string::_M_construct<char const*>(a1, "", (long long)"");
}
return a1;
}
| string_repeat:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
LEA R12,[RDI + 0x10]
MOV qword ptr [RDI],R12
TEST RDX,RDX
JZ 0x0011df1e
MOV R14,RDX
MOV R15,RSI
MOV qword ptr [RBX + 0x8],0x0
MOV byte ptr [RBX + 0x10],0x0
MOV RSI,qword ptr [RSI + 0x8]
IMUL RSI,RDX
LAB_0011df00:
MOV RDI,RBX
CALL 0x00118a20
LAB_0011df08:
MOV RSI,qword ptr [R15]
MOV RDX,qword ptr [R15 + 0x8]
LAB_0011df0f:
MOV RDI,RBX
CALL 0x001181d0
LAB_0011df17:
DEC R14
JNZ 0x0011df08
JMP 0x0011df30
LAB_0011df1e:
LEA RDX,[0x1a7de5]
MOV RDI,RBX
MOV RSI,RDX
CALL 0x0011ca72
LAB_0011df30:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* string_repeat(std::__cxx11::string const&, unsigned long) */
string * string_repeat(string *param_1,ulong param_2)
{
long in_RDX;
*(string **)param_1 = param_1 + 0x10;
if (in_RDX == 0) {
std::__cxx11::string::_M_construct<char_const*>(param_1,"");
}
else {
*(int8 *)(param_1 + 8) = 0;
param_1[0x10] = (string)0x0;
/* try { // try from 0011df00 to 0011df07 has its CatchHandler @ 0011df3f */
std::__cxx11::string::reserve((ulong)param_1);
do {
/* try { // try from 0011df0f to 0011df16 has its CatchHandler @ 0011df41 */
std::__cxx11::string::_M_append((char *)param_1,*(ulong *)param_2);
in_RDX = in_RDX + -1;
} while (in_RDX != 0);
}
return param_1;
}
|
|
959 | update_file_rotations | eloqsql/plugin/server_audit/server_audit.c | static void update_file_rotations(MYSQL_THD thd __attribute__((unused)),
struct st_mysql_sys_var *var __attribute__((unused)),
void *var_ptr __attribute__((unused)), const void *save)
{
rotations= *(unsigned int *) save;
error_header();
fprintf(stderr, "Log file rotations was changed to '%d'.\n", rotations);
if (!logging || output_type != OUTPUT_FILE)
return;
mysql_prlock_wrlock(&lock_operations);
logfile->rotations= rotations;
mysql_prlock_unlock(&lock_operations);
} | O3 | c | update_file_rotations:
pushq %rbp
movq %rsp, %rbp
movl (%rcx), %eax
movl %eax, 0x7ffb(%rip) # 0xf9d0
callq 0x6aaf
movq 0x4617(%rip), %rax # 0xbff8
movq (%rax), %rdi
movl 0x7fe6(%rip), %ecx # 0xf9d0
leaq 0x1edc(%rip), %rdx # 0x98cd
movl $0x1, %esi
xorl %eax, %eax
callq 0x3300
cmpb $0x0, 0x5fec(%rip) # 0xd9f0
je 0x7a52
cmpq $0x1, 0x72fa(%rip) # 0xed08
jne 0x7a52
cmpq $0x0, 0x71b0(%rip) # 0xebc8
jne 0x7a54
leaq 0x713f(%rip), %rdi # 0xeb60
callq 0x30c0
movl 0x7fa4(%rip), %eax # 0xf9d0
movq 0x72dd(%rip), %rcx # 0xed10
movl %eax, 0x210(%rcx)
movq 0x7188(%rip), %rdi # 0xebc8
testq %rdi, %rdi
jne 0x7a5b
leaq 0x7114(%rip), %rdi # 0xeb60
popq %rbp
jmp 0x3110
popq %rbp
retq
callq 0x3473
jmp 0x7a26
movq 0x454e(%rip), %rax # 0xbfb0
movq (%rax), %rax
callq *0x168(%rax)
jmp 0x7a45
| update_file_rotations:
push rbp
mov rbp, rsp
mov eax, [rcx]
mov cs:rotations, eax
call error_header
mov rax, cs:stderr_ptr
mov rdi, [rax]
mov ecx, cs:rotations
lea rdx, aLogFileRotatio; "Log file rotations was changed to '%d'."...
mov esi, 1
xor eax, eax
call ___fprintf_chk
cmp cs:logging, 0
jz short loc_7A52
cmp cs:output_type, 1
jnz short loc_7A52
cmp cs:qword_EBC8, 0
jnz short loc_7A54
lea rdi, lock_operations
call _rw_pr_wrlock
loc_7A26:
mov eax, cs:rotations
mov rcx, cs:logfile
mov [rcx+210h], eax
mov rdi, cs:qword_EBC8
test rdi, rdi
jnz short loc_7A5B
loc_7A45:
lea rdi, lock_operations
pop rbp
jmp _rw_pr_unlock
loc_7A52:
pop rbp
retn
loc_7A54:
call update_file_rotations_cold_1
jmp short loc_7A26
loc_7A5B:
mov rax, cs:PSI_server_ptr
mov rax, [rax]
call qword ptr [rax+168h]
jmp short loc_7A45
| long long update_file_rotations(long long a1, long long a2, long long a3, int *a4)
{
long long result; // rax
rotations = *a4;
error_header();
result = __fprintf_chk(stderr, 1LL, "Log file rotations was changed to '%d'.\n", rotations);
if ( logging && output_type == 1 )
{
if ( qword_EBC8 )
update_file_rotations_cold_1();
else
rw_pr_wrlock(&lock_operations);
*(_DWORD *)(logfile + 528) = rotations;
if ( qword_EBC8 )
((void (*)(void))PSI_server[45])();
return rw_pr_unlock(&lock_operations);
}
return result;
}
| update_file_rotations:
PUSH RBP
MOV RBP,RSP
MOV EAX,dword ptr [RCX]
MOV dword ptr [0x0010f9d0],EAX
CALL 0x00106aaf
MOV RAX,qword ptr [0x0010bff8]
MOV RDI,qword ptr [RAX]
MOV ECX,dword ptr [0x0010f9d0]
LEA RDX,[0x1098cd]
MOV ESI,0x1
XOR EAX,EAX
CALL 0x00103300
CMP byte ptr [0x0010d9f0],0x0
JZ 0x00107a52
CMP qword ptr [0x0010ed08],0x1
JNZ 0x00107a52
CMP qword ptr [0x0010ebc8],0x0
JNZ 0x00107a54
LEA RDI,[0x10eb60]
CALL 0x001030c0
LAB_00107a26:
MOV EAX,dword ptr [0x0010f9d0]
MOV RCX,qword ptr [0x0010ed10]
MOV dword ptr [RCX + 0x210],EAX
MOV RDI,qword ptr [0x0010ebc8]
TEST RDI,RDI
JNZ 0x00107a5b
LAB_00107a45:
LEA RDI,[0x10eb60]
POP RBP
JMP 0x00103110
LAB_00107a52:
POP RBP
RET
LAB_00107a54:
CALL 0x00103473
JMP 0x00107a26
LAB_00107a5b:
MOV RAX,qword ptr [0x0010bfb0]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x168]
JMP 0x00107a45
|
void update_file_rotations(void)
{
int4 *in_RCX;
rotations = *in_RCX;
error_header();
__fprintf_chk(*(int8 *)PTR_stderr_0010bff8,1,"Log file rotations was changed to \'%d\'.\n",
rotations);
if ((logging != '\0') && (output_type == 1)) {
if (lock_operations._104_8_ == 0) {
rw_pr_wrlock(lock_operations);
}
else {
update_file_rotations_cold_1();
}
*(int4 *)(logfile + 0x210) = rotations;
if (lock_operations._104_8_ != 0) {
(**(code **)(*(long *)PTR_PSI_server_0010bfb0 + 0x168))();
}
rw_pr_unlock(lock_operations);
return;
}
return;
}
|
|
960 | get_simple_key_cache_statistics | eloqsql/mysys/mf_keycache.c | static
void get_simple_key_cache_statistics(SIMPLE_KEY_CACHE_CB *keycache,
uint partition_no __attribute__((unused)),
KEY_CACHE_STATISTICS *keycache_stats)
{
DBUG_ENTER("simple_get_key_cache_statistics");
keycache_stats->mem_size= (longlong) keycache->key_cache_mem_size;
keycache_stats->block_size= (longlong) keycache->key_cache_block_size;
keycache_stats->blocks_used= keycache->blocks_used;
keycache_stats->blocks_unused= keycache->blocks_unused;
keycache_stats->blocks_changed= keycache->global_blocks_changed;
keycache_stats->blocks_warm= keycache->warm_blocks;
keycache_stats->read_requests= keycache->global_cache_r_requests;
keycache_stats->reads= keycache->global_cache_read;
keycache_stats->write_requests= keycache->global_cache_w_requests;
keycache_stats->writes= keycache->global_cache_write;
DBUG_VOID_RETURN;
} | O0 | c | get_simple_key_cache_statistics:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x138(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x150(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq 0x158(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
movq 0x140(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rax
movq 0x148(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x48(%rax)
jmp 0xe6ca0
popq %rbp
retq
nopw %cs:(%rax,%rax)
| get_simple_key_cache_statistics:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov rax, [rbp+var_8]
mov rcx, [rax+8]
mov rax, [rbp+var_18]
mov [rax], rcx
mov rax, [rbp+var_8]
mov eax, [rax+18h]
mov ecx, eax
mov rax, [rbp+var_18]
mov [rax+8], rcx
mov rax, [rbp+var_8]
mov rcx, [rax+50h]
mov rax, [rbp+var_18]
mov [rax+10h], rcx
mov rax, [rbp+var_8]
mov rcx, [rax+58h]
mov rax, [rbp+var_18]
mov [rax+18h], rcx
mov rax, [rbp+var_8]
mov rcx, [rax+138h]
mov rax, [rbp+var_18]
mov [rax+20h], rcx
mov rax, [rbp+var_8]
mov rcx, [rax+68h]
mov rax, [rbp+var_18]
mov [rax+28h], rcx
mov rax, [rbp+var_8]
mov rcx, [rax+150h]
mov rax, [rbp+var_18]
mov [rax+30h], rcx
mov rax, [rbp+var_8]
mov rcx, [rax+158h]
mov rax, [rbp+var_18]
mov [rax+38h], rcx
mov rax, [rbp+var_8]
mov rcx, [rax+140h]
mov rax, [rbp+var_18]
mov [rax+40h], rcx
mov rax, [rbp+var_8]
mov rcx, [rax+148h]
mov rax, [rbp+var_18]
mov [rax+48h], rcx
jmp short $+2
loc_E6CA0:
pop rbp
retn
| _QWORD * get_simple_key_cache_statistics(long long a1, long long a2, _QWORD *a3)
{
_QWORD *result; // rax
*a3 = *(_QWORD *)(a1 + 8);
a3[1] = *(unsigned int *)(a1 + 24);
a3[2] = *(_QWORD *)(a1 + 80);
a3[3] = *(_QWORD *)(a1 + 88);
a3[4] = *(_QWORD *)(a1 + 312);
a3[5] = *(_QWORD *)(a1 + 104);
a3[6] = *(_QWORD *)(a1 + 336);
a3[7] = *(_QWORD *)(a1 + 344);
a3[8] = *(_QWORD *)(a1 + 320);
result = a3;
a3[9] = *(_QWORD *)(a1 + 328);
return result;
}
| get_simple_key_cache_statistics:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x18]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x50]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x58]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x18],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x138]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x20],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x68]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x28],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x150]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x30],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x158]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x38],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x140]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x40],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x148]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x48],RCX
JMP 0x001e6ca0
LAB_001e6ca0:
POP RBP
RET
|
void get_simple_key_cache_statistics(long param_1,int8 param_2,int8 *param_3)
{
*param_3 = *(int8 *)(param_1 + 8);
param_3[1] = (ulong)*(uint *)(param_1 + 0x18);
param_3[2] = *(int8 *)(param_1 + 0x50);
param_3[3] = *(int8 *)(param_1 + 0x58);
param_3[4] = *(int8 *)(param_1 + 0x138);
param_3[5] = *(int8 *)(param_1 + 0x68);
param_3[6] = *(int8 *)(param_1 + 0x150);
param_3[7] = *(int8 *)(param_1 + 0x158);
param_3[8] = *(int8 *)(param_1 + 0x140);
param_3[9] = *(int8 *)(param_1 + 0x148);
return;
}
|
|
961 | multiple_choice_prepare_one_task(llama_context*, multiple_choice_task&, bool) | monkey531[P]llama/examples/perplexity/perplexity.cpp | static bool multiple_choice_prepare_one_task(llama_context * ctx, multiple_choice_task& task, bool log_error) {
if (task.question.empty() || task.mc1.answers.empty()) {
if (log_error) {
LOG_ERR("%s: found bad task with empty question and/or answers\n", __func__);
}
return false;
}
task.seq_tokens.reserve(task.mc1.answers.size());
for (auto& answer : task.mc1.answers) {
if (answer.empty()) {
if (log_error) {
LOG_ERR("%s: found empty answer\n", __func__);
}
return false;
}
task.seq_tokens.emplace_back(::common_tokenize(ctx, task.question + " " + answer, true));
}
auto min_len = task.seq_tokens.front().size();
for (auto& seq : task.seq_tokens) {
min_len = std::min(min_len, seq.size());
}
task.common_prefix = 0;
for (size_t k = 0; k < min_len; ++k) {
auto token = task.seq_tokens[0][k];
bool all_same = true;
for (size_t i = 1; i < task.seq_tokens.size(); ++i) {
if (task.seq_tokens[i][k] != token) {
all_same = false;
break;
}
}
if (!all_same) {
break;
}
++task.common_prefix;
}
task.required_tokens = task.common_prefix;
for (auto& seq : task.seq_tokens) {
task.required_tokens += seq.size() - task.common_prefix;
}
return true;
} | O0 | cpp | multiple_choice_prepare_one_task(llama_context*, multiple_choice_task&, bool):
subq $0x138, %rsp # imm = 0x138
movb %dl, %al
movq %rdi, 0x128(%rsp)
movq %rsi, 0x120(%rsp)
andb $0x1, %al
movb %al, 0x11f(%rsp)
movq 0x120(%rsp), %rdi
callq 0x5e520
testb $0x1, %al
jne 0x70b5a
movq 0x120(%rsp), %rdi
addq $0x20, %rdi
callq 0x83440
testb $0x1, %al
jne 0x70b5a
jmp 0x70ba6
testb $0x1, 0x11f(%rsp)
je 0x70b99
jmp 0x70b66
xorl %eax, %eax
leaq 0x259af9(%rip), %rcx # 0x2ca668
cmpl (%rcx), %eax
jg 0x70b95
callq 0x1de560
movq %rax, %rdi
movl $0x4, %esi
leaq 0x1b5ec5(%rip), %rdx # 0x226a4c
leaq 0x1b5ef5(%rip), %rcx # 0x226a83
movb $0x0, %al
callq 0x1de650
jmp 0x70b97
jmp 0x70b99
movb $0x0, 0x137(%rsp)
jmp 0x7105d
movq 0x120(%rsp), %rax
addq $0x98, %rax
movq %rax, 0x20(%rsp)
movq 0x120(%rsp), %rdi
addq $0x20, %rdi
callq 0x79ee0
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x83490
movq 0x120(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x110(%rsp)
movq 0x110(%rsp), %rdi
callq 0x7a230
movq %rax, 0x108(%rsp)
movq 0x110(%rsp), %rdi
callq 0x7a9c0
movq %rax, 0x100(%rsp)
leaq 0x108(%rsp), %rdi
leaq 0x100(%rsp), %rsi
callq 0x7bb40
testb $0x1, %al
jne 0x70c33
jmp 0x70ddc
leaq 0x108(%rsp), %rdi
callq 0x82fe0
movq %rax, 0xf8(%rsp)
movq 0xf8(%rsp), %rdi
callq 0x5e520
testb $0x1, %al
jne 0x70c5b
jmp 0x70ca7
testb $0x1, 0x11f(%rsp)
je 0x70c9a
jmp 0x70c67
xorl %eax, %eax
leaq 0x2599f8(%rip), %rcx # 0x2ca668
cmpl (%rcx), %eax
jg 0x70c96
callq 0x1de560
movq %rax, %rdi
movl $0x4, %esi
leaq 0x1b5e1c(%rip), %rdx # 0x226aa4
leaq 0x1b5df4(%rip), %rcx # 0x226a83
movb $0x0, %al
callq 0x1de650
jmp 0x70c98
jmp 0x70c9a
movb $0x0, 0x137(%rsp)
jmp 0x7105d
movq 0x120(%rsp), %rsi
movq %rsi, %rax
addq $0x98, %rax
movq %rax, 0x8(%rsp)
movq 0x128(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x1c0328(%rip), %rdx # 0x230ff9
leaq 0xa0(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x7a050
movq 0x18(%rsp), %rsi
movq 0xf8(%rsp), %rdx
leaq 0xc0(%rsp), %rdi
callq 0x7a000
jmp 0x70cff
movq 0x10(%rsp), %rsi
leaq 0xe0(%rsp), %rdi
leaq 0xc0(%rsp), %rdx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x1124c0
jmp 0x70d23
movq 0x8(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
callq 0x835a0
jmp 0x70d37
leaq 0xe0(%rsp), %rdi
callq 0x771b0
leaq 0xc0(%rsp), %rdi
callq 0x5f628
leaq 0xa0(%rsp), %rdi
callq 0x5f628
leaq 0x108(%rsp), %rdi
callq 0x7bf30
jmp 0x70c15
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x70dca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x70dbd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0xe0(%rsp), %rdi
callq 0x771b0
leaq 0xc0(%rsp), %rdi
callq 0x5f628
leaq 0xa0(%rsp), %rdi
callq 0x5f628
jmp 0x7106e
movq 0x120(%rsp), %rdi
addq $0x98, %rdi
callq 0x83620
movq %rax, %rdi
callq 0x7a120
movq %rax, 0x88(%rsp)
movq 0x120(%rsp), %rax
addq $0x98, %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rdi
callq 0x83650
movq %rax, 0x78(%rsp)
movq 0x80(%rsp), %rdi
callq 0x83680
movq %rax, 0x70(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x836b0
testb $0x1, %al
jne 0x70e4f
jmp 0x70e96
leaq 0x78(%rsp), %rdi
callq 0x836f0
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rdi
callq 0x7a120
movq %rax, 0x60(%rsp)
leaq 0x88(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x77be0
movq (%rax), %rax
movq %rax, 0x88(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x83700
jmp 0x70e3a
movq 0x120(%rsp), %rax
movq $0x0, 0x88(%rax)
movq $0x0, 0x58(%rsp)
movq 0x58(%rsp), %rax
cmpq 0x88(%rsp), %rax
jae 0x70fa4
movq 0x120(%rsp), %rdi
addq $0x98, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x812a0
movq %rax, %rdi
movq 0x58(%rsp), %rsi
callq 0x7a140
movl (%rax), %eax
movl %eax, 0x54(%rsp)
movb $0x1, 0x53(%rsp)
movq $0x1, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movq 0x120(%rsp), %rdi
addq $0x98, %rdi
callq 0x811e0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x70f6e
movq 0x120(%rsp), %rdi
addq $0x98, %rdi
movq 0x48(%rsp), %rsi
callq 0x812a0
movq %rax, %rdi
movq 0x58(%rsp), %rsi
callq 0x7a140
movl (%rax), %eax
cmpl 0x54(%rsp), %eax
je 0x70f5c
movb $0x0, 0x53(%rsp)
jmp 0x70f6e
jmp 0x70f5e
movq 0x48(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x48(%rsp)
jmp 0x70efe
testb $0x1, 0x53(%rsp)
jne 0x70f77
jmp 0x70fa4
movq 0x120(%rsp), %rax
movq 0x88(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x88(%rax)
movq 0x58(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x58(%rsp)
jmp 0x70eb2
movq 0x120(%rsp), %rax
movq 0x88(%rax), %rcx
movq 0x120(%rsp), %rax
movq %rcx, 0x90(%rax)
movq 0x120(%rsp), %rax
addq $0x98, %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x83650
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x83680
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x836b0
testb $0x1, %al
jne 0x71008
jmp 0x71055
leaq 0x38(%rsp), %rdi
callq 0x836f0
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x7a120
movq %rax, %rcx
movq 0x120(%rsp), %rax
subq 0x88(%rax), %rcx
movq 0x120(%rsp), %rax
addq 0x90(%rax), %rcx
movq %rcx, 0x90(%rax)
leaq 0x38(%rsp), %rdi
callq 0x83700
jmp 0x70ff3
movb $0x1, 0x137(%rsp)
movb 0x137(%rsp), %al
andb $0x1, %al
addq $0x138, %rsp # imm = 0x138
retq
movq 0x98(%rsp), %rdi
callq 0x5ec30
nopl (%rax,%rax)
| _ZL32multiple_choice_prepare_one_taskP13llama_contextR20multiple_choice_taskb:
sub rsp, 138h
mov al, dl
mov qword ptr [rsp+138h+var_10], rdi
mov qword ptr [rsp+138h+var_18], rsi
and al, 1
mov [rsp+138h+var_19], al
mov rdi, qword ptr [rsp+138h+var_18]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5emptyEv; std::string::empty(void)
test al, 1
jnz short loc_70B5A
mov rdi, qword ptr [rsp+138h+var_18]
add rdi, 20h ; ' '
call _ZNKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE5emptyEv; std::vector<std::string>::empty(void)
test al, 1
jnz short loc_70B5A
jmp short loc_70BA6
loc_70B5A:
test [rsp+138h+var_19], 1
jz short loc_70B99
jmp short $+2
loc_70B66:
xor eax, eax
lea rcx, common_log_verbosity_thold
cmp eax, [rcx]
jg short loc_70B95
call _Z15common_log_mainv; common_log_main(void)
mov rdi, rax
mov esi, 4
lea rdx, aSFoundBadTaskW; "%s: found bad task with empty question "...
lea rcx, aMultipleChoice_0; "multiple_choice_prepare_one_task"
mov al, 0
call _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
loc_70B95:
jmp short $+2
loc_70B97:
jmp short $+2
loc_70B99:
mov [rsp+138h+var_1], 0
jmp loc_7105D
loc_70BA6:
mov rax, qword ptr [rsp+138h+var_18]
add rax, 98h
mov [rsp+138h+var_118], rax
mov rdi, qword ptr [rsp+138h+var_18]
add rdi, 20h ; ' '
call _ZNKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE4sizeEv; std::vector<std::string>::size(void)
mov rdi, [rsp+138h+var_118]
mov rsi, rax
call _ZNSt6vectorIS_IiSaIiEESaIS1_EE7reserveEm; std::vector<std::vector<int>>::reserve(ulong)
mov rax, qword ptr [rsp+138h+var_18]
add rax, 20h ; ' '
mov [rsp+138h+var_28], rax
mov rdi, [rsp+138h+var_28]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE5beginEv; std::vector<std::string>::begin(void)
mov [rsp+138h+var_30], rax
mov rdi, [rsp+138h+var_28]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE3endEv; std::vector<std::string>::end(void)
mov [rsp+138h+var_38], rax
loc_70C15:
lea rdi, [rsp+138h+var_30]
lea rsi, [rsp+138h+var_38]
call _ZN9__gnu_cxxneIPNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS6_SaIS6_EEEEbRKNS_17__normal_iteratorIT_T0_EESG_; __gnu_cxx::operator!=<std::string *,std::vector<std::string>>(__gnu_cxx::__normal_iterator<std::string *,std::vector<std::string>> const&,__gnu_cxx::__normal_iterator<std::string *,std::vector<std::string>> const&)
test al, 1
jnz short loc_70C33
jmp loc_70DDC
loc_70C33:
lea rdi, [rsp+138h+var_30]
call _ZNK9__gnu_cxx17__normal_iteratorIPNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS6_SaIS6_EEEdeEv; __gnu_cxx::__normal_iterator<std::string *,std::vector<std::string>>::operator*(void)
mov [rsp+138h+var_40], rax
mov rdi, [rsp+138h+var_40]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5emptyEv; std::string::empty(void)
test al, 1
jnz short loc_70C5B
jmp short loc_70CA7
loc_70C5B:
test [rsp+138h+var_19], 1
jz short loc_70C9A
jmp short $+2
loc_70C67:
xor eax, eax
lea rcx, common_log_verbosity_thold
cmp eax, [rcx]
jg short loc_70C96
call _Z15common_log_mainv; common_log_main(void)
mov rdi, rax
mov esi, 4
lea rdx, aSFoundEmptyAns; "%s: found empty answer\n"
lea rcx, aMultipleChoice_0; "multiple_choice_prepare_one_task"
mov al, 0
call _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
loc_70C96:
jmp short $+2
loc_70C98:
jmp short $+2
loc_70C9A:
mov [rsp+138h+var_1], 0
jmp loc_7105D
loc_70CA7:
mov rsi, qword ptr [rsp+138h+var_18]; int
mov rax, rsi
add rax, 98h
mov [rsp+138h+var_130], rax; void *
mov rax, qword ptr [rsp+138h+var_10]
mov qword ptr [rsp+138h+var_128], rax; int
lea rdx, aForMessageInMe+144h; int
lea rdi, [rsp+138h+var_98]; int
mov [rsp+138h+var_120], rdi; __int64
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EERKS8_PKS5_; std::operator+<char>(std::string const&,char const*)
mov rsi, [rsp+138h+var_120]
mov rdx, [rsp+138h+var_40]
lea rdi, [rsp+138h+var_78]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_RKS8_; std::operator+<char>(std::string&&,std::string const&)
jmp short $+2
loc_70CFF:
mov rsi, qword ptr [rsp+138h+var_128]
lea rdi, [rsp+138h+var_58]
lea rdx, [rsp+138h+var_78]
mov ecx, 1
xor r8d, r8d
call _Z15common_tokenizePK13llama_contextRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbb; common_tokenize(llama_context const*,std::string const&,bool,bool)
jmp short $+2
loc_70D23:
mov rdi, [rsp+138h+var_130]
lea rsi, [rsp+138h+var_58]
call _ZNSt6vectorIS_IiSaIiEESaIS1_EE12emplace_backIJS1_EEERS1_DpOT_; std::vector<std::vector<int>>::emplace_back<std::vector<int>>(std::vector<int> &&)
jmp short $+2
loc_70D37:
lea rdi, [rsp+138h+var_58]
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
lea rdi, [rsp+138h+var_78]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+138h+var_98]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+138h+var_30]
call _ZN9__gnu_cxx17__normal_iteratorIPNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS6_SaIS6_EEEppEv; __gnu_cxx::__normal_iterator<std::string *,std::vector<std::string>>::operator++(void)
jmp loc_70C15
mov rcx, rax
mov eax, edx
mov [rsp+arg_90], rcx
mov [rsp+arg_8C], eax
jmp short loc_70DCA
mov rcx, rax
mov eax, edx
mov [rsp+arg_90], rcx
mov [rsp+arg_8C], eax
jmp short loc_70DBD
mov rcx, rax
mov eax, edx
mov [rsp+arg_90], rcx
mov [rsp+arg_8C], eax
lea rdi, [rsp+arg_D8]
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
loc_70DBD:
lea rdi, [rsp+arg_B8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_70DCA:
lea rdi, [rsp+arg_98]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp loc_7106E
loc_70DDC:
mov rdi, qword ptr [rsp+138h+var_18]
add rdi, 98h
call _ZNSt6vectorIS_IiSaIiEESaIS1_EE5frontEv; std::vector<std::vector<int>>::front(void)
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE4sizeEv; std::vector<int>::size(void)
mov [rsp+138h+var_B0], rax
mov rax, qword ptr [rsp+138h+var_18]
add rax, 98h
mov [rsp+138h+var_B8], rax
mov rdi, [rsp+138h+var_B8]
call _ZNSt6vectorIS_IiSaIiEESaIS1_EE5beginEv; std::vector<std::vector<int>>::begin(void)
mov [rsp+138h+var_C0], rax
mov rdi, [rsp+138h+var_B8]
call _ZNSt6vectorIS_IiSaIiEESaIS1_EE3endEv; std::vector<std::vector<int>>::end(void)
mov [rsp+138h+var_C8], rax
loc_70E3A:
lea rdi, [rsp+138h+var_C0]
lea rsi, [rsp+138h+var_C8]
call _ZN9__gnu_cxxneIPSt6vectorIiSaIiEES1_IS3_SaIS3_EEEEbRKNS_17__normal_iteratorIT_T0_EESC_; __gnu_cxx::operator!=<std::vector<int> *,std::vector<std::vector<int>>>(__gnu_cxx::__normal_iterator<std::vector<int> *,std::vector<std::vector<int>>> const&,__gnu_cxx::__normal_iterator<std::vector<int> *,std::vector<std::vector<int>>> const&)
test al, 1
jnz short loc_70E4F
jmp short loc_70E96
loc_70E4F:
lea rdi, [rsp+138h+var_C0]
call _ZNK9__gnu_cxx17__normal_iteratorIPSt6vectorIiSaIiEES1_IS3_SaIS3_EEEdeEv; __gnu_cxx::__normal_iterator<std::vector<int> *,std::vector<std::vector<int>>>::operator*(void)
mov [rsp+138h+var_D0], rax
mov rdi, [rsp+138h+var_D0]
call _ZNKSt6vectorIiSaIiEE4sizeEv; std::vector<int>::size(void)
mov [rsp+138h+var_D8], rax
lea rdi, [rsp+138h+var_B0]
lea rsi, [rsp+138h+var_D8]
call _ZSt3minImERKT_S2_S2_; std::min<ulong>(ulong const&,ulong const&)
mov rax, [rax]
mov [rsp+138h+var_B0], rax
lea rdi, [rsp+138h+var_C0]
call _ZN9__gnu_cxx17__normal_iteratorIPSt6vectorIiSaIiEES1_IS3_SaIS3_EEEppEv; __gnu_cxx::__normal_iterator<std::vector<int> *,std::vector<std::vector<int>>>::operator++(void)
jmp short loc_70E3A
loc_70E96:
mov rax, qword ptr [rsp+138h+var_18]
mov qword ptr [rax+88h], 0
mov [rsp+138h+var_E0], 0
loc_70EB2:
mov rax, [rsp+138h+var_E0]
cmp rax, [rsp+138h+var_B0]
jnb loc_70FA4
mov rdi, qword ptr [rsp+138h+var_18]
add rdi, 98h
xor eax, eax
mov esi, eax
call _ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm; std::vector<std::vector<int>>::operator[](ulong)
mov rdi, rax
mov rsi, [rsp+138h+var_E0]
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov eax, [rax]
mov [rsp+138h+var_E4], eax
mov [rsp+138h+var_E5], 1
mov [rsp+138h+var_F0], 1
loc_70EFE:
mov rax, [rsp+138h+var_F0]
mov [rsp+138h+var_138], rax
mov rdi, qword ptr [rsp+138h+var_18]
add rdi, 98h
call _ZNKSt6vectorIS_IiSaIiEESaIS1_EE4sizeEv; std::vector<std::vector<int>>::size(void)
mov rcx, rax
mov rax, [rsp+138h+var_138]
cmp rax, rcx
jnb short loc_70F6E
mov rdi, qword ptr [rsp+138h+var_18]
add rdi, 98h
mov rsi, [rsp+138h+var_F0]
call _ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm; std::vector<std::vector<int>>::operator[](ulong)
mov rdi, rax
mov rsi, [rsp+138h+var_E0]
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov eax, [rax]
cmp eax, [rsp+138h+var_E4]
jz short loc_70F5C
mov [rsp+138h+var_E5], 0
jmp short loc_70F6E
loc_70F5C:
jmp short $+2
loc_70F5E:
mov rax, [rsp+138h+var_F0]
add rax, 1
mov [rsp+138h+var_F0], rax
jmp short loc_70EFE
loc_70F6E:
test [rsp+138h+var_E5], 1
jnz short loc_70F77
jmp short loc_70FA4
loc_70F77:
mov rax, qword ptr [rsp+138h+var_18]
mov rcx, [rax+88h]
add rcx, 1
mov [rax+88h], rcx
mov rax, [rsp+138h+var_E0]
add rax, 1
mov [rsp+138h+var_E0], rax
jmp loc_70EB2
loc_70FA4:
mov rax, qword ptr [rsp+138h+var_18]
mov rcx, [rax+88h]
mov rax, qword ptr [rsp+138h+var_18]
mov [rax+90h], rcx
mov rax, qword ptr [rsp+138h+var_18]
add rax, 98h
mov [rsp+138h+var_F8], rax
mov rdi, [rsp+138h+var_F8]
call _ZNSt6vectorIS_IiSaIiEESaIS1_EE5beginEv; std::vector<std::vector<int>>::begin(void)
mov [rsp+138h+var_100], rax
mov rdi, [rsp+138h+var_F8]
call _ZNSt6vectorIS_IiSaIiEESaIS1_EE3endEv; std::vector<std::vector<int>>::end(void)
mov [rsp+138h+var_108], rax
loc_70FF3:
lea rdi, [rsp+138h+var_100]
lea rsi, [rsp+138h+var_108]
call _ZN9__gnu_cxxneIPSt6vectorIiSaIiEES1_IS3_SaIS3_EEEEbRKNS_17__normal_iteratorIT_T0_EESC_; __gnu_cxx::operator!=<std::vector<int> *,std::vector<std::vector<int>>>(__gnu_cxx::__normal_iterator<std::vector<int> *,std::vector<std::vector<int>>> const&,__gnu_cxx::__normal_iterator<std::vector<int> *,std::vector<std::vector<int>>> const&)
test al, 1
jnz short loc_71008
jmp short loc_71055
loc_71008:
lea rdi, [rsp+138h+var_100]
call _ZNK9__gnu_cxx17__normal_iteratorIPSt6vectorIiSaIiEES1_IS3_SaIS3_EEEdeEv; __gnu_cxx::__normal_iterator<std::vector<int> *,std::vector<std::vector<int>>>::operator*(void)
mov [rsp+138h+var_110], rax
mov rdi, [rsp+138h+var_110]
call _ZNKSt6vectorIiSaIiEE4sizeEv; std::vector<int>::size(void)
mov rcx, rax
mov rax, qword ptr [rsp+138h+var_18]
sub rcx, [rax+88h]
mov rax, qword ptr [rsp+138h+var_18]
add rcx, [rax+90h]
mov [rax+90h], rcx
lea rdi, [rsp+138h+var_100]
call _ZN9__gnu_cxx17__normal_iteratorIPSt6vectorIiSaIiEES1_IS3_SaIS3_EEEppEv; __gnu_cxx::__normal_iterator<std::vector<int> *,std::vector<std::vector<int>>>::operator++(void)
jmp short loc_70FF3
loc_71055:
mov [rsp+138h+var_1], 1
loc_7105D:
mov al, [rsp+138h+var_1]
and al, 1
add rsp, 138h
retn
loc_7106E:
mov rdi, [rsp+arg_90]
call __Unwind_Resume
| char multiple_choice_prepare_one_task(long long a1, long long a2, char a3)
{
int v3; // eax
int v4; // r8d
int v5; // r9d
long long v6; // rax
int v7; // ecx
int v8; // r8d
int v9; // r9d
int v10; // eax
int v11; // r8d
int v12; // r9d
long long v13; // rax
long long v14; // rax
long long v15; // rax
long long v16; // rax
int v18; // [rsp+0h] [rbp-138h]
void *v19; // [rsp+8h] [rbp-130h]
int v20[2]; // [rsp+10h] [rbp-128h]
long long v21; // [rsp+18h] [rbp-120h]
long long v22; // [rsp+28h] [rbp-110h]
long long v23; // [rsp+30h] [rbp-108h] BYREF
long long v24; // [rsp+38h] [rbp-100h] BYREF
long long v25; // [rsp+40h] [rbp-F8h]
unsigned long long j; // [rsp+48h] [rbp-F0h]
char v27; // [rsp+53h] [rbp-E5h]
int v28; // [rsp+54h] [rbp-E4h]
unsigned long long i; // [rsp+58h] [rbp-E0h]
long long v30; // [rsp+60h] [rbp-D8h] BYREF
long long v31; // [rsp+68h] [rbp-D0h]
long long v32; // [rsp+70h] [rbp-C8h] BYREF
long long v33; // [rsp+78h] [rbp-C0h] BYREF
long long v34; // [rsp+80h] [rbp-B8h]
unsigned long long v35[3]; // [rsp+88h] [rbp-B0h] BYREF
long long v36[4]; // [rsp+A0h] [rbp-98h] BYREF
_BYTE v37[32]; // [rsp+C0h] [rbp-78h] BYREF
_BYTE v38[24]; // [rsp+E0h] [rbp-58h] BYREF
long long v39; // [rsp+F8h] [rbp-40h]
long long v40; // [rsp+100h] [rbp-38h] BYREF
_QWORD v41[2]; // [rsp+108h] [rbp-30h] BYREF
char v42; // [rsp+11Fh] [rbp-19h]
int v43[2]; // [rsp+120h] [rbp-18h]
int v44[3]; // [rsp+128h] [rbp-10h]
*(_QWORD *)v44 = a1;
*(_QWORD *)v43 = a2;
v42 = a3 & 1;
if ( (std::string::empty(a2) & 1) != 0 || (std::vector<std::string>::empty(*(_QWORD *)v43 + 32LL) & 1) != 0 )
{
if ( (v42 & 1) != 0 && common_log_verbosity_thold >= 0 )
{
v3 = common_log_main();
common_log_add(
v3,
4,
(unsigned int)"%s: found bad task with empty question and/or answers\n",
(unsigned int)"multiple_choice_prepare_one_task",
v4,
v5);
}
return 0;
}
else
{
v6 = std::vector<std::string>::size(*(_QWORD *)v43 + 32LL);
std::vector<std::vector<int>>::reserve(*(_QWORD *)v43 + 152LL, v6);
v41[1] = *(_QWORD *)v43 + 32LL;
v41[0] = std::vector<std::string>::begin(*(_QWORD *)v43 + 32LL);
v40 = std::vector<std::string>::end(*(_QWORD *)v43 + 32LL);
while ( (__gnu_cxx::operator!=<std::string *,std::vector<std::string>>(v41, &v40) & 1) != 0 )
{
v39 = __gnu_cxx::__normal_iterator<std::string *,std::vector<std::string>>::operator*(v41);
if ( (std::string::empty(v39) & 1) != 0 )
{
if ( (v42 & 1) != 0 && common_log_verbosity_thold >= 0 )
{
v10 = common_log_main();
common_log_add(
v10,
4,
(unsigned int)"%s: found empty answer\n",
(unsigned int)"multiple_choice_prepare_one_task",
v11,
v12);
}
return 0;
}
std::operator+<char>(
(int)v36,
v43[0],
(int)" ",
v7,
v8,
v9,
v18,
(void *)(*(_QWORD *)v43 + 152LL),
v44[0],
(long long)v36);
std::operator+<char>(v37, v21, v39);
common_tokenize(v38, *(_QWORD *)v20, v37, 1LL, 0LL);
std::vector<std::vector<int>>::emplace_back<std::vector<int>>(v19, v38);
std::vector<int>::~vector(v38);
std::string::~string(v37);
std::string::~string(v36);
__gnu_cxx::__normal_iterator<std::string *,std::vector<std::string>>::operator++(v41);
}
v13 = std::vector<std::vector<int>>::front(*(_QWORD *)v43 + 152LL);
v35[0] = std::vector<int>::size(v13);
v34 = *(_QWORD *)v43 + 152LL;
v33 = std::vector<std::vector<int>>::begin(*(_QWORD *)v43 + 152LL);
v32 = std::vector<std::vector<int>>::end(v34);
while ( (__gnu_cxx::operator!=<std::vector<int> *,std::vector<std::vector<int>>>(&v33, &v32) & 1) != 0 )
{
v31 = __gnu_cxx::__normal_iterator<std::vector<int> *,std::vector<std::vector<int>>>::operator*(&v33);
v30 = std::vector<int>::size(v31);
v35[0] = *(_QWORD *)std::min<unsigned long>(v35, &v30);
__gnu_cxx::__normal_iterator<std::vector<int> *,std::vector<std::vector<int>>>::operator++(&v33);
}
*(_QWORD *)(*(_QWORD *)v43 + 136LL) = 0LL;
for ( i = 0LL; i < v35[0]; ++i )
{
v14 = std::vector<std::vector<int>>::operator[](*(_QWORD *)v43 + 152LL, 0LL);
v28 = *(_DWORD *)std::vector<int>::operator[](v14, i);
v27 = 1;
for ( j = 1LL; j < std::vector<std::vector<int>>::size(*(_QWORD *)v43 + 152LL); ++j )
{
v15 = std::vector<std::vector<int>>::operator[](*(_QWORD *)v43 + 152LL, j);
if ( *(_DWORD *)std::vector<int>::operator[](v15, i) != v28 )
{
v27 = 0;
break;
}
}
if ( (v27 & 1) == 0 )
break;
++*(_QWORD *)(*(_QWORD *)v43 + 136LL);
}
*(_QWORD *)(*(_QWORD *)v43 + 144LL) = *(_QWORD *)(*(_QWORD *)v43 + 136LL);
v25 = *(_QWORD *)v43 + 152LL;
v24 = std::vector<std::vector<int>>::begin(*(_QWORD *)v43 + 152LL);
v23 = std::vector<std::vector<int>>::end(v25);
while ( (__gnu_cxx::operator!=<std::vector<int> *,std::vector<std::vector<int>>>(&v24, &v23) & 1) != 0 )
{
v22 = __gnu_cxx::__normal_iterator<std::vector<int> *,std::vector<std::vector<int>>>::operator*(&v24);
v16 = std::vector<int>::size(v22);
*(_QWORD *)(*(_QWORD *)v43 + 144LL) += v16 - *(_QWORD *)(*(_QWORD *)v43 + 136LL);
__gnu_cxx::__normal_iterator<std::vector<int> *,std::vector<std::vector<int>>>::operator++(&v24);
}
return 1;
}
}
| multiple_choice_prepare_one_task:
SUB RSP,0x138
MOV AL,DL
MOV qword ptr [RSP + 0x128],RDI
MOV qword ptr [RSP + 0x120],RSI
AND AL,0x1
MOV byte ptr [RSP + 0x11f],AL
MOV RDI,qword ptr [RSP + 0x120]
CALL 0x0015e520
TEST AL,0x1
JNZ 0x00170b5a
MOV RDI,qword ptr [RSP + 0x120]
ADD RDI,0x20
CALL 0x00183440
TEST AL,0x1
JNZ 0x00170b5a
JMP 0x00170ba6
LAB_00170b5a:
TEST byte ptr [RSP + 0x11f],0x1
JZ 0x00170b99
JMP 0x00170b66
LAB_00170b66:
XOR EAX,EAX
LEA RCX,[0x3ca668]
CMP EAX,dword ptr [RCX]
JG 0x00170b95
CALL 0x002de560
MOV RDI,RAX
MOV ESI,0x4
LEA RDX,[0x326a4c]
LEA RCX,[0x326a83]
MOV AL,0x0
CALL 0x002de650
LAB_00170b95:
JMP 0x00170b97
LAB_00170b97:
JMP 0x00170b99
LAB_00170b99:
MOV byte ptr [RSP + 0x137],0x0
JMP 0x0017105d
LAB_00170ba6:
MOV RAX,qword ptr [RSP + 0x120]
ADD RAX,0x98
MOV qword ptr [RSP + 0x20],RAX
MOV RDI,qword ptr [RSP + 0x120]
ADD RDI,0x20
CALL 0x00179ee0
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,RAX
CALL 0x00183490
MOV RAX,qword ptr [RSP + 0x120]
ADD RAX,0x20
MOV qword ptr [RSP + 0x110],RAX
MOV RDI,qword ptr [RSP + 0x110]
CALL 0x0017a230
MOV qword ptr [RSP + 0x108],RAX
MOV RDI,qword ptr [RSP + 0x110]
CALL 0x0017a9c0
MOV qword ptr [RSP + 0x100],RAX
LAB_00170c15:
LEA RDI,[RSP + 0x108]
LEA RSI,[RSP + 0x100]
CALL 0x0017bb40
TEST AL,0x1
JNZ 0x00170c33
JMP 0x00170ddc
LAB_00170c33:
LEA RDI,[RSP + 0x108]
CALL 0x00182fe0
MOV qword ptr [RSP + 0xf8],RAX
MOV RDI,qword ptr [RSP + 0xf8]
CALL 0x0015e520
TEST AL,0x1
JNZ 0x00170c5b
JMP 0x00170ca7
LAB_00170c5b:
TEST byte ptr [RSP + 0x11f],0x1
JZ 0x00170c9a
JMP 0x00170c67
LAB_00170c67:
XOR EAX,EAX
LEA RCX,[0x3ca668]
CMP EAX,dword ptr [RCX]
JG 0x00170c96
CALL 0x002de560
MOV RDI,RAX
MOV ESI,0x4
LEA RDX,[0x326aa4]
LEA RCX,[0x326a83]
MOV AL,0x0
CALL 0x002de650
LAB_00170c96:
JMP 0x00170c98
LAB_00170c98:
JMP 0x00170c9a
LAB_00170c9a:
MOV byte ptr [RSP + 0x137],0x0
JMP 0x0017105d
LAB_00170ca7:
MOV RSI,qword ptr [RSP + 0x120]
MOV RAX,RSI
ADD RAX,0x98
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [RSP + 0x128]
MOV qword ptr [RSP + 0x10],RAX
LEA RDX,[0x330ff9]
LEA RDI,[RSP + 0xa0]
MOV qword ptr [RSP + 0x18],RDI
CALL 0x0017a050
MOV RSI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0xf8]
LAB_00170cf0:
LEA RDI,[RSP + 0xc0]
CALL 0x0017a000
JMP 0x00170cff
LAB_00170cff:
MOV RSI,qword ptr [RSP + 0x10]
LEA RDI,[RSP + 0xe0]
LEA RDX,[RSP + 0xc0]
MOV ECX,0x1
XOR R8D,R8D
CALL 0x002124c0
JMP 0x00170d23
LAB_00170d23:
MOV RDI,qword ptr [RSP + 0x8]
LEA RSI,[RSP + 0xe0]
CALL 0x001835a0
LAB_00170d35:
JMP 0x00170d37
LAB_00170d37:
LEA RDI,[RSP + 0xe0]
CALL 0x001771b0
LEA RDI,[RSP + 0xc0]
CALL 0x0015f628
LEA RDI,[RSP + 0xa0]
CALL 0x0015f628
LEA RDI,[RSP + 0x108]
CALL 0x0017bf30
JMP 0x00170c15
LAB_00170ddc:
MOV RDI,qword ptr [RSP + 0x120]
ADD RDI,0x98
CALL 0x00183620
MOV RDI,RAX
CALL 0x0017a120
MOV qword ptr [RSP + 0x88],RAX
MOV RAX,qword ptr [RSP + 0x120]
ADD RAX,0x98
MOV qword ptr [RSP + 0x80],RAX
MOV RDI,qword ptr [RSP + 0x80]
CALL 0x00183650
MOV qword ptr [RSP + 0x78],RAX
MOV RDI,qword ptr [RSP + 0x80]
CALL 0x00183680
MOV qword ptr [RSP + 0x70],RAX
LAB_00170e3a:
LEA RDI,[RSP + 0x78]
LEA RSI,[RSP + 0x70]
CALL 0x001836b0
TEST AL,0x1
JNZ 0x00170e4f
JMP 0x00170e96
LAB_00170e4f:
LEA RDI,[RSP + 0x78]
CALL 0x001836f0
MOV qword ptr [RSP + 0x68],RAX
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x0017a120
MOV qword ptr [RSP + 0x60],RAX
LEA RDI,[RSP + 0x88]
LEA RSI,[RSP + 0x60]
CALL 0x00177be0
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP + 0x88],RAX
LEA RDI,[RSP + 0x78]
CALL 0x00183700
JMP 0x00170e3a
LAB_00170e96:
MOV RAX,qword ptr [RSP + 0x120]
MOV qword ptr [RAX + 0x88],0x0
MOV qword ptr [RSP + 0x58],0x0
LAB_00170eb2:
MOV RAX,qword ptr [RSP + 0x58]
CMP RAX,qword ptr [RSP + 0x88]
JNC 0x00170fa4
MOV RDI,qword ptr [RSP + 0x120]
ADD RDI,0x98
XOR EAX,EAX
MOV ESI,EAX
CALL 0x001812a0
MOV RDI,RAX
MOV RSI,qword ptr [RSP + 0x58]
CALL 0x0017a140
MOV EAX,dword ptr [RAX]
MOV dword ptr [RSP + 0x54],EAX
MOV byte ptr [RSP + 0x53],0x1
MOV qword ptr [RSP + 0x48],0x1
LAB_00170efe:
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP],RAX
MOV RDI,qword ptr [RSP + 0x120]
ADD RDI,0x98
CALL 0x001811e0
MOV RCX,RAX
MOV RAX,qword ptr [RSP]
CMP RAX,RCX
JNC 0x00170f6e
MOV RDI,qword ptr [RSP + 0x120]
ADD RDI,0x98
MOV RSI,qword ptr [RSP + 0x48]
CALL 0x001812a0
MOV RDI,RAX
MOV RSI,qword ptr [RSP + 0x58]
CALL 0x0017a140
MOV EAX,dword ptr [RAX]
CMP EAX,dword ptr [RSP + 0x54]
JZ 0x00170f5c
MOV byte ptr [RSP + 0x53],0x0
JMP 0x00170f6e
LAB_00170f5c:
JMP 0x00170f5e
LAB_00170f5e:
MOV RAX,qword ptr [RSP + 0x48]
ADD RAX,0x1
MOV qword ptr [RSP + 0x48],RAX
JMP 0x00170efe
LAB_00170f6e:
TEST byte ptr [RSP + 0x53],0x1
JNZ 0x00170f77
JMP 0x00170fa4
LAB_00170f77:
MOV RAX,qword ptr [RSP + 0x120]
MOV RCX,qword ptr [RAX + 0x88]
ADD RCX,0x1
MOV qword ptr [RAX + 0x88],RCX
MOV RAX,qword ptr [RSP + 0x58]
ADD RAX,0x1
MOV qword ptr [RSP + 0x58],RAX
JMP 0x00170eb2
LAB_00170fa4:
MOV RAX,qword ptr [RSP + 0x120]
MOV RCX,qword ptr [RAX + 0x88]
MOV RAX,qword ptr [RSP + 0x120]
MOV qword ptr [RAX + 0x90],RCX
MOV RAX,qword ptr [RSP + 0x120]
ADD RAX,0x98
MOV qword ptr [RSP + 0x40],RAX
MOV RDI,qword ptr [RSP + 0x40]
CALL 0x00183650
MOV qword ptr [RSP + 0x38],RAX
MOV RDI,qword ptr [RSP + 0x40]
CALL 0x00183680
MOV qword ptr [RSP + 0x30],RAX
LAB_00170ff3:
LEA RDI,[RSP + 0x38]
LEA RSI,[RSP + 0x30]
CALL 0x001836b0
TEST AL,0x1
JNZ 0x00171008
JMP 0x00171055
LAB_00171008:
LEA RDI,[RSP + 0x38]
CALL 0x001836f0
MOV qword ptr [RSP + 0x28],RAX
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x0017a120
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x120]
SUB RCX,qword ptr [RAX + 0x88]
MOV RAX,qword ptr [RSP + 0x120]
ADD RCX,qword ptr [RAX + 0x90]
MOV qword ptr [RAX + 0x90],RCX
LEA RDI,[RSP + 0x38]
CALL 0x00183700
JMP 0x00170ff3
LAB_00171055:
MOV byte ptr [RSP + 0x137],0x1
LAB_0017105d:
MOV AL,byte ptr [RSP + 0x137]
AND AL,0x1
ADD RSP,0x138
RET
|
/* multiple_choice_prepare_one_task(llama_context*, multiple_choice_task&, bool) */
int1
multiple_choice_prepare_one_task(llama_context *param_1,multiple_choice_task *param_2,bool param_3)
{
llama_context *plVar1;
bool bVar2;
ulong uVar3;
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
*pvVar4;
int8 uVar5;
vector<int,std::allocator<int>> *pvVar6;
ulong *puVar7;
int *piVar8;
ulong uVar9;
long lVar10;
int8 local_108;
int8 local_100;
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
*local_f8;
ulong local_f0;
byte local_e5;
int local_e4;
ulong local_e0;
ulong local_d8;
vector<int,std::allocator<int>> *local_d0;
int8 local_c8;
int8 local_c0;
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
*local_b8;
ulong local_b0 [3];
string local_98 [32];
string local_78 [32];
llama_context local_58 [24];
int8 local_40;
int8 local_38;
int8 local_30;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *local_28;
byte local_19;
multiple_choice_task *local_18;
llama_context *local_10;
int1 local_1;
local_19 = param_3;
local_18 = param_2;
local_10 = param_1;
uVar3 = std::__cxx11::string::empty();
if (((uVar3 & 1) == 0) &&
(uVar3 = std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::empty
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)
(local_18 + 0x20)), (uVar3 & 1) == 0)) {
pvVar4 = (vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
*)(local_18 + 0x98);
uVar3 = std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::size
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)
(local_18 + 0x20));
std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::reserve(pvVar4,uVar3);
local_28 = (vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)
(local_18 + 0x20);
local_30 = std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::begin
(local_28);
local_38 = std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::end(local_28)
;
while (bVar2 = __gnu_cxx::operator!=
((__normal_iterator *)&local_30,(__normal_iterator *)&local_38), bVar2)
{
local_40 = __gnu_cxx::
__normal_iterator<std::__cxx11::string*,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>
::operator*((__normal_iterator<std::__cxx11::string*,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>
*)&local_30);
uVar3 = std::__cxx11::string::empty();
plVar1 = local_10;
if ((uVar3 & 1) != 0) {
if (((local_19 & 1) != 0) && (-1 < common_log_verbosity_thold)) {
uVar5 = common_log_main();
common_log_add(uVar5,4,"%s: found empty answer\n","multiple_choice_prepare_one_task");
}
return 0;
}
pvVar4 = (vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
*)(local_18 + 0x98);
std::operator+(local_98,(char *)local_18);
/* try { // try from 00170cf0 to 00170cfc has its CatchHandler @ 00170d70 */
std::operator+(local_78,local_98);
/* try { // try from 00170cff to 00170d20 has its CatchHandler @ 00170d86 */
common_tokenize(local_58,(string *)plVar1,SUB81(local_78,0),true);
/* try { // try from 00170d23 to 00170d34 has its CatchHandler @ 00170d9c */
std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::emplace_back<std::vector<int,std::allocator<int>>>(pvVar4,(vector *)local_58);
std::vector<int,std::allocator<int>>::~vector((vector<int,std::allocator<int>> *)local_58);
std::__cxx11::string::~string(local_78);
std::__cxx11::string::~string(local_98);
__gnu_cxx::
__normal_iterator<std::__cxx11::string*,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>
::operator++((__normal_iterator<std::__cxx11::string*,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>
*)&local_30);
}
pvVar6 = (vector<int,std::allocator<int>> *)
std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::front((vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
*)(local_18 + 0x98));
local_b0[0] = std::vector<int,std::allocator<int>>::size(pvVar6);
local_b8 = (vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
*)(local_18 + 0x98);
local_c0 = std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::begin(local_b8);
local_c8 = std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::end(local_b8);
while (bVar2 = __gnu_cxx::operator!=
((__normal_iterator *)&local_c0,(__normal_iterator *)&local_c8), bVar2)
{
local_d0 = (vector<int,std::allocator<int>> *)
__gnu_cxx::
__normal_iterator<std::vector<int,std::allocator<int>>*,std::vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>>
::operator*((__normal_iterator<std::vector<int,std::allocator<int>>*,std::vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>>
*)&local_c0);
local_d8 = std::vector<int,std::allocator<int>>::size(local_d0);
puVar7 = std::min<unsigned_long>(local_b0,&local_d8);
local_b0[0] = *puVar7;
__gnu_cxx::
__normal_iterator<std::vector<int,std::allocator<int>>*,std::vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>>
::operator++((__normal_iterator<std::vector<int,std::allocator<int>>*,std::vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>>
*)&local_c0);
}
*(int8 *)(local_18 + 0x88) = 0;
for (local_e0 = 0; local_e0 < local_b0[0]; local_e0 = local_e0 + 1) {
pvVar6 = (vector<int,std::allocator<int>> *)
std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::operator[]((vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
*)(local_18 + 0x98),0);
piVar8 = (int *)std::vector<int,std::allocator<int>>::operator[](pvVar6,local_e0);
local_e4 = *piVar8;
local_e5 = 1;
for (local_f0 = 1; uVar3 = local_f0,
uVar9 = std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::size((vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
*)(local_18 + 0x98)), uVar3 < uVar9; local_f0 = local_f0 + 1) {
pvVar6 = (vector<int,std::allocator<int>> *)
std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::operator[]((vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
*)(local_18 + 0x98),local_f0);
piVar8 = (int *)std::vector<int,std::allocator<int>>::operator[](pvVar6,local_e0);
if (*piVar8 != local_e4) {
local_e5 = 0;
break;
}
}
if ((local_e5 & 1) == 0) break;
*(long *)(local_18 + 0x88) = *(long *)(local_18 + 0x88) + 1;
}
*(int8 *)(local_18 + 0x90) = *(int8 *)(local_18 + 0x88);
local_f8 = (vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
*)(local_18 + 0x98);
local_100 = std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::begin(local_f8);
local_108 = std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::end(local_f8);
while (bVar2 = __gnu_cxx::operator!=
((__normal_iterator *)&local_100,(__normal_iterator *)&local_108),
bVar2) {
pvVar6 = (vector<int,std::allocator<int>> *)
__gnu_cxx::
__normal_iterator<std::vector<int,std::allocator<int>>*,std::vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>>
::operator*((__normal_iterator<std::vector<int,std::allocator<int>>*,std::vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>>
*)&local_100);
lVar10 = std::vector<int,std::allocator<int>>::size(pvVar6);
*(long *)(local_18 + 0x90) =
(lVar10 - *(long *)(local_18 + 0x88)) + *(long *)(local_18 + 0x90);
__gnu_cxx::
__normal_iterator<std::vector<int,std::allocator<int>>*,std::vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>>
::operator++((__normal_iterator<std::vector<int,std::allocator<int>>*,std::vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>>
*)&local_100);
}
local_1 = 1;
}
else {
if (((local_19 & 1) != 0) && (-1 < common_log_verbosity_thold)) {
uVar5 = common_log_main();
common_log_add(uVar5,4,"%s: found bad task with empty question and/or answers\n",
"multiple_choice_prepare_one_task");
}
local_1 = 0;
}
return local_1;
}
|
|
962 | multiple_choice_prepare_one_task(llama_context*, multiple_choice_task&, bool) | monkey531[P]llama/examples/perplexity/perplexity.cpp | static bool multiple_choice_prepare_one_task(llama_context * ctx, multiple_choice_task& task, bool log_error) {
if (task.question.empty() || task.mc1.answers.empty()) {
if (log_error) {
LOG_ERR("%s: found bad task with empty question and/or answers\n", __func__);
}
return false;
}
task.seq_tokens.reserve(task.mc1.answers.size());
for (auto& answer : task.mc1.answers) {
if (answer.empty()) {
if (log_error) {
LOG_ERR("%s: found empty answer\n", __func__);
}
return false;
}
task.seq_tokens.emplace_back(::common_tokenize(ctx, task.question + " " + answer, true));
}
auto min_len = task.seq_tokens.front().size();
for (auto& seq : task.seq_tokens) {
min_len = std::min(min_len, seq.size());
}
task.common_prefix = 0;
for (size_t k = 0; k < min_len; ++k) {
auto token = task.seq_tokens[0][k];
bool all_same = true;
for (size_t i = 1; i < task.seq_tokens.size(); ++i) {
if (task.seq_tokens[i][k] != token) {
all_same = false;
break;
}
}
if (!all_same) {
break;
}
++task.common_prefix;
}
task.required_tokens = task.common_prefix;
for (auto& seq : task.seq_tokens) {
task.required_tokens += seq.size() - task.common_prefix;
}
return true;
} | O3 | cpp | multiple_choice_prepare_one_task(llama_context*, multiple_choice_task&, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, 0x58(%rsp)
cmpq $0x0, 0x8(%rsi)
je 0x2a917
movq %rsi, %rbx
movq 0x20(%rsi), %rax
movq 0x28(%rsi), %rsi
cmpq %rsi, %rax
je 0x2a917
movl %edx, 0x4(%rsp)
leaq 0x98(%rbx), %rdi
subq %rax, %rsi
sarq $0x5, %rsi
movq %rdi, 0x50(%rsp)
callq 0x2f3b4
movq 0x20(%rbx), %r13
movq 0x28(%rbx), %rax
movq %rax, 0x48(%rsp)
cmpq %rax, %r13
je 0x2a8cf
leaq 0x38(%rsp), %r14
leaq 0x8(%rsp), %r12
leaq 0x60(%rsp), %rbp
cmpq $0x0, 0x8(%r13)
je 0x2a95a
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x2d500
movq %r12, %rdi
leaq 0xd2e5c(%rip), %rsi # 0xfd651
callq 0x1c1b0
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %r12, %rdi
callq 0x1b260
movq %r14, 0x28(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
movq %rbp, %r15
je 0x2a830
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x2a837
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %r15, %rdi
movq 0x58(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x8368b
movq 0x50(%rsp), %rdi
movq %r15, %rsi
callq 0x2f492
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x2a88d
movq 0x70(%rsp), %rsi
subq %rdi, %rsi
callq 0x1b8f0
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x2a8a4
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1b8f0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2a8c0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b8f0
addq $0x20, %r13
cmpq 0x48(%rsp), %r13
jne 0x2a7c4
movq 0x98(%rbx), %rax
movq 0xa0(%rbx), %rcx
movq (%rax), %rdx
movq 0x8(%rax), %rsi
subq %rdx, %rsi
sarq $0x2, %rsi
cmpq %rcx, %rax
je 0x2a985
movq %rax, %r8
movq 0x8(%r8), %rdi
subq (%r8), %rdi
sarq $0x2, %rdi
cmpq %rsi, %rdi
cmovaeq %rsi, %rdi
addq $0x18, %r8
movq %rdi, %rsi
cmpq %rcx, %r8
jne 0x2a8f7
jmp 0x2a988
xorl %ebp, %ebp
testb %dl, %dl
je 0x2aa22
leaq 0x111b60(%rip), %rax # 0x13c488
cmpl $0x0, (%rax)
js 0x2aa22
callq 0xd98db
leaq 0xc8f7a(%rip), %rdx # 0xf38b7
leaq 0xc8faa(%rip), %rcx # 0xf38ee
xorl %ebp, %ebp
movq %rax, %rdi
movl $0x4, %esi
xorl %eax, %eax
callq 0xd9978
jmp 0x2aa22
xorl %ebp, %ebp
cmpb $0x0, 0x4(%rsp)
je 0x2aa22
leaq 0x111b1a(%rip), %rax # 0x13c488
cmpl $0x0, (%rax)
js 0x2aa22
callq 0xd98db
leaq 0xc8f8c(%rip), %rdx # 0xf390f
jmp 0x2a93d
movq %rsi, %rdi
movq $0x0, 0x88(%rbx)
testq %rdi, %rdi
je 0x2a9ed
movq %rcx, %rsi
subq %rax, %rsi
sarq $0x3, %rsi
movabsq $-0x5555555555555555, %r8 # imm = 0xAAAAAAAAAAAAAAAB
imulq %rsi, %r8
leaq -0x1(%r8), %r9
leaq 0x18(%rax), %r10
xorl %esi, %esi
cmpq $0x2, %r8
jb 0x2a9dc
movl (%rdx,%rsi,4), %r11d
movq %r10, %r14
movq %r9, %r15
movq (%r14), %r12
cmpl %r11d, (%r12,%rsi,4)
jne 0x2a9ef
addq $0x18, %r14
decq %r15
jne 0x2a9ca
incq %rsi
movq %rsi, 0x88(%rbx)
cmpq %rdi, %rsi
jne 0x2a9ba
jmp 0x2a9ef
xorl %esi, %esi
movq %rsi, 0x90(%rbx)
movb $0x1, %bpl
cmpq %rcx, %rax
je 0x2aa22
movq %rsi, %rdx
movq 0x8(%rax), %rdi
subq (%rax), %rdi
sarq $0x2, %rdi
subq %rsi, %rdx
addq %rdi, %rdx
addq $0x18, %rax
cmpq %rcx, %rax
jne 0x2aa01
movq %rdx, 0x90(%rbx)
movl %ebp, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2aa51
movq %rax, %rbx
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x2aa59
movq 0x70(%rsp), %rsi
subq %rdi, %rsi
callq 0x1b8f0
jmp 0x2aa59
movq %rax, %rbx
jmp 0x2aa70
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x2aa70
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1b8f0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2aa8c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b8f0
movq %rbx, %rdi
callq 0x1c020
| _ZL32multiple_choice_prepare_one_taskP13llama_contextR20multiple_choice_taskb:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 78h
mov [rsp+0A8h+var_50], rdi
cmp qword ptr [rsi+8], 0
jz loc_2A917
mov rbx, rsi
mov rax, [rsi+20h]
mov rsi, [rsi+28h]
cmp rax, rsi
jz loc_2A917
mov [rsp+0A8h+var_A4], edx
lea rdi, [rbx+98h]
sub rsi, rax
sar rsi, 5
mov [rsp+0A8h+var_58], rdi
call _ZNSt6vectorIS_IiSaIiEESaIS1_EE7reserveEm; std::vector<std::vector<int>>::reserve(ulong)
mov r13, [rbx+20h]
mov rax, [rbx+28h]
mov [rsp+0A8h+var_60], rax
cmp r13, rax
jz loc_2A8CF
lea r14, [rsp+0A8h+var_70]
lea r12, [rsp+0A8h+var_A0]
lea rbp, [rsp+0A8h+var_48]
loc_2A7C4:
cmp qword ptr [r13+8], 0
jz loc_2A95A
lea rax, [rsp+0A8h+var_90]
mov [rsp+0A8h+var_A0], rax
mov rsi, [rbx]
mov rdx, [rbx+8]
add rdx, rsi
mov rdi, r12
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
mov rdi, r12
lea rsi, aForMessageInMe+144h; " "
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov rsi, [r13+0]
mov rdx, [r13+8]
mov rdi, r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
mov [rsp+0A8h+var_80], r14
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
mov r15, rbp
jz short loc_2A830
mov [rsp+0A8h+var_80], rdx
mov rdx, [rcx]
mov [rsp+0A8h+var_70], rdx
jmp short loc_2A837
loc_2A830:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r14], xmm0
loc_2A837:
mov rdx, [rax+8]
mov [rsp+0A8h+var_78], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
mov rdi, r15
mov rsi, [rsp+0A8h+var_50]
lea rdx, [rsp+0A8h+var_80]
mov ecx, 1
xor r8d, r8d
call _Z15common_tokenizePK13llama_contextRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbb; common_tokenize(llama_context const*,std::string const&,bool,bool)
mov rdi, [rsp+0A8h+var_58]
mov rsi, r15
call _ZNSt6vectorIS_IiSaIiEESaIS1_EE12emplace_backIJS1_EEERS1_DpOT_; std::vector<std::vector<int>>::emplace_back<std::vector<int>>(std::vector<int> &&)
mov rdi, [rsp+0A8h+var_48]; void *
test rdi, rdi
jz short loc_2A88D
mov rsi, [rsp+0A8h+var_38]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2A88D:
mov rdi, [rsp+0A8h+var_80]; void *
cmp rdi, r14
jz short loc_2A8A4
mov rsi, [rsp+0A8h+var_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2A8A4:
mov rdi, [rsp+0A8h+var_A0]; void *
lea rax, [rsp+0A8h+var_90]
cmp rdi, rax
jz short loc_2A8C0
mov rsi, [rsp+0A8h+var_90]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2A8C0:
add r13, 20h ; ' '
cmp r13, [rsp+0A8h+var_60]
jnz loc_2A7C4
loc_2A8CF:
mov rax, [rbx+98h]
mov rcx, [rbx+0A0h]
mov rdx, [rax]
mov rsi, [rax+8]
sub rsi, rdx
sar rsi, 2
cmp rax, rcx
jz loc_2A985
mov r8, rax
loc_2A8F7:
mov rdi, [r8+8]
sub rdi, [r8]
sar rdi, 2
cmp rdi, rsi
cmovnb rdi, rsi
add r8, 18h
mov rsi, rdi
cmp r8, rcx
jnz short loc_2A8F7
jmp short loc_2A988
loc_2A917:
xor ebp, ebp
test dl, dl
jz loc_2AA22
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
js loc_2AA22
call _Z15common_log_mainv; common_log_main(void)
lea rdx, aSFoundBadTaskW; "%s: found bad task with empty question "...
loc_2A93D:
lea rcx, aMultipleChoice_0; "multiple_choice_prepare_one_task"
xor ebp, ebp
mov rdi, rax
mov esi, 4
xor eax, eax
call _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
jmp loc_2AA22
loc_2A95A:
xor ebp, ebp
cmp byte ptr [rsp+0A8h+var_A4], 0
jz loc_2AA22
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
js loc_2AA22
call _Z15common_log_mainv; common_log_main(void)
lea rdx, aSFoundEmptyAns; "%s: found empty answer\n"
jmp short loc_2A93D
loc_2A985:
mov rdi, rsi
loc_2A988:
mov qword ptr [rbx+88h], 0
test rdi, rdi
jz short loc_2A9ED
mov rsi, rcx
sub rsi, rax
sar rsi, 3
mov r8, 0AAAAAAAAAAAAAAABh
imul r8, rsi
lea r9, [r8-1]
lea r10, [rax+18h]
xor esi, esi
loc_2A9BA:
cmp r8, 2
jb short loc_2A9DC
mov r11d, [rdx+rsi*4]
mov r14, r10
mov r15, r9
loc_2A9CA:
mov r12, [r14]
cmp [r12+rsi*4], r11d
jnz short loc_2A9EF
add r14, 18h
dec r15
jnz short loc_2A9CA
loc_2A9DC:
inc rsi
mov [rbx+88h], rsi
cmp rsi, rdi
jnz short loc_2A9BA
jmp short loc_2A9EF
loc_2A9ED:
xor esi, esi
loc_2A9EF:
mov [rbx+90h], rsi
mov bpl, 1
cmp rax, rcx
jz short loc_2AA22
mov rdx, rsi
loc_2AA01:
mov rdi, [rax+8]
sub rdi, [rax]
sar rdi, 2
sub rdx, rsi
add rdx, rdi
add rax, 18h
cmp rax, rcx
jnz short loc_2AA01
mov [rbx+90h], rdx
loc_2AA22:
mov eax, ebp
add rsp, 78h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_2AA51
mov rbx, rax
mov rdi, [rsp+arg_58]; void *
test rdi, rdi
jz short loc_2AA59
mov rsi, [rsp+arg_68]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_2AA59
loc_2AA51:
mov rbx, rax
jmp short loc_2AA70
mov rbx, rax
loc_2AA59:
mov rdi, [rsp+arg_20]; void *
cmp rdi, r14
jz short loc_2AA70
mov rsi, [rsp+arg_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2AA70:
mov rdi, [rsp+arg_0]; void *
lea rax, [rsp+arg_10]
cmp rdi, rax
jz short loc_2AA8C
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2AA8C:
mov rdi, rbx
call __Unwind_Resume
| long long multiple_choice_prepare_one_task(long long a1, _QWORD *a2, char a3)
{
void **v3; // rbp
long long v5; // rax
long long v6; // rsi
_QWORD *v7; // r13
long long v8; // rax
__int128 *v9; // rcx
long long *v10; // rax
long long *v11; // rcx
long long v12; // rdx
unsigned long long v13; // rsi
long long *v14; // r8
unsigned long long v15; // rdi
int v16; // eax
int v17; // r8d
int v18; // r9d
const char *v19; // rdx
unsigned long long v20; // r8
long long v21; // rsi
_QWORD *v22; // r14
unsigned long long v23; // r15
long long v24; // rdx
void *v27[2]; // [rsp+8h] [rbp-A0h] BYREF
_QWORD v28[2]; // [rsp+18h] [rbp-90h] BYREF
void *v29[2]; // [rsp+28h] [rbp-80h] BYREF
__int128 v30; // [rsp+38h] [rbp-70h] BYREF
_QWORD *v31; // [rsp+48h] [rbp-60h]
_QWORD *v32; // [rsp+50h] [rbp-58h]
long long v33; // [rsp+58h] [rbp-50h]
void *v34[9]; // [rsp+60h] [rbp-48h] BYREF
v33 = a1;
if ( !a2[1] || (v5 = a2[4], v6 = a2[5], v5 == v6) )
{
LODWORD(v3) = 0;
if ( a3 && common_log_verbosity_thold >= 0 )
{
v16 = common_log_main();
v19 = "%s: found bad task with empty question and/or answers\n";
LABEL_25:
LODWORD(v3) = 0;
common_log_add(v16, 4, (_DWORD)v19, (unsigned int)"multiple_choice_prepare_one_task", v17, v18);
}
}
else
{
v32 = a2 + 19;
std::vector<std::vector<int>>::reserve(a2 + 19, (v6 - v5) >> 5);
v7 = (_QWORD *)a2[4];
v31 = (_QWORD *)a2[5];
if ( v7 == v31 )
{
LABEL_16:
v10 = (long long *)a2[19];
v11 = (long long *)a2[20];
v12 = *v10;
v13 = (v10[1] - *v10) >> 2;
if ( v10 == v11 )
{
v15 = (v10[1] - *v10) >> 2;
}
else
{
v14 = (long long *)a2[19];
do
{
v15 = (v14[1] - *v14) >> 2;
if ( v15 >= v13 )
v15 = v13;
v14 += 3;
v13 = v15;
}
while ( v14 != v11 );
}
a2[17] = 0LL;
if ( v15 )
{
v20 = 0xAAAAAAAAAAAAAAABLL * (v11 - v10);
v21 = 0LL;
while ( v20 < 2 )
{
LABEL_36:
a2[17] = ++v21;
if ( v21 == v15 )
goto LABEL_39;
}
v22 = v10 + 3;
v23 = v20 - 1;
while ( *(_DWORD *)(*v22 + 4 * v21) == *(_DWORD *)(v12 + 4 * v21) )
{
v22 += 3;
if ( !--v23 )
goto LABEL_36;
}
}
else
{
v21 = 0LL;
}
LABEL_39:
a2[18] = v21;
LOBYTE(v3) = 1;
if ( v10 != v11 )
{
v24 = v21;
do
{
v24 = ((v10[1] - *v10) >> 2) + v24 - v21;
v10 += 3;
}
while ( v10 != v11 );
a2[18] = v24;
}
}
else
{
v3 = v34;
while ( v7[1] )
{
v27[0] = v28;
std::string::_M_construct<char *>(v27, *a2, *a2 + a2[1]);
std::string::append(v27, " ");
v8 = std::string::_M_append(v27, *v7, v7[1]);
v29[0] = &v30;
v9 = (__int128 *)(v8 + 16);
if ( *(_QWORD *)v8 == v8 + 16 )
{
v30 = *v9;
}
else
{
v29[0] = *(void **)v8;
*(_QWORD *)&v30 = *(_QWORD *)v9;
}
v29[1] = *(void **)(v8 + 8);
*(_QWORD *)v8 = v9;
*(_QWORD *)(v8 + 8) = 0LL;
*(_BYTE *)(v8 + 16) = 0;
common_tokenize(v34, v33, v29, 1LL, 0LL);
std::vector<std::vector<int>>::emplace_back<std::vector<int>>(v32, v34);
if ( v34[0] )
operator delete(v34[0], (char *)v34[2] - (char *)v34[0]);
if ( v29[0] != &v30 )
operator delete(v29[0], v30 + 1);
if ( v27[0] != v28 )
operator delete(v27[0], v28[0] + 1LL);
v7 += 4;
if ( v7 == v31 )
goto LABEL_16;
}
LODWORD(v3) = 0;
if ( a3 && common_log_verbosity_thold >= 0 )
{
v16 = common_log_main();
v19 = "%s: found empty answer\n";
goto LABEL_25;
}
}
}
return (unsigned int)v3;
}
| multiple_choice_prepare_one_task:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x78
MOV qword ptr [RSP + 0x58],RDI
CMP qword ptr [RSI + 0x8],0x0
JZ 0x0012a917
MOV RBX,RSI
MOV RAX,qword ptr [RSI + 0x20]
MOV RSI,qword ptr [RSI + 0x28]
CMP RAX,RSI
JZ 0x0012a917
MOV dword ptr [RSP + 0x4],EDX
LEA RDI,[RBX + 0x98]
SUB RSI,RAX
SAR RSI,0x5
MOV qword ptr [RSP + 0x50],RDI
CALL 0x0012f3b4
MOV R13,qword ptr [RBX + 0x20]
MOV RAX,qword ptr [RBX + 0x28]
MOV qword ptr [RSP + 0x48],RAX
CMP R13,RAX
JZ 0x0012a8cf
LEA R14,[RSP + 0x38]
LEA R12,[RSP + 0x8]
LEA RBP,[RSP + 0x60]
LAB_0012a7c4:
CMP qword ptr [R13 + 0x8],0x0
JZ 0x0012a95a
LEA RAX,[RSP + 0x18]
MOV qword ptr [RSP + 0x8],RAX
MOV RSI,qword ptr [RBX]
MOV RDX,qword ptr [RBX + 0x8]
ADD RDX,RSI
MOV RDI,R12
CALL 0x0012d500
LAB_0012a7eb:
MOV RDI,R12
LEA RSI,[0x1fd651]
CALL 0x0011c1b0
MOV RSI,qword ptr [R13]
MOV RDX,qword ptr [R13 + 0x8]
LAB_0012a802:
MOV RDI,R12
CALL 0x0011b260
MOV qword ptr [RSP + 0x28],R14
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
MOV R15,RBP
JZ 0x0012a830
MOV qword ptr [RSP + 0x28],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x38],RDX
JMP 0x0012a837
LAB_0012a830:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [R14],XMM0
LAB_0012a837:
MOV RDX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x30],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
LAB_0012a84f:
MOV RDI,R15
MOV RSI,qword ptr [RSP + 0x58]
LEA RDX,[RSP + 0x28]
MOV ECX,0x1
XOR R8D,R8D
CALL 0x0018368b
LAB_0012a869:
MOV RDI,qword ptr [RSP + 0x50]
MOV RSI,R15
CALL 0x0012f492
LAB_0012a876:
MOV RDI,qword ptr [RSP + 0x60]
TEST RDI,RDI
JZ 0x0012a88d
MOV RSI,qword ptr [RSP + 0x70]
SUB RSI,RDI
CALL 0x0011b8f0
LAB_0012a88d:
MOV RDI,qword ptr [RSP + 0x28]
CMP RDI,R14
JZ 0x0012a8a4
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x0011b8f0
LAB_0012a8a4:
MOV RDI,qword ptr [RSP + 0x8]
LEA RAX,[RSP + 0x18]
CMP RDI,RAX
JZ 0x0012a8c0
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011b8f0
LAB_0012a8c0:
ADD R13,0x20
CMP R13,qword ptr [RSP + 0x48]
JNZ 0x0012a7c4
LAB_0012a8cf:
MOV RAX,qword ptr [RBX + 0x98]
MOV RCX,qword ptr [RBX + 0xa0]
MOV RDX,qword ptr [RAX]
MOV RSI,qword ptr [RAX + 0x8]
SUB RSI,RDX
SAR RSI,0x2
CMP RAX,RCX
JZ 0x0012a985
MOV R8,RAX
LAB_0012a8f7:
MOV RDI,qword ptr [R8 + 0x8]
SUB RDI,qword ptr [R8]
SAR RDI,0x2
CMP RDI,RSI
CMOVNC RDI,RSI
ADD R8,0x18
MOV RSI,RDI
CMP R8,RCX
JNZ 0x0012a8f7
JMP 0x0012a988
LAB_0012a917:
XOR EBP,EBP
TEST DL,DL
JZ 0x0012aa22
LEA RAX,[0x23c488]
CMP dword ptr [RAX],0x0
JS 0x0012aa22
CALL 0x001d98db
LEA RDX,[0x1f38b7]
LAB_0012a93d:
LEA RCX,[0x1f38ee]
XOR EBP,EBP
MOV RDI,RAX
MOV ESI,0x4
XOR EAX,EAX
CALL 0x001d9978
JMP 0x0012aa22
LAB_0012a95a:
XOR EBP,EBP
CMP byte ptr [RSP + 0x4],0x0
JZ 0x0012aa22
LEA RAX,[0x23c488]
CMP dword ptr [RAX],0x0
JS 0x0012aa22
CALL 0x001d98db
LEA RDX,[0x1f390f]
JMP 0x0012a93d
LAB_0012a985:
MOV RDI,RSI
LAB_0012a988:
MOV qword ptr [RBX + 0x88],0x0
TEST RDI,RDI
JZ 0x0012a9ed
MOV RSI,RCX
SUB RSI,RAX
SAR RSI,0x3
MOV R8,-0x5555555555555555
IMUL R8,RSI
LEA R9,[R8 + -0x1]
LEA R10,[RAX + 0x18]
XOR ESI,ESI
LAB_0012a9ba:
CMP R8,0x2
JC 0x0012a9dc
MOV R11D,dword ptr [RDX + RSI*0x4]
MOV R14,R10
MOV R15,R9
LAB_0012a9ca:
MOV R12,qword ptr [R14]
CMP dword ptr [R12 + RSI*0x4],R11D
JNZ 0x0012a9ef
ADD R14,0x18
DEC R15
JNZ 0x0012a9ca
LAB_0012a9dc:
INC RSI
MOV qword ptr [RBX + 0x88],RSI
CMP RSI,RDI
JNZ 0x0012a9ba
JMP 0x0012a9ef
LAB_0012a9ed:
XOR ESI,ESI
LAB_0012a9ef:
MOV qword ptr [RBX + 0x90],RSI
MOV BPL,0x1
CMP RAX,RCX
JZ 0x0012aa22
MOV RDX,RSI
LAB_0012aa01:
MOV RDI,qword ptr [RAX + 0x8]
SUB RDI,qword ptr [RAX]
SAR RDI,0x2
SUB RDX,RSI
ADD RDX,RDI
ADD RAX,0x18
CMP RAX,RCX
JNZ 0x0012aa01
MOV qword ptr [RBX + 0x90],RDX
LAB_0012aa22:
MOV EAX,EBP
ADD RSP,0x78
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* multiple_choice_prepare_one_task(llama_context*, multiple_choice_task&, bool) */
ulong multiple_choice_prepare_one_task
(llama_context *param_1,multiple_choice_task *param_2,bool param_3)
{
long lVar1;
long *plVar2;
int8 uVar3;
long *plVar4;
char *pcVar5;
llama_context *unaff_RBP;
ulong uVar6;
ulong uVar7;
long *plVar8;
ulong uVar9;
ulong *puVar10;
long lVar11;
long *local_a0 [2];
long local_90 [2];
long *local_80;
long local_78;
long local_70;
long lStack_68;
ulong *local_60;
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
*local_58;
llama_context *local_50;
void *local_48 [2];
long local_38;
local_50 = param_1;
if (*(long *)(param_2 + 8) != 0) {
if (*(long *)(param_2 + 0x20) != *(long *)(param_2 + 0x28)) {
local_58 = (vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
*)(param_2 + 0x98);
std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::reserve(local_58,*(long *)(param_2 + 0x28) - *(long *)(param_2 + 0x20) >> 5);
puVar10 = *(ulong **)(param_2 + 0x20);
local_60 = *(ulong **)(param_2 + 0x28);
if (puVar10 != local_60) {
unaff_RBP = (llama_context *)local_48;
do {
if (puVar10[1] == 0) {
uVar6 = 0;
if ((!param_3) || (common_log_verbosity_thold < 0)) goto LAB_0012aa22;
uVar3 = common_log_main();
pcVar5 = "%s: found empty answer\n";
goto LAB_0012a93d;
}
local_a0[0] = local_90;
std::__cxx11::string::_M_construct<char*>
(local_a0,*(long *)param_2,*(long *)(param_2 + 8) + *(long *)param_2);
/* try { // try from 0012a7eb to 0012a7f9 has its CatchHandler @ 0012aa51 */
std::__cxx11::string::append((char *)local_a0);
/* try { // try from 0012a802 to 0012a809 has its CatchHandler @ 0012aa33 */
plVar2 = (long *)std::__cxx11::string::_M_append((char *)local_a0,*puVar10);
plVar4 = plVar2 + 2;
if ((long *)*plVar2 == plVar4) {
local_70 = *plVar4;
lStack_68 = plVar2[3];
local_80 = &local_70;
}
else {
local_70 = *plVar4;
local_80 = (long *)*plVar2;
}
local_78 = plVar2[1];
*plVar2 = (long)plVar4;
plVar2[1] = 0;
*(int1 *)(plVar2 + 2) = 0;
/* try { // try from 0012a84f to 0012a868 has its CatchHandler @ 0012aa56 */
common_tokenize(unaff_RBP,(string *)local_50,SUB81(&local_80,0),true);
/* try { // try from 0012a869 to 0012a875 has its CatchHandler @ 0012aa35 */
std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::emplace_back<std::vector<int,std::allocator<int>>>(local_58,(vector *)unaff_RBP);
if (local_48[0] != (void *)0x0) {
operator_delete(local_48[0],local_38 - (long)local_48[0]);
}
if (local_80 != &local_70) {
operator_delete(local_80,local_70 + 1);
}
if (local_a0[0] != local_90) {
operator_delete(local_a0[0],local_90[0] + 1);
}
puVar10 = puVar10 + 4;
} while (puVar10 != local_60);
}
plVar2 = *(long **)(param_2 + 0x98);
plVar4 = *(long **)(param_2 + 0xa0);
lVar1 = *plVar2;
uVar6 = plVar2[1] - lVar1 >> 2;
for (plVar8 = plVar2; plVar8 != plVar4; plVar8 = plVar8 + 3) {
uVar7 = plVar8[1] - *plVar8 >> 2;
if (uVar6 <= uVar7) {
uVar7 = uVar6;
}
uVar6 = uVar7;
}
*(int8 *)(param_2 + 0x88) = 0;
if (uVar6 == 0) {
uVar7 = 0;
}
else {
uVar9 = ((long)plVar4 - (long)plVar2 >> 3) * -0x5555555555555555;
uVar7 = 0;
do {
if (1 < uVar9) {
lVar11 = uVar9 - 1;
plVar8 = plVar2;
do {
plVar8 = plVar8 + 3;
if (*(int *)(*plVar8 + uVar7 * 4) != *(int *)(lVar1 + uVar7 * 4)) goto LAB_0012a9ef;
lVar11 = lVar11 + -1;
} while (lVar11 != 0);
}
uVar7 = uVar7 + 1;
*(ulong *)(param_2 + 0x88) = uVar7;
} while (uVar7 != uVar6);
}
LAB_0012a9ef:
*(ulong *)(param_2 + 0x90) = uVar7;
uVar6 = CONCAT71((int7)((ulong)unaff_RBP >> 8),1);
uVar9 = uVar7;
if (plVar2 != plVar4) {
do {
uVar9 = (uVar9 - uVar7) + (plVar2[1] - *plVar2 >> 2);
plVar2 = plVar2 + 3;
} while (plVar2 != plVar4);
*(ulong *)(param_2 + 0x90) = uVar9;
}
goto LAB_0012aa22;
}
}
uVar6 = 0;
if ((param_3) && (-1 < common_log_verbosity_thold)) {
uVar3 = common_log_main();
pcVar5 = "%s: found bad task with empty question and/or answers\n";
LAB_0012a93d:
uVar6 = 0;
common_log_add(uVar3,4,pcVar5,"multiple_choice_prepare_one_task");
}
LAB_0012aa22:
return uVar6 & 0xffffffff;
}
|
|
963 | my_error_register | eloqsql/mysys/my_error.c | int my_error_register(const char** (*get_errmsgs)(int error), uint first,
uint last)
{
struct my_err_head *meh_p;
struct my_err_head **search_meh_pp;
/* Allocate a new header structure. */
if (! (meh_p= (struct my_err_head*) my_malloc(key_memory_my_err_head,
sizeof(struct my_err_head),
MYF(MY_WME))))
return 1;
meh_p->get_errmsgs= get_errmsgs;
meh_p->meh_first= first;
meh_p->meh_last= last;
/* Search for the right position in the list. */
for (search_meh_pp= &my_errmsgs_list;
*search_meh_pp;
search_meh_pp= &(*search_meh_pp)->meh_next)
{
if ((*search_meh_pp)->meh_last > first)
break;
}
/* Error numbers must be unique. No overlapping is allowed. */
if (*search_meh_pp && ((*search_meh_pp)->meh_first <= last))
{
my_free(meh_p);
return 1;
}
/* Insert header into the chain. */
meh_p->meh_next= *search_meh_pp;
*search_meh_pp= meh_p;
return 0;
} | O0 | c | my_error_register:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
leaq 0x3aa1a7(%rip), %rax # 0x40ec50
movl (%rax), %edi
movl $0x18, %esi
movl $0x10, %edx
callq 0x58d60
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x64ad0
movl $0x1, -0x4(%rbp)
jmp 0x64b70
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x14(%rax)
leaq 0x1af981(%rip), %rax # 0x214478
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
je 0x64b25
movq -0x28(%rbp), %rax
movq (%rax), %rax
movl 0x14(%rax), %eax
cmpl -0x14(%rbp), %eax
jbe 0x64b16
jmp 0x64b25
jmp 0x64b18
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x64afb
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
je 0x64b50
movq -0x28(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %eax
cmpl -0x18(%rbp), %eax
ja 0x64b50
movq -0x20(%rbp), %rdi
callq 0x590e0
movl $0x1, -0x4(%rbp)
jmp 0x64b70
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| my_error_register:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
lea rax, key_memory_my_err_head
mov edi, [rax]
mov esi, 18h
mov edx, 10h
call my_malloc
mov [rbp+var_20], rax
cmp rax, 0
jnz short loc_64AD0
mov [rbp+var_4], 1
jmp loc_64B70
loc_64AD0:
mov rcx, [rbp+var_10]
mov rax, [rbp+var_20]
mov [rax+8], rcx
mov ecx, [rbp+var_14]
mov rax, [rbp+var_20]
mov [rax+10h], ecx
mov ecx, [rbp+var_18]
mov rax, [rbp+var_20]
mov [rax+14h], ecx
lea rax, my_errmsgs_list
mov [rbp+var_28], rax
loc_64AFB:
mov rax, [rbp+var_28]
cmp qword ptr [rax], 0
jz short loc_64B25
mov rax, [rbp+var_28]
mov rax, [rax]
mov eax, [rax+14h]
cmp eax, [rbp+var_14]
jbe short loc_64B16
jmp short loc_64B25
loc_64B16:
jmp short $+2
loc_64B18:
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rbp+var_28], rax
jmp short loc_64AFB
loc_64B25:
mov rax, [rbp+var_28]
cmp qword ptr [rax], 0
jz short loc_64B50
mov rax, [rbp+var_28]
mov rax, [rax]
mov eax, [rax+10h]
cmp eax, [rbp+var_18]
ja short loc_64B50
mov rdi, [rbp+var_20]
call my_free
mov [rbp+var_4], 1
jmp short loc_64B70
loc_64B50:
mov rax, [rbp+var_28]
mov rcx, [rax]
mov rax, [rbp+var_20]
mov [rax], rcx
mov rcx, [rbp+var_20]
mov rax, [rbp+var_28]
mov [rax], rcx
mov [rbp+var_4], 0
loc_64B70:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long my_error_register(long long a1, unsigned int a2, unsigned int a3)
{
long long **i; // [rsp+8h] [rbp-28h]
long long v5; // [rsp+10h] [rbp-20h]
v5 = my_malloc(key_memory_my_err_head, 0x18uLL, 16);
if ( v5 )
{
*(_QWORD *)(v5 + 8) = a1;
*(_DWORD *)(v5 + 16) = a2;
*(_DWORD *)(v5 + 20) = a3;
for ( i = &my_errmsgs_list; *i && *((_DWORD *)*i + 5) <= a2; i = (long long **)*i )
;
if ( *i && *((_DWORD *)*i + 4) <= a3 )
{
my_free(v5);
return 1;
}
else
{
*(_QWORD *)v5 = *i;
*i = (long long *)v5;
return 0;
}
}
else
{
return 1;
}
}
| my_error_register:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
LEA RAX,[0x50ec50]
MOV EDI,dword ptr [RAX]
MOV ESI,0x18
MOV EDX,0x10
CALL 0x00158d60
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JNZ 0x00164ad0
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00164b70
LAB_00164ad0:
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x8],RCX
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x10],ECX
MOV ECX,dword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x14],ECX
LEA RAX,[0x314478]
MOV qword ptr [RBP + -0x28],RAX
LAB_00164afb:
MOV RAX,qword ptr [RBP + -0x28]
CMP qword ptr [RAX],0x0
JZ 0x00164b25
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x14]
CMP EAX,dword ptr [RBP + -0x14]
JBE 0x00164b16
JMP 0x00164b25
LAB_00164b16:
JMP 0x00164b18
LAB_00164b18:
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00164afb
LAB_00164b25:
MOV RAX,qword ptr [RBP + -0x28]
CMP qword ptr [RAX],0x0
JZ 0x00164b50
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x10]
CMP EAX,dword ptr [RBP + -0x18]
JA 0x00164b50
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x001590e0
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00164b70
LAB_00164b50:
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x0
LAB_00164b70:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 my_error_register(long param_1,uint param_2,uint param_3)
{
long *plVar1;
int **local_30;
int4 local_c;
plVar1 = (long *)my_malloc(key_memory_my_err_head,0x18,0x10);
if (plVar1 == (long *)0x0) {
local_c = 1;
}
else {
plVar1[1] = param_1;
*(uint *)(plVar1 + 2) = param_2;
*(uint *)((long)plVar1 + 0x14) = param_3;
for (local_30 = &my_errmsgs_list;
(*local_30 != (int *)0x0 && (*(uint *)(*local_30 + 0x14) <= param_2));
local_30 = (int **)*local_30) {
}
if ((*local_30 == (int *)0x0) || (param_3 < *(uint *)(*local_30 + 0x10))) {
*plVar1 = (long)*local_30;
*local_30 = (int *)plVar1;
local_c = 0;
}
else {
my_free(plVar1);
local_c = 1;
}
}
return local_c;
}
|
|
964 | parts_get_action_name | qoraal-tictactoe/build_O0/_deps/qoraal_engine-src/src/parts/parts.c | const char*
parts_get_action_name (uint16_t action_id)
{
const PART_ACTION_T* action = parts_get_action (action_id) ;
if (action == 0) {
return 0 ;
}
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Warray-bounds"
return action->name ;
#pragma GCC diagnostic pop
} | O0 | c | parts_get_action_name:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %di, %ax
movw %ax, -0xa(%rbp)
movzwl -0xa(%rbp), %edi
callq 0x8f20
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x8fcd
movq $0x0, -0x8(%rbp)
jmp 0x8fd9
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| parts_get_action_name:
push rbp
mov rbp, rsp
sub rsp, 20h
mov ax, di
mov [rbp+var_A], ax
movzx edi, [rbp+var_A]
call parts_get_action
mov [rbp+var_18], rax
cmp [rbp+var_18], 0
jnz short loc_8FCD
mov [rbp+var_8], 0
jmp short loc_8FD9
loc_8FCD:
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov [rbp+var_8], rax
loc_8FD9:
mov rax, [rbp+var_8]
add rsp, 20h
pop rbp
retn
| long long ( * parts_get_action_name(__int16 a1))()
{
long long ( **action)(); // [rsp+8h] [rbp-18h]
action = parts_get_action(a1);
if ( action )
return action[1];
else
return 0LL;
}
| parts_get_action_name:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV AX,DI
MOV word ptr [RBP + -0xa],AX
MOVZX EDI,word ptr [RBP + -0xa]
CALL 0x00108f20
MOV qword ptr [RBP + -0x18],RAX
CMP qword ptr [RBP + -0x18],0x0
JNZ 0x00108fcd
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00108fd9
LAB_00108fcd:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x8],RAX
LAB_00108fd9:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x20
POP RBP
RET
|
int8 parts_get_action_name(int2 param_1)
{
long lVar1;
int8 local_10;
lVar1 = parts_get_action(param_1);
if (lVar1 == 0) {
local_10 = 0;
}
else {
local_10 = *(int8 *)(lVar1 + 8);
}
return local_10;
}
|
|
965 | 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
} | O3 | c | my_time_init:
pushq %rbp
movq %rsp, %rbp
popq %rbp
retq
| 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;
}
|
|
966 | LefDefParser::lefiViaLayer::rectColorMask(int) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiVia.cpp | int
lefiViaLayer::rectColorMask(int index)
{
char msg[160];
if (index < 0 || index >= numRects_) {
sprintf(msg, "ERROR (LEFPARS-1420): The index number %d given for the VIA LAYER RECTANGLE is invalid.\nValid index is from 0 to %d", index, numRects_);
lefiError(0, 1420, msg);
return 0;
}
return rectColorMask_[index];
} | O3 | cpp | LefDefParser::lefiViaLayer::rectColorMask(int):
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movl %esi, %edx
testl %esi, %esi
setns %al
movl 0x18(%rdi), %ecx
cmpl %esi, %ecx
setg %sil
testb %sil, %al
je 0x13a94
movq 0x8(%rdi), %rax
movl %edx, %ecx
movl (%rax,%rcx,4), %ebx
jmp 0x13ab9
leaq 0x3a0b4(%rip), %rsi # 0x4db4f
xorl %ebx, %ebx
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x2050
xorl %edi, %edi
movl $0x58c, %esi # imm = 0x58C
movq %r14, %rdx
callq 0x27ae8
movl %ebx, %eax
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
| _ZN12LefDefParser12lefiViaLayer13rectColorMaskEi:
push r14
push rbx
sub rsp, 0A8h
mov edx, esi
test esi, esi
setns al
mov ecx, [rdi+18h]
cmp ecx, esi
setnle sil
test al, sil
jz short loc_13A94
mov rax, [rdi+8]
mov ecx, edx
mov ebx, [rax+rcx*4]
jmp short loc_13AB9
loc_13A94:
lea rsi, aErrorLefpars14; "ERROR (LEFPARS-1420): The index number "...
xor ebx, ebx
mov r14, rsp
mov rdi, r14
xor eax, eax
call _sprintf
xor edi, edi; this
mov esi, 58Ch; int
mov rdx, r14; int
call _ZN12LefDefParser9lefiErrorEiiPKc; LefDefParser::lefiError(int,int,char const*)
loc_13AB9:
mov eax, ebx
add rsp, 0A8h
pop rbx
pop r14
retn
| long long LefDefParser::lefiViaLayer::rectColorMask(LefDefParser::lefiViaLayer *this, signed int a2)
{
int v2; // ecx
unsigned int v3; // ebx
const char *v4; // rcx
_BYTE v6[184]; // [rsp+0h] [rbp-B8h] BYREF
v2 = *((_DWORD *)this + 6);
if ( v2 > a2 && a2 >= 0 )
{
return *(unsigned int *)(*((_QWORD *)this + 1) + 4LL * (unsigned int)a2);
}
else
{
v3 = 0;
sprintf(
v6,
"ERROR (LEFPARS-1420): The index number %d given for the VIA LAYER RECTANGLE is invalid.\n"
"Valid index is from 0 to %d",
a2,
v2);
LefDefParser::lefiError(0LL, 1420, (int)v6, v4);
}
return v3;
}
| rectColorMask:
PUSH R14
PUSH RBX
SUB RSP,0xa8
MOV EDX,ESI
TEST ESI,ESI
SETNS AL
MOV ECX,dword ptr [RDI + 0x18]
CMP ECX,ESI
SETG SIL
TEST AL,SIL
JZ 0x00113a94
MOV RAX,qword ptr [RDI + 0x8]
MOV ECX,EDX
MOV EBX,dword ptr [RAX + RCX*0x4]
JMP 0x00113ab9
LAB_00113a94:
LEA RSI,[0x14db4f]
XOR EBX,EBX
MOV R14,RSP
MOV RDI,R14
XOR EAX,EAX
CALL 0x00102050
XOR EDI,EDI
MOV ESI,0x58c
MOV RDX,R14
CALL 0x00127ae8
LAB_00113ab9:
MOV EAX,EBX
ADD RSP,0xa8
POP RBX
POP R14
RET
|
/* LefDefParser::lefiViaLayer::rectColorMask(int) */
int4 __thiscall LefDefParser::lefiViaLayer::rectColorMask(lefiViaLayer *this,int param_1)
{
int4 uVar1;
char acStack_b8 [168];
if (param_1 < 0 || *(int *)(this + 0x18) <= param_1) {
uVar1 = 0;
sprintf(acStack_b8,
"ERROR (LEFPARS-1420): The index number %d given for the VIA LAYER RECTANGLE is invalid.\nValid index is from 0 to %d"
);
lefiError(0,0x58c,acStack_b8);
}
else {
uVar1 = *(int4 *)(*(long *)(this + 8) + (ulong)(uint)param_1 * 4);
}
return uVar1;
}
|
|
967 | compress_block | 3fs/build_O3/src/apache-arrow-cpp/cpp/zlib_ep-prefix/src/zlib_ep/trees.c | local void compress_block(s, ltree, dtree)
deflate_state *s;
const ct_data *ltree; /* literal tree */
const ct_data *dtree; /* distance tree */
{
unsigned dist; /* distance of matched string */
int lc; /* match length or unmatched char (if dist == 0) */
unsigned sx = 0; /* running index in sym_buf */
unsigned code; /* the code to send */
int extra; /* number of extra bits to send */
if (s->sym_next != 0) do {
dist = s->sym_buf[sx++] & 0xff;
dist += (unsigned)(s->sym_buf[sx++] & 0xff) << 8;
lc = s->sym_buf[sx++];
if (dist == 0) {
send_code(s, lc, ltree); /* send a literal byte */
Tracecv(isgraph(lc), (stderr," '%c' ", lc));
} else {
/* Here, lc is the match length - MIN_MATCH */
code = _length_code[lc];
send_code(s, code + LITERALS + 1, ltree); /* send length code */
extra = extra_lbits[code];
if (extra != 0) {
lc -= base_length[code];
send_bits(s, lc, extra); /* send the extra length bits */
}
dist--; /* dist is now the match distance - 1 */
code = d_code(dist);
Assert (code < D_CODES, "bad d_code");
send_code(s, code, dtree); /* send the distance code */
extra = extra_dbits[code];
if (extra != 0) {
dist -= (unsigned)base_dist[code];
send_bits(s, dist, extra); /* send the extra distance bits */
}
} /* literal or match pair ? */
/* Check that the overlay between pending_buf and sym_buf is ok: */
Assert(s->pending < s->lit_bufsize + sx, "pendingBuf overflow");
} while (sx < s->sym_next);
send_code(s, END_BLOCK, ltree);
} | O3 | c | compress_block:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpl $0x0, 0x170c(%rdi)
je 0xe2db
xorl %eax, %eax
leaq 0x4ebc(%rip), %r8 # 0x12e30
leaq 0x4cb5(%rip), %r10 # 0x12c30
movq 0x1700(%rdi), %rcx
leal 0x1(%rax), %r9d
movl %eax, %r11d
movzbl (%rcx,%r11), %r11d
leal 0x2(%rax), %r12d
movzbl (%rcx,%r9), %r15d
shll $0x8, %r15d
orl %r11d, %r15d
movzbl (%rcx,%r12), %r12d
je 0xe03b
movzbl (%r8,%r12), %r13d
movzwl 0x406(%rsi,%r13,4), %r9d
movl 0x1734(%rdi), %ecx
movl $0x10, %ebx
subl %r9d, %ebx
movzwl 0x404(%rsi,%r13,4), %r11d
movl %r11d, %ebp
shll %cl, %ebp
orw 0x1730(%rdi), %bp
movw %bp, 0x1730(%rdi)
cmpl %ebx, %ecx
jle 0xe0c3
movq 0x10(%rdi), %rcx
movq 0x28(%rdi), %rbx
leaq 0x1(%rbx), %r14
movq %r14, 0x28(%rdi)
movb %bpl, (%rcx,%rbx)
movb 0x1731(%rdi), %cl
movq 0x10(%rdi), %rbx
movq 0x28(%rdi), %r14
leaq 0x1(%r14), %rbp
movq %rbp, 0x28(%rdi)
movb %cl, (%rbx,%r14)
movl 0x1734(%rdi), %ebx
movb $0x10, %cl
subb %bl, %cl
shrl %cl, %r11d
movw %r11w, 0x1730(%rdi)
leal (%r9,%rbx), %ecx
addl $-0x10, %ecx
movl %r11d, %ebp
jmp 0xe0c6
movzwl 0x2(%rsi,%r12,4), %r9d
movl 0x1734(%rdi), %ecx
movl $0x10, %r15d
subl %r9d, %r15d
movzwl (%rsi,%r12,4), %r11d
movl %r11d, %ebp
shll %cl, %ebp
orw 0x1730(%rdi), %bp
movw %bp, 0x1730(%rdi)
cmpl %r15d, %ecx
jle 0xe160
movq 0x10(%rdi), %rcx
movq 0x28(%rdi), %r15
leaq 0x1(%r15), %r12
movq %r12, 0x28(%rdi)
movb %bpl, (%rcx,%r15)
movb 0x1731(%rdi), %cl
movq 0x10(%rdi), %r15
movq 0x28(%rdi), %r12
leaq 0x1(%r12), %r13
movq %r13, 0x28(%rdi)
movb %cl, (%r15,%r12)
movl 0x1734(%rdi), %r15d
movb $0x10, %cl
subb %r15b, %cl
shrl %cl, %r11d
movw %r11w, 0x1730(%rdi)
leal (%r9,%r15), %ecx
addl $-0x10, %ecx
jmp 0xe2c4
addl %r9d, %ecx
movl %ecx, 0x1734(%rdi)
leaq -0x1c(%r13), %r9
cmpq $-0x14, %r9
jb 0xe181
leaq 0x54bf(%rip), %r9 # 0x135a0
subl (%r9,%r13,4), %r12d
leaq 0x5344(%rip), %r9 # 0x13430
movl (%r9,%r13,4), %r13d
movl $0x10, %r9d
subl %r13d, %r9d
cmpl %r9d, %ecx
jle 0xe168
movzwl %r12w, %r9d
shll %cl, %r12d
orl %r12d, %ebp
movw %bp, 0x1730(%rdi)
movq 0x10(%rdi), %rcx
movq 0x28(%rdi), %r11
leaq 0x1(%r11), %rbx
movq %rbx, 0x28(%rdi)
movb %bpl, (%rcx,%r11)
movb 0x1731(%rdi), %cl
movq 0x10(%rdi), %r11
movq 0x28(%rdi), %rbx
leaq 0x1(%rbx), %r14
movq %r14, 0x28(%rdi)
movb %cl, (%r11,%rbx)
movl 0x1734(%rdi), %r11d
movb $0x10, %cl
subb %r11b, %cl
shrl %cl, %r9d
movw %r9w, 0x1730(%rdi)
leal (%r11,%r13), %ecx
addl $-0x10, %ecx
movl %r9d, %ebp
jmp 0xe17b
addl %r9d, %ecx
jmp 0xe2c4
shll %cl, %r12d
orl %r12d, %ebp
movw %bp, 0x1730(%rdi)
addl %ecx, %r13d
movl %r13d, %ecx
movl %ecx, 0x1734(%rdi)
leal -0x1(%r15), %r12d
movl %r12d, %r9d
shrl $0x7, %r9d
addl $0x100, %r9d # imm = 0x100
cmpl $0x101, %r15d # imm = 0x101
cmovbl %r12d, %r9d
movzbl (%r10,%r9), %r15d
movzwl 0x2(%rdx,%r15,4), %r13d
movl $0x10, %r11d
movzwl (%rdx,%r15,4), %r9d
movl %r9d, %ebx
shll %cl, %ebx
subl %r13d, %r11d
orl %ebx, %ebp
movw %bp, 0x1730(%rdi)
cmpl %r11d, %ecx
jle 0xe21b
movq 0x10(%rdi), %rcx
movq 0x28(%rdi), %r11
leaq 0x1(%r11), %rbx
movq %rbx, 0x28(%rdi)
movb %bpl, (%rcx,%r11)
movb 0x1731(%rdi), %cl
movq 0x10(%rdi), %r11
movq 0x28(%rdi), %rbx
leaq 0x1(%rbx), %r14
movq %r14, 0x28(%rdi)
movb %cl, (%r11,%rbx)
movl 0x1734(%rdi), %r11d
movb $0x10, %cl
subb %r11b, %cl
shrl %cl, %r9d
movw %r9w, 0x1730(%rdi)
leal (%r11,%r13), %ecx
addl $-0x10, %ecx
movl %r9d, %ebp
jmp 0xe21e
addl %r13d, %ecx
movl %ecx, 0x1734(%rdi)
cmpb $0x4, %r15b
jb 0xe2ca
leaq 0x53eb(%rip), %r9 # 0x13620
subl (%r9,%r15,4), %r12d
leaq 0x5270(%rip), %r9 # 0x134b0
movl (%r9,%r15,4), %r15d
movl $0x10, %r9d
subl %r15d, %r9d
cmpl %r9d, %ecx
jle 0xe2b1
movzwl %r12w, %r9d
shll %cl, %r12d
orl %r12d, %ebp
movw %bp, 0x1730(%rdi)
movq 0x10(%rdi), %rcx
movq 0x28(%rdi), %r11
leaq 0x1(%r11), %rbx
movq %rbx, 0x28(%rdi)
movb %bpl, (%rcx,%r11)
movb 0x1731(%rdi), %cl
movq 0x10(%rdi), %r11
movq 0x28(%rdi), %rbx
leaq 0x1(%rbx), %r14
movq %r14, 0x28(%rdi)
movb %cl, (%r11,%rbx)
movl 0x1734(%rdi), %r11d
movb $0x10, %cl
subb %r11b, %cl
shrl %cl, %r9d
movw %r9w, 0x1730(%rdi)
leal (%r15,%r11), %ecx
addl $-0x10, %ecx
jmp 0xe2c4
shll %cl, %r12d
orl %r12d, %ebp
movw %bp, 0x1730(%rdi)
addl %ecx, %r15d
movl %r15d, %ecx
movl %ecx, 0x1734(%rdi)
addl $0x3, %eax
cmpl 0x170c(%rdi), %eax
jb 0xdf7b
jmp 0xe2e1
movl 0x1734(%rdi), %ecx
movzwl 0x402(%rsi), %eax
movl $0x10, %r8d
subl %eax, %r8d
movzwl 0x400(%rsi), %edx
movl %edx, %esi
shll %cl, %esi
orw 0x1730(%rdi), %si
movw %si, 0x1730(%rdi)
cmpl %r8d, %ecx
jle 0xe359
movq 0x10(%rdi), %rcx
movq 0x28(%rdi), %r8
leaq 0x1(%r8), %r9
movq %r9, 0x28(%rdi)
movb %sil, (%rcx,%r8)
movb 0x1731(%rdi), %cl
movq 0x10(%rdi), %rsi
movq 0x28(%rdi), %r8
leaq 0x1(%r8), %r9
movq %r9, 0x28(%rdi)
movb %cl, (%rsi,%r8)
movl 0x1734(%rdi), %esi
movb $0x10, %cl
subb %sil, %cl
shrl %cl, %edx
movw %dx, 0x1730(%rdi)
leal (%rax,%rsi), %ecx
addl $-0x10, %ecx
jmp 0xe35b
addl %eax, %ecx
movl %ecx, 0x1734(%rdi)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| compress_block:
push rbp
push r15
push r14
push r13
push r12
push rbx
cmp dword ptr [rdi+170Ch], 0
jz loc_E2DB
xor eax, eax
lea r8, _length_code
lea r10, _dist_code
loc_DF7B:
mov rcx, [rdi+1700h]
lea r9d, [rax+1]
mov r11d, eax
movzx r11d, byte ptr [rcx+r11]
lea r12d, [rax+2]
movzx r15d, byte ptr [rcx+r9]
shl r15d, 8
or r15d, r11d
movzx r12d, byte ptr [rcx+r12]
jz loc_E03B
movzx r13d, byte ptr [r8+r12]
movzx r9d, word ptr [rsi+r13*4+406h]
mov ecx, [rdi+1734h]
mov ebx, 10h
sub ebx, r9d
movzx r11d, word ptr [rsi+r13*4+404h]
mov ebp, r11d
shl ebp, cl
or bp, [rdi+1730h]
mov [rdi+1730h], bp
cmp ecx, ebx
jle loc_E0C3
mov rcx, [rdi+10h]
mov rbx, [rdi+28h]
lea r14, [rbx+1]
mov [rdi+28h], r14
mov [rcx+rbx], bpl
mov cl, [rdi+1731h]
mov rbx, [rdi+10h]
mov r14, [rdi+28h]
lea rbp, [r14+1]
mov [rdi+28h], rbp
mov [rbx+r14], cl
mov ebx, [rdi+1734h]
mov cl, 10h
sub cl, bl
shr r11d, cl
mov [rdi+1730h], r11w
lea ecx, [r9+rbx]
add ecx, 0FFFFFFF0h
mov ebp, r11d
jmp loc_E0C6
loc_E03B:
movzx r9d, word ptr [rsi+r12*4+2]
mov ecx, [rdi+1734h]
mov r15d, 10h
sub r15d, r9d
movzx r11d, word ptr [rsi+r12*4]
mov ebp, r11d
shl ebp, cl
or bp, [rdi+1730h]
mov [rdi+1730h], bp
cmp ecx, r15d
jle loc_E160
mov rcx, [rdi+10h]
mov r15, [rdi+28h]
lea r12, [r15+1]
mov [rdi+28h], r12
mov [rcx+r15], bpl
mov cl, [rdi+1731h]
mov r15, [rdi+10h]
mov r12, [rdi+28h]
lea r13, [r12+1]
mov [rdi+28h], r13
mov [r15+r12], cl
mov r15d, [rdi+1734h]
mov cl, 10h
sub cl, r15b
shr r11d, cl
mov [rdi+1730h], r11w
lea ecx, [r9+r15]
add ecx, 0FFFFFFF0h
jmp loc_E2C4
loc_E0C3:
add ecx, r9d
loc_E0C6:
mov [rdi+1734h], ecx
lea r9, [r13-1Ch]
cmp r9, 0FFFFFFFFFFFFFFECh
jb loc_E181
lea r9, base_length
sub r12d, [r9+r13*4]
lea r9, extra_lbits
mov r13d, [r9+r13*4]
mov r9d, 10h
sub r9d, r13d
cmp ecx, r9d
jle short loc_E168
movzx r9d, r12w
shl r12d, cl
or ebp, r12d
mov [rdi+1730h], bp
mov rcx, [rdi+10h]
mov r11, [rdi+28h]
lea rbx, [r11+1]
mov [rdi+28h], rbx
mov [rcx+r11], bpl
mov cl, [rdi+1731h]
mov r11, [rdi+10h]
mov rbx, [rdi+28h]
lea r14, [rbx+1]
mov [rdi+28h], r14
mov [r11+rbx], cl
mov r11d, [rdi+1734h]
mov cl, 10h
sub cl, r11b
shr r9d, cl
mov [rdi+1730h], r9w
lea ecx, [r11+r13]
add ecx, 0FFFFFFF0h
mov ebp, r9d
jmp short loc_E17B
loc_E160:
add ecx, r9d
jmp loc_E2C4
loc_E168:
shl r12d, cl
or ebp, r12d
mov [rdi+1730h], bp
add r13d, ecx
mov ecx, r13d
loc_E17B:
mov [rdi+1734h], ecx
loc_E181:
lea r12d, [r15-1]
mov r9d, r12d
shr r9d, 7
add r9d, 100h
cmp r15d, 101h
cmovb r9d, r12d
movzx r15d, byte ptr [r10+r9]
movzx r13d, word ptr [rdx+r15*4+2]
mov r11d, 10h
movzx r9d, word ptr [rdx+r15*4]
mov ebx, r9d
shl ebx, cl
sub r11d, r13d
or ebp, ebx
mov [rdi+1730h], bp
cmp ecx, r11d
jle short loc_E21B
mov rcx, [rdi+10h]
mov r11, [rdi+28h]
lea rbx, [r11+1]
mov [rdi+28h], rbx
mov [rcx+r11], bpl
mov cl, [rdi+1731h]
mov r11, [rdi+10h]
mov rbx, [rdi+28h]
lea r14, [rbx+1]
mov [rdi+28h], r14
mov [r11+rbx], cl
mov r11d, [rdi+1734h]
mov cl, 10h
sub cl, r11b
shr r9d, cl
mov [rdi+1730h], r9w
lea ecx, [r11+r13]
add ecx, 0FFFFFFF0h
mov ebp, r9d
jmp short loc_E21E
loc_E21B:
add ecx, r13d
loc_E21E:
mov [rdi+1734h], ecx
cmp r15b, 4
jb loc_E2CA
lea r9, base_dist
sub r12d, [r9+r15*4]
lea r9, extra_dbits
mov r15d, [r9+r15*4]
mov r9d, 10h
sub r9d, r15d
cmp ecx, r9d
jle short loc_E2B1
movzx r9d, r12w
shl r12d, cl
or ebp, r12d
mov [rdi+1730h], bp
mov rcx, [rdi+10h]
mov r11, [rdi+28h]
lea rbx, [r11+1]
mov [rdi+28h], rbx
mov [rcx+r11], bpl
mov cl, [rdi+1731h]
mov r11, [rdi+10h]
mov rbx, [rdi+28h]
lea r14, [rbx+1]
mov [rdi+28h], r14
mov [r11+rbx], cl
mov r11d, [rdi+1734h]
mov cl, 10h
sub cl, r11b
shr r9d, cl
mov [rdi+1730h], r9w
lea ecx, [r15+r11]
add ecx, 0FFFFFFF0h
jmp short loc_E2C4
loc_E2B1:
shl r12d, cl
or ebp, r12d
mov [rdi+1730h], bp
add r15d, ecx
mov ecx, r15d
loc_E2C4:
mov [rdi+1734h], ecx
loc_E2CA:
add eax, 3
cmp eax, [rdi+170Ch]
jb loc_DF7B
jmp short loc_E2E1
loc_E2DB:
mov ecx, [rdi+1734h]
loc_E2E1:
movzx eax, word ptr [rsi+402h]
mov r8d, 10h
sub r8d, eax
movzx edx, word ptr [rsi+400h]
mov esi, edx
shl esi, cl
or si, [rdi+1730h]
mov [rdi+1730h], si
cmp ecx, r8d
jle short loc_E359
mov rcx, [rdi+10h]
mov r8, [rdi+28h]
lea r9, [r8+1]
mov [rdi+28h], r9
mov [rcx+r8], sil
mov cl, [rdi+1731h]
mov rsi, [rdi+10h]
mov r8, [rdi+28h]
lea r9, [r8+1]
mov [rdi+28h], r9
mov [rsi+r8], cl
mov esi, [rdi+1734h]
mov cl, 10h
sub cl, sil
shr edx, cl
mov [rdi+1730h], dx
lea ecx, [rax+rsi]
add ecx, 0FFFFFFF0h
jmp short loc_E35B
loc_E359:
add ecx, eax
loc_E35B:
mov [rdi+1734h], ecx
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long compress_block(long long a1, long long a2, long long a3)
{
unsigned int v3; // eax
long long v4; // rcx
unsigned int v5; // r15d
long long v6; // r12
long long v7; // r13
int v8; // r9d
int v9; // ecx
unsigned int v10; // r11d
int v11; // ebp
long long v12; // rcx
long long v13; // rbx
long long v14; // rbx
long long v15; // r14
int v16; // r11d
int v17; // ecx
int v18; // r9d
int v19; // ecx
unsigned int v20; // r11d
__int16 v21; // bp
long long v22; // rcx
long long v23; // r15
long long v24; // r15
long long v25; // r12
int v26; // ecx
int v27; // r12d
int v28; // r13d
__int16 v29; // bp
long long v30; // rcx
long long v31; // r11
long long v32; // r11
long long v33; // rbx
unsigned int v34; // r12d
long long v35; // r9
long long v36; // r15
int v37; // r13d
unsigned int v38; // r9d
int v39; // ebp
long long v40; // rcx
long long v41; // r11
long long v42; // r11
long long v43; // rbx
int v44; // r9d
unsigned int v45; // r12d
int v46; // r15d
int v47; // ebp
long long v48; // rcx
long long v49; // r11
long long v50; // r11
long long v51; // rbx
long long result; // rax
unsigned int v53; // edx
__int16 v54; // si
long long v55; // rcx
long long v56; // r8
long long v57; // rsi
long long v58; // r8
int v59; // ecx
if ( *(_DWORD *)(a1 + 5900) )
{
v3 = 0;
while ( 1 )
{
v4 = *(_QWORD *)(a1 + 5888);
v5 = *(unsigned __int8 *)(v4 + v3) | (*(unsigned __int8 *)(v4 + v3 + 1) << 8);
v6 = *(unsigned __int8 *)(v4 + v3 + 2);
if ( v5 )
{
v7 = length_code[v6];
v8 = *(unsigned __int16 *)(a2 + 4 * v7 + 1030);
v9 = *(_DWORD *)(a1 + 5940);
v10 = *(unsigned __int16 *)(a2 + 4 * v7 + 1028);
v11 = v10 << v9;
LOWORD(v11) = *(_WORD *)(a1 + 5936) | (v10 << v9);
*(_WORD *)(a1 + 5936) = v11;
if ( v9 <= 16 - v8 )
{
v17 = v8 + v9;
}
else
{
v12 = *(_QWORD *)(a1 + 16);
v13 = *(_QWORD *)(a1 + 40);
*(_QWORD *)(a1 + 40) = v13 + 1;
*(_BYTE *)(v12 + v13) = v11;
LOBYTE(v12) = *(_BYTE *)(a1 + 5937);
v14 = *(_QWORD *)(a1 + 16);
v15 = *(_QWORD *)(a1 + 40);
*(_QWORD *)(a1 + 40) = v15 + 1;
*(_BYTE *)(v14 + v15) = v12;
LODWORD(v14) = *(_DWORD *)(a1 + 5940);
v16 = v10 >> (16 - v14);
*(_WORD *)(a1 + 5936) = v16;
v17 = v8 + v14 - 16;
v11 = v16;
}
*(_DWORD *)(a1 + 5940) = v17;
if ( (unsigned long long)(v7 - 28) >= 0xFFFFFFFFFFFFFFECLL )
{
v27 = v6 - base_length[v7];
v28 = extra_lbits[v7];
if ( v17 <= 16 - v28 )
{
v11 |= v27 << v17;
*(_WORD *)(a1 + 5936) = v11;
v17 += v28;
}
else
{
v29 = (v27 << v17) | v11;
*(_WORD *)(a1 + 5936) = v29;
v30 = *(_QWORD *)(a1 + 16);
v31 = *(_QWORD *)(a1 + 40);
*(_QWORD *)(a1 + 40) = v31 + 1;
*(_BYTE *)(v30 + v31) = v29;
LOBYTE(v30) = *(_BYTE *)(a1 + 5937);
v32 = *(_QWORD *)(a1 + 16);
v33 = *(_QWORD *)(a1 + 40);
*(_QWORD *)(a1 + 40) = v33 + 1;
*(_BYTE *)(v32 + v33) = v30;
LODWORD(v32) = *(_DWORD *)(a1 + 5940);
*(_WORD *)(a1 + 5936) = (unsigned __int16)v27 >> (16 - v32);
v17 = v32 + v28 - 16;
v11 = (unsigned __int16)v27 >> (16 - v32);
}
*(_DWORD *)(a1 + 5940) = v17;
}
v34 = v5 - 1;
v35 = ((v5 - 1) >> 7) + 256;
if ( v5 < 0x101 )
v35 = v34;
v36 = dist_code[v35];
v37 = *(unsigned __int16 *)(a3 + 4 * v36 + 2);
v38 = *(unsigned __int16 *)(a3 + 4 * v36);
v39 = (v38 << v17) | v11;
*(_WORD *)(a1 + 5936) = v39;
if ( v17 <= 16 - v37 )
{
v26 = v37 + v17;
}
else
{
v40 = *(_QWORD *)(a1 + 16);
v41 = *(_QWORD *)(a1 + 40);
*(_QWORD *)(a1 + 40) = v41 + 1;
*(_BYTE *)(v40 + v41) = v39;
LOBYTE(v40) = *(_BYTE *)(a1 + 5937);
v42 = *(_QWORD *)(a1 + 16);
v43 = *(_QWORD *)(a1 + 40);
*(_QWORD *)(a1 + 40) = v43 + 1;
*(_BYTE *)(v42 + v43) = v40;
LODWORD(v42) = *(_DWORD *)(a1 + 5940);
v44 = v38 >> (16 - v42);
*(_WORD *)(a1 + 5936) = v44;
v26 = v42 + v37 - 16;
v39 = v44;
}
*(_DWORD *)(a1 + 5940) = v26;
if ( (unsigned __int8)v36 < 4u )
goto LABEL_25;
v45 = v34 - base_dist[v36];
v46 = extra_dbits[v36];
if ( v26 <= 16 - v46 )
{
*(_WORD *)(a1 + 5936) = ((_WORD)v45 << v26) | v39;
v26 += v46;
}
else
{
v47 = (v45 << v26) | v39;
*(_WORD *)(a1 + 5936) = v47;
v48 = *(_QWORD *)(a1 + 16);
v49 = *(_QWORD *)(a1 + 40);
*(_QWORD *)(a1 + 40) = v49 + 1;
*(_BYTE *)(v48 + v49) = v47;
LOBYTE(v48) = *(_BYTE *)(a1 + 5937);
v50 = *(_QWORD *)(a1 + 16);
v51 = *(_QWORD *)(a1 + 40);
*(_QWORD *)(a1 + 40) = v51 + 1;
*(_BYTE *)(v50 + v51) = v48;
LODWORD(v50) = *(_DWORD *)(a1 + 5940);
*(_WORD *)(a1 + 5936) = (unsigned __int16)v45 >> (16 - v50);
v26 = v46 + v50 - 16;
}
}
else
{
v18 = *(unsigned __int16 *)(a2 + 4 * v6 + 2);
v19 = *(_DWORD *)(a1 + 5940);
v20 = *(unsigned __int16 *)(a2 + 4 * v6);
v21 = *(_WORD *)(a1 + 5936) | (v20 << v19);
*(_WORD *)(a1 + 5936) = v21;
if ( v19 <= 16 - v18 )
{
v26 = v18 + v19;
}
else
{
v22 = *(_QWORD *)(a1 + 16);
v23 = *(_QWORD *)(a1 + 40);
*(_QWORD *)(a1 + 40) = v23 + 1;
*(_BYTE *)(v22 + v23) = v21;
LOBYTE(v22) = *(_BYTE *)(a1 + 5937);
v24 = *(_QWORD *)(a1 + 16);
v25 = *(_QWORD *)(a1 + 40);
*(_QWORD *)(a1 + 40) = v25 + 1;
*(_BYTE *)(v24 + v25) = v22;
LODWORD(v24) = *(_DWORD *)(a1 + 5940);
*(_WORD *)(a1 + 5936) = v20 >> (16 - v24);
v26 = v18 + v24 - 16;
}
}
*(_DWORD *)(a1 + 5940) = v26;
LABEL_25:
v3 += 3;
if ( v3 >= *(_DWORD *)(a1 + 5900) )
goto LABEL_28;
}
}
v26 = *(_DWORD *)(a1 + 5940);
LABEL_28:
result = *(unsigned __int16 *)(a2 + 1026);
v53 = *(unsigned __int16 *)(a2 + 1024);
v54 = *(_WORD *)(a1 + 5936) | (v53 << v26);
*(_WORD *)(a1 + 5936) = v54;
if ( v26 <= 16 - (int)result )
{
v59 = result + v26;
}
else
{
v55 = *(_QWORD *)(a1 + 16);
v56 = *(_QWORD *)(a1 + 40);
*(_QWORD *)(a1 + 40) = v56 + 1;
*(_BYTE *)(v55 + v56) = v54;
LOBYTE(v55) = *(_BYTE *)(a1 + 5937);
v57 = *(_QWORD *)(a1 + 16);
v58 = *(_QWORD *)(a1 + 40);
*(_QWORD *)(a1 + 40) = v58 + 1;
*(_BYTE *)(v57 + v58) = v55;
LODWORD(v57) = *(_DWORD *)(a1 + 5940);
*(_WORD *)(a1 + 5936) = v53 >> (16 - v57);
v59 = result + v57 - 16;
}
*(_DWORD *)(a1 + 5940) = v59;
return result;
}
| compress_block:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
CMP dword ptr [RDI + 0x170c],0x0
JZ 0x0010e2db
XOR EAX,EAX
LEA R8,[0x112e30]
LEA R10,[0x112c30]
LAB_0010df7b:
MOV RCX,qword ptr [RDI + 0x1700]
LEA R9D,[RAX + 0x1]
MOV R11D,EAX
MOVZX R11D,byte ptr [RCX + R11*0x1]
LEA R12D,[RAX + 0x2]
MOVZX R15D,byte ptr [RCX + R9*0x1]
SHL R15D,0x8
OR R15D,R11D
MOVZX R12D,byte ptr [RCX + R12*0x1]
JZ 0x0010e03b
MOVZX R13D,byte ptr [R8 + R12*0x1]
MOVZX R9D,word ptr [RSI + R13*0x4 + 0x406]
MOV ECX,dword ptr [RDI + 0x1734]
MOV EBX,0x10
SUB EBX,R9D
MOVZX R11D,word ptr [RSI + R13*0x4 + 0x404]
MOV EBP,R11D
SHL EBP,CL
OR BP,word ptr [RDI + 0x1730]
MOV word ptr [RDI + 0x1730],BP
CMP ECX,EBX
JLE 0x0010e0c3
MOV RCX,qword ptr [RDI + 0x10]
MOV RBX,qword ptr [RDI + 0x28]
LEA R14,[RBX + 0x1]
MOV qword ptr [RDI + 0x28],R14
MOV byte ptr [RCX + RBX*0x1],BPL
MOV CL,byte ptr [RDI + 0x1731]
MOV RBX,qword ptr [RDI + 0x10]
MOV R14,qword ptr [RDI + 0x28]
LEA RBP,[R14 + 0x1]
MOV qword ptr [RDI + 0x28],RBP
MOV byte ptr [RBX + R14*0x1],CL
MOV EBX,dword ptr [RDI + 0x1734]
MOV CL,0x10
SUB CL,BL
SHR R11D,CL
MOV word ptr [RDI + 0x1730],R11W
LEA ECX,[R9 + RBX*0x1]
ADD ECX,-0x10
MOV EBP,R11D
JMP 0x0010e0c6
LAB_0010e03b:
MOVZX R9D,word ptr [RSI + R12*0x4 + 0x2]
MOV ECX,dword ptr [RDI + 0x1734]
MOV R15D,0x10
SUB R15D,R9D
MOVZX R11D,word ptr [RSI + R12*0x4]
MOV EBP,R11D
SHL EBP,CL
OR BP,word ptr [RDI + 0x1730]
MOV word ptr [RDI + 0x1730],BP
CMP ECX,R15D
JLE 0x0010e160
MOV RCX,qword ptr [RDI + 0x10]
MOV R15,qword ptr [RDI + 0x28]
LEA R12,[R15 + 0x1]
MOV qword ptr [RDI + 0x28],R12
MOV byte ptr [RCX + R15*0x1],BPL
MOV CL,byte ptr [RDI + 0x1731]
MOV R15,qword ptr [RDI + 0x10]
MOV R12,qword ptr [RDI + 0x28]
LEA R13,[R12 + 0x1]
MOV qword ptr [RDI + 0x28],R13
MOV byte ptr [R15 + R12*0x1],CL
MOV R15D,dword ptr [RDI + 0x1734]
MOV CL,0x10
SUB CL,R15B
SHR R11D,CL
MOV word ptr [RDI + 0x1730],R11W
LEA ECX,[R9 + R15*0x1]
ADD ECX,-0x10
JMP 0x0010e2c4
LAB_0010e0c3:
ADD ECX,R9D
LAB_0010e0c6:
MOV dword ptr [RDI + 0x1734],ECX
LEA R9,[R13 + -0x1c]
CMP R9,-0x14
JC 0x0010e181
LEA R9,[0x1135a0]
SUB R12D,dword ptr [R9 + R13*0x4]
LEA R9,[0x113430]
MOV R13D,dword ptr [R9 + R13*0x4]
MOV R9D,0x10
SUB R9D,R13D
CMP ECX,R9D
JLE 0x0010e168
MOVZX R9D,R12W
SHL R12D,CL
OR EBP,R12D
MOV word ptr [RDI + 0x1730],BP
MOV RCX,qword ptr [RDI + 0x10]
MOV R11,qword ptr [RDI + 0x28]
LEA RBX,[R11 + 0x1]
MOV qword ptr [RDI + 0x28],RBX
MOV byte ptr [RCX + R11*0x1],BPL
MOV CL,byte ptr [RDI + 0x1731]
MOV R11,qword ptr [RDI + 0x10]
MOV RBX,qword ptr [RDI + 0x28]
LEA R14,[RBX + 0x1]
MOV qword ptr [RDI + 0x28],R14
MOV byte ptr [R11 + RBX*0x1],CL
MOV R11D,dword ptr [RDI + 0x1734]
MOV CL,0x10
SUB CL,R11B
SHR R9D,CL
MOV word ptr [RDI + 0x1730],R9W
LEA ECX,[R11 + R13*0x1]
ADD ECX,-0x10
MOV EBP,R9D
JMP 0x0010e17b
LAB_0010e160:
ADD ECX,R9D
JMP 0x0010e2c4
LAB_0010e168:
SHL R12D,CL
OR EBP,R12D
MOV word ptr [RDI + 0x1730],BP
ADD R13D,ECX
MOV ECX,R13D
LAB_0010e17b:
MOV dword ptr [RDI + 0x1734],ECX
LAB_0010e181:
LEA R12D,[R15 + -0x1]
MOV R9D,R12D
SHR R9D,0x7
ADD R9D,0x100
CMP R15D,0x101
CMOVC R9D,R12D
MOVZX R15D,byte ptr [R10 + R9*0x1]
MOVZX R13D,word ptr [RDX + R15*0x4 + 0x2]
MOV R11D,0x10
MOVZX R9D,word ptr [RDX + R15*0x4]
MOV EBX,R9D
SHL EBX,CL
SUB R11D,R13D
OR EBP,EBX
MOV word ptr [RDI + 0x1730],BP
CMP ECX,R11D
JLE 0x0010e21b
MOV RCX,qword ptr [RDI + 0x10]
MOV R11,qword ptr [RDI + 0x28]
LEA RBX,[R11 + 0x1]
MOV qword ptr [RDI + 0x28],RBX
MOV byte ptr [RCX + R11*0x1],BPL
MOV CL,byte ptr [RDI + 0x1731]
MOV R11,qword ptr [RDI + 0x10]
MOV RBX,qword ptr [RDI + 0x28]
LEA R14,[RBX + 0x1]
MOV qword ptr [RDI + 0x28],R14
MOV byte ptr [R11 + RBX*0x1],CL
MOV R11D,dword ptr [RDI + 0x1734]
MOV CL,0x10
SUB CL,R11B
SHR R9D,CL
MOV word ptr [RDI + 0x1730],R9W
LEA ECX,[R11 + R13*0x1]
ADD ECX,-0x10
MOV EBP,R9D
JMP 0x0010e21e
LAB_0010e21b:
ADD ECX,R13D
LAB_0010e21e:
MOV dword ptr [RDI + 0x1734],ECX
CMP R15B,0x4
JC 0x0010e2ca
LEA R9,[0x113620]
SUB R12D,dword ptr [R9 + R15*0x4]
LEA R9,[0x1134b0]
MOV R15D,dword ptr [R9 + R15*0x4]
MOV R9D,0x10
SUB R9D,R15D
CMP ECX,R9D
JLE 0x0010e2b1
MOVZX R9D,R12W
SHL R12D,CL
OR EBP,R12D
MOV word ptr [RDI + 0x1730],BP
MOV RCX,qword ptr [RDI + 0x10]
MOV R11,qword ptr [RDI + 0x28]
LEA RBX,[R11 + 0x1]
MOV qword ptr [RDI + 0x28],RBX
MOV byte ptr [RCX + R11*0x1],BPL
MOV CL,byte ptr [RDI + 0x1731]
MOV R11,qword ptr [RDI + 0x10]
MOV RBX,qword ptr [RDI + 0x28]
LEA R14,[RBX + 0x1]
MOV qword ptr [RDI + 0x28],R14
MOV byte ptr [R11 + RBX*0x1],CL
MOV R11D,dword ptr [RDI + 0x1734]
MOV CL,0x10
SUB CL,R11B
SHR R9D,CL
MOV word ptr [RDI + 0x1730],R9W
LEA ECX,[R15 + R11*0x1]
ADD ECX,-0x10
JMP 0x0010e2c4
LAB_0010e2b1:
SHL R12D,CL
OR EBP,R12D
MOV word ptr [RDI + 0x1730],BP
ADD R15D,ECX
MOV ECX,R15D
LAB_0010e2c4:
MOV dword ptr [RDI + 0x1734],ECX
LAB_0010e2ca:
ADD EAX,0x3
CMP EAX,dword ptr [RDI + 0x170c]
JC 0x0010df7b
JMP 0x0010e2e1
LAB_0010e2db:
MOV ECX,dword ptr [RDI + 0x1734]
LAB_0010e2e1:
MOVZX EAX,word ptr [RSI + 0x402]
MOV R8D,0x10
SUB R8D,EAX
MOVZX EDX,word ptr [RSI + 0x400]
MOV ESI,EDX
SHL ESI,CL
OR SI,word ptr [RDI + 0x1730]
MOV word ptr [RDI + 0x1730],SI
CMP ECX,R8D
JLE 0x0010e359
MOV RCX,qword ptr [RDI + 0x10]
MOV R8,qword ptr [RDI + 0x28]
LEA R9,[R8 + 0x1]
MOV qword ptr [RDI + 0x28],R9
MOV byte ptr [RCX + R8*0x1],SIL
MOV CL,byte ptr [RDI + 0x1731]
MOV RSI,qword ptr [RDI + 0x10]
MOV R8,qword ptr [RDI + 0x28]
LEA R9,[R8 + 0x1]
MOV qword ptr [RDI + 0x28],R9
MOV byte ptr [RSI + R8*0x1],CL
MOV ESI,dword ptr [RDI + 0x1734]
MOV CL,0x10
SUB CL,SIL
SHR EDX,CL
MOV word ptr [RDI + 0x1730],DX
LEA ECX,[RAX + RSI*0x1]
ADD ECX,-0x10
JMP 0x0010e35b
LAB_0010e359:
ADD ECX,EAX
LAB_0010e35b:
MOV dword ptr [RDI + 0x1734],ECX
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void compress_block(long param_1,long param_2,long param_3)
{
byte bVar1;
ushort uVar2;
ushort uVar3;
int iVar4;
long lVar5;
uint uVar6;
uint uVar7;
int iVar8;
ushort uVar9;
uint uVar10;
uint uVar11;
ulong uVar12;
uint uVar13;
if (*(int *)(param_1 + 0x170c) == 0) {
iVar8 = *(int *)(param_1 + 0x1734);
}
else {
uVar7 = 0;
do {
lVar5 = *(long *)(param_1 + 0x1700);
uVar13 = (uint)CONCAT11(*(int1 *)(lVar5 + (ulong)(uVar7 + 1)),
*(int1 *)(lVar5 + (ulong)uVar7));
bVar1 = *(byte *)(lVar5 + (ulong)(uVar7 + 2));
uVar12 = (ulong)bVar1;
if (uVar13 == 0) {
uVar2 = *(ushort *)(param_2 + 2 + uVar12 * 4);
iVar8 = *(int *)(param_1 + 0x1734);
uVar3 = *(ushort *)(param_2 + uVar12 * 4);
uVar9 = uVar3 << ((byte)iVar8 & 0x1f) | *(ushort *)(param_1 + 0x1730);
*(ushort *)(param_1 + 0x1730) = uVar9;
if ((int)(0x10 - (uint)uVar2) < iVar8) {
lVar5 = *(long *)(param_1 + 0x28);
*(long *)(param_1 + 0x28) = lVar5 + 1;
*(char *)(*(long *)(param_1 + 0x10) + lVar5) = (char)uVar9;
lVar5 = *(long *)(param_1 + 0x28);
*(long *)(param_1 + 0x28) = lVar5 + 1;
*(int1 *)(*(long *)(param_1 + 0x10) + lVar5) = *(int1 *)(param_1 + 0x1731);
*(ushort *)(param_1 + 0x1730) = uVar3 >> (0x10U - (char)*(int *)(param_1 + 0x1734) & 0x1f)
;
iVar8 = (uint)uVar2 + *(int *)(param_1 + 0x1734) + -0x10;
}
else {
iVar8 = iVar8 + (uint)uVar2;
}
LAB_0010e2c4:
*(int *)(param_1 + 0x1734) = iVar8;
}
else {
uVar12 = (ulong)(byte)_length_code[uVar12];
uVar2 = *(ushort *)(param_2 + 0x406 + uVar12 * 4);
iVar8 = *(int *)(param_1 + 0x1734);
uVar3 = *(ushort *)(param_2 + 0x404 + uVar12 * 4);
uVar9 = uVar3 << ((byte)iVar8 & 0x1f) | *(ushort *)(param_1 + 0x1730);
*(ushort *)(param_1 + 0x1730) = uVar9;
if ((int)(0x10 - (uint)uVar2) < iVar8) {
lVar5 = *(long *)(param_1 + 0x28);
*(long *)(param_1 + 0x28) = lVar5 + 1;
*(char *)(*(long *)(param_1 + 0x10) + lVar5) = (char)uVar9;
lVar5 = *(long *)(param_1 + 0x28);
*(long *)(param_1 + 0x28) = lVar5 + 1;
*(int1 *)(*(long *)(param_1 + 0x10) + lVar5) = *(int1 *)(param_1 + 0x1731);
uVar9 = uVar3 >> (0x10U - (char)*(int *)(param_1 + 0x1734) & 0x1f);
*(ushort *)(param_1 + 0x1730) = uVar9;
iVar8 = (uint)uVar2 + *(int *)(param_1 + 0x1734) + -0x10;
}
else {
iVar8 = iVar8 + (uint)uVar2;
}
uVar10 = (uint)uVar9;
*(int *)(param_1 + 0x1734) = iVar8;
if (0xffffffffffffffeb < uVar12 - 0x1c) {
uVar11 = (uint)bVar1 - *(int *)(base_length + uVar12 * 4);
iVar4 = *(int *)(extra_lbits + uVar12 * 4);
if (0x10 - iVar4 < iVar8) {
uVar10 = uVar10 | uVar11 << ((byte)iVar8 & 0x1f);
*(short *)(param_1 + 0x1730) = (short)uVar10;
lVar5 = *(long *)(param_1 + 0x28);
*(long *)(param_1 + 0x28) = lVar5 + 1;
*(char *)(*(long *)(param_1 + 0x10) + lVar5) = (char)uVar10;
lVar5 = *(long *)(param_1 + 0x28);
*(long *)(param_1 + 0x28) = lVar5 + 1;
*(int1 *)(*(long *)(param_1 + 0x10) + lVar5) = *(int1 *)(param_1 + 0x1731);
uVar10 = (uVar11 & 0xffff) >> (0x10U - (char)*(int *)(param_1 + 0x1734) & 0x1f);
*(short *)(param_1 + 0x1730) = (short)uVar10;
iVar8 = *(int *)(param_1 + 0x1734) + iVar4 + -0x10;
}
else {
uVar10 = uVar10 | uVar11 << ((byte)iVar8 & 0x1f);
*(short *)(param_1 + 0x1730) = (short)uVar10;
iVar8 = iVar4 + iVar8;
}
*(int *)(param_1 + 0x1734) = iVar8;
}
uVar11 = uVar13 - 1;
uVar6 = (uVar11 >> 7) + 0x100;
if (uVar13 < 0x101) {
uVar6 = uVar11;
}
bVar1 = (&_dist_code)[uVar6];
uVar12 = (ulong)bVar1;
uVar2 = *(ushort *)(param_3 + 2 + uVar12 * 4);
uVar3 = *(ushort *)(param_3 + uVar12 * 4);
uVar10 = uVar10 | (uint)uVar3 << ((byte)iVar8 & 0x1f);
*(short *)(param_1 + 0x1730) = (short)uVar10;
if ((int)(0x10 - (uint)uVar2) < iVar8) {
lVar5 = *(long *)(param_1 + 0x28);
*(long *)(param_1 + 0x28) = lVar5 + 1;
*(char *)(*(long *)(param_1 + 0x10) + lVar5) = (char)uVar10;
lVar5 = *(long *)(param_1 + 0x28);
*(long *)(param_1 + 0x28) = lVar5 + 1;
*(int1 *)(*(long *)(param_1 + 0x10) + lVar5) = *(int1 *)(param_1 + 0x1731);
uVar3 = uVar3 >> (0x10U - (char)*(int *)(param_1 + 0x1734) & 0x1f);
*(ushort *)(param_1 + 0x1730) = uVar3;
iVar8 = *(int *)(param_1 + 0x1734) + (uint)uVar2 + -0x10;
uVar10 = (uint)uVar3;
}
else {
iVar8 = iVar8 + (uint)uVar2;
}
*(int *)(param_1 + 0x1734) = iVar8;
if (3 < bVar1) {
uVar11 = uVar11 - *(int *)(base_dist + uVar12 * 4);
iVar4 = *(int *)(extra_dbits + uVar12 * 4);
if (0x10 - iVar4 < iVar8) {
uVar10 = uVar10 | uVar11 << ((byte)iVar8 & 0x1f);
*(short *)(param_1 + 0x1730) = (short)uVar10;
lVar5 = *(long *)(param_1 + 0x28);
*(long *)(param_1 + 0x28) = lVar5 + 1;
*(char *)(*(long *)(param_1 + 0x10) + lVar5) = (char)uVar10;
lVar5 = *(long *)(param_1 + 0x28);
*(long *)(param_1 + 0x28) = lVar5 + 1;
*(int1 *)(*(long *)(param_1 + 0x10) + lVar5) = *(int1 *)(param_1 + 0x1731);
*(short *)(param_1 + 0x1730) =
(short)((uVar11 & 0xffff) >> (0x10U - (char)*(int *)(param_1 + 0x1734) & 0x1f));
iVar8 = iVar4 + *(int *)(param_1 + 0x1734) + -0x10;
}
else {
*(ushort *)(param_1 + 0x1730) =
(ushort)uVar10 | (ushort)(uVar11 << ((byte)iVar8 & 0x1f));
iVar8 = iVar4 + iVar8;
}
goto LAB_0010e2c4;
}
}
uVar7 = uVar7 + 3;
} while (uVar7 < *(uint *)(param_1 + 0x170c));
}
uVar2 = *(ushort *)(param_2 + 0x402);
uVar3 = *(ushort *)(param_2 + 0x400);
uVar9 = uVar3 << ((byte)iVar8 & 0x1f) | *(ushort *)(param_1 + 0x1730);
*(ushort *)(param_1 + 0x1730) = uVar9;
if ((int)(0x10 - (uint)uVar2) < iVar8) {
lVar5 = *(long *)(param_1 + 0x28);
*(long *)(param_1 + 0x28) = lVar5 + 1;
*(char *)(*(long *)(param_1 + 0x10) + lVar5) = (char)uVar9;
lVar5 = *(long *)(param_1 + 0x28);
*(long *)(param_1 + 0x28) = lVar5 + 1;
*(int1 *)(*(long *)(param_1 + 0x10) + lVar5) = *(int1 *)(param_1 + 0x1731);
*(ushort *)(param_1 + 0x1730) = uVar3 >> (0x10U - (char)*(int *)(param_1 + 0x1734) & 0x1f);
iVar8 = (uint)uVar2 + *(int *)(param_1 + 0x1734) + -0x10;
}
else {
iVar8 = iVar8 + (uint)uVar2;
}
*(int *)(param_1 + 0x1734) = iVar8;
return;
}
|
|
968 | read_long_data2 | eloqsql/storage/maria/ma_blockrec.c | static my_bool read_long_data2(MARIA_HA *info, uchar *to, ulong length,
MARIA_EXTENT_CURSOR *extent,
uchar **data, uchar **end_of_data)
{
uint left_length= (uint) (*end_of_data - *data);
DBUG_ENTER("read_long_data2");
DBUG_PRINT("enter", ("length: %lu left_length: %u",
length, left_length));
DBUG_ASSERT(*data <= *end_of_data);
/*
Fields are never split in middle. This means that if length > rest-of-data
we should start reading from the next extent. The reason we may have
data left on the page is that if the fixed part of the row was less than
min_block_length the head block was extended to min_block_length.
This may change in the future, which is why we have the loop written
the way it's written.
*/
if (extent->first_extent && length > left_length)
{
*end_of_data= *data;
left_length= 0;
}
for(;;)
{
if (unlikely(left_length >= length))
{
memcpy(to, *data, length);
(*data)+= length;
DBUG_PRINT("info", ("left_length: %u", left_length - (uint) length));
DBUG_RETURN(0);
}
memcpy(to, *data, left_length);
to+= left_length;
length-= left_length;
if (!(*data= read_next_extent(info, extent, end_of_data)))
break;
left_length= (uint) (*end_of_data - *data);
}
DBUG_RETURN(1);
} | O3 | c | read_long_data2:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r12
movq %r8, %r13
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, -0x30(%rbp)
movq (%r9), %rdi
movq (%r8), %rax
subq %rax, %rdi
movq %rcx, -0x38(%rbp)
cmpb $0x0, 0x34(%rcx)
setne %dl
movl %edi, %esi
cmpq %r14, %rsi
setb %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x64154
movq %rax, (%r12)
movq (%r13), %rax
xorl %edi, %edi
movl %edi, %ebx
cmpq %r14, %rbx
jae 0x641a1
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x29080
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %r12, %rdx
callq 0x5f20b
movq %rax, (%r13)
testq %rax, %rax
je 0x64190
subq %rbx, %r14
addq %rbx, %r15
movl (%r12), %ebx
subl %eax, %ebx
jmp 0x64156
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x29080
addq %r14, (%r13)
xorl %eax, %eax
jmp 0x64192
| read_long_data2:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r12, r9
mov r13, r8
mov r14, rdx
mov r15, rsi
mov [rbp+var_30], rdi
mov rdi, [r9]
mov rax, [r8]
sub rdi, rax
mov [rbp+var_38], rcx
cmp byte ptr [rcx+34h], 0
setnz dl
mov esi, edi
cmp rsi, r14
setb sil
and sil, dl
cmp sil, 1
jnz short loc_64154
mov [r12], rax
mov rax, [r13+0]
xor edi, edi
loc_64154:
mov ebx, edi
loc_64156:
cmp rbx, r14
jnb short loc_641A1
mov rdi, r15
mov rsi, rax
mov rdx, rbx
call _memcpy
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_38]
mov rdx, r12
call read_next_extent
mov [r13+0], rax
test rax, rax
jz short loc_64190
sub r14, rbx
add r15, rbx
mov ebx, [r12]
sub ebx, eax
jmp short loc_64156
loc_64190:
mov al, 1
loc_64192:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_641A1:
mov rdi, r15
mov rsi, rax
mov rdx, r14
call _memcpy
add [r13+0], r14
xor eax, eax
jmp short loc_64192
| long long read_long_data2(long long *a1, long long a2, unsigned long long a3, long long a4, long long *a5, long long *a6)
{
unsigned long long v8; // r14
long long next_extent; // rax
long long v11; // rdi
unsigned long long i; // rbx
unsigned long long v13; // rcx
long long v14; // r8
int v15; // r9d
v8 = a3;
next_extent = *a5;
v11 = *a6 - *a5;
if ( *(_BYTE *)(a4 + 52) != 0 && (unsigned int)v11 < a3 )
{
*a6 = next_extent;
next_extent = *a5;
LODWORD(v11) = 0;
}
for ( i = (unsigned int)v11; i < v8; i = (unsigned int)(*(_DWORD *)a6 - next_extent) )
{
memcpy(a2, next_extent, i);
next_extent = read_next_extent(a1, (long long *)a4, (unsigned long long)a6, v13, v14, v15);
*a5 = next_extent;
if ( !next_extent )
return 1LL;
v8 -= i;
a2 += i;
}
memcpy(a2, next_extent, v8);
*a5 += v8;
return 0LL;
}
| read_long_data2:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R12,R9
MOV R13,R8
MOV R14,RDX
MOV R15,RSI
MOV qword ptr [RBP + -0x30],RDI
MOV RDI,qword ptr [R9]
MOV RAX,qword ptr [R8]
SUB RDI,RAX
MOV qword ptr [RBP + -0x38],RCX
CMP byte ptr [RCX + 0x34],0x0
SETNZ DL
MOV ESI,EDI
CMP RSI,R14
SETC SIL
AND SIL,DL
CMP SIL,0x1
JNZ 0x00164154
MOV qword ptr [R12],RAX
MOV RAX,qword ptr [R13]
XOR EDI,EDI
LAB_00164154:
MOV EBX,EDI
LAB_00164156:
CMP RBX,R14
JNC 0x001641a1
MOV RDI,R15
MOV RSI,RAX
MOV RDX,RBX
CALL 0x00129080
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x38]
MOV RDX,R12
CALL 0x0015f20b
MOV qword ptr [R13],RAX
TEST RAX,RAX
JZ 0x00164190
SUB R14,RBX
ADD R15,RBX
MOV EBX,dword ptr [R12]
SUB EBX,EAX
JMP 0x00164156
LAB_00164190:
MOV AL,0x1
LAB_00164192:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001641a1:
MOV RDI,R15
MOV RSI,RAX
MOV RDX,R14
CALL 0x00129080
ADD qword ptr [R13],R14
XOR EAX,EAX
JMP 0x00164192
|
int8
read_long_data2(int8 param_1,void *param_2,ulong param_3,long param_4,long *param_5,
long *param_6)
{
void *__src;
ulong uVar1;
__src = (void *)*param_5;
uVar1 = *param_6 - (long)__src;
if ((uVar1 & 0xffffffff) < param_3 && *(char *)(param_4 + 0x34) != '\0') {
*param_6 = (long)__src;
__src = (void *)*param_5;
uVar1 = 0;
}
uVar1 = uVar1 & 0xffffffff;
while( true ) {
if (param_3 <= uVar1) {
memcpy(param_2,__src,param_3);
*param_5 = *param_5 + param_3;
return 0;
}
memcpy(param_2,__src,uVar1);
__src = (void *)read_next_extent(param_1,param_4,param_6);
*param_5 = (long)__src;
if (__src == (void *)0x0) break;
param_3 = param_3 - uVar1;
param_2 = (void *)((long)param_2 + uVar1);
uVar1 = (ulong)(uint)((int)*param_6 - (int)__src);
}
return 1;
}
|
|
969 | google::protobuf::stringpiece_internal::StringPiece::find_last_of(google::protobuf::stringpiece_internal::StringPiece, unsigned long) const | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/stubs/stringpiece.cc | StringPiece::size_type StringPiece::find_last_of(StringPiece s,
size_type pos) const {
if (empty() || s.empty()) return npos;
// Avoid the cost of BuildLookupTable() for a single-character search.
if (s.length_ == 1) return find_last_of(s.ptr_[0], pos);
bool lookup[UCHAR_MAX + 1] = { false };
BuildLookupTable(s, lookup);
for (size_type i = std::min(pos, length_ - 1);; --i) {
if (lookup[static_cast<unsigned char>(ptr_[i])]) {
return i;
}
if (i == 0) break;
}
return npos;
} | O3 | cpp | google::protobuf::stringpiece_internal::StringPiece::find_last_of(google::protobuf::stringpiece_internal::StringPiece, unsigned long) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rcx, %r14
movq 0x8(%rdi), %r13
testq %r13, %r13
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
je 0xa74c4
movq $-0x1, %rax
jmp 0xa7546
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
cmpq $0x1, %rdx
jne 0xa74ee
decq %r13
cmpq %r14, %r13
cmovaeq %r14, %r13
movb (%r15), %cl
movq (%rbx), %rdx
cmpb %cl, (%rdx,%r13)
jne 0xa7558
movq %r13, %rax
jmp 0xa7546
movq %rsp, %rdi
xorl %ebp, %ebp
movl $0x100, %edx # imm = 0x100
xorl %esi, %esi
callq 0xf1d0
movzbl (%r15,%rbp), %eax
movb $0x1, (%rsp,%rax)
incq %rbp
cmpq %rbp, %r12
jne 0xa74ff
decq %r13
cmpq %r14, %r13
cmovaeq %r14, %r13
movq (%rbx), %rax
incq %r13
movq %r13, %rdx
movzbl -0x1(%rax,%r13), %ecx
movb (%rsp,%rcx), %cl
decq %r13
cmpq $0x1, %rdx
je 0xa7539
testb %cl, %cl
je 0xa7520
testb %cl, %cl
movq $-0x1, %rax
cmovneq %r13, %rax
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %rax
subq $0x1, %rax
jb 0xa74b8
cmpb %cl, -0x1(%rdx,%r13)
movq %rax, %r13
jne 0xa755b
jmp 0xa7546
nop
| _ZNK6google8protobuf20stringpiece_internal11StringPiece12find_last_ofES2_m:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 108h
mov r14, rcx
mov r13, [rdi+8]
test r13, r13
setz al
test rdx, rdx
setz cl
or cl, al
jz short loc_A74C4
loc_A74B8:
mov rax, 0FFFFFFFFFFFFFFFFh
jmp loc_A7546
loc_A74C4:
mov r12, rdx
mov r15, rsi
mov rbx, rdi
cmp rdx, 1
jnz short loc_A74EE
dec r13
cmp r13, r14
cmovnb r13, r14
mov cl, [r15]
mov rdx, [rbx]
cmp [rdx+r13], cl
jnz short loc_A7558
mov rax, r13
jmp short loc_A7546
loc_A74EE:
mov rdi, rsp
xor ebp, ebp
mov edx, 100h
xor esi, esi
call _memset
loc_A74FF:
movzx eax, byte ptr [r15+rbp]
mov [rsp+rax+138h+var_138], 1
inc rbp
cmp r12, rbp
jnz short loc_A74FF
dec r13
cmp r13, r14
cmovnb r13, r14
mov rax, [rbx]
inc r13
loc_A7520:
mov rdx, r13
movzx ecx, byte ptr [rax+r13-1]
mov cl, [rsp+rcx+138h+var_138]
dec r13
cmp rdx, 1
jz short loc_A7539
test cl, cl
jz short loc_A7520
loc_A7539:
test cl, cl
mov rax, 0FFFFFFFFFFFFFFFFh
cmovnz rax, r13
loc_A7546:
add rsp, 108h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_A7558:
mov rax, r13
loc_A755B:
sub rax, 1
jb loc_A74B8
cmp [rdx+r13-1], cl
mov r13, rax
jnz short loc_A755B
jmp short loc_A7546
| long long google::protobuf::stringpiece_internal::StringPiece::find_last_of(
_QWORD *a1,
_BYTE *a2,
long long a3,
unsigned long long a4)
{
long long v5; // r13
long long result; // rax
unsigned long long v8; // r13
long long v9; // rbp
unsigned long long v10; // r13
unsigned long long v11; // r13
unsigned long long v12; // rdx
char v13; // cl
bool v15; // zf
_BYTE v16[312]; // [rsp+0h] [rbp-138h] BYREF
v5 = a1[1];
if ( v5 == 0 || a3 == 0 )
return -1LL;
if ( a3 == 1 )
{
v8 = v5 - 1;
if ( v8 >= a4 )
v8 = a4;
if ( *(_BYTE *)(*a1 + v8) != *a2 )
{
result = v8;
while ( result-- != 0 )
{
v15 = *(_BYTE *)(*a1 + v8 - 1) == *a2;
v8 = result;
if ( v15 )
return result;
}
return -1LL;
}
return v8;
}
else
{
v9 = 0LL;
memset(v16, 0LL, 256LL);
do
v16[(unsigned __int8)a2[v9++]] = 1;
while ( a3 != v9 );
v10 = v5 - 1;
if ( v10 >= a4 )
v10 = a4;
v11 = v10 + 1;
do
{
v12 = v11;
v13 = v16[*(unsigned __int8 *)(*a1 + v11-- - 1)];
}
while ( v12 != 1 && !v13 );
result = -1LL;
if ( v13 )
return v11;
}
return result;
}
| find_last_of:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x108
MOV R14,RCX
MOV R13,qword ptr [RDI + 0x8]
TEST R13,R13
SETZ AL
TEST RDX,RDX
SETZ CL
OR CL,AL
JZ 0x001a74c4
LAB_001a74b8:
MOV RAX,-0x1
JMP 0x001a7546
LAB_001a74c4:
MOV R12,RDX
MOV R15,RSI
MOV RBX,RDI
CMP RDX,0x1
JNZ 0x001a74ee
DEC R13
CMP R13,R14
CMOVNC R13,R14
MOV CL,byte ptr [R15]
MOV RDX,qword ptr [RBX]
CMP byte ptr [RDX + R13*0x1],CL
JNZ 0x001a7558
MOV RAX,R13
JMP 0x001a7546
LAB_001a74ee:
MOV RDI,RSP
XOR EBP,EBP
MOV EDX,0x100
XOR ESI,ESI
CALL 0x0010f1d0
LAB_001a74ff:
MOVZX EAX,byte ptr [R15 + RBP*0x1]
MOV byte ptr [RSP + RAX*0x1],0x1
INC RBP
CMP R12,RBP
JNZ 0x001a74ff
DEC R13
CMP R13,R14
CMOVNC R13,R14
MOV RAX,qword ptr [RBX]
INC R13
LAB_001a7520:
MOV RDX,R13
MOVZX ECX,byte ptr [RAX + R13*0x1 + -0x1]
MOV CL,byte ptr [RSP + RCX*0x1]
DEC R13
CMP RDX,0x1
JZ 0x001a7539
TEST CL,CL
JZ 0x001a7520
LAB_001a7539:
TEST CL,CL
MOV RAX,-0x1
CMOVNZ RAX,R13
LAB_001a7546:
ADD RSP,0x108
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001a7558:
MOV RAX,R13
LAB_001a755b:
SUB RAX,0x1
JC 0x001a74b8
CMP byte ptr [RDX + R13*0x1 + -0x1],CL
MOV R13,RAX
JNZ 0x001a755b
JMP 0x001a7546
|
/* google::protobuf::stringpiece_internal::StringPiece::find_last_of(google::protobuf::stringpiece_internal::StringPiece,
unsigned long) const */
ulong google::protobuf::stringpiece_internal::StringPiece::find_last_of
(long *param_1,char *param_2,long param_3,ulong param_4)
{
byte *pbVar1;
char cVar2;
long lVar3;
ulong uVar4;
long lVar5;
ulong uVar6;
char acStack_138 [264];
lVar3 = param_1[1];
if (param_3 == 0 || lVar3 == 0) {
LAB_001a74b8:
uVar4 = 0xffffffffffffffff;
}
else if (param_3 == 1) {
uVar4 = lVar3 - 1U;
if (param_4 <= lVar3 - 1U) {
uVar4 = param_4;
}
cVar2 = *(char *)(*param_1 + uVar4);
while (cVar2 != *param_2) {
if (uVar4 == 0) goto LAB_001a74b8;
cVar2 = *(char *)(*param_1 + -1 + uVar4);
uVar4 = uVar4 - 1;
}
}
else {
lVar5 = 0;
memset(acStack_138,0,0x100);
do {
acStack_138[(byte)param_2[lVar5]] = '\x01';
lVar5 = lVar5 + 1;
} while (param_3 != lVar5);
uVar4 = lVar3 - 1U;
if (param_4 <= lVar3 - 1U) {
uVar4 = param_4;
}
uVar4 = uVar4 + 1;
do {
pbVar1 = (byte *)(*param_1 + -1 + uVar4);
uVar6 = uVar4 - 1;
if (uVar4 == 1) break;
uVar4 = uVar6;
} while (acStack_138[*pbVar1] == '\0');
uVar4 = 0xffffffffffffffff;
if (acStack_138[*pbVar1] != '\0') {
uVar4 = uVar6;
}
}
return uVar4;
}
|
|
970 | nglog::IsFailureSignalHandlerInstalled() | ng-log[P]ng-log/src/signalhandler.cc | bool IsFailureSignalHandlerInstalled() {
#ifdef HAVE_SIGACTION
// TODO(andschwa): Return kFailureSignalHandlerInstalled?
struct sigaction sig_action;
memset(&sig_action, 0, sizeof(sig_action));
sigemptyset(&sig_action.sa_mask);
sigaction(SIGABRT, nullptr, &sig_action);
if (sig_action.sa_sigaction == &FailureSignalHandler) {
return true;
}
#elif defined(NGLOG_OS_WINDOWS)
return kFailureSignalHandlerInstalled;
#endif // HAVE_SIGACTION
return false;
} | O1 | cpp | nglog::IsFailureSignalHandlerInstalled():
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsp, %rbx
movl $0x98, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x72b0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x76a0
movl $0x6, %edi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x76b0
leaq 0x12(%rip), %rax # 0x2082d
cmpq %rax, -0x8(%r14)
sete %al
addq $0x98, %rsp
popq %rbx
popq %r14
retq
| _ZN5nglog31IsFailureSignalHandlerInstalledEv:
push r14
push rbx
sub rsp, 98h
mov rbx, rsp
mov edx, 98h
mov rdi, rbx
xor esi, esi
call _memset
lea r14, [rsp+0A8h+var_A0]
mov rdi, r14
call _sigemptyset
mov edi, 6
xor esi, esi
mov rdx, rbx
call _sigaction
lea rax, _ZN5nglog12_GLOBAL__N_120FailureSignalHandlerEiP9siginfo_tPv; nglog::`anonymous namespace'::FailureSignalHandler(int,siginfo_t *,void *)
cmp [r14-8], rax
setz al
add rsp, 98h
pop rbx
pop r14
retn
| bool nglog::IsFailureSignalHandlerInstalled(nglog *this)
{
long long ( *v2)(); // [rsp+0h] [rbp-A8h] BYREF
_BYTE v3[160]; // [rsp+8h] [rbp-A0h] BYREF
memset(&v2, 0LL, 152LL);
sigemptyset(v3);
sigaction(6LL, 0LL, &v2);
return v2 == nglog::`anonymous namespace'::FailureSignalHandler;
}
| IsFailureSignalHandlerInstalled:
PUSH R14
PUSH RBX
SUB RSP,0x98
MOV RBX,RSP
MOV EDX,0x98
MOV RDI,RBX
XOR ESI,ESI
CALL 0x001072b0
LEA R14,[RSP + 0x8]
MOV RDI,R14
CALL 0x001076a0
MOV EDI,0x6
XOR ESI,ESI
MOV RDX,RBX
CALL 0x001076b0
LEA RAX,[0x12082d]
CMP qword ptr [R14 + -0x8],RAX
SETZ AL
ADD RSP,0x98
POP RBX
POP R14
RET
|
/* nglog::IsFailureSignalHandlerInstalled() */
int8 nglog::IsFailureSignalHandlerInstalled(void)
{
_union_1457 local_a8;
sigset_t local_a0;
memset(&local_a8,0,0x98);
sigemptyset(&local_a0);
sigaction(6,(sigaction *)0x0,(sigaction *)&local_a8);
return CONCAT71(0x1208,local_a8.sa_handler == (anonymous_namespace)::FailureSignalHandler);
}
|
|
971 | my_copy_fix_mb2_or_mb4 | eloqsql/strings/ctype-ucs2.c | static size_t
my_copy_fix_mb2_or_mb4(CHARSET_INFO *cs,
char *dst, size_t dst_length,
const char *src, size_t src_length,
size_t nchars, MY_STRCOPY_STATUS *status)
{
size_t length2, src_offset= src_length % cs->mbminlen;
my_char_copy_status_t padstatus;
if (!src_offset)
return my_copy_fix_mb(cs, dst, dst_length,
src, src_length, nchars, status);
if ((padstatus= my_copy_incomplete_char(cs, dst, dst_length,
src, src_length, nchars, TRUE)) ==
MY_CHAR_COPY_ERROR)
{
status->m_source_end_pos= status->m_well_formed_error_pos= src;
return 0;
}
length2= my_copy_fix_mb(cs, dst + cs->mbminlen, dst_length - cs->mbminlen,
src + src_offset, src_length - src_offset,
nchars - 1, status);
if (padstatus == MY_CHAR_COPY_FIXED)
status->m_well_formed_error_pos= src;
return cs->mbminlen /* The left-padded character */ + length2;
} | O0 | c | my_copy_fix_mb2_or_mb4:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x98(%rcx), %ecx
xorl %edx, %edx
divq %rcx
movq %rdx, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0xb95b0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
movq 0x10(%rbp), %rax
movq %rax, (%rsp)
callq 0x9ed60
movq %rax, -0x8(%rbp)
jmp 0xb966c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
movl $0x1, (%rsp)
callq 0xbae60
movl %eax, -0x4c(%rbp)
cmpl $0x1, %eax
jne 0xb95f9
movq -0x28(%rbp), %rcx
movq 0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rbp), %rax
movq %rcx, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0xb966c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x98(%rax), %eax
addq %rax, %rsi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movl 0x98(%rax), %eax
subq %rax, %rdx
movq -0x28(%rbp), %rcx
addq -0x48(%rbp), %rcx
movq -0x30(%rbp), %r8
subq -0x48(%rbp), %r8
movq -0x38(%rbp), %r9
subq $0x1, %r9
movq 0x10(%rbp), %rax
movq %rax, (%rsp)
callq 0x9ed60
movq %rax, -0x40(%rbp)
cmpl $0x2, -0x4c(%rbp)
jne 0xb965a
movq -0x28(%rbp), %rcx
movq 0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x98(%rax), %eax
addq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_copy_fix_mb2_or_mb4:
push rbp
mov rbp, rsp
sub rsp, 60h
mov rax, [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 rax, [rbp+var_30]
mov rcx, [rbp+var_10]
mov ecx, [rcx+98h]
xor edx, edx
div rcx
mov [rbp+var_48], rdx
cmp [rbp+var_48], 0
jnz short loc_B95B0
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_28]
mov r8, [rbp+var_30]
mov r9, [rbp+var_38]
mov rax, [rbp+arg_0]
mov [rsp+60h+var_60], rax
call my_copy_fix_mb
mov [rbp+var_8], rax
jmp loc_B966C
loc_B95B0:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_28]
mov r8, [rbp+var_30]
mov r9, [rbp+var_38]
mov dword ptr [rsp+60h+var_60], 1
call my_copy_incomplete_char
mov [rbp+var_4C], eax
cmp eax, 1
jnz short loc_B95F9
mov rcx, [rbp+var_28]
mov rax, [rbp+arg_0]
mov [rax+8], rcx
mov rax, [rbp+arg_0]
mov [rax], rcx
mov [rbp+var_8], 0
jmp short loc_B966C
loc_B95F9:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rax, [rbp+var_10]
mov eax, [rax+98h]
add rsi, rax
mov rdx, [rbp+var_20]
mov rax, [rbp+var_10]
mov eax, [rax+98h]
sub rdx, rax
mov rcx, [rbp+var_28]
add rcx, [rbp+var_48]
mov r8, [rbp+var_30]
sub r8, [rbp+var_48]
mov r9, [rbp+var_38]
sub r9, 1
mov rax, [rbp+arg_0]
mov [rsp+60h+var_60], rax
call my_copy_fix_mb
mov [rbp+var_40], rax
cmp [rbp+var_4C], 2
jnz short loc_B965A
mov rcx, [rbp+var_28]
mov rax, [rbp+arg_0]
mov [rax+8], rcx
loc_B965A:
mov rax, [rbp+var_10]
mov eax, [rax+98h]
add rax, [rbp+var_40]
mov [rbp+var_8], rax
loc_B966C:
mov rax, [rbp+var_8]
add rsp, 60h
pop rbp
retn
| long long my_copy_fix_mb2_or_mb4(
long long a1,
long long a2,
unsigned long long a3,
long long a4,
unsigned long long a5,
long long a6,
long long *a7)
{
int v8; // [rsp+14h] [rbp-4Ch]
unsigned long long v9; // [rsp+18h] [rbp-48h]
long long fixed; // [rsp+20h] [rbp-40h]
v9 = a5 % *(unsigned int *)(a1 + 152);
if ( !v9 )
return my_copy_fix_mb(a1, a2, a3, a4, a5, a6, a7);
v8 = my_copy_incomplete_char(a1, a2, a3, a4, a5, a6, 1);
if ( v8 == 1 )
{
a7[1] = a4;
*a7 = a4;
return 0LL;
}
else
{
fixed = my_copy_fix_mb(
a1,
*(unsigned int *)(a1 + 152) + a2,
a3 - *(unsigned int *)(a1 + 152),
v9 + a4,
a5 - v9,
a6 - 1,
a7);
if ( v8 == 2 )
a7[1] = a4;
return fixed + *(unsigned int *)(a1 + 152);
}
}
| my_copy_fix_mb2_or_mb4:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV RAX,qword 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 RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RCX + 0x98]
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x48],RDX
CMP qword ptr [RBP + -0x48],0x0
JNZ 0x001b95b0
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x28]
MOV R8,qword ptr [RBP + -0x30]
MOV R9,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RSP],RAX
CALL 0x0019ed60
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001b966c
LAB_001b95b0:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x28]
MOV R8,qword ptr [RBP + -0x30]
MOV R9,qword ptr [RBP + -0x38]
MOV dword ptr [RSP],0x1
CALL 0x001bae60
MOV dword ptr [RBP + -0x4c],EAX
CMP EAX,0x1
JNZ 0x001b95f9
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RAX],RCX
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001b966c
LAB_001b95f9:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x98]
ADD RSI,RAX
MOV RDX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x98]
SUB RDX,RAX
MOV RCX,qword ptr [RBP + -0x28]
ADD RCX,qword ptr [RBP + -0x48]
MOV R8,qword ptr [RBP + -0x30]
SUB R8,qword ptr [RBP + -0x48]
MOV R9,qword ptr [RBP + -0x38]
SUB R9,0x1
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RSP],RAX
CALL 0x0019ed60
MOV qword ptr [RBP + -0x40],RAX
CMP dword ptr [RBP + -0x4c],0x2
JNZ 0x001b965a
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
LAB_001b965a:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x98]
ADD RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x8],RAX
LAB_001b966c:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x60
POP RBP
RET
|
long my_copy_fix_mb2_or_mb4
(long param_1,long param_2,long param_3,long param_4,ulong param_5,long param_6,
long *param_7)
{
int iVar1;
ulong uVar2;
long local_10;
uVar2 = param_5 % (ulong)*(uint *)(param_1 + 0x98);
if (uVar2 == 0) {
local_10 = my_copy_fix_mb(param_1,param_2,param_3,param_4,param_5,param_6,param_7);
}
else {
iVar1 = my_copy_incomplete_char(param_1,param_2,param_3,param_4,param_5,param_6,1);
if (iVar1 == 1) {
param_7[1] = param_4;
*param_7 = param_4;
local_10 = 0;
}
else {
local_10 = my_copy_fix_mb(param_1,param_2 + (ulong)*(uint *)(param_1 + 0x98),
param_3 - (ulong)*(uint *)(param_1 + 0x98),param_4 + uVar2,
param_5 - uVar2,param_6 + -1,param_7);
if (iVar1 == 2) {
param_7[1] = param_4;
}
local_10 = (ulong)*(uint *)(param_1 + 0x98) + local_10;
}
}
return local_10;
}
|
|
972 | minja::Value::array(std::vector<minja::Value, std::allocator<minja::Value>>) | monkey531[P]llama/common/minja.hpp | static Value array(const std::vector<Value> values = {}) {
auto array = std::make_shared<ArrayType>();
for (const auto& item : values) {
array->push_back(item);
}
return Value(array);
} | O0 | cpp | minja::Value::array(std::vector<minja::Value, std::allocator<minja::Value>>):
subq $0x68, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x11e600
movq 0x10(%rsp), %rsi
movq %rsi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x114a10
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x114a40
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x1251b0
testb $0x1, %al
jne 0x124f26
jmp 0x124f76
leaq 0x38(%rsp), %rdi
callq 0x1251f0
movq %rax, 0x28(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x113410
movq %rax, %rdi
movq 0x28(%rsp), %rsi
callq 0x125200
jmp 0x124f4e
jmp 0x124f50
leaq 0x38(%rsp), %rdi
callq 0x125270
jmp 0x124f11
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x114c50
jmp 0x124f9a
movq (%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x125290
jmp 0x124f86
leaq 0x48(%rsp), %rdi
callq 0x114c50
movq 0x8(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x5abc0
nopw %cs:(%rax,%rax)
nop
| _ZN5minja5Value5arrayESt6vectorIS0_SaIS0_EE:
sub rsp, 68h
mov [rsp+68h+var_58], rsi
mov [rsp+68h+var_68], rdi
mov rax, rdi
mov [rsp+68h+var_60], rax
mov [rsp+68h+var_8], rdi
mov [rsp+68h+var_10], rsi
lea rdi, [rsp+68h+var_20]
call _ZSt11make_sharedISt6vectorIN5minja5ValueESaIS2_EEJEESt10shared_ptrIT_EDpOT0_; std::make_shared<std::vector<minja::Value>>()
mov rsi, [rsp+68h+var_58]
mov [rsp+68h+var_28], rsi
mov rdi, [rsp+68h+var_28]
call _ZNKSt6vectorIN5minja5ValueESaIS1_EE5beginEv; std::vector<minja::Value>::begin(void)
mov [rsp+68h+var_30], rax
mov rdi, [rsp+68h+var_28]
call _ZNKSt6vectorIN5minja5ValueESaIS1_EE3endEv; std::vector<minja::Value>::end(void)
mov [rsp+68h+var_38], rax
loc_124F11:
lea rdi, [rsp+68h+var_30]
lea rsi, [rsp+68h+var_38]
call _ZN9__gnu_cxxneIPKN5minja5ValueESt6vectorIS2_SaIS2_EEEEbRKNS_17__normal_iteratorIT_T0_EESD_; __gnu_cxx::operator!=<minja::Value const*,std::vector<minja::Value>>(__gnu_cxx::__normal_iterator<minja::Value const*,std::vector<minja::Value>> const&,__gnu_cxx::__normal_iterator<minja::Value const*,std::vector<minja::Value>> const&)
test al, 1
jnz short loc_124F26
jmp short loc_124F76
loc_124F26:
lea rdi, [rsp+68h+var_30]
call _ZNK9__gnu_cxx17__normal_iteratorIPKN5minja5ValueESt6vectorIS2_SaIS2_EEEdeEv; __gnu_cxx::__normal_iterator<minja::Value const*,std::vector<minja::Value>>::operator*(void)
mov [rsp+68h+var_40], rax
lea rdi, [rsp+68h+var_20]
call _ZNKSt19__shared_ptr_accessISt6vectorIN5minja5ValueESaIS2_EELN9__gnu_cxx12_Lock_policyE2ELb0ELb0EEptEv; std::__shared_ptr_access<std::vector<minja::Value>,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(void)
mov rdi, rax
mov rsi, [rsp+68h+var_40]
call _ZNSt6vectorIN5minja5ValueESaIS1_EE9push_backERKS1_; std::vector<minja::Value>::push_back(minja::Value const&)
jmp short $+2
loc_124F4E:
jmp short $+2
loc_124F50:
lea rdi, [rsp+68h+var_30]
call _ZN9__gnu_cxx17__normal_iteratorIPKN5minja5ValueESt6vectorIS2_SaIS2_EEEppEv; __gnu_cxx::__normal_iterator<minja::Value const*,std::vector<minja::Value>>::operator++(void)
jmp short loc_124F11
mov rcx, rax
mov eax, edx
mov [rsp+arg_18], rcx
mov [rsp+arg_14], eax
lea rdi, [rsp+arg_40]
call _ZNSt10shared_ptrISt6vectorIN5minja5ValueESaIS2_EEED2Ev; std::shared_ptr<std::vector<minja::Value>>::~shared_ptr()
jmp short loc_124F9A
loc_124F76:
mov rdi, [rsp+68h+var_68]
lea rsi, [rsp+68h+var_20]
call _ZN5minja5ValueC2ERKSt10shared_ptrISt6vectorIS0_SaIS0_EEE; minja::Value::Value(std::shared_ptr<std::vector<minja::Value>> const&)
jmp short $+2
loc_124F86:
lea rdi, [rsp+68h+var_20]
call _ZNSt10shared_ptrISt6vectorIN5minja5ValueESaIS2_EEED2Ev; std::shared_ptr<std::vector<minja::Value>>::~shared_ptr()
mov rax, [rsp+68h+var_60]
add rsp, 68h
retn
loc_124F9A:
mov rdi, [rsp+arg_18]
call __Unwind_Resume
| long long minja::Value::array(long long a1, long long a2)
{
long long v2; // rax
long long v4; // [rsp+28h] [rbp-40h]
long long v5; // [rsp+30h] [rbp-38h] BYREF
_QWORD v6[2]; // [rsp+38h] [rbp-30h] BYREF
_BYTE v7[16]; // [rsp+48h] [rbp-20h] BYREF
long long v8; // [rsp+58h] [rbp-10h]
long long v9; // [rsp+60h] [rbp-8h]
v9 = a1;
v8 = a2;
std::make_shared<std::vector<minja::Value>>((long long)v7);
v6[1] = a2;
v6[0] = std::vector<minja::Value>::begin(a2);
v5 = std::vector<minja::Value>::end(a2);
while ( (__gnu_cxx::operator!=<minja::Value const*,std::vector<minja::Value>>(v6, &v5) & 1) != 0 )
{
v4 = __gnu_cxx::__normal_iterator<minja::Value const*,std::vector<minja::Value>>::operator*(v6);
v2 = std::__shared_ptr_access<std::vector<minja::Value>,(__gnu_cxx::_Lock_policy)2,false,false>::operator->((long long)v7);
std::vector<minja::Value>::push_back(v2, v4);
__gnu_cxx::__normal_iterator<minja::Value const*,std::vector<minja::Value>>::operator++(v6);
}
minja::Value::Value(a1, v7);
std::shared_ptr<std::vector<minja::Value>>::~shared_ptr((long long)v7);
return a1;
}
| |||
973 | minja::Value::array(std::vector<minja::Value, std::allocator<minja::Value>>) | monkey531[P]llama/common/minja.hpp | static Value array(const std::vector<Value> values = {}) {
auto array = std::make_shared<ArrayType>();
for (const auto& item : values) {
array->push_back(item);
}
return Value(array);
} | O2 | cpp | minja::Value::array(std::vector<minja::Value, std::allocator<minja::Value>>):
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x6747b
movq (%r15), %r14
movq 0x8(%r15), %r15
cmpq %r15, %r14
je 0x68cb9
movq (%rsp), %rdi
movq %r14, %rsi
callq 0x68da0
addq $0x50, %r14
jmp 0x68ca2
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x68dcc
leaq 0x8(%rsp), %rdi
callq 0x4f1f0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4f1f0
movq %rbx, %rdi
callq 0x23fa0
| _ZN5minja5Value5arrayESt6vectorIS0_SaIS0_EE:
push r15
push r14
push rbx
sub rsp, 10h
mov r15, rsi
mov rbx, rdi
mov rdi, rsp
call _ZSt11make_sharedISt6vectorIN5minja5ValueESaIS2_EEJEESt10shared_ptrIT_EDpOT0_; std::make_shared<std::vector<minja::Value>>()
mov r14, [r15]
mov r15, [r15+8]
loc_68CA2:
cmp r14, r15
jz short loc_68CB9
mov rdi, [rsp+28h+var_28]
mov rsi, r14
call _ZNSt6vectorIN5minja5ValueESaIS1_EE9push_backERKS1_; std::vector<minja::Value>::push_back(minja::Value const&)
add r14, 50h ; 'P'
jmp short loc_68CA2
loc_68CB9:
mov rsi, rsp
mov rdi, rbx
call _ZN5minja5ValueC2ERKSt10shared_ptrISt6vectorIS0_SaIS0_EEE; minja::Value::Value(std::shared_ptr<std::vector<minja::Value>> const&)
lea rdi, [rsp+28h+var_20]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rax, rbx
add rsp, 10h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
lea rdi, [rsp+arg_0]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rdi, rbx
call __Unwind_Resume
| long long minja::Value::array(long long a1, long long *a2)
{
long long v2; // r14
long long v3; // r15
long long v5; // [rsp+0h] [rbp-28h] BYREF
_QWORD v6[4]; // [rsp+8h] [rbp-20h] BYREF
std::make_shared<std::vector<minja::Value>>((long long)&v5);
v2 = *a2;
v3 = a2[1];
while ( v2 != v3 )
{
std::vector<minja::Value>::push_back(v5, v2);
v2 += 80LL;
}
minja::Value::Value(a1, &v5);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(v6);
return a1;
}
| array:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV R15,RSI
MOV RBX,RDI
MOV RDI,RSP
CALL 0x0016747b
MOV R14,qword ptr [R15]
MOV R15,qword ptr [R15 + 0x8]
LAB_00168ca2:
CMP R14,R15
JZ 0x00168cb9
MOV RDI,qword ptr [RSP]
LAB_00168cab:
MOV RSI,R14
CALL 0x00168da0
LAB_00168cb3:
ADD R14,0x50
JMP 0x00168ca2
LAB_00168cb9:
MOV RSI,RSP
MOV RDI,RBX
CALL 0x00168dcc
LEA RDI,[RSP + 0x8]
CALL 0x0014f1f0
MOV RAX,RBX
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
|
/* minja::Value::array(std::vector<minja::Value, std::allocator<minja::Value> >) */
Value * __thiscall minja::Value::array(Value *this,int8 *param_2)
{
Value *pVVar1;
Value *pVVar2;
vector<minja::Value,std::allocator<minja::Value>> *local_28;
__shared_count<(__gnu_cxx::_Lock_policy)2> local_20 [8];
std::make_shared<std::vector<minja::Value,std::allocator<minja::Value>>>();
pVVar1 = (Value *)param_2[1];
for (pVVar2 = (Value *)*param_2; pVVar2 != pVVar1; pVVar2 = pVVar2 + 0x50) {
/* try { // try from 00168cab to 00168cb2 has its CatchHandler @ 00168cdb */
std::vector<minja::Value,std::allocator<minja::Value>>::push_back(local_28,pVVar2);
}
Value(this,(shared_ptr *)&local_28);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_20);
return this;
}
|
|
974 | google::protobuf::compiler::java::MessageBuilderLiteGenerator::MessageBuilderLiteGenerator(google::protobuf::Descriptor const*, google::protobuf::compiler::java::Context*) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/compiler/java/message_builder_lite.cc | MessageBuilderLiteGenerator::MessageBuilderLiteGenerator(
const Descriptor* descriptor, Context* context)
: descriptor_(descriptor),
context_(context),
name_resolver_(context->GetNameResolver()),
field_generators_(descriptor, context_) {
GOOGLE_CHECK(!HasDescriptorMethods(descriptor->file(), context->EnforceLite()))
<< "Generator factory error: A lite message generator is used to "
"generate non-lite messages.";
for (int i = 0; i < descriptor_->field_count(); i++) {
if (IsRealOneof(descriptor_->field(i))) {
oneofs_.insert(descriptor_->field(i)->containing_oneof());
}
}
} | O0 | cpp | google::protobuf::compiler::java::MessageBuilderLiteGenerator::MessageBuilderLiteGenerator(google::protobuf::Descriptor const*, google::protobuf::compiler::java::Context*):
subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movq %rdx, 0xe0(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x33b2c5(%rip), %rcx # 0x4ec2d8
movq %rcx, (%rax)
movq 0xe8(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0xe0(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0xe0(%rsp), %rdi
callq 0x194e70
movq %rax, %rcx
movq 0x60(%rsp), %rax
movq %rcx, 0x18(%rax)
movq %rax, %rdi
addq $0x20, %rdi
movq %rdi, 0x58(%rsp)
movq 0xe8(%rsp), %rsi
movq 0x10(%rax), %rdx
callq 0x1a4500
movq 0x60(%rsp), %rdi
addq $0x40, %rdi
movq %rdi, 0x68(%rsp)
callq 0x154270
movq 0xe8(%rsp), %rdi
movb $0x0, 0x97(%rsp)
callq 0x58040
movq %rax, 0x70(%rsp)
jmp 0x1b1093
movq 0xe0(%rsp), %rdi
callq 0x149960
movb %al, 0x57(%rsp)
jmp 0x1b10a6
movq 0x70(%rsp), %rdi
movb 0x57(%rsp), %al
movzbl %al, %esi
andl $0x1, %esi
callq 0x149940
movb %al, 0x56(%rsp)
jmp 0x1b10c0
movb 0x56(%rsp), %al
testb $0x1, %al
jne 0x1b10cc
jmp 0x1b10ca
jmp 0x1b113d
leaq 0x236d95(%rip), %rdx # 0x3e7e68
leaq 0x98(%rsp), %rdi
movl $0x3, %esi
movl $0x46, %ecx
callq 0x219560
jmp 0x1b10ec
movb $0x1, 0x97(%rsp)
leaq 0x21f31e(%rip), %rsi # 0x3d0419
leaq 0x98(%rsp), %rdi
callq 0x218e20
movq %rax, 0x48(%rsp)
jmp 0x1b110f
movq 0x48(%rsp), %rdi
leaq 0x21f350(%rip), %rsi # 0x3d046b
callq 0x218e20
movq %rax, 0x40(%rsp)
jmp 0x1b1127
movq 0x40(%rsp), %rsi
leaq 0x96(%rsp), %rdi
callq 0x218fd0
jmp 0x1b113b
jmp 0x1b113d
testb $0x1, 0x97(%rsp)
jne 0x1b1149
jmp 0x1b1156
leaq 0x98(%rsp), %rdi
callq 0x2195a0
movl $0x0, 0x90(%rsp)
movq 0x60(%rsp), %rax
movl 0x90(%rsp), %ecx
movl %ecx, 0x38(%rsp)
movq 0x8(%rax), %rdi
callq 0x3ca80
movl %eax, 0x3c(%rsp)
jmp 0x1b1180
movl 0x38(%rsp), %eax
movl 0x3c(%rsp), %ecx
cmpl %ecx, %eax
jge 0x1b12a0
movq 0x60(%rsp), %rax
movq 0x8(%rax), %rdi
movl 0x90(%rsp), %esi
callq 0x3ca90
movq %rax, 0x30(%rsp)
jmp 0x1b11ac
movq 0x30(%rsp), %rdi
callq 0x78110
movb %al, 0x2f(%rsp)
jmp 0x1b11bc
movb 0x2f(%rsp), %al
testb $0x1, %al
jne 0x1b11c9
jmp 0x1b1288
movq 0x60(%rsp), %rax
movq %rax, %rcx
addq $0x40, %rcx
movq %rcx, 0x18(%rsp)
movq 0x8(%rax), %rdi
movl 0x90(%rsp), %esi
callq 0x3ca90
movq %rax, 0x20(%rsp)
jmp 0x1b11f1
movq 0x20(%rsp), %rdi
callq 0x3cbb0
movq %rax, 0x10(%rsp)
jmp 0x1b1202
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, 0x88(%rsp)
leaq 0x88(%rsp), %rsi
callq 0x154280
movb %dl, 0x7(%rsp)
movq %rax, 0x8(%rsp)
jmp 0x1b122c
movb 0x7(%rsp), %al
movq 0x8(%rsp), %rcx
movq %rcx, 0x78(%rsp)
movb %al, 0x80(%rsp)
jmp 0x1b1288
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd8(%rsp)
movl %eax, 0xd4(%rsp)
jmp 0x1b12a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd8(%rsp)
movl %eax, 0xd4(%rsp)
testb $0x1, 0x97(%rsp)
jne 0x1b1279
jmp 0x1b1286
leaq 0x98(%rsp), %rdi
callq 0x2195a0
jmp 0x1b12a8
jmp 0x1b128a
movl 0x90(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x90(%rsp)
jmp 0x1b1161
addq $0xf8, %rsp
retq
movq 0x68(%rsp), %rdi
callq 0x1542e0
movq 0x58(%rsp), %rdi
callq 0x1a4cc0
movq 0xd8(%rsp), %rdi
callq 0x21700
nopl (%rax)
| _ZN6google8protobuf8compiler4java27MessageBuilderLiteGeneratorC2EPKNS0_10DescriptorEPNS2_7ContextE:
sub rsp, 0F8h
mov [rsp+0F8h+var_8], rdi
mov [rsp+0F8h+var_10], rsi
mov [rsp+0F8h+var_18], rdx
mov rax, [rsp+0F8h+var_8]
mov [rsp+0F8h+var_98], rax
lea rcx, off_4EC2D8
mov [rax], rcx
mov rcx, [rsp+0F8h+var_10]
mov [rax+8], rcx
mov rcx, [rsp+0F8h+var_18]
mov [rax+10h], rcx
mov rdi, [rsp+0F8h+var_18]; this
call _ZNK6google8protobuf8compiler4java7Context15GetNameResolverEv; google::protobuf::compiler::java::Context::GetNameResolver(void)
mov rcx, rax
mov rax, [rsp+0F8h+var_98]
mov [rax+18h], rcx
mov rdi, rax
add rdi, 20h ; ' '
mov [rsp+0F8h+var_A0], rdi
mov rsi, [rsp+0F8h+var_10]
mov rdx, [rax+10h]
call _ZN6google8protobuf8compiler4java17FieldGeneratorMapINS2_27ImmutableFieldLiteGeneratorEEC2EPKNS0_10DescriptorEPNS2_7ContextE; google::protobuf::compiler::java::FieldGeneratorMap<google::protobuf::compiler::java::ImmutableFieldLiteGenerator>::FieldGeneratorMap(google::protobuf::Descriptor const*,google::protobuf::compiler::java::Context *)
mov rdi, [rsp+0F8h+var_98]
add rdi, 40h ; '@'
mov [rsp+0F8h+var_90], rdi
call _ZNSt3setIPKN6google8protobuf15OneofDescriptorESt4lessIS4_ESaIS4_EEC2Ev; std::set<google::protobuf::OneofDescriptor const*>::set(void)
mov rdi, [rsp+0F8h+var_10]; this
mov byte ptr [rsp+0F8h+var_68+7], 0
call _ZNK6google8protobuf10Descriptor4fileEv; google::protobuf::Descriptor::file(void)
mov [rsp+0F8h+var_88], rax
jmp short $+2
loc_1B1093:
mov rdi, [rsp+0F8h+var_18]; this
call _ZNK6google8protobuf8compiler4java7Context11EnforceLiteEv; google::protobuf::compiler::java::Context::EnforceLite(void)
mov [rsp+0F8h+var_A1], al
jmp short $+2
loc_1B10A6:
mov rdi, [rsp+0F8h+var_88]; this
mov al, [rsp+0F8h+var_A1]
movzx esi, al
and esi, 1; google::protobuf::FileDescriptor *
call _ZN6google8protobuf8compiler4java20HasDescriptorMethodsEPKNS0_14FileDescriptorEb; google::protobuf::compiler::java::HasDescriptorMethods(google::protobuf::FileDescriptor const*,bool)
mov [rsp+0F8h+var_A2], al
jmp short $+2
loc_1B10C0:
mov al, [rsp+0F8h+var_A2]
test al, 1
jnz short loc_1B10CC
jmp short $+2
loc_1B10CA:
jmp short loc_1B113D
loc_1B10CC:
lea rdx, aWorkspaceLlm4b_47; "/workspace/llm4binary/github2025/aimrt_"...
lea rdi, [rsp+0F8h+var_60]
mov esi, 3
mov ecx, 46h ; 'F'
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
jmp short $+2
loc_1B10EC:
mov byte ptr [rsp+0F8h+var_68+7], 1
lea rsi, aCheckFailedHas_5; "CHECK failed: !HasDescriptorMethods(des"...
lea rdi, [rsp+0F8h+var_60]
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+0F8h+var_B0], rax
jmp short $+2
loc_1B110F:
mov rdi, [rsp+0F8h+var_B0]
lea rsi, aGeneratorFacto_0; "Generator factory error: A lite message"...
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+0F8h+var_B8], rax
jmp short $+2
loc_1B1127:
mov rsi, [rsp+0F8h+var_B8]
lea rdi, [rsp+0F8h+var_68+6]
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
jmp short $+2
loc_1B113B:
jmp short $+2
loc_1B113D:
test byte ptr [rsp+0F8h+var_68+7], 1
jnz short loc_1B1149
jmp short loc_1B1156
loc_1B1149:
lea rdi, [rsp+0F8h+var_60]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_1B1156:
mov dword ptr [rsp+0F8h+var_68], 0
loc_1B1161:
mov rax, [rsp+0F8h+var_98]
mov ecx, dword ptr [rsp+0F8h+var_68]
mov [rsp+0F8h+var_C0], ecx
mov rdi, [rax+8]; this
call _ZNK6google8protobuf10Descriptor11field_countEv; google::protobuf::Descriptor::field_count(void)
mov [rsp+0F8h+var_BC], eax
jmp short $+2
loc_1B1180:
mov eax, [rsp+0F8h+var_C0]
mov ecx, [rsp+0F8h+var_BC]
cmp eax, ecx
jge loc_1B12A0
mov rax, [rsp+0F8h+var_98]
mov rdi, [rax+8]; this
mov esi, dword ptr [rsp+0F8h+var_68]; google::protobuf::FieldDescriptor *
call _ZNK6google8protobuf10Descriptor5fieldEi; google::protobuf::Descriptor::field(int)
mov [rsp+0F8h+var_C8], rax
jmp short $+2
loc_1B11AC:
mov rdi, [rsp+0F8h+var_C8]; this
call _ZN6google8protobuf8compiler4java11IsRealOneofEPKNS0_15FieldDescriptorE; google::protobuf::compiler::java::IsRealOneof(google::protobuf::FieldDescriptor const*)
mov [rsp+0F8h+var_C9], al
jmp short $+2
loc_1B11BC:
mov al, [rsp+0F8h+var_C9]
test al, 1
jnz short loc_1B11C9
jmp loc_1B1288
loc_1B11C9:
mov rax, [rsp+0F8h+var_98]
mov rcx, rax
add rcx, 40h ; '@'
mov [rsp+0F8h+var_E0], rcx
mov rdi, [rax+8]; this
mov esi, dword ptr [rsp+0F8h+var_68]; int
call _ZNK6google8protobuf10Descriptor5fieldEi; google::protobuf::Descriptor::field(int)
mov [rsp+0F8h+var_D8], rax
jmp short $+2
loc_1B11F1:
mov rdi, [rsp+0F8h+var_D8]; this
call _ZNK6google8protobuf15FieldDescriptor16containing_oneofEv; google::protobuf::FieldDescriptor::containing_oneof(void)
mov [rsp+0F8h+var_E8], rax
jmp short $+2
loc_1B1202:
mov rdi, [rsp+0F8h+var_E0]
mov rax, [rsp+0F8h+var_E8]
mov [rsp+0F8h+var_70], rax
lea rsi, [rsp+0F8h+var_70]
call _ZNSt3setIPKN6google8protobuf15OneofDescriptorESt4lessIS4_ESaIS4_EE6insertEOS4_; std::set<google::protobuf::OneofDescriptor const*>::insert(google::protobuf::OneofDescriptor const*&&)
mov [rsp+0F8h+var_F1], dl
mov [rsp+0F8h+var_F0], rax
jmp short $+2
loc_1B122C:
mov al, [rsp+0F8h+var_F1]
mov rcx, [rsp+0F8h+var_F0]
mov [rsp+0F8h+var_80], rcx
mov [rsp+0F8h+var_78], al
jmp short loc_1B1288
mov rcx, rax
mov eax, edx
mov [rsp+arg_D0], rcx
mov [rsp+arg_CC], eax
jmp short loc_1B12A8
mov rcx, rax
mov eax, edx
mov [rsp+arg_D0], rcx
mov [rsp+arg_CC], eax
test [rsp+arg_8F], 1
jnz short loc_1B1279
jmp short loc_1B1286
loc_1B1279:
lea rdi, [rsp+arg_90]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_1B1286:
jmp short loc_1B12A8
loc_1B1288:
jmp short $+2
loc_1B128A:
mov eax, dword ptr [rsp+0F8h+var_68]
add eax, 1
mov dword ptr [rsp+0F8h+var_68], eax
jmp loc_1B1161
loc_1B12A0:
add rsp, 0F8h
retn
loc_1B12A8:
mov rdi, [rsp+arg_60]
call _ZNSt3setIPKN6google8protobuf15OneofDescriptorESt4lessIS4_ESaIS4_EED2Ev; std::set<google::protobuf::OneofDescriptor const*>::~set()
mov rdi, [rsp+arg_50]
call _ZN6google8protobuf8compiler4java17FieldGeneratorMapINS2_27ImmutableFieldLiteGeneratorEED2Ev; google::protobuf::compiler::java::FieldGeneratorMap<google::protobuf::compiler::java::ImmutableFieldLiteGenerator>::~FieldGeneratorMap()
mov rdi, [rsp+arg_D0]
call __Unwind_Resume
| long long google::protobuf::compiler::java::MessageBuilderLiteGenerator::MessageBuilderLiteGenerator(
google::protobuf::compiler::java::MessageBuilderLiteGenerator *this,
const google::protobuf::Descriptor *a2,
google::protobuf::compiler::java::Context *a3)
{
long long result; // rax
const google::protobuf::FieldDescriptor *v4; // rsi
google::protobuf::FieldDescriptor *v5; // [rsp+20h] [rbp-D8h]
google::protobuf::compiler::java *v6; // [rsp+30h] [rbp-C8h]
unsigned int v7; // [rsp+38h] [rbp-C0h]
signed int v8; // [rsp+3Ch] [rbp-BCh]
long long v9; // [rsp+40h] [rbp-B8h]
long long v10; // [rsp+48h] [rbp-B0h]
char v11; // [rsp+57h] [rbp-A1h]
google::protobuf::compiler::java *v12; // [rsp+70h] [rbp-88h]
long long v13; // [rsp+88h] [rbp-70h] BYREF
unsigned int i; // [rsp+90h] [rbp-68h]
google::protobuf::FieldDescriptor *v15; // [rsp+96h] [rbp-62h] BYREF
_BYTE v16[72]; // [rsp+98h] [rbp-60h] BYREF
google::protobuf::compiler::java::Context *v17; // [rsp+E0h] [rbp-18h]
google::protobuf::Descriptor *v18; // [rsp+E8h] [rbp-10h]
google::protobuf::compiler::java::MessageBuilderLiteGenerator *v19; // [rsp+F0h] [rbp-8h]
v19 = this;
v18 = a2;
v17 = a3;
*(_QWORD *)this = off_4EC2D8;
*((_QWORD *)this + 1) = v18;
*((_QWORD *)this + 2) = v17;
*((_QWORD *)this + 3) = google::protobuf::compiler::java::Context::GetNameResolver(v17);
google::protobuf::compiler::java::FieldGeneratorMap<google::protobuf::compiler::java::ImmutableFieldLiteGenerator>::FieldGeneratorMap(
(google::protobuf::Descriptor **)this + 4,
v18,
*((_QWORD *)this + 2));
std::set<google::protobuf::OneofDescriptor const*>::set((long long)this + 64);
BYTE1(v15) = 0;
v12 = (google::protobuf::compiler::java *)google::protobuf::Descriptor::file(v18);
v11 = google::protobuf::compiler::java::Context::EnforceLite(v17);
if ( google::protobuf::compiler::java::HasDescriptorMethods(v12, (const google::protobuf::FileDescriptor *)(v11 & 1)) )
{
google::protobuf::internal::LogMessage::LogMessage(
v16,
3LL,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/compiler/java/message_builder_lite.cc",
70LL);
BYTE1(v15) = 1;
v10 = google::protobuf::internal::LogMessage::operator<<(
v16,
"CHECK failed: !HasDescriptorMethods(descriptor->file(), context->EnforceLite()): ");
v9 = google::protobuf::internal::LogMessage::operator<<(
v10,
"Generator factory error: A lite message generator is used to generate non-lite messages.");
google::protobuf::internal::LogFinisher::operator=(&v15, v9);
}
if ( (BYTE1(v15) & 1) != 0 )
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)v16);
for ( i = 0; ; ++i )
{
v7 = i;
v8 = google::protobuf::Descriptor::field_count(*((google::protobuf::Descriptor **)this + 1));
result = v7;
if ( (int)v7 >= v8 )
break;
v4 = (const google::protobuf::FieldDescriptor *)i;
v6 = (google::protobuf::compiler::java *)google::protobuf::Descriptor::field(
*((google::protobuf::Descriptor **)this + 1),
i);
if ( (google::protobuf::compiler::java::IsRealOneof(v6, v4) & 1) != 0 )
{
v5 = (google::protobuf::FieldDescriptor *)google::protobuf::Descriptor::field(
*((google::protobuf::Descriptor **)this + 1),
i);
v13 = google::protobuf::FieldDescriptor::containing_oneof(v5);
std::set<google::protobuf::OneofDescriptor const*>::insert((long long)this + 64, (long long)&v13);
}
}
return result;
}
| |||
975 | google::protobuf::compiler::java::MessageBuilderLiteGenerator::MessageBuilderLiteGenerator(google::protobuf::Descriptor const*, google::protobuf::compiler::java::Context*) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/compiler/java/message_builder_lite.cc | MessageBuilderLiteGenerator::MessageBuilderLiteGenerator(
const Descriptor* descriptor, Context* context)
: descriptor_(descriptor),
context_(context),
name_resolver_(context->GetNameResolver()),
field_generators_(descriptor, context_) {
GOOGLE_CHECK(!HasDescriptorMethods(descriptor->file(), context->EnforceLite()))
<< "Generator factory error: A lite message generator is used to "
"generate non-lite messages.";
for (int i = 0; i < descriptor_->field_count(); i++) {
if (IsRealOneof(descriptor_->field(i))) {
oneofs_.insert(descriptor_->field(i)->containing_oneof());
}
}
} | O3 | cpp | google::protobuf::compiler::java::MessageBuilderLiteGenerator::MessageBuilderLiteGenerator(google::protobuf::Descriptor const*, google::protobuf::compiler::java::Context*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
leaq 0x19e802(%rip), %rax # 0x279a20
movq %rax, (%rdi)
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rdx, %rdi
callq 0xcda64
movq %rax, 0x18(%r15)
leaq 0x20(%r15), %rbx
movq 0x10(%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd4a52
leaq 0x40(%r15), %r14
leaq 0x48(%r15), %rax
movl $0x0, 0x48(%r15)
xorl %ecx, %ecx
movq %rcx, 0x50(%r15)
movq %rax, 0x58(%r15)
movq %rax, 0x60(%r15)
movq %rcx, 0x68(%r15)
cmpb $0x0, 0x6b(%r12)
jne 0xdb2c4
leaq 0xfdbbb(%rip), %rdx # 0x1d8e34
leaq 0x10(%rsp), %rdi
movl $0x3, %esi
movl $0x46, %ecx
callq 0x1072ba
leaq 0xe66e6(%rip), %rsi # 0x1c197a
leaq 0x10(%rsp), %rdi
callq 0x106db8
leaq 0xe6727(%rip), %rsi # 0x1c19cc
movq %rax, %rdi
callq 0x106db8
leaq 0xf(%rsp), %rdi
movq %rax, %rsi
callq 0x106e92
leaq 0x10(%rsp), %rdi
callq 0x1072d8
movq 0x8(%r15), %rax
cmpl $0x0, 0x4(%rax)
jle 0xdb32c
movl $0x28, %r13d
xorl %ebp, %ebp
leaq 0x10(%rsp), %r12
movq 0x28(%rax), %rcx
testb $0x10, -0x27(%rcx,%r13)
sete %dl
movq (%rcx,%r13), %rcx
testq %rcx, %rcx
sete %sil
orb %dl, %sil
jne 0xdb31c
cmpl $0x1, 0x4(%rcx)
jne 0xdb308
movq 0x20(%rcx), %rdx
testb $0x2, 0x1(%rdx)
jne 0xdb31c
movq %rcx, 0x10(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0xaf242
movq 0x8(%r15), %rax
incq %rbp
movslq 0x4(%rax), %rcx
addq $0x48, %r13
cmpq %rcx, %rbp
jl 0xdb2db
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xdb33f
jmp 0xdb34e
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0x1072d8
jmp 0xdb351
movq %rax, %r15
movq %r14, %rdi
callq 0xaf1f8
movq %rbx, %rdi
callq 0xd4d80
movq %r15, %rdi
callq 0x1f860
nop
| _ZN6google8protobuf8compiler4java27MessageBuilderLiteGeneratorC2EPKNS0_10DescriptorEPNS2_7ContextE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov r12, rdx
mov r14, rsi
mov r15, rdi
lea rax, off_279A20
mov [rdi], rax
mov [rdi+8], rsi
mov [rdi+10h], rdx
mov rdi, rdx; this
call _ZNK6google8protobuf8compiler4java7Context15GetNameResolverEv; google::protobuf::compiler::java::Context::GetNameResolver(void)
mov [r15+18h], rax
lea rbx, [r15+20h]
mov rdx, [r15+10h]
mov rdi, rbx
mov rsi, r14
call _ZN6google8protobuf8compiler4java17FieldGeneratorMapINS2_27ImmutableFieldLiteGeneratorEEC2EPKNS0_10DescriptorEPNS2_7ContextE; google::protobuf::compiler::java::FieldGeneratorMap<google::protobuf::compiler::java::ImmutableFieldLiteGenerator>::FieldGeneratorMap(google::protobuf::Descriptor const*,google::protobuf::compiler::java::Context *)
lea r14, [r15+40h]
lea rax, [r15+48h]
mov dword ptr [r15+48h], 0
xor ecx, ecx
mov [r15+50h], rcx
mov [r15+58h], rax
mov [r15+60h], rax
mov [r15+68h], rcx
cmp byte ptr [r12+6Bh], 0
jnz short loc_DB2C4
lea rdx, aWorkspaceLlm4b_39; "/workspace/llm4binary/github2025/aimrt_"...
lea rdi, [rsp+78h+var_68]
mov esi, 3
mov ecx, 46h ; 'F'
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
lea rsi, aCheckFailedHas_4; "CHECK failed: !HasDescriptorMethods(des"...
lea rdi, [rsp+78h+var_68]
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
lea rsi, aGeneratorFacto_0; "Generator factory error: A lite message"...
mov rdi, rax
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
lea rdi, [rsp+78h+var_69]
mov rsi, rax
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
lea rdi, [rsp+78h+var_68]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_DB2C4:
mov rax, [r15+8]
cmp dword ptr [rax+4], 0
jle short loc_DB32C
mov r13d, 28h ; '('
xor ebp, ebp
lea r12, [rsp+78h+var_68]
loc_DB2DB:
mov rcx, [rax+28h]
test byte ptr [rcx+r13-27h], 10h
setz dl
mov rcx, [rcx+r13]
test rcx, rcx
setz sil
or sil, dl
jnz short loc_DB31C
cmp dword ptr [rcx+4], 1
jnz short loc_DB308
mov rdx, [rcx+20h]
test byte ptr [rdx+1], 2
jnz short loc_DB31C
loc_DB308:
mov [rsp+78h+var_68], rcx
mov rdi, r14
mov rsi, r12
call _ZNSt8_Rb_treeIPKN6google8protobuf15OneofDescriptorES4_St9_IdentityIS4_ESt4lessIS4_ESaIS4_EE16_M_insert_uniqueIS4_EESt4pairISt17_Rb_tree_iteratorIS4_EbEOT_; std::_Rb_tree<google::protobuf::OneofDescriptor const*,google::protobuf::OneofDescriptor const*,std::_Identity<google::protobuf::OneofDescriptor const*>,std::less<google::protobuf::OneofDescriptor const*>,std::allocator<google::protobuf::OneofDescriptor const*>>::_M_insert_unique<google::protobuf::OneofDescriptor const*>(google::protobuf::OneofDescriptor const* &&)
mov rax, [r15+8]
loc_DB31C:
inc rbp
movsxd rcx, dword ptr [rax+4]
add r13, 48h ; 'H'
cmp rbp, rcx
jl short loc_DB2DB
loc_DB32C:
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_DB33F
jmp short loc_DB34E
loc_DB33F:
mov r15, rax
lea rdi, [rsp+arg_8]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
jmp short loc_DB351
loc_DB34E:
mov r15, rax
loc_DB351:
mov rdi, r14
call _ZNSt8_Rb_treeIPKN6google8protobuf15OneofDescriptorES4_St9_IdentityIS4_ESt4lessIS4_ESaIS4_EED2Ev; std::_Rb_tree<google::protobuf::OneofDescriptor const*,google::protobuf::OneofDescriptor const*,std::_Identity<google::protobuf::OneofDescriptor const*>,std::less<google::protobuf::OneofDescriptor const*>,std::allocator<google::protobuf::OneofDescriptor const*>>::~_Rb_tree()
mov rdi, rbx
call _ZN6google8protobuf8compiler4java17FieldGeneratorMapINS2_27ImmutableFieldLiteGeneratorEED2Ev; google::protobuf::compiler::java::FieldGeneratorMap<google::protobuf::compiler::java::ImmutableFieldLiteGenerator>::~FieldGeneratorMap()
mov rdi, r15
call __Unwind_Resume
| long long google::protobuf::compiler::java::MessageBuilderLiteGenerator::MessageBuilderLiteGenerator(
google::protobuf::compiler::java::MessageBuilderLiteGenerator *this,
const google::protobuf::Descriptor *a2,
google::protobuf::compiler::java::Context *a3)
{
long long v4; // rax
long long v5; // rax
long long result; // rax
long long v7; // r13
long long v8; // rbp
long long v9; // rcx
bool v10; // dl
long long v11; // rcx
char v12; // [rsp+Fh] [rbp-69h] BYREF
_QWORD v13[13]; // [rsp+10h] [rbp-68h] BYREF
*(_QWORD *)this = off_279A20;
*((_QWORD *)this + 1) = a2;
*((_QWORD *)this + 2) = a3;
*((_QWORD *)this + 3) = google::protobuf::compiler::java::Context::GetNameResolver(a3);
google::protobuf::compiler::java::FieldGeneratorMap<google::protobuf::compiler::java::ImmutableFieldLiteGenerator>::FieldGeneratorMap(
(_QWORD *)this + 4,
(long long)a2,
*((google::protobuf::compiler::java::Context **)this + 2));
*((_DWORD *)this + 18) = 0;
*((_QWORD *)this + 10) = 0LL;
*((_QWORD *)this + 11) = (char *)this + 72;
*((_QWORD *)this + 12) = (char *)this + 72;
*((_QWORD *)this + 13) = 0LL;
if ( !*((_BYTE *)a3 + 107) )
{
google::protobuf::internal::LogMessage::LogMessage(
v13,
3LL,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/compiler/java/message_builder_lite.cc",
70LL);
v4 = google::protobuf::internal::LogMessage::operator<<(
v13,
"CHECK failed: !HasDescriptorMethods(descriptor->file(), context->EnforceLite()): ");
v5 = google::protobuf::internal::LogMessage::operator<<(
v4,
"Generator factory error: A lite message generator is used to generate non-lite messages.");
google::protobuf::internal::LogFinisher::operator=(&v12, v5);
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)v13);
}
result = *((_QWORD *)this + 1);
if ( *(int *)(result + 4) > 0 )
{
v7 = 40LL;
v8 = 0LL;
do
{
v9 = *(_QWORD *)(result + 40);
v10 = (*(_BYTE *)(v9 + v7 - 39) & 0x10) == 0;
v11 = *(_QWORD *)(v9 + v7);
if ( !v10 && v11 != 0 && (*(_DWORD *)(v11 + 4) != 1 || (*(_BYTE *)(*(_QWORD *)(v11 + 32) + 1LL) & 2) == 0) )
{
v13[0] = v11;
std::_Rb_tree<google::protobuf::OneofDescriptor const*,google::protobuf::OneofDescriptor const*,std::_Identity<google::protobuf::OneofDescriptor const*>,std::less<google::protobuf::OneofDescriptor const*>,std::allocator<google::protobuf::OneofDescriptor const*>>::_M_insert_unique<google::protobuf::OneofDescriptor const*>(
(long long)this + 64,
(long long)v13);
result = *((_QWORD *)this + 1);
}
++v8;
v7 += 72LL;
}
while ( v8 < *(int *)(result + 4) );
}
return result;
}
| MessageBuilderLiteGenerator:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R12,RDX
MOV R14,RSI
MOV R15,RDI
LEA RAX,[0x379a20]
MOV qword ptr [RDI],RAX
MOV qword ptr [RDI + 0x8],RSI
MOV qword ptr [RDI + 0x10],RDX
MOV RDI,RDX
CALL 0x001cda64
MOV qword ptr [R15 + 0x18],RAX
LEA RBX,[R15 + 0x20]
MOV RDX,qword ptr [R15 + 0x10]
MOV RDI,RBX
MOV RSI,R14
CALL 0x001d4a52
LEA R14,[R15 + 0x40]
LEA RAX,[R15 + 0x48]
MOV dword ptr [R15 + 0x48],0x0
XOR ECX,ECX
MOV qword ptr [R15 + 0x50],RCX
MOV qword ptr [R15 + 0x58],RAX
MOV qword ptr [R15 + 0x60],RAX
MOV qword ptr [R15 + 0x68],RCX
CMP byte ptr [R12 + 0x6b],0x0
JNZ 0x001db2c4
LAB_001db272:
LEA RDX,[0x2d8e34]
LEA RDI,[RSP + 0x10]
MOV ESI,0x3
MOV ECX,0x46
CALL 0x002072ba
LAB_001db28d:
LEA RSI,[0x2c197a]
LEA RDI,[RSP + 0x10]
CALL 0x00206db8
LEA RSI,[0x2c19cc]
MOV RDI,RAX
CALL 0x00206db8
LAB_001db2ad:
LEA RDI,[RSP + 0xf]
MOV RSI,RAX
CALL 0x00206e92
LEA RDI,[RSP + 0x10]
CALL 0x002072d8
LAB_001db2c4:
MOV RAX,qword ptr [R15 + 0x8]
CMP dword ptr [RAX + 0x4],0x0
JLE 0x001db32c
MOV R13D,0x28
XOR EBP,EBP
LEA R12,[RSP + 0x10]
LAB_001db2db:
MOV RCX,qword ptr [RAX + 0x28]
TEST byte ptr [RCX + R13*0x1 + -0x27],0x10
SETZ DL
MOV RCX,qword ptr [RCX + R13*0x1]
TEST RCX,RCX
SETZ SIL
OR SIL,DL
JNZ 0x001db31c
CMP dword ptr [RCX + 0x4],0x1
JNZ 0x001db308
MOV RDX,qword ptr [RCX + 0x20]
TEST byte ptr [RDX + 0x1],0x2
JNZ 0x001db31c
LAB_001db308:
MOV qword ptr [RSP + 0x10],RCX
LAB_001db30d:
MOV RDI,R14
MOV RSI,R12
CALL 0x001af242
LAB_001db318:
MOV RAX,qword ptr [R15 + 0x8]
LAB_001db31c:
INC RBP
MOVSXD RCX,dword ptr [RAX + 0x4]
ADD R13,0x48
CMP RBP,RCX
JL 0x001db2db
LAB_001db32c:
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* google::protobuf::compiler::java::MessageBuilderLiteGenerator::MessageBuilderLiteGenerator(google::protobuf::Descriptor
const*, google::protobuf::compiler::java::Context*) */
void __thiscall
google::protobuf::compiler::java::MessageBuilderLiteGenerator::MessageBuilderLiteGenerator
(MessageBuilderLiteGenerator *this,Descriptor *param_1,Context *param_2)
{
int8 uVar1;
LogMessage *pLVar2;
long lVar3;
long lVar4;
long lVar5;
LogFinisher local_69;
OneofDescriptor *local_68 [7];
*(int ***)this = &PTR__MessageBuilderLiteGenerator_00379a20;
*(Descriptor **)(this + 8) = param_1;
*(Context **)(this + 0x10) = param_2;
uVar1 = Context::GetNameResolver(param_2);
*(int8 *)(this + 0x18) = uVar1;
FieldGeneratorMap<google::protobuf::compiler::java::ImmutableFieldLiteGenerator>::
FieldGeneratorMap((FieldGeneratorMap<google::protobuf::compiler::java::ImmutableFieldLiteGenerator>
*)(this + 0x20),param_1,*(Context **)(this + 0x10));
*(int4 *)(this + 0x48) = 0;
*(int8 *)(this + 0x50) = 0;
*(MessageBuilderLiteGenerator **)(this + 0x58) = this + 0x48;
*(MessageBuilderLiteGenerator **)(this + 0x60) = this + 0x48;
*(int8 *)(this + 0x68) = 0;
if (param_2[0x6b] == (Context)0x0) {
/* try { // try from 001db272 to 001db28c has its CatchHandler @ 001db33d */
internal::LogMessage::LogMessage
((LogMessage *)local_68,3,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/compiler/java/message_builder_lite.cc"
,0x46);
/* try { // try from 001db28d to 001db2ac has its CatchHandler @ 001db33f */
pLVar2 = (LogMessage *)
internal::LogMessage::operator<<
((LogMessage *)local_68,
"CHECK failed: !HasDescriptorMethods(descriptor->file(), context->EnforceLite()): "
);
pLVar2 = (LogMessage *)
internal::LogMessage::operator<<
(pLVar2,
"Generator factory error: A lite message generator is used to generate non-lite messages."
);
/* try { // try from 001db2ad to 001db2b9 has its CatchHandler @ 001db33b */
internal::LogFinisher::operator=(&local_69,pLVar2);
internal::LogMessage::~LogMessage((LogMessage *)local_68);
}
lVar3 = *(long *)(this + 8);
if (0 < *(int *)(lVar3 + 4)) {
lVar5 = 0x28;
lVar4 = 0;
do {
local_68[0] = *(OneofDescriptor **)(*(long *)(lVar3 + 0x28) + lVar5);
if ((local_68[0] != (OneofDescriptor *)0x0 &&
(*(byte *)(*(long *)(lVar3 + 0x28) + -0x27 + lVar5) & 0x10) != 0) &&
((*(int *)(local_68[0] + 4) != 1 ||
((*(byte *)(*(long *)(local_68[0] + 0x20) + 1) & 2) == 0)))) {
/* try { // try from 001db30d to 001db317 has its CatchHandler @ 001db34e */
std::
_Rb_tree<google::protobuf::OneofDescriptor_const*,google::protobuf::OneofDescriptor_const*,std::_Identity<google::protobuf::OneofDescriptor_const*>,std::less<google::protobuf::OneofDescriptor_const*>,std::allocator<google::protobuf::OneofDescriptor_const*>>
::_M_insert_unique<google::protobuf::OneofDescriptor_const*>
((_Rb_tree<google::protobuf::OneofDescriptor_const*,google::protobuf::OneofDescriptor_const*,std::_Identity<google::protobuf::OneofDescriptor_const*>,std::less<google::protobuf::OneofDescriptor_const*>,std::allocator<google::protobuf::OneofDescriptor_const*>>
*)(this + 0x40),local_68);
lVar3 = *(long *)(this + 8);
}
lVar4 = lVar4 + 1;
lVar5 = lVar5 + 0x48;
} while (lVar4 < *(int *)(lVar3 + 4));
}
return;
}
|
|
976 | my_os_charset_to_mysql_charset | eloqsql/mysys/charset.c | static const char*
my_os_charset_to_mysql_charset(const char* csname)
{
const MY_CSET_OS_NAME* csp;
for (csp = charsets; csp->os_name; csp++)
{
if (!strcasecmp(csp->os_name, csname))
{
switch (csp->param)
{
case my_cs_exact:
return csp->my_name;
case my_cs_approx:
/*
Maybe we should print a warning eventually:
character set correspondence is not exact.
*/
return csp->my_name;
default:
return NULL;
}
}
}
return NULL;
} | O0 | c | my_os_charset_to_mysql_charset:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x1d719d(%rip), %rax # 0x2b5720
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0xde5f6
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x295a0
cmpl $0x0, %eax
jne 0xde5e6
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0xde5c0
jmp 0xde5b6
movl -0x1c(%rbp), %eax
subl $0x1, %eax
je 0xde5ce
jmp 0xde5dc
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xde5fe
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xde5fe
movq $0x0, -0x8(%rbp)
jmp 0xde5fe
jmp 0xde5e8
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
jmp 0xde587
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| my_os_charset_to_mysql_charset:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
lea rax, charsets
mov [rbp+var_18], rax
loc_DE587:
mov rax, [rbp+var_18]
cmp qword ptr [rax], 0
jz short loc_DE5F6
mov rax, [rbp+var_18]
mov rdi, [rax]
mov rsi, [rbp+var_10]
call _strcasecmp
cmp eax, 0
jnz short loc_DE5E6
mov rax, [rbp+var_18]
mov eax, [rax+10h]
mov [rbp+var_1C], eax
test eax, eax
jz short loc_DE5C0
jmp short $+2
loc_DE5B6:
mov eax, [rbp+var_1C]
sub eax, 1
jz short loc_DE5CE
jmp short loc_DE5DC
loc_DE5C0:
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov [rbp+var_8], rax
jmp short loc_DE5FE
loc_DE5CE:
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov [rbp+var_8], rax
jmp short loc_DE5FE
loc_DE5DC:
mov [rbp+var_8], 0
jmp short loc_DE5FE
loc_DE5E6:
jmp short $+2
loc_DE5E8:
mov rax, [rbp+var_18]
add rax, 18h
mov [rbp+var_18], rax
jmp short loc_DE587
loc_DE5F6:
mov [rbp+var_8], 0
loc_DE5FE:
mov rax, [rbp+var_8]
add rsp, 20h
pop rbp
retn
| char * my_os_charset_to_mysql_charset(long long a1)
{
int v2; // [rsp+4h] [rbp-1Ch]
char **i; // [rsp+8h] [rbp-18h]
for ( i = charsets; ; i += 3 )
{
if ( !*i )
return 0LL;
if ( !(unsigned int)strcasecmp(*i, a1) )
break;
}
v2 = *((_DWORD *)i + 4);
if ( !v2 )
return i[1];
if ( v2 == 1 )
return i[1];
return 0LL;
}
| my_os_charset_to_mysql_charset:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
LEA RAX,[0x3b5720]
MOV qword ptr [RBP + -0x18],RAX
LAB_001de587:
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX],0x0
JZ 0x001de5f6
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x001295a0
CMP EAX,0x0
JNZ 0x001de5e6
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x10]
MOV dword ptr [RBP + -0x1c],EAX
TEST EAX,EAX
JZ 0x001de5c0
JMP 0x001de5b6
LAB_001de5b6:
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x1
JZ 0x001de5ce
JMP 0x001de5dc
LAB_001de5c0:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001de5fe
LAB_001de5ce:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001de5fe
LAB_001de5dc:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001de5fe
LAB_001de5e6:
JMP 0x001de5e8
LAB_001de5e8:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x18
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001de587
LAB_001de5f6:
MOV qword ptr [RBP + -0x8],0x0
LAB_001de5fe:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x20
POP RBP
RET
|
int * my_os_charset_to_mysql_charset(char *param_1)
{
int iVar1;
int **local_20;
local_20 = &charsets;
while( true ) {
if (*local_20 == (int *)0x0) {
return (int *)0x0;
}
iVar1 = strcasecmp(*local_20,param_1);
if (iVar1 == 0) break;
local_20 = local_20 + 3;
}
if (*(int *)(local_20 + 2) != 0) {
if (*(int *)(local_20 + 2) != 1) {
return (int *)0x0;
}
return local_20[1];
}
return local_20[1];
}
|
|
977 | flux::lexer::Token::getKeywordType(std::basic_string_view<char, std::char_traits<char>>) | kvthweatt[P]FluxLang/src/lexer/token.cpp | TokenType Token::getKeywordType(std::string_view keyword) {
auto it = keywords_.find(keyword);
if (it != keywords_.end()) {
return it->second;
}
// Special case for !void
if (keyword == "!void") {
return TokenType::BANG_VOID;
}
return TokenType::IDENTIFIER;
} | O0 | cpp | flux::lexer::Token::getKeywordType(std::basic_string_view<char, std::char_traits<char>>):
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x7e419(%rip), %rdi # 0x963c0
leaq -0x18(%rbp), %rsi
callq 0x18290
movq %rax, -0x20(%rbp)
leaq 0x7e405(%rip), %rdi # 0x963c0
callq 0x182f0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x182c0
testb $0x1, %al
jne 0x17fd7
jmp 0x17fe8
leaq -0x20(%rbp), %rdi
callq 0x18320
movl 0x10(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x18033
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x48(%rbp), %rdi
leaq 0x4a995(%rip), %rsi # 0x62998
callq 0xd130
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x40(%rbp), %rcx
callq 0x15330
testb $0x1, %al
jne 0x18023
jmp 0x1802c
movl $0x68, -0x4(%rbp)
jmp 0x18033
movl $0x5, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
| _ZN4flux5lexer5Token14getKeywordTypeESt17basic_string_viewIcSt11char_traitsIcEE:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_18], rdi
mov [rbp+var_10], rsi
lea rdi, _ZN4flux5lexer5Token9keywords_E; flux::lexer::Token::keywords_
lea rsi, [rbp+var_18]
call _ZNKSt13unordered_mapISt17basic_string_viewIcSt11char_traitsIcEEN4flux5lexer9TokenTypeESt4hashIS3_ESt8equal_toIS3_ESaISt4pairIKS3_S6_EEE4findERSC_; std::unordered_map<std::string_view,flux::lexer::TokenType>::find(std::string_view const&)
mov [rbp+var_20], rax
lea rdi, _ZN4flux5lexer5Token9keywords_E; flux::lexer::Token::keywords_
call _ZNKSt13unordered_mapISt17basic_string_viewIcSt11char_traitsIcEEN4flux5lexer9TokenTypeESt4hashIS3_ESt8equal_toIS3_ESaISt4pairIKS3_S6_EEE3endEv; std::unordered_map<std::string_view,flux::lexer::TokenType>::end(void)
mov [rbp+var_28], rax
lea rdi, [rbp+var_20]
lea rsi, [rbp+var_28]
call _ZNSt8__detailneERKNS_19_Node_iterator_baseISt4pairIKSt17basic_string_viewIcSt11char_traitsIcEEN4flux5lexer9TokenTypeEELb1EEESD_; std::__detail::operator!=(std::__detail::_Node_iterator_base<std::pair<std::string_view const,flux::lexer::TokenType>,true> const&,std::__detail::_Node_iterator_base<std::pair<std::string_view const,flux::lexer::TokenType>,true> const&)
test al, 1
jnz short loc_17FD7
jmp short loc_17FE8
loc_17FD7:
lea rdi, [rbp+var_20]
call _ZNKSt8__detail20_Node_const_iteratorISt4pairIKSt17basic_string_viewIcSt11char_traitsIcEEN4flux5lexer9TokenTypeEELb0ELb1EEptEv; std::__detail::_Node_const_iterator<std::pair<std::string_view const,flux::lexer::TokenType>,false,true>::operator->(void)
mov eax, [rax+10h]
mov [rbp+var_4], eax
jmp short loc_18033
loc_17FE8:
mov rax, [rbp+var_18]
mov [rbp+var_38], rax
mov rax, [rbp+var_10]
mov [rbp+var_30], rax
lea rdi, [rbp+var_48]
lea rsi, aVoid; "!void"
call _ZNSt17basic_string_viewIcSt11char_traitsIcEEC2EPKc; std::string_view::basic_string_view(char const*)
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_48]
mov rcx, [rbp+var_40]
call _ZSteqIcSt11char_traitsIcEEbSt17basic_string_viewIT_T0_ENSt15__type_identityIS5_E4typeE; std::operator==<char,std::char_traits<char>>(std::string_view,std::__type_identity<std::string_view>::type)
test al, 1
jnz short loc_18023
jmp short loc_1802C
loc_18023:
mov [rbp+var_4], 68h ; 'h'
jmp short loc_18033
loc_1802C:
mov [rbp+var_4], 5
loc_18033:
mov eax, [rbp+var_4]
add rsp, 50h
pop rbp
retn
| long long flux::lexer::Token::getKeywordType(long long a1, long long a2)
{
long long v3[2]; // [rsp+8h] [rbp-48h] BYREF
long long v4; // [rsp+18h] [rbp-38h]
long long v5; // [rsp+20h] [rbp-30h]
long long v6; // [rsp+28h] [rbp-28h] BYREF
long long v7; // [rsp+30h] [rbp-20h] BYREF
long long v8; // [rsp+38h] [rbp-18h] BYREF
long long v9; // [rsp+40h] [rbp-10h]
v8 = a1;
v9 = a2;
v7 = std::unordered_map<std::string_view,flux::lexer::TokenType>::find(&flux::lexer::Token::keywords_, &v8);
v6 = std::unordered_map<std::string_view,flux::lexer::TokenType>::end(&flux::lexer::Token::keywords_);
if ( (std::__detail::operator!=(&v7, &v6) & 1) != 0 )
{
return *(unsigned int *)(std::__detail::_Node_const_iterator<std::pair<std::string_view const,flux::lexer::TokenType>,false,true>::operator->(&v7)
+ 16);
}
else
{
v4 = v8;
v5 = v9;
std::string_view::basic_string_view(v3, (long long)"!void");
if ( std::operator==<char,std::char_traits<char>>(v4, v5, v3[0], v3[1]) )
return 104;
else
return 5;
}
}
| getKeywordType:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x10],RSI
LEA RDI,[0x1963c0]
LEA RSI,[RBP + -0x18]
CALL 0x00118290
MOV qword ptr [RBP + -0x20],RAX
LEA RDI,[0x1963c0]
CALL 0x001182f0
MOV qword ptr [RBP + -0x28],RAX
LEA RDI,[RBP + -0x20]
LEA RSI,[RBP + -0x28]
CALL 0x001182c0
TEST AL,0x1
JNZ 0x00117fd7
JMP 0x00117fe8
LAB_00117fd7:
LEA RDI,[RBP + -0x20]
CALL 0x00118320
MOV EAX,dword ptr [RAX + 0x10]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00118033
LAB_00117fe8:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x30],RAX
LEA RDI,[RBP + -0x48]
LEA RSI,[0x162998]
CALL 0x0010d130
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RBP + -0x40]
CALL 0x00115330
TEST AL,0x1
JNZ 0x00118023
JMP 0x0011802c
LAB_00118023:
MOV dword ptr [RBP + -0x4],0x68
JMP 0x00118033
LAB_0011802c:
MOV dword ptr [RBP + -0x4],0x5
LAB_00118033:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x50
POP RBP
RET
|
/* flux::lexer::Token::getKeywordType(std::basic_string_view<char, std::char_traits<char> >) */
int4 __thiscall flux::lexer::Token::getKeywordType(Token *this,int8 param_2)
{
bool bVar1;
ulong uVar2;
long lVar3;
int8 local_50;
int8 local_48;
Token *local_40;
int8 local_38;
int8 local_30;
int8 local_28;
Token *local_20;
int8 local_18;
int4 local_c;
local_20 = this;
local_18 = param_2;
local_28 = std::
unordered_map<std::basic_string_view<char,std::char_traits<char>>,flux::lexer::TokenType,std::hash<std::basic_string_view<char,std::char_traits<char>>>,std::equal_to<std::basic_string_view<char,std::char_traits<char>>>,std::allocator<std::pair<std::basic_string_view<char,std::char_traits<char>>const,flux::lexer::TokenType>>>
::find((unordered_map<std::basic_string_view<char,std::char_traits<char>>,flux::lexer::TokenType,std::hash<std::basic_string_view<char,std::char_traits<char>>>,std::equal_to<std::basic_string_view<char,std::char_traits<char>>>,std::allocator<std::pair<std::basic_string_view<char,std::char_traits<char>>const,flux::lexer::TokenType>>>
*)keywords_,(basic_string_view *)&local_20);
local_30 = std::
unordered_map<std::basic_string_view<char,std::char_traits<char>>,flux::lexer::TokenType,std::hash<std::basic_string_view<char,std::char_traits<char>>>,std::equal_to<std::basic_string_view<char,std::char_traits<char>>>,std::allocator<std::pair<std::basic_string_view<char,std::char_traits<char>>const,flux::lexer::TokenType>>>
::end();
uVar2 = std::__detail::operator!=
((_Node_iterator_base *)&local_28,(_Node_iterator_base *)&local_30);
if ((uVar2 & 1) == 0) {
local_40 = local_20;
local_38 = local_18;
std::basic_string_view<char,std::char_traits<char>>::basic_string_view
((basic_string_view<char,std::char_traits<char>> *)&local_50,"!void");
bVar1 = std::operator==(local_40,local_38,local_50,local_48);
if (bVar1) {
local_c = 0x68;
}
else {
local_c = 5;
}
}
else {
lVar3 = std::__detail::
_Node_const_iterator<std::pair<std::basic_string_view<char,std::char_traits<char>>const,flux::lexer::TokenType>,false,true>
::operator->((_Node_const_iterator<std::pair<std::basic_string_view<char,std::char_traits<char>>const,flux::lexer::TokenType>,false,true>
*)&local_28);
local_c = *(int4 *)(lVar3 + 0x10);
}
return local_c;
}
|
|
978 | flux::lexer::Token::getKeywordType(std::basic_string_view<char, std::char_traits<char>>) | kvthweatt[P]FluxLang/src/lexer/token.cpp | TokenType Token::getKeywordType(std::string_view keyword) {
auto it = keywords_.find(keyword);
if (it != keywords_.end()) {
return it->second;
}
// Special case for !void
if (keyword == "!void") {
return TokenType::BANG_VOID;
}
return TokenType::IDENTIFIER;
} | O1 | cpp | flux::lexer::Token::getKeywordType(std::basic_string_view<char, std::char_traits<char>>):
subq $0x18, %rsp
leaq 0x8(%rsp), %rax
movq %rdi, (%rax)
movq %rsi, 0x8(%rax)
leaq 0x2e7e1(%rip), %rdi # 0x3b2f0
movq %rax, %rsi
callq 0xd0c6
testq %rax, %rax
je 0xcb21
movl 0x18(%rax), %eax
jmp 0xcb51
movq 0x8(%rsp), %rdx
movl $0x5, %eax
cmpq $0x5, %rdx
jne 0xcb51
movq 0x10(%rsp), %rdi
leaq 0x1ef53(%rip), %rsi # 0x2ba90
callq 0x6290
testl %eax, %eax
movl $0x68, %ecx
movl $0x5, %eax
cmovel %ecx, %eax
addq $0x18, %rsp
retq
| _ZN4flux5lexer5Token14getKeywordTypeESt17basic_string_viewIcSt11char_traitsIcEE:
sub rsp, 18h
lea rax, [rsp+18h+var_10]
mov [rax], rdi
mov [rax+8], rsi
lea rdi, _ZN4flux5lexer5Token9keywords_E; flux::lexer::Token::keywords_
mov rsi, rax
call _ZNKSt10_HashtableISt17basic_string_viewIcSt11char_traitsIcEESt4pairIKS3_N4flux5lexer9TokenTypeEESaIS9_ENSt8__detail10_Select1stESt8equal_toIS3_ESt4hashIS3_ENSB_18_Mod_range_hashingENSB_20_Default_ranged_hashENSB_20_Prime_rehash_policyENSB_17_Hashtable_traitsILb1ELb0ELb1EEEE4findERS5_; std::_Hashtable<std::string_view,std::pair<std::string_view const,flux::lexer::TokenType>,std::allocator<std::pair<std::string_view const,flux::lexer::TokenType>>,std::__detail::_Select1st,std::equal_to<std::string_view>,std::hash<std::string_view>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::find(std::string_view const&)
test rax, rax
jz short loc_CB21
mov eax, [rax+18h]
jmp short loc_CB51
loc_CB21:
mov rdx, [rsp+18h+var_10]
mov eax, 5
cmp rdx, 5
jnz short loc_CB51
mov rdi, [rsp+18h+var_8]
lea rsi, aVoid; "!void"
call _bcmp
test eax, eax
mov ecx, 68h ; 'h'
mov eax, 5
cmovz eax, ecx
loc_CB51:
add rsp, 18h
retn
| long long flux::lexer::Token::getKeywordType(long long a1, long long a2)
{
long long v2; // rax
long long result; // rax
bool v4; // zf
long long v5; // [rsp+8h] [rbp-10h] BYREF
long long v6; // [rsp+10h] [rbp-8h]
v5 = a1;
v6 = a2;
v2 = std::_Hashtable<std::string_view,std::pair<std::string_view const,flux::lexer::TokenType>,std::allocator<std::pair<std::string_view const,flux::lexer::TokenType>>,std::__detail::_Select1st,std::equal_to<std::string_view>,std::hash<std::string_view>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::find(
&flux::lexer::Token::keywords_,
&v5);
if ( v2 )
return *(unsigned int *)(v2 + 24);
result = 5LL;
if ( v5 == 5 )
{
v4 = (unsigned int)bcmp(v6, "!void", 5LL) == 0;
result = 5LL;
if ( v4 )
return 104LL;
}
return result;
}
| getKeywordType:
SUB RSP,0x18
LEA RAX,[RSP + 0x8]
MOV qword ptr [RAX],RDI
MOV qword ptr [RAX + 0x8],RSI
LEA RDI,[0x13b2f0]
MOV RSI,RAX
CALL 0x0010d0c6
TEST RAX,RAX
JZ 0x0010cb21
MOV EAX,dword ptr [RAX + 0x18]
JMP 0x0010cb51
LAB_0010cb21:
MOV RDX,qword ptr [RSP + 0x8]
MOV EAX,0x5
CMP RDX,0x5
JNZ 0x0010cb51
MOV RDI,qword ptr [RSP + 0x10]
LEA RSI,[0x12ba90]
CALL 0x00106290
TEST EAX,EAX
MOV ECX,0x68
MOV EAX,0x5
CMOVZ EAX,ECX
LAB_0010cb51:
ADD RSP,0x18
RET
|
/* flux::lexer::Token::getKeywordType(std::basic_string_view<char, std::char_traits<char> >) */
int4 __thiscall flux::lexer::Token::getKeywordType(Token *this,void *param_2)
{
int iVar1;
int4 uVar2;
long lVar3;
Token *local_10;
void *local_8;
local_10 = this;
local_8 = param_2;
lVar3 = std::
_Hashtable<std::basic_string_view<char,std::char_traits<char>>,std::pair<std::basic_string_view<char,std::char_traits<char>>const,flux::lexer::TokenType>,std::allocator<std::pair<std::basic_string_view<char,std::char_traits<char>>const,flux::lexer::TokenType>>,std::__detail::_Select1st,std::equal_to<std::basic_string_view<char,std::char_traits<char>>>,std::hash<std::basic_string_view<char,std::char_traits<char>>>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
::find((_Hashtable<std::basic_string_view<char,std::char_traits<char>>,std::pair<std::basic_string_view<char,std::char_traits<char>>const,flux::lexer::TokenType>,std::allocator<std::pair<std::basic_string_view<char,std::char_traits<char>>const,flux::lexer::TokenType>>,std::__detail::_Select1st,std::equal_to<std::basic_string_view<char,std::char_traits<char>>>,std::hash<std::basic_string_view<char,std::char_traits<char>>>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
*)keywords_,(basic_string_view *)&local_10);
if (lVar3 == 0) {
uVar2 = 5;
if (local_10 == (Token *)0x5) {
iVar1 = bcmp(local_8,&DAT_0012ba90,5);
uVar2 = 5;
if (iVar1 == 0) {
uVar2 = 0x68;
}
}
}
else {
uVar2 = *(int4 *)(lVar3 + 0x18);
}
return uVar2;
}
|
|
979 | try_draft(std::unordered_map<common_ngram, std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, int>>>, common_ngram_hash_function, std::equal_to<common_ngram>, std::allocator<std::pair<common_ngram const, std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, int>>>>>>&, std::vector<common_ngram, std::allocator<common_ngram>> const&, std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, int>>>&, int const*, int const*) | monkey531[P]llama/common/ngram-cache.cpp | static llama_token try_draft(
common_ngram_cache & nc_primary, const std::vector<common_ngram> & ngrams_primary, common_ngram_cache_part & part_static,
const int * min_sample_size, const int * min_percent) {
llama_token drafted_token = LLAMA_TOKEN_NULL;
for (int i = ngrams_primary.size()-1; i >= 0 && drafted_token == LLAMA_TOKEN_NULL; --i) {
const common_ngram ngram_primary = ngrams_primary[i];
common_ngram_cache::iterator part_primary_it = nc_primary.find(ngram_primary);
if (part_primary_it == nc_primary.end()) {
continue;
}
const common_ngram_cache_part part_primary = part_primary_it->second;
int max_count_primary = 0;
int max_count_static = 0;
int sum_count_primary = 0;
llama_token max_token = LLAMA_TOKEN_NULL;
for (std::pair<llama_token, int> token_count_primary : part_primary) {
const llama_token token = token_count_primary.first;
common_ngram_cache_part::iterator token_count_static_it = part_static.find(token);
const int32_t count_primary = token_count_primary.second;
const int32_t count_static = token_count_static_it != part_static.end() ? 100*token_count_static_it->second : 1;
if (count_primary*count_static > max_count_primary*max_count_static) {
max_token = token;
max_count_primary = count_primary;
max_count_static = count_static;
}
sum_count_primary += count_primary;
}
if (sum_count_primary < min_sample_size[i]) {
continue;
}
if (100*max_count_primary < min_percent[i]*sum_count_primary) {
continue;;
}
drafted_token = max_token;
}
return drafted_token;
} | O1 | cpp | try_draft(std::unordered_map<common_ngram, std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, int>>>, common_ngram_hash_function, std::equal_to<common_ngram>, std::allocator<std::pair<common_ngram const, std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, int>>>>>>&, std::vector<common_ngram, std::allocator<common_ngram>> const&, std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, int>>>&, int const*, int const*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r8, 0x8(%rsp)
movq %rcx, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x8(%rsi), %rax
subq (%rsi), %rax
shrq $0x4, %rax
decl %eax
js 0xce050
movq %rsi, %rbx
movq %rdi, %r14
movl %eax, %r12d
leaq 0x40(%rsp), %r13
movq %rsi, 0x18(%rsp)
movq %rdi, 0x10(%rsp)
movq (%rbx), %rax
movq %r12, %rcx
shlq $0x4, %rcx
movups (%rax,%rcx), %xmm0
movaps %xmm0, 0x40(%rsp)
movq %r14, %rdi
movq %r13, %rsi
callq 0xced08
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
testq %rax, %rax
je 0xce03d
movq %rax, %rsi
addq $0x18, %rsi
xorl %r15d, %r15d
movq %r15, 0x50(%rsp)
movq 0x20(%rax), %rcx
movq %rcx, 0x58(%rsp)
movq %r15, 0x60(%rsp)
movq 0x30(%rax), %rcx
movq %rcx, 0x68(%rsp)
movups 0x38(%rax), %xmm0
leaq 0x70(%rsp), %rax
movups %xmm0, (%rax)
movq %r15, 0x80(%rsp)
leaq 0x50(%rsp), %rdi
movq %rdi, 0x38(%rsp)
leaq 0x38(%rsp), %rdx
callq 0xcebc2
movq 0x60(%rsp), %r9
movl $0xffffffff, 0x4(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, %r8d # imm = 0xFFFFFFFF
movl $0x0, %eax
testq %r9, %r9
je 0xce009
movq %r12, 0x30(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %r10
movq 0x8(%rax), %r11
xorl %ebx, %ebx
xorl %r13d, %r13d
xorl %r15d, %r15d
movslq 0x8(%r9), %rcx
movl 0xc(%r9), %r12d
movq %rcx, %rax
xorl %edx, %edx
divq %r11
movq %rdx, %rsi
movq (%r10,%rdx,8), %rdx
movl $0x0, %eax
testq %rdx, %rdx
je 0xcdfad
movq (%rdx), %rbp
movq %rdx, %rax
cmpl 0x8(%rbp), %ecx
je 0xcdfad
movq %rbp, %r14
movq (%rbp), %rbp
testq %rbp, %rbp
je 0xcdfab
movslq 0x8(%rbp), %rdi
movq %rdi, %rax
xorl %edx, %edx
divq %r11
movl $0x0, %eax
cmpq %rsi, %rdx
jne 0xcdfad
movq %r14, %rax
cmpl %edi, %ecx
jne 0xcdf80
jmp 0xcdfad
xorl %eax, %eax
testq %rax, %rax
je 0xcdfb7
movq (%rax), %rax
jmp 0xcdfb9
xorl %eax, %eax
testq %rax, %rax
je 0xcdfc4
imull $0x64, 0xc(%rax), %eax
jmp 0xcdfc9
movl $0x1, %eax
movl %eax, %edx
imull %r12d, %edx
movl %ebx, %esi
imull %r13d, %esi
cmpl %esi, %edx
cmovgl %ecx, %r8d
cmovgl %eax, %r13d
cmovgl %r12d, %ebx
addl %r12d, %r15d
movq (%r9), %r9
testq %r9, %r9
jne 0xcdf54
imull $0x64, %ebx, %eax
movq 0x18(%rsp), %rbx
movq 0x10(%rsp), %r14
movq 0x30(%rsp), %r12
leaq 0x40(%rsp), %r13
movq 0x28(%rsp), %rcx
cmpl (%rcx,%r12,4), %r15d
jl 0xce02f
movq 0x8(%rsp), %rcx
imull (%rcx,%r12,4), %r15d
cmpl %r15d, %eax
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmovll %eax, %r8d
movl %r8d, 0x4(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x21f0e
movl 0x4(%rsp), %ecx
testq %r12, %r12
jle 0xce055
decq %r12
cmpl $-0x1, %ecx
je 0xcdea0
jmp 0xce055
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
movl %ecx, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZL9try_draftRSt13unordered_mapI12common_ngramS_IiiSt4hashIiESt8equal_toIiESaISt4pairIKiiEEE26common_ngram_hash_functionS3_IS0_ESaIS5_IKS0_S9_EEERKSt6vectorIS0_SaIS0_EERS9_PS6_SN_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 88h
mov [rsp+0B8h+var_B0], r8
mov [rsp+0B8h+var_90], rcx
mov [rsp+0B8h+var_98], rdx
mov rax, [rsi+8]
sub rax, [rsi]
shr rax, 4
dec eax
js loc_CE050
mov rbx, rsi
mov r14, rdi
mov r12d, eax
lea r13, [rsp+0B8h+var_78]
mov [rsp+0B8h+var_A0], rsi
mov [rsp+0B8h+var_A8], rdi
loc_CDEA0:
mov rax, [rbx]
mov rcx, r12
shl rcx, 4
movups xmm0, xmmword ptr [rax+rcx]
movaps [rsp+0B8h+var_78], xmm0
mov rdi, r14
mov rsi, r13
call _ZNSt10_HashtableI12common_ngramSt4pairIKS0_St13unordered_mapIiiSt4hashIiESt8equal_toIiESaIS1_IKiiEEEESaISC_ENSt8__detail10_Select1stES6_IS0_E26common_ngram_hash_functionNSE_18_Mod_range_hashingENSE_20_Default_ranged_hashENSE_20_Prime_rehash_policyENSE_17_Hashtable_traitsILb1ELb0ELb1EEEE4findERS2_; std::_Hashtable<common_ngram,std::pair<common_ngram const,std::unordered_map<int,int>>,std::allocator<std::pair<common_ngram const,std::unordered_map<int,int>>>,std::__detail::_Select1st,std::equal_to<common_ngram>,common_ngram_hash_function,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::find(common_ngram const&)
mov ecx, 0FFFFFFFFh
test rax, rax
jz loc_CE03D
mov rsi, rax
add rsi, 18h
xor r15d, r15d
mov [rsp+0B8h+var_68], r15
mov rcx, [rax+20h]
mov [rsp+0B8h+var_60], rcx
mov [rsp+0B8h+var_58], r15
mov rcx, [rax+30h]
mov [rsp+0B8h+var_50], rcx
movups xmm0, xmmword ptr [rax+38h]
lea rax, [rsp+0B8h+var_48]
movups xmmword ptr [rax], xmm0
mov [rsp+0B8h+var_38], r15
lea rdi, [rsp+0B8h+var_68]
mov [rsp+0B8h+var_80], rdi
lea rdx, [rsp+0B8h+var_80]
call _ZNSt10_HashtableIiSt4pairIKiiESaIS2_ENSt8__detail10_Select1stESt8equal_toIiESt4hashIiENS4_18_Mod_range_hashingENS4_20_Default_ranged_hashENS4_20_Prime_rehash_policyENS4_17_Hashtable_traitsILb0ELb0ELb1EEEE9_M_assignIRKSF_NS4_10_AllocNodeISaINS4_10_Hash_nodeIS2_Lb0EEEEEEEEvOT_RKT0_; std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::_M_assign<std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>> const&,std::__detail::_AllocNode<std::allocator<std::__detail::_Hash_node<std::pair<int const,int>,false>>>>(std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>> const&,std::__detail::_AllocNode<std::allocator<std::__detail::_Hash_node<std::pair<int const,int>,false>>> const&)
mov r9, [rsp+0B8h+var_58]
mov [rsp+0B8h+var_B4], 0FFFFFFFFh
mov r8d, 0FFFFFFFFh
mov eax, 0
test r9, r9
jz loc_CE009
mov [rsp+0B8h+var_88], r12
mov rax, [rsp+0B8h+var_98]
mov r10, [rax]
mov r11, [rax+8]
xor ebx, ebx
xor r13d, r13d
xor r15d, r15d
loc_CDF54:
movsxd rcx, dword ptr [r9+8]
mov r12d, [r9+0Ch]
mov rax, rcx
xor edx, edx
div r11
mov rsi, rdx
mov rdx, [r10+rdx*8]
mov eax, 0
test rdx, rdx
jz short loc_CDFAD
mov rbp, [rdx]
mov rax, rdx
cmp ecx, [rbp+8]
jz short loc_CDFAD
loc_CDF80:
mov r14, rbp
mov rbp, [rbp+0]
test rbp, rbp
jz short loc_CDFAB
movsxd rdi, dword ptr [rbp+8]
mov rax, rdi
xor edx, edx
div r11
mov eax, 0
cmp rdx, rsi
jnz short loc_CDFAD
mov rax, r14
cmp ecx, edi
jnz short loc_CDF80
jmp short loc_CDFAD
loc_CDFAB:
xor eax, eax
loc_CDFAD:
test rax, rax
jz short loc_CDFB7
mov rax, [rax]
jmp short loc_CDFB9
loc_CDFB7:
xor eax, eax
loc_CDFB9:
test rax, rax
jz short loc_CDFC4
imul eax, [rax+0Ch], 64h ; 'd'
jmp short loc_CDFC9
loc_CDFC4:
mov eax, 1
loc_CDFC9:
mov edx, eax
imul edx, r12d
mov esi, ebx
imul esi, r13d
cmp edx, esi
cmovg r8d, ecx
cmovg r13d, eax
cmovg ebx, r12d
add r15d, r12d
mov r9, [r9]
test r9, r9
jnz loc_CDF54
imul eax, ebx, 64h ; 'd'
mov rbx, [rsp+0B8h+var_A0]
mov r14, [rsp+0B8h+var_A8]
mov r12, [rsp+0B8h+var_88]
lea r13, [rsp+0B8h+var_78]
loc_CE009:
mov rcx, [rsp+0B8h+var_90]
cmp r15d, [rcx+r12*4]
jl short loc_CE02F
mov rcx, [rsp+0B8h+var_B0]
imul r15d, [rcx+r12*4]
cmp eax, r15d
mov eax, 0FFFFFFFFh
cmovl r8d, eax
mov [rsp+0B8h+var_B4], r8d
loc_CE02F:
lea rdi, [rsp+0B8h+var_68]
call _ZNSt10_HashtableIiSt4pairIKiiESaIS2_ENSt8__detail10_Select1stESt8equal_toIiESt4hashIiENS4_18_Mod_range_hashingENS4_20_Default_ranged_hashENS4_20_Prime_rehash_policyENS4_17_Hashtable_traitsILb0ELb0ELb1EEEED2Ev; std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::~_Hashtable()
mov ecx, [rsp+0B8h+var_B4]
loc_CE03D:
test r12, r12
jle short loc_CE055
dec r12
cmp ecx, 0FFFFFFFFh
jz loc_CDEA0
jmp short loc_CE055
loc_CE050:
mov ecx, 0FFFFFFFFh
loc_CE055:
mov eax, ecx
add rsp, 88h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long try_draft(long long a1, _QWORD *a2, long long *a3, long long a4, long long a5)
{
int v5; // eax
_QWORD *v6; // rbx
long long v7; // r14
long long v8; // r12
long long v9; // rax
unsigned int v10; // ecx
int v11; // r15d
long long *v12; // r9
int v13; // r8d
int v14; // eax
long long v15; // r10
unsigned long long v16; // r11
int v17; // ebx
int v18; // r13d
int v19; // ecx
int v20; // r12d
unsigned long long v21; // rsi
long long **v22; // rdx
long long *v23; // rax
long long *v24; // rbp
long long *v25; // r14
long long v26; // rax
int v27; // eax
int v29; // [rsp+4h] [rbp-B4h]
long long v34; // [rsp+30h] [rbp-88h]
_QWORD *v35; // [rsp+38h] [rbp-80h] BYREF
__int128 v36; // [rsp+40h] [rbp-78h] BYREF
_QWORD v37[2]; // [rsp+50h] [rbp-68h] BYREF
long long *v38; // [rsp+60h] [rbp-58h]
long long v39; // [rsp+68h] [rbp-50h]
__int128 v40; // [rsp+70h] [rbp-48h]
long long v41; // [rsp+80h] [rbp-38h]
v5 = ((a2[1] - *a2) >> 4) - 1;
if ( v5 < 0 )
{
return (unsigned int)-1;
}
else
{
v6 = a2;
v7 = a1;
v8 = (unsigned int)v5;
do
{
v36 = *(_OWORD *)(*v6 + 16 * v8);
v9 = std::_Hashtable<common_ngram,std::pair<common_ngram const,std::unordered_map<int,int>>,std::allocator<std::pair<common_ngram const,std::unordered_map<int,int>>>,std::__detail::_Select1st,std::equal_to<common_ngram>,common_ngram_hash_function,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::find(
v7,
&v36,
a3,
16 * v8);
v10 = -1;
if ( v9 )
{
v11 = 0;
v37[0] = 0LL;
v37[1] = *(_QWORD *)(v9 + 32);
v38 = 0LL;
v39 = *(_QWORD *)(v9 + 48);
v40 = *(_OWORD *)(v9 + 56);
v41 = 0LL;
v35 = v37;
std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::_M_assign<std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>> const&,std::__detail::_AllocNode<std::allocator<std::__detail::_Hash_node<std::pair<int const,int>,false>>>>(
v37,
v9 + 24,
&v35);
v12 = v38;
v29 = -1;
v13 = -1;
v14 = 0;
if ( v38 )
{
v34 = v8;
v15 = *a3;
v16 = a3[1];
v17 = 0;
v18 = 0;
v11 = 0;
do
{
v19 = *((_DWORD *)v12 + 2);
v20 = *((_DWORD *)v12 + 3);
v21 = v19 % v16;
v22 = *(long long ***)(v15 + 8 * v21);
v23 = 0LL;
if ( v22 )
{
v24 = *v22;
v23 = *(long long **)(v15 + 8 * v21);
if ( v19 != *((_DWORD *)*v22 + 2) )
{
while ( 1 )
{
v25 = v24;
v24 = (long long *)*v24;
if ( !v24 )
break;
v23 = 0LL;
if ( *((int *)v24 + 2) % v16 == v21 )
{
v23 = v25;
if ( v19 != *((_DWORD *)v24 + 2) )
continue;
}
goto LABEL_13;
}
v23 = 0LL;
}
}
LABEL_13:
if ( v23 )
v26 = *v23;
else
v26 = 0LL;
if ( v26 )
v27 = 100 * *(_DWORD *)(v26 + 12);
else
v27 = 1;
if ( v20 * v27 > v18 * v17 )
{
v13 = *((_DWORD *)v12 + 2);
v18 = v27;
v17 = *((_DWORD *)v12 + 3);
}
v11 += v20;
v12 = (long long *)*v12;
}
while ( v12 );
v14 = 100 * v17;
v6 = a2;
v7 = a1;
v8 = v34;
}
if ( v11 >= *(_DWORD *)(a4 + 4 * v8) )
{
if ( v14 < *(_DWORD *)(a5 + 4 * v8) * v11 )
v13 = -1;
v29 = v13;
}
std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::~_Hashtable((long long)v37);
v10 = v29;
}
if ( v8 <= 0 )
break;
--v8;
}
while ( v10 == -1 );
}
return v10;
}
| |||
980 | try_draft(std::unordered_map<common_ngram, std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, int>>>, common_ngram_hash_function, std::equal_to<common_ngram>, std::allocator<std::pair<common_ngram const, std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, int>>>>>>&, std::vector<common_ngram, std::allocator<common_ngram>> const&, std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, int>>>&, int const*, int const*) | monkey531[P]llama/common/ngram-cache.cpp | static llama_token try_draft(
common_ngram_cache & nc_primary, const std::vector<common_ngram> & ngrams_primary, common_ngram_cache_part & part_static,
const int * min_sample_size, const int * min_percent) {
llama_token drafted_token = LLAMA_TOKEN_NULL;
for (int i = ngrams_primary.size()-1; i >= 0 && drafted_token == LLAMA_TOKEN_NULL; --i) {
const common_ngram ngram_primary = ngrams_primary[i];
common_ngram_cache::iterator part_primary_it = nc_primary.find(ngram_primary);
if (part_primary_it == nc_primary.end()) {
continue;
}
const common_ngram_cache_part part_primary = part_primary_it->second;
int max_count_primary = 0;
int max_count_static = 0;
int sum_count_primary = 0;
llama_token max_token = LLAMA_TOKEN_NULL;
for (std::pair<llama_token, int> token_count_primary : part_primary) {
const llama_token token = token_count_primary.first;
common_ngram_cache_part::iterator token_count_static_it = part_static.find(token);
const int32_t count_primary = token_count_primary.second;
const int32_t count_static = token_count_static_it != part_static.end() ? 100*token_count_static_it->second : 1;
if (count_primary*count_static > max_count_primary*max_count_static) {
max_token = token;
max_count_primary = count_primary;
max_count_static = count_static;
}
sum_count_primary += count_primary;
}
if (sum_count_primary < min_sample_size[i]) {
continue;
}
if (100*max_count_primary < min_percent[i]*sum_count_primary) {
continue;;
}
drafted_token = max_token;
}
return drafted_token;
} | O2 | cpp | try_draft(std::unordered_map<common_ngram, std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, int>>>, common_ngram_hash_function, std::equal_to<common_ngram>, std::allocator<std::pair<common_ngram const, std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, int>>>>>>&, std::vector<common_ngram, std::allocator<common_ngram>> const&, std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, int>>>&, int const*, int const*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r8, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movq %rdx, 0x38(%rsp)
movq %rdi, 0x18(%rsp)
movq 0x8(%rsi), %rax
movq %rsi, 0x20(%rsp)
subq (%rsi), %rax
shrq $0x4, %rax
movl %eax, %r14d
pushq $-0x1
popq %rbp
leaq 0x50(%rsp), %r15
movl %ebp, %ebx
decq %r14
testl %r14d, %r14d
js 0x98065
cmpl $-0x1, %ebx
jne 0x98065
movl %r14d, %r12d
andl $0x7fffffff, %r12d # imm = 0x7FFFFFFF
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %r12, %rcx
shlq $0x4, %rcx
movups (%rax,%rcx), %xmm0
movaps %xmm0, 0x40(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x98b66
movl %ebp, %ebx
testq %rax, %rax
je 0x97f5d
movq %r12, 0x28(%rsp)
movq %r14, 0x30(%rsp)
addq $0x18, %rax
movq %r15, %rdi
movq %rax, %rsi
callq 0x98a4c
xorl %r13d, %r13d
leaq 0x60(%rsp), %rbx
movl %ebp, %r14d
xorl %r12d, %r12d
xorl %r15d, %r15d
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x98021
movl 0x8(%rbx), %eax
movl 0xc(%rbx), %ebp
movl %eax, 0x4(%rsp)
movq 0x38(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x9927c
pushq $0x1
popq %rcx
testq %rax, %rax
je 0x98001
imull $0x64, 0xc(%rax), %ecx
movl %ecx, %eax
imull %ebp, %eax
movl %r15d, %edx
imull %r12d, %edx
cmpl %edx, %eax
jle 0x9801c
movl 0x4(%rsp), %r14d
movl %ecx, %r12d
movl %ebp, %r15d
addl %ebp, %r13d
jmp 0x97fd4
pushq $-0x1
popq %rbp
movl %ebp, %ebx
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rdx
cmpl (%rax,%rdx,4), %r13d
jl 0x9804e
imull $0x64, %r15d, %eax
movq 0x8(%rsp), %rcx
imull (%rcx,%rdx,4), %r13d
cmpl %r13d, %eax
cmovll %ebp, %r14d
movl %r14d, %ebx
leaq 0x50(%rsp), %r15
movq %r15, %rdi
callq 0x2800e
movq 0x30(%rsp), %r14
jmp 0x97f5d
movl %ebx, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x2800e
movq %rbx, %rdi
callq 0x24f60
| _ZL9try_draftRSt13unordered_mapI12common_ngramS_IiiSt4hashIiESt8equal_toIiESaISt4pairIKiiEEE26common_ngram_hash_functionS3_IS0_ESaIS5_IKS0_S9_EEERKSt6vectorIS0_SaIS0_EERS9_PS6_SN_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 88h
mov [rsp+0B8h+var_B0], r8
mov [rsp+0B8h+var_A8], rcx
mov [rsp+0B8h+var_80], rdx
mov [rsp+0B8h+var_A0], rdi
mov rax, [rsi+8]
mov [rsp+0B8h+var_98], rsi
sub rax, [rsi]
shr rax, 4
mov r14d, eax
push 0FFFFFFFFFFFFFFFFh
pop rbp
lea r15, [rsp+0B8h+var_68]
mov ebx, ebp
loc_97F5D:
dec r14
test r14d, r14d
js loc_98065
cmp ebx, 0FFFFFFFFh
jnz loc_98065
mov r12d, r14d
and r12d, 7FFFFFFFh
mov rax, [rsp+0B8h+var_98]
mov rax, [rax]
mov rcx, r12
shl rcx, 4
movups xmm0, xmmword ptr [rax+rcx]
movaps [rsp+0B8h+var_78], xmm0
mov rdi, [rsp+0B8h+var_A0]
lea rsi, [rsp+0B8h+var_78]
call _ZNSt10_HashtableI12common_ngramSt4pairIKS0_St13unordered_mapIiiSt4hashIiESt8equal_toIiESaIS1_IKiiEEEESaISC_ENSt8__detail10_Select1stES6_IS0_E26common_ngram_hash_functionNSE_18_Mod_range_hashingENSE_20_Default_ranged_hashENSE_20_Prime_rehash_policyENSE_17_Hashtable_traitsILb1ELb0ELb1EEEE4findERS2_; std::_Hashtable<common_ngram,std::pair<common_ngram const,std::unordered_map<int,int>>,std::allocator<std::pair<common_ngram const,std::unordered_map<int,int>>>,std::__detail::_Select1st,std::equal_to<common_ngram>,common_ngram_hash_function,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::find(common_ngram const&)
mov ebx, ebp
test rax, rax
jz short loc_97F5D
mov [rsp+0B8h+var_90], r12
mov [rsp+0B8h+var_88], r14
add rax, 18h
mov rdi, r15
mov rsi, rax
call _ZNSt10_HashtableIiSt4pairIKiiESaIS2_ENSt8__detail10_Select1stESt8equal_toIiESt4hashIiENS4_18_Mod_range_hashingENS4_20_Default_ranged_hashENS4_20_Prime_rehash_policyENS4_17_Hashtable_traitsILb0ELb0ELb1EEEEC2ERKSF_; std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::_Hashtable(std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>> const&)
xor r13d, r13d
lea rbx, [rsp+0B8h+var_58]
mov r14d, ebp
xor r12d, r12d
xor r15d, r15d
loc_97FD4:
mov rbx, [rbx]
test rbx, rbx
jz short loc_98021
mov eax, [rbx+8]
mov ebp, [rbx+0Ch]
mov [rsp+0B8h+var_B4], eax
mov rdi, [rsp+0B8h+var_80]
lea rsi, [rsp+0B8h+var_B4]
call _ZNSt10_HashtableIiSt4pairIKiiESaIS2_ENSt8__detail10_Select1stESt8equal_toIiESt4hashIiENS4_18_Mod_range_hashingENS4_20_Default_ranged_hashENS4_20_Prime_rehash_policyENS4_17_Hashtable_traitsILb0ELb0ELb1EEEE4findERS1_; std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::find(int const&)
push 1
pop rcx
test rax, rax
jz short loc_98001
imul ecx, [rax+0Ch], 64h ; 'd'
loc_98001:
mov eax, ecx
imul eax, ebp
mov edx, r15d
imul edx, r12d
cmp eax, edx
jle short loc_9801C
mov r14d, [rsp+0B8h+var_B4]
mov r12d, ecx
mov r15d, ebp
loc_9801C:
add r13d, ebp
jmp short loc_97FD4
loc_98021:
push 0FFFFFFFFFFFFFFFFh
pop rbp
mov ebx, ebp
mov rax, [rsp+0B8h+var_A8]
mov rdx, [rsp+0B8h+var_90]
cmp r13d, [rax+rdx*4]
jl short loc_9804E
imul eax, r15d, 64h ; 'd'
mov rcx, [rsp+0B8h+var_B0]
imul r13d, [rcx+rdx*4]
cmp eax, r13d
cmovl r14d, ebp
mov ebx, r14d
loc_9804E:
lea r15, [rsp+0B8h+var_68]
mov rdi, r15
call _ZNSt10_HashtableIiSt4pairIKiiESaIS2_ENSt8__detail10_Select1stESt8equal_toIiESt4hashIiENS4_18_Mod_range_hashingENS4_20_Default_ranged_hashENS4_20_Prime_rehash_policyENS4_17_Hashtable_traitsILb0ELb0ELb1EEEED2Ev; std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::~_Hashtable()
mov r14, [rsp+0B8h+var_88]
jmp loc_97F5D
loc_98065:
mov eax, ebx
add rsp, 88h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
lea rdi, [rsp+arg_48]
call _ZNSt10_HashtableIiSt4pairIKiiESaIS2_ENSt8__detail10_Select1stESt8equal_toIiESt4hashIiENS4_18_Mod_range_hashingENS4_20_Default_ranged_hashENS4_20_Prime_rehash_policyENS4_17_Hashtable_traitsILb0ELb0ELb1EEEED2Ev; std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::~_Hashtable()
mov rdi, rbx
call __Unwind_Resume
| long long try_draft(long long a1, _QWORD *a2, long long a3, long long a4, long long a5)
{
long long v5; // rax
long long v6; // r14
unsigned int v7; // ebx
long long v8; // rax
int v9; // r13d
char *v10; // rbx
int v11; // r14d
int v12; // r12d
int v13; // r15d
int v14; // ebp
long long v15; // rax
int v16; // ecx
int v18; // [rsp+4h] [rbp-B4h] BYREF
long long v19; // [rsp+8h] [rbp-B0h]
long long v20; // [rsp+10h] [rbp-A8h]
long long v21; // [rsp+18h] [rbp-A0h]
_QWORD *v22; // [rsp+20h] [rbp-98h]
long long v23; // [rsp+28h] [rbp-90h]
long long v24; // [rsp+30h] [rbp-88h]
long long v25; // [rsp+38h] [rbp-80h]
__int128 v26; // [rsp+40h] [rbp-78h] BYREF
_BYTE v27[16]; // [rsp+50h] [rbp-68h] BYREF
char v28; // [rsp+60h] [rbp-58h] BYREF
v19 = a5;
v20 = a4;
v25 = a3;
v21 = a1;
v5 = a2[1];
v22 = a2;
v6 = (unsigned int)((unsigned long long)(v5 - *a2) >> 4);
v7 = -1;
while ( (int)--v6 >= 0 && v7 == -1 )
{
v26 = *(_OWORD *)(*v22 + 16 * (v6 & 0x7FFFFFFF));
v8 = std::_Hashtable<common_ngram,std::pair<common_ngram const,std::unordered_map<int,int>>,std::allocator<std::pair<common_ngram const,std::unordered_map<int,int>>>,std::__detail::_Select1st,std::equal_to<common_ngram>,common_ngram_hash_function,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::find(
v21,
&v26);
v7 = -1;
if ( v8 )
{
v23 = v6 & 0x7FFFFFFF;
v24 = v6;
std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::_Hashtable(
v27,
v8 + 24);
v9 = 0;
v10 = &v28;
v11 = -1;
v12 = 0;
v13 = 0;
while ( 1 )
{
v10 = *(char **)v10;
if ( !v10 )
break;
v14 = *((_DWORD *)v10 + 3);
v18 = *((_DWORD *)v10 + 2);
v15 = std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::find(
v25,
&v18);
v16 = 1;
if ( v15 )
v16 = 100 * *(_DWORD *)(v15 + 12);
if ( v14 * v16 > v12 * v13 )
{
v11 = v18;
v12 = v16;
v13 = v14;
}
v9 += v14;
}
v7 = -1;
if ( v9 >= *(_DWORD *)(v20 + 4 * v23) )
{
if ( 100 * v13 < *(_DWORD *)(v19 + 4 * v23) * v9 )
v11 = -1;
v7 = v11;
}
std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::~_Hashtable((long long)v27);
v6 = v24;
}
}
return v7;
}
| try_draft:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x88
MOV qword ptr [RSP + 0x8],R8
MOV qword ptr [RSP + 0x10],RCX
MOV qword ptr [RSP + 0x38],RDX
MOV qword ptr [RSP + 0x18],RDI
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RSP + 0x20],RSI
SUB RAX,qword ptr [RSI]
SHR RAX,0x4
MOV R14D,EAX
PUSH -0x1
POP RBP
LEA R15,[RSP + 0x50]
MOV EBX,EBP
LAB_00197f5d:
DEC R14
TEST R14D,R14D
JS 0x00198065
CMP EBX,-0x1
JNZ 0x00198065
MOV R12D,R14D
AND R12D,0x7fffffff
MOV RAX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RAX]
MOV RCX,R12
SHL RCX,0x4
MOVUPS XMM0,xmmword ptr [RAX + RCX*0x1]
MOVAPS xmmword ptr [RSP + 0x40],XMM0
MOV RDI,qword ptr [RSP + 0x18]
LEA RSI,[RSP + 0x40]
CALL 0x00198b66
MOV EBX,EBP
TEST RAX,RAX
JZ 0x00197f5d
MOV qword ptr [RSP + 0x28],R12
MOV qword ptr [RSP + 0x30],R14
ADD RAX,0x18
MOV RDI,R15
MOV RSI,RAX
CALL 0x00198a4c
XOR R13D,R13D
LEA RBX,[RSP + 0x60]
MOV R14D,EBP
XOR R12D,R12D
XOR R15D,R15D
LAB_00197fd4:
MOV RBX,qword ptr [RBX]
TEST RBX,RBX
JZ 0x00198021
MOV EAX,dword ptr [RBX + 0x8]
MOV EBP,dword ptr [RBX + 0xc]
MOV dword ptr [RSP + 0x4],EAX
LAB_00197fe6:
MOV RDI,qword ptr [RSP + 0x38]
LEA RSI,[RSP + 0x4]
CALL 0x0019927c
LAB_00197ff5:
PUSH 0x1
POP RCX
TEST RAX,RAX
JZ 0x00198001
IMUL ECX,dword ptr [RAX + 0xc],0x64
LAB_00198001:
MOV EAX,ECX
IMUL EAX,EBP
MOV EDX,R15D
IMUL EDX,R12D
CMP EAX,EDX
JLE 0x0019801c
MOV R14D,dword ptr [RSP + 0x4]
MOV R12D,ECX
MOV R15D,EBP
LAB_0019801c:
ADD R13D,EBP
JMP 0x00197fd4
LAB_00198021:
PUSH -0x1
POP RBP
MOV EBX,EBP
MOV RAX,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x28]
CMP R13D,dword ptr [RAX + RDX*0x4]
JL 0x0019804e
IMUL EAX,R15D,0x64
MOV RCX,qword ptr [RSP + 0x8]
IMUL R13D,dword ptr [RCX + RDX*0x4]
CMP EAX,R13D
CMOVL R14D,EBP
MOV EBX,R14D
LAB_0019804e:
LEA R15,[RSP + 0x50]
MOV RDI,R15
CALL 0x0012800e
MOV R14,qword ptr [RSP + 0x30]
JMP 0x00197f5d
LAB_00198065:
MOV EAX,EBX
ADD RSP,0x88
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* try_draft(std::unordered_map<common_ngram, std::unordered_map<int, int, std::hash<int>,
std::equal_to<int>, std::allocator<std::pair<int const, int> > >, common_ngram_hash_function,
std::equal_to<common_ngram>, std::allocator<std::pair<common_ngram const, std::unordered_map<int,
int, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, int> > > > > >&,
std::vector<common_ngram, std::allocator<common_ngram> > const&, std::unordered_map<int, int,
std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, int> > >&, int const*,
int const*) */
int try_draft(unordered_map *param_1,vector *param_2,unordered_map *param_3,int *param_4,
int *param_5)
{
int8 *puVar1;
int iVar2;
long lVar3;
int iVar4;
long *plVar5;
int iVar6;
ulong uVar7;
int iVar8;
int iVar9;
ulong uVar10;
int iVar11;
int local_b4;
int *local_b0;
int *local_a8;
_Hashtable<common_ngram,std::pair<common_ngram_const,std::unordered_map<int,int,std::hash<int>,std::equal_to<int>,std::allocator<std::pair<int_const,int>>>>,std::allocator<std::pair<common_ngram_const,std::unordered_map<int,int,std::hash<int>,std::equal_to<int>,std::allocator<std::pair<int_const,int>>>>>,std::__detail::_Select1st,std::equal_to<common_ngram>,common_ngram_hash_function,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
*local_a0;
vector *local_98;
ulong local_90;
ulong local_88;
unordered_map *local_80;
int8 local_78;
int8 uStack_70;
_Hashtable<int,std::pair<int_const,int>,std::allocator<std::pair<int_const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
local_68 [16];
long local_58 [5];
iVar6 = -1;
uVar10 = (ulong)(*(long *)(param_2 + 8) - *(long *)param_2) >> 4 & 0xffffffff;
local_b0 = param_5;
local_a8 = param_4;
local_a0 = (_Hashtable<common_ngram,std::pair<common_ngram_const,std::unordered_map<int,int,std::hash<int>,std::equal_to<int>,std::allocator<std::pair<int_const,int>>>>,std::allocator<std::pair<common_ngram_const,std::unordered_map<int,int,std::hash<int>,std::equal_to<int>,std::allocator<std::pair<int_const,int>>>>>,std::__detail::_Select1st,std::equal_to<common_ngram>,common_ngram_hash_function,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
*)param_1;
local_98 = param_2;
local_80 = param_3;
while( true ) {
uVar10 = uVar10 - 1;
if (((int)(uint)uVar10 < 0) || (iVar6 != -1)) break;
uVar7 = (ulong)((uint)uVar10 & 0x7fffffff);
puVar1 = (int8 *)(*(long *)local_98 + uVar7 * 0x10);
local_78 = *puVar1;
uStack_70 = puVar1[1];
lVar3 = std::
_Hashtable<common_ngram,std::pair<common_ngram_const,std::unordered_map<int,int,std::hash<int>,std::equal_to<int>,std::allocator<std::pair<int_const,int>>>>,std::allocator<std::pair<common_ngram_const,std::unordered_map<int,int,std::hash<int>,std::equal_to<int>,std::allocator<std::pair<int_const,int>>>>>,std::__detail::_Select1st,std::equal_to<common_ngram>,common_ngram_hash_function,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
::find(local_a0,(common_ngram *)&local_78);
iVar6 = -1;
if (lVar3 != 0) {
local_90 = uVar7;
local_88 = uVar10;
std::
_Hashtable<int,std::pair<int_const,int>,std::allocator<std::pair<int_const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
::_Hashtable(local_68,(_Hashtable *)(lVar3 + 0x18));
iVar8 = 0;
plVar5 = local_58;
iVar9 = -1;
iVar6 = 0;
iVar11 = 0;
while (plVar5 = (long *)*plVar5, plVar5 != (long *)0x0) {
local_b4 = *(int *)(plVar5 + 1);
iVar2 = *(int *)((long)plVar5 + 0xc);
/* try { // try from 00197fe6 to 00197ff4 has its CatchHandler @ 00198079 */
lVar3 = std::
_Hashtable<int,std::pair<int_const,int>,std::allocator<std::pair<int_const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
::find((_Hashtable<int,std::pair<int_const,int>,std::allocator<std::pair<int_const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
*)local_80,&local_b4);
iVar4 = 1;
if (lVar3 != 0) {
iVar4 = *(int *)(lVar3 + 0xc) * 100;
}
if (iVar11 * iVar6 < iVar4 * iVar2) {
iVar11 = iVar2;
iVar6 = iVar4;
iVar9 = local_b4;
}
iVar8 = iVar8 + iVar2;
}
iVar6 = -1;
if ((local_a8[local_90] <= iVar8) &&
(iVar6 = iVar9, iVar11 * 100 < iVar8 * local_b0[local_90])) {
iVar6 = -1;
}
std::
_Hashtable<int,std::pair<int_const,int>,std::allocator<std::pair<int_const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
::~_Hashtable(local_68);
uVar10 = local_88;
}
}
return iVar6;
}
|
|
981 | bf_op2 | bluesky950520[P]quickjs/libbf.c | static no_inline int bf_op2(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
bf_flags_t flags, bf_op2_func_t *func)
{
bf_t tmp;
int ret;
if (r == a || r == b) {
bf_init(r->ctx, &tmp);
ret = func(&tmp, a, b, prec, flags);
bf_move(r, &tmp);
} else {
ret = func(r, a, b, prec, flags);
}
return ret;
} | O1 | c | bf_op2:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
cmpq %rsi, %rdi
setne %al
cmpq %rdx, %rdi
setne %dil
testb %dil, %al
jne 0x87bc6
movq (%rbx), %rax
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movl $0x0, 0x8(%r14)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x10(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r14)
movq %r14, %rdi
callq *%r9
movl %eax, %ebp
cmpq %rbx, %r14
je 0x87bbb
movq 0x20(%rbx), %rsi
testq %rsi, %rsi
je 0x87ba1
movq (%rbx), %rax
movq (%rax), %rdi
xorl %edx, %edx
callq *0x8(%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rbx)
movups 0x8(%rsp), %xmm0
movups 0x18(%rsp), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmpq *%r9
| bf_op2:
push rbp
push r14
push rbx
sub rsp, 30h
mov rbx, rdi
cmp rdi, rsi
setnz al
cmp rdi, rdx
setnz dil
test al, dil
jnz short loc_87BC6
mov rax, [rbx]
lea r14, [rsp+48h+var_40]
mov [r14], rax
mov dword ptr [r14+8], 0
mov rax, 8000000000000000h
mov [r14+10h], rax
xorps xmm0, xmm0
movups xmmword ptr [r14+18h], xmm0
mov rdi, r14
call r9 ; __bf_sub
mov ebp, eax
cmp r14, rbx
jz short loc_87BBB
mov rsi, [rbx+20h]
test rsi, rsi
jz short loc_87BA1
mov rax, [rbx]
mov rdi, [rax]
xor edx, edx
call qword ptr [rax+8]
loc_87BA1:
mov rax, [rsp+48h+var_20]
mov [rbx+20h], rax
movups xmm0, [rsp+48h+var_40]
movups xmm1, [rsp+48h+var_30]
movups xmmword ptr [rbx+10h], xmm1
movups xmmword ptr [rbx], xmm0
loc_87BBB:
mov eax, ebp
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_87BC6:
mov rdi, rbx
add rsp, 30h
pop rbx
pop r14
pop rbp
jmp r9
| long long bf_op2(
__int128 *a1,
__int128 *a2,
__int128 *a3,
long long a4,
long long a5,
long long ( *a6)(__int128 *))
{
unsigned int v6; // ebp
long long v7; // rsi
__int128 v8; // xmm0
__int128 v10; // [rsp+8h] [rbp-40h] BYREF
_BYTE v11[24]; // [rsp+18h] [rbp-30h]
if ( a1 != a3 && a1 != a2 )
return a6(a1);
*(_QWORD *)&v10 = *(_QWORD *)a1;
DWORD2(v10) = 0;
*(_QWORD *)v11 = 0x8000000000000000LL;
*(_OWORD *)&v11[8] = 0LL;
v6 = a6(&v10);
if ( &v10 != a1 )
{
v7 = *((_QWORD *)a1 + 4);
if ( v7 )
(*(void ( **)(_QWORD, long long, _QWORD))(*(_QWORD *)a1 + 8LL))(**(_QWORD **)a1, v7, 0LL);
*((_QWORD *)a1 + 4) = *(_QWORD *)&v11[16];
v8 = v10;
a1[1] = *(_OWORD *)v11;
*a1 = v8;
}
return v6;
}
| bf_op2:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV RBX,RDI
CMP RDI,RSI
SETNZ AL
CMP RDI,RDX
SETNZ DIL
TEST AL,DIL
JNZ 0x00187bc6
MOV RAX,qword ptr [RBX]
LEA R14,[RSP + 0x8]
MOV qword ptr [R14],RAX
MOV dword ptr [R14 + 0x8],0x0
MOV RAX,-0x8000000000000000
MOV qword ptr [R14 + 0x10],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14 + 0x18],XMM0
MOV RDI,R14
CALL R9
MOV EBP,EAX
CMP R14,RBX
JZ 0x00187bbb
MOV RSI,qword ptr [RBX + 0x20]
TEST RSI,RSI
JZ 0x00187ba1
MOV RAX,qword ptr [RBX]
MOV RDI,qword ptr [RAX]
XOR EDX,EDX
CALL qword ptr [RAX + 0x8]
LAB_00187ba1:
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RBX + 0x20],RAX
MOVUPS XMM0,xmmword ptr [RSP + 0x8]
MOVUPS XMM1,xmmword ptr [RSP + 0x18]
MOVUPS xmmword ptr [RBX + 0x10],XMM1
MOVUPS xmmword ptr [RBX],XMM0
LAB_00187bbb:
MOV EAX,EBP
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_00187bc6:
MOV RDI,RBX
ADD RSP,0x30
POP RBX
POP R14
POP RBP
JMP R9
|
ulong bf_op2(long *param_1,long *param_2,long *param_3,int8 param_4,int8 param_5,
code *UNRECOVERED_JUMPTABLE)
{
uint uVar1;
ulong uVar2;
long local_40;
int4 uStack_38;
int4 uStack_34;
long local_30;
long lStack_28;
long lStack_20;
if (param_1 == param_2 || param_1 == param_3) {
local_40 = *param_1;
uStack_38 = 0;
local_30 = -0x8000000000000000;
lStack_28 = 0;
lStack_20 = 0;
uVar1 = (*UNRECOVERED_JUMPTABLE)(&local_40);
if (&local_40 != param_1) {
if (param_1[4] != 0) {
(*(code *)((int8 *)*param_1)[1])(*(int8 *)*param_1,param_1[4],0);
}
param_1[4] = lStack_20;
param_1[2] = local_30;
param_1[3] = lStack_28;
*param_1 = local_40;
param_1[1] = CONCAT44(uStack_34,uStack_38);
}
return (ulong)uVar1;
}
/* WARNING: Could not recover jumptable at 0x00187bd1. Too many branches */
/* WARNING: Treating indirect jump as call */
uVar2 = (*UNRECOVERED_JUMPTABLE)(param_1);
return uVar2;
}
|
|
982 | bf_op2 | bluesky950520[P]quickjs/libbf.c | static no_inline int bf_op2(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
bf_flags_t flags, bf_op2_func_t *func)
{
bf_t tmp;
int ret;
if (r == a || r == b) {
bf_init(r->ctx, &tmp);
ret = func(&tmp, a, b, prec, flags);
bf_move(r, &tmp);
} else {
ret = func(r, a, b, prec, flags);
}
return ret;
} | O2 | c | bf_op2:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
cmpq %rsi, %rdi
setne %al
cmpq %rdx, %rdi
setne %dil
testb %dil, %al
jne 0x71cd3
movq (%rbx), %rax
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
andl $0x0, 0x8(%r14)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x10(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r14)
movq %r14, %rdi
callq *%r9
movl %eax, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6f6c4
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmpq *%r9
| bf_op2:
push rbp
push r14
push rbx
sub rsp, 30h
mov rbx, rdi
cmp rdi, rsi
setnz al
cmp rdi, rdx
setnz dil
test al, dil
jnz short loc_71CD3
mov rax, [rbx]
lea r14, [rsp+48h+var_40]
mov [r14], rax
and dword ptr [r14+8], 0
mov rax, 8000000000000000h
mov [r14+10h], rax
xorps xmm0, xmm0
movups xmmword ptr [r14+18h], xmm0
mov rdi, r14
call r9 ; __bf_sub
mov ebp, eax
mov rdi, rbx
mov rsi, r14
call bf_move
mov eax, ebp
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_71CD3:
mov rdi, rbx
add rsp, 30h
pop rbx
pop r14
pop rbp
jmp r9
| long long bf_op2(
__int128 *a1,
__int128 *a2,
__int128 *a3,
long long a4,
long long a5,
long long ( *a6)(__int128 *))
{
unsigned int v6; // ebp
__int128 v8; // [rsp+8h] [rbp-40h] BYREF
unsigned long long v9; // [rsp+18h] [rbp-30h]
__int128 v10; // [rsp+20h] [rbp-28h]
if ( a1 != a3 && a1 != a2 )
return a6(a1);
*(_QWORD *)&v8 = *(_QWORD *)a1;
DWORD2(v8) = 0;
v9 = 0x8000000000000000LL;
v10 = 0LL;
v6 = a6(&v8);
bf_move(a1, &v8);
return v6;
}
| bf_op2:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV RBX,RDI
CMP RDI,RSI
SETNZ AL
CMP RDI,RDX
SETNZ DIL
TEST AL,DIL
JNZ 0x00171cd3
MOV RAX,qword ptr [RBX]
LEA R14,[RSP + 0x8]
MOV qword ptr [R14],RAX
AND dword ptr [R14 + 0x8],0x0
MOV RAX,-0x8000000000000000
MOV qword ptr [R14 + 0x10],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14 + 0x18],XMM0
MOV RDI,R14
CALL R9
MOV EBP,EAX
MOV RDI,RBX
MOV RSI,R14
CALL 0x0016f6c4
MOV EAX,EBP
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_00171cd3:
MOV RDI,RBX
ADD RSP,0x30
POP RBX
POP R14
POP RBP
JMP R9
|
ulong bf_op2(int8 *param_1,int8 *param_2,int8 *param_3,int8 param_4,
int8 param_5,code *UNRECOVERED_JUMPTABLE)
{
uint uVar1;
ulong uVar2;
int8 local_40;
int4 local_38;
int8 local_30;
int8 local_28;
int8 uStack_20;
if (param_1 == param_2 || param_1 == param_3) {
local_40 = *param_1;
local_38 = 0;
local_30 = 0x8000000000000000;
local_28 = 0;
uStack_20 = 0;
uVar1 = (*UNRECOVERED_JUMPTABLE)(&local_40);
bf_move(param_1,&local_40);
return (ulong)uVar1;
}
/* WARNING: Could not recover jumptable at 0x00171cde. Too many branches */
/* WARNING: Treating indirect jump as call */
uVar2 = (*UNRECOVERED_JUMPTABLE)(param_1);
return uVar2;
}
|
|
983 | evmone::baseline::CodeAnalysis::CodeAnalysis(std::basic_string_view<unsigned char, evmc::byte_traits<unsigned char>>, std::basic_string_view<unsigned char, evmc::byte_traits<unsigned char>>, evmone::EOF1Header) | corpus-core[P]colibri-stateless/build_O3/_deps/evmone_external-src/lib/evmone/baseline.hpp | CodeAnalysis(bytes_view container, bytes_view executable_code, EOF1Header header)
: m_raw_code{container}, m_executable_code(executable_code), m_eof_header{std::move(header)}
{} | O3 | cpp | evmone::baseline::CodeAnalysis::CodeAnalysis(std::basic_string_view<unsigned char, evmc::byte_traits<unsigned char>>, std::basic_string_view<unsigned char, evmc::byte_traits<unsigned char>>, evmone::EOF1Header):
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
movq %r8, 0x18(%rdi)
xorl %eax, %eax
movq %rax, 0x20(%rdi)
movl %eax, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movl %eax, 0x38(%rdi)
movq %rax, 0x40(%rdi)
movups (%r9), %xmm0
movups %xmm0, 0x48(%rdi)
movups 0x10(%r9), %xmm0
movups %xmm0, 0x58(%rdi)
movq 0x20(%r9), %rcx
movq %rcx, 0x68(%rdi)
movq %rax, 0x20(%r9)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r9)
movups 0x28(%r9), %xmm1
movups %xmm1, 0x70(%rdi)
movq 0x38(%r9), %rcx
movq %rcx, 0x80(%rdi)
movq %rax, 0x38(%r9)
movups %xmm0, 0x28(%r9)
movq 0x40(%r9), %rcx
movq %rcx, 0x88(%rdi)
movups 0x48(%r9), %xmm1
movups %xmm1, 0x90(%rdi)
movq 0x58(%r9), %rcx
movq %rcx, 0xa0(%rdi)
movq %rax, 0x58(%r9)
movups %xmm0, 0x48(%r9)
movups 0x60(%r9), %xmm1
movups %xmm1, 0xa8(%rdi)
movq 0x70(%r9), %rcx
movq %rcx, 0xb8(%rdi)
movq %rax, 0x70(%r9)
movups %xmm0, 0x60(%r9)
movq %rax, 0xc0(%rdi)
retq
| _ZN6evmone8baseline12CodeAnalysisC2ESt17basic_string_viewIhN4evmc11byte_traitsIhEEES6_NS_10EOF1HeaderE:
mov [rdi], rsi
mov [rdi+8], rdx
mov [rdi+10h], rcx
mov [rdi+18h], r8
xor eax, eax
mov [rdi+20h], rax
mov [rdi+28h], eax
mov [rdi+30h], rax
mov [rdi+38h], eax
mov [rdi+40h], rax
movups xmm0, xmmword ptr [r9]
movups xmmword ptr [rdi+48h], xmm0
movups xmm0, xmmword ptr [r9+10h]
movups xmmword ptr [rdi+58h], xmm0
mov rcx, [r9+20h]
mov [rdi+68h], rcx
mov [r9+20h], rax
xorps xmm0, xmm0
movups xmmword ptr [r9+10h], xmm0
movups xmm1, xmmword ptr [r9+28h]
movups xmmword ptr [rdi+70h], xmm1
mov rcx, [r9+38h]
mov [rdi+80h], rcx
mov [r9+38h], rax
movups xmmword ptr [r9+28h], xmm0
mov rcx, [r9+40h]
mov [rdi+88h], rcx
movups xmm1, xmmword ptr [r9+48h]
movups xmmword ptr [rdi+90h], xmm1
mov rcx, [r9+58h]
mov [rdi+0A0h], rcx
mov [r9+58h], rax
movups xmmword ptr [r9+48h], xmm0
movups xmm1, xmmword ptr [r9+60h]
movups xmmword ptr [rdi+0A8h], xmm1
mov rcx, [r9+70h]
mov [rdi+0B8h], rcx
mov [r9+70h], rax
movups xmmword ptr [r9+60h], xmm0
mov [rdi+0C0h], rax
retn
| long long evmone::baseline::CodeAnalysis::CodeAnalysis(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6)
{
long long result; // rax
*(_QWORD *)a1 = a2;
*(_QWORD *)(a1 + 8) = a3;
*(_QWORD *)(a1 + 16) = a4;
*(_QWORD *)(a1 + 24) = a5;
result = 0LL;
*(_QWORD *)(a1 + 32) = 0LL;
*(_DWORD *)(a1 + 40) = 0;
*(_QWORD *)(a1 + 48) = 0LL;
*(_DWORD *)(a1 + 56) = 0;
*(_QWORD *)(a1 + 64) = 0LL;
*(_OWORD *)(a1 + 72) = *(_OWORD *)a6;
*(_OWORD *)(a1 + 88) = *(_OWORD *)(a6 + 16);
*(_QWORD *)(a1 + 104) = *(_QWORD *)(a6 + 32);
*(_QWORD *)(a6 + 32) = 0LL;
*(_OWORD *)(a6 + 16) = 0LL;
*(_OWORD *)(a1 + 112) = *(_OWORD *)(a6 + 40);
*(_QWORD *)(a1 + 128) = *(_QWORD *)(a6 + 56);
*(_QWORD *)(a6 + 56) = 0LL;
*(_OWORD *)(a6 + 40) = 0LL;
*(_QWORD *)(a1 + 136) = *(_QWORD *)(a6 + 64);
*(_OWORD *)(a1 + 144) = *(_OWORD *)(a6 + 72);
*(_QWORD *)(a1 + 160) = *(_QWORD *)(a6 + 88);
*(_QWORD *)(a6 + 88) = 0LL;
*(_OWORD *)(a6 + 72) = 0LL;
*(_OWORD *)(a1 + 168) = *(_OWORD *)(a6 + 96);
*(_QWORD *)(a1 + 184) = *(_QWORD *)(a6 + 112);
*(_QWORD *)(a6 + 112) = 0LL;
*(_OWORD *)(a6 + 96) = 0LL;
*(_QWORD *)(a1 + 192) = 0LL;
return result;
}
| CodeAnalysis:
MOV qword ptr [RDI],RSI
MOV qword ptr [RDI + 0x8],RDX
MOV qword ptr [RDI + 0x10],RCX
MOV qword ptr [RDI + 0x18],R8
XOR EAX,EAX
MOV qword ptr [RDI + 0x20],RAX
MOV dword ptr [RDI + 0x28],EAX
MOV qword ptr [RDI + 0x30],RAX
MOV dword ptr [RDI + 0x38],EAX
MOV qword ptr [RDI + 0x40],RAX
MOVUPS XMM0,xmmword ptr [R9]
MOVUPS xmmword ptr [RDI + 0x48],XMM0
MOVUPS XMM0,xmmword ptr [R9 + 0x10]
MOVUPS xmmword ptr [RDI + 0x58],XMM0
MOV RCX,qword ptr [R9 + 0x20]
MOV qword ptr [RDI + 0x68],RCX
MOV qword ptr [R9 + 0x20],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R9 + 0x10],XMM0
MOVUPS XMM1,xmmword ptr [R9 + 0x28]
MOVUPS xmmword ptr [RDI + 0x70],XMM1
MOV RCX,qword ptr [R9 + 0x38]
MOV qword ptr [RDI + 0x80],RCX
MOV qword ptr [R9 + 0x38],RAX
MOVUPS xmmword ptr [R9 + 0x28],XMM0
MOV RCX,qword ptr [R9 + 0x40]
MOV qword ptr [RDI + 0x88],RCX
MOVUPS XMM1,xmmword ptr [R9 + 0x48]
MOVUPS xmmword ptr [RDI + 0x90],XMM1
MOV RCX,qword ptr [R9 + 0x58]
MOV qword ptr [RDI + 0xa0],RCX
MOV qword ptr [R9 + 0x58],RAX
MOVUPS xmmword ptr [R9 + 0x48],XMM0
MOVUPS XMM1,xmmword ptr [R9 + 0x60]
MOVUPS xmmword ptr [RDI + 0xa8],XMM1
MOV RCX,qword ptr [R9 + 0x70]
MOV qword ptr [RDI + 0xb8],RCX
MOV qword ptr [R9 + 0x70],RAX
MOVUPS xmmword ptr [R9 + 0x60],XMM0
MOV qword ptr [RDI + 0xc0],RAX
RET
|
/* evmone::baseline::CodeAnalysis::CodeAnalysis(std::basic_string_view<unsigned char,
evmc::byte_traits<unsigned char> >, std::basic_string_view<unsigned char,
evmc::byte_traits<unsigned char> >, evmone::EOF1Header) */
void __thiscall
evmone::baseline::CodeAnalysis::CodeAnalysis
(CodeAnalysis *this,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 *param_6)
{
int8 uVar1;
*(int8 *)this = param_2;
*(int8 *)(this + 8) = param_3;
*(int8 *)(this + 0x10) = param_4;
*(int8 *)(this + 0x18) = param_5;
*(int8 *)(this + 0x20) = 0;
*(int4 *)(this + 0x28) = 0;
*(int8 *)(this + 0x30) = 0;
*(int4 *)(this + 0x38) = 0;
*(int8 *)(this + 0x40) = 0;
uVar1 = param_6[1];
*(int8 *)(this + 0x48) = *param_6;
*(int8 *)(this + 0x50) = uVar1;
uVar1 = param_6[3];
*(int8 *)(this + 0x58) = param_6[2];
*(int8 *)(this + 0x60) = uVar1;
*(int8 *)(this + 0x68) = param_6[4];
param_6[4] = 0;
param_6[2] = 0;
param_6[3] = 0;
uVar1 = param_6[6];
*(int8 *)(this + 0x70) = param_6[5];
*(int8 *)(this + 0x78) = uVar1;
*(int8 *)(this + 0x80) = param_6[7];
param_6[7] = 0;
param_6[5] = 0;
param_6[6] = 0;
*(int8 *)(this + 0x88) = param_6[8];
uVar1 = param_6[10];
*(int8 *)(this + 0x90) = param_6[9];
*(int8 *)(this + 0x98) = uVar1;
*(int8 *)(this + 0xa0) = param_6[0xb];
param_6[0xb] = 0;
param_6[9] = 0;
param_6[10] = 0;
uVar1 = param_6[0xd];
*(int8 *)(this + 0xa8) = param_6[0xc];
*(int8 *)(this + 0xb0) = uVar1;
*(int8 *)(this + 0xb8) = param_6[0xe];
param_6[0xe] = 0;
param_6[0xc] = 0;
param_6[0xd] = 0;
*(int8 *)(this + 0xc0) = 0;
return;
}
|
|
984 | js_symbol_toString | bluesky950520[P]quickjs/quickjs.c | static JSValue js_symbol_toString(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue val, ret;
val = js_thisSymbolValue(ctx, this_val);
if (JS_IsException(val))
return val;
/* XXX: use JS_ToStringInternal() with a flags */
ret = js_string_constructor(ctx, JS_UNDEFINED, 1, &val);
JS_FreeValue(ctx, val);
return ret;
} | O2 | c | js_symbol_toString:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r15
callq 0x6e05b
movq %rax, %rbx
movq %rdx, %r14
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
cmpl $0x6, %r14d
je 0x6dfc7
pushq $0x3
popq %rdx
pushq $0x1
popq %rcx
movq %rsp, %r8
movq %r15, %rdi
xorl %esi, %esi
callq 0x35763
movq %rax, %r12
movq %rdx, %r13
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1bbce
movq %r12, %rbx
movq %r13, %r14
movq %rbx, %rax
movq %r14, %rdx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| js_symbol_toString:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 10h
mov r15, rdi
call js_thisSymbolValue
mov rbx, rax
mov r14, rdx
mov [rsp+38h+var_38], rax
mov [rsp+38h+var_30], rdx
cmp r14d, 6
jz short loc_6DFC7
push 3
pop rdx
push 1
pop rcx
mov r8, rsp
mov rdi, r15
xor esi, esi
call js_string_constructor
mov r12, rax
mov r13, rdx
mov rdi, r15
mov rsi, rbx
mov rdx, r14
call JS_FreeValue
mov rbx, r12
mov r14, r13
loc_6DFC7:
mov rax, rbx
mov rdx, r14
add rsp, 10h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
| long long js_symbol_toString(
long long a1,
__m128 a2,
__m128 a3,
__m128 a4,
__m128 a5,
double a6,
double a7,
__m128 a8,
__m128 a9)
{
long long v9; // rbx
double v10; // xmm4_8
double v11; // xmm5_8
long long v12; // rdx
long long v13; // r14
long long v14; // r12
long long v16[7]; // [rsp+0h] [rbp-38h] BYREF
v9 = js_thisSymbolValue();
v13 = v12;
v16[0] = v9;
v16[1] = v12;
if ( (_DWORD)v12 != 6 )
{
v14 = js_string_constructor(a1, 0LL, 3LL, 1, v16, a2, a3, a4, a5, v10, v11, a8, a9);
JS_FreeValue(a1, v9, v13);
return v14;
}
return v9;
}
| js_symbol_toString:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV R15,RDI
CALL 0x0016e05b
MOV RBX,RAX
MOV R14,RDX
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x8],RDX
CMP R14D,0x6
JZ 0x0016dfc7
PUSH 0x3
POP RDX
PUSH 0x1
POP RCX
MOV R8,RSP
MOV RDI,R15
XOR ESI,ESI
CALL 0x00135763
MOV R12,RAX
MOV R13,RDX
MOV RDI,R15
MOV RSI,RBX
MOV RDX,R14
CALL 0x0011bbce
MOV RBX,R12
MOV R14,R13
LAB_0016dfc7:
MOV RAX,RBX
MOV RDX,R14
ADD RSP,0x10
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
int1 [16] js_symbol_toString(int8 param_1)
{
int8 uVar1;
int8 uVar2;
int1 auVar3 [16];
int1 local_38 [16];
auVar3 = js_thisSymbolValue();
uVar2 = auVar3._8_8_;
uVar1 = auVar3._0_8_;
if (auVar3._8_4_ != 6) {
local_38 = auVar3;
auVar3 = js_string_constructor(param_1,0,3,1,local_38);
JS_FreeValue(param_1,uVar1,uVar2);
}
return auVar3;
}
|
|
985 | ggml_soft_max_back | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c | struct ggml_tensor * ggml_soft_max_back(
struct ggml_context * ctx,
struct ggml_tensor * a,
struct ggml_tensor * b) {
return ggml_soft_max_back_impl(ctx, a, b, false);
} | O1 | c | ggml_soft_max_back:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl (%rsi), %esi
leaq 0x10(%r14), %rcx
movl $0x4, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x1b871
movl $0x2b, 0x50(%rax)
movq %r14, 0x98(%rax)
movq %rbx, 0xa0(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| ggml_soft_max_back:
push r14
push rbx
push rax
mov rbx, rdx
mov r14, rsi
mov esi, [rsi]
lea rcx, [r14+10h]
mov edx, 4
xor r8d, r8d
xor r9d, r9d
call ggml_new_tensor_impl
mov dword ptr [rax+50h], 2Bh ; '+'
mov [rax+98h], r14
mov [rax+0A0h], rbx
add rsp, 8
pop rbx
pop r14
retn
| long long ggml_soft_max_back(long long a1, long long a2, long long a3, double a4)
{
long long result; // rax
result = ggml_new_tensor_impl(a1, *(_DWORD *)a2, 4, (long long *)(a2 + 16), 0LL, 0LL, a4);
*(_DWORD *)(result + 80) = 43;
*(_QWORD *)(result + 152) = a2;
*(_QWORD *)(result + 160) = a3;
return result;
}
| ggml_soft_max_back:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R14,RSI
MOV ESI,dword ptr [RSI]
LEA RCX,[R14 + 0x10]
MOV EDX,0x4
XOR R8D,R8D
XOR R9D,R9D
CALL 0x0011b871
MOV dword ptr [RAX + 0x50],0x2b
MOV qword ptr [RAX + 0x98],R14
MOV qword ptr [RAX + 0xa0],RBX
ADD RSP,0x8
POP RBX
POP R14
RET
|
void ggml_soft_max_back(int8 param_1,int4 *param_2,int8 param_3)
{
long lVar1;
lVar1 = ggml_new_tensor_impl(param_1,*param_2,4,param_2 + 4,0,0);
*(int4 *)(lVar1 + 0x50) = 0x2b;
*(int4 **)(lVar1 + 0x98) = param_2;
*(int8 *)(lVar1 + 0xa0) = param_3;
return;
}
|
|
986 | ggml_soft_max_back | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c | struct ggml_tensor * ggml_soft_max_back(
struct ggml_context * ctx,
struct ggml_tensor * a,
struct ggml_tensor * b) {
return ggml_soft_max_back_impl(ctx, a, b, false);
} | O3 | c | ggml_soft_max_back:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl (%rsi), %esi
leaq 0x10(%r14), %rcx
movl $0x4, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x1a57f
movl $0x2b, 0x50(%rax)
movq %r14, 0x98(%rax)
movq %rbx, 0xa0(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| ggml_soft_max_back:
push r14
push rbx
push rax
mov rbx, rdx
mov r14, rsi
mov esi, [rsi]
lea rcx, [r14+10h]
mov edx, 4
xor r8d, r8d
xor r9d, r9d
call ggml_new_tensor_impl
mov dword ptr [rax+50h], 2Bh ; '+'
mov [rax+98h], r14
mov [rax+0A0h], rbx
add rsp, 8
pop rbx
pop r14
retn
| long long ggml_soft_max_back(long long a1, long long a2, long long a3, double a4)
{
long long result; // rax
result = ggml_new_tensor_impl(a1, *(_DWORD *)a2, 4u, (long long *)(a2 + 16), 0LL, 0LL, a4);
*(_DWORD *)(result + 80) = 43;
*(_QWORD *)(result + 152) = a2;
*(_QWORD *)(result + 160) = a3;
return result;
}
| ggml_soft_max_back:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R14,RSI
MOV ESI,dword ptr [RSI]
LEA RCX,[R14 + 0x10]
MOV EDX,0x4
XOR R8D,R8D
XOR R9D,R9D
CALL 0x0011a57f
MOV dword ptr [RAX + 0x50],0x2b
MOV qword ptr [RAX + 0x98],R14
MOV qword ptr [RAX + 0xa0],RBX
ADD RSP,0x8
POP RBX
POP R14
RET
|
void ggml_soft_max_back(int8 param_1,int4 *param_2,int8 param_3)
{
long lVar1;
lVar1 = ggml_new_tensor_impl(param_1,*param_2,4,param_2 + 4,0,0);
*(int4 *)(lVar1 + 0x50) = 0x2b;
*(int4 **)(lVar1 + 0x98) = param_2;
*(int8 *)(lVar1 + 0xa0) = param_3;
return;
}
|
|
987 | my_create | eloqsql/mysys/my_create.c | File my_create(const char *FileName, int CreateFlags, int access_flags,
myf MyFlags)
{
int fd;
DBUG_ENTER("my_create");
DBUG_PRINT("my",("Name: '%s' CreateFlags: %d AccessFlags: %d MyFlags: %lu",
FileName, CreateFlags, access_flags, MyFlags));
#if defined(_WIN32)
fd= my_win_open(FileName, access_flags | O_CREAT);
#else
fd= open((char *) FileName, access_flags | O_CREAT | O_CLOEXEC,
CreateFlags ? CreateFlags : my_umask);
#endif
if ((MyFlags & MY_SYNC_DIR) && (fd >=0) &&
my_sync_dir_by_file(FileName, MyFlags))
{
my_close(fd, MyFlags);
fd= -1;
}
fd= my_register_filename(fd, FileName, FILE_BY_CREATE,
EE_CANTCREATEFILE, MyFlags);
DBUG_RETURN(fd);
} | O0 | c | my_create:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
jmp 0xb6268
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x10(%rbp), %eax
orl $0x40, %eax
orl $0x80000, %eax # imm = 0x80000
movl %eax, -0x20(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0xb628c
movl -0xc(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0xb6298
leaq 0x1d2b15(%rip), %rax # 0x288da8
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x20(%rbp), %esi
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %edx
movb $0x0, %al
callq 0x27b90
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
andq $0x8000, %rax # imm = 0x8000
cmpq $0x0, %rax
je 0xb62e7
cmpl $0x0, -0x1c(%rbp)
jl 0xb62e7
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xc0a20
cmpl $0x0, %eax
je 0xb62e7
movl -0x1c(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0xbf1c0
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl -0x1c(%rbp), %edi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %r8
movl $0x2, %edx
movl $0x1, %ecx
callq 0xbf060
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| my_create:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_10], edx
mov [rbp+var_18], rcx
jmp short $+2
loc_B6268:
mov rax, [rbp+var_8]
mov [rbp+var_28], rax
mov eax, [rbp+var_10]
or eax, 40h
or eax, 80000h
mov [rbp+var_20], eax
cmp [rbp+var_C], 0
jz short loc_B628C
mov eax, [rbp+var_C]
mov [rbp+var_2C], eax
jmp short loc_B6298
loc_B628C:
lea rax, my_umask
mov eax, [rax]
mov [rbp+var_2C], eax
loc_B6298:
mov esi, [rbp+var_20]
mov rdi, [rbp+var_28]
mov edx, [rbp+var_2C]
mov al, 0
call _open64
mov [rbp+var_1C], eax
mov rax, [rbp+var_18]
and rax, 8000h
cmp rax, 0
jz short loc_B62E7
cmp [rbp+var_1C], 0
jl short loc_B62E7
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_18]
call my_sync_dir_by_file
cmp eax, 0
jz short loc_B62E7
mov edi, [rbp+var_1C]
mov rsi, [rbp+var_18]
call my_close
mov [rbp+var_1C], 0FFFFFFFFh
loc_B62E7:
mov edi, [rbp+var_1C]
mov rsi, [rbp+var_8]
mov r8, [rbp+var_18]
mov edx, 2
mov ecx, 1
call my_register_filename
mov [rbp+var_1C], eax
mov eax, [rbp+var_1C]
mov [rbp+var_30], eax
mov eax, [rbp+var_30]
add rsp, 30h
pop rbp
retn
| long long my_create(long long a1, unsigned int a2, int a3, long long a4)
{
unsigned int v5; // [rsp+4h] [rbp-2Ch]
int v6; // [rsp+14h] [rbp-1Ch]
if ( a2 )
v5 = a2;
else
v5 = my_umask;
v6 = open64(a1, a3 | 0x80040u, v5);
if ( (a4 & 0x8000) != 0 && v6 >= 0 && (unsigned int)my_sync_dir_by_file(a1, a4) )
{
my_close((unsigned int)v6, a4);
v6 = -1;
}
return (unsigned int)my_register_filename((unsigned int)v6, a1, 2LL, 1LL, a4);
}
| my_create:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV dword ptr [RBP + -0x10],EDX
MOV qword ptr [RBP + -0x18],RCX
JMP 0x001b6268
LAB_001b6268:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x28],RAX
MOV EAX,dword ptr [RBP + -0x10]
OR EAX,0x40
OR EAX,0x80000
MOV dword ptr [RBP + -0x20],EAX
CMP dword ptr [RBP + -0xc],0x0
JZ 0x001b628c
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x001b6298
LAB_001b628c:
LEA RAX,[0x388da8]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x2c],EAX
LAB_001b6298:
MOV ESI,dword ptr [RBP + -0x20]
MOV RDI,qword ptr [RBP + -0x28]
MOV EDX,dword ptr [RBP + -0x2c]
MOV AL,0x0
CALL 0x00127b90
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x8000
CMP RAX,0x0
JZ 0x001b62e7
CMP dword ptr [RBP + -0x1c],0x0
JL 0x001b62e7
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x001c0a20
CMP EAX,0x0
JZ 0x001b62e7
MOV EDI,dword ptr [RBP + -0x1c]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x001bf1c0
MOV dword ptr [RBP + -0x1c],0xffffffff
LAB_001b62e7:
MOV EDI,dword ptr [RBP + -0x1c]
MOV RSI,qword ptr [RBP + -0x8]
MOV R8,qword ptr [RBP + -0x18]
MOV EDX,0x2
MOV ECX,0x1
CALL 0x001bf060
MOV dword ptr [RBP + -0x1c],EAX
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x30],EAX
MOV EAX,dword ptr [RBP + -0x30]
ADD RSP,0x30
POP RBP
RET
|
int4 my_create(char *param_1,uint param_2,uint param_3,ulong param_4)
{
int iVar1;
int4 uVar2;
uint local_34;
int local_24;
local_34 = param_2;
if (param_2 == 0) {
local_34 = my_umask;
}
local_24 = open64(param_1,param_3 | 0x80040,(ulong)local_34);
if ((((param_4 & 0x8000) != 0) && (-1 < local_24)) &&
(iVar1 = my_sync_dir_by_file(param_1,param_4), iVar1 != 0)) {
my_close(local_24,param_4);
local_24 = -1;
}
uVar2 = my_register_filename(local_24,param_1,2,1,param_4);
return uVar2;
}
|
|
988 | pick_next | eloqsql/storage/maria/ma_rt_split.c | static void pick_next(SplitStruct *node, int n_entries, double *g1, double *g2,
SplitStruct **choice, int *n_group, int n_dim)
{
SplitStruct *cur= node;
SplitStruct *end= node + n_entries;
double max_diff= -DBL_MAX;
for (; cur < end; cur++)
{
double diff;
double abs_diff;
if (cur->n_node)
{
continue;
}
diff= mbr_join_square(g1, cur->coords, n_dim) -
mbr_join_square(g2, cur->coords, n_dim);
abs_diff= fabs(diff);
if (abs_diff > max_diff)
{
max_diff= abs_diff;
*n_group= 1 + (diff > 0);
*choice= cur;
}
}
} | O0 | c | pick_next:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movsd 0xbcedb(%rip), %xmm0 # 0x158c80
movsd %xmm0, -0x48(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x9be6b
movq -0x38(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x9bdc7
jmp 0x9be5a
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rsi
movl 0x10(%rbp), %edx
callq 0x9bf20
movsd %xmm0, -0x60(%rbp)
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rsi
movl 0x10(%rbp), %edx
callq 0x9bf20
movaps %xmm0, %xmm1
movsd -0x60(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x50(%rbp), %xmm0
movaps 0xbd29f(%rip), %xmm1 # 0x1590b0
pand %xmm1, %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x58(%rbp), %xmm0
ucomisd -0x48(%rbp), %xmm0
jbe 0x9be58
movsd -0x58(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x50(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movzbl %al, %ecx
addl $0x1, %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x9be5a
movq -0x38(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x38(%rbp)
jmp 0x9bdaa
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| pick_next:
push rbp
mov rbp, rsp
sub rsp, 60h
mov eax, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov rax, [rbp+var_8]
mov [rbp+var_38], rax
mov rax, [rbp+var_8]
movsxd rcx, [rbp+var_C]
shl rcx, 5
add rax, rcx
mov [rbp+var_40], rax
movsd xmm0, cs:qword_158C80
movsd [rbp+var_48], xmm0
loc_9BDAA:
mov rax, [rbp+var_38]
cmp rax, [rbp+var_40]
jnb loc_9BE6B
mov rax, [rbp+var_38]
cmp dword ptr [rax+8], 0
jz short loc_9BDC7
jmp loc_9BE5A
loc_9BDC7:
mov rdi, [rbp+var_18]
mov rax, [rbp+var_38]
mov rsi, [rax+18h]
mov edx, [rbp+arg_0]
call mbr_join_square
movsd [rbp+var_60], xmm0
mov rdi, [rbp+var_20]
mov rax, [rbp+var_38]
mov rsi, [rax+18h]
mov edx, [rbp+arg_0]
call mbr_join_square
movaps xmm1, xmm0
movsd xmm0, [rbp+var_60]
subsd xmm0, xmm1
movsd [rbp+var_50], xmm0
movsd xmm0, [rbp+var_50]
movaps xmm1, cs:xmmword_1590B0
pand xmm0, xmm1
movsd [rbp+var_58], xmm0
movsd xmm0, [rbp+var_58]
ucomisd xmm0, [rbp+var_48]
jbe short loc_9BE58
movsd xmm0, [rbp+var_58]
movsd [rbp+var_48], xmm0
movsd xmm0, [rbp+var_50]
xorps xmm1, xmm1
ucomisd xmm0, xmm1
setnbe al
and al, 1
movzx ecx, al
add ecx, 1
mov rax, [rbp+var_30]
mov [rax], ecx
mov rcx, [rbp+var_38]
mov rax, [rbp+var_28]
mov [rax], rcx
loc_9BE58:
jmp short $+2
loc_9BE5A:
mov rax, [rbp+var_38]
add rax, 20h ; ' '
mov [rbp+var_38], rax
jmp loc_9BDAA
loc_9BE6B:
add rsp, 60h
pop rbp
retn
| unsigned long long pick_next(
unsigned long long a1,
int a2,
long long a3,
long long a4,
unsigned long long *a5,
_DWORD *a6,
unsigned int a7)
{
unsigned long long result; // rax
double v8; // [rsp+0h] [rbp-60h]
double v9; // [rsp+8h] [rbp-58h]
double v10; // [rsp+10h] [rbp-50h]
double v11; // [rsp+18h] [rbp-48h]
unsigned long long v12; // [rsp+28h] [rbp-38h]
v12 = a1;
v11 = -1.797693134862316e308;
while ( 1 )
{
result = v12;
if ( v12 >= 32LL * a2 + a1 )
break;
if ( !*(_DWORD *)(v12 + 8) )
{
v8 = mbr_join_square(a3, *(_QWORD *)(v12 + 24), a7);
v10 = v8 - mbr_join_square(a4, *(_QWORD *)(v12 + 24), a7);
v9 = *(double *)_mm_and_si128((__m128i)*(unsigned long long *)&v10, (__m128i)xmmword_1590B0).m128i_i64;
if ( v9 > v11 )
{
v11 = v9;
*a6 = (v10 > 0.0) + 1;
*a5 = v12;
}
}
v12 += 32LL;
}
return result;
}
| pick_next:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV EAX,dword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RBP + -0xc]
SHL RCX,0x5
ADD RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
MOVSD XMM0,qword ptr [0x00258c80]
MOVSD qword ptr [RBP + -0x48],XMM0
LAB_0019bdaa:
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RBP + -0x40]
JNC 0x0019be6b
MOV RAX,qword ptr [RBP + -0x38]
CMP dword ptr [RAX + 0x8],0x0
JZ 0x0019bdc7
JMP 0x0019be5a
LAB_0019bdc7:
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RAX + 0x18]
MOV EDX,dword ptr [RBP + 0x10]
CALL 0x0019bf20
MOVSD qword ptr [RBP + -0x60],XMM0
MOV RDI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RAX + 0x18]
MOV EDX,dword ptr [RBP + 0x10]
CALL 0x0019bf20
MOVAPS XMM1,XMM0
MOVSD XMM0,qword ptr [RBP + -0x60]
SUBSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x50],XMM0
MOVSD XMM0,qword ptr [RBP + -0x50]
MOVAPS XMM1,xmmword ptr [0x002590b0]
PAND XMM0,XMM1
MOVSD qword ptr [RBP + -0x58],XMM0
MOVSD XMM0,qword ptr [RBP + -0x58]
UCOMISD XMM0,qword ptr [RBP + -0x48]
JBE 0x0019be58
MOVSD XMM0,qword ptr [RBP + -0x58]
MOVSD qword ptr [RBP + -0x48],XMM0
MOVSD XMM0,qword ptr [RBP + -0x50]
XORPS XMM1,XMM1
UCOMISD XMM0,XMM1
SETA AL
AND AL,0x1
MOVZX ECX,AL
ADD ECX,0x1
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],ECX
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
LAB_0019be58:
JMP 0x0019be5a
LAB_0019be5a:
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x20
MOV qword ptr [RBP + -0x38],RAX
JMP 0x0019bdaa
LAB_0019be6b:
ADD RSP,0x60
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void pick_next(ulong param_1,int param_2,int8 param_3,int8 param_4,ulong *param_5,
int *param_6,int4 param_7)
{
double dVar1;
double dVar2;
int4 local_58;
int4 uStack_54;
int8 local_50;
int8 local_40;
local_50 = DAT_00258c80;
for (local_40 = param_1; local_40 < param_1 + (long)param_2 * 0x20; local_40 = local_40 + 0x20) {
if (*(int *)(local_40 + 8) == 0) {
dVar1 = (double)mbr_join_square(param_3,*(int8 *)(local_40 + 0x18),param_7);
dVar2 = (double)mbr_join_square(param_4,*(int8 *)(local_40 + 0x18),param_7);
dVar1 = dVar1 - dVar2;
local_58 = SUB84(dVar1,0);
uStack_54 = (uint)((ulong)dVar1 >> 0x20);
if (local_50 < (double)CONCAT44(uStack_54 & _UNK_002590b4,local_58 & _DAT_002590b0)) {
local_50 = (double)CONCAT44(uStack_54 & _UNK_002590b4,local_58 & _DAT_002590b0);
*param_6 = (0.0 < dVar1) + 1;
*param_5 = local_40;
}
}
}
return;
}
|
|
989 | my_once_alloc | eloqsql/mysys/my_once.c | void* my_once_alloc(size_t Size, myf MyFlags)
{
size_t get_size, max_left;
uchar* point;
reg1 USED_MEM *next;
reg2 USED_MEM **prev;
Size= ALIGN_SIZE(Size);
prev= &my_once_root_block;
max_left=0;
for (next=my_once_root_block ; next && next->left < Size ; next= next->next)
{
if (next->left > max_left)
max_left=next->left;
prev= &next->next;
}
if (! next)
{ /* Time to alloc new block */
get_size= Size+ALIGN_SIZE(sizeof(USED_MEM));
if (max_left*4 < my_once_extra && get_size < my_once_extra)
get_size=my_once_extra; /* Normal alloc */
if ((next = (USED_MEM*) malloc(get_size)) == 0)
{
my_errno=errno;
if (MyFlags & (MY_FAE+MY_WME))
my_error(EE_OUTOFMEMORY, MYF(ME_BELL+ME_FATAL), get_size);
return((uchar*) 0);
}
DBUG_PRINT("test",("my_once_malloc %lu byte malloced", (ulong) get_size));
next->next= 0;
next->size= get_size;
next->left= get_size-ALIGN_SIZE(sizeof(USED_MEM));
*prev=next;
}
point= (uchar*) ((char*) next+ (next->size-next->left));
next->left-= Size;
if (MyFlags & MY_ZEROFILL)
bzero(point, Size);
return((void*) point);
} | O0 | c | my_once_alloc:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
subq $0x1, %rax
andq $-0x8, %rax
movq %rax, -0x10(%rbp)
leaq 0xb91f05(%rip), %rax # 0xc8e670
movq %rax, -0x40(%rbp)
movq $0x0, -0x28(%rbp)
leaq 0xb91ef2(%rip), %rax # 0xc8e670
movq (%rax), %rax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x38(%rbp)
movb %al, -0x41(%rbp)
je 0xfc7a3
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
setb %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0xfc7ac
jmp 0xfc7db
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x28(%rbp), %rax
jbe 0xfc7c6
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0xfc785
cmpq $0x0, -0x38(%rbp)
jne 0xfc8b4
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
shlq $0x2, %rax
leaq 0x1ce7af(%rip), %rcx # 0x2cafb0
movl (%rcx), %ecx
cmpq %rcx, %rax
jae 0xfc827
movq -0x20(%rbp), %rax
leaq 0x1ce79d(%rip), %rcx # 0x2cafb0
movl (%rcx), %ecx
cmpq %rcx, %rax
jae 0xfc827
leaq 0x1ce78f(%rip), %rax # 0x2cafb0
movl (%rax), %eax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2a740
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0xfc87e
callq 0x2a7d0
movl (%rax), %eax
movl %eax, -0x48(%rbp)
callq 0xfe880
movl -0x48(%rbp), %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
andq $0x18, %rax
cmpq $0x0, %rax
je 0xfc871
movq -0x20(%rbp), %rdx
movl $0x5, %edi
movl $0x1004, %esi # imm = 0x1004
movb $0x0, %al
callq 0xf3f50
movq $0x0, -0x8(%rbp)
jmp 0xfc907
jmp 0xfc880
jmp 0xfc882
movq -0x38(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
subq $0x18, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movq -0x38(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x38(%rbp), %rdx
subq 0x8(%rdx), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdx
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
andq $0x20, %rax
cmpq $0x0, %rax
je 0xfc8ff
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rdx
xorl %esi, %esi
callq 0x2a2c0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_once_alloc:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
add rax, 8
sub rax, 1
and rax, 0FFFFFFFFFFFFFFF8h
mov [rbp+var_10], rax
lea rax, my_once_root_block
mov [rbp+var_40], rax
mov [rbp+var_28], 0
lea rax, my_once_root_block
mov rax, [rax]
mov [rbp+var_38], rax
loc_FC785:
xor eax, eax
cmp [rbp+var_38], 0
mov [rbp+var_41], al
jz short loc_FC7A3
mov rax, [rbp+var_38]
mov rax, [rax+8]
cmp rax, [rbp+var_10]
setb al
mov [rbp+var_41], al
loc_FC7A3:
mov al, [rbp+var_41]
test al, 1
jnz short loc_FC7AC
jmp short loc_FC7DB
loc_FC7AC:
mov rax, [rbp+var_38]
mov rax, [rax+8]
cmp rax, [rbp+var_28]
jbe short loc_FC7C6
mov rax, [rbp+var_38]
mov rax, [rax+8]
mov [rbp+var_28], rax
loc_FC7C6:
mov rax, [rbp+var_38]
mov [rbp+var_40], rax
mov rax, [rbp+var_38]
mov rax, [rax]
mov [rbp+var_38], rax
jmp short loc_FC785
loc_FC7DB:
cmp [rbp+var_38], 0
jnz loc_FC8B4
mov rax, [rbp+var_10]
add rax, 18h
mov [rbp+var_20], rax
mov rax, [rbp+var_28]
shl rax, 2
lea rcx, my_once_extra
mov ecx, [rcx]
cmp rax, rcx
jnb short loc_FC827
mov rax, [rbp+var_20]
lea rcx, my_once_extra
mov ecx, [rcx]
cmp rax, rcx
jnb short loc_FC827
lea rax, my_once_extra
mov eax, [rax]
mov [rbp+var_20], rax
loc_FC827:
mov rdi, [rbp+var_20]
call _malloc
mov [rbp+var_38], rax
cmp rax, 0
jnz short loc_FC87E
call ___errno_location
mov eax, [rax]
mov [rbp+var_48], eax
call _my_thread_var
mov ecx, [rbp+var_48]
mov [rax], ecx
mov rax, [rbp+var_18]
and rax, 18h
cmp rax, 0
jz short loc_FC871
mov rdx, [rbp+var_20]
mov edi, 5
mov esi, 1004h
mov al, 0
call my_error
loc_FC871:
mov [rbp+var_8], 0
jmp loc_FC907
loc_FC87E:
jmp short $+2
loc_FC880:
jmp short $+2
loc_FC882:
mov rax, [rbp+var_38]
mov qword ptr [rax], 0
mov rcx, [rbp+var_20]
mov rax, [rbp+var_38]
mov [rax+10h], rcx
mov rcx, [rbp+var_20]
sub rcx, 18h
mov rax, [rbp+var_38]
mov [rax+8], rcx
mov rcx, [rbp+var_38]
mov rax, [rbp+var_40]
mov [rax], rcx
loc_FC8B4:
mov rax, [rbp+var_38]
mov rcx, [rbp+var_38]
mov rcx, [rcx+10h]
mov rdx, [rbp+var_38]
sub rcx, [rdx+8]
add rax, rcx
mov [rbp+var_30], rax
mov rdx, [rbp+var_10]
mov rax, [rbp+var_38]
mov rcx, [rax+8]
sub rcx, rdx
mov [rax+8], rcx
mov rax, [rbp+var_18]
and rax, 20h
cmp rax, 0
jz short loc_FC8FF
mov rdi, [rbp+var_30]
mov rdx, [rbp+var_10]
xor esi, esi
call _memset
loc_FC8FF:
mov rax, [rbp+var_30]
mov [rbp+var_8], rax
loc_FC907:
mov rax, [rbp+var_8]
add rsp, 50h
pop rbp
retn
| char * my_once_alloc(long long a1, const char *a2)
{
int v3; // [rsp+8h] [rbp-48h]
bool v4; // [rsp+Fh] [rbp-41h]
_QWORD *v5; // [rsp+10h] [rbp-40h]
_QWORD *i; // [rsp+18h] [rbp-38h]
char *v7; // [rsp+20h] [rbp-30h]
unsigned long long v8; // [rsp+28h] [rbp-28h]
unsigned long long v9; // [rsp+30h] [rbp-20h]
unsigned long long v10; // [rsp+40h] [rbp-10h]
v10 = (a1 + 7) & 0xFFFFFFFFFFFFFFF8LL;
v5 = &my_once_root_block;
v8 = 0LL;
for ( i = (_QWORD *)my_once_root_block; ; i = (_QWORD *)*i )
{
v4 = 0;
if ( i )
v4 = i[1] < v10;
if ( !v4 )
break;
if ( i[1] > v8 )
v8 = i[1];
v5 = i;
}
if ( !i )
{
v9 = v10 + 24;
if ( 4 * v8 < my_once_extra && v9 < my_once_extra )
v9 = my_once_extra;
i = (_QWORD *)malloc(v9);
if ( !i )
{
v3 = *(_DWORD *)__errno_location();
*(_DWORD *)my_thread_var(v9, a2) = v3;
if ( ((unsigned __int8)a2 & 0x18) != 0 )
my_error(5u, 4100LL, v9);
return 0LL;
}
*i = 0LL;
i[2] = v9;
i[1] = v9 - 24;
*v5 = i;
}
v7 = (char *)i + i[2] - i[1];
i[1] -= v10;
if ( ((unsigned __int8)a2 & 0x20) != 0 )
memset(v7, 0LL, v10);
return v7;
}
| my_once_alloc:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x8
SUB RAX,0x1
AND RAX,-0x8
MOV qword ptr [RBP + -0x10],RAX
LEA RAX,[0xd8e670]
MOV qword ptr [RBP + -0x40],RAX
MOV qword ptr [RBP + -0x28],0x0
LEA RAX,[0xd8e670]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
LAB_001fc785:
XOR EAX,EAX
CMP qword ptr [RBP + -0x38],0x0
MOV byte ptr [RBP + -0x41],AL
JZ 0x001fc7a3
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
CMP RAX,qword ptr [RBP + -0x10]
SETC AL
MOV byte ptr [RBP + -0x41],AL
LAB_001fc7a3:
MOV AL,byte ptr [RBP + -0x41]
TEST AL,0x1
JNZ 0x001fc7ac
JMP 0x001fc7db
LAB_001fc7ac:
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x001fc7c6
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x28],RAX
LAB_001fc7c6:
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
JMP 0x001fc785
LAB_001fc7db:
CMP qword ptr [RBP + -0x38],0x0
JNZ 0x001fc8b4
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x18
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x28]
SHL RAX,0x2
LEA RCX,[0x3cafb0]
MOV ECX,dword ptr [RCX]
CMP RAX,RCX
JNC 0x001fc827
MOV RAX,qword ptr [RBP + -0x20]
LEA RCX,[0x3cafb0]
MOV ECX,dword ptr [RCX]
CMP RAX,RCX
JNC 0x001fc827
LEA RAX,[0x3cafb0]
MOV EAX,dword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
LAB_001fc827:
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x0012a740
MOV qword ptr [RBP + -0x38],RAX
CMP RAX,0x0
JNZ 0x001fc87e
CALL 0x0012a7d0
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x48],EAX
CALL 0x001fe880
MOV ECX,dword ptr [RBP + -0x48]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x18
CMP RAX,0x0
JZ 0x001fc871
MOV RDX,qword ptr [RBP + -0x20]
MOV EDI,0x5
MOV ESI,0x1004
MOV AL,0x0
CALL 0x001f3f50
LAB_001fc871:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001fc907
LAB_001fc87e:
JMP 0x001fc880
LAB_001fc880:
JMP 0x001fc882
LAB_001fc882:
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX],0x0
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,qword ptr [RBP + -0x20]
SUB RCX,0x18
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x8],RCX
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RAX],RCX
LAB_001fc8b4:
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RCX + 0x10]
MOV RDX,qword ptr [RBP + -0x38]
SUB RCX,qword ptr [RDX + 0x8]
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
MOV RDX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RAX + 0x8]
SUB RCX,RDX
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x20
CMP RAX,0x0
JZ 0x001fc8ff
MOV RDI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x10]
XOR ESI,ESI
CALL 0x0012a2c0
LAB_001fc8ff:
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x8],RAX
LAB_001fc907:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x50
POP RBP
RET
|
void * my_once_alloc(long param_1,ulong param_2)
{
int iVar1;
ulong __n;
int *piVar2;
void *__s;
bool bVar3;
int8 *local_48;
int8 *local_40;
ulong local_30;
size_t local_28;
__n = param_1 + 7U & 0xfffffffffffffff8;
local_48 = &my_once_root_block;
local_30 = 0;
local_40 = my_once_root_block;
while( true ) {
bVar3 = false;
if (local_40 != (int8 *)0x0) {
bVar3 = (ulong)local_40[1] < __n;
}
if (!bVar3) break;
if (local_30 < (ulong)local_40[1]) {
local_30 = local_40[1];
}
local_48 = local_40;
local_40 = (int8 *)*local_40;
}
if (local_40 == (int8 *)0x0) {
local_28 = __n + 0x18;
if ((local_30 << 2 < (ulong)my_once_extra) && (local_28 < my_once_extra)) {
local_28 = (size_t)my_once_extra;
}
local_40 = (int8 *)malloc(local_28);
if (local_40 == (int8 *)0x0) {
piVar2 = __errno_location();
iVar1 = *piVar2;
piVar2 = (int *)_my_thread_var();
*piVar2 = iVar1;
if ((param_2 & 0x18) != 0) {
my_error(5,0x1004,local_28);
}
return (void *)0x0;
}
*local_40 = 0;
local_40[2] = local_28;
local_40[1] = local_28 - 0x18;
*local_48 = local_40;
}
__s = (void *)((long)local_40 + (local_40[2] - local_40[1]));
local_40[1] = local_40[1] - __n;
if ((param_2 & 0x20) != 0) {
memset(__s,0,__n);
}
return __s;
}
|
|
990 | copy_typelib | eloqsql/mysys/typelib.c | TYPELIB *copy_typelib(MEM_ROOT *root, const TYPELIB *from)
{
TYPELIB *to;
uint i;
if (!from)
return NULL;
if (!(to= (TYPELIB*) alloc_root(root, sizeof(TYPELIB))))
return NULL;
if (!(to->type_names= (const char **)
alloc_root(root, (sizeof(char *) + sizeof(int)) * (from->count + 1))))
return NULL;
to->type_lengths= (unsigned int *)(to->type_names + from->count + 1);
to->count= from->count;
if (from->name)
{
if (!(to->name= strdup_root(root, from->name)))
return NULL;
}
else
to->name= NULL;
for (i= 0; i < from->count; i++)
{
if (!(to->type_names[i]= strmake_root(root, from->type_names[i],
from->type_lengths[i])))
return NULL;
to->type_lengths[i]= from->type_lengths[i];
}
to->type_names[to->count]= NULL;
to->type_lengths[to->count]= 0;
return to;
} | O3 | c | copy_typelib:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rsi, %rsi
je 0xabf0f
movq %rsi, %r14
movq %rdi, %r15
movl $0x20, %esi
callq 0xa075f
testq %rax, %rax
je 0xabf0f
movq %rax, %rbx
movl (%r14), %eax
incl %eax
shlq $0x2, %rax
leaq (%rax,%rax,2), %rsi
movq %r15, %rdi
callq 0xa075f
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0xabf0f
movl (%r14), %ecx
leaq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, 0x18(%rbx)
movl (%r14), %eax
movl %eax, (%rbx)
movq 0x8(%r14), %rsi
testq %rsi, %rsi
je 0xabf1d
movq %r15, %rdi
callq 0xa0afa
movq %rax, 0x8(%rbx)
testq %rax, %rax
jne 0xabf25
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq $0x0, 0x8(%rbx)
cmpl $0x0, (%r14)
je 0xabf6e
xorl %r12d, %r12d
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
movq (%rax,%r12,8), %rsi
movl (%rcx,%r12,4), %edx
movq %r15, %rdi
callq 0xa0b21
movq 0x10(%rbx), %rcx
movq %rax, (%rcx,%r12,8)
testq %rax, %rax
je 0xabf0f
movq 0x18(%r14), %rax
movl (%rax,%r12,4), %eax
movq 0x18(%rbx), %rcx
movl %eax, (%rcx,%r12,4)
incq %r12
movl (%r14), %eax
cmpq %rax, %r12
jb 0xabf2e
movq 0x10(%rbx), %rax
movl (%rbx), %ecx
movq $0x0, (%rax,%rcx,8)
movq 0x18(%rbx), %rax
movl (%rbx), %ecx
movl $0x0, (%rax,%rcx,4)
jmp 0xabf11
| copy_typelib:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
test rsi, rsi
jz short loc_ABF0F
mov r14, rsi
mov r15, rdi
mov esi, 20h ; ' '
call alloc_root
test rax, rax
jz short loc_ABF0F
mov rbx, rax
mov eax, [r14]
inc eax
shl rax, 2
lea rsi, [rax+rax*2]
mov rdi, r15
call alloc_root
mov [rbx+10h], rax
test rax, rax
jz short loc_ABF0F
mov ecx, [r14]
lea rax, [rax+rcx*8]
add rax, 8
mov [rbx+18h], rax
mov eax, [r14]
mov [rbx], eax
mov rsi, [r14+8]
test rsi, rsi
jz short loc_ABF1D
mov rdi, r15
call strdup_root
mov [rbx+8], rax
test rax, rax
jnz short loc_ABF25
loc_ABF0F:
xor ebx, ebx
loc_ABF11:
mov rax, rbx
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_ABF1D:
mov qword ptr [rbx+8], 0
loc_ABF25:
cmp dword ptr [r14], 0
jz short loc_ABF6E
xor r12d, r12d
loc_ABF2E:
mov rax, [r14+10h]
mov rcx, [r14+18h]
mov rsi, [rax+r12*8]
mov edx, [rcx+r12*4]
mov rdi, r15
call strmake_root
mov rcx, [rbx+10h]
mov [rcx+r12*8], rax
test rax, rax
jz short loc_ABF0F
mov rax, [r14+18h]
mov eax, [rax+r12*4]
mov rcx, [rbx+18h]
mov [rcx+r12*4], eax
inc r12
mov eax, [r14]
cmp r12, rax
jb short loc_ABF2E
loc_ABF6E:
mov rax, [rbx+10h]
mov ecx, [rbx]
mov qword ptr [rax+rcx*8], 0
mov rax, [rbx+18h]
mov ecx, [rbx]
mov dword ptr [rax+rcx*4], 0
jmp short loc_ABF11
| char * copy_typelib(long long a1, unsigned int *a2)
{
char *v3; // rax
char *v4; // rbx
char *v5; // rax
long long v6; // rsi
long long v7; // rax
long long v9; // r12
char *v10; // rax
if ( !a2 )
return 0LL;
v3 = alloc_root(a1, 32LL);
if ( !v3 )
return 0LL;
v4 = v3;
v5 = alloc_root(a1, 12LL * (*a2 + 1));
*((_QWORD *)v4 + 2) = v5;
if ( !v5 )
return 0LL;
*((_QWORD *)v4 + 3) = &v5[8 * *a2 + 8];
*(_DWORD *)v4 = *a2;
v6 = *((_QWORD *)a2 + 1);
if ( v6 )
{
v7 = strdup_root(a1, v6);
*((_QWORD *)v4 + 1) = v7;
if ( !v7 )
return 0LL;
}
else
{
*((_QWORD *)v4 + 1) = 0LL;
}
if ( !*a2 )
{
LABEL_13:
*(_QWORD *)(*((_QWORD *)v4 + 2) + 8LL * *(unsigned int *)v4) = 0LL;
*(_DWORD *)(*((_QWORD *)v4 + 3) + 4LL * *(unsigned int *)v4) = 0;
return v4;
}
v9 = 0LL;
while ( 1 )
{
v10 = strmake_root(a1, *(_QWORD *)(*((_QWORD *)a2 + 2) + 8 * v9), *(unsigned int *)(*((_QWORD *)a2 + 3) + 4 * v9));
*(_QWORD *)(*((_QWORD *)v4 + 2) + 8 * v9) = v10;
if ( !v10 )
return 0LL;
*(_DWORD *)(*((_QWORD *)v4 + 3) + 4 * v9) = *(_DWORD *)(*((_QWORD *)a2 + 3) + 4 * v9);
if ( ++v9 >= (unsigned long long)*a2 )
goto LABEL_13;
}
}
| copy_typelib:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
TEST RSI,RSI
JZ 0x001abf0f
MOV R14,RSI
MOV R15,RDI
MOV ESI,0x20
CALL 0x001a075f
TEST RAX,RAX
JZ 0x001abf0f
MOV RBX,RAX
MOV EAX,dword ptr [R14]
INC EAX
SHL RAX,0x2
LEA RSI,[RAX + RAX*0x2]
MOV RDI,R15
CALL 0x001a075f
MOV qword ptr [RBX + 0x10],RAX
TEST RAX,RAX
JZ 0x001abf0f
MOV ECX,dword ptr [R14]
LEA RAX,[RAX + RCX*0x8]
ADD RAX,0x8
MOV qword ptr [RBX + 0x18],RAX
MOV EAX,dword ptr [R14]
MOV dword ptr [RBX],EAX
MOV RSI,qword ptr [R14 + 0x8]
TEST RSI,RSI
JZ 0x001abf1d
MOV RDI,R15
CALL 0x001a0afa
MOV qword ptr [RBX + 0x8],RAX
TEST RAX,RAX
JNZ 0x001abf25
LAB_001abf0f:
XOR EBX,EBX
LAB_001abf11:
MOV RAX,RBX
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001abf1d:
MOV qword ptr [RBX + 0x8],0x0
LAB_001abf25:
CMP dword ptr [R14],0x0
JZ 0x001abf6e
XOR R12D,R12D
LAB_001abf2e:
MOV RAX,qword ptr [R14 + 0x10]
MOV RCX,qword ptr [R14 + 0x18]
MOV RSI,qword ptr [RAX + R12*0x8]
MOV EDX,dword ptr [RCX + R12*0x4]
MOV RDI,R15
CALL 0x001a0b21
MOV RCX,qword ptr [RBX + 0x10]
MOV qword ptr [RCX + R12*0x8],RAX
TEST RAX,RAX
JZ 0x001abf0f
MOV RAX,qword ptr [R14 + 0x18]
MOV EAX,dword ptr [RAX + R12*0x4]
MOV RCX,qword ptr [RBX + 0x18]
MOV dword ptr [RCX + R12*0x4],EAX
INC R12
MOV EAX,dword ptr [R14]
CMP R12,RAX
JC 0x001abf2e
LAB_001abf6e:
MOV RAX,qword ptr [RBX + 0x10]
MOV ECX,dword ptr [RBX]
MOV qword ptr [RAX + RCX*0x8],0x0
MOV RAX,qword ptr [RBX + 0x18]
MOV ECX,dword ptr [RBX]
MOV dword ptr [RAX + RCX*0x4],0x0
JMP 0x001abf11
|
uint * copy_typelib(int8 param_1,uint *param_2)
{
uint *puVar1;
long lVar2;
ulong uVar3;
if ((param_2 != (uint *)0x0) && (puVar1 = (uint *)alloc_root(param_1,0x20), puVar1 != (uint *)0x0)
) {
lVar2 = alloc_root(param_1,(ulong)(*param_2 + 1) * 0xc);
*(long *)(puVar1 + 4) = lVar2;
if (lVar2 != 0) {
*(ulong *)(puVar1 + 6) = lVar2 + (ulong)*param_2 * 8 + 8;
*puVar1 = *param_2;
if (*(long *)(param_2 + 2) == 0) {
puVar1[2] = 0;
puVar1[3] = 0;
}
else {
lVar2 = strdup_root(param_1);
*(long *)(puVar1 + 2) = lVar2;
if (lVar2 == 0) {
return (uint *)0x0;
}
}
if (*param_2 != 0) {
uVar3 = 0;
do {
lVar2 = strmake_root(param_1,*(int8 *)(*(long *)(param_2 + 4) + uVar3 * 8),
*(int4 *)(*(long *)(param_2 + 6) + uVar3 * 4));
*(long *)(*(long *)(puVar1 + 4) + uVar3 * 8) = lVar2;
if (lVar2 == 0) {
return (uint *)0x0;
}
*(int4 *)(*(long *)(puVar1 + 6) + uVar3 * 4) =
*(int4 *)(*(long *)(param_2 + 6) + uVar3 * 4);
uVar3 = uVar3 + 1;
} while (uVar3 < *param_2);
}
*(int8 *)(*(long *)(puVar1 + 4) + (ulong)*puVar1 * 8) = 0;
*(int4 *)(*(long *)(puVar1 + 6) + (ulong)*puVar1 * 4) = 0;
return puVar1;
}
}
return (uint *)0x0;
}
|
|
991 | minja::ArgumentsValue::get_named(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/./minja.hpp | Value get_named(const std::string & name) {
for (const auto & [key, value] : kwargs) {
if (key == name) return value;
}
return Value();
} | O3 | cpp | minja::ArgumentsValue::get_named(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rsi), %r14
movq 0x20(%rsi), %r13
cmpq %r13, %r14
je 0x726f6
movq (%rdx), %r15
movq 0x8(%rdx), %r12
cmpq %r12, 0x8(%r14)
jne 0x726ed
testq %r12, %r12
je 0x72734
movq (%r14), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x186e0
testl %eax, %eax
je 0x72734
addq $0x70, %r14
cmpq %r13, %r14
jne 0x726d0
leaq 0x40(%rbx), %r14
movq $0x0, 0x48(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x30(%rbx)
movb $0x0, 0x40(%rbx)
movq %r14, %rdi
movl $0x1, %esi
callq 0x3d970
movq %r14, %rdi
movl $0x1, %esi
callq 0x3d970
jmp 0x72743
addq $0x20, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4ed98
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| _ZN5minja14ArgumentsValue9get_namedERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r15
push r14
push r13
push r12
push rbx
mov rbx, rdi
mov r14, [rsi+18h]
mov r13, [rsi+20h]
cmp r14, r13
jz short loc_726F6
mov r15, [rdx]
mov r12, [rdx+8]
loc_726D0:
cmp [r14+8], r12
jnz short loc_726ED
test r12, r12
jz short loc_72734
mov rdi, [r14]
mov rsi, r15
mov rdx, r12
call _bcmp
test eax, eax
jz short loc_72734
loc_726ED:
add r14, 70h ; 'p'
cmp r14, r13
jnz short loc_726D0
loc_726F6:
lea r14, [rbx+40h]
mov qword ptr [rbx+48h], 0
xorps xmm0, xmm0
movups xmmword ptr [rbx], xmm0
movups xmmword ptr [rbx+10h], xmm0
movups xmmword ptr [rbx+20h], xmm0
movups xmmword ptr [rbx+30h], xmm0
mov byte ptr [rbx+40h], 0
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
jmp short loc_72743
loc_72734:
add r14, 20h ; ' '
mov rdi, rbx; this
mov rsi, r14; minja::Value *
call _ZN5minja5ValueC2ERKS0_; minja::Value::Value(minja::Value const&)
loc_72743:
mov rax, rbx
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
| minja::Value * minja::ArgumentsValue::get_named(minja::Value *this, long long a2, long long *a3)
{
_QWORD *v3; // r14
_QWORD *v4; // r13
long long v5; // r15
long long v6; // r12
v3 = *(_QWORD **)(a2 + 24);
v4 = *(_QWORD **)(a2 + 32);
if ( v3 == v4 )
{
LABEL_7:
*((_QWORD *)this + 9) = 0LL;
*(_OWORD *)this = 0LL;
*((_OWORD *)this + 1) = 0LL;
*((_OWORD *)this + 2) = 0LL;
*((_OWORD *)this + 3) = 0LL;
*((_BYTE *)this + 64) = 0;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)this + 64);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)this + 64);
}
else
{
v5 = *a3;
v6 = a3[1];
while ( v3[1] != v6 || v6 && (unsigned int)bcmp(*v3, v5) )
{
v3 += 14;
if ( v3 == v4 )
goto LABEL_7;
}
minja::Value::Value(this, (const minja::Value *)(v3 + 4));
}
return this;
}
| get_named:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV RBX,RDI
MOV R14,qword ptr [RSI + 0x18]
MOV R13,qword ptr [RSI + 0x20]
CMP R14,R13
JZ 0x001726f6
MOV R15,qword ptr [RDX]
MOV R12,qword ptr [RDX + 0x8]
LAB_001726d0:
CMP qword ptr [R14 + 0x8],R12
JNZ 0x001726ed
TEST R12,R12
JZ 0x00172734
MOV RDI,qword ptr [R14]
MOV RSI,R15
MOV RDX,R12
CALL 0x001186e0
TEST EAX,EAX
JZ 0x00172734
LAB_001726ed:
ADD R14,0x70
CMP R14,R13
JNZ 0x001726d0
LAB_001726f6:
LEA R14,[RBX + 0x40]
MOV qword ptr [RBX + 0x48],0x0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
MOVUPS xmmword ptr [RBX + 0x10],XMM0
MOVUPS xmmword ptr [RBX + 0x20],XMM0
MOVUPS xmmword ptr [RBX + 0x30],XMM0
MOV byte ptr [RBX + 0x40],0x0
MOV RDI,R14
MOV ESI,0x1
CALL 0x0013d970
MOV RDI,R14
MOV ESI,0x1
CALL 0x0013d970
JMP 0x00172743
LAB_00172734:
ADD R14,0x20
MOV RDI,RBX
MOV RSI,R14
CALL 0x0014ed98
LAB_00172743:
MOV RAX,RBX
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* minja::ArgumentsValue::get_named(std::__cxx11::string const&) */
string * minja::ArgumentsValue::get_named(string *param_1)
{
int8 *puVar1;
void *__s2;
size_t __n;
int iVar2;
int8 *in_RDX;
long in_RSI;
bool bVar3;
int8 *puVar4;
puVar4 = *(int8 **)(in_RSI + 0x18);
puVar1 = *(int8 **)(in_RSI + 0x20);
if (puVar4 != puVar1) {
__s2 = (void *)*in_RDX;
__n = in_RDX[1];
do {
if ((puVar4[1] == __n) && ((__n == 0 || (iVar2 = bcmp((void *)*puVar4,__s2,__n), iVar2 == 0)))
) {
minja::Value::Value((Value *)param_1,(Value *)(puVar4 + 4));
return param_1;
}
puVar4 = puVar4 + 0xe;
} while (puVar4 != puVar1);
}
bVar3 = (bool)((char)param_1 + '@');
*(int8 *)(param_1 + 0x48) = 0;
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
*(int8 *)(param_1 + 0x18) = 0;
*(int8 *)(param_1 + 0x20) = 0;
*(int8 *)(param_1 + 0x28) = 0;
*(int8 *)(param_1 + 0x30) = 0;
*(int8 *)(param_1 + 0x38) = 0;
param_1[0x40] = (string)0x0;
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(bVar3);
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(bVar3);
return param_1;
}
|
|
992 | pagecache_unlock | eloqsql/storage/maria/ma_pagecache.c | void pagecache_unlock(PAGECACHE *pagecache,
PAGECACHE_FILE *file,
pgcache_page_no_t pageno,
enum pagecache_page_lock lock,
enum pagecache_page_pin pin,
LSN first_REDO_LSN_for_page,
LSN lsn, my_bool was_changed)
{
PAGECACHE_BLOCK_LINK *block;
int page_st;
DBUG_ENTER("pagecache_unlock");
DBUG_PRINT("enter", ("fd: %u page: %lu %s %s",
(uint) file->file, (ulong) pageno,
page_cache_page_lock_str[lock],
page_cache_page_pin_str[pin]));
/* we do not allow any lock/pin increasing here */
DBUG_ASSERT(pin != PAGECACHE_PIN);
DBUG_ASSERT(lock != PAGECACHE_LOCK_READ && lock != PAGECACHE_LOCK_WRITE);
pagecache_pthread_mutex_lock(&pagecache->cache_lock);
/*
As soon as we keep lock cache can be used, and we have lock because want
to unlock.
*/
DBUG_ASSERT(pagecache->can_be_used);
inc_counter_for_resize_op(pagecache);
/* See NOTE for pagecache_unlock about registering requests */
block= find_block(pagecache, file, pageno, 0, 0, 0,
pin == PAGECACHE_PIN_LEFT_UNPINNED, FALSE, &page_st);
PCBLOCK_INFO(block);
DBUG_ASSERT(block != 0 && page_st == PAGE_READ);
if (first_REDO_LSN_for_page)
{
DBUG_ASSERT(lock == PAGECACHE_LOCK_WRITE_UNLOCK);
DBUG_ASSERT(pin == PAGECACHE_UNPIN);
pagecache_set_block_rec_lsn(block, first_REDO_LSN_for_page);
}
if (lsn != LSN_IMPOSSIBLE)
check_and_set_lsn(pagecache, lsn, block);
/* if we lock for write we must link the block to changed blocks */
DBUG_ASSERT((block->status & PCBLOCK_DIRECT_W) == 0 ||
(lock == PAGECACHE_LOCK_WRITE_UNLOCK ||
lock == PAGECACHE_LOCK_WRITE_TO_READ ||
lock == PAGECACHE_LOCK_LEFT_WRITELOCKED));
/*
if was_changed then status should be PCBLOCK_DIRECT_W or marked
as dirty
*/
DBUG_ASSERT(!was_changed || (block->status & PCBLOCK_DIRECT_W) ||
(block->status & PCBLOCK_CHANGED));
if ((block->status & PCBLOCK_DIRECT_W) &&
(lock == PAGECACHE_LOCK_WRITE_UNLOCK ||
lock == PAGECACHE_LOCK_WRITE_TO_READ))
{
if (!(block->status & PCBLOCK_CHANGED) && was_changed)
link_to_changed_list(pagecache, block);
block->status&= ~PCBLOCK_DIRECT_W;
DBUG_PRINT("info", ("Drop PCBLOCK_DIRECT_W for block: %p", block));
}
if (make_lock_and_pin(pagecache, block, lock, pin, FALSE))
{
DBUG_ASSERT(0); /* should not happend */
}
remove_reader(block);
/*
Link the block into the LRU chain if it's the last submitted request
for the block and block will not be pinned.
See NOTE for pagecache_unlock about registering requests.
*/
if (pin != PAGECACHE_PIN_LEFT_PINNED)
unreg_request(pagecache, block, 1);
dec_counter_for_resize_op(pagecache);
pagecache_pthread_mutex_unlock(&pagecache->cache_lock);
DBUG_VOID_RETURN;
} | O3 | c | pagecache_unlock:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r12
movl %r8d, -0x30(%rbp)
movl %ecx, -0x34(%rbp)
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r14
movb 0x18(%rbp), %al
movb %al, -0x29(%rbp)
movq 0x10(%rbp), %rbx
addq $0xc8, %rdi
cmpq $0x0, 0x108(%r14)
movq %rdi, -0x40(%rbp)
jne 0x3270d
callq 0x29220
incq 0x68(%r14)
xorl %eax, %eax
cmpl $0x1, -0x30(%rbp)
sete %al
subq $0x8, %rsp
leaq -0x44(%rbp), %r10
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %r10
pushq $0x0
pushq %rax
callq 0x3275c
addq $0x20, %rsp
movq %rax, %r13
testq %r12, %r12
je 0x325c3
movabsq $0xffffffffffffff, %rax # imm = 0xFFFFFFFFFFFFFF
cmpq %rax, 0x88(%r13)
jne 0x325c3
movq %r12, 0x88(%r13)
testq %rbx, %rbx
je 0x325d6
movq %r14, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x32da6
movl -0x34(%rbp), %edx
movl %edx, %eax
andl $-0x2, %eax
cmpl $0x6, %eax
jne 0x32671
movzwl 0x74(%r13), %eax
movzwl %ax, %ecx
movl %ecx, %esi
andl $0x40, %esi
je 0x32671
cmpb $0x0, -0x29(%rbp)
je 0x32667
andl $0x20, %ecx
jne 0x32667
movq %r13, %rax
addq $0x10, %rax
movq 0x10(%r13), %rsi
movq 0x18(%r13), %rcx
testq %rsi, %rsi
je 0x3261e
movq %rcx, 0x18(%rsi)
movq (%rax), %rsi
jmp 0x32620
xorl %esi, %esi
movq %rsi, (%rcx)
movq 0x128(%r14), %rcx
movq 0x20(%r13), %rdi
movl 0x28(%r14), %esi
decl %esi
andl 0x28(%rdi), %esi
leaq (%rcx,%rsi,8), %rcx
movq %rcx, 0x18(%r13)
movq (%rcx), %rsi
movq %rsi, 0x10(%r13)
testq %rsi, %rsi
je 0x3264f
movq %rax, 0x18(%rsi)
movq %r13, (%rcx)
orb $0x20, 0x74(%r13)
incq 0x58(%r14)
incq 0x168(%r14)
movzwl 0x74(%r13), %eax
andl $0xffbf, %eax # imm = 0xFFBF
movw %ax, 0x74(%r13)
movq %r14, %rdi
movq %r13, %rsi
movl -0x30(%rbp), %ecx
callq 0x32e63
movq 0x20(%r13), %rax
decl 0x68(%rax)
jne 0x326a6
movq 0x28(%r13), %rbx
testq %rbx, %rbx
je 0x326a6
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
jne 0x32735
movq %rbx, %rdi
callq 0x295c0
cmpl $0x0, -0x30(%rbp)
je 0x326bc
movq %r14, %rdi
movq %r13, %rsi
movl $0x1, %edx
callq 0x32fd3
decq 0x68(%r14)
jne 0x326ea
movq 0x110(%r14), %rax
testq %rax, %rax
je 0x326ea
movq 0x88(%rax), %rbx
movq 0x38(%rbx), %rdi
addq $0x8, %rbx
testq %rdi, %rdi
jne 0x3274a
movq %rbx, %rdi
callq 0x295c0
movq 0x108(%r14), %rdi
testq %rdi, %rdi
jne 0x32723
movq -0x40(%rbp), %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x291e0
leaq 0xa8177(%rip), %rsi # 0xda88b
movl $0xc97, %edx # imm = 0xC97
callq 0x2eb8f
jmp 0x3256d
leaq 0x355996(%rip), %rax # 0x3880c0
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x326f6
leaq 0x355984(%rip), %rax # 0x3880c0
movq (%rax), %rax
callq *0x170(%rax)
jmp 0x3269e
leaq 0x35596f(%rip), %rax # 0x3880c0
movq (%rax), %rax
callq *0x170(%rax)
jmp 0x326e2
| pagecache_unlock:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r12, r9
mov [rbp+var_30], r8d
mov [rbp+var_34], ecx
mov r13, rdx
mov r15, rsi
mov r14, rdi
mov al, [rbp+arg_8]
mov [rbp+var_29], al
mov rbx, [rbp+arg_0]
add rdi, 0C8h
cmp qword ptr [r14+108h], 0
mov [rbp+var_40], rdi
jnz loc_3270D
call _pthread_mutex_lock
loc_3256D:
inc qword ptr [r14+68h]
xor eax, eax
cmp [rbp+var_30], 1
setz al
sub rsp, 8
lea r10, [rbp+var_44]
mov rdi, r14
mov rsi, r15
mov rdx, r13
xor ecx, ecx
xor r8d, r8d
xor r9d, r9d
push r10
push 0
push rax
call find_block
add rsp, 20h
mov r13, rax
test r12, r12
jz short loc_325C3
mov rax, 0FFFFFFFFFFFFFFh
cmp [r13+88h], rax
jnz short loc_325C3
mov [r13+88h], r12
loc_325C3:
test rbx, rbx
jz short loc_325D6
mov rdi, r14
mov rsi, rbx
mov rdx, r13
call check_and_set_lsn
loc_325D6:
mov edx, [rbp+var_34]
mov eax, edx
and eax, 0FFFFFFFEh
cmp eax, 6
jnz loc_32671
movzx eax, word ptr [r13+74h]
movzx ecx, ax
mov esi, ecx
and esi, 40h
jz short loc_32671
cmp [rbp+var_29], 0
jz short loc_32667
and ecx, 20h
jnz short loc_32667
mov rax, r13
add rax, 10h
mov rsi, [r13+10h]
mov rcx, [r13+18h]
test rsi, rsi
jz short loc_3261E
mov [rsi+18h], rcx
mov rsi, [rax]
jmp short loc_32620
loc_3261E:
xor esi, esi
loc_32620:
mov [rcx], rsi
mov rcx, [r14+128h]
mov rdi, [r13+20h]
mov esi, [r14+28h]
dec esi
and esi, [rdi+28h]
lea rcx, [rcx+rsi*8]
mov [r13+18h], rcx
mov rsi, [rcx]
mov [r13+10h], rsi
test rsi, rsi
jz short loc_3264F
mov [rsi+18h], rax
loc_3264F:
mov [rcx], r13
or byte ptr [r13+74h], 20h
inc qword ptr [r14+58h]
inc qword ptr [r14+168h]
movzx eax, word ptr [r13+74h]
loc_32667:
and eax, 0FFBFh
mov [r13+74h], ax
loc_32671:
mov rdi, r14
mov rsi, r13
mov ecx, [rbp+var_30]
call make_lock_and_pin
mov rax, [r13+20h]
dec dword ptr [rax+68h]
jnz short loc_326A6
mov rbx, [r13+28h]
test rbx, rbx
jz short loc_326A6
mov rdi, [rbx+30h]
test rdi, rdi
jnz loc_32735
loc_3269E:
mov rdi, rbx
call _pthread_cond_signal
loc_326A6:
cmp [rbp+var_30], 0
jz short loc_326BC
mov rdi, r14
mov rsi, r13
mov edx, 1
call unreg_request
loc_326BC:
dec qword ptr [r14+68h]
jnz short loc_326EA
mov rax, [r14+110h]
test rax, rax
jz short loc_326EA
mov rbx, [rax+88h]
mov rdi, [rbx+38h]
add rbx, 8
test rdi, rdi
jnz short loc_3274A
loc_326E2:
mov rdi, rbx
call _pthread_cond_signal
loc_326EA:
mov rdi, [r14+108h]
test rdi, rdi
jnz short loc_32723
loc_326F6:
mov rdi, [rbp+var_40]
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _pthread_mutex_unlock
loc_3270D:
lea rsi, aWorkspaceLlm4b_25; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 0C97h
call psi_mutex_lock
jmp loc_3256D
loc_32723:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_326F6
loc_32735:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+170h]
jmp loc_3269E
loc_3274A:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+170h]
jmp short loc_326E2
| long long pagecache_unlock(
long long a1,
int a2,
int a3,
unsigned int a4,
unsigned int a5,
long long a6,
long long a7,
char a8)
{
long long v11; // rdi
bool v12; // zf
long long block; // r13
long long v14; // rdx
__int16 v15; // ax
long long *v16; // rax
long long v17; // rsi
_QWORD *v18; // rcx
long long v19; // rsi
long long *v20; // rcx
long long v21; // rsi
long long v22; // rax
long long v23; // rbx
long long v24; // rax
long long v25; // rbx
long long v26; // rdi
long long v27; // rbx
char v29[4]; // [rsp+Ch] [rbp-44h] BYREF
long long v30; // [rsp+10h] [rbp-40h]
unsigned int v31; // [rsp+1Ch] [rbp-34h]
unsigned int v32; // [rsp+20h] [rbp-30h]
char v33; // [rsp+27h] [rbp-29h]
v32 = a5;
v31 = a4;
v33 = a8;
v11 = a1 + 200;
v12 = *(_QWORD *)(a1 + 264) == 0LL;
v30 = v11;
if ( v12 )
pthread_mutex_lock(v11);
else
psi_mutex_lock(v11, (long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c", 0xC97u);
++*(_QWORD *)(a1 + 104);
block = find_block(a1, a2, a3, 0, 0, 0, v32 == 1, 0, (long long)v29);
if ( a6 && *(_QWORD *)(block + 136) == 0xFFFFFFFFFFFFFFLL )
*(_QWORD *)(block + 136) = a6;
if ( a7 )
check_and_set_lsn(a1, a7, block);
v14 = v31;
if ( (v31 & 0xFFFFFFFE) == 6 )
{
v15 = *(_WORD *)(block + 116);
if ( (v15 & 0x40) != 0 )
{
if ( v33 && (*(_WORD *)(block + 116) & 0x20) == 0 )
{
v16 = (long long *)(block + 16);
v17 = *(_QWORD *)(block + 16);
v18 = *(_QWORD **)(block + 24);
if ( v17 )
{
*(_QWORD *)(v17 + 24) = v18;
v19 = *v16;
}
else
{
v19 = 0LL;
}
*v18 = v19;
v20 = (long long *)(*(_QWORD *)(a1 + 296)
+ 8LL * (*(_DWORD *)(*(_QWORD *)(block + 32) + 40LL) & (unsigned int)(*(_DWORD *)(a1 + 40) - 1)));
*(_QWORD *)(block + 24) = v20;
v21 = *v20;
*(_QWORD *)(block + 16) = *v20;
if ( v21 )
*(_QWORD *)(v21 + 24) = v16;
*v20 = block;
*(_BYTE *)(block + 116) |= 0x20u;
++*(_QWORD *)(a1 + 88);
++*(_QWORD *)(a1 + 360);
v15 = *(_WORD *)(block + 116);
}
*(_WORD *)(block + 116) = v15 & 0xFFBF;
}
}
make_lock_and_pin(a1, block, v14, v32);
v22 = *(_QWORD *)(block + 32);
v12 = (*(_DWORD *)(v22 + 104))-- == 1;
if ( v12 )
{
v23 = *(_QWORD *)(block + 40);
if ( v23 )
{
if ( *(_QWORD *)(v23 + 48) )
PSI_server[46]();
pthread_cond_signal(v23);
}
}
if ( v32 )
unreg_request(a1, block, 1LL);
v12 = (*(_QWORD *)(a1 + 104))-- == 1LL;
if ( v12 )
{
v24 = *(_QWORD *)(a1 + 272);
if ( v24 )
{
v25 = *(_QWORD *)(v24 + 136);
v26 = *(_QWORD *)(v25 + 56);
v27 = v25 + 8;
if ( v26 )
PSI_server[46]();
pthread_cond_signal(v27);
}
}
if ( *(_QWORD *)(a1 + 264) )
PSI_server[44]();
return pthread_mutex_unlock(v30);
}
| pagecache_unlock:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R12,R9
MOV dword ptr [RBP + -0x30],R8D
MOV dword ptr [RBP + -0x34],ECX
MOV R13,RDX
MOV R15,RSI
MOV R14,RDI
MOV AL,byte ptr [RBP + 0x18]
MOV byte ptr [RBP + -0x29],AL
MOV RBX,qword ptr [RBP + 0x10]
ADD RDI,0xc8
CMP qword ptr [R14 + 0x108],0x0
MOV qword ptr [RBP + -0x40],RDI
JNZ 0x0013270d
CALL 0x00129220
LAB_0013256d:
INC qword ptr [R14 + 0x68]
XOR EAX,EAX
CMP dword ptr [RBP + -0x30],0x1
SETZ AL
SUB RSP,0x8
LEA R10,[RBP + -0x44]
MOV RDI,R14
MOV RSI,R15
MOV RDX,R13
XOR ECX,ECX
XOR R8D,R8D
XOR R9D,R9D
PUSH R10
PUSH 0x0
PUSH RAX
CALL 0x0013275c
ADD RSP,0x20
MOV R13,RAX
TEST R12,R12
JZ 0x001325c3
MOV RAX,0xffffffffffffff
CMP qword ptr [R13 + 0x88],RAX
JNZ 0x001325c3
MOV qword ptr [R13 + 0x88],R12
LAB_001325c3:
TEST RBX,RBX
JZ 0x001325d6
MOV RDI,R14
MOV RSI,RBX
MOV RDX,R13
CALL 0x00132da6
LAB_001325d6:
MOV EDX,dword ptr [RBP + -0x34]
MOV EAX,EDX
AND EAX,0xfffffffe
CMP EAX,0x6
JNZ 0x00132671
MOVZX EAX,word ptr [R13 + 0x74]
MOVZX ECX,AX
MOV ESI,ECX
AND ESI,0x40
JZ 0x00132671
CMP byte ptr [RBP + -0x29],0x0
JZ 0x00132667
AND ECX,0x20
JNZ 0x00132667
MOV RAX,R13
ADD RAX,0x10
MOV RSI,qword ptr [R13 + 0x10]
MOV RCX,qword ptr [R13 + 0x18]
TEST RSI,RSI
JZ 0x0013261e
MOV qword ptr [RSI + 0x18],RCX
MOV RSI,qword ptr [RAX]
JMP 0x00132620
LAB_0013261e:
XOR ESI,ESI
LAB_00132620:
MOV qword ptr [RCX],RSI
MOV RCX,qword ptr [R14 + 0x128]
MOV RDI,qword ptr [R13 + 0x20]
MOV ESI,dword ptr [R14 + 0x28]
DEC ESI
AND ESI,dword ptr [RDI + 0x28]
LEA RCX,[RCX + RSI*0x8]
MOV qword ptr [R13 + 0x18],RCX
MOV RSI,qword ptr [RCX]
MOV qword ptr [R13 + 0x10],RSI
TEST RSI,RSI
JZ 0x0013264f
MOV qword ptr [RSI + 0x18],RAX
LAB_0013264f:
MOV qword ptr [RCX],R13
OR byte ptr [R13 + 0x74],0x20
INC qword ptr [R14 + 0x58]
INC qword ptr [R14 + 0x168]
MOVZX EAX,word ptr [R13 + 0x74]
LAB_00132667:
AND EAX,0xffbf
MOV word ptr [R13 + 0x74],AX
LAB_00132671:
MOV RDI,R14
MOV RSI,R13
MOV ECX,dword ptr [RBP + -0x30]
CALL 0x00132e63
MOV RAX,qword ptr [R13 + 0x20]
DEC dword ptr [RAX + 0x68]
JNZ 0x001326a6
MOV RBX,qword ptr [R13 + 0x28]
TEST RBX,RBX
JZ 0x001326a6
MOV RDI,qword ptr [RBX + 0x30]
TEST RDI,RDI
JNZ 0x00132735
LAB_0013269e:
MOV RDI,RBX
CALL 0x001295c0
LAB_001326a6:
CMP dword ptr [RBP + -0x30],0x0
JZ 0x001326bc
MOV RDI,R14
MOV RSI,R13
MOV EDX,0x1
CALL 0x00132fd3
LAB_001326bc:
DEC qword ptr [R14 + 0x68]
JNZ 0x001326ea
MOV RAX,qword ptr [R14 + 0x110]
TEST RAX,RAX
JZ 0x001326ea
MOV RBX,qword ptr [RAX + 0x88]
MOV RDI,qword ptr [RBX + 0x38]
ADD RBX,0x8
TEST RDI,RDI
JNZ 0x0013274a
LAB_001326e2:
MOV RDI,RBX
CALL 0x001295c0
LAB_001326ea:
MOV RDI,qword ptr [R14 + 0x108]
TEST RDI,RDI
JNZ 0x00132723
LAB_001326f6:
MOV RDI,qword ptr [RBP + -0x40]
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x001291e0
LAB_0013270d:
LEA RSI,[0x1da88b]
MOV EDX,0xc97
CALL 0x0012eb8f
JMP 0x0013256d
LAB_00132723:
LEA RAX,[0x4880c0]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x001326f6
LAB_00132735:
LEA RAX,[0x4880c0]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x170]
JMP 0x0013269e
LAB_0013274a:
LEA RAX,[0x4880c0]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x170]
JMP 0x001326e2
|
void pagecache_unlock(long param_1,int8 param_2,int8 param_3,uint param_4,int param_5,
long param_6,long param_7,char param_8)
{
int *piVar1;
long *plVar2;
int8 *puVar3;
long lVar4;
pthread_cond_t *__cond;
ushort uVar5;
long lVar6;
int8 uVar7;
int1 local_4c [4];
pthread_mutex_t *local_48;
uint local_3c;
int local_38;
char local_31;
local_31 = param_8;
local_48 = (pthread_mutex_t *)(param_1 + 200);
local_3c = param_4;
local_38 = param_5;
if (*(long *)(param_1 + 0x108) == 0) {
pthread_mutex_lock(local_48);
}
else {
psi_mutex_lock(local_48,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",
0xc97);
}
*(long *)(param_1 + 0x68) = *(long *)(param_1 + 0x68) + 1;
lVar6 = find_block(param_1,param_2,param_3,0,0,0,local_38 == 1,0,local_4c);
if ((param_6 != 0) && (*(long *)(lVar6 + 0x88) == 0xffffffffffffff)) {
*(long *)(lVar6 + 0x88) = param_6;
}
if (param_7 != 0) {
check_and_set_lsn(param_1,param_7,lVar6);
}
if (((local_3c & 0xfffffffe) == 6) && (uVar5 = *(ushort *)(lVar6 + 0x74), (uVar5 & 0x40) != 0)) {
if ((local_31 != '\0') && ((uVar5 & 0x20) == 0)) {
puVar3 = *(int8 **)(lVar6 + 0x18);
if (*(long *)(lVar6 + 0x10) == 0) {
uVar7 = 0;
}
else {
*(int8 **)(*(long *)(lVar6 + 0x10) + 0x18) = puVar3;
uVar7 = *(int8 *)(lVar6 + 0x10);
}
*puVar3 = uVar7;
plVar2 = (long *)(*(long *)(param_1 + 0x128) +
(ulong)(*(int *)(param_1 + 0x28) - 1U &
*(uint *)(*(long *)(lVar6 + 0x20) + 0x28)) * 8);
*(long **)(lVar6 + 0x18) = plVar2;
lVar4 = *plVar2;
*(long *)(lVar6 + 0x10) = lVar4;
if (lVar4 != 0) {
*(int8 **)(lVar4 + 0x18) = (int8 *)(lVar6 + 0x10);
}
*plVar2 = lVar6;
*(byte *)(lVar6 + 0x74) = *(byte *)(lVar6 + 0x74) | 0x20;
*(long *)(param_1 + 0x58) = *(long *)(param_1 + 0x58) + 1;
*(long *)(param_1 + 0x168) = *(long *)(param_1 + 0x168) + 1;
uVar5 = *(ushort *)(lVar6 + 0x74);
}
*(ushort *)(lVar6 + 0x74) = uVar5 & 0xffbf;
}
make_lock_and_pin(param_1,lVar6,local_3c,local_38);
piVar1 = (int *)(*(long *)(lVar6 + 0x20) + 0x68);
*piVar1 = *piVar1 + -1;
if ((*piVar1 == 0) &&
(__cond = *(pthread_cond_t **)(lVar6 + 0x28), __cond != (pthread_cond_t *)0x0)) {
if (__cond[1].__align != 0) {
(**(code **)(PSI_server + 0x170))();
}
pthread_cond_signal(__cond);
}
if (local_38 != 0) {
unreg_request(param_1,lVar6,1);
}
plVar2 = (long *)(param_1 + 0x68);
*plVar2 = *plVar2 + -1;
if ((*plVar2 == 0) && (*(long *)(param_1 + 0x110) != 0)) {
lVar6 = *(long *)(*(long *)(param_1 + 0x110) + 0x88);
if (*(long *)(lVar6 + 0x38) != 0) {
(**(code **)(PSI_server + 0x170))();
}
pthread_cond_signal((pthread_cond_t *)(lVar6 + 8));
}
if (*(long *)(param_1 + 0x108) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(local_48);
return;
}
|
|
993 | ggml_vec_dot_q3_K_q8_K | monkey531[P]llama/ggml/src/ggml-cpu/ggml-cpu-quants.c | void ggml_vec_dot_q3_K_q8_K(int n, float * restrict s, size_t bs, const void * restrict vx, size_t bx, const void * restrict vy, size_t by, int nrc) {
assert(n % QK_K == 0);
assert(nrc == 1);
UNUSED(nrc);
UNUSED(bx);
UNUSED(by);
UNUSED(bs);
const uint32_t kmask1 = 0x03030303;
const uint32_t kmask2 = 0x0f0f0f0f;
const block_q3_K * restrict x = vx;
const block_q8_K * restrict y = vy;
const int nb = n / QK_K;
#ifdef __ARM_NEON
uint32_t aux[3];
uint32_t utmp[4];
const uint8x16_t m3b = vdupq_n_u8(0x3);
const int32x4_t vzero = vdupq_n_s32(0);
const uint8x16_t m0 = vdupq_n_u8(1);
const uint8x16_t m1 = vshlq_n_u8(m0, 1);
const uint8x16_t m2 = vshlq_n_u8(m0, 2);
const uint8x16_t m3 = vshlq_n_u8(m0, 3);
const int8_t m32 = 32;
ggml_int8x16x4_t q3bytes;
float sum = 0;
for (int i = 0; i < nb; ++i) {
const float d = y[i].d * GGML_FP16_TO_FP32(x[i].d);
const uint8_t * restrict q3 = x[i].qs;
const uint8_t * restrict qh = x[i].hmask;
const int8_t * restrict q8 = y[i].qs;
ggml_uint8x16x2_t qhbits = ggml_vld1q_u8_x2(qh);
ggml_uint8x16x4_t q3h;
int32_t isum = 0;
// Set up scales
memcpy(aux, x[i].scales, 12);
utmp[3] = ((aux[1] >> 4) & kmask2) | (((aux[2] >> 6) & kmask1) << 4);
utmp[2] = ((aux[0] >> 4) & kmask2) | (((aux[2] >> 4) & kmask1) << 4);
utmp[1] = (aux[1] & kmask2) | (((aux[2] >> 2) & kmask1) << 4);
utmp[0] = (aux[0] & kmask2) | (((aux[2] >> 0) & kmask1) << 4);
int8_t * scale = (int8_t *)utmp;
for (int j = 0; j < 16; ++j) scale[j] -= m32;
for (int j = 0; j < QK_K/128; ++j) {
const ggml_uint8x16x2_t q3bits = ggml_vld1q_u8_x2(q3); q3 += 32;
const ggml_int8x16x4_t q8bytes_1 = ggml_vld1q_s8_x4(q8); q8 += 64;
const ggml_int8x16x4_t q8bytes_2 = ggml_vld1q_s8_x4(q8); q8 += 64;
q3h.val[0] = vshlq_n_u8(vbicq_u8(m0, qhbits.val[0]), 2);
q3h.val[1] = vshlq_n_u8(vbicq_u8(m0, qhbits.val[1]), 2);
q3h.val[2] = vshlq_n_u8(vbicq_u8(m1, qhbits.val[0]), 1);
q3h.val[3] = vshlq_n_u8(vbicq_u8(m1, qhbits.val[1]), 1);
q3bytes.val[0] = vsubq_s8(vreinterpretq_s8_u8(vandq_u8(q3bits.val[0], m3b)), vreinterpretq_s8_u8(q3h.val[0]));
q3bytes.val[1] = vsubq_s8(vreinterpretq_s8_u8(vandq_u8(q3bits.val[1], m3b)), vreinterpretq_s8_u8(q3h.val[1]));
q3bytes.val[2] = vsubq_s8(vreinterpretq_s8_u8(vandq_u8(vshrq_n_u8(q3bits.val[0], 2), m3b)), vreinterpretq_s8_u8(q3h.val[2]));
q3bytes.val[3] = vsubq_s8(vreinterpretq_s8_u8(vandq_u8(vshrq_n_u8(q3bits.val[1], 2), m3b)), vreinterpretq_s8_u8(q3h.val[3]));
isum += vaddvq_s32(ggml_vdotq_s32(vzero, q3bytes.val[0], q8bytes_1.val[0])) * scale[0];
isum += vaddvq_s32(ggml_vdotq_s32(vzero, q3bytes.val[1], q8bytes_1.val[1])) * scale[1];
isum += vaddvq_s32(ggml_vdotq_s32(vzero, q3bytes.val[2], q8bytes_1.val[2])) * scale[2];
isum += vaddvq_s32(ggml_vdotq_s32(vzero, q3bytes.val[3], q8bytes_1.val[3])) * scale[3];
scale += 4;
q3h.val[0] = vbicq_u8(m2, qhbits.val[0]);
q3h.val[1] = vbicq_u8(m2, qhbits.val[1]);
q3h.val[2] = vshrq_n_u8(vbicq_u8(m3, qhbits.val[0]), 1);
q3h.val[3] = vshrq_n_u8(vbicq_u8(m3, qhbits.val[1]), 1);
q3bytes.val[0] = vsubq_s8(vreinterpretq_s8_u8(vandq_u8(vshrq_n_u8(q3bits.val[0], 4), m3b)), vreinterpretq_s8_u8(q3h.val[0]));
q3bytes.val[1] = vsubq_s8(vreinterpretq_s8_u8(vandq_u8(vshrq_n_u8(q3bits.val[1], 4), m3b)), vreinterpretq_s8_u8(q3h.val[1]));
q3bytes.val[2] = vsubq_s8(vreinterpretq_s8_u8(vandq_u8(vshrq_n_u8(q3bits.val[0], 6), m3b)), vreinterpretq_s8_u8(q3h.val[2]));
q3bytes.val[3] = vsubq_s8(vreinterpretq_s8_u8(vandq_u8(vshrq_n_u8(q3bits.val[1], 6), m3b)), vreinterpretq_s8_u8(q3h.val[3]));
isum += vaddvq_s32(ggml_vdotq_s32(vzero, q3bytes.val[0], q8bytes_2.val[0])) * scale[0];
isum += vaddvq_s32(ggml_vdotq_s32(vzero, q3bytes.val[1], q8bytes_2.val[1])) * scale[1];
isum += vaddvq_s32(ggml_vdotq_s32(vzero, q3bytes.val[2], q8bytes_2.val[2])) * scale[2];
isum += vaddvq_s32(ggml_vdotq_s32(vzero, q3bytes.val[3], q8bytes_2.val[3])) * scale[3];
scale += 4;
if (j == 0) {
qhbits.val[0] = vshrq_n_u8(qhbits.val[0], 4);
qhbits.val[1] = vshrq_n_u8(qhbits.val[1], 4);
}
}
sum += d * isum;
}
*s = sum;
#elif defined __AVX2__
const __m256i m3 = _mm256_set1_epi8(3);
const __m256i mone = _mm256_set1_epi8(1);
const __m128i m32 = _mm_set1_epi8(32);
__m256 acc = _mm256_setzero_ps();
uint32_t aux[3];
for (int i = 0; i < nb; ++i) {
const float d = y[i].d * GGML_FP16_TO_FP32(x[i].d);
const uint8_t * restrict q3 = x[i].qs;
const int8_t * restrict q8 = y[i].qs;
// Set up scales
memcpy(aux, x[i].scales, 12);
__m128i scales128 = _mm_set_epi32(
((aux[1] >> 4) & kmask2) | (((aux[2] >> 6) & kmask1) << 4),
((aux[0] >> 4) & kmask2) | (((aux[2] >> 4) & kmask1) << 4),
(aux[1] & kmask2) | (((aux[2] >> 2) & kmask1) << 4),
(aux[0] & kmask2) | (((aux[2] >> 0) & kmask1) << 4));
scales128 = _mm_sub_epi8(scales128, m32);
const __m256i all_scales = _mm256_cvtepi8_epi16(scales128);
const __m128i l_scales = _mm256_extracti128_si256(all_scales, 0);
const __m128i h_scales = _mm256_extracti128_si256(all_scales, 1);
const __m256i scales[2] = {MM256_SET_M128I(l_scales, l_scales), MM256_SET_M128I(h_scales, h_scales)};
// high bit
const __m256i hbits = _mm256_loadu_si256((const __m256i*)x[i].hmask);
// integer accumulator
__m256i sumi = _mm256_setzero_si256();
int bit = 0;
int is = 0;
for (int j = 0; j < QK_K/128; ++j) {
// load low 2 bits
const __m256i q3bits = _mm256_loadu_si256((const __m256i*)q3); q3 += 32;
// prepare low and high bits
const __m256i q3l_0 = _mm256_and_si256(q3bits, m3);
const __m256i q3h_0 = _mm256_slli_epi16(_mm256_srli_epi16(_mm256_andnot_si256(hbits, _mm256_slli_epi16(mone, bit)), bit), 2);
++bit;
const __m256i q3l_1 = _mm256_and_si256(_mm256_srli_epi16(q3bits, 2), m3);
const __m256i q3h_1 = _mm256_slli_epi16(_mm256_srli_epi16(_mm256_andnot_si256(hbits, _mm256_slli_epi16(mone, bit)), bit), 2);
++bit;
const __m256i q3l_2 = _mm256_and_si256(_mm256_srli_epi16(q3bits, 4), m3);
const __m256i q3h_2 = _mm256_slli_epi16(_mm256_srli_epi16(_mm256_andnot_si256(hbits, _mm256_slli_epi16(mone, bit)), bit), 2);
++bit;
const __m256i q3l_3 = _mm256_and_si256(_mm256_srli_epi16(q3bits, 6), m3);
const __m256i q3h_3 = _mm256_slli_epi16(_mm256_srli_epi16(_mm256_andnot_si256(hbits, _mm256_slli_epi16(mone, bit)), bit), 2);
++bit;
// load Q8 quants
const __m256i q8_0 = _mm256_loadu_si256((const __m256i*)q8); q8 += 32;
const __m256i q8_1 = _mm256_loadu_si256((const __m256i*)q8); q8 += 32;
const __m256i q8_2 = _mm256_loadu_si256((const __m256i*)q8); q8 += 32;
const __m256i q8_3 = _mm256_loadu_si256((const __m256i*)q8); q8 += 32;
// Dot product: we multiply the 2 low bits and 1 high bit part separately, so we can use _mm256_maddubs_epi16,
// and then subtract. The high bit part has the 2 already subtracted (and so, it is zero if the high bit was not set,
// and 2 if the high bit was set)
__m256i q8s_0 = _mm256_maddubs_epi16(q3h_0, q8_0);
__m256i q8s_1 = _mm256_maddubs_epi16(q3h_1, q8_1);
__m256i q8s_2 = _mm256_maddubs_epi16(q3h_2, q8_2);
__m256i q8s_3 = _mm256_maddubs_epi16(q3h_3, q8_3);
__m256i p16_0 = _mm256_maddubs_epi16(q3l_0, q8_0);
__m256i p16_1 = _mm256_maddubs_epi16(q3l_1, q8_1);
__m256i p16_2 = _mm256_maddubs_epi16(q3l_2, q8_2);
__m256i p16_3 = _mm256_maddubs_epi16(q3l_3, q8_3);
p16_0 = _mm256_sub_epi16(p16_0, q8s_0);
p16_1 = _mm256_sub_epi16(p16_1, q8s_1);
p16_2 = _mm256_sub_epi16(p16_2, q8s_2);
p16_3 = _mm256_sub_epi16(p16_3, q8s_3);
// multiply with scales
p16_0 = _mm256_madd_epi16(_mm256_shuffle_epi8(scales[j], get_scale_shuffle_q3k(is + 0)), p16_0);
p16_1 = _mm256_madd_epi16(_mm256_shuffle_epi8(scales[j], get_scale_shuffle_q3k(is + 1)), p16_1);
p16_2 = _mm256_madd_epi16(_mm256_shuffle_epi8(scales[j], get_scale_shuffle_q3k(is + 2)), p16_2);
p16_3 = _mm256_madd_epi16(_mm256_shuffle_epi8(scales[j], get_scale_shuffle_q3k(is + 3)), p16_3);
// accumulate
p16_0 = _mm256_add_epi32(p16_0, p16_1);
p16_2 = _mm256_add_epi32(p16_2, p16_3);
sumi = _mm256_add_epi32(sumi, _mm256_add_epi32(p16_0, p16_2));
}
// multiply with block scale and accumulate
acc = _mm256_fmadd_ps(_mm256_broadcast_ss(&d), _mm256_cvtepi32_ps(sumi), acc);
}
*s = hsum_float_8(acc);
#elif defined __AVX__
const __m128i m3 = _mm_set1_epi8(3);
const __m128i mone = _mm_set1_epi8(1);
const __m128i m32 = _mm_set1_epi8(32);
const __m128i m2 = _mm_set1_epi8(2);
__m256 acc = _mm256_setzero_ps();
const uint32_t *aux;
for (int i = 0; i < nb; ++i) {
const float d = y[i].d * GGML_FP16_TO_FP32(x[i].d);
const uint8_t * restrict q3 = x[i].qs;
const int8_t * restrict q8 = y[i].qs;
// Set up scales
aux = (const uint32_t *)x[i].scales;
__m128i scales128 = _mm_set_epi32(
((aux[1] >> 4) & kmask2) | (((aux[2] >> 6) & kmask1) << 4),
((aux[0] >> 4) & kmask2) | (((aux[2] >> 4) & kmask1) << 4),
(aux[1] & kmask2) | (((aux[2] >> 2) & kmask1) << 4),
(aux[0] & kmask2) | (((aux[2] >> 0) & kmask1) << 4));
scales128 = _mm_sub_epi8(scales128, m32);
const __m128i scales_0 = _mm_cvtepi8_epi16(scales128);
const __m128i scales_1 = _mm_cvtepi8_epi16(_mm_unpackhi_epi64(scales128, scales128));
const __m128i scales[2] = { scales_0, scales_1 };
// high bit *128*2 from block_q3_K.hmask[QK_K/8]
const __m128i hbits_0 = _mm_loadu_si128((const __m128i*)&x[i].hmask[0]);
const __m128i hbits_1 = _mm_loadu_si128((const __m128i*)&x[i].hmask[16]);
// integer accumulator
__m128i sumi_0 = _mm_setzero_si128();
__m128i sumi_1 = _mm_setzero_si128();
for (int j = 0; j < QK_K/128; ++j) {
// load low 2 bits *64*2 from block_q3_K.qs[QK_K/4]
const __m128i q3bits_0 = _mm_loadu_si128((const __m128i*)q3); q3 += 16;
const __m128i q3bits_1 = _mm_loadu_si128((const __m128i*)q3); q3 += 16;
// prepare low and high bits
const int bit = j << 2;
const __m128i q3l_0 = _mm_and_si128(q3bits_0, m3);
const __m128i q3l_1 = _mm_and_si128(q3bits_1, m3);
const __m128i q3h_0 = _mm_slli_epi16(_mm_srli_epi16(_mm_andnot_si128(hbits_0, _mm_slli_epi16(mone, bit)), bit), 2);
const __m128i q3h_1 = _mm_slli_epi16(_mm_srli_epi16(_mm_andnot_si128(hbits_1, _mm_slli_epi16(mone, bit)), bit), 2);
const __m128i q3l_2 = _mm_and_si128(_mm_srli_epi16(q3bits_0, 2), m3);
const __m128i q3l_3 = _mm_and_si128(_mm_srli_epi16(q3bits_1, 2), m3);
const __m128i q3h_2 = _mm_slli_epi16(_mm_srli_epi16(_mm_andnot_si128(hbits_0, _mm_slli_epi16(mone, bit+1)), bit+1), 2);
const __m128i q3h_3 = _mm_slli_epi16(_mm_srli_epi16(_mm_andnot_si128(hbits_1, _mm_slli_epi16(mone, bit+1)), bit+1), 2);
const __m128i q3l_4 = _mm_and_si128(_mm_srli_epi16(q3bits_0, 4), m3);
const __m128i q3l_5 = _mm_and_si128(_mm_srli_epi16(q3bits_1, 4), m3);
const __m128i q3h_4 = _mm_slli_epi16(_mm_srli_epi16(_mm_andnot_si128(hbits_0, _mm_slli_epi16(mone, bit+2)), bit+2), 2);
const __m128i q3h_5 = _mm_slli_epi16(_mm_srli_epi16(_mm_andnot_si128(hbits_1, _mm_slli_epi16(mone, bit+2)), bit+2), 2);
const __m128i q3l_6 = _mm_and_si128(_mm_srli_epi16(q3bits_0, 6), m3);
const __m128i q3l_7 = _mm_and_si128(_mm_srli_epi16(q3bits_1, 6), m3);
const __m128i q3h_6 = _mm_slli_epi16(_mm_srli_epi16(_mm_andnot_si128(hbits_0, _mm_slli_epi16(mone, bit+3)), bit+3), 2);
const __m128i q3h_7 = _mm_slli_epi16(_mm_srli_epi16(_mm_andnot_si128(hbits_1, _mm_slli_epi16(mone, bit+3)), bit+3), 2);
// load Q8 quants from block_q8_K.qs[QK_K]
const __m128i q8_0 = _mm_loadu_si128((const __m128i*)q8); q8 += 16;
const __m128i q8_1 = _mm_loadu_si128((const __m128i*)q8); q8 += 16;
const __m128i q8_2 = _mm_loadu_si128((const __m128i*)q8); q8 += 16;
const __m128i q8_3 = _mm_loadu_si128((const __m128i*)q8); q8 += 16;
const __m128i q8_4 = _mm_loadu_si128((const __m128i*)q8); q8 += 16;
const __m128i q8_5 = _mm_loadu_si128((const __m128i*)q8); q8 += 16;
const __m128i q8_6 = _mm_loadu_si128((const __m128i*)q8); q8 += 16;
const __m128i q8_7 = _mm_loadu_si128((const __m128i*)q8); q8 += 16;
// Dot product: we multiply the 2 low bits and 1 high bit part separately, so we can use _mm256_maddubs_epi16,
// and then subtract. The high bit part has the 2 already subtracted (and so, it is zero if the high bit was not set,
// and 2 if the high bit was set)
__m128i q8s_0 = _mm_maddubs_epi16(q3h_0, q8_0);
__m128i q8s_1 = _mm_maddubs_epi16(q3h_1, q8_1);
__m128i q8s_2 = _mm_maddubs_epi16(q3h_2, q8_2);
__m128i q8s_3 = _mm_maddubs_epi16(q3h_3, q8_3);
__m128i q8s_4 = _mm_maddubs_epi16(q3h_4, q8_4);
__m128i q8s_5 = _mm_maddubs_epi16(q3h_5, q8_5);
__m128i q8s_6 = _mm_maddubs_epi16(q3h_6, q8_6);
__m128i q8s_7 = _mm_maddubs_epi16(q3h_7, q8_7);
__m128i p16_0 = _mm_maddubs_epi16(q3l_0, q8_0);
__m128i p16_1 = _mm_maddubs_epi16(q3l_1, q8_1);
__m128i p16_2 = _mm_maddubs_epi16(q3l_2, q8_2);
__m128i p16_3 = _mm_maddubs_epi16(q3l_3, q8_3);
__m128i p16_4 = _mm_maddubs_epi16(q3l_4, q8_4);
__m128i p16_5 = _mm_maddubs_epi16(q3l_5, q8_5);
__m128i p16_6 = _mm_maddubs_epi16(q3l_6, q8_6);
__m128i p16_7 = _mm_maddubs_epi16(q3l_7, q8_7);
p16_0 = _mm_sub_epi16(p16_0, q8s_0);
p16_1 = _mm_sub_epi16(p16_1, q8s_1);
p16_2 = _mm_sub_epi16(p16_2, q8s_2);
p16_3 = _mm_sub_epi16(p16_3, q8s_3);
p16_4 = _mm_sub_epi16(p16_4, q8s_4);
p16_5 = _mm_sub_epi16(p16_5, q8s_5);
p16_6 = _mm_sub_epi16(p16_6, q8s_6);
p16_7 = _mm_sub_epi16(p16_7, q8s_7);
// multiply with scales
__m128i shuffle = _mm_set1_epi16(0x0100);
p16_0 = _mm_madd_epi16(_mm_shuffle_epi8(scales[j], shuffle), p16_0);
shuffle = _mm_add_epi16(shuffle, m2);
p16_1 = _mm_madd_epi16(_mm_shuffle_epi8(scales[j], shuffle), p16_1);
shuffle = _mm_add_epi16(shuffle, m2);
p16_2 = _mm_madd_epi16(_mm_shuffle_epi8(scales[j], shuffle), p16_2);
shuffle = _mm_add_epi16(shuffle, m2);
p16_3 = _mm_madd_epi16(_mm_shuffle_epi8(scales[j], shuffle), p16_3);
shuffle = _mm_add_epi16(shuffle, m2);
p16_4 = _mm_madd_epi16(_mm_shuffle_epi8(scales[j], shuffle), p16_4);
shuffle = _mm_add_epi16(shuffle, m2);
p16_5 = _mm_madd_epi16(_mm_shuffle_epi8(scales[j], shuffle), p16_5);
shuffle = _mm_add_epi16(shuffle, m2);
p16_6 = _mm_madd_epi16(_mm_shuffle_epi8(scales[j], shuffle), p16_6);
shuffle = _mm_add_epi16(shuffle, m2);
p16_7 = _mm_madd_epi16(_mm_shuffle_epi8(scales[j], shuffle), p16_7);
// accumulate
p16_0 = _mm_add_epi32(p16_0, p16_1);
p16_2 = _mm_add_epi32(p16_2, p16_3);
p16_4 = _mm_add_epi32(p16_4, p16_5);
p16_6 = _mm_add_epi32(p16_6, p16_7);
sumi_0 = _mm_add_epi32(sumi_0, _mm_add_epi32(p16_0, p16_2));
sumi_1 = _mm_add_epi32(sumi_1, _mm_add_epi32(p16_4, p16_6));
}
// multiply with block scale and accumulate
__m256i sumi = MM256_SET_M128I(sumi_1, sumi_0);
acc = _mm256_add_ps(_mm256_mul_ps(_mm256_broadcast_ss(&d), _mm256_cvtepi32_ps(sumi)), acc);
}
*s = hsum_float_8(acc);
#elif defined __riscv_v_intrinsic
uint32_t aux[3];
uint32_t utmp[4];
float sumf = 0;
for (int i = 0; i < nb; ++i) {
const uint8_t * restrict q3 = x[i].qs;
const uint8_t * restrict qh = x[i].hmask;
const int8_t * restrict q8 = y[i].qs;
memcpy(aux, x[i].scales, 12);
utmp[3] = ((aux[1] >> 4) & kmask2) | (((aux[2] >> 6) & kmask1) << 4);
utmp[2] = ((aux[0] >> 4) & kmask2) | (((aux[2] >> 4) & kmask1) << 4);
utmp[1] = (aux[1] & kmask2) | (((aux[2] >> 2) & kmask1) << 4);
utmp[0] = (aux[0] & kmask2) | (((aux[2] >> 0) & kmask1) << 4);
int8_t * scale = (int8_t *)utmp;
for (int j = 0; j < 16; ++j) scale[j] -= 32;
size_t vl = 32;
uint8_t m = 1;
vint32m1_t vzero = __riscv_vmv_v_x_i32m1(0, 1);
vuint8m1_t vqh = __riscv_vle8_v_u8m1(qh, vl);
int sum_t = 0;
for (int j = 0; j < QK_K; j += 128) {
vl = 32;
// load Q3
vuint8m1_t q3_x = __riscv_vle8_v_u8m1(q3, vl);
vint8m1_t q3_0 = __riscv_vreinterpret_v_u8m1_i8m1(__riscv_vand_vx_u8m1(q3_x, 0x03, vl));
vint8m1_t q3_1 = __riscv_vreinterpret_v_u8m1_i8m1(__riscv_vand_vx_u8m1(__riscv_vsrl_vx_u8m1(q3_x, 0x2, vl), 0x03 , vl));
vint8m1_t q3_2 = __riscv_vreinterpret_v_u8m1_i8m1(__riscv_vand_vx_u8m1(__riscv_vsrl_vx_u8m1(q3_x, 0x4, vl), 0x03 , vl));
vint8m1_t q3_3 = __riscv_vreinterpret_v_u8m1_i8m1(__riscv_vand_vx_u8m1(__riscv_vsrl_vx_u8m1(q3_x, 0x6, vl), 0x03 , vl));
// compute mask for subtraction
vuint8m1_t qh_m0 = __riscv_vand_vx_u8m1(vqh, m, vl);
vbool8_t vmask_0 = __riscv_vmseq_vx_u8m1_b8(qh_m0, 0, vl);
vint8m1_t q3_m0 = __riscv_vsub_vx_i8m1_mu(vmask_0, q3_0, q3_0, 0x4, vl);
m <<= 1;
vuint8m1_t qh_m1 = __riscv_vand_vx_u8m1(vqh, m, vl);
vbool8_t vmask_1 = __riscv_vmseq_vx_u8m1_b8(qh_m1, 0, vl);
vint8m1_t q3_m1 = __riscv_vsub_vx_i8m1_mu(vmask_1, q3_1, q3_1, 0x4, vl);
m <<= 1;
vuint8m1_t qh_m2 = __riscv_vand_vx_u8m1(vqh, m, vl);
vbool8_t vmask_2 = __riscv_vmseq_vx_u8m1_b8(qh_m2, 0, vl);
vint8m1_t q3_m2 = __riscv_vsub_vx_i8m1_mu(vmask_2, q3_2, q3_2, 0x4, vl);
m <<= 1;
vuint8m1_t qh_m3 = __riscv_vand_vx_u8m1(vqh, m, vl);
vbool8_t vmask_3 = __riscv_vmseq_vx_u8m1_b8(qh_m3, 0, vl);
vint8m1_t q3_m3 = __riscv_vsub_vx_i8m1_mu(vmask_3, q3_3, q3_3, 0x4, vl);
m <<= 1;
// load Q8 and take product with Q3
vint16m2_t a0 = __riscv_vwmul_vv_i16m2(q3_m0, __riscv_vle8_v_i8m1(q8, vl), vl);
vint16m2_t a1 = __riscv_vwmul_vv_i16m2(q3_m1, __riscv_vle8_v_i8m1(q8+32, vl), vl);
vint16m2_t a2 = __riscv_vwmul_vv_i16m2(q3_m2, __riscv_vle8_v_i8m1(q8+64, vl), vl);
vint16m2_t a3 = __riscv_vwmul_vv_i16m2(q3_m3, __riscv_vle8_v_i8m1(q8+96, vl), vl);
vl = 16;
// retrieve lane to multiply with scale
vint32m2_t aux0_0 = __riscv_vwmul_vx_i32m2(__riscv_vget_v_i16m2_i16m1(a0, 0), (scale[0]), vl);
vint32m2_t aux0_1 = __riscv_vwmul_vx_i32m2(__riscv_vget_v_i16m2_i16m1(a0, 1), (scale[1]), vl);
vint32m2_t aux1_0 = __riscv_vwmul_vx_i32m2(__riscv_vget_v_i16m2_i16m1(a1, 0), (scale[2]), vl);
vint32m2_t aux1_1 = __riscv_vwmul_vx_i32m2(__riscv_vget_v_i16m2_i16m1(a1, 1), (scale[3]), vl);
vint32m2_t aux2_0 = __riscv_vwmul_vx_i32m2(__riscv_vget_v_i16m2_i16m1(a2, 0), (scale[4]), vl);
vint32m2_t aux2_1 = __riscv_vwmul_vx_i32m2(__riscv_vget_v_i16m2_i16m1(a2, 1), (scale[5]), vl);
vint32m2_t aux3_0 = __riscv_vwmul_vx_i32m2(__riscv_vget_v_i16m2_i16m1(a3, 0), (scale[6]), vl);
vint32m2_t aux3_1 = __riscv_vwmul_vx_i32m2(__riscv_vget_v_i16m2_i16m1(a3, 1), (scale[7]), vl);
vint32m1_t isum0 = __riscv_vredsum_vs_i32m2_i32m1(__riscv_vadd_vv_i32m2(aux0_0, aux0_1, vl), vzero, vl);
vint32m1_t isum1 = __riscv_vredsum_vs_i32m2_i32m1(__riscv_vadd_vv_i32m2(aux1_0, aux1_1, vl), isum0, vl);
vint32m1_t isum2 = __riscv_vredsum_vs_i32m2_i32m1(__riscv_vadd_vv_i32m2(aux2_0, aux2_1, vl), isum1, vl);
vint32m1_t isum3 = __riscv_vredsum_vs_i32m2_i32m1(__riscv_vadd_vv_i32m2(aux3_0, aux3_1, vl), isum2, vl);
sum_t += __riscv_vmv_x_s_i32m1_i32(isum3);
q3 += 32; q8 += 128; scale += 8;
}
const float d = GGML_FP16_TO_FP32(x[i].d) * y[i].d;
sumf += d*sum_t;
}
*s = sumf;
#elif defined(__POWER9_VECTOR__)
const vector signed char lowMask = vec_splats((signed char)0x3);
const vector signed char lowMask1 = vec_splats((int8_t)0xf);
const vector signed char lowMask2 = vec_splats((int8_t)0x30);
const vector int v0 = vec_splats((int32_t)0);
const vector signed char v1 = vec_splats((signed char)0x1);
const vector unsigned char v2 = vec_splats((unsigned char)0x2);
const vector unsigned char v3 = vec_splats((unsigned char)0x3);
const vector unsigned char v4 = vec_splats((unsigned char)0x4);
const vector unsigned char v6 = vec_splats((unsigned char)0x6);
const vector signed char off = vec_splats((signed char)0x20);
vector float vsumf0 = vec_splats(0.0f);
vector float vsumf1 = vec_splats(0.0f);
vector float vsumf2 = vec_splats(0.0f);
vector float vsumf3 = vec_splats(0.0f);
for (int i = 0; i < nb; ++i) {
vector float vxd = vec_splats(GGML_FP16_TO_FP32(x[i].d));
vector float vyd = vec_splats(y[i].d);
vector float vd = vec_mul(vxd, vyd);
UNUSED(kmask1);
UNUSED(kmask2);
vector signed char u0 = (vector signed char)vec_xl_len(x[i].scales, 8);
vector signed char u1 = vec_and(u0, lowMask1);
vector signed char u2 = (vector signed char)vec_xl_len(x[i].scales + 8, 4);
vector signed char u3 = (vector signed char)vec_mergeh((vector signed int)u2, (vector signed int)vec_sr(u2, v2));
vector signed char u30 = vec_sl(vec_and(u3, lowMask), v4);
vector signed char u31 = vec_and(u3, lowMask2);
u1 = vec_or(u1, u30);
u2 = vec_or(vec_sr(u0, v4), u31);
vector signed char vscales = (vector signed char)vec_mergeh((vector signed long long)u1, (vector signed long long)u2);
vector signed char qxhs0 = (vector signed char)vec_xl( 0, x[i].hmask);
vector signed char qxhs1 = (vector signed char)vec_xl(16, x[i].hmask);
vscales = vec_sub(vscales, off);
vector signed int vsumi0 = v0;
vector signed int vsumi1 = v0;
vector signed int vsumi2 = v0;
vector signed int vsumi3 = v0;
vector signed int vsumi4 = v0;
vector signed int vsumi5 = v0;
vector signed int vsumi6 = v0;
vector signed int vsumi7 = v0;
const uint8_t * restrict q3 = x[i].qs;
const int8_t * restrict q8 = y[i].qs;
for (int j = 0; j < QK_K/128; ++j) {
__builtin_prefetch(q3, 0, 1);
__builtin_prefetch(q8, 0, 1);
vector signed char qxs0 = (vector signed char)vec_xl( 0, q3);
vector signed char qxs1 = (vector signed char)vec_xl(16, q3);
q3 += 32;
//the low 2 bits
vector signed char qxs00 = vec_and(qxs0, lowMask);
vector signed char qxs01 = vec_and(vec_sr(qxs0, v2), lowMask);
vector signed char qxs02 = vec_and(vec_sr(qxs0, v4), lowMask);
vector signed char qxs03 = vec_and(vec_sr(qxs0, v6), lowMask);
vector signed char qxs10 = vec_and(qxs1, lowMask);
vector signed char qxs11 = vec_and(vec_sr(qxs1, v2), lowMask);
vector signed char qxs12 = vec_and(vec_sr(qxs1, v4), lowMask);
vector signed char qxs13 = vec_and(vec_sr(qxs1, v6), lowMask);
//the 3rd bit
vector signed char qxh00 = vec_sl(vec_andc(v1, qxhs0), v2);
vector signed char qxh01 = vec_sl(vec_andc(v1, vec_sr(qxhs0, (vector unsigned char)v1)), v2);
vector signed char qxh02 = vec_sl(vec_andc(v1, vec_sr(qxhs0, v2)), v2);
vector signed char qxh03 = vec_sl(vec_andc(v1, vec_sr(qxhs0, v3)), v2);
vector signed char qxh10 = vec_sl(vec_andc(v1, qxhs1), v2);
vector signed char qxh11 = vec_sl(vec_andc(v1, vec_sr(qxhs1, (vector unsigned char)v1)), v2);
vector signed char qxh12 = vec_sl(vec_andc(v1, vec_sr(qxhs1, v2)), v2);
vector signed char qxh13 = vec_sl(vec_andc(v1, vec_sr(qxhs1, v3)), v2);
qxhs0 = vec_sr(qxhs0, v4);
qxhs1 = vec_sr(qxhs1, v4);
vector signed char q3x00 = vec_sub(qxs00, qxh00);
vector signed char q3x01 = vec_sub(qxs01, qxh01);
vector signed char q3x02 = vec_sub(qxs02, qxh02);
vector signed char q3x03 = vec_sub(qxs03, qxh03);
vector signed char q3x10 = vec_sub(qxs10, qxh10);
vector signed char q3x11 = vec_sub(qxs11, qxh11);
vector signed char q3x12 = vec_sub(qxs12, qxh12);
vector signed char q3x13 = vec_sub(qxs13, qxh13);
vector signed char q8y00 = vec_xl( 0, q8);
vector signed char q8y10 = vec_xl( 16, q8);
vector signed char q8y01 = vec_xl( 32, q8);
vector signed char q8y11 = vec_xl( 48, q8);
vector signed char q8y02 = vec_xl( 64, q8);
vector signed char q8y12 = vec_xl( 80, q8);
vector signed char q8y03 = vec_xl( 96, q8);
vector signed char q8y13 = vec_xl(112, q8);
q8 += 128;
vector signed short vscales_h = vec_unpackh(vscales);
vector signed short vs0 = vec_splat(vscales_h, 0);
vector signed short vs1 = vec_splat(vscales_h, 1);
vector signed short vs2 = vec_splat(vscales_h, 2);
vector signed short vs3 = vec_splat(vscales_h, 3);
vector signed short vs4 = vec_splat(vscales_h, 4);
vector signed short vs5 = vec_splat(vscales_h, 5);
vector signed short vs6 = vec_splat(vscales_h, 6);
vector signed short vs7 = vec_splat(vscales_h, 7);
vscales = vec_sld(vscales, vscales, 8);
vector signed short qv00 = vec_add(vec_mule(q3x00, q8y00), vec_mulo(q3x00, q8y00));
vector signed short qv01 = vec_add(vec_mule(q3x01, q8y01), vec_mulo(q3x01, q8y01));
vector signed short qv02 = vec_add(vec_mule(q3x02, q8y02), vec_mulo(q3x02, q8y02));
vector signed short qv03 = vec_add(vec_mule(q3x03, q8y03), vec_mulo(q3x03, q8y03));
vector signed short qv10 = vec_add(vec_mule(q3x10, q8y10), vec_mulo(q3x10, q8y10));
vector signed short qv11 = vec_add(vec_mule(q3x11, q8y11), vec_mulo(q3x11, q8y11));
vector signed short qv12 = vec_add(vec_mule(q3x12, q8y12), vec_mulo(q3x12, q8y12));
vector signed short qv13 = vec_add(vec_mule(q3x13, q8y13), vec_mulo(q3x13, q8y13));
vsumi0 = vec_msum(qv00, vs0, vsumi0);
vsumi1 = vec_msum(qv01, vs2, vsumi1);
vsumi2 = vec_msum(qv02, vs4, vsumi2);
vsumi3 = vec_msum(qv03, vs6, vsumi3);
vsumi4 = vec_msum(qv10, vs1, vsumi4);
vsumi5 = vec_msum(qv11, vs3, vsumi5);
vsumi6 = vec_msum(qv12, vs5, vsumi6);
vsumi7 = vec_msum(qv13, vs7, vsumi7);
}
vsumi0 = vec_add(vsumi0, vsumi4);
vsumi1 = vec_add(vsumi1, vsumi5);
vsumi2 = vec_add(vsumi2, vsumi6);
vsumi3 = vec_add(vsumi3, vsumi7);
vsumf0 = vec_madd(vec_ctf(vsumi0, 0), vd, vsumf0);
vsumf1 = vec_madd(vec_ctf(vsumi1, 0), vd, vsumf1);
vsumf2 = vec_madd(vec_ctf(vsumi2, 0), vd, vsumf2);
vsumf3 = vec_madd(vec_ctf(vsumi3, 0), vd, vsumf3);
}
vsumf0 = vec_add(vsumf0, vsumf2);
vsumf1 = vec_add(vsumf1, vsumf3);
vsumf0 = vec_add(vsumf0, vsumf1);
vsumf0 = vec_add(vsumf0, vec_sld(vsumf0, vsumf0, 4));
vsumf0 = vec_add(vsumf0, vec_sld(vsumf0, vsumf0, 8));
*s = vec_extract(vsumf0, 0);
#elif defined __loongarch_asx
const __m256i m3 = __lasx_xvreplgr2vr_b(3);
const __m256i mone = __lasx_xvreplgr2vr_b(1);
const __m128i m32 = __lsx_vreplgr2vr_b(32);
__m256 acc = (__m256)__lasx_xvldi(0);
uint32_t aux[3];
for (int i = 0; i < nb; ++i) {
const float d = y[i].d * GGML_FP16_TO_FP32(x[i].d);
const uint8_t * restrict q3 = x[i].qs;
const int8_t * restrict q8 = y[i].qs;
// Set up scales
memcpy(aux, x[i].scales, 12);
__m128i scales128 = lsx_set_w(
((aux[1] >> 4) & kmask2) | (((aux[2] >> 6) & kmask1) << 4),
((aux[0] >> 4) & kmask2) | (((aux[2] >> 4) & kmask1) << 4),
(aux[1] & kmask2) | (((aux[2] >> 2) & kmask1) << 4),
(aux[0] & kmask2) | (((aux[2] >> 0) & kmask1) << 4));
scales128 = __lsx_vsub_b(scales128, m32);
const __m256i all_scales = lasx_ext8_16(scales128);
const __m128i l_scales = lasx_extracti128(all_scales, 0);
const __m128i h_scales = lasx_extracti128(all_scales, 1);
const __m256i scales[2] = {lasx_insertf128(l_scales, l_scales), lasx_insertf128(h_scales, h_scales)};
// high bit
const __m256i hbits = __lasx_xvld((const __m256i*)x[i].hmask, 0);
// integer accumulator
__m256i sumi = __lasx_xvldi(0);
int bit = 0;
int is = 0;
__m256i xvbit;
for (int j = 0; j < QK_K/128; ++j) {
// load low 2 bits
const __m256i q3bits = __lasx_xvld((const __m256i*)q3, 0); q3 += 32;
xvbit = __lasx_xvreplgr2vr_h(bit);
// prepare low and high bits
const __m256i q3l_0 = __lasx_xvand_v(q3bits, m3);
const __m256i q3h_0 = __lasx_xvslli_h(__lasx_xvsrl_h(__lasx_xvandn_v(hbits, __lasx_xvsll_h(mone, xvbit)), xvbit), 2);
++bit;
xvbit = __lasx_xvreplgr2vr_h(bit);
const __m256i q3l_1 = __lasx_xvand_v(__lasx_xvsrli_h(q3bits, 2), m3);
const __m256i q3h_1 = __lasx_xvslli_h(__lasx_xvsrl_h(__lasx_xvandn_v(hbits, __lasx_xvsll_h(mone, xvbit)), xvbit), 2);
++bit;
xvbit = __lasx_xvreplgr2vr_h(bit);
const __m256i q3l_2 = __lasx_xvand_v(__lasx_xvsrli_h(q3bits, 4), m3);
const __m256i q3h_2 = __lasx_xvslli_h(__lasx_xvsrl_h(__lasx_xvandn_v(hbits, __lasx_xvsll_h(mone, xvbit)), xvbit), 2);
++bit;
xvbit = __lasx_xvreplgr2vr_h(bit);
const __m256i q3l_3 = __lasx_xvand_v(__lasx_xvsrli_h(q3bits, 6), m3);
const __m256i q3h_3 = __lasx_xvslli_h(__lasx_xvsrl_h(__lasx_xvandn_v(hbits, __lasx_xvsll_h(mone, xvbit)), xvbit), 2);
++bit;
// load Q8 quants
const __m256i q8_0 = __lasx_xvld((const __m256i*)q8, 0); q8 += 32;
const __m256i q8_1 = __lasx_xvld((const __m256i*)q8, 0); q8 += 32;
const __m256i q8_2 = __lasx_xvld((const __m256i*)q8, 0); q8 += 32;
const __m256i q8_3 = __lasx_xvld((const __m256i*)q8, 0); q8 += 32;
// Dot product: we multiply the 2 low bits and 1 high bit part separately, so we can use lasx_maddubs_h,
// and then subtract. The high bit part has the 2 already subtracted (and so, it is zero if the high bit was not set,
// and 2 if the high bit was set)
__m256i q8s_0 = lasx_maddubs_h(q3h_0, q8_0);
__m256i q8s_1 = lasx_maddubs_h(q3h_1, q8_1);
__m256i q8s_2 = lasx_maddubs_h(q3h_2, q8_2);
__m256i q8s_3 = lasx_maddubs_h(q3h_3, q8_3);
__m256i p16_0 = lasx_maddubs_h(q3l_0, q8_0);
__m256i p16_1 = lasx_maddubs_h(q3l_1, q8_1);
__m256i p16_2 = lasx_maddubs_h(q3l_2, q8_2);
__m256i p16_3 = lasx_maddubs_h(q3l_3, q8_3);
p16_0 = __lasx_xvsub_h(p16_0, q8s_0);
p16_1 = __lasx_xvsub_h(p16_1, q8s_1);
p16_2 = __lasx_xvsub_h(p16_2, q8s_2);
p16_3 = __lasx_xvsub_h(p16_3, q8s_3);
// multiply with scales
p16_0 = lasx_madd_h(lasx_shuffle_b(scales[j], get_scale_shuffle_q3k(is + 0)), p16_0);
p16_1 = lasx_madd_h(lasx_shuffle_b(scales[j], get_scale_shuffle_q3k(is + 1)), p16_1);
p16_2 = lasx_madd_h(lasx_shuffle_b(scales[j], get_scale_shuffle_q3k(is + 2)), p16_2);
p16_3 = lasx_madd_h(lasx_shuffle_b(scales[j], get_scale_shuffle_q3k(is + 3)), p16_3);
// accumulate
p16_0 = __lasx_xvadd_w(p16_0, p16_1);
p16_2 = __lasx_xvadd_w(p16_2, p16_3);
sumi = __lasx_xvadd_w(sumi, __lasx_xvadd_w(p16_0, p16_2));
}
// multiply with block scale and accumulate
acc = __lasx_xvfmadd_s(__lasx_xvreplfr2vr_s(d), __lasx_xvffint_s_w(sumi), acc);//FIXME
}
*s = hsum_float_8(acc);
#else
// scalar version
// This function is written like this so the compiler can manage to vectorize most of it
// Using -Ofast, GCC and clang manage to produce code that is within a factor of 2 or so from the
// manually vectorized version above. Every other version I tried would run at least 4 times slower.
// The ideal situation would be if we could just write the code once, and the compiler would
// automatically produce the best possible set of machine instructions, instead of us having to manually
// write vectorized versions for AVX, ARM_NEON, etc.
int8_t aux8[QK_K];
int16_t aux16[8];
float sums [8];
int32_t aux32[8];
memset(sums, 0, 8*sizeof(float));
uint32_t auxs[4];
const int8_t * scales = (const int8_t*)auxs;
float sumf = 0;
for (int i = 0; i < nb; ++i) {
const uint8_t * restrict q3 = x[i].qs;
const uint8_t * restrict hm = x[i].hmask;
const int8_t * restrict q8 = y[i].qs;
memset(aux32, 0, 8*sizeof(int32_t));
int8_t * restrict a = aux8;
uint8_t m = 1;
for (int j = 0; j < QK_K; j += 128) {
for (int l = 0; l < 32; ++l) a[l] = q3[l] & 3;
for (int l = 0; l < 32; ++l) a[l] -= (hm[l] & m ? 0 : 4);
a += 32; m <<= 1;
for (int l = 0; l < 32; ++l) a[l] = (q3[l] >> 2) & 3;
for (int l = 0; l < 32; ++l) a[l] -= (hm[l] & m ? 0 : 4);
a += 32; m <<= 1;
for (int l = 0; l < 32; ++l) a[l] = (q3[l] >> 4) & 3;
for (int l = 0; l < 32; ++l) a[l] -= (hm[l] & m ? 0 : 4);
a += 32; m <<= 1;
for (int l = 0; l < 32; ++l) a[l] = (q3[l] >> 6) & 3;
for (int l = 0; l < 32; ++l) a[l] -= (hm[l] & m ? 0 : 4);
a += 32; m <<= 1;
q3 += 32;
}
a = aux8;
memcpy(auxs, x[i].scales, 12);
uint32_t tmp = auxs[2];
auxs[2] = ((auxs[0] >> 4) & kmask2) | (((tmp >> 4) & kmask1) << 4);
auxs[3] = ((auxs[1] >> 4) & kmask2) | (((tmp >> 6) & kmask1) << 4);
auxs[0] = (auxs[0] & kmask2) | (((tmp >> 0) & kmask1) << 4);
auxs[1] = (auxs[1] & kmask2) | (((tmp >> 2) & kmask1) << 4);
for (int j = 0; j < QK_K/16; ++j) {
for (int l = 0; l < 8; ++l) aux16[l] = q8[l] * a[l];
for (int l = 0; l < 8; ++l) aux32[l] += (scales[j] - 32) * aux16[l];
q8 += 8; a += 8;
for (int l = 0; l < 8; ++l) aux16[l] = q8[l] * a[l];
for (int l = 0; l < 8; ++l) aux32[l] += (scales[j] - 32) * aux16[l];
q8 += 8; a += 8;
}
const float d = GGML_FP16_TO_FP32(x[i].d) * y[i].d;
for (int l = 0; l < 8; ++l) sums[l] += d * aux32[l];
}
for (int l = 0; l < 8; ++l) sumf += sums[l];
*s = sumf;
#endif
} | O2 | c | ggml_vec_dot_q3_K_q8_K:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
andq $-0x20, %rsp
subq $0x40, %rsp
movl %edi, %eax
movl $0x100, %edi # imm = 0x100
cltd
idivl %edi
movl %eax, %edx
sarl $0x1f, %edx
andnl %eax, %edx, %eax
leaq 0x20(%rcx), %rdx
vxorps %xmm0, %xmm0, %xmm0
xorl %edi, %edi
vpmovsxbq 0x1a915(%rip), %xmm18 # 0x48501
vpbroadcastq 0x1a8b3(%rip), %xmm2 # 0x484a8
vmovdqa64 0x232c1(%rip), %xmm19 # 0x50ec0
movq 0x2b36a(%rip), %r8 # 0x58f70
vmovdqa 0x232c2(%rip), %xmm4 # 0x50ed0
vpbroadcastb 0x1a8e5(%rip), %xmm5 # 0x484fc
vpcmpeqd %ymm6, %ymm6, %ymm6
vpbroadcastw 0x1a8da(%rip), %ymm7 # 0x484fe
vpbroadcastb 0x1a8d3(%rip), %ymm8 # 0x48500
vmovdqa 0x1a6cb(%rip), %ymm9 # 0x48300
vmovdqa 0x1a6e3(%rip), %ymm10 # 0x48320
vmovdqa 0x1a6fb(%rip), %ymm11 # 0x48340
vmovdqa 0x1a713(%rip), %ymm12 # 0x48360
cmpq %rax, %rdi
je 0x2de9b
imulq $0x124, %rdi, %r10 # imm = 0x124
addq %r9, %r10
addq $0x4, %r10
vmovss -0x4(%r10), %xmm13
imulq $0x6e, %rdi, %r11
movzwl 0x6c(%rcx,%r11), %ebx
vmovss (%r8,%rbx,4), %xmm14
movl 0x60(%rcx,%r11), %ebx
movq 0x64(%rcx,%r11), %r14
vmovq %r14, %xmm15
shrl $0x4, %r14d
vmovd %ebx, %xmm16
vpsrlq $0x20, %xmm15, %xmm17
vpermt2d %xmm16, %xmm18, %xmm15
vpinsrd $0x3, %r14d, %xmm15, %xmm15
vpinsrd $0x1, %ebx, %xmm17, %xmm16
vpshufd $0x10, %xmm16, %xmm16 # xmm16 = xmm16[0,0,1,0]
vpsllvd %xmm2, %xmm16, %xmm1
vpsrlvd %xmm2, %xmm16, %xmm3
vpblendd $0xc, %xmm3, %xmm1, %xmm1 # xmm1 = xmm1[0,1],xmm3[2,3]
vpandd %xmm19, %xmm1, %xmm1
vpternlogd $0xf8, %xmm4, %xmm15, %xmm1
vpaddb %xmm5, %xmm1, %xmm1
vpmovsxbw %xmm1, %ymm1
vpermq $0x44, %ymm1, %ymm3 # ymm3 = ymm1[0,1,0,1]
vmovdqa %ymm3, (%rsp)
vpermq $0xee, %ymm1, %ymm1 # ymm1 = ymm1[2,3,2,3]
vmovdqa %ymm1, 0x20(%rsp)
vpxorq (%rcx,%r11), %ymm6, %ymm16
vpxor %xmm15, %xmm15, %xmm15
xorl %r11d, %r11d
cmpq $0x8, %r11
je 0x2de7b
vmovdqu (%rdx,%r11,8), %ymm1
vmovd %r11d, %xmm3
vpsllw %xmm3, %ymm7, %ymm17
vpandq %ymm16, %ymm17, %ymm17
vpsrlw %xmm3, %ymm17, %ymm3
vpsllw $0x2, %ymm3, %ymm3
leal 0x1(%r11), %ebx
vmovd %ebx, %xmm17
vpsllw %xmm17, %ymm7, %ymm20
vpandq %ymm16, %ymm20, %ymm20
vpsrlw %xmm17, %ymm20, %ymm17
vpsrlw $0x2, %ymm1, %ymm20
vpsllw $0x2, %ymm17, %ymm17
leal 0x2(%r11), %ebx
vmovd %ebx, %xmm21
vpsllw %xmm21, %ymm7, %ymm22
vpsrlw $0x4, %ymm1, %ymm23
vpandq %ymm16, %ymm22, %ymm22
vpsrlw %xmm21, %ymm22, %ymm21
vpsllw $0x2, %ymm21, %ymm21
leal 0x3(%r11), %ebx
vmovd %ebx, %xmm22
vpsllw %xmm22, %ymm7, %ymm24
vpandq %ymm16, %ymm24, %ymm24
vpsrlw %xmm22, %ymm24, %ymm22
vpsrlw $0x6, %ymm1, %ymm24
vpsllw $0x2, %ymm22, %ymm22
vmovdqu64 (%r10), %ymm25
vmovdqu64 0x20(%r10), %ymm26
vmovdqu64 0x40(%r10), %ymm27
vmovdqu64 0x60(%r10), %ymm28
vpmaddubsw %ymm25, %ymm3, %ymm3
vpmaddubsw %ymm26, %ymm17, %ymm17
vpmaddubsw %ymm27, %ymm21, %ymm21
vpmaddubsw %ymm28, %ymm22, %ymm22
vpand %ymm1, %ymm8, %ymm1
vpmaddubsw %ymm25, %ymm1, %ymm1
vpsubw %ymm3, %ymm1, %ymm1
vpandq %ymm8, %ymm20, %ymm3
vpmaddubsw %ymm26, %ymm3, %ymm3
vpsubw %ymm17, %ymm3, %ymm3
vpandq %ymm8, %ymm23, %ymm17
vpmaddubsw %ymm27, %ymm17, %ymm17
vpsubw %ymm21, %ymm17, %ymm17
vpandq %ymm8, %ymm24, %ymm20
vpmaddubsw %ymm28, %ymm20, %ymm20
vpsubw %ymm22, %ymm20, %ymm20
vmovdqa64 (%rsp,%r11,8), %ymm21
vpshufb %ymm9, %ymm21, %ymm22
vpmaddwd %ymm1, %ymm22, %ymm1
vpshufb %ymm10, %ymm21, %ymm22
vpmaddwd %ymm3, %ymm22, %ymm3
vpshufb %ymm11, %ymm21, %ymm22
vpmaddwd %ymm17, %ymm22, %ymm17
vpaddd %ymm17, %ymm3, %ymm3
vpshufb %ymm12, %ymm21, %ymm17
vpmaddwd %ymm20, %ymm17, %ymm17
vpaddd %ymm1, %ymm15, %ymm1
vpaddd %ymm3, %ymm1, %ymm1
vpaddd %ymm17, %ymm1, %ymm15
addq $0x4, %r11
subq $-0x80, %r10
jmp 0x2dd02
vmulss %xmm14, %xmm13, %xmm1
vbroadcastss %xmm1, %ymm1
vcvtdq2ps %ymm15, %ymm3
vfmadd231ps %ymm3, %ymm1, %ymm0 # ymm0 = (ymm1 * ymm3) + ymm0
incq %rdi
addq $0x6e, %rdx
jmp 0x2dc4d
vextractf128 $0x1, %ymm0, %xmm1
vaddps %xmm0, %xmm1, %xmm0
vshufpd $0x1, %xmm0, %xmm0, %xmm1 # xmm1 = xmm0[1,0]
vaddps %xmm1, %xmm0, %xmm0
vhaddps %xmm0, %xmm0, %xmm0
vmovss %xmm0, (%rsi)
leaq -0x10(%rbp), %rsp
popq %rbx
popq %r14
popq %rbp
vzeroupper
retq
| ggml_vec_dot_q3_K_q8_K:
push rbp
mov rbp, rsp
push r14
push rbx
and rsp, 0FFFFFFFFFFFFFFE0h
sub rsp, 40h
mov eax, edi
mov edi, 100h
cdq
idiv edi
mov edx, eax
sar edx, 1Fh
andn eax, edx, eax
lea rdx, [rcx+20h]
vxorps xmm0, xmm0, xmm0
xor edi, edi
vpmovsxbq xmm18, cs:word_48501
vpbroadcastq xmm2, cs:qword_484A8
vmovdqa64 xmm19, cs:xmmword_50EC0
mov r8, cs:ggml_table_f32_f16_ptr
vmovdqa xmm4, cs:xmmword_50ED0
vpbroadcastb xmm5, cs:byte_484FC
vpcmpeqd ymm6, ymm6, ymm6
vpbroadcastw ymm7, cs:word_484FE
vpbroadcastb ymm8, cs:byte_48500
vmovdqa ymm9, cs:ymmword_48300
vmovdqa ymm10, cs:ymmword_48320
vmovdqa ymm11, cs:ymmword_48340
vmovdqa ymm12, cs:ymmword_48360
loc_2DC4D:
cmp rdi, rax
jz loc_2DE9B
imul r10, rdi, 124h
add r10, r9
add r10, 4
vmovss xmm13, dword ptr [r10-4]
imul r11, rdi, 6Eh ; 'n'
movzx ebx, word ptr [rcx+r11+6Ch]
vmovss xmm14, dword ptr [r8+rbx*4]
mov ebx, [rcx+r11+60h]
mov r14, [rcx+r11+64h]
vmovq xmm15, r14
shr r14d, 4
vmovd xmm16, ebx
vpsrlq xmm17, xmm15, 20h ; ' '
vpermt2d xmm15, xmm18, xmm16
vpinsrd xmm15, xmm15, r14d, 3
vpinsrd xmm16, xmm17, ebx, 1
vpshufd xmm16, xmm16, 10h
vpsllvd xmm1, xmm16, xmm2
vpsrlvd xmm3, xmm16, xmm2
vpblendd xmm1, xmm1, xmm3, 0Ch
vpandd xmm1, xmm1, xmm19
vpternlogd xmm1, xmm15, xmm4, 0F8h
vpaddb xmm1, xmm1, xmm5
vpmovsxbw ymm1, xmm1
vpermq ymm3, ymm1, 44h ; 'D'
vmovdqa [rsp+50h+var_50], ymm3
vpermq ymm1, ymm1, 0EEh
vmovdqa [rsp+50h+var_30], ymm1
vpxorq ymm16, ymm6, ymmword ptr [rcx+r11]
vpxor xmm15, xmm15, xmm15
xor r11d, r11d
loc_2DD02:
cmp r11, 8
jz loc_2DE7B
vmovdqu ymm1, ymmword ptr [rdx+r11*8]
vmovd xmm3, r11d
vpsllw ymm17, ymm7, xmm3
vpandq ymm17, ymm17, ymm16
vpsrlw ymm3, ymm17, xmm3
vpsllw ymm3, ymm3, 2
lea ebx, [r11+1]
vmovd xmm17, ebx
vpsllw ymm20, ymm7, xmm17
vpandq ymm20, ymm20, ymm16
vpsrlw ymm17, ymm20, xmm17
vpsrlw ymm20, ymm1, 2
vpsllw ymm17, ymm17, 2
lea ebx, [r11+2]
vmovd xmm21, ebx
vpsllw ymm22, ymm7, xmm21
vpsrlw ymm23, ymm1, 4
vpandq ymm22, ymm22, ymm16
vpsrlw ymm21, ymm22, xmm21
vpsllw ymm21, ymm21, 2
lea ebx, [r11+3]
vmovd xmm22, ebx
vpsllw ymm24, ymm7, xmm22
vpandq ymm24, ymm24, ymm16
vpsrlw ymm22, ymm24, xmm22
vpsrlw ymm24, ymm1, 6
vpsllw ymm22, ymm22, 2
vmovdqu64 ymm25, ymmword ptr [r10]
vmovdqu64 ymm26, ymmword ptr [r10+20h]
vmovdqu64 ymm27, ymmword ptr [r10+40h]
vmovdqu64 ymm28, ymmword ptr [r10+60h]
vpmaddubsw ymm3, ymm3, ymm25
vpmaddubsw ymm17, ymm17, ymm26
vpmaddubsw ymm21, ymm21, ymm27
vpmaddubsw ymm22, ymm22, ymm28
vpand ymm1, ymm8, ymm1
vpmaddubsw ymm1, ymm1, ymm25
vpsubw ymm1, ymm1, ymm3
vpandq ymm3, ymm20, ymm8
vpmaddubsw ymm3, ymm3, ymm26
vpsubw ymm3, ymm3, ymm17
vpandq ymm17, ymm23, ymm8
vpmaddubsw ymm17, ymm17, ymm27
vpsubw ymm17, ymm17, ymm21
vpandq ymm20, ymm24, ymm8
vpmaddubsw ymm20, ymm20, ymm28
vpsubw ymm20, ymm20, ymm22
vmovdqa64 ymm21, [rsp+r11*8+50h+var_50]
vpshufb ymm22, ymm21, ymm9
vpmaddwd ymm1, ymm22, ymm1
vpshufb ymm22, ymm21, ymm10
vpmaddwd ymm3, ymm22, ymm3
vpshufb ymm22, ymm21, ymm11
vpmaddwd ymm17, ymm22, ymm17
vpaddd ymm3, ymm3, ymm17
vpshufb ymm17, ymm21, ymm12
vpmaddwd ymm17, ymm17, ymm20
vpaddd ymm1, ymm15, ymm1
vpaddd ymm1, ymm1, ymm3
vpaddd ymm15, ymm1, ymm17
add r11, 4
sub r10, 0FFFFFFFFFFFFFF80h
jmp loc_2DD02
loc_2DE7B:
vmulss xmm1, xmm13, xmm14
vbroadcastss ymm1, xmm1
vcvtdq2ps ymm3, ymm15
vfmadd231ps ymm0, ymm1, ymm3
inc rdi
add rdx, 6Eh ; 'n'
jmp loc_2DC4D
loc_2DE9B:
vextractf128 xmm1, ymm0, 1
vaddps xmm0, xmm1, xmm0
vshufpd xmm1, xmm0, xmm0, 1
vaddps xmm0, xmm0, xmm1
vhaddps xmm0, xmm0, xmm0
vmovss dword ptr [rsi], xmm0
lea rsp, [rbp-10h]
pop rbx
pop r14
pop rbp
vzeroupper
retn
| long long ggml_vec_dot_q3_K_q8_K(
int a1,
long long _RSI,
__m128 _XMM0,
long long a4,
long long a5,
long long a6,
long long a7)
{
long long result; // rax
long long v13; // rdi
result = (a1 / 256) & (unsigned int)~((a1 / 256) >> 31);
_RDX = a5 + 32;
__asm { vxorps xmm0, xmm0, xmm0 }
v13 = 0LL;
__asm
{
vpmovsxbq xmm18, cs:word_48501
vpbroadcastq xmm2, cs:qword_484A8
vmovdqa64 xmm19, cs:xmmword_50EC0
}
_R8 = &ggml_table_f32_f16;
__asm
{
vmovdqa xmm4, cs:xmmword_50ED0
vpbroadcastb xmm5, cs:byte_484FC
vpcmpeqd ymm6, ymm6, ymm6
vpbroadcastw ymm7, cs:word_484FE
vpbroadcastb ymm8, cs:byte_48500
vmovdqa ymm9, cs:ymmword_48300
vmovdqa ymm10, cs:ymmword_48320
vmovdqa ymm11, cs:ymmword_48340
vmovdqa ymm12, cs:ymmword_48360
}
while ( v13 != result )
{
_R10 = a7 + 292 * v13 + 4;
__asm { vmovss xmm13, dword ptr [r10-4] }
_RBX = *(unsigned __int16 *)(a5 + 110 * v13 + 108);
__asm { vmovss xmm14, dword ptr [r8+rbx*4] }
LODWORD(_RBX) = *(_DWORD *)(a5 + 110 * v13 + 96);
_R14 = *(_QWORD *)(a5 + 110 * v13 + 100);
__asm
{
vmovq xmm15, r14
vmovd xmm16, ebx
vpsrlq xmm17, xmm15, 20h ; ' '
vpermt2d xmm15, xmm18, xmm16
vpinsrd xmm15, xmm15, r14d, 3
vpinsrd xmm16, xmm17, ebx, 1
vpshufd xmm16, xmm16, 10h
vpsllvd xmm1, xmm16, xmm2
vpsrlvd xmm3, xmm16, xmm2
vpblendd xmm1, xmm1, xmm3, 0Ch
vpandd xmm1, xmm1, xmm19
vpternlogd xmm1, xmm15, xmm4, 0F8h
vpaddb xmm1, xmm1, xmm5
vpmovsxbw ymm1, xmm1
vpermq ymm3, ymm1, 44h ; 'D'
vmovdqa [rsp+50h+var_50], ymm3
vpermq ymm1, ymm1, 0EEh
vmovdqa [rsp+50h+var_30], ymm1
vpxorq ymm16, ymm6, ymmword ptr [rcx+r11]
vpxor xmm15, xmm15, xmm15
}
for ( _R11 = 0LL; _R11 != 8; _R11 += 4LL )
{
__asm
{
vmovdqu ymm1, ymmword ptr [rdx+r11*8]
vmovd xmm3, r11d
vpsllw ymm17, ymm7, xmm3
vpandq ymm17, ymm17, ymm16
vpsrlw ymm3, ymm17, xmm3
vpsllw ymm3, ymm3, 2
}
_EBX = _R11 + 1;
__asm
{
vmovd xmm17, ebx
vpsllw ymm20, ymm7, xmm17
vpandq ymm20, ymm20, ymm16
vpsrlw ymm17, ymm20, xmm17
vpsrlw ymm20, ymm1, 2
vpsllw ymm17, ymm17, 2
}
_EBX = _R11 + 2;
__asm
{
vmovd xmm21, ebx
vpsllw ymm22, ymm7, xmm21
vpsrlw ymm23, ymm1, 4
vpandq ymm22, ymm22, ymm16
vpsrlw ymm21, ymm22, xmm21
vpsllw ymm21, ymm21, 2
}
_EBX = _R11 + 3;
__asm
{
vmovd xmm22, ebx
vpsllw ymm24, ymm7, xmm22
vpandq ymm24, ymm24, ymm16
vpsrlw ymm22, ymm24, xmm22
vpsrlw ymm24, ymm1, 6
vpsllw ymm22, ymm22, 2
vmovdqu64 ymm25, ymmword ptr [r10]
vmovdqu64 ymm26, ymmword ptr [r10+20h]
vmovdqu64 ymm27, ymmword ptr [r10+40h]
vmovdqu64 ymm28, ymmword ptr [r10+60h]
vpmaddubsw ymm3, ymm3, ymm25
vpmaddubsw ymm17, ymm17, ymm26
vpmaddubsw ymm21, ymm21, ymm27
vpmaddubsw ymm22, ymm22, ymm28
vpand ymm1, ymm8, ymm1
vpmaddubsw ymm1, ymm1, ymm25
vpsubw ymm1, ymm1, ymm3
vpandq ymm3, ymm20, ymm8
vpmaddubsw ymm3, ymm3, ymm26
vpsubw ymm3, ymm3, ymm17
vpandq ymm17, ymm23, ymm8
vpmaddubsw ymm17, ymm17, ymm27
vpsubw ymm17, ymm17, ymm21
vpandq ymm20, ymm24, ymm8
vpmaddubsw ymm20, ymm20, ymm28
vpsubw ymm20, ymm20, ymm22
vmovdqa64 ymm21, [rsp+r11*8+50h+var_50]
vpshufb ymm22, ymm21, ymm9
vpmaddwd ymm1, ymm22, ymm1
vpshufb ymm22, ymm21, ymm10
vpmaddwd ymm3, ymm22, ymm3
vpshufb ymm22, ymm21, ymm11
vpmaddwd ymm17, ymm22, ymm17
vpaddd ymm3, ymm3, ymm17
vpshufb ymm17, ymm21, ymm12
vpmaddwd ymm17, ymm17, ymm20
vpaddd ymm1, ymm15, ymm1
vpaddd ymm1, ymm1, ymm3
vpaddd ymm15, ymm1, ymm17
}
_R10 += 128LL;
}
__asm
{
vmulss xmm1, xmm13, xmm14
vbroadcastss ymm1, xmm1
vcvtdq2ps ymm3, ymm15
vfmadd231ps ymm0, ymm1, ymm3
}
++v13;
_RDX += 110LL;
}
__asm
{
vextractf128 xmm1, ymm0, 1
vaddps xmm0, xmm1, xmm0
vshufpd xmm1, xmm0, xmm0, 1
vaddps xmm0, xmm0, xmm1
vhaddps xmm0, xmm0, xmm0
vmovss dword ptr [rsi], xmm0
vzeroupper
}
return result;
}
| ggml_vec_dot_q3_K_q8_K:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
AND RSP,-0x20
SUB RSP,0x40
MOV EAX,EDI
MOV EDI,0x100
CDQ
IDIV EDI
MOV EDX,EAX
SAR EDX,0x1f
ANDN EAX,EDX,EAX
LEA RDX,[RCX + 0x20]
VXORPS XMM0,XMM0,XMM0
XOR EDI,EDI
VPMOVSXBQ XMM2,word ptr [0x00148501]
VPBROADCASTQ XMM2,qword ptr [0x001484a8]
VMOVDQA64 XMM3,xmmword ptr [0x00150ec0]
MOV R8,qword ptr [0x00158f70]
VMOVDQA XMM4,xmmword ptr [0x00150ed0]
VPBROADCASTB XMM5,byte ptr [0x001484fc]
VPCMPEQD YMM6,YMM6,YMM6
VPBROADCASTW YMM7,word ptr [0x001484fe]
VPBROADCASTB YMM8,byte ptr [0x00148500]
VMOVDQA YMM9,ymmword ptr [0x00148300]
VMOVDQA YMM10,ymmword ptr [0x00148320]
VMOVDQA YMM11,ymmword ptr [0x00148340]
VMOVDQA YMM12,ymmword ptr [0x00148360]
CMP RDI,RAX
JZ 0x0012de9b
IMUL R10,RDI,0x124
ADD R10,R9
ADD R10,0x4
VMOVSS XMM13,dword ptr [R10 + -0x4]
IMUL R11,RDI,0x6e
MOVZX EBX,word ptr [RCX + R11*0x1 + 0x6c]
VMOVSS XMM14,dword ptr [R8 + RBX*0x4]
MOV EBX,dword ptr [RCX + R11*0x1 + 0x60]
MOV R14,qword ptr [RCX + R11*0x1 + 0x64]
VMOVQ XMM15,R14
SHR R14D,0x4
VMOVD XMM0,EBX
VPSRLQ XMM1,XMM15,0x20
LAB_0012de9b:
VEXTRACTF128 XMM1,YMM0,0x1
VADDPS XMM0,XMM1,XMM0
VSHUFPD XMM1,XMM0,XMM0,0x1
VADDPS XMM0,XMM0,XMM1
VHADDPS XMM0,XMM0,XMM0
VMOVSS dword ptr [RSI],XMM0
LEA RSP,[RBP + -0x10]
POP RBX
POP R14
POP RBP
VZEROUPPER
RET
|
/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void ggml_vec_dot_q3_K_q8_K(int param_1,int4 *param_2,int8 param_3,long param_4)
{
int1 auVar1 [16];
int1 in_ZMM6 [64];
int1 auVar2 [16];
vpmovsxbq_avx512vl(ZEXT216(DAT_00148501));
vmovdqa64_avx512vl(_DAT_00150ec0);
vpcmpeqd_avx2(in_ZMM6._0_32_,in_ZMM6._0_32_);
if ((~(param_1 / 0x100 >> 0x1f) & param_1 / 0x100) == 0) {
auVar2 = vshufpd_avx(ZEXT816(0),ZEXT816(0),1);
auVar1._0_4_ = auVar2._0_4_ + 0.0;
auVar1._4_4_ = auVar2._4_4_ + 0.0;
auVar1._8_4_ = auVar2._8_4_ + 0.0;
auVar1._12_4_ = auVar2._12_4_ + 0.0;
auVar2 = vhaddps_avx(auVar1,auVar1);
*param_2 = auVar2._0_4_;
return;
}
auVar2._8_8_ = 0;
auVar2._0_8_ = *(ulong *)(param_4 + 100);
vpsrlq_avx512vl(auVar2,0x20);
/* WARNING: Bad instruction - Truncating control flow here */
halt_baddata();
}
|
|
994 | void fmt::v10::detail::bigint::assign<unsigned long, 0>(unsigned long) | aimrt_mujoco_sim/_deps/fmt-src/include/fmt/format.h | FMT_CONSTEXPR20 void assign(UInt n) {
size_t num_bigits = 0;
do {
bigits_[num_bigits++] = static_cast<bigit>(n);
n >>= bigit_bits;
} while (n != 0);
bigits_.resize(num_bigits);
exp_ = 0;
} | O3 | c | void fmt::v10::detail::bigint::assign<unsigned long, 0>(unsigned long):
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
xorl %r14d, %r14d
movl %esi, (%rax,%r14,4)
incq %r14
shrq $0x20, %rsi
jne 0xa15ae
movq 0x18(%rbx), %rax
leaq -0x1(%r14), %rcx
cmpq %rcx, %rax
ja 0xa15d7
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *(%rax)
movq 0x18(%rbx), %rax
cmpq %r14, %rax
cmovbq %rax, %r14
movq %r14, 0x10(%rbx)
movl $0x0, 0xa0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| _ZN3fmt3v106detail6bigint6assignImTnNSt9enable_ifIXoosr3std7is_sameIT_mEE5valuesr3std7is_sameIS5_oEE5valueEiE4typeELi0EEEvS5_:
push r14
push rbx
push rax
mov rbx, rdi
mov rax, [rdi+8]
xor r14d, r14d
loc_A15AE:
mov [rax+r14*4], esi
inc r14
shr rsi, 20h
jnz short loc_A15AE
mov rax, [rbx+18h]
lea rcx, [r14-1]
cmp rax, rcx
ja short loc_A15D7
mov rax, [rbx]
mov rdi, rbx
mov rsi, r14
call qword ptr [rax]
mov rax, [rbx+18h]
loc_A15D7:
cmp rax, r14
cmovb r14, rax
mov [rbx+10h], r14
mov dword ptr [rbx+0A0h], 0
add rsp, 8
pop rbx
pop r14
retn
| unsigned long long ZN3fmt3v106detail6bigint6assignImTnNSt9enable_ifIXoosr3std7is_sameIT_mEE5valuesr3std7is_sameIS5_oEE5valueEiE4typeELi0EEEvS5_(
long long a1,
unsigned long long a2)
{
long long v2; // rax
unsigned long long v3; // r14
unsigned long long result; // rax
v2 = *(_QWORD *)(a1 + 8);
v3 = 0LL;
do
{
*(_DWORD *)(v2 + 4 * v3++) = a2;
a2 >>= 32;
}
while ( a2 );
result = *(_QWORD *)(a1 + 24);
if ( result <= v3 - 1 )
{
(**(void ( ***)(long long, unsigned long long))a1)(a1, v3);
result = *(_QWORD *)(a1 + 24);
}
if ( result < v3 )
v3 = result;
*(_QWORD *)(a1 + 16) = v3;
*(_DWORD *)(a1 + 160) = 0;
return result;
}
| _ZN3fmt3v106detail6bigint6assignImTnNSt9enable_ifIXoosr3std7is_sameIT_mEE5valuesr3std7is_sameIS5_oEE5valueEiE4typeELi0EEEvS5_:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x8]
XOR R14D,R14D
LAB_001a15ae:
MOV dword ptr [RAX + R14*0x4],ESI
INC R14
SHR RSI,0x20
JNZ 0x001a15ae
MOV RAX,qword ptr [RBX + 0x18]
LEA RCX,[R14 + -0x1]
CMP RAX,RCX
JA 0x001a15d7
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
MOV RSI,R14
CALL qword ptr [RAX]
MOV RAX,qword ptr [RBX + 0x18]
LAB_001a15d7:
CMP RAX,R14
CMOVC R14,RAX
MOV qword ptr [RBX + 0x10],R14
MOV dword ptr [RBX + 0xa0],0x0
ADD RSP,0x8
POP RBX
POP R14
RET
|
void _ZN3fmt3v106detail6bigint6assignImTnNSt9enable_ifIXoosr3std7is_sameIT_mEE5valuesr3std7is_sameIS5_oEE5valueEiE4typeELi0EEEvS5_
(int8 *param_1,ulong param_2)
{
long lVar1;
ulong uVar2;
ulong uVar3;
ulong uVar4;
lVar1 = param_1[1];
uVar4 = 0;
do {
uVar3 = uVar4;
*(int *)(lVar1 + uVar3 * 4) = (int)param_2;
uVar4 = uVar3 + 1;
param_2 = param_2 >> 0x20;
} while (param_2 != 0);
uVar2 = param_1[3];
if (uVar2 <= uVar3) {
(**(code **)*param_1)(param_1,uVar4);
uVar2 = param_1[3];
}
if (uVar2 < uVar4) {
uVar4 = uVar2;
}
param_1[2] = uVar4;
*(int4 *)(param_1 + 0x14) = 0;
return;
}
|
|
995 | fmt::v10::appender fmt::v10::detail::write<char, fmt::v10::appender, int, 0>(fmt::v10::appender, int) | AlayaLite/build_O0/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h | FMT_CONSTEXPR auto write(OutputIt out, T value) -> OutputIt {
auto abs_value = static_cast<uint32_or_64_or_128_t<T>>(value);
bool negative = is_negative(value);
// Don't do -abs_value since it trips unsigned-integer-overflow sanitizer.
if (negative) abs_value = ~abs_value + 1;
int num_digits = count_digits(abs_value);
auto size = (negative ? 1 : 0) + static_cast<size_t>(num_digits);
auto it = reserve(out, size);
if (auto ptr = to_pointer<Char>(it, size)) {
if (negative) *ptr++ = static_cast<Char>('-');
format_decimal<Char>(ptr, abs_value, num_digits);
return out;
}
if (negative) *it++ = static_cast<Char>('-');
it = format_decimal<Char>(it, abs_value, num_digits).end;
return base_iterator(out, it);
} | O0 | c | fmt::v10::appender fmt::v10::detail::write<char, fmt::v10::appender, int, 0>(fmt::v10::appender, int):
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x80(%rsp), %rdi
callq 0xaba40
andb $0x1, %al
movb %al, 0x77(%rsp)
testb $0x1, 0x77(%rsp)
je 0xab5e0
movq 0x78(%rsp), %rax
xorq $-0x1, %rax
addq $0x1, %rax
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rdi
callq 0x54be0
movl %eax, 0x70(%rsp)
movb 0x77(%rsp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
cltq
movslq 0x70(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rsi
leaq 0x88(%rsp), %rdi
callq 0x8d9c0
movq (%rax), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x68(%rsp), %rsi
movq 0x50(%rsp), %rdi
callq 0x8d9d0
movq %rax, 0x58(%rsp)
cmpq $0x0, 0x58(%rsp)
je 0xab69b
testb $0x1, 0x77(%rsp)
je 0xab669
movq 0x58(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x58(%rsp)
movb $0x2d, (%rax)
movq 0x58(%rsp), %rdi
movq 0x78(%rsp), %rsi
movl 0x70(%rsp), %edx
callq 0x54cd0
movq %rax, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x90(%rsp)
jmp 0xab72e
testb $0x1, 0x77(%rsp)
je 0xab6cf
movb $0x2d, 0x3f(%rsp)
leaq 0x60(%rsp), %rdi
xorl %esi, %esi
callq 0x24320
movq %rax, 0x30(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x24340
movq %rax, %rdi
leaq 0x3f(%rsp), %rsi
callq 0x24350
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x78(%rsp), %rsi
movl 0x70(%rsp), %edx
movq 0x18(%rsp), %rdi
callq 0x8df60
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x8daf0
movq %rax, 0x90(%rsp)
movq 0x90(%rsp), %rax
addq $0x98, %rsp
retq
nop
| _ZN3fmt3v106detail5writeIcNS0_8appenderEmTnNSt9enable_ifIXaaaasr11is_integralIT1_EE5valuentsr3std7is_sameIS5_bEE5valuentsr3std7is_sameIS5_T_EE5valueEiE4typeELi0EEET0_S9_S5_:
sub rsp, 98h
mov [rsp+98h+var_10], rdi
mov [rsp+98h+var_18], rsi
mov rax, [rsp+98h+var_18]
mov [rsp+98h+var_20], rax
mov rdi, [rsp+98h+var_18]
call _ZN3fmt3v106detail11is_negativeImTnNSt9enable_ifIXntsr9is_signedIT_EE5valueEiE4typeELi0EEEbS4_
and al, 1
mov [rsp+98h+var_21], al
test [rsp+98h+var_21], 1
jz short loc_AB5E0
mov rax, [rsp+98h+var_20]
xor rax, 0FFFFFFFFFFFFFFFFh
add rax, 1
mov [rsp+98h+var_20], rax
loc_AB5E0:
mov rdi, [rsp+98h+var_20]; this
call _ZN3fmt3v106detail12count_digitsEm; fmt::v10::detail::count_digits(ulong)
mov [rsp+98h+var_28], eax
mov dl, [rsp+98h+var_21]
xor eax, eax
mov ecx, 1
test dl, 1
cmovnz eax, ecx
cdqe
movsxd rcx, [rsp+98h+var_28]
add rax, rcx
mov [rsp+98h+var_30], rax
mov rsi, [rsp+98h+var_30]
lea rdi, [rsp+98h+var_10]
call _ZN3fmt3v106detail7reserveINS0_8appenderEEERT_S5_m; fmt::v10::detail::reserve<fmt::v10::appender>(fmt::v10::appender &,ulong)
mov rax, [rax]
mov [rsp+98h+var_38], rax
mov rax, [rsp+98h+var_38]
mov [rsp+98h+var_48], rax
mov rsi, [rsp+98h+var_30]
mov rdi, [rsp+98h+var_48]
call _ZN3fmt3v106detail10to_pointerIcEEPT_NSt11conditionalIXsr3std7is_sameIS3_cEE5valueENS0_8appenderESt20back_insert_iteratorINS1_6bufferIS3_EEEE4typeEm
mov [rsp+98h+var_40], rax
cmp [rsp+98h+var_40], 0
jz short loc_AB69B
test [rsp+98h+var_21], 1
jz short loc_AB669
mov rax, [rsp+98h+var_40]
mov rcx, rax
add rcx, 1
mov [rsp+98h+var_40], rcx
mov byte ptr [rax], 2Dh ; '-'
loc_AB669:
mov rdi, [rsp+98h+var_40]
mov rsi, [rsp+98h+var_20]
mov edx, [rsp+98h+var_28]
call _ZN3fmt3v106detail14format_decimalIcmEENS1_21format_decimal_resultIPT_EES5_T0_i; fmt::v10::detail::format_decimal<char,ulong>(char *,ulong,int)
mov [rsp+98h+var_58], rax
mov [rsp+98h+var_50], rdx
mov rax, [rsp+98h+var_10]
mov [rsp+98h+var_8], rax
jmp loc_AB72E
loc_AB69B:
test [rsp+98h+var_21], 1
jz short loc_AB6CF
mov [rsp+98h+var_59], 2Dh ; '-'
lea rdi, [rsp+98h+var_38]
xor esi, esi
call _ZN3fmt3v108appenderppEi; fmt::v10::appender::operator++(int)
mov [rsp+98h+var_68], rax
lea rdi, [rsp+98h+var_68]
call _ZNSt20back_insert_iteratorIN3fmt3v106detail6bufferIcEEEdeEv; std::back_insert_iterator<fmt::v10::detail::buffer<char>>::operator*(void)
mov rdi, rax
lea rsi, [rsp+98h+var_59]
call _ZNSt20back_insert_iteratorIN3fmt3v106detail6bufferIcEEEaSEOc; std::back_insert_iterator<fmt::v10::detail::buffer<char>>::operator=(char &&)
loc_AB6CF:
mov rax, [rsp+98h+var_38]
mov [rsp+98h+var_80], rax
mov rsi, [rsp+98h+var_20]
mov edx, [rsp+98h+var_28]
mov rdi, [rsp+98h+var_80]
call _ZN3fmt3v106detail14format_decimalIcmNS0_8appenderETnNSt9enable_ifIXntsr3std10is_pointerINSt9remove_cvINSt16remove_referenceIT1_E4typeEE4typeEEE5valueEiE4typeELi0EEENS1_21format_decimal_resultIS7_EES7_T0_i
mov [rsp+98h+var_78], rax
mov [rsp+98h+var_70], rdx
mov rax, [rsp+98h+var_70]
mov [rsp+98h+var_38], rax
mov rax, [rsp+98h+var_10]
mov [rsp+98h+var_88], rax
mov rax, [rsp+98h+var_38]
mov [rsp+98h+var_90], rax
mov rdi, [rsp+98h+var_88]
mov rsi, [rsp+98h+var_90]
call _ZN3fmt3v106detail13base_iteratorINS0_8appenderEEET_S4_S4_; fmt::v10::detail::base_iterator<fmt::v10::appender>(fmt::v10::appender,fmt::v10::appender)
mov [rsp+98h+var_8], rax
loc_AB72E:
mov rax, [rsp+98h+var_8]
add rsp, 98h
retn
| long long ZN3fmt3v106detail5writeIcNS0_8appenderEmTnNSt9enable_ifIXaaaasr11is_integralIT1_EE5valuentsr3std7is_sameIS5_bEE5valuentsr3std7is_sameIS5_T_EE5valueEiE4typeELi0EEET0_S9_S5_(
long long a1,
fmt::v10::detail *a2)
{
_BYTE *v2; // rax
long long v3; // rdx
_QWORD *v4; // rax
long long v5; // rdx
long long v7; // [rsp+30h] [rbp-68h] BYREF
char v8; // [rsp+3Fh] [rbp-59h] BYREF
_WORD *v9; // [rsp+40h] [rbp-58h]
long long v10; // [rsp+48h] [rbp-50h]
long long v11; // [rsp+50h] [rbp-48h]
_BYTE *v12; // [rsp+58h] [rbp-40h]
long long v13; // [rsp+60h] [rbp-38h] BYREF
long long v14; // [rsp+68h] [rbp-30h]
int v15; // [rsp+70h] [rbp-28h]
char v16; // [rsp+77h] [rbp-21h]
fmt::v10::detail *v17; // [rsp+78h] [rbp-20h]
fmt::v10::detail *v18; // [rsp+80h] [rbp-18h]
long long v19; // [rsp+88h] [rbp-10h] BYREF
v19 = a1;
v18 = a2;
v17 = a2;
v16 = ZN3fmt3v106detail11is_negativeImTnNSt9enable_ifIXntsr9is_signedIT_EE5valueEiE4typeELi0EEEbS4_(a2) & 1;
if ( v16 )
v17 = (fmt::v10::detail *)-(long long)v17;
v15 = fmt::v10::detail::count_digits(v17, (unsigned long long)a2);
v14 = v15 + (unsigned long long)((v16 & 1) != 0);
v13 = *(_QWORD *)fmt::v10::detail::reserve<fmt::v10::appender>((long long)&v19);
v11 = v13;
v12 = (_BYTE *)fmt::v10::detail::to_pointer<char>(v13, v14);
if ( v12 )
{
if ( (v16 & 1) != 0 )
{
v2 = v12++;
*v2 = 45;
}
v9 = fmt::v10::detail::format_decimal<char,unsigned long>((long long)v12, v17, v15);
v10 = v3;
return v19;
}
else
{
if ( (v16 & 1) != 0 )
{
v8 = 45;
v7 = fmt::v10::appender::operator++((long long)&v13);
v4 = (_QWORD *)std::back_insert_iterator<fmt::v10::detail::buffer<char>>::operator*((long long)&v7);
std::back_insert_iterator<fmt::v10::detail::buffer<char>>::operator=(v4, (long long)&v8);
}
ZN3fmt3v106detail14format_decimalIcmNS0_8appenderETnNSt9enable_ifIXntsr3std10is_pointerINSt9remove_cvINSt16remove_referenceIT1_E4typeEE4typeEEE5valueEiE4typeELi0EEENS1_21format_decimal_resultIS7_EES7_T0_i(
v13,
v17,
v15);
v13 = v5;
return fmt::v10::detail::base_iterator<fmt::v10::appender>(v19, v5);
}
}
| _ZN3fmt3v106detail5writeIcNS0_8appenderEmTnNSt9enable_ifIXaaaasr11is_integralIT1_EE5valuentsr3std7is_sameIS5_bEE5valuentsr3std7is_sameIS5_T_EE5valueEiE4typeELi0EEET0_S9_S5_:
SUB RSP,0x98
MOV qword ptr [RSP + 0x88],RDI
MOV qword ptr [RSP + 0x80],RSI
MOV RAX,qword ptr [RSP + 0x80]
MOV qword ptr [RSP + 0x78],RAX
MOV RDI,qword ptr [RSP + 0x80]
CALL 0x001aba40
AND AL,0x1
MOV byte ptr [RSP + 0x77],AL
TEST byte ptr [RSP + 0x77],0x1
JZ 0x001ab5e0
MOV RAX,qword ptr [RSP + 0x78]
XOR RAX,-0x1
ADD RAX,0x1
MOV qword ptr [RSP + 0x78],RAX
LAB_001ab5e0:
MOV RDI,qword ptr [RSP + 0x78]
CALL 0x00154be0
MOV dword ptr [RSP + 0x70],EAX
MOV DL,byte ptr [RSP + 0x77]
XOR EAX,EAX
MOV ECX,0x1
TEST DL,0x1
CMOVNZ EAX,ECX
CDQE
MOVSXD RCX,dword ptr [RSP + 0x70]
ADD RAX,RCX
MOV qword ptr [RSP + 0x68],RAX
MOV RSI,qword ptr [RSP + 0x68]
LEA RDI,[RSP + 0x88]
CALL 0x0018d9c0
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP + 0x60],RAX
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x50],RAX
MOV RSI,qword ptr [RSP + 0x68]
MOV RDI,qword ptr [RSP + 0x50]
CALL 0x0018d9d0
MOV qword ptr [RSP + 0x58],RAX
CMP qword ptr [RSP + 0x58],0x0
JZ 0x001ab69b
TEST byte ptr [RSP + 0x77],0x1
JZ 0x001ab669
MOV RAX,qword ptr [RSP + 0x58]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RSP + 0x58],RCX
MOV byte ptr [RAX],0x2d
LAB_001ab669:
MOV RDI,qword ptr [RSP + 0x58]
MOV RSI,qword ptr [RSP + 0x78]
MOV EDX,dword ptr [RSP + 0x70]
CALL 0x00154cd0
MOV qword ptr [RSP + 0x40],RAX
MOV qword ptr [RSP + 0x48],RDX
MOV RAX,qword ptr [RSP + 0x88]
MOV qword ptr [RSP + 0x90],RAX
JMP 0x001ab72e
LAB_001ab69b:
TEST byte ptr [RSP + 0x77],0x1
JZ 0x001ab6cf
MOV byte ptr [RSP + 0x3f],0x2d
LEA RDI,[RSP + 0x60]
XOR ESI,ESI
CALL 0x00124320
MOV qword ptr [RSP + 0x30],RAX
LEA RDI,[RSP + 0x30]
CALL 0x00124340
MOV RDI,RAX
LEA RSI,[RSP + 0x3f]
CALL 0x00124350
LAB_001ab6cf:
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x18],RAX
MOV RSI,qword ptr [RSP + 0x78]
MOV EDX,dword ptr [RSP + 0x70]
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x0018df60
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x28],RDX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x60],RAX
MOV RAX,qword ptr [RSP + 0x88]
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP + 0x8]
CALL 0x0018daf0
MOV qword ptr [RSP + 0x90],RAX
LAB_001ab72e:
MOV RAX,qword ptr [RSP + 0x90]
ADD RSP,0x98
RET
|
int8
_ZN3fmt3v106detail5writeIcNS0_8appenderEmTnNSt9enable_ifIXaaaasr11is_integralIT1_EE5valuentsr3std7is_sameIS5_bEE5valuentsr3std7is_sameIS5_T_EE5valueEiE4typeELi0EEET0_S9_S5_
(int8 param_1,ulong param_2)
{
int8 *puVar1;
back_insert_iterator<fmt::v10::detail::buffer<char>> *this;
int8 extraout_RDX;
int8 local_68;
char local_59 [17];
int8 local_48;
char *local_40;
int8 local_38;
ulong local_30;
int local_28;
byte local_21;
ulong local_20;
ulong local_18;
int8 local_10;
int8 local_8;
local_20 = param_2;
local_18 = param_2;
local_10 = param_1;
local_21 = _ZN3fmt3v106detail11is_negativeImTnNSt9enable_ifIXntsr9is_signedIT_EE5valueEiE4typeELi0EEEbS4_
(param_2);
local_21 = local_21 & 1;
if (local_21 != 0) {
local_20 = (local_20 ^ 0xffffffffffffffff) + 1;
}
local_28 = fmt::v10::detail::count_digits(local_20);
local_30 = (long)(int)(uint)((local_21 & 1) != 0) + (long)local_28;
puVar1 = (int8 *)
fmt::v10::detail::reserve<fmt::v10::appender>((appender *)&local_10,local_30);
local_48 = *puVar1;
local_38 = local_48;
local_40 = fmt::v10::detail::to_pointer<char>(local_48);
if (local_40 == (char *)0x0) {
if ((local_21 & 1) != 0) {
local_59[0] = '-';
local_68 = fmt::v10::appender::operator++((appender *)&local_38,0);
this = (back_insert_iterator<fmt::v10::detail::buffer<char>> *)
std::back_insert_iterator<fmt::v10::detail::buffer<char>>::operator*
((back_insert_iterator<fmt::v10::detail::buffer<char>> *)&local_68);
std::back_insert_iterator<fmt::v10::detail::buffer<char>>::operator=(this,local_59);
}
_ZN3fmt3v106detail14format_decimalIcmNS0_8appenderETnNSt9enable_ifIXntsr3std10is_pointerINSt9remove_cvINSt16remove_referenceIT1_E4typeEE4typeEEE5valueEiE4typeELi0EEENS1_21format_decimal_resultIS7_EES7_T0_i
(local_38,local_20,local_28);
local_38 = extraout_RDX;
local_8 = fmt::v10::detail::base_iterator<fmt::v10::appender>(local_10,extraout_RDX);
}
else {
if ((local_21 & 1) != 0) {
*local_40 = '-';
local_40 = local_40 + 1;
}
fmt::v10::detail::format_decimal<char,unsigned_long>(local_40,local_20,local_28);
local_8 = local_10;
}
return local_8;
}
|
|
996 | tree_search_key | eloqsql/mysys/tree.c | void *tree_search_key(TREE *tree, const void *key,
TREE_ELEMENT **parents, TREE_ELEMENT ***last_pos,
enum ha_rkey_function flag, void *custom_arg)
{
int cmp;
TREE_ELEMENT *element= tree->root;
TREE_ELEMENT **last_left_step_parent= NULL, **last_right_step_parent= NULL;
TREE_ELEMENT **last_equal_element= NULL;
/*
TODO: support for HA_READ_KEY_OR_PREV, HA_READ_PREFIX flags if needed.
*/
*parents = &null_element;
while (element != &null_element)
{
*++parents= element;
if ((cmp= (*tree->compare)(custom_arg, ELEMENT_KEY(tree, element),
key)) == 0)
{
switch (flag) {
case HA_READ_KEY_EXACT:
case HA_READ_KEY_OR_NEXT:
case HA_READ_BEFORE_KEY:
case HA_READ_KEY_OR_PREV:
last_equal_element= parents;
cmp= 1;
break;
case HA_READ_AFTER_KEY:
cmp= -1;
break;
case HA_READ_PREFIX_LAST:
case HA_READ_PREFIX_LAST_OR_PREV:
last_equal_element= parents;
cmp= -1;
break;
default:
return NULL;
}
}
if (cmp < 0) /* element < key */
{
last_right_step_parent= parents;
element= element->right;
}
else
{
last_left_step_parent= parents;
element= element->left;
}
}
switch (flag) {
case HA_READ_KEY_EXACT:
case HA_READ_PREFIX_LAST:
*last_pos= last_equal_element;
break;
case HA_READ_KEY_OR_NEXT:
*last_pos= last_equal_element ? last_equal_element : last_left_step_parent;
break;
case HA_READ_AFTER_KEY:
*last_pos= last_left_step_parent;
break;
case HA_READ_PREFIX_LAST_OR_PREV:
*last_pos= last_equal_element ? last_equal_element : last_right_step_parent;
break;
case HA_READ_BEFORE_KEY:
*last_pos= last_right_step_parent;
break;
case HA_READ_KEY_OR_PREV:
*last_pos= last_equal_element ? last_equal_element : last_right_step_parent;
break;
default:
return NULL;
}
return *last_pos ? ELEMENT_KEY(tree, **last_pos) : NULL;
} | O0 | c | tree_search_key:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
movq $0x0, -0x60(%rbp)
movq -0x20(%rbp), %rax
leaq 0x1c3c9f(%rip), %rcx # 0x2bec60
movq %rcx, (%rax)
leaq 0x1c3c95(%rip), %rax # 0x2bec60
cmpq %rax, -0x48(%rbp)
je 0xfb0e9
movq -0x48(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, -0x20(%rbp)
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x228(%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x208(%rax)
je 0xfb027
movq -0x48(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x208(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x78(%rbp)
jmp 0xfb033
movq -0x48(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x70(%rbp), %rax
movq -0x68(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq *%rax
movl %eax, -0x3c(%rbp)
cmpl $0x0, %eax
jne 0xfb0b5
movl -0x2c(%rbp), %eax
movl %eax, -0x7c(%rbp)
subl $0x3, %eax
jb 0xfb07b
jmp 0xfb05a
movl -0x7c(%rbp), %eax
subl $0x3, %eax
je 0xfb08c
jmp 0xfb064
movl -0x7c(%rbp), %eax
subl $0x4, %eax
je 0xfb07b
jmp 0xfb06e
movl -0x7c(%rbp), %eax
addl $-0x6, %eax
subl $0x2, %eax
jb 0xfb095
jmp 0xfb0a6
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x1, -0x3c(%rbp)
jmp 0xfb0b3
movl $0xffffffff, -0x3c(%rbp) # imm = 0xFFFFFFFF
jmp 0xfb0b3
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0xffffffff, -0x3c(%rbp) # imm = 0xFFFFFFFF
jmp 0xfb0b3
movq $0x0, -0x8(%rbp)
jmp 0xfb24a
jmp 0xfb0b5
cmpl $0x0, -0x3c(%rbp)
jge 0xfb0d1
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0xfb0e4
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0xfafc4
movl -0x2c(%rbp), %eax
movq %rax, -0x88(%rbp)
subq $0x7, %rax
ja 0xfb1ce
movq -0x88(%rbp), %rax
leaq 0x5d5f9(%rip), %rcx # 0x158704
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x60(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0xfb1d8
cmpq $0x0, -0x60(%rbp)
je 0xfb138
movq -0x60(%rbp), %rax
movq %rax, -0x90(%rbp)
jmp 0xfb143
movq -0x50(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0xfb1d8
movq -0x50(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0xfb1d8
cmpq $0x0, -0x60(%rbp)
je 0xfb177
movq -0x60(%rbp), %rax
movq %rax, -0x98(%rbp)
jmp 0xfb182
movq -0x58(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0xfb1d8
movq -0x58(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0xfb1d8
cmpq $0x0, -0x60(%rbp)
je 0xfb1b3
movq -0x60(%rbp), %rax
movq %rax, -0xa0(%rbp)
jmp 0xfb1be
movq -0x58(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0xfb1d8
movq $0x0, -0x8(%rbp)
jmp 0xfb24a
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
je 0xfb234
movq -0x10(%rbp), %rax
cmpl $0x0, 0x208(%rax)
je 0xfb20f
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x208(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0xa8(%rbp)
jmp 0xfb224
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rax
movq %rax, -0xb0(%rbp)
jmp 0xfb23f
xorl %eax, %eax
movq %rax, -0xb0(%rbp)
jmp 0xfb23f
movq -0xb0(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| tree_search_key:
push rbp
mov rbp, rsp
sub rsp, 0B0h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_2C], r8d
mov [rbp+var_38], r9
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_48], rax
mov [rbp+var_50], 0
mov [rbp+var_58], 0
mov [rbp+var_60], 0
mov rax, [rbp+var_20]
lea rcx, null_element
mov [rax], rcx
loc_FAFC4:
lea rax, null_element
cmp [rbp+var_48], rax
jz loc_FB0E9
mov rcx, [rbp+var_48]
mov rax, [rbp+var_20]
mov rdx, rax
add rdx, 8
mov [rbp+var_20], rdx
mov [rax+8], rcx
mov rax, [rbp+var_10]
mov rax, [rax+228h]
mov [rbp+var_70], rax
mov rax, [rbp+var_38]
mov [rbp+var_68], rax
mov rax, [rbp+var_10]
cmp dword ptr [rax+208h], 0
jz short loc_FB027
mov rax, [rbp+var_48]
mov rcx, [rbp+var_10]
mov ecx, [rcx+208h]
add rax, rcx
mov [rbp+var_78], rax
jmp short loc_FB033
loc_FB027:
mov rax, [rbp+var_48]
mov rax, [rax+18h]
mov [rbp+var_78], rax
loc_FB033:
mov rax, [rbp+var_70]
mov rdi, [rbp+var_68]
mov rsi, [rbp+var_78]
mov rdx, [rbp+var_18]
call rax
mov [rbp+var_3C], eax
cmp eax, 0
jnz short loc_FB0B5
mov eax, [rbp+var_2C]
mov [rbp+var_7C], eax
sub eax, 3
jb short loc_FB07B
jmp short $+2
loc_FB05A:
mov eax, [rbp+var_7C]
sub eax, 3
jz short loc_FB08C
jmp short $+2
loc_FB064:
mov eax, [rbp+var_7C]
sub eax, 4
jz short loc_FB07B
jmp short $+2
loc_FB06E:
mov eax, [rbp+var_7C]
add eax, 0FFFFFFFAh
sub eax, 2
jb short loc_FB095
jmp short loc_FB0A6
loc_FB07B:
mov rax, [rbp+var_20]
mov [rbp+var_60], rax
mov [rbp+var_3C], 1
jmp short loc_FB0B3
loc_FB08C:
mov [rbp+var_3C], 0FFFFFFFFh
jmp short loc_FB0B3
loc_FB095:
mov rax, [rbp+var_20]
mov [rbp+var_60], rax
mov [rbp+var_3C], 0FFFFFFFFh
jmp short loc_FB0B3
loc_FB0A6:
mov [rbp+var_8], 0
jmp loc_FB24A
loc_FB0B3:
jmp short $+2
loc_FB0B5:
cmp [rbp+var_3C], 0
jge short loc_FB0D1
mov rax, [rbp+var_20]
mov [rbp+var_58], rax
mov rax, [rbp+var_48]
mov rax, [rax+8]
mov [rbp+var_48], rax
jmp short loc_FB0E4
loc_FB0D1:
mov rax, [rbp+var_20]
mov [rbp+var_50], rax
mov rax, [rbp+var_48]
mov rax, [rax]
mov [rbp+var_48], rax
loc_FB0E4:
jmp loc_FAFC4
loc_FB0E9:
mov eax, [rbp+var_2C]
mov [rbp+var_88], rax
sub rax, 7; switch 8 cases
ja def_FB112; jumptable 00000000000FB112 default case, case 5
mov rax, [rbp+var_88]
lea rcx, jpt_FB112
movsxd rax, ds:(jpt_FB112 - 158704h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_FB114:
mov rcx, [rbp+var_60]; jumptable 00000000000FB112 cases 0,6
mov rax, [rbp+var_28]
mov [rax], rcx
jmp loc_FB1D8
loc_FB124:
cmp [rbp+var_60], 0; jumptable 00000000000FB112 case 1
jz short loc_FB138
mov rax, [rbp+var_60]
mov [rbp+var_90], rax
jmp short loc_FB143
loc_FB138:
mov rax, [rbp+var_50]
mov [rbp+var_90], rax
loc_FB143:
mov rcx, [rbp+var_90]
mov rax, [rbp+var_28]
mov [rax], rcx
jmp loc_FB1D8
loc_FB156:
mov rcx, [rbp+var_50]; jumptable 00000000000FB112 case 3
mov rax, [rbp+var_28]
mov [rax], rcx
jmp short loc_FB1D8
loc_FB163:
cmp [rbp+var_60], 0; jumptable 00000000000FB112 case 7
jz short loc_FB177
mov rax, [rbp+var_60]
mov [rbp+var_98], rax
jmp short loc_FB182
loc_FB177:
mov rax, [rbp+var_58]
mov [rbp+var_98], rax
loc_FB182:
mov rcx, [rbp+var_98]
mov rax, [rbp+var_28]
mov [rax], rcx
jmp short loc_FB1D8
loc_FB192:
mov rcx, [rbp+var_58]; jumptable 00000000000FB112 case 4
mov rax, [rbp+var_28]
mov [rax], rcx
jmp short loc_FB1D8
loc_FB19F:
cmp [rbp+var_60], 0; jumptable 00000000000FB112 case 2
jz short loc_FB1B3
mov rax, [rbp+var_60]
mov [rbp+var_A0], rax
jmp short loc_FB1BE
loc_FB1B3:
mov rax, [rbp+var_58]
mov [rbp+var_A0], rax
loc_FB1BE:
mov rcx, [rbp+var_A0]
mov rax, [rbp+var_28]
mov [rax], rcx
jmp short loc_FB1D8
def_FB112:
mov [rbp+var_8], 0; jumptable 00000000000FB112 default case, case 5
jmp short loc_FB24A
loc_FB1D8:
mov rax, [rbp+var_28]
cmp qword ptr [rax], 0
jz short loc_FB234
mov rax, [rbp+var_10]
cmp dword ptr [rax+208h], 0
jz short loc_FB20F
mov rax, [rbp+var_28]
mov rax, [rax]
mov rax, [rax]
mov rcx, [rbp+var_10]
mov ecx, [rcx+208h]
add rax, rcx
mov [rbp+var_A8], rax
jmp short loc_FB224
loc_FB20F:
mov rax, [rbp+var_28]
mov rax, [rax]
mov rax, [rax]
mov rax, [rax+18h]
mov [rbp+var_A8], rax
loc_FB224:
mov rax, [rbp+var_A8]
mov [rbp+var_B0], rax
jmp short loc_FB23F
loc_FB234:
xor eax, eax
mov [rbp+var_B0], rax
jmp short $+2
loc_FB23F:
mov rax, [rbp+var_B0]
mov [rbp+var_8], rax
loc_FB24A:
mov rax, [rbp+var_8]
add rsp, 0B0h
pop rbp
retn
| long long tree_search_key(long long ***a1, long long a2, _QWORD *a3, long long a4, unsigned int a5, long long a6)
{
_QWORD *v6; // rax
int v7; // eax
long long v9; // [rsp+0h] [rbp-B0h]
long long v10; // [rsp+8h] [rbp-A8h]
_QWORD *v11; // [rsp+10h] [rbp-A0h]
_QWORD *v12; // [rsp+18h] [rbp-98h]
_QWORD *v13; // [rsp+20h] [rbp-90h]
long long *v14; // [rsp+40h] [rbp-70h]
_QWORD *v15; // [rsp+50h] [rbp-60h]
_QWORD *v16; // [rsp+58h] [rbp-58h]
_QWORD *v17; // [rsp+60h] [rbp-50h]
long long **v18; // [rsp+68h] [rbp-48h]
int v19; // [rsp+74h] [rbp-3Ch]
_QWORD *v23; // [rsp+90h] [rbp-20h]
long long v24; // [rsp+A8h] [rbp-8h]
v23 = a3;
v18 = *a1;
v17 = 0LL;
v16 = 0LL;
v15 = 0LL;
*a3 = &null_element;
while ( v18 != (long long **)&null_element )
{
v6 = v23++;
v6[1] = v18;
v14 = (long long *)a1[69];
if ( *((_DWORD *)a1 + 130) )
v7 = ((long long ( *)(long long, char *, long long))v14)(a6, (char *)v18 + *((unsigned int *)a1 + 130), a2);
else
v7 = ((long long ( *)(long long, long long *, long long))v14)(a6, v18[3], a2);
v19 = v7;
if ( !v7 )
{
if ( a5 < 3 )
goto LABEL_12;
if ( a5 == 3 )
{
v19 = -1;
goto LABEL_15;
}
if ( a5 == 4 )
{
LABEL_12:
v15 = v23;
v19 = 1;
}
else
{
if ( a5 - 6 >= 2 )
return 0LL;
v15 = v23;
v19 = -1;
}
}
LABEL_15:
if ( v19 >= 0 )
{
v17 = v23;
v18 = (long long **)*v18;
}
else
{
v16 = v23;
v18 = (long long **)v18[1];
}
}
switch ( a5 )
{
case 0u:
case 6u:
*(_QWORD *)a4 = v15;
goto LABEL_35;
case 1u:
if ( v15 )
v13 = v15;
else
v13 = v17;
*(_QWORD *)a4 = v13;
goto LABEL_35;
case 2u:
if ( v15 )
v11 = v15;
else
v11 = v16;
*(_QWORD *)a4 = v11;
goto LABEL_35;
case 3u:
*(_QWORD *)a4 = v17;
goto LABEL_35;
case 4u:
*(_QWORD *)a4 = v16;
goto LABEL_35;
case 7u:
if ( v15 )
v12 = v15;
else
v12 = v16;
*(_QWORD *)a4 = v12;
LABEL_35:
if ( *(_QWORD *)a4 )
{
if ( *((_DWORD *)a1 + 130) )
v10 = *((unsigned int *)a1 + 130) + **(_QWORD **)a4;
else
v10 = *(_QWORD *)(**(_QWORD **)a4 + 24LL);
v9 = v10;
}
else
{
v9 = 0LL;
}
v24 = v9;
break;
default:
v24 = 0LL;
break;
}
return v24;
}
| tree_search_key:
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 qword ptr [RBP + -0x28],RCX
MOV dword ptr [RBP + -0x2c],R8D
MOV qword ptr [RBP + -0x38],R9
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x48],RAX
MOV qword ptr [RBP + -0x50],0x0
MOV qword ptr [RBP + -0x58],0x0
MOV qword ptr [RBP + -0x60],0x0
MOV RAX,qword ptr [RBP + -0x20]
LEA RCX,[0x3bec60]
MOV qword ptr [RAX],RCX
LAB_001fafc4:
LEA RAX,[0x3bec60]
CMP qword ptr [RBP + -0x48],RAX
JZ 0x001fb0e9
MOV RCX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x228]
MOV qword ptr [RBP + -0x70],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x208],0x0
JZ 0x001fb027
MOV RAX,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RCX + 0x208]
ADD RAX,RCX
MOV qword ptr [RBP + -0x78],RAX
JMP 0x001fb033
LAB_001fb027:
MOV RAX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RBP + -0x78],RAX
LAB_001fb033:
MOV RAX,qword ptr [RBP + -0x70]
MOV RDI,qword ptr [RBP + -0x68]
MOV RSI,qword ptr [RBP + -0x78]
MOV RDX,qword ptr [RBP + -0x18]
CALL RAX
MOV dword ptr [RBP + -0x3c],EAX
CMP EAX,0x0
JNZ 0x001fb0b5
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x7c],EAX
SUB EAX,0x3
JC 0x001fb07b
JMP 0x001fb05a
LAB_001fb05a:
MOV EAX,dword ptr [RBP + -0x7c]
SUB EAX,0x3
JZ 0x001fb08c
JMP 0x001fb064
LAB_001fb064:
MOV EAX,dword ptr [RBP + -0x7c]
SUB EAX,0x4
JZ 0x001fb07b
JMP 0x001fb06e
LAB_001fb06e:
MOV EAX,dword ptr [RBP + -0x7c]
ADD EAX,-0x6
SUB EAX,0x2
JC 0x001fb095
JMP 0x001fb0a6
LAB_001fb07b:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x60],RAX
MOV dword ptr [RBP + -0x3c],0x1
JMP 0x001fb0b3
LAB_001fb08c:
MOV dword ptr [RBP + -0x3c],0xffffffff
JMP 0x001fb0b3
LAB_001fb095:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x60],RAX
MOV dword ptr [RBP + -0x3c],0xffffffff
JMP 0x001fb0b3
LAB_001fb0a6:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001fb24a
LAB_001fb0b3:
JMP 0x001fb0b5
LAB_001fb0b5:
CMP dword ptr [RBP + -0x3c],0x0
JGE 0x001fb0d1
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x48],RAX
JMP 0x001fb0e4
LAB_001fb0d1:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x48],RAX
LAB_001fb0e4:
JMP 0x001fafc4
LAB_001fb0e9:
MOV EAX,dword ptr [RBP + -0x2c]
MOV qword ptr [RBP + -0x88],RAX
SUB RAX,0x7
JA 0x001fb1ce
MOV RAX,qword ptr [RBP + -0x88]
LEA RCX,[0x258704]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_0:
MOV RCX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
JMP 0x001fb1d8
caseD_1:
CMP qword ptr [RBP + -0x60],0x0
JZ 0x001fb138
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x90],RAX
JMP 0x001fb143
LAB_001fb138:
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x90],RAX
LAB_001fb143:
MOV RCX,qword ptr [RBP + -0x90]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
JMP 0x001fb1d8
caseD_3:
MOV RCX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
JMP 0x001fb1d8
caseD_7:
CMP qword ptr [RBP + -0x60],0x0
JZ 0x001fb177
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x98],RAX
JMP 0x001fb182
LAB_001fb177:
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x98],RAX
LAB_001fb182:
MOV RCX,qword ptr [RBP + -0x98]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
JMP 0x001fb1d8
caseD_4:
MOV RCX,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
JMP 0x001fb1d8
caseD_2:
CMP qword ptr [RBP + -0x60],0x0
JZ 0x001fb1b3
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0xa0],RAX
JMP 0x001fb1be
LAB_001fb1b3:
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0xa0],RAX
LAB_001fb1be:
MOV RCX,qword ptr [RBP + -0xa0]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
JMP 0x001fb1d8
caseD_5:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001fb24a
LAB_001fb1d8:
MOV RAX,qword ptr [RBP + -0x28]
CMP qword ptr [RAX],0x0
JZ 0x001fb234
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x208],0x0
JZ 0x001fb20f
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RCX + 0x208]
ADD RAX,RCX
MOV qword ptr [RBP + -0xa8],RAX
JMP 0x001fb224
LAB_001fb20f:
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RBP + -0xa8],RAX
LAB_001fb224:
MOV RAX,qword ptr [RBP + -0xa8]
MOV qword ptr [RBP + -0xb0],RAX
JMP 0x001fb23f
LAB_001fb234:
XOR EAX,EAX
MOV qword ptr [RBP + -0xb0],RAX
JMP 0x001fb23f
LAB_001fb23f:
MOV RAX,qword ptr [RBP + -0xb0]
MOV qword ptr [RBP + -0x8],RAX
LAB_001fb24a:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0xb0
POP RBP
RET
|
long tree_search_key(int8 *param_1,int8 param_2,int8 *param_3,long *param_4,
uint param_5,int8 param_6)
{
int8 *puVar1;
long local_b8;
long local_b0;
int8 *local_a8;
int8 *local_a0;
int8 *local_98;
long local_80;
int8 *local_68;
int8 *local_60;
int8 *local_58;
int8 *local_50;
int local_44;
int8 *local_28;
local_50 = (int8 *)*param_1;
local_58 = (int8 *)0x0;
local_60 = (int8 *)0x0;
local_68 = (int8 *)0x0;
*param_3 = null_element;
local_28 = param_3;
do {
if (local_50 == (int8 *)null_element) {
switch(param_5) {
case 0:
case 6:
*param_4 = (long)local_68;
break;
case 1:
if (local_68 == (int8 *)0x0) {
local_98 = local_58;
}
else {
local_98 = local_68;
}
*param_4 = (long)local_98;
break;
case 2:
if (local_68 == (int8 *)0x0) {
local_a8 = local_60;
}
else {
local_a8 = local_68;
}
*param_4 = (long)local_a8;
break;
case 3:
*param_4 = (long)local_58;
break;
case 4:
*param_4 = (long)local_60;
break;
default:
return 0;
case 7:
if (local_68 == (int8 *)0x0) {
local_a0 = local_60;
}
else {
local_a0 = local_68;
}
*param_4 = (long)local_a0;
}
if (*param_4 == 0) {
local_b8 = 0;
}
else {
if (*(int *)(param_1 + 0x41) == 0) {
local_b0 = *(long *)(*(long *)*param_4 + 0x18);
}
else {
local_b0 = *(long *)*param_4 + (ulong)*(uint *)(param_1 + 0x41);
}
local_b8 = local_b0;
}
return local_b8;
}
puVar1 = local_28 + 1;
local_28[1] = local_50;
if (*(int *)(param_1 + 0x41) == 0) {
local_80 = local_50[3];
}
else {
local_80 = (long)local_50 + (ulong)*(uint *)(param_1 + 0x41);
}
local_44 = (*(code *)param_1[0x45])(param_6,local_80,param_2);
if (local_44 == 0) {
if (param_5 < 3) {
LAB_001fb07b:
local_44 = 1;
local_68 = puVar1;
}
else if (param_5 == 3) {
local_44 = -1;
}
else {
if (param_5 == 4) goto LAB_001fb07b;
if (1 < param_5 - 6) {
return 0;
}
local_44 = -1;
local_68 = puVar1;
}
}
local_28 = puVar1;
if (local_44 < 0) {
local_50 = (int8 *)local_50[1];
local_60 = puVar1;
}
else {
local_50 = (int8 *)*local_50;
local_58 = puVar1;
}
} while( true );
}
|
|
997 | mysql_stmt_bind_param | eloqsql/libmariadb/libmariadb/mariadb_stmt.c | my_bool STDCALL mysql_stmt_bind_param(MYSQL_STMT *stmt, MYSQL_BIND *bind)
{
MYSQL *mysql= stmt->mysql;
if (!mysql)
{
SET_CLIENT_STMT_ERROR(stmt, CR_SERVER_LOST, SQLSTATE_UNKNOWN, 0);
return(1);
}
/* If number of parameters was specified via mysql_stmt_attr_set we need to realloc
them, e.g. for mariadb_stmt_execute_direct()
*/
if ((stmt->state < MYSQL_STMT_PREPARED || stmt->state >= MYSQL_STMT_EXECUTED) &&
stmt->prebind_params > 0)
{
if (!stmt->params && stmt->prebind_params)
{
if (!(stmt->params= (MYSQL_BIND *)ma_alloc_root(&stmt->mem_root, stmt->prebind_params * sizeof(MYSQL_BIND))))
{
SET_CLIENT_STMT_ERROR(stmt, CR_OUT_OF_MEMORY, SQLSTATE_UNKNOWN, 0);
return(1);
}
memset(stmt->params, '\0', stmt->prebind_params * sizeof(MYSQL_BIND));
}
stmt->param_count= stmt->prebind_params;
}
else if (stmt->state < MYSQL_STMT_PREPARED) {
SET_CLIENT_STMT_ERROR(stmt, CR_NO_PREPARE_STMT, SQLSTATE_UNKNOWN, 0);
return(1);
}
if (stmt->param_count && bind)
{
uint i;
memcpy(stmt->params, bind, sizeof(MYSQL_BIND) * stmt->param_count);
stmt->send_types_to_server= 1;
for (i=0; i < stmt->param_count; i++)
{
if (stmt->mysql->methods->db_supported_buffer_type &&
!stmt->mysql->methods->db_supported_buffer_type(stmt->params[i].buffer_type))
{
SET_CLIENT_STMT_ERROR(stmt, CR_UNSUPPORTED_PARAM_TYPE, SQLSTATE_UNKNOWN, 0);
return(1);
}
if (!stmt->params[i].is_null)
stmt->params[i].is_null= &is_not_null;
if (stmt->params[i].long_data_used)
stmt->params[i].long_data_used= 0;
if (!stmt->params[i].length)
stmt->params[i].length= &stmt->params[i].buffer_length;
switch(stmt->params[i].buffer_type) {
case MYSQL_TYPE_NULL:
stmt->params[i].is_null= &is_null;
break;
case MYSQL_TYPE_TINY:
stmt->params[i].buffer_length= 1;
break;
case MYSQL_TYPE_SHORT:
case MYSQL_TYPE_YEAR:
stmt->params[i].buffer_length= 2;
break;
case MYSQL_TYPE_LONG:
case MYSQL_TYPE_FLOAT:
stmt->params[i].buffer_length= 4;
break;
case MYSQL_TYPE_LONGLONG:
case MYSQL_TYPE_DOUBLE:
stmt->params[i].buffer_length= 8;
break;
case MYSQL_TYPE_DATETIME:
case MYSQL_TYPE_TIMESTAMP:
stmt->params[i].buffer_length= 12;
break;
case MYSQL_TYPE_TIME:
stmt->params[i].buffer_length= 13;
break;
case MYSQL_TYPE_DATE:
stmt->params[i].buffer_length= 5;
break;
case MYSQL_TYPE_STRING:
case MYSQL_TYPE_JSON:
case MYSQL_TYPE_VAR_STRING:
case MYSQL_TYPE_BLOB:
case MYSQL_TYPE_TINY_BLOB:
case MYSQL_TYPE_MEDIUM_BLOB:
case MYSQL_TYPE_LONG_BLOB:
case MYSQL_TYPE_DECIMAL:
case MYSQL_TYPE_NEWDECIMAL:
break;
default:
SET_CLIENT_STMT_ERROR(stmt, CR_UNSUPPORTED_PARAM_TYPE, SQLSTATE_UNKNOWN, 0);
return(1);
break;
}
}
}
stmt->bind_param_done= stmt->send_types_to_server= 1;
CLEAR_CLIENT_STMT_ERROR(stmt);
return(0);
} | O3 | c | mysql_stmt_bind_param:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x38(%rdi)
je 0x4ee77
movq %rsi, %r14
movl 0x50(%rbx), %ecx
cmpl $0x1, %ecx
je 0x4eed8
movl 0x378(%rbx), %eax
testq %rax, %rax
je 0x4eed0
cmpq $0x0, 0x70(%rbx)
jne 0x4ee72
imulq $0x70, %rax, %rsi
movq %rbx, %rdi
callq 0x4cb3b
movq %rax, 0x70(%rbx)
testq %rax, %rax
je 0x4f0f2
movl 0x378(%rbx), %ecx
imulq $0x70, %rcx, %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x37300
movl 0x378(%rbx), %eax
movl %eax, 0x64(%rbx)
jmp 0x4eed8
movl $0x7dd, 0x108(%rbx) # imm = 0x7DD
leaq 0x30d(%rbx), %rdi
leaq 0x2fe6f1(%rip), %rax # 0x34d580
movq (%rax), %rsi
movl $0x5, %edx
callq 0x37130
xorl %r14d, %r14d
movb %r14b, 0x312(%rbx)
leaq 0x10c(%rbx), %rdi
leaq 0x2fe6dc(%rip), %rax # 0x34d590
movq 0x68(%rax), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x37130
movb %r14b, 0x30b(%rbx)
movb $0x1, %al
jmp 0x4f051
testl %ecx, %ecx
je 0x4f0a9
movl 0x64(%rbx), %eax
testq %rax, %rax
sete %cl
testq %r14, %r14
sete %dl
orb %cl, %dl
jne 0x4f020
movq 0x70(%rbx), %rdi
imulq $0x70, %rax, %rdx
movq %r14, %rsi
callq 0x370a0
movb $0x1, 0x68(%rbx)
cmpl $0x0, 0x64(%rbx)
je 0x4f020
movl $0x40, %r14d
xorl %r15d, %r15d
movl $0x3f3, %r13d # imm = 0x3F3
leaq 0x5cba1(%rip), %r12 # 0xabac4
movq 0x38(%rbx), %rcx
movq 0x70(%rbx), %rax
movq 0x4d0(%rcx), %rcx
movq 0x38(%rcx), %rcx
testq %rcx, %rcx
je 0x4ef4e
movl 0x20(%rax,%r14), %edi
callq *%rcx
testb %al, %al
je 0x4f060
movq 0x70(%rbx), %rax
cmpq $0x0, -0x38(%rax,%r14)
jne 0x4ef66
leaq 0x376b2d(%rip), %rcx # 0x3c5a8a
movq %rcx, -0x38(%rax,%r14)
movq 0x70(%rbx), %rax
cmpb $0x0, 0x26(%rax,%r14)
je 0x4ef78
movb $0x0, 0x26(%rax,%r14)
movq 0x70(%rbx), %rax
cmpq $0x0, -0x40(%rax,%r14)
jne 0x4ef8d
leaq (%rax,%r14), %rcx
movq %rcx, -0x40(%rax,%r14)
movq 0x70(%rbx), %rax
movl 0x20(%rax,%r14), %ecx
cmpq $0xd, %rcx
ja 0x4efab
movslq (%r12,%rcx,4), %rcx
addq %r12, %rcx
jmpq *%rcx
movq $0x2, (%rax,%r14)
jmp 0x4f00d
addl $0xffffff0b, %ecx # imm = 0xFFFFFF0B
cmpl $0x9, %ecx
ja 0x4f060
btl %ecx, %r13d
jb 0x4f00d
jmp 0x4f060
movq $0x4, (%rax,%r14)
jmp 0x4f00d
movq $0x8, (%rax,%r14)
jmp 0x4f00d
movq $0xc, (%rax,%r14)
jmp 0x4f00d
movq $0xd, (%rax,%r14)
jmp 0x4f00d
movq $0x1, (%rax,%r14)
jmp 0x4f00d
leaq 0x2fd6a2(%rip), %rcx # 0x34c6a0
movq %rcx, -0x38(%rax,%r14)
jmp 0x4f00d
movq $0x5, (%rax,%r14)
incq %r15
movl 0x64(%rbx), %eax
addq $0x70, %r14
cmpq %rax, %r15
jb 0x4ef23
movb $0x1, %al
movb %al, 0x68(%rbx)
movb %al, 0xe9(%rbx)
movl $0x0, 0x108(%rbx)
movl $0x30303030, 0x30d(%rbx) # imm = 0x30303030
movw $0x30, 0x311(%rbx)
movb $0x0, 0x10c(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x7f4, 0x108(%rbx) # imm = 0x7F4
leaq 0x30d(%rbx), %rdi
leaq 0x2fe508(%rip), %rax # 0x34d580
movq (%rax), %rsi
movl $0x5, %edx
callq 0x37130
xorl %r14d, %r14d
movb %r14b, 0x312(%rbx)
leaq 0x10c(%rbx), %rdi
leaq 0x2fe4f3(%rip), %rax # 0x34d590
movq 0x120(%rax), %rsi
jmp 0x4eeb8
movl $0x7ee, 0x108(%rbx) # imm = 0x7EE
leaq 0x30d(%rbx), %rdi
leaq 0x2fe4bf(%rip), %rax # 0x34d580
movq (%rax), %rsi
movl $0x5, %edx
callq 0x37130
xorl %r14d, %r14d
movb %r14b, 0x312(%rbx)
leaq 0x10c(%rbx), %rdi
leaq 0x2fe4aa(%rip), %rax # 0x34d590
movq 0xf0(%rax), %rsi
jmp 0x4eeb8
movl $0x7d8, 0x108(%rbx) # imm = 0x7D8
leaq 0x30d(%rbx), %rdi
leaq 0x2fe476(%rip), %rax # 0x34d580
movq (%rax), %rsi
movl $0x5, %edx
callq 0x37130
xorl %r14d, %r14d
movb %r14b, 0x312(%rbx)
leaq 0x10c(%rbx), %rdi
leaq 0x2fe461(%rip), %rax # 0x34d590
movq 0x40(%rax), %rsi
jmp 0x4eeb8
| mysql_stmt_bind_param:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
cmp qword ptr [rdi+38h], 0
jz short loc_4EE77
mov r14, rsi
mov ecx, [rbx+50h]
cmp ecx, 1
jz loc_4EED8
mov eax, [rbx+378h]
test rax, rax
jz loc_4EED0
cmp qword ptr [rbx+70h], 0
jnz short loc_4EE72
imul rsi, rax, 70h ; 'p'
mov rdi, rbx
call ma_alloc_root
mov [rbx+70h], rax
test rax, rax
jz loc_4F0F2
mov ecx, [rbx+378h]
imul rdx, rcx, 70h ; 'p'
mov rdi, rax
xor esi, esi
call _memset
mov eax, [rbx+378h]
loc_4EE72:
mov [rbx+64h], eax
jmp short loc_4EED8
loc_4EE77:
mov dword ptr [rbx+108h], 7DDh
lea rdi, [rbx+30Dh]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
xor r14d, r14d
mov [rbx+312h], r14b
lea rdi, [rbx+10Ch]
lea rax, client_errors
mov rsi, [rax+68h]
loc_4EEB8:
mov edx, 200h
call _strncpy
mov [rbx+30Bh], r14b
mov al, 1
jmp loc_4F051
loc_4EED0:
test ecx, ecx
jz loc_4F0A9
loc_4EED8:
mov eax, [rbx+64h]
test rax, rax
setz cl
test r14, r14
setz dl
or dl, cl
jnz loc_4F020
mov rdi, [rbx+70h]
imul rdx, rax, 70h ; 'p'
mov rsi, r14
call _memcpy
mov byte ptr [rbx+68h], 1
cmp dword ptr [rbx+64h], 0
jz loc_4F020
mov r14d, 40h ; '@'
xor r15d, r15d
mov r13d, 3F3h
lea r12, jpt_4EF9F
loc_4EF23:
mov rcx, [rbx+38h]
mov rax, [rbx+70h]
mov rcx, [rcx+4D0h]
mov rcx, [rcx+38h]
test rcx, rcx
jz short loc_4EF4E
mov edi, [rax+r14+20h]
call rcx
test al, al
jz loc_4F060; jumptable 000000000004EF9F case 9
mov rax, [rbx+70h]
loc_4EF4E:
cmp qword ptr [rax+r14-38h], 0
jnz short loc_4EF66
lea rcx, is_not_null
mov [rax+r14-38h], rcx
mov rax, [rbx+70h]
loc_4EF66:
cmp byte ptr [rax+r14+26h], 0
jz short loc_4EF78
mov byte ptr [rax+r14+26h], 0
mov rax, [rbx+70h]
loc_4EF78:
cmp qword ptr [rax+r14-40h], 0
jnz short loc_4EF8D
lea rcx, [rax+r14]
mov [rax+r14-40h], rcx
mov rax, [rbx+70h]
loc_4EF8D:
mov ecx, [rax+r14+20h]
cmp rcx, 0Dh; switch 14 cases
ja short def_4EF9F; jumptable 000000000004EF9F default case
movsxd rcx, ds:(jpt_4EF9F - 0ABAC4h)[r12+rcx*4]
add rcx, r12
jmp rcx; switch jump
loc_4EFA1:
mov qword ptr [rax+r14], 2; jumptable 000000000004EF9F cases 2,13
jmp short loc_4F00D; jumptable 000000000004EF9F case 0
def_4EF9F:
add ecx, 0FFFFFF0Bh; jumptable 000000000004EF9F default case
cmp ecx, 9
ja loc_4F060; jumptable 000000000004EF9F case 9
bt r13d, ecx
jb short loc_4F00D; jumptable 000000000004EF9F case 0
jmp loc_4F060; jumptable 000000000004EF9F case 9
loc_4EFC5:
mov qword ptr [rax+r14], 4; jumptable 000000000004EF9F cases 3,4
jmp short loc_4F00D; jumptable 000000000004EF9F case 0
loc_4EFCF:
mov qword ptr [rax+r14], 8; jumptable 000000000004EF9F cases 5,8
jmp short loc_4F00D; jumptable 000000000004EF9F case 0
loc_4EFD9:
mov qword ptr [rax+r14], 0Ch; jumptable 000000000004EF9F cases 7,12
jmp short loc_4F00D; jumptable 000000000004EF9F case 0
loc_4EFE3:
mov qword ptr [rax+r14], 0Dh; jumptable 000000000004EF9F case 11
jmp short loc_4F00D; jumptable 000000000004EF9F case 0
loc_4EFED:
mov qword ptr [rax+r14], 1; jumptable 000000000004EF9F case 1
jmp short loc_4F00D; jumptable 000000000004EF9F case 0
loc_4EFF7:
lea rcx, is_null; jumptable 000000000004EF9F case 6
mov [rax+r14-38h], rcx
jmp short loc_4F00D; jumptable 000000000004EF9F case 0
loc_4F005:
mov qword ptr [rax+r14], 5; jumptable 000000000004EF9F case 10
loc_4F00D:
inc r15; jumptable 000000000004EF9F case 0
mov eax, [rbx+64h]
add r14, 70h ; 'p'
cmp r15, rax
jb loc_4EF23
loc_4F020:
mov al, 1
mov [rbx+68h], al
mov [rbx+0E9h], al
mov dword ptr [rbx+108h], 0
mov dword ptr [rbx+30Dh], 30303030h
mov word ptr [rbx+311h], 30h ; '0'
mov byte ptr [rbx+10Ch], 0
xor eax, eax
loc_4F051:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_4F060:
mov dword ptr [rbx+108h], 7F4h; jumptable 000000000004EF9F case 9
lea rdi, [rbx+30Dh]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
xor r14d, r14d
mov [rbx+312h], r14b
lea rdi, [rbx+10Ch]
lea rax, client_errors
mov rsi, [rax+120h]
jmp loc_4EEB8
loc_4F0A9:
mov dword ptr [rbx+108h], 7EEh
lea rdi, [rbx+30Dh]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
xor r14d, r14d
mov [rbx+312h], r14b
lea rdi, [rbx+10Ch]
lea rax, client_errors
mov rsi, [rax+0F0h]
jmp loc_4EEB8
loc_4F0F2:
mov dword ptr [rbx+108h], 7D8h
lea rdi, [rbx+30Dh]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
xor r14d, r14d
mov [rbx+312h], r14b
lea rdi, [rbx+10Ch]
lea rax, client_errors
mov rsi, [rax+40h]
jmp loc_4EEB8
| char mysql_stmt_bind_param(long long a1, long long a2)
{
int v3; // ecx
long long v4; // rax
char *v5; // rax
long long v6; // rdi
char *v7; // rsi
long long v9; // rax
long long v10; // r14
unsigned long long v11; // r15
int v12; // r13d
long long v13; // rax
unsigned __int8 ( *v14)(_QWORD); // rcx
unsigned int v15; // ecx
if ( !*(_QWORD *)(a1 + 56) )
{
*(_DWORD *)(a1 + 264) = 2013;
strncpy(a1 + 781, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 786) = 0;
v6 = a1 + 268;
v7 = client_errors[13];
goto LABEL_9;
}
v3 = *(_DWORD *)(a1 + 80);
if ( v3 == 1 )
goto LABEL_11;
v4 = *(unsigned int *)(a1 + 888);
if ( *(_DWORD *)(a1 + 888) )
{
if ( *(_QWORD *)(a1 + 112) )
{
LABEL_7:
*(_DWORD *)(a1 + 100) = v4;
goto LABEL_11;
}
v5 = ma_alloc_root(a1, 112 * v4);
*(_QWORD *)(a1 + 112) = v5;
if ( v5 )
{
memset(v5, 0LL, 112LL * *(unsigned int *)(a1 + 888));
LODWORD(v4) = *(_DWORD *)(a1 + 888);
goto LABEL_7;
}
*(_DWORD *)(a1 + 264) = 2008;
strncpy(a1 + 781, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 786) = 0;
v6 = a1 + 268;
v7 = client_errors[8];
LABEL_9:
strncpy(v6, v7, 512LL);
*(_BYTE *)(a1 + 779) = 0;
return 1;
}
if ( !v3 )
{
*(_DWORD *)(a1 + 264) = 2030;
strncpy(a1 + 781, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 786) = 0;
v6 = a1 + 268;
v7 = client_errors[30];
goto LABEL_9;
}
LABEL_11:
v9 = *(unsigned int *)(a1 + 100);
if ( v9 != 0 && a2 != 0 )
{
memcpy(*(_QWORD *)(a1 + 112), a2, 112 * v9);
*(_BYTE *)(a1 + 104) = 1;
if ( *(_DWORD *)(a1 + 100) )
{
v10 = 64LL;
v11 = 0LL;
v12 = 1011;
do
{
v13 = *(_QWORD *)(a1 + 112);
v14 = *(unsigned __int8 ( **)(_QWORD))(*(_QWORD *)(*(_QWORD *)(a1 + 56) + 1232LL) + 56LL);
if ( v14 )
{
if ( !v14(*(unsigned int *)(v13 + v10 + 32)) )
{
LABEL_38:
*(_DWORD *)(a1 + 264) = 2036;
strncpy(a1 + 781, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 786) = 0;
v6 = a1 + 268;
v7 = client_errors[36];
goto LABEL_9;
}
v13 = *(_QWORD *)(a1 + 112);
}
if ( !*(_QWORD *)(v13 + v10 - 56) )
{
*(_QWORD *)(v13 + v10 - 56) = &is_not_null;
v13 = *(_QWORD *)(a1 + 112);
}
if ( *(_BYTE *)(v13 + v10 + 38) )
{
*(_BYTE *)(v13 + v10 + 38) = 0;
v13 = *(_QWORD *)(a1 + 112);
}
if ( !*(_QWORD *)(v13 + v10 - 64) )
{
*(_QWORD *)(v13 + v10 - 64) = v13 + v10;
v13 = *(_QWORD *)(a1 + 112);
}
switch ( *(_DWORD *)(v13 + v10 + 32) )
{
case 0:
break;
case 1:
*(_QWORD *)(v13 + v10) = 1LL;
break;
case 2:
case 0xD:
*(_QWORD *)(v13 + v10) = 2LL;
break;
case 3:
case 4:
*(_QWORD *)(v13 + v10) = 4LL;
break;
case 5:
case 8:
*(_QWORD *)(v13 + v10) = 8LL;
break;
case 6:
*(_QWORD *)(v13 + v10 - 56) = &is_null;
break;
case 7:
case 0xC:
*(_QWORD *)(v13 + v10) = 12LL;
break;
case 9:
goto LABEL_38;
case 0xA:
*(_QWORD *)(v13 + v10) = 5LL;
break;
case 0xB:
*(_QWORD *)(v13 + v10) = 13LL;
break;
default:
v15 = *(_DWORD *)(v13 + v10 + 32) - 245;
if ( v15 > 9 || !_bittest(&v12, v15) )
goto LABEL_38;
break;
}
++v11;
v10 += 112LL;
}
while ( v11 < *(unsigned int *)(a1 + 100) );
}
}
*(_BYTE *)(a1 + 104) = 1;
*(_BYTE *)(a1 + 233) = 1;
*(_DWORD *)(a1 + 264) = 0;
strcpy((char *)(a1 + 781), "00000");
*(_BYTE *)(a1 + 268) = 0;
return 0;
}
| mysql_stmt_bind_param:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
CMP qword ptr [RDI + 0x38],0x0
JZ 0x0014ee77
MOV R14,RSI
MOV ECX,dword ptr [RBX + 0x50]
CMP ECX,0x1
JZ 0x0014eed8
MOV EAX,dword ptr [RBX + 0x378]
TEST RAX,RAX
JZ 0x0014eed0
CMP qword ptr [RBX + 0x70],0x0
JNZ 0x0014ee72
IMUL RSI,RAX,0x70
MOV RDI,RBX
CALL 0x0014cb3b
MOV qword ptr [RBX + 0x70],RAX
TEST RAX,RAX
JZ 0x0014f0f2
MOV ECX,dword ptr [RBX + 0x378]
IMUL RDX,RCX,0x70
MOV RDI,RAX
XOR ESI,ESI
CALL 0x00137300
MOV EAX,dword ptr [RBX + 0x378]
LAB_0014ee72:
MOV dword ptr [RBX + 0x64],EAX
JMP 0x0014eed8
LAB_0014ee77:
MOV dword ptr [RBX + 0x108],0x7dd
LEA RDI,[RBX + 0x30d]
LEA RAX,[0x44d580]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00137130
XOR R14D,R14D
MOV byte ptr [RBX + 0x312],R14B
LEA RDI,[RBX + 0x10c]
LEA RAX,[0x44d590]
MOV RSI,qword ptr [RAX + 0x68]
LAB_0014eeb8:
MOV EDX,0x200
CALL 0x00137130
MOV byte ptr [RBX + 0x30b],R14B
MOV AL,0x1
JMP 0x0014f051
LAB_0014eed0:
TEST ECX,ECX
JZ 0x0014f0a9
LAB_0014eed8:
MOV EAX,dword ptr [RBX + 0x64]
TEST RAX,RAX
SETZ CL
TEST R14,R14
SETZ DL
OR DL,CL
JNZ 0x0014f020
MOV RDI,qword ptr [RBX + 0x70]
IMUL RDX,RAX,0x70
MOV RSI,R14
CALL 0x001370a0
MOV byte ptr [RBX + 0x68],0x1
CMP dword ptr [RBX + 0x64],0x0
JZ 0x0014f020
MOV R14D,0x40
XOR R15D,R15D
MOV R13D,0x3f3
LEA R12,[0x1abac4]
LAB_0014ef23:
MOV RCX,qword ptr [RBX + 0x38]
MOV RAX,qword ptr [RBX + 0x70]
MOV RCX,qword ptr [RCX + 0x4d0]
MOV RCX,qword ptr [RCX + 0x38]
TEST RCX,RCX
JZ 0x0014ef4e
MOV EDI,dword ptr [RAX + R14*0x1 + 0x20]
CALL RCX
TEST AL,AL
JZ 0x0014f060
MOV RAX,qword ptr [RBX + 0x70]
LAB_0014ef4e:
CMP qword ptr [RAX + R14*0x1 + -0x38],0x0
JNZ 0x0014ef66
LEA RCX,[0x4c5a8a]
MOV qword ptr [RAX + R14*0x1 + -0x38],RCX
MOV RAX,qword ptr [RBX + 0x70]
LAB_0014ef66:
CMP byte ptr [RAX + R14*0x1 + 0x26],0x0
JZ 0x0014ef78
MOV byte ptr [RAX + R14*0x1 + 0x26],0x0
MOV RAX,qword ptr [RBX + 0x70]
LAB_0014ef78:
CMP qword ptr [RAX + R14*0x1 + -0x40],0x0
JNZ 0x0014ef8d
LEA RCX,[RAX + R14*0x1]
MOV qword ptr [RAX + R14*0x1 + -0x40],RCX
MOV RAX,qword ptr [RBX + 0x70]
LAB_0014ef8d:
MOV ECX,dword ptr [RAX + R14*0x1 + 0x20]
CMP RCX,0xd
JA 0x0014efab
MOVSXD RCX,dword ptr [R12 + RCX*0x4]
ADD RCX,R12
switchD:
JMP RCX
caseD_2:
MOV qword ptr [RAX + R14*0x1],0x2
JMP 0x0014f00d
default:
ADD ECX,0xffffff0b
CMP ECX,0x9
JA 0x0014f060
BT R13D,ECX
JC 0x0014f00d
JMP 0x0014f060
caseD_3:
MOV qword ptr [RAX + R14*0x1],0x4
JMP 0x0014f00d
caseD_5:
MOV qword ptr [RAX + R14*0x1],0x8
JMP 0x0014f00d
caseD_7:
MOV qword ptr [RAX + R14*0x1],0xc
JMP 0x0014f00d
caseD_b:
MOV qword ptr [RAX + R14*0x1],0xd
JMP 0x0014f00d
caseD_1:
MOV qword ptr [RAX + R14*0x1],0x1
JMP 0x0014f00d
caseD_6:
LEA RCX,[0x44c6a0]
MOV qword ptr [RAX + R14*0x1 + -0x38],RCX
JMP 0x0014f00d
caseD_a:
MOV qword ptr [RAX + R14*0x1],0x5
caseD_0:
INC R15
MOV EAX,dword ptr [RBX + 0x64]
ADD R14,0x70
CMP R15,RAX
JC 0x0014ef23
LAB_0014f020:
MOV AL,0x1
MOV byte ptr [RBX + 0x68],AL
MOV byte ptr [RBX + 0xe9],AL
MOV dword ptr [RBX + 0x108],0x0
MOV dword ptr [RBX + 0x30d],0x30303030
MOV word ptr [RBX + 0x311],0x30
MOV byte ptr [RBX + 0x10c],0x0
XOR EAX,EAX
LAB_0014f051:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
caseD_9:
MOV dword ptr [RBX + 0x108],0x7f4
LEA RDI,[RBX + 0x30d]
LEA RAX,[0x44d580]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00137130
XOR R14D,R14D
MOV byte ptr [RBX + 0x312],R14B
LEA RDI,[RBX + 0x10c]
LEA RAX,[0x44d590]
MOV RSI,qword ptr [RAX + 0x120]
JMP 0x0014eeb8
LAB_0014f0a9:
MOV dword ptr [RBX + 0x108],0x7ee
LEA RDI,[RBX + 0x30d]
LEA RAX,[0x44d580]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00137130
XOR R14D,R14D
MOV byte ptr [RBX + 0x312],R14B
LEA RDI,[RBX + 0x10c]
LEA RAX,[0x44d590]
MOV RSI,qword ptr [RAX + 0xf0]
JMP 0x0014eeb8
LAB_0014f0f2:
MOV dword ptr [RBX + 0x108],0x7d8
LEA RDI,[RBX + 0x30d]
LEA RAX,[0x44d580]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00137130
XOR R14D,R14D
MOV byte ptr [RBX + 0x312],R14B
LEA RDI,[RBX + 0x10c]
LEA RAX,[0x44d590]
MOV RSI,qword ptr [RAX + 0x40]
JMP 0x0014eeb8
|
int8 mysql_stmt_bind_param(long param_1,void *param_2)
{
code *pcVar1;
char cVar2;
int iVar3;
void *__s;
int8 uVar4;
long lVar5;
uint uVar6;
char *__src;
long lVar7;
ulong uVar8;
if (*(long *)(param_1 + 0x38) == 0) {
*(int4 *)(param_1 + 0x108) = 0x7dd;
strncpy((char *)(param_1 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x312) = 0;
__src = PTR_s_Lost_connection_to_server_during_0044d5f8;
LAB_0014eeb8:
strncpy((char *)(param_1 + 0x10c),__src,0x200);
*(int1 *)(param_1 + 0x30b) = 0;
uVar4 = 1;
}
else {
if (*(int *)(param_1 + 0x50) != 1) {
iVar3 = *(int *)(param_1 + 0x378);
if (iVar3 == 0) {
if (*(int *)(param_1 + 0x50) == 0) {
*(int4 *)(param_1 + 0x108) = 0x7ee;
strncpy((char *)(param_1 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x312) = 0;
__src = PTR_s_Statement_is_not_prepared_0044d680;
goto LAB_0014eeb8;
}
}
else {
if (*(long *)(param_1 + 0x70) == 0) {
__s = (void *)ma_alloc_root(param_1);
*(void **)(param_1 + 0x70) = __s;
if (__s == (void *)0x0) {
*(int4 *)(param_1 + 0x108) = 0x7d8;
strncpy((char *)(param_1 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x312) = 0;
__src = PTR_s_Client_run_out_of_memory_0044d5d0;
goto LAB_0014eeb8;
}
memset(__s,0,(ulong)*(uint *)(param_1 + 0x378) * 0x70);
iVar3 = *(int *)(param_1 + 0x378);
}
*(int *)(param_1 + 100) = iVar3;
}
}
if (param_2 != (void *)0x0 && (ulong)*(uint *)(param_1 + 100) != 0) {
memcpy(*(void **)(param_1 + 0x70),param_2,(ulong)*(uint *)(param_1 + 100) * 0x70);
*(int1 *)(param_1 + 0x68) = 1;
if (*(int *)(param_1 + 100) != 0) {
lVar7 = 0x40;
uVar8 = 0;
do {
lVar5 = *(long *)(param_1 + 0x70);
pcVar1 = *(code **)(*(long *)(*(long *)(param_1 + 0x38) + 0x4d0) + 0x38);
if (pcVar1 != (code *)0x0) {
cVar2 = (*pcVar1)(*(int4 *)(lVar5 + 0x20 + lVar7));
if (cVar2 != '\0') {
lVar5 = *(long *)(param_1 + 0x70);
goto LAB_0014ef4e;
}
switchD_0014ef9f_caseD_9:
*(int4 *)(param_1 + 0x108) = 0x7f4;
strncpy((char *)(param_1 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x312) = 0;
__src = PTR_s_Buffer_type_is_not_supported_0044d6b0;
goto LAB_0014eeb8;
}
LAB_0014ef4e:
if (*(long *)(lVar5 + -0x38 + lVar7) == 0) {
*(int1 **)(lVar5 + -0x38 + lVar7) = &is_not_null;
lVar5 = *(long *)(param_1 + 0x70);
}
if (*(char *)(lVar5 + 0x26 + lVar7) != '\0') {
*(int1 *)(lVar5 + 0x26 + lVar7) = 0;
lVar5 = *(long *)(param_1 + 0x70);
}
if (*(long *)(lVar5 + -0x40 + lVar7) == 0) {
*(long *)(lVar5 + -0x40 + lVar7) = lVar5 + lVar7;
lVar5 = *(long *)(param_1 + 0x70);
}
iVar3 = *(int *)(lVar5 + 0x20 + lVar7);
switch(iVar3) {
case 0:
break;
case 1:
*(int8 *)(lVar5 + lVar7) = 1;
break;
case 2:
case 0xd:
*(int8 *)(lVar5 + lVar7) = 2;
break;
case 3:
case 4:
*(int8 *)(lVar5 + lVar7) = 4;
break;
case 5:
case 8:
*(int8 *)(lVar5 + lVar7) = 8;
break;
case 6:
*(int1 **)(lVar5 + -0x38 + lVar7) = &is_null;
break;
case 7:
case 0xc:
*(int8 *)(lVar5 + lVar7) = 0xc;
break;
case 9:
goto switchD_0014ef9f_caseD_9;
case 10:
*(int8 *)(lVar5 + lVar7) = 5;
break;
case 0xb:
*(int8 *)(lVar5 + lVar7) = 0xd;
break;
default:
uVar6 = iVar3 - 0xf5;
if ((9 < uVar6) || ((0x3f3U >> (uVar6 & 0x1f) & 1) == 0)) goto switchD_0014ef9f_caseD_9;
}
uVar8 = uVar8 + 1;
lVar7 = lVar7 + 0x70;
} while (uVar8 < *(uint *)(param_1 + 100));
}
}
*(int1 *)(param_1 + 0x68) = 1;
*(int1 *)(param_1 + 0xe9) = 1;
*(int4 *)(param_1 + 0x108) = 0;
*(int4 *)(param_1 + 0x30d) = 0x30303030;
*(int2 *)(param_1 + 0x311) = 0x30;
*(int1 *)(param_1 + 0x10c) = 0;
uVar4 = 0;
}
return uVar4;
}
|
|
998 | minja::Parser::parseString[abi:cxx11]()::'lambda'(char)::operator()[abi:cxx11](char) const | llama.cpp/common/minja/minja.hpp | std::unique_ptr<std::string> parseString() {
auto doParse = [&](char quote) -> std::unique_ptr<std::string> {
if (it == end || *it != quote) return nullptr;
std::string result;
bool escape = false;
for (++it; it != end; ++it) {
if (escape) {
escape = false;
switch (*it) {
case 'n': result += '\n'; break;
case 'r': result += '\r'; break;
case 't': result += '\t'; break;
case 'b': result += '\b'; break;
case 'f': result += '\f'; break;
case '\\': result += '\\'; break;
default:
if (*it == quote) {
result += quote;
} else {
result += *it;
}
break;
}
} else if (*it == '\\') {
escape = true;
} else if (*it == quote) {
++it;
return std::make_unique<std::string>(std::move(result));
} else {
result += *it;
}
}
return nullptr;
};
consumeSpaces();
if (it == end) return nullptr;
if (*it == '"') return doParse('"');
if (*it == '\'') return doParse('\'');
return nullptr;
} | O3 | cpp | minja::Parser::parseString[abi:cxx11]()::'lambda'(char)::operator()[abi:cxx11](char) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rsi), %r12
movq 0x18(%r12), %rcx
movq 0x20(%r12), %rax
cmpq %rcx, %rax
je 0xe5991
movl %edx, %ebp
cmpb %bpl, (%rax)
jne 0xe5991
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x1(%rax), %rdx
movq %rdx, 0x20(%r12)
cmpq %rcx, %rdx
je 0xe59aa
xorl %edx, %edx
movl $0x1a29, %r13d # imm = 0x1A29
leaq 0x8(%rsp), %r15
movb 0x1(%rax), %cl
testb $0x1, %dl
je 0xe5943
movsbl %cl, %eax
addl $-0x5c, %eax
rorl %eax
cmpl $0xc, %eax
ja 0xe594f
btl %eax, %r13d
jae 0xe594f
movl %eax, %eax
leaq 0x3905a(%rip), %rcx # 0x11e998
movb (%rax,%rcx), %cl
jmp 0xe594f
movb $0x1, %dl
cmpb $0x5c, %cl
je 0xe595c
cmpb %bpl, %cl
je 0xe59af
movsbl %cl, %esi
movq %r15, %rdi
callq 0x21390
xorl %edx, %edx
movq 0x20(%r12), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%r12)
cmpq 0x18(%r12), %rcx
jne 0xe591a
movq 0x8(%rsp), %rdi
movq $0x0, (%rbx)
cmpq %r14, %rdi
je 0xe5998
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x20180
jmp 0xe5998
movq $0x0, (%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r15d, %r15d
jmp 0xe5a0b
addq $0x2, %rax
movq %rax, 0x20(%r12)
movl $0x20, %edi
callq 0x20210
movq %rax, %r15
movq %rax, %rdi
addq $0x10, %rdi
movq %rdi, (%rax)
movq 0x8(%rsp), %rax
cmpq %r14, %rax
je 0xe59ec
movq %rax, (%r15)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%r15)
movq 0x10(%rsp), %r12
jmp 0xe59fe
movq 0x10(%rsp), %r12
leaq 0x1(%r12), %rdx
movq %r14, %rsi
callq 0x200f0
movq %r12, 0x8(%r15)
movq $0x0, 0x10(%rsp)
movq %r15, (%rbx)
jmp 0xe5998
jmp 0xe5a12
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xe5a2c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x20180
movq %rbx, %rdi
callq 0x20ae0
| _ZZN5minja6Parser11parseStringB5cxx11EvENKUlcE_clB5cxx11Ec:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rbx, rdi
mov r12, [rsi]
mov rcx, [r12+18h]
mov rax, [r12+20h]
cmp rax, rcx
jz loc_E5991
mov ebp, edx
cmp [rax], bpl
jnz loc_E5991
lea r14, [rsp+58h+var_40]
mov [r14-10h], r14
mov qword ptr [r14-8], 0
mov byte ptr [r14], 0
lea rdx, [rax+1]
mov [r12+20h], rdx
cmp rdx, rcx
jz loc_E59AA
xor edx, edx
mov r13d, 1A29h
lea r15, [rsp+58h+var_50]
loc_E591A:
mov cl, [rax+1]
test dl, 1
jz short loc_E5943
movsx eax, cl
add eax, 0FFFFFFA4h
ror eax, 1
cmp eax, 0Ch
ja short loc_E594F
bt r13d, eax
jnb short loc_E594F
mov eax, eax
lea rcx, unk_11E998
mov cl, [rax+rcx]
jmp short loc_E594F
loc_E5943:
mov dl, 1
cmp cl, 5Ch ; '\'
jz short loc_E595C
cmp cl, bpl
jz short loc_E59AF
loc_E594F:
movsx esi, cl
mov rdi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
xor edx, edx
loc_E595C:
mov rax, [r12+20h]
lea rcx, [rax+1]
mov [r12+20h], rcx
cmp rcx, [r12+18h]
jnz short loc_E591A
mov rdi, [rsp+58h+var_50]; void *
mov qword ptr [rbx], 0
cmp rdi, r14
jz short loc_E5998
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_E5998
loc_E5991:
mov qword ptr [rbx], 0
loc_E5998:
mov rax, rbx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_E59AA:
xor r15d, r15d
jmp short loc_E5A0B
loc_E59AF:
add rax, 2
mov [r12+20h], rax
mov edi, 20h ; ' '; unsigned __int64
call __Znwm; operator new(ulong)
mov r15, rax
mov rdi, rax
add rdi, 10h
mov [rax], rdi
mov rax, [rsp+58h+var_50]
cmp rax, r14
jz short loc_E59EC
mov [r15], rax
mov rax, [rsp+58h+var_40]
mov [r15+10h], rax
mov r12, [rsp+58h+var_48]
jmp short loc_E59FE
loc_E59EC:
mov r12, [rsp+58h+var_48]
lea rdx, [r12+1]
mov rsi, r14
call _memcpy
loc_E59FE:
mov [r15+8], r12
mov [rsp+58h+var_48], 0
loc_E5A0B:
mov [rbx], r15
jmp short loc_E5998
jmp short $+2
loc_E5A12:
mov rbx, rax
mov rdi, [rsp+arg_0]; void *
cmp rdi, r14
jz short loc_E5A2C
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_E5A2C:
mov rdi, rbx
call __Unwind_Resume
| void *** minja::Parser::parseString[abi:cxx11](void)::{lambda(char)#1}::operator()[abi:cxx11](
void ***a1,
long long *a2,
char a3)
{
long long v4; // r12
_BYTE *v5; // rcx
_BYTE *v6; // rax
char v8; // dl
int v9; // r13d
char v10; // cl
unsigned int v11; // eax
_QWORD *v12; // rdi
void **v14; // r15
void *v15; // r12
void *v16; // [rsp+8h] [rbp-50h] BYREF
char *v17; // [rsp+10h] [rbp-48h]
_QWORD v18[8]; // [rsp+18h] [rbp-40h] BYREF
v4 = *a2;
v5 = *(_BYTE **)(*a2 + 24);
v6 = *(_BYTE **)(*a2 + 32);
if ( v6 == v5 || *v6 != a3 )
{
*a1 = 0LL;
return a1;
}
v16 = v18;
v17 = 0LL;
LOBYTE(v18[0]) = 0;
*(_QWORD *)(v4 + 32) = v6 + 1;
if ( v6 + 1 == v5 )
{
v14 = 0LL;
goto LABEL_22;
}
v8 = 0;
v9 = 6697;
while ( 1 )
{
v10 = v6[1];
if ( (v8 & 1) != 0 )
{
v11 = __ROR4__(v10 - 92, 1);
if ( v11 <= 0xC && _bittest(&v9, v11) )
v10 = byte_11E998[v11];
goto LABEL_11;
}
v8 = 1;
if ( v10 != 92 )
break;
LABEL_12:
v6 = *(_BYTE **)(v4 + 32);
*(_QWORD *)(v4 + 32) = v6 + 1;
if ( v6 + 1 == *(_BYTE **)(v4 + 24) )
{
v12 = v16;
*a1 = 0LL;
if ( v12 != v18 )
operator delete(v12, v18[0] + 1LL);
return a1;
}
}
if ( v10 != a3 )
{
LABEL_11:
std::string::push_back(&v16, (unsigned int)v10);
v8 = 0;
goto LABEL_12;
}
*(_QWORD *)(v4 + 32) = v6 + 2;
v14 = (void **)operator new(0x20uLL);
*v14 = v14 + 2;
if ( v16 == v18 )
{
v15 = v17;
memcpy(v14 + 2, v18, v17 + 1);
}
else
{
*v14 = v16;
v14[2] = (void *)v18[0];
v15 = v17;
}
v14[1] = v15;
v17 = 0LL;
LABEL_22:
*a1 = v14;
return a1;
}
| operator()[abi:cxx11]:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
MOV R12,qword ptr [RSI]
MOV RCX,qword ptr [R12 + 0x18]
MOV RAX,qword ptr [R12 + 0x20]
CMP RAX,RCX
JZ 0x001e5991
MOV EBP,EDX
CMP byte ptr [RAX],BPL
JNZ 0x001e5991
LEA R14,[RSP + 0x18]
MOV qword ptr [R14 + -0x10],R14
MOV qword ptr [R14 + -0x8],0x0
MOV byte ptr [R14],0x0
LEA RDX,[RAX + 0x1]
MOV qword ptr [R12 + 0x20],RDX
CMP RDX,RCX
JZ 0x001e59aa
XOR EDX,EDX
MOV R13D,0x1a29
LEA R15,[RSP + 0x8]
LAB_001e591a:
MOV CL,byte ptr [RAX + 0x1]
TEST DL,0x1
JZ 0x001e5943
MOVSX EAX,CL
ADD EAX,-0x5c
ROR EAX,0x1
CMP EAX,0xc
JA 0x001e594f
BT R13D,EAX
JNC 0x001e594f
MOV EAX,EAX
LEA RCX,[0x21e998]
MOV CL,byte ptr [RAX + RCX*0x1]
JMP 0x001e594f
LAB_001e5943:
MOV DL,0x1
CMP CL,0x5c
JZ 0x001e595c
CMP CL,BPL
JZ 0x001e59af
LAB_001e594f:
MOVSX ESI,CL
MOV RDI,R15
CALL 0x00121390
XOR EDX,EDX
LAB_001e595c:
MOV RAX,qword ptr [R12 + 0x20]
LEA RCX,[RAX + 0x1]
MOV qword ptr [R12 + 0x20],RCX
CMP RCX,qword ptr [R12 + 0x18]
JNZ 0x001e591a
MOV RDI,qword ptr [RSP + 0x8]
MOV qword ptr [RBX],0x0
CMP RDI,R14
JZ 0x001e5998
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x00120180
JMP 0x001e5998
LAB_001e5991:
MOV qword ptr [RBX],0x0
LAB_001e5998:
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001e59aa:
XOR R15D,R15D
JMP 0x001e5a0b
LAB_001e59af:
ADD RAX,0x2
MOV qword ptr [R12 + 0x20],RAX
LAB_001e59b8:
MOV EDI,0x20
CALL 0x00120210
LAB_001e59c2:
MOV R15,RAX
MOV RDI,RAX
ADD RDI,0x10
MOV qword ptr [RAX],RDI
MOV RAX,qword ptr [RSP + 0x8]
CMP RAX,R14
JZ 0x001e59ec
MOV qword ptr [R15],RAX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [R15 + 0x10],RAX
MOV R12,qword ptr [RSP + 0x10]
JMP 0x001e59fe
LAB_001e59ec:
MOV R12,qword ptr [RSP + 0x10]
LEA RDX,[R12 + 0x1]
MOV RSI,R14
CALL 0x001200f0
LAB_001e59fe:
MOV qword ptr [R15 + 0x8],R12
MOV qword ptr [RSP + 0x10],0x0
LAB_001e5a0b:
MOV qword ptr [RBX],R15
JMP 0x001e5998
|
/* operator()[abi:cxx11](char) const */
int8 *
minja::Parser::parseString[abi:cxx11]()::{lambda(char)#1}::operator()[abi_cxx11_(char param_1)
{
long lVar1;
char *pcVar2;
int8 *puVar3;
char in_DL;
bool bVar4;
long *in_RSI;
int7 in_register_00000039;
int8 *puVar5;
int1 *local_50;
long local_48;
int1 local_40;
int7 uStack_3f;
puVar5 = (int8 *)CONCAT71(in_register_00000039,param_1);
lVar1 = *in_RSI;
pcVar2 = *(char **)(lVar1 + 0x20);
if ((pcVar2 == *(char **)(lVar1 + 0x18)) || (*pcVar2 != in_DL)) {
*puVar5 = 0;
}
else {
local_48 = 0;
local_40 = 0;
*(char **)(lVar1 + 0x20) = pcVar2 + 1;
if (pcVar2 + 1 == *(char **)(lVar1 + 0x18)) {
puVar3 = (int8 *)0x0;
LAB_001e5a0b:
*puVar5 = puVar3;
}
else {
bVar4 = false;
local_50 = &local_40;
do {
if (bVar4) {
LAB_001e594f:
/* try { // try from 001e594f to 001e5959 has its CatchHandler @ 001e5a12 */
std::__cxx11::string::push_back((char)&local_50);
bVar4 = false;
}
else {
bVar4 = true;
if (pcVar2[1] != '\\') {
if (pcVar2[1] != in_DL) goto LAB_001e594f;
*(char **)(lVar1 + 0x20) = pcVar2 + 2;
/* try { // try from 001e59b8 to 001e59c1 has its CatchHandler @ 001e5a10 */
puVar3 = (int8 *)operator_new(0x20);
lVar1 = local_48;
*puVar3 = puVar3 + 2;
if (local_50 == &local_40) {
memcpy(puVar3 + 2,&local_40,local_48 + 1);
}
else {
*puVar3 = local_50;
puVar3[2] = CONCAT71(uStack_3f,local_40);
}
puVar3[1] = lVar1;
goto LAB_001e5a0b;
}
}
pcVar2 = *(char **)(lVar1 + 0x20);
*(char **)(lVar1 + 0x20) = pcVar2 + 1;
} while (pcVar2 + 1 != *(char **)(lVar1 + 0x18));
*puVar5 = 0;
if (local_50 != &local_40) {
operator_delete(local_50,CONCAT71(uStack_3f,local_40) + 1);
}
}
}
return puVar5;
}
|
|
999 | Config::Location::operator==(Config::Location const&) const | Dolphin-anty/Source/Core/Common/Config/ConfigInfo.cpp | bool Location::operator==(const Location& other) const
{
return system == other.system && strcasecmp(section.c_str(), other.section.c_str()) == 0 &&
strcasecmp(key.c_str(), other.key.c_str()) == 0;
} | O3 | cpp | Config::Location::operator==(Config::Location const&) const:
movl (%rdi), %eax
cmpl (%rsi), %eax
jne 0x19651
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq 0x8(%rsi), %rsi
callq 0x7410
testl %eax, %eax
je 0x19654
xorl %eax, %eax
jmp 0x19666
xorl %eax, %eax
retq
movq 0x28(%r14), %rdi
movq 0x28(%rbx), %rsi
callq 0x7410
testl %eax, %eax
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| _ZNK6Config8LocationeqERKS0_:
mov eax, [rdi]
cmp eax, [rsi]
jnz short loc_19651
push r14
push rbx
push rax
mov rbx, rsi
mov r14, rdi
mov rdi, [rdi+8]
mov rsi, [rsi+8]
call _strcasecmp
test eax, eax
jz short loc_19654
xor eax, eax
jmp short loc_19666
loc_19651:
xor eax, eax
retn
loc_19654:
mov rdi, [r14+28h]
mov rsi, [rbx+28h]
call _strcasecmp
test eax, eax
setz al
loc_19666:
add rsp, 8
pop rbx
pop r14
retn
| bool Config::Location::operator==(long long a1, long long a2, long long a3, long long a4)
{
long long v4; // rdx
long long v5; // rcx
if ( *(_DWORD *)a1 != *(_DWORD *)a2 )
return 0;
if ( !(unsigned int)strcasecmp(*(_QWORD *)(a1 + 8), *(_QWORD *)(a2 + 8), a3, a4) )
return (unsigned int)strcasecmp(*(_QWORD *)(a1 + 40), *(_QWORD *)(a2 + 40), v4, v5) == 0;
return 0;
}
| operator==:
MOV EAX,dword ptr [RDI]
CMP EAX,dword ptr [RSI]
JNZ 0x00119651
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
MOV RDI,qword ptr [RDI + 0x8]
MOV RSI,qword ptr [RSI + 0x8]
CALL 0x00107410
TEST EAX,EAX
JZ 0x00119654
XOR EAX,EAX
JMP 0x00119666
LAB_00119651:
XOR EAX,EAX
RET
LAB_00119654:
MOV RDI,qword ptr [R14 + 0x28]
MOV RSI,qword ptr [RBX + 0x28]
CALL 0x00107410
TEST EAX,EAX
SETZ AL
LAB_00119666:
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* Config::Location::TEMPNAMEPLACEHOLDERVALUE(Config::Location const&) const */
int8 __thiscall Config::Location::operator==(Location *this,Location *param_1)
{
int iVar1;
int4 extraout_var;
int8 uVar2;
if (*(int *)this == *(int *)param_1) {
iVar1 = strcasecmp(*(char **)(this + 8),*(char **)(param_1 + 8));
if (iVar1 == 0) {
iVar1 = strcasecmp(*(char **)(this + 0x28),*(char **)(param_1 + 0x28));
uVar2 = CONCAT71((int7)(CONCAT44(extraout_var,iVar1) >> 8),iVar1 == 0);
}
else {
uVar2 = 0;
}
return uVar2;
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.