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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
43,500 | init_key_cache_internal | eloqsql/mysys/mf_keycache.c | static
int init_key_cache_internal(KEY_CACHE *keycache, uint key_cache_block_size,
size_t use_mem, uint division_limit,
uint age_threshold, uint changed_blocks_hash_size,
uint partitions,
my_bool use_op_lock)
{
void *keycache_cb;
int blocks;
if (keycache->key_cache_inited)
{
if (use_op_lock)
pthread_mutex_lock(&keycache->op_lock);
keycache_cb= keycache->keycache_cb;
}
else
{
if (partitions == 0)
{
if (!(keycache_cb= (void *) my_malloc(key_memory_KEY_CACHE,
sizeof(SIMPLE_KEY_CACHE_CB),
MYF(0))))
return 0;
((SIMPLE_KEY_CACHE_CB *) keycache_cb)->key_cache_inited= 0;
keycache->key_cache_type= SIMPLE_KEY_CACHE;
keycache->interface_funcs= &simple_key_cache_funcs;
}
else
{
if (!(keycache_cb= (void *) my_malloc(key_memory_KEY_CACHE,
sizeof(PARTITIONED_KEY_CACHE_CB),
MYF(0))))
return 0;
((PARTITIONED_KEY_CACHE_CB *) keycache_cb)->key_cache_inited= 0;
keycache->key_cache_type= PARTITIONED_KEY_CACHE;
keycache->interface_funcs= &partitioned_key_cache_funcs;
}
/*
Initialize op_lock if it's not initialized before.
The mutex may have been initialized before if we are being called
from repartition_key_cache_internal().
*/
if (use_op_lock)
pthread_mutex_init(&keycache->op_lock, MY_MUTEX_INIT_FAST);
keycache->keycache_cb= keycache_cb;
keycache->key_cache_inited= 1;
if (use_op_lock)
pthread_mutex_lock(&keycache->op_lock);
}
if (partitions != 0)
{
((PARTITIONED_KEY_CACHE_CB *) keycache_cb)->partitions= partitions;
}
keycache->can_be_used= 0;
blocks= keycache->interface_funcs->init(keycache_cb, key_cache_block_size,
use_mem, division_limit,
age_threshold, changed_blocks_hash_size);
keycache->partitions= partitions ?
((PARTITIONED_KEY_CACHE_CB *) keycache_cb)->partitions :
0;
DBUG_ASSERT(partitions <= MAX_KEY_CACHE_PARTITIONS);
keycache->key_cache_mem_size=
keycache->partitions ?
((PARTITIONED_KEY_CACHE_CB *) keycache_cb)->key_cache_mem_size :
((SIMPLE_KEY_CACHE_CB *) keycache_cb)->key_cache_mem_size;
if (blocks > 0)
keycache->can_be_used= 1;
if (use_op_lock)
pthread_mutex_unlock(&keycache->op_lock);
return blocks;
} | O0 | c | init_key_cache_internal:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb 0x18(%rbp), %al
movl 0x10(%rbp), %eax
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x48(%rax)
je 0xe45f2
cmpb $0x0, 0x18(%rbp)
je 0xe45e1
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
callq 0x2a220
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0xe46d7
cmpl $0x0, 0x10(%rbp)
jne 0xe4647
leaq 0xb9ecb9(%rip), %rax # 0xc832b8
movl (%rax), %edi
movl $0x170, %esi # imm = 0x170
xorl %eax, %eax
movl %eax, %edx
callq 0xf3830
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0xe4625
movl $0x0, -0x4(%rbp)
jmp 0xe4791
movq -0x38(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
leaq 0x1db167(%rip), %rcx # 0x2bf7a8
movq %rcx, 0x10(%rax)
jmp 0xe4694
leaq 0xb9ec6a(%rip), %rax # 0xc832b8
movl (%rax), %edi
movl $0x20, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xf3830
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0xe4674
movl $0x0, -0x4(%rbp)
jmp 0xe4791
movq -0x38(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movq -0x10(%rbp), %rax
leaq 0x1db168(%rip), %rcx # 0x2bf7f8
movq %rcx, 0x10(%rax)
cmpb $0x0, 0x18(%rbp)
je 0xe46ae
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
leaq 0xb9ef87(%rip), %rsi # 0xc83630
callq 0x2a340
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x48(%rax)
cmpb $0x0, 0x18(%rbp)
je 0xe46d5
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
callq 0x2a220
jmp 0xe46d7
cmpl $0x0, 0x10(%rbp)
je 0xe46e7
movl 0x10(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x49(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %r8d
movl -0x2c(%rbp), %r9d
callq *%rax
movl %eax, -0x3c(%rbp)
cmpl $0x0, 0x10(%rbp)
je 0xe4727
movq -0x38(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x40(%rbp)
jmp 0xe472e
xorl %eax, %eax
movl %eax, -0x40(%rbp)
jmp 0xe472e
movl -0x40(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4c(%rax)
jmp 0xe473a
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4c(%rax)
je 0xe4752
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0xe475e
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
cmpl $0x0, -0x3c(%rbp)
jle 0xe4778
movq -0x10(%rbp), %rax
movb $0x1, 0x49(%rax)
cmpb $0x0, 0x18(%rbp)
je 0xe478b
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
callq 0x2a1f0
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| init_key_cache_internal:
push rbp
mov rbp, rsp
sub rsp, 50h
mov al, [rbp+arg_8]
mov eax, [rbp+arg_0]
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov [rbp+var_24], ecx
mov [rbp+var_28], r8d
mov [rbp+var_2C], r9d
mov rax, [rbp+var_10]
cmp byte ptr [rax+48h], 0
jz short loc_E45F2
cmp [rbp+arg_8], 0
jz short loc_E45E1
mov rdi, [rbp+var_10]
add rdi, 58h ; 'X'
call _pthread_mutex_lock
loc_E45E1:
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rbp+var_38], rax
jmp loc_E46D7
loc_E45F2:
cmp [rbp+arg_0], 0
jnz short loc_E4647
lea rax, key_memory_KEY_CACHE
mov edi, [rax]
mov esi, 170h
xor eax, eax
mov edx, eax
call my_malloc
mov [rbp+var_38], rax
cmp rax, 0
jnz short loc_E4625
mov [rbp+var_4], 0
jmp loc_E4791
loc_E4625:
mov rax, [rbp+var_38]
mov byte ptr [rax], 0
mov rax, [rbp+var_10]
mov dword ptr [rax], 0
mov rax, [rbp+var_10]
lea rcx, simple_key_cache_funcs
mov [rax+10h], rcx
jmp short loc_E4694
loc_E4647:
lea rax, key_memory_KEY_CACHE
mov edi, [rax]
mov esi, 20h ; ' '
xor eax, eax
mov edx, eax
call my_malloc
mov [rbp+var_38], rax
cmp rax, 0
jnz short loc_E4674
mov [rbp+var_4], 0
jmp loc_E4791
loc_E4674:
mov rax, [rbp+var_38]
mov byte ptr [rax], 0
mov rax, [rbp+var_10]
mov dword ptr [rax], 1
mov rax, [rbp+var_10]
lea rcx, partitioned_key_cache_funcs
mov [rax+10h], rcx
loc_E4694:
cmp [rbp+arg_8], 0
jz short loc_E46AE
mov rdi, [rbp+var_10]
add rdi, 58h ; 'X'
lea rsi, my_fast_mutexattr
call _pthread_mutex_init
loc_E46AE:
mov rcx, [rbp+var_38]
mov rax, [rbp+var_10]
mov [rax+8], rcx
mov rax, [rbp+var_10]
mov byte ptr [rax+48h], 1
cmp [rbp+arg_8], 0
jz short loc_E46D5
mov rdi, [rbp+var_10]
add rdi, 58h ; 'X'
call _pthread_mutex_lock
loc_E46D5:
jmp short $+2
loc_E46D7:
cmp [rbp+arg_0], 0
jz short loc_E46E7
mov ecx, [rbp+arg_0]
mov rax, [rbp+var_38]
mov [rax+1Ch], ecx
loc_E46E7:
mov rax, [rbp+var_10]
mov byte ptr [rax+49h], 0
mov rax, [rbp+var_10]
mov rax, [rax+10h]
mov rax, [rax]
mov rdi, [rbp+var_38]
mov esi, [rbp+var_14]
mov rdx, [rbp+var_20]
mov ecx, [rbp+var_24]
mov r8d, [rbp+var_28]
mov r9d, [rbp+var_2C]
call rax
mov [rbp+var_3C], eax
cmp [rbp+arg_0], 0
jz short loc_E4727
mov rax, [rbp+var_38]
mov eax, [rax+1Ch]
mov [rbp+var_40], eax
jmp short loc_E472E
loc_E4727:
xor eax, eax
mov [rbp+var_40], eax
jmp short $+2
loc_E472E:
mov ecx, [rbp+var_40]
mov rax, [rbp+var_10]
mov [rax+4Ch], ecx
jmp short $+2
loc_E473A:
mov rax, [rbp+var_10]
cmp dword ptr [rax+4Ch], 0
jz short loc_E4752
mov rax, [rbp+var_38]
mov rax, [rax+10h]
mov [rbp+var_48], rax
jmp short loc_E475E
loc_E4752:
mov rax, [rbp+var_38]
mov rax, [rax+8]
mov [rbp+var_48], rax
loc_E475E:
mov rcx, [rbp+var_48]
mov rax, [rbp+var_10]
mov [rax+50h], rcx
cmp [rbp+var_3C], 0
jle short loc_E4778
mov rax, [rbp+var_10]
mov byte ptr [rax+49h], 1
loc_E4778:
cmp [rbp+arg_8], 0
jz short loc_E478B
mov rdi, [rbp+var_10]
add rdi, 58h ; 'X'
call _pthread_mutex_unlock
loc_E478B:
mov eax, [rbp+var_3C]
mov [rbp+var_4], eax
loc_E4791:
mov eax, [rbp+var_4]
add rsp, 50h
pop rbp
retn
| long long init_key_cache_internal(
long long a1,
unsigned int a2,
long long a3,
unsigned int a4,
unsigned int a5,
unsigned int a6,
int a7,
char a8)
{
long long v9; // [rsp+8h] [rbp-48h]
int v10; // [rsp+10h] [rbp-40h]
int v11; // [rsp+14h] [rbp-3Ch]
long long v12; // [rsp+18h] [rbp-38h]
if ( *(_BYTE *)(a1 + 72) )
{
if ( a8 )
pthread_mutex_lock(a1 + 88);
v12 = *(_QWORD *)(a1 + 8);
}
else
{
if ( a7 )
{
v12 = my_malloc(key_memory_KEY_CACHE, 32LL, 0LL);
if ( !v12 )
return 0;
*(_BYTE *)v12 = 0;
*(_DWORD *)a1 = 1;
*(_QWORD *)(a1 + 16) = partitioned_key_cache_funcs;
}
else
{
v12 = my_malloc(key_memory_KEY_CACHE, 368LL, 0LL);
if ( !v12 )
return 0;
*(_BYTE *)v12 = 0;
*(_DWORD *)a1 = 0;
*(_QWORD *)(a1 + 16) = simple_key_cache_funcs;
}
if ( a8 )
pthread_mutex_init(a1 + 88, &my_fast_mutexattr);
*(_QWORD *)(a1 + 8) = v12;
*(_BYTE *)(a1 + 72) = 1;
if ( a8 )
pthread_mutex_lock(a1 + 88);
}
if ( a7 )
*(_DWORD *)(v12 + 28) = a7;
*(_BYTE *)(a1 + 73) = 0;
v11 = (**(long long ( ***)(long long, _QWORD, long long, _QWORD, _QWORD, _QWORD))(a1 + 16))(
v12,
a2,
a3,
a4,
a5,
a6);
if ( a7 )
v10 = *(_DWORD *)(v12 + 28);
else
v10 = 0;
*(_DWORD *)(a1 + 76) = v10;
if ( *(_DWORD *)(a1 + 76) )
v9 = *(_QWORD *)(v12 + 16);
else
v9 = *(_QWORD *)(v12 + 8);
*(_QWORD *)(a1 + 80) = v9;
if ( v11 > 0 )
*(_BYTE *)(a1 + 73) = 1;
if ( a8 )
pthread_mutex_unlock(a1 + 88);
return (unsigned int)v11;
}
| init_key_cache_internal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV AL,byte ptr [RBP + 0x18]
MOV EAX,dword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV dword ptr [RBP + -0x24],ECX
MOV dword ptr [RBP + -0x28],R8D
MOV dword ptr [RBP + -0x2c],R9D
MOV RAX,qword ptr [RBP + -0x10]
CMP byte ptr [RAX + 0x48],0x0
JZ 0x001e45f2
CMP byte ptr [RBP + 0x18],0x0
JZ 0x001e45e1
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x58
CALL 0x0012a220
LAB_001e45e1:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x38],RAX
JMP 0x001e46d7
LAB_001e45f2:
CMP dword ptr [RBP + 0x10],0x0
JNZ 0x001e4647
LEA RAX,[0xd832b8]
MOV EDI,dword ptr [RAX]
MOV ESI,0x170
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001f3830
MOV qword ptr [RBP + -0x38],RAX
CMP RAX,0x0
JNZ 0x001e4625
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001e4791
LAB_001e4625:
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x10]
LEA RCX,[0x3bf7a8]
MOV qword ptr [RAX + 0x10],RCX
JMP 0x001e4694
LAB_001e4647:
LEA RAX,[0xd832b8]
MOV EDI,dword ptr [RAX]
MOV ESI,0x20
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001f3830
MOV qword ptr [RBP + -0x38],RAX
CMP RAX,0x0
JNZ 0x001e4674
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001e4791
LAB_001e4674:
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],0x1
MOV RAX,qword ptr [RBP + -0x10]
LEA RCX,[0x3bf7f8]
MOV qword ptr [RAX + 0x10],RCX
LAB_001e4694:
CMP byte ptr [RBP + 0x18],0x0
JZ 0x001e46ae
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x58
LEA RSI,[0xd83630]
CALL 0x0012a340
LAB_001e46ae:
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x48],0x1
CMP byte ptr [RBP + 0x18],0x0
JZ 0x001e46d5
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x58
CALL 0x0012a220
LAB_001e46d5:
JMP 0x001e46d7
LAB_001e46d7:
CMP dword ptr [RBP + 0x10],0x0
JZ 0x001e46e7
MOV ECX,dword ptr [RBP + 0x10]
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x1c],ECX
LAB_001e46e7:
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x49],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RBP + -0x38]
MOV ESI,dword ptr [RBP + -0x14]
MOV RDX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x24]
MOV R8D,dword ptr [RBP + -0x28]
MOV R9D,dword ptr [RBP + -0x2c]
CALL RAX
MOV dword ptr [RBP + -0x3c],EAX
CMP dword ptr [RBP + 0x10],0x0
JZ 0x001e4727
MOV RAX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RAX + 0x1c]
MOV dword ptr [RBP + -0x40],EAX
JMP 0x001e472e
LAB_001e4727:
XOR EAX,EAX
MOV dword ptr [RBP + -0x40],EAX
JMP 0x001e472e
LAB_001e472e:
MOV ECX,dword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x4c],ECX
JMP 0x001e473a
LAB_001e473a:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x4c],0x0
JZ 0x001e4752
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x48],RAX
JMP 0x001e475e
LAB_001e4752:
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x48],RAX
LAB_001e475e:
MOV RCX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x50],RCX
CMP dword ptr [RBP + -0x3c],0x0
JLE 0x001e4778
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x49],0x1
LAB_001e4778:
CMP byte ptr [RBP + 0x18],0x0
JZ 0x001e478b
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x58
CALL 0x0012a1f0
LAB_001e478b:
MOV EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x4],EAX
LAB_001e4791:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x50
POP RBP
RET
|
int init_key_cache_internal
(int4 *param_1,int4 param_2,int8 param_3,int4 param_4,
int4 param_5,int4 param_6,int param_7,char param_8)
{
int iVar1;
int8 local_50;
int4 local_48;
int1 *local_40;
if (*(char *)(param_1 + 0x12) == '\0') {
if (param_7 == 0) {
local_40 = (int1 *)my_malloc(key_memory_KEY_CACHE,0x170,0);
if (local_40 == (int1 *)0x0) {
return 0;
}
*local_40 = 0;
*param_1 = 0;
*(int1 **)(param_1 + 4) = simple_key_cache_funcs;
}
else {
local_40 = (int1 *)my_malloc(key_memory_KEY_CACHE,0x20,0);
if (local_40 == (int1 *)0x0) {
return 0;
}
*local_40 = 0;
*param_1 = 1;
*(int1 **)(param_1 + 4) = partitioned_key_cache_funcs;
}
if (param_8 != '\0') {
pthread_mutex_init((pthread_mutex_t *)(param_1 + 0x16),
(pthread_mutexattr_t *)&my_fast_mutexattr);
}
*(int1 **)(param_1 + 2) = local_40;
*(int1 *)(param_1 + 0x12) = 1;
if (param_8 != '\0') {
pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x16));
}
}
else {
if (param_8 != '\0') {
pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x16));
}
local_40 = *(int1 **)(param_1 + 2);
}
if (param_7 != 0) {
*(int *)(local_40 + 0x1c) = param_7;
}
*(int1 *)((long)param_1 + 0x49) = 0;
iVar1 = (*(code *)**(int8 **)(param_1 + 4))
(local_40,param_2,param_3,param_4,param_5,param_6);
if (param_7 == 0) {
local_48 = 0;
}
else {
local_48 = *(int4 *)(local_40 + 0x1c);
}
param_1[0x13] = local_48;
if (param_1[0x13] == 0) {
local_50 = *(int8 *)(local_40 + 8);
}
else {
local_50 = *(int8 *)(local_40 + 0x10);
}
*(int8 *)(param_1 + 0x14) = local_50;
if (0 < iVar1) {
*(int1 *)((long)param_1 + 0x49) = 1;
}
if (param_8 != '\0') {
pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x16));
}
return iVar1;
}
| |
43,501 | ggml_view_2d | monkey531[P]llama/ggml/src/ggml.c | struct ggml_tensor * ggml_view_2d(
struct ggml_context * ctx,
struct ggml_tensor * a,
int64_t ne0,
int64_t ne1,
size_t nb1,
size_t offset) {
const int64_t ne[2] = { ne0, ne1 };
struct ggml_tensor * result = ggml_view_impl(ctx, a, 2, ne, offset);
result->nb[1] = nb1;
result->nb[2] = result->nb[1]*ne1;
result->nb[3] = result->nb[2];
return result;
} | O0 | c | ggml_view_2d:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %r9, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
leaq 0x10(%rsp), %rcx
movq 0x28(%rsp), %r8
movl $0x2, %edx
callq 0x4def0
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rcx
imulq 0x38(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x40(%rax)
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x48(%rax)
movq 0x8(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
| ggml_view_2d:
sub rsp, 58h
mov [rsp+58h+var_8], rdi
mov [rsp+58h+var_10], rsi
mov [rsp+58h+var_18], rdx
mov [rsp+58h+var_20], rcx
mov [rsp+58h+var_28], r8
mov [rsp+58h+var_30], r9
mov rax, [rsp+58h+var_18]
mov [rsp+58h+var_48], rax
mov rax, [rsp+58h+var_20]
mov [rsp+58h+var_40], rax
mov rdi, [rsp+58h+var_8]
mov rsi, [rsp+58h+var_10]
lea rcx, [rsp+58h+var_48]
mov r8, [rsp+58h+var_30]
mov edx, 2
call ggml_view_impl
mov [rsp+58h+var_50], rax
mov rcx, [rsp+58h+var_28]
mov rax, [rsp+58h+var_50]
mov [rax+38h], rcx
mov rax, [rsp+58h+var_50]
mov rcx, [rax+38h]
imul rcx, [rsp+58h+var_20]
mov rax, [rsp+58h+var_50]
mov [rax+40h], rcx
mov rax, [rsp+58h+var_50]
mov rcx, [rax+40h]
mov rax, [rsp+58h+var_50]
mov [rax+48h], rcx
mov rax, [rsp+58h+var_50]
add rsp, 58h
retn
| _QWORD * ggml_view_2d(
long long a1,
unsigned int *a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
double a11,
double a12,
__m128 a13,
__m128 a14)
{
_QWORD *result; // rax
long long v15[4]; // [rsp+10h] [rbp-48h] BYREF
long long v16; // [rsp+30h] [rbp-28h]
long long v17; // [rsp+38h] [rbp-20h]
long long v18; // [rsp+40h] [rbp-18h]
unsigned int *v19; // [rsp+48h] [rbp-10h]
long long v20; // [rsp+50h] [rbp-8h]
v20 = a1;
v19 = a2;
v18 = a3;
v17 = a4;
v16 = a5;
v15[3] = a6;
v15[0] = a3;
v15[1] = a4;
result = ggml_view_impl(a1, a2, 2, v15, a6, a7, a8, a9, a10, a11, a12, a13, a14);
result[7] = v16;
result[8] = v17 * result[7];
result[9] = result[8];
return result;
}
| ggml_view_2d:
SUB RSP,0x58
MOV qword ptr [RSP + 0x50],RDI
MOV qword ptr [RSP + 0x48],RSI
MOV qword ptr [RSP + 0x40],RDX
MOV qword ptr [RSP + 0x38],RCX
MOV qword ptr [RSP + 0x30],R8
MOV qword ptr [RSP + 0x28],R9
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x18],RAX
MOV RDI,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RSP + 0x48]
LEA RCX,[RSP + 0x10]
MOV R8,qword ptr [RSP + 0x28]
MOV EDX,0x2
CALL 0x0014def0
MOV qword ptr [RSP + 0x8],RAX
MOV RCX,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RAX + 0x38],RCX
MOV RAX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RAX + 0x38]
IMUL RCX,qword ptr [RSP + 0x38]
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RAX + 0x40],RCX
MOV RAX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RAX + 0x40]
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RAX + 0x48],RCX
MOV RAX,qword ptr [RSP + 0x8]
ADD RSP,0x58
RET
|
long ggml_view_2d(int8 param_1,int8 param_2,int8 param_3,long param_4,
int8 param_5,int8 param_6)
{
long lVar1;
int8 local_48;
long local_40;
int8 local_30;
int8 local_28;
long local_20;
int8 local_18;
int8 local_10;
int8 local_8;
local_48 = param_3;
local_40 = param_4;
local_30 = param_6;
local_28 = param_5;
local_20 = param_4;
local_18 = param_3;
local_10 = param_2;
local_8 = param_1;
lVar1 = ggml_view_impl(param_1,param_2,2,&local_48,param_6);
*(int8 *)(lVar1 + 0x38) = local_28;
*(long *)(lVar1 + 0x40) = *(long *)(lVar1 + 0x38) * local_20;
*(int8 *)(lVar1 + 0x48) = *(int8 *)(lVar1 + 0x40);
return lVar1;
}
| |
43,502 | ggml_view_2d | monkey531[P]llama/ggml/src/ggml.c | struct ggml_tensor * ggml_view_2d(
struct ggml_context * ctx,
struct ggml_tensor * a,
int64_t ne0,
int64_t ne1,
size_t nb1,
size_t offset) {
const int64_t ne[2] = { ne0, ne1 };
struct ggml_tensor * result = ggml_view_impl(ctx, a, 2, ne, offset);
result->nb[1] = nb1;
result->nb[2] = result->nb[1]*ne1;
result->nb[3] = result->nb[2];
return result;
} | O1 | c | ggml_view_2d:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rsp, %rcx
movq %rdx, (%rcx)
movq %r14, 0x8(%rcx)
movl $0x2, %edx
movq %r9, %r8
callq 0x1be86
movq %rbx, 0x38(%rax)
imulq %r14, %rbx
movq %rbx, 0x40(%rax)
movq %rbx, 0x48(%rax)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
| ggml_view_2d:
push r14
push rbx
sub rsp, 18h
mov rbx, r8
mov r14, rcx
mov rcx, rsp
mov [rcx], rdx
mov [rcx+8], r14
mov edx, 2
mov r8, r9
call ggml_view_impl
mov [rax+38h], rbx
imul rbx, r14
mov [rax+40h], rbx
mov [rax+48h], rbx
add rsp, 18h
pop rbx
pop r14
retn
| _QWORD * ggml_view_2d(long long a1, unsigned int *a2, long long a3, long long a4, long long a5, long long a6)
{
_QWORD *result; // rax
long long v9; // rbx
_QWORD v10[5]; // [rsp+0h] [rbp-28h] BYREF
v10[0] = a3;
v10[1] = a4;
result = (_QWORD *)ggml_view_impl(a1, a2, 2, v10, a6);
result[7] = a5;
v9 = a4 * a5;
result[8] = v9;
result[9] = v9;
return result;
}
| ggml_view_2d:
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV RBX,R8
MOV R14,RCX
MOV RCX,RSP
MOV qword ptr [RCX],RDX
MOV qword ptr [RCX + 0x8],R14
MOV EDX,0x2
MOV R8,R9
CALL 0x0011be86
MOV qword ptr [RAX + 0x38],RBX
IMUL RBX,R14
MOV qword ptr [RAX + 0x40],RBX
MOV qword ptr [RAX + 0x48],RBX
ADD RSP,0x18
POP RBX
POP R14
RET
|
void ggml_view_2d(int8 param_1,int8 param_2,int8 param_3,long param_4,long param_5
,int8 param_6)
{
long lVar1;
int8 local_28;
long local_20;
local_28 = param_3;
local_20 = param_4;
lVar1 = ggml_view_impl(param_1,param_2,2,&local_28,param_6);
*(long *)(lVar1 + 0x38) = param_5;
*(long *)(lVar1 + 0x40) = param_5 * param_4;
*(long *)(lVar1 + 0x48) = param_5 * param_4;
return;
}
| |
43,503 | js_has_unscopable | bluesky950520[P]quickjs/quickjs.c | static __exception int js_has_unscopable(JSContext *ctx, JSValue obj,
JSAtom atom)
{
JSValue arr, val;
int ret;
arr = JS_GetProperty(ctx, obj, JS_ATOM_Symbol_unscopables);
if (JS_IsException(arr))
return -1;
ret = 0;
if (JS_IsObject(arr)) {
val = JS_GetProperty(ctx, arr, atom);
ret = JS_ToBoolFree(ctx, val);
}
JS_FreeValue(ctx, arr);
return ret;
} | O0 | c | js_has_unscopable:
subq $0x78, %rsp
movq %rsi, 0x60(%rsp)
movq %rdx, 0x68(%rsp)
movq %rdi, 0x58(%rsp)
movl %ecx, 0x54(%rsp)
movq 0x58(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rdx
movl $0xde, %ecx
callq 0x28ac0
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x22a00
cmpl $0x0, %eax
je 0x6c1df
movl $0xffffffff, 0x74(%rsp) # imm = 0xFFFFFFFF
jmp 0x6c265
movl $0x0, 0x2c(%rsp)
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x29cb0
cmpl $0x0, %eax
je 0x6c249
movq 0x58(%rsp), %rdi
movl 0x54(%rsp), %ecx
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x28ac0
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x58(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x2d070
movl %eax, 0x2c(%rsp)
movq 0x58(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x229d0
movl 0x2c(%rsp), %eax
movl %eax, 0x74(%rsp)
movl 0x74(%rsp), %eax
addq $0x78, %rsp
retq
nop
| js_has_unscopable:
sub rsp, 78h
mov [rsp+78h+var_18], rsi
mov [rsp+78h+var_10], rdx
mov [rsp+78h+var_20], rdi
mov [rsp+78h+var_24], ecx
mov rdi, [rsp+78h+var_20]
mov rsi, [rsp+78h+var_18]
mov rdx, [rsp+78h+var_10]
mov ecx, 0DEh
call JS_GetProperty
mov [rsp+78h+var_60], rax
mov [rsp+78h+var_58], rdx
mov rax, [rsp+78h+var_60]
mov [rsp+78h+var_38], rax
mov rax, [rsp+78h+var_58]
mov [rsp+78h+var_30], rax
mov rdi, [rsp+78h+var_38]
mov rsi, [rsp+78h+var_30]
call JS_IsException_1
cmp eax, 0
jz short loc_6C1DF
mov [rsp+78h+var_4], 0FFFFFFFFh
jmp loc_6C265
loc_6C1DF:
mov [rsp+78h+var_4C], 0
mov rdi, [rsp+78h+var_38]
mov rsi, [rsp+78h+var_30]
call JS_IsObject
cmp eax, 0
jz short loc_6C249
mov rdi, [rsp+78h+var_20]
mov ecx, [rsp+78h+var_24]
mov rsi, [rsp+78h+var_38]
mov rdx, [rsp+78h+var_30]
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_48], rax
mov rax, [rsp+78h+var_68]
mov [rsp+78h+var_40], rax
mov rdi, [rsp+78h+var_20]
mov rsi, [rsp+78h+var_48]
mov rdx, [rsp+78h+var_40]
call JS_ToBoolFree
mov [rsp+78h+var_4C], eax
loc_6C249:
mov rdi, [rsp+78h+var_20]
mov rsi, [rsp+78h+var_38]
mov rdx, [rsp+78h+var_30]
call JS_FreeValue
mov eax, [rsp+78h+var_4C]
mov [rsp+78h+var_4], eax
loc_6C265:
mov eax, [rsp+78h+var_4]
add rsp, 78h
retn
| long long js_has_unscopable(long long a1, int a2, int a3, int a4)
{
long long v4; // rdx
long long v5; // rdx
long long v7; // [rsp+8h] [rbp-70h]
long long Property; // [rsp+18h] [rbp-60h]
unsigned int v9; // [rsp+2Ch] [rbp-4Ch]
long long v10; // [rsp+48h] [rbp-30h]
Property = JS_GetProperty(a1, a2, a3, 222);
v10 = v4;
if ( JS_IsException_1(Property, v4) )
{
return (unsigned int)-1;
}
else
{
v9 = 0;
if ( JS_IsObject(Property, v10) )
{
v7 = JS_GetProperty(a1, Property, v10, a4);
v9 = JS_ToBoolFree(a1, v7, v5);
}
JS_FreeValue(a1, Property, v10);
return v9;
}
}
| js_has_unscopable:
SUB RSP,0x78
MOV qword ptr [RSP + 0x60],RSI
MOV qword ptr [RSP + 0x68],RDX
MOV qword ptr [RSP + 0x58],RDI
MOV dword ptr [RSP + 0x54],ECX
MOV RDI,qword ptr [RSP + 0x58]
MOV RSI,qword ptr [RSP + 0x60]
MOV RDX,qword ptr [RSP + 0x68]
MOV ECX,0xde
CALL 0x00128ac0
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x20],RDX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x40],RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x48],RAX
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x48]
CALL 0x00122a00
CMP EAX,0x0
JZ 0x0016c1df
MOV dword ptr [RSP + 0x74],0xffffffff
JMP 0x0016c265
LAB_0016c1df:
MOV dword ptr [RSP + 0x2c],0x0
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x48]
CALL 0x00129cb0
CMP EAX,0x0
JZ 0x0016c249
MOV RDI,qword ptr [RSP + 0x58]
MOV ECX,dword ptr [RSP + 0x54]
MOV RSI,qword ptr [RSP + 0x40]
MOV RDX,qword ptr [RSP + 0x48]
CALL 0x00128ac0
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],RDX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x38],RAX
MOV RDI,qword ptr [RSP + 0x58]
MOV RSI,qword ptr [RSP + 0x30]
MOV RDX,qword ptr [RSP + 0x38]
CALL 0x0012d070
MOV dword ptr [RSP + 0x2c],EAX
LAB_0016c249:
MOV RDI,qword ptr [RSP + 0x58]
MOV RSI,qword ptr [RSP + 0x40]
MOV RDX,qword ptr [RSP + 0x48]
CALL 0x001229d0
MOV EAX,dword ptr [RSP + 0x2c]
MOV dword ptr [RSP + 0x74],EAX
LAB_0016c265:
MOV EAX,dword ptr [RSP + 0x74]
ADD RSP,0x78
RET
|
int4
js_has_unscopable(int8 param_1,int8 param_2,int8 param_3,int4 param_4)
{
int iVar1;
int8 uVar2;
int8 uVar3;
int1 auVar4 [16];
int4 local_4c;
int4 local_4;
auVar4 = JS_GetProperty(param_1,param_2,param_3,0xde);
uVar3 = auVar4._8_8_;
uVar2 = auVar4._0_8_;
iVar1 = JS_IsException(uVar2,uVar3);
if (iVar1 == 0) {
local_4c = 0;
iVar1 = JS_IsObject(uVar2,uVar3);
if (iVar1 != 0) {
auVar4 = JS_GetProperty(param_1,uVar2,uVar3,param_4);
local_4c = JS_ToBoolFree(param_1,auVar4._0_8_,auVar4._8_8_);
}
JS_FreeValue(param_1,uVar2,uVar3);
local_4 = local_4c;
}
else {
local_4 = 0xffffffff;
}
return local_4;
}
| |
43,504 | google::protobuf::RepeatedField<unsigned int>::RepeatedField(google::protobuf::RepeatedField<unsigned int>&&) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/repeated_field.h | inline RepeatedField<Element>::RepeatedField(RepeatedField&& other) noexcept
: RepeatedField() {
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
CopyFrom(other);
#else // PROTOBUF_FORCE_COPY_IN_MOVE
// We don't just call Swap(&other) here because it would perform 3 copies if
// other is on an arena. This field can't be on an arena because arena
// construction always uses the Arena* accepting constructor.
if (other.GetOwningArena()) {
CopyFrom(other);
} else {
InternalSwap(&other);
}
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
} | O0 | c | google::protobuf::RepeatedField<unsigned int>::RepeatedField(google::protobuf::RepeatedField<unsigned int>&&):
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x1c9e90
movq 0x18(%rsp), %rdi
callq 0x1cac70
movq %rax, 0x10(%rsp)
jmp 0x1cac2e
movq 0x10(%rsp), %rax
cmpq $0x0, %rax
je 0x1cac4c
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x1cabc0
jmp 0x1cac4a
jmp 0x1cac5f
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x1cacc0
jmp 0x1cac5d
jmp 0x1cac5f
addq $0x28, %rsp
retq
movq %rax, %rdi
callq 0x16db0
nopl (%rax)
| _ZN6google8protobuf13RepeatedFieldIdEC2EOS2_:
sub rsp, 28h; Alternative name is 'google::protobuf::RepeatedField<double>::RepeatedField(google::protobuf::RepeatedField<double>&&)'
mov [rsp+28h+var_8], rdi
mov [rsp+28h+var_10], rsi
mov rdi, [rsp+28h+var_8]
mov [rsp+28h+var_20], rdi
call _ZN6google8protobuf13RepeatedFieldIdEC2Ev; google::protobuf::RepeatedField<double>::RepeatedField(void)
mov rdi, [rsp+28h+var_10]
call _ZNK6google8protobuf13RepeatedFieldIdE14GetOwningArenaEv; google::protobuf::RepeatedField<double>::GetOwningArena(void)
mov [rsp+28h+var_18], rax
jmp short $+2
loc_1CAC2E:
mov rax, [rsp+28h+var_18]
cmp rax, 0
jz short loc_1CAC4C
mov rdi, [rsp+28h+var_20]
mov rsi, [rsp+28h+var_10]
call _ZN6google8protobuf13RepeatedFieldIdE8CopyFromERKS2_; google::protobuf::RepeatedField<double>::CopyFrom(google::protobuf::RepeatedField<double> const&)
jmp short $+2
loc_1CAC4A:
jmp short loc_1CAC5F
loc_1CAC4C:
mov rdi, [rsp+28h+var_20]
mov rsi, [rsp+28h+var_10]
call _ZN6google8protobuf13RepeatedFieldIdE12InternalSwapEPS2_; google::protobuf::RepeatedField<double>::InternalSwap(google::protobuf::RepeatedField<double>*)
jmp short $+2
loc_1CAC5D:
jmp short $+2
loc_1CAC5F:
add rsp, 28h
retn
mov rdi, rax
call __clang_call_terminate
| long long google::protobuf::RepeatedField<double>::RepeatedField(long long a1, long long a2)
{
int v2; // edx
int v3; // ecx
int v4; // r8d
int v5; // r9d
google::protobuf::RepeatedField<double>::RepeatedField(a1);
if ( google::protobuf::RepeatedField<double>::GetOwningArena(a2) )
return google::protobuf::RepeatedField<double>::CopyFrom(a1, a2);
else
return google::protobuf::RepeatedField<double>::InternalSwap(a1, a2, v2, v3, v4, v5);
}
| |||
43,505 | google::protobuf::RepeatedField<unsigned int>::RepeatedField(google::protobuf::RepeatedField<unsigned int>&&) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/repeated_field.h | inline RepeatedField<Element>::RepeatedField(RepeatedField&& other) noexcept
: RepeatedField() {
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
CopyFrom(other);
#else // PROTOBUF_FORCE_COPY_IN_MOVE
// We don't just call Swap(&other) here because it would perform 3 copies if
// other is on an arena. This field can't be on an arena because arena
// construction always uses the Arena* accepting constructor.
if (other.GetOwningArena()) {
CopyFrom(other);
} else {
InternalSwap(&other);
}
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
} | O3 | c | google::protobuf::RepeatedField<unsigned int>::RepeatedField(google::protobuf::RepeatedField<unsigned int>&&):
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x8(%rsi), %rax
movq 0x8(%rsi), %rcx
addq $-0x8, %rcx
cmpl $0x0, 0x4(%rsi)
cmoveq %rax, %rcx
cmpq $0x0, (%rcx)
je 0xa5237
cmpq %r14, %rbx
je 0xa5241
movl (%rbx), %esi
testl %esi, %esi
je 0xa5241
movq %r14, %rdi
callq 0xa5098
movl (%rbx), %eax
movq 0x8(%r14), %rdi
addl %eax, (%r14)
movq 0x8(%rbx), %rsi
movslq (%rbx), %rdx
shlq $0x3, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xf2f0
movups (%rbx), %xmm1
movups %xmm1, (%r14)
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x13387
nop
| _ZN6google8protobuf13RepeatedFieldIdEC2EOS2_:
push r14; Alternative name is 'google::protobuf::RepeatedField<double>::RepeatedField(google::protobuf::RepeatedField<double>&&)'
push rbx
push rax
mov rbx, rsi
mov r14, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
lea rax, [rsi+8]
mov rcx, [rsi+8]
add rcx, 0FFFFFFFFFFFFFFF8h
cmp dword ptr [rsi+4], 0
cmovz rcx, rax
cmp qword ptr [rcx], 0
jz short loc_A5237
cmp rbx, r14
jz short loc_A5241
mov esi, [rbx]
test esi, esi
jz short loc_A5241
mov rdi, r14
call _ZN6google8protobuf13RepeatedFieldIdE7ReserveEi; google::protobuf::RepeatedField<double>::Reserve(int)
mov eax, [rbx]
mov rdi, [r14+8]
add [r14], eax
mov rsi, [rbx+8]
movsxd rdx, dword ptr [rbx]
shl rdx, 3
add rsp, 8
pop rbx
pop r14
jmp _memcpy
loc_A5237:
movups xmm1, xmmword ptr [rbx]
movups xmmword ptr [r14], xmm1
movups xmmword ptr [rbx], xmm0
loc_A5241:
add rsp, 8
pop rbx
pop r14
retn
mov rdi, rax
call __clang_call_terminate
| long long google::protobuf::RepeatedField<double>::RepeatedField(long long a1, long long a2)
{
long long result; // rax
_QWORD *v5; // rcx
int v6; // esi
long long v7; // rdi
*(_OWORD *)a1 = 0LL;
result = a2 + 8;
v5 = (_QWORD *)(*(_QWORD *)(a2 + 8) - 8LL);
if ( !*(_DWORD *)(a2 + 4) )
v5 = (_QWORD *)(a2 + 8);
if ( *v5 )
{
if ( a2 != a1 )
{
v6 = *(_DWORD *)a2;
if ( v6 )
{
google::protobuf::RepeatedField<double>::Reserve((int *)a1, v6);
v7 = *(_QWORD *)(a1 + 8);
*(_DWORD *)a1 += *(_DWORD *)a2;
return memcpy(v7);
}
}
}
else
{
*(_OWORD *)a1 = *(_OWORD *)a2;
*(_OWORD *)a2 = 0LL;
}
return result;
}
| RepeatedField:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
LEA RAX,[RSI + 0x8]
MOV RCX,qword ptr [RSI + 0x8]
ADD RCX,-0x8
CMP dword ptr [RSI + 0x4],0x0
CMOVZ RCX,RAX
CMP qword ptr [RCX],0x0
JZ 0x001a5237
CMP RBX,R14
JZ 0x001a5241
MOV ESI,dword ptr [RBX]
TEST ESI,ESI
JZ 0x001a5241
LAB_001a520f:
MOV RDI,R14
CALL 0x001a5098
LAB_001a5217:
MOV EAX,dword ptr [RBX]
MOV RDI,qword ptr [R14 + 0x8]
ADD dword ptr [R14],EAX
MOV RSI,qword ptr [RBX + 0x8]
MOVSXD RDX,dword ptr [RBX]
SHL RDX,0x3
ADD RSP,0x8
POP RBX
POP R14
JMP 0x0010f2f0
LAB_001a5237:
MOVUPS XMM1,xmmword ptr [RBX]
MOVUPS xmmword ptr [R14],XMM1
MOVUPS xmmword ptr [RBX],XMM0
LAB_001a5241:
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* google::protobuf::RepeatedField<double>::RepeatedField(google::protobuf::RepeatedField<double>&&)
*/
void __thiscall
google::protobuf::RepeatedField<double>::RepeatedField
(RepeatedField<double> *this,RepeatedField *param_1)
{
int8 uVar1;
RepeatedField *pRVar2;
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
pRVar2 = (RepeatedField *)(*(long *)(param_1 + 8) + -8);
if (*(int *)(param_1 + 4) == 0) {
pRVar2 = param_1 + 8;
}
if (*(long *)pRVar2 == 0) {
uVar1 = *(int8 *)(param_1 + 8);
*(int8 *)this = *(int8 *)param_1;
*(int8 *)(this + 8) = uVar1;
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
}
else if ((param_1 != (RepeatedField *)this) && (*(int *)param_1 != 0)) {
/* try { // try from 001a520f to 001a5216 has its CatchHandler @ 001a5249 */
Reserve(this,*(int *)param_1);
*(int *)this = *(int *)this + *(int *)param_1;
memcpy(*(void **)(this + 8),*(void **)(param_1 + 8),(long)*(int *)param_1 << 3);
return;
}
return;
}
| |
43,506 | ma_bitmap_get_page_bits | eloqsql/storage/maria/ma_bitmap.c | static uint bitmap_get_page_bits(MARIA_HA *info, MARIA_FILE_BITMAP *bitmap,
pgcache_page_no_t page)
{
pgcache_page_no_t bitmap_page;
uint offset_page, offset, tmp;
uchar *data;
DBUG_ENTER("_ma_bitmap_get_page_bits");
bitmap_page= page - page % bitmap->pages_covered;
if (bitmap_page != bitmap->page &&
_ma_change_bitmap_page(info, bitmap, bitmap_page))
DBUG_RETURN(~ (uint) 0);
/* Find page number from start of bitmap */
offset_page= (uint) (page - bitmap->page - 1);
/*
Mark place used by reading/writing 2 bytes at a time to handle
bitmaps in overlapping bytes
*/
offset_page*= 3;
offset= offset_page & 7;
data= bitmap->map + offset_page / 8;
tmp= uint2korr(data);
DBUG_RETURN((tmp >> offset) & 7);
} | O3 | c | ma_bitmap_get_page_bits:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
leaq 0x88(%rsi), %rbx
cmpq $0x0, 0xc8(%rsi)
jne 0x4239f
movq %rbx, %rdi
callq 0x29220
movq %r15, %rax
xorl %edx, %edx
divq 0x138(%r14)
movq %rdx, %rax
movq %r15, %rdx
subq %rax, %rdx
cmpq 0x10(%r14), %rdx
je 0x4235e
movq %r12, %rdi
movq %r14, %rsi
callq 0x41f91
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
testb %al, %al
jne 0x4237f
movq 0x10(%r14), %rdx
notl %edx
addl %edx, %r15d
leal (%r15,%r15,2), %ecx
movq 0x8(%r14), %rax
movl %ecx, %edx
shrl $0x3, %edx
movzwl (%rax,%rdx), %r12d
andb $0x7, %cl
shrl %cl, %r12d
andl $0x7, %r12d
movq 0xc8(%r14), %rdi
testq %rdi, %rdi
jne 0x423b8
movq %rbx, %rdi
callq 0x291e0
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x98750(%rip), %rsi # 0xdaaf6
movq %rbx, %rdi
movl $0x97b, %edx # imm = 0x97B
callq 0x2eb8f
jmp 0x4232a
leaq 0x345d01(%rip), %rax # 0x3880c0
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x4238b
| _ma_bitmap_get_page_bits:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov r15, rdx
mov r14, rsi
mov r12, rdi
lea rbx, [rsi+88h]
cmp qword ptr [rsi+0C8h], 0
jnz short loc_4239F
mov rdi, rbx
call _pthread_mutex_lock
loc_4232A:
mov rax, r15
xor edx, edx
div qword ptr [r14+138h]
mov rax, rdx
mov rdx, r15
sub rdx, rax
cmp rdx, [r14+10h]
jz short loc_4235E
mov rdi, r12
mov rsi, r14
call _ma_change_bitmap_page
mov r12d, 0FFFFFFFFh
test al, al
jnz short loc_4237F
mov rdx, [r14+10h]
loc_4235E:
not edx
add r15d, edx
lea ecx, [r15+r15*2]
mov rax, [r14+8]
mov edx, ecx
shr edx, 3
movzx r12d, word ptr [rax+rdx]
and cl, 7
shr r12d, cl
and r12d, 7
loc_4237F:
mov rdi, [r14+0C8h]
test rdi, rdi
jnz short loc_423B8
loc_4238B:
mov rdi, rbx
call _pthread_mutex_unlock
mov eax, r12d
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_4239F:
lea rsi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, rbx
mov edx, 97Bh
call psi_mutex_lock
jmp loc_4232A
loc_423B8:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_4238B
| long long ma_bitmap_get_page_bits(long long *a1, _QWORD *a2, unsigned long long a3)
{
long long v4; // rbx
long long v5; // rcx
long long v6; // r8
unsigned long long v7; // rdx
unsigned int v8; // r12d
v4 = (long long)(a2 + 17);
if ( a2[25] )
psi_mutex_lock(v4, (long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_bitmap.c", 0x97Bu);
else
pthread_mutex_lock(a2 + 17);
v7 = a3 - a3 % a2[39];
if ( v7 != a2[2] )
{
v8 = -1;
if ( (unsigned __int8)ma_change_bitmap_page(a1, (long long)a2, v7, v5, v6) )
goto LABEL_7;
v7 = a2[2];
}
v8 = (*(unsigned __int16 *)(a2[1] + ((unsigned int)(3 * (~(_DWORD)v7 + a3)) >> 3)) >> ((3 * (~(_BYTE)v7 + a3)) & 7)) & 7;
LABEL_7:
if ( a2[25] )
PSI_server[44]();
pthread_mutex_unlock(v4);
return v8;
}
| _ma_bitmap_get_page_bits:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R15,RDX
MOV R14,RSI
MOV R12,RDI
LEA RBX,[RSI + 0x88]
CMP qword ptr [RSI + 0xc8],0x0
JNZ 0x0014239f
MOV RDI,RBX
CALL 0x00129220
LAB_0014232a:
MOV RAX,R15
XOR EDX,EDX
DIV qword ptr [R14 + 0x138]
MOV RAX,RDX
MOV RDX,R15
SUB RDX,RAX
CMP RDX,qword ptr [R14 + 0x10]
JZ 0x0014235e
MOV RDI,R12
MOV RSI,R14
CALL 0x00141f91
MOV R12D,0xffffffff
TEST AL,AL
JNZ 0x0014237f
MOV RDX,qword ptr [R14 + 0x10]
LAB_0014235e:
NOT EDX
ADD R15D,EDX
LEA ECX,[R15 + R15*0x2]
MOV RAX,qword ptr [R14 + 0x8]
MOV EDX,ECX
SHR EDX,0x3
MOVZX R12D,word ptr [RAX + RDX*0x1]
AND CL,0x7
SHR R12D,CL
AND R12D,0x7
LAB_0014237f:
MOV RDI,qword ptr [R14 + 0xc8]
TEST RDI,RDI
JNZ 0x001423b8
LAB_0014238b:
MOV RDI,RBX
CALL 0x001291e0
MOV EAX,R12D
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0014239f:
LEA RSI,[0x1daaf6]
MOV RDI,RBX
MOV EDX,0x97b
CALL 0x0012eb8f
JMP 0x0014232a
LAB_001423b8:
LEA RAX,[0x4880c0]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x0014238b
|
uint _ma_bitmap_get_page_bits(int8 param_1,long param_2,ulong param_3)
{
pthread_mutex_t *__mutex;
char cVar1;
long lVar2;
uint uVar3;
__mutex = (pthread_mutex_t *)(param_2 + 0x88);
if (*(long *)(param_2 + 200) == 0) {
pthread_mutex_lock(__mutex);
}
else {
psi_mutex_lock(__mutex,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_bitmap.c",
0x97b);
}
lVar2 = param_3 - param_3 % *(ulong *)(param_2 + 0x138);
if (lVar2 != *(long *)(param_2 + 0x10)) {
cVar1 = _ma_change_bitmap_page(param_1,param_2);
uVar3 = 0xffffffff;
if (cVar1 != '\0') goto LAB_0014237f;
lVar2 = *(long *)(param_2 + 0x10);
}
uVar3 = ((int)param_3 + ~(uint)lVar2) * 3;
uVar3 = *(ushort *)(*(long *)(param_2 + 8) + (ulong)(uVar3 >> 3)) >> ((byte)uVar3 & 7) & 7;
LAB_0014237f:
if (*(long *)(param_2 + 200) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
return uVar3;
}
| |
43,507 | CLI::detail::get_names(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&) | MikePodsytnik[P]TCRtrie/build_O3/_deps/cli11-src/include/CLI/impl/Split_inl.hpp | CLI11_INLINE std::tuple<std::vector<std::string>, std::vector<std::string>, std::string>
get_names(const std::vector<std::string> &input) {
std::vector<std::string> short_names;
std::vector<std::string> long_names;
std::string pos_name;
for(std::string name : input) {
if(name.length() == 0) {
continue;
}
if(name.length() > 1 && name[0] == '-' && name[1] != '-') {
if(name.length() == 2 && valid_first_char(name[1]))
short_names.emplace_back(1, name[1]);
else
throw BadNameString::OneCharName(name);
} else if(name.length() > 2 && name.substr(0, 2) == "--") {
name = name.substr(2);
if(valid_name_string(name))
long_names.push_back(name);
else
throw BadNameString::BadLongName(name);
} else if(name == "-" || name == "--") {
throw BadNameString::DashesOnly(name);
} else {
if(pos_name.length() > 0)
throw BadNameString::MultiPositionalNames(name);
pos_name = name;
}
}
return std::make_tuple(short_names, long_names, pos_name);
} | O3 | cpp | CLI::detail::get_names(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rdi, 0xa0(%rsp)
xorl %eax, %eax
movq %rax, 0x90(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x80(%rsp)
movq %rax, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
leaq 0x30(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb $0x0, (%rcx)
movq (%rsi), %r15
movq 0x8(%rsi), %r13
cmpq %r13, %r15
je 0x1c14a
leaq 0x10(%rsp), %rbp
movq %rsp, %r14
leaq 0x1b56f(%rip), %rbx # 0x374b7
leaq 0x1b567(%rip), %r12 # 0x374b6
movq %rbp, (%rsp)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x177be
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x1c029
cmpq $0x1, %rax
je 0x1bfea
movq (%rsp), %rdx
cmpb $0x2d, (%rdx)
jne 0x1bf8f
movzbl 0x1(%rdx), %ecx
cmpl $0x2d, %ecx
jne 0x1c051
cmpq $0x3, %rax
jb 0x1bfea
movl $0x2, %ecx
leaq 0x40(%rsp), %rbp
movq %rbp, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x7460
movq %rbp, %rdi
movq %r12, %rbp
movq %r12, %rsi
callq 0x7130
movl %eax, %r12d
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x1bfd9
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x7430
testl %r12d, %r12d
movq %rbp, %r12
leaq 0x10(%rsp), %rbp
je 0x1c095
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7130
testl %eax, %eax
je 0x1c217
movq %r14, %rdi
movq %r12, %rsi
callq 0x7130
testl %eax, %eax
je 0x1c217
cmpq $0x0, 0x28(%rsp)
jne 0x1c27a
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x7210
movq (%rsp), %rdi
cmpq %rbp, %rdi
je 0x1c03f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7430
addq $0x20, %r15
cmpq %r13, %r15
jne 0x1bf4f
jmp 0x1c14a
cmpq $0x2, %rax
jne 0x1c2da
cmpl $0x21, %ecx
ja 0x1c076
movl %ecx, %eax
movabsq $0x300000400, %rcx # imm = 0x300000400
btq %rax, %rcx
jb 0x1c2da
incq %rdx
movl $0x1, 0x40(%rsp)
leaq 0x80(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x1c48a
jmp 0x1c029
movl $0x2, %edx
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
movq $-0x1, %rcx
callq 0x7460
movq %r14, %rdi
leaq 0x40(%rsp), %rsi
callq 0x7510
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x1c0d7
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x7430
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x1c1b4
movq (%rsp), %rcx
movzbl (%rcx), %edx
cmpq $0x2d, %rdx
ja 0x1c106
movabsq $0x200300000400, %rsi # imm = 0x200300000400
btq %rdx, %rsi
jb 0x1c1b4
movl $0x1, %edx
cmpq %rdx, %rax
je 0x1c138
movzbl (%rcx,%rdx), %esi
cmpq $0x3d, %rsi
ja 0x1c12e
movabsq $0x2400000100000400, %rdi # imm = 0x2400000100000400
btq %rsi, %rdi
jb 0x1c1b4
incq %rdx
cmpl $0x7b, %esi
jne 0x1c10b
jmp 0x1c1b4
leaq 0x60(%rsp), %rdi
movq %r14, %rsi
callq 0x129a8
jmp 0x1c029
leaq 0x80(%rsp), %rsi
leaq 0x60(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq 0xa0(%rsp), %rbx
movq %rbx, %rdi
callq 0x1cbee
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x1c188
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x7430
leaq 0x60(%rsp), %rdi
callq 0xb00e
leaq 0x80(%rsp), %rdi
callq 0xb00e
movq %rbx, %rax
addq $0x128, %rsp # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x38, %edi
callq 0x71d0
movq %rax, %r14
leaq 0xf8(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
leaq 0xe8(%rsp), %rdi
callq 0x177be
movb $0x1, %r12b
leaq 0xe8(%rsp), %rsi
movq %r14, %rdi
callq 0x1c54e
xorl %r12d, %r12d
leaq 0x2d3d5(%rip), %rsi # 0x495d8
leaq 0xd69c(%rip), %rdx # 0x298a6
movq %r14, %rdi
callq 0x7750
jmp 0x1c338
movl $0x38, %edi
callq 0x71d0
movq %rax, %r14
leaq 0xd8(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
leaq 0xc8(%rsp), %rdi
callq 0x177be
movb $0x1, %r12b
leaq 0xc8(%rsp), %rsi
movq %r14, %rdi
callq 0x1c5c6
xorl %r12d, %r12d
leaq 0x2d372(%rip), %rsi # 0x495d8
leaq 0xd639(%rip), %rdx # 0x298a6
movq %r14, %rdi
callq 0x7750
jmp 0x1c338
movl $0x38, %edi
callq 0x71d0
movq %rax, %r14
leaq 0xb8(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
leaq 0xa8(%rsp), %rdi
callq 0x177be
movb $0x1, %r12b
leaq 0xa8(%rsp), %rsi
movq %r14, %rdi
callq 0x1c63e
xorl %r12d, %r12d
leaq 0x2d30f(%rip), %rsi # 0x495d8
leaq 0xd5d6(%rip), %rdx # 0x298a6
movq %r14, %rdi
callq 0x7750
jmp 0x1c338
movl $0x38, %edi
callq 0x71d0
movq %rax, %r14
leaq 0x118(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
leaq 0x108(%rsp), %rdi
callq 0x177be
movb $0x1, %r12b
leaq 0x108(%rsp), %rsi
movq %r14, %rdi
callq 0x1c4d6
xorl %r12d, %r12d
leaq 0x2d2af(%rip), %rsi # 0x495d8
leaq 0xd576(%rip), %rdx # 0x298a6
movq %r14, %rdi
callq 0x7750
jmp 0x1c3b8
jmp 0x1c3c2
jmp 0x1c3b8
movq %rax, %rbx
leaq 0x30(%rsp), %r15
leaq 0x10(%rsp), %rbp
jmp 0x1c40d
movq %rax, %rbx
movq 0x108(%rsp), %rdi
cmpq %r15, %rdi
je 0x1c3ec
movq 0x118(%rsp), %rsi
jmp 0x1c3e4
jmp 0x1c3a9
movq %rax, %rbx
movq 0xa8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1c3ec
movq 0xb8(%rsp), %rsi
jmp 0x1c3e4
jmp 0x1c3a9
movq %rax, %rbx
movq 0xc8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1c3ec
movq 0xd8(%rsp), %rsi
jmp 0x1c3e4
movq %rax, %rbx
leaq 0x30(%rsp), %r15
leaq 0x10(%rsp), %rbp
jmp 0x1c405
movq %rax, %rbx
leaq 0x30(%rsp), %r15
jmp 0x1c40d
movq %rax, %rbx
leaq 0x30(%rsp), %r15
jmp 0x1c423
movq %rax, %rbx
movq 0xe8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1c3ec
movq 0xf8(%rsp), %rsi
incq %rsi
callq 0x7430
testb %r12b, %r12b
leaq 0x30(%rsp), %r15
leaq 0x10(%rsp), %rbp
jne 0x1c405
jmp 0x1c40d
movq %rax, %rbx
leaq 0x30(%rsp), %r15
movq %r14, %rdi
callq 0x7310
movq (%rsp), %rdi
cmpq %rbp, %rdi
je 0x1c423
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7430
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x1c43a
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x7430
leaq 0x60(%rsp), %rdi
callq 0xb00e
leaq 0x80(%rsp), %rdi
callq 0xb00e
movq %rbx, %rdi
callq 0x7780
nop
| _ZN3CLI6detail9get_namesERKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS7_EE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 128h
mov [rsp+158h+var_B8], rdi
xor eax, eax
mov [rsp+158h+var_C8], rax
xorps xmm0, xmm0
movaps [rsp+158h+var_D8], xmm0
mov [rsp+158h+var_E8], rax
movaps [rsp+158h+var_F8], xmm0
lea rcx, [rsp+158h+var_128]
mov [rcx-10h], rcx
mov [rcx-8], rax
mov byte ptr [rcx], 0
mov r15, [rsi]
mov r13, [rsi+8]
cmp r15, r13
jz loc_1C14A
lea rbp, [rsp+158h+var_148]
mov r14, rsp
lea rbx, asc_374B6+1; "-"
lea r12, asc_374B6; "--"
loc_1BF4F:
mov [rsp+158h+var_158], rbp; int
mov rsi, [r15]
mov rdx, [r15+8]
add rdx, rsi
mov rdi, r14
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
mov rax, [rsp+158h+var_150]
test rax, rax
jz loc_1C029
cmp rax, 1
jz short loc_1BFEA
mov rdx, [rsp+158h+var_158]
cmp byte ptr [rdx], 2Dh ; '-'
jnz short loc_1BF8F
movzx ecx, byte ptr [rdx+1]
cmp ecx, 2Dh ; '-'
jnz loc_1C051
loc_1BF8F:
cmp rax, 3
jb short loc_1BFEA
mov ecx, 2
lea rbp, [rsp+158h+var_118]
mov rdi, rbp
mov rsi, r14
xor edx, edx
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
mov rdi, rbp
mov rbp, r12
mov rsi, r12
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
mov r12d, eax
mov rdi, [rsp+158h+var_118]; void *
lea rax, [rsp+158h+var_108]
cmp rdi, rax
jz short loc_1BFD9
mov rsi, [rsp+158h+var_108]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1BFD9:
test r12d, r12d
mov r12, rbp
lea rbp, [rsp+158h+var_148]
jz loc_1C095
loc_1BFEA:
mov rdi, r14
mov rsi, rbx
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz loc_1C217
mov rdi, r14
mov rsi, r12
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz loc_1C217
cmp [rsp+158h+var_130], 0
jnz loc_1C27A
lea rdi, [rsp+158h+var_138]
mov rsi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_assignERKS4_; std::string::_M_assign(std::string const&)
loc_1C029:
mov rdi, [rsp+158h+var_158]; void *
cmp rdi, rbp
jz short loc_1C03F
mov rsi, qword ptr [rsp+158h+var_148]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1C03F:
add r15, 20h ; ' '
cmp r15, r13
jnz loc_1BF4F
jmp loc_1C14A
loc_1C051:
cmp rax, 2
jnz loc_1C2DA
cmp ecx, 21h ; '!'
ja short loc_1C076
mov eax, ecx
mov rcx, 300000400h
bt rcx, rax
jb loc_1C2DA
loc_1C076:
inc rdx
mov dword ptr [rsp+158h+var_118], 1
lea rdi, [rsp+158h+var_D8]
lea rsi, [rsp+158h+var_118]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE12emplace_backIJiRcEEERS5_DpOT_; std::vector<std::string>::emplace_back<int,char &>(int,char &)
jmp short loc_1C029
loc_1C095:
mov edx, 2
lea rdi, [rsp+158h+var_118]
mov rsi, r14
mov rcx, 0FFFFFFFFFFFFFFFFh
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
mov rdi, r14
lea rsi, [rsp+158h+var_118]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, [rsp+158h+var_118]; void *
lea rax, [rsp+158h+var_108]
cmp rdi, rax
jz short loc_1C0D7
mov rsi, [rsp+158h+var_108]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1C0D7:
mov rax, [rsp+158h+var_150]
test rax, rax
jz loc_1C1B4
mov rcx, [rsp+158h+var_158]
movzx edx, byte ptr [rcx]
cmp rdx, 2Dh ; '-'
ja short loc_1C106
mov rsi, 200300000400h
bt rsi, rdx
jb loc_1C1B4
loc_1C106:
mov edx, 1
loc_1C10B:
cmp rax, rdx
jz short loc_1C138
movzx esi, byte ptr [rcx+rdx]
cmp rsi, 3Dh ; '='
ja short loc_1C12E
mov rdi, 2400000100000400h
bt rdi, rsi
jb loc_1C1B4
loc_1C12E:
inc rdx
cmp esi, 7Bh ; '{'
jnz short loc_1C10B
jmp short loc_1C1B4
loc_1C138:
lea rdi, [rsp+158h+var_F8]
mov rsi, r14
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE9push_backERKS5_; std::vector<std::string>::push_back(std::string const&)
jmp loc_1C029
loc_1C14A:
lea rsi, [rsp+158h+var_D8]
lea rdx, [rsp+158h+var_F8]
lea rcx, [rsp+158h+var_138]
mov rbx, [rsp+158h+var_B8]
mov rdi, rbx
call _ZNSt11_Tuple_implILm0EJSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS6_EES8_S6_EEC2IRS8_JSB_RS6_EvEEOT_DpOT0_; std::_Tuple_impl<0ul,std::vector<std::string>,std::vector<std::string>,std::string>::_Tuple_impl<std::vector<std::string>&,std::vector<std::string>&,std::string&,void>(std::vector<std::string>&,std::vector<std::string>&,std::string&)
mov rdi, [rsp+158h+var_138]; void *
lea rax, [rsp+158h+var_128]
cmp rdi, rax
jz short loc_1C188
mov rsi, [rsp+158h+var_128]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1C188:
lea rdi, [rsp+158h+var_F8]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
lea rdi, [rsp+158h+var_D8]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rax, rbx
add rsp, 128h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1C1B4:
mov edi, 38h ; '8'; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea r15, [rsp+158h+var_60]
mov [r15-10h], r15
mov rsi, [rsp+158h+var_158]
mov rdx, [rsp+158h+var_150]
add rdx, rsi
lea rdi, [rsp+158h+var_70]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
mov r12b, 1
lea rsi, [rsp+158h+var_70]
mov rdi, r14; int
call _ZN3CLI13BadNameString11BadLongNameENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; CLI::BadNameString::BadLongName(std::string)
xor r12d, r12d
lea rsi, _ZTIN3CLI13BadNameStringE; lptinfo
lea rdx, _ZN3CLI5ErrorD2Ev; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp loc_1C338
loc_1C217:
mov edi, 38h ; '8'; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea r15, [rsp+158h+var_80]
mov [r15-10h], r15
mov rsi, [rsp+158h+var_158]
mov rdx, [rsp+158h+var_150]
add rdx, rsi
lea rdi, [rsp+158h+var_90]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
mov r12b, 1
lea rsi, [rsp+158h+var_90]
mov rdi, r14; int
call _ZN3CLI13BadNameString10DashesOnlyENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; CLI::BadNameString::DashesOnly(std::string)
xor r12d, r12d
lea rsi, _ZTIN3CLI13BadNameStringE; lptinfo
lea rdx, _ZN3CLI5ErrorD2Ev; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp loc_1C338
loc_1C27A:
mov edi, 38h ; '8'; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea r15, [rsp+158h+var_A0]
mov [r15-10h], r15
mov rsi, [rsp+158h+var_158]
mov rdx, [rsp+158h+var_150]
add rdx, rsi
lea rdi, [rsp+158h+var_B0]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
mov r12b, 1
lea rsi, [rsp+158h+var_B0]
mov rdi, r14; int
call _ZN3CLI13BadNameString20MultiPositionalNamesENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; CLI::BadNameString::MultiPositionalNames(std::string)
xor r12d, r12d
lea rsi, _ZTIN3CLI13BadNameStringE; lptinfo
lea rdx, _ZN3CLI5ErrorD2Ev; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp short loc_1C338
loc_1C2DA:
mov edi, 38h ; '8'; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea r15, [rsp+158h+var_40]
mov [r15-10h], r15
mov rsi, [rsp+158h+var_158]
mov rdx, [rsp+158h+var_150]
add rdx, rsi
lea rdi, [rsp+158h+var_50]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
mov r12b, 1
lea rsi, [rsp+158h+var_50]
mov rdi, r14; int
call _ZN3CLI13BadNameString11OneCharNameENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; CLI::BadNameString::OneCharName(std::string)
xor r12d, r12d
lea rsi, _ZTIN3CLI13BadNameStringE; lptinfo
lea rdx, _ZN3CLI5ErrorD2Ev; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
loc_1C338:
jmp short loc_1C3B8
jmp loc_1C3C2
jmp short loc_1C3B8
mov rbx, rax
lea r15, [rsp+158h+var_128]
lea rbp, [rsp+158h+var_148]
jmp loc_1C40D
mov rbx, rax
mov rdi, [rsp+158h+var_50]
cmp rdi, r15
jz loc_1C3EC
mov rsi, [rsp+158h+var_40]
jmp short loc_1C3E4
jmp short loc_1C3A9
mov rbx, rax
mov rdi, [rsp+158h+var_B0]
cmp rdi, r15
jz short loc_1C3EC
mov rsi, [rsp+158h+var_A0]
jmp short loc_1C3E4
jmp short loc_1C3A9
mov rbx, rax
mov rdi, [rsp+158h+var_90]
cmp rdi, r15
jz short loc_1C3EC
mov rsi, [rsp+158h+var_80]
jmp short loc_1C3E4
loc_1C3A9:
mov rbx, rax
lea r15, [rsp+158h+var_128]
lea rbp, [rsp+158h+var_148]
jmp short loc_1C405
loc_1C3B8:
mov rbx, rax
lea r15, [rsp+158h+var_128]
jmp short loc_1C40D
loc_1C3C2:
mov rbx, rax
lea r15, [rsp+158h+var_128]
jmp short loc_1C423
mov rbx, rax
mov rdi, [rsp+158h+var_70]; void *
cmp rdi, r15
jz short loc_1C3EC
mov rsi, [rsp+158h+var_60]
loc_1C3E4:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1C3EC:
test r12b, r12b
lea r15, [rsp+158h+var_128]
lea rbp, [rsp+158h+var_148]
jnz short loc_1C405
jmp short loc_1C40D
mov rbx, rax
lea r15, [rsp+158h+var_128]
loc_1C405:
mov rdi, r14; void *
call ___cxa_free_exception
loc_1C40D:
mov rdi, [rsp+158h+var_158]; void *
cmp rdi, rbp
jz short loc_1C423
mov rsi, qword ptr [rsp+158h+var_148]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1C423:
mov rdi, [rsp+158h+var_138]; void *
cmp rdi, r15
jz short loc_1C43A
mov rsi, [rsp+158h+var_128]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1C43A:
lea rdi, [rsp+158h+var_F8]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
lea rdi, [rsp+158h+var_D8]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rdi, rbx
call __Unwind_Resume
| long long CLI::detail::get_names(long long a1, long long *a2)
{
long long v2; // r15
long long v3; // r13
const char *v4; // r12
unsigned int v5; // ecx
const char *v6; // rbp
int v7; // r12d
bool v8; // zf
long long v9; // rcx
unsigned long long v10; // rdx
long long v11; // rsi
long long v12; // rdx
unsigned long long v13; // rsi
long long v14; // rdi
long long v15; // rbx
void *v17; // r14
void *v18; // r14
void *v19; // r14
void *exception; // r14
void *v21; // [rsp+0h] [rbp-158h] BYREF
unsigned long long v22; // [rsp+8h] [rbp-150h]
int v23[2]; // [rsp+10h] [rbp-148h] BYREF
void *v24; // [rsp+20h] [rbp-138h] BYREF
long long v25; // [rsp+28h] [rbp-130h]
_QWORD v26[2]; // [rsp+30h] [rbp-128h] BYREF
void *v27[2]; // [rsp+40h] [rbp-118h] BYREF
_QWORD v28[2]; // [rsp+50h] [rbp-108h] BYREF
__int128 v29; // [rsp+60h] [rbp-F8h] BYREF
long long v30; // [rsp+70h] [rbp-E8h]
__int128 v31; // [rsp+80h] [rbp-D8h] BYREF
long long v32; // [rsp+90h] [rbp-C8h]
long long v33; // [rsp+A0h] [rbp-B8h]
long long *v34; // [rsp+A8h] [rbp-B0h] BYREF
long long v35; // [rsp+B8h] [rbp-A0h] BYREF
long long *v36; // [rsp+C8h] [rbp-90h] BYREF
long long v37; // [rsp+D8h] [rbp-80h] BYREF
void *v38; // [rsp+E8h] [rbp-70h] BYREF
long long v39; // [rsp+F8h] [rbp-60h] BYREF
long long *v40; // [rsp+108h] [rbp-50h] BYREF
long long v41; // [rsp+118h] [rbp-40h] BYREF
v33 = a1;
v32 = 0LL;
v31 = 0LL;
v30 = 0LL;
v29 = 0LL;
v24 = v26;
v25 = 0LL;
LOBYTE(v26[0]) = 0;
v2 = *a2;
v3 = a2[1];
if ( *a2 != v3 )
{
v4 = "--";
do
{
v21 = v23;
std::string::_M_construct<char *>((long long)&v21, *(_BYTE **)v2, *(_QWORD *)v2 + *(_QWORD *)(v2 + 8));
if ( v22 )
{
if ( v22 != 1 )
{
if ( *(_BYTE *)v21 == 45 )
{
v5 = *((unsigned __int8 *)v21 + 1);
if ( v5 != 45 )
{
if ( v22 != 2 || v5 <= 0x21 && (v9 = 0x300000400LL, _bittest64(&v9, *((unsigned __int8 *)v21 + 1))) )
{
exception = __cxa_allocate_exception(0x38uLL);
v40 = &v41;
std::string::_M_construct<char *>((long long)&v40, v21, (long long)v21 + v22);
CLI::BadNameString::OneCharName((int)exception, (int)v21, v22, *(long long *)v23);
__cxa_throw(exception, (struct type_info *)&`typeinfo for'CLI::BadNameString, CLI::Error::~Error);
}
LODWORD(v27[0]) = 1;
std::vector<std::string>::emplace_back<int,char &>(&v31, v27, (char *)v21 + 1);
goto LABEL_15;
}
}
if ( v22 >= 3 )
{
std::string::substr(v27, &v21, 0LL, 2LL);
v6 = v4;
v7 = std::string::compare(v27, v4);
if ( v27[0] != v28 )
operator delete(v27[0], v28[0] + 1LL);
v8 = v7 == 0;
v4 = v6;
if ( v8 )
{
std::string::substr(v27, &v21, 2LL, -1LL);
std::string::operator=(&v21, v27);
if ( v27[0] != v28 )
operator delete(v27[0], v28[0] + 1LL);
if ( !v22
|| (v10 = *(unsigned __int8 *)v21, v10 <= 0x2D) && (v11 = 0x200300000400LL, _bittest64(&v11, v10)) )
{
LABEL_38:
v17 = __cxa_allocate_exception(0x38uLL);
v38 = &v39;
std::string::_M_construct<char *>((long long)&v38, v21, (long long)v21 + v22);
CLI::BadNameString::BadLongName((int)v17, (int)v21, v22, *(long long *)v23);
__cxa_throw(v17, (struct type_info *)&`typeinfo for'CLI::BadNameString, CLI::Error::~Error);
}
v12 = 1LL;
while ( v22 != v12 )
{
v13 = *((unsigned __int8 *)v21 + v12);
if ( v13 > 0x3D || (v14 = 0x2400000100000400LL, !_bittest64(&v14, v13)) )
{
++v12;
if ( (_DWORD)v13 != 123 )
continue;
}
goto LABEL_38;
}
std::vector<std::string>::push_back((long long)&v29, &v21);
goto LABEL_15;
}
}
}
if ( !(unsigned int)std::string::compare(&v21, "-") || !(unsigned int)std::string::compare(&v21, v4) )
{
v18 = __cxa_allocate_exception(0x38uLL);
v36 = &v37;
std::string::_M_construct<char *>((long long)&v36, v21, (long long)v21 + v22);
CLI::BadNameString::DashesOnly((int)v18, (int)v21, v22, *(long long *)v23);
__cxa_throw(v18, (struct type_info *)&`typeinfo for'CLI::BadNameString, CLI::Error::~Error);
}
if ( v25 )
{
v19 = __cxa_allocate_exception(0x38uLL);
v34 = &v35;
std::string::_M_construct<char *>((long long)&v34, v21, (long long)v21 + v22);
CLI::BadNameString::MultiPositionalNames((int)v19, (int)v21, v22, *(long long *)v23);
__cxa_throw(v19, (struct type_info *)&`typeinfo for'CLI::BadNameString, CLI::Error::~Error);
}
std::string::_M_assign(&v24, &v21);
}
LABEL_15:
if ( v21 != v23 )
operator delete(v21, *(_QWORD *)v23 + 1LL);
v2 += 32LL;
}
while ( v2 != v3 );
}
v15 = v33;
std::_Tuple_impl<0ul,std::vector<std::string>,std::vector<std::string>,std::string>::_Tuple_impl<std::vector<std::string>&,std::vector<std::string>&,std::string&,void>(
v33,
&v31,
&v29,
&v24);
if ( v24 != v26 )
operator delete(v24, v26[0] + 1LL);
std::vector<std::string>::~vector((long long)&v29);
std::vector<std::string>::~vector((long long)&v31);
return v15;
}
| get_names:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x128
MOV qword ptr [RSP + 0xa0],RDI
XOR EAX,EAX
MOV qword ptr [RSP + 0x90],RAX
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x80],XMM0
MOV qword ptr [RSP + 0x70],RAX
MOVAPS xmmword ptr [RSP + 0x60],XMM0
LEA RCX,[RSP + 0x30]
MOV qword ptr [RCX + -0x10],RCX
MOV qword ptr [RCX + -0x8],RAX
MOV byte ptr [RCX],0x0
MOV R15,qword ptr [RSI]
MOV R13,qword ptr [RSI + 0x8]
CMP R15,R13
JZ 0x0011c14a
LEA RBP,[RSP + 0x10]
MOV R14,RSP
LEA RBX,[0x1374b7]
LEA R12,[0x1374b6]
LAB_0011bf4f:
MOV qword ptr [RSP],RBP
MOV RSI,qword ptr [R15]
MOV RDX,qword ptr [R15 + 0x8]
ADD RDX,RSI
LAB_0011bf5d:
MOV RDI,R14
CALL 0x001177be
MOV RAX,qword ptr [RSP + 0x8]
TEST RAX,RAX
JZ 0x0011c029
CMP RAX,0x1
JZ 0x0011bfea
MOV RDX,qword ptr [RSP]
CMP byte ptr [RDX],0x2d
JNZ 0x0011bf8f
MOVZX ECX,byte ptr [RDX + 0x1]
CMP ECX,0x2d
JNZ 0x0011c051
LAB_0011bf8f:
CMP RAX,0x3
JC 0x0011bfea
LAB_0011bf95:
MOV ECX,0x2
LEA RBP,[RSP + 0x40]
MOV RDI,RBP
MOV RSI,R14
XOR EDX,EDX
CALL 0x00107460
MOV RDI,RBP
MOV RBP,R12
MOV RSI,R12
CALL 0x00107130
MOV R12D,EAX
MOV RDI,qword ptr [RSP + 0x40]
LEA RAX,[RSP + 0x50]
CMP RDI,RAX
JZ 0x0011bfd9
MOV RSI,qword ptr [RSP + 0x50]
INC RSI
CALL 0x00107430
LAB_0011bfd9:
TEST R12D,R12D
MOV R12,RBP
LEA RBP,[RSP + 0x10]
JZ 0x0011c095
LAB_0011bfea:
MOV RDI,R14
MOV RSI,RBX
CALL 0x00107130
TEST EAX,EAX
JZ 0x0011c217
MOV RDI,R14
MOV RSI,R12
CALL 0x00107130
TEST EAX,EAX
JZ 0x0011c217
CMP qword ptr [RSP + 0x28],0x0
JNZ 0x0011c27a
LAB_0011c01c:
LEA RDI,[RSP + 0x20]
MOV RSI,R14
CALL 0x00107210
LAB_0011c029:
MOV RDI,qword ptr [RSP]
CMP RDI,RBP
JZ 0x0011c03f
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x00107430
LAB_0011c03f:
ADD R15,0x20
CMP R15,R13
JNZ 0x0011bf4f
JMP 0x0011c14a
LAB_0011c051:
CMP RAX,0x2
JNZ 0x0011c2da
CMP ECX,0x21
JA 0x0011c076
MOV EAX,ECX
MOV RCX,0x300000400
BT RCX,RAX
JC 0x0011c2da
LAB_0011c076:
INC RDX
MOV dword ptr [RSP + 0x40],0x1
LAB_0011c081:
LEA RDI,[RSP + 0x80]
LEA RSI,[RSP + 0x40]
CALL 0x0011c48a
JMP 0x0011c029
LAB_0011c095:
MOV EDX,0x2
LEA RDI,[RSP + 0x40]
MOV RSI,R14
MOV RCX,-0x1
CALL 0x00107460
MOV RDI,R14
LEA RSI,[RSP + 0x40]
CALL 0x00107510
MOV RDI,qword ptr [RSP + 0x40]
LEA RAX,[RSP + 0x50]
CMP RDI,RAX
JZ 0x0011c0d7
MOV RSI,qword ptr [RSP + 0x50]
INC RSI
CALL 0x00107430
LAB_0011c0d7:
MOV RAX,qword ptr [RSP + 0x8]
TEST RAX,RAX
JZ 0x0011c1b4
MOV RCX,qword ptr [RSP]
MOVZX EDX,byte ptr [RCX]
CMP RDX,0x2d
JA 0x0011c106
MOV RSI,0x200300000400
BT RSI,RDX
JC 0x0011c1b4
LAB_0011c106:
MOV EDX,0x1
LAB_0011c10b:
CMP RAX,RDX
JZ 0x0011c138
MOVZX ESI,byte ptr [RCX + RDX*0x1]
CMP RSI,0x3d
JA 0x0011c12e
MOV RDI,0x2400000100000400
BT RDI,RSI
JC 0x0011c1b4
LAB_0011c12e:
INC RDX
CMP ESI,0x7b
JNZ 0x0011c10b
JMP 0x0011c1b4
LAB_0011c138:
LEA RDI,[RSP + 0x60]
MOV RSI,R14
CALL 0x001129a8
JMP 0x0011c029
LAB_0011c14a:
LEA RSI,[RSP + 0x80]
LEA RDX,[RSP + 0x60]
LEA RCX,[RSP + 0x20]
MOV RBX,qword ptr [RSP + 0xa0]
MOV RDI,RBX
CALL 0x0011cbee
LAB_0011c16c:
MOV RDI,qword ptr [RSP + 0x20]
LEA RAX,[RSP + 0x30]
CMP RDI,RAX
JZ 0x0011c188
MOV RSI,qword ptr [RSP + 0x30]
INC RSI
CALL 0x00107430
LAB_0011c188:
LEA RDI,[RSP + 0x60]
CALL 0x0010b00e
LEA RDI,[RSP + 0x80]
CALL 0x0010b00e
MOV RAX,RBX
ADD RSP,0x128
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0011c1b4:
MOV EDI,0x38
CALL 0x001071d0
MOV R14,RAX
LEA R15,[RSP + 0xf8]
MOV qword ptr [R15 + -0x10],R15
MOV RSI,qword ptr [RSP]
MOV RDX,qword ptr [RSP + 0x8]
ADD RDX,RSI
LAB_0011c1d9:
LEA RDI,[RSP + 0xe8]
CALL 0x001177be
MOV R12B,0x1
LAB_0011c1e9:
LEA RSI,[RSP + 0xe8]
MOV RDI,R14
CALL 0x0011c54e
XOR R12D,R12D
LEA RSI,[0x1495d8]
LEA RDX,[0x1298a6]
MOV RDI,R14
CALL 0x00107750
LAB_0011c217:
MOV EDI,0x38
CALL 0x001071d0
MOV R14,RAX
LEA R15,[RSP + 0xd8]
MOV qword ptr [R15 + -0x10],R15
MOV RSI,qword ptr [RSP]
MOV RDX,qword ptr [RSP + 0x8]
ADD RDX,RSI
LAB_0011c23c:
LEA RDI,[RSP + 0xc8]
CALL 0x001177be
MOV R12B,0x1
LAB_0011c24c:
LEA RSI,[RSP + 0xc8]
MOV RDI,R14
CALL 0x0011c5c6
XOR R12D,R12D
LEA RSI,[0x1495d8]
LEA RDX,[0x1298a6]
MOV RDI,R14
CALL 0x00107750
LAB_0011c27a:
MOV EDI,0x38
CALL 0x001071d0
MOV R14,RAX
LEA R15,[RSP + 0xb8]
MOV qword ptr [R15 + -0x10],R15
MOV RSI,qword ptr [RSP]
MOV RDX,qword ptr [RSP + 0x8]
ADD RDX,RSI
LAB_0011c29f:
LEA RDI,[RSP + 0xa8]
CALL 0x001177be
MOV R12B,0x1
LAB_0011c2af:
LEA RSI,[RSP + 0xa8]
MOV RDI,R14
CALL 0x0011c63e
XOR R12D,R12D
LEA RSI,[0x1495d8]
LEA RDX,[0x1298a6]
MOV RDI,R14
CALL 0x00107750
LAB_0011c2da:
MOV EDI,0x38
CALL 0x001071d0
MOV R14,RAX
LEA R15,[RSP + 0x118]
MOV qword ptr [R15 + -0x10],R15
MOV RSI,qword ptr [RSP]
MOV RDX,qword ptr [RSP + 0x8]
ADD RDX,RSI
LAB_0011c2ff:
LEA RDI,[RSP + 0x108]
CALL 0x001177be
MOV R12B,0x1
LAB_0011c30f:
LEA RSI,[RSP + 0x108]
MOV RDI,R14
CALL 0x0011c4d6
XOR R12D,R12D
LEA RSI,[0x1495d8]
LEA RDX,[0x1298a6]
MOV RDI,R14
CALL 0x00107750
|
/* CLI::detail::get_names(std::vector<std::__cxx11::string, std::allocator<std::__cxx11::string > >
const&) */
_Tuple_impl<0ul,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>,std::__cxx11::string>
* __thiscall CLI::detail::get_names(detail *this,vector *param_1)
{
byte bVar1;
long *plVar2;
int iVar3;
int8 uVar4;
ulong uVar5;
long *plVar6;
byte *local_158;
ulong local_150;
long local_148 [2];
int1 *local_138;
long local_130;
int1 local_128;
int7 uStack_127;
int4 local_118;
int4 uStack_114;
long local_108 [2];
int8 local_f8;
int8 uStack_f0;
int8 local_e8;
int8 local_d8;
int8 uStack_d0;
int8 local_c8;
_Tuple_impl<0ul,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>,std::__cxx11::string>
*local_b8;
int1 *local_b0 [2];
int1 local_a0 [16];
int1 *local_90 [2];
int1 local_80 [16];
int1 *local_70 [2];
int1 local_60 [16];
int1 *local_50 [2];
int1 local_40 [16];
local_c8 = 0;
local_d8 = 0;
uStack_d0 = 0;
local_e8 = 0;
local_f8 = 0;
uStack_f0 = 0;
local_138 = &local_128;
local_130 = 0;
local_128 = 0;
plVar6 = *(long **)param_1;
plVar2 = *(long **)(param_1 + 8);
do {
local_b8 = (_Tuple_impl<0ul,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>,std::__cxx11::string>
*)this;
if (plVar6 == plVar2) {
/* try { // try from 0011c14a to 0011c16b has its CatchHandler @ 0011c33a */
std::
_Tuple_impl<0ul,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>,std::__cxx11::string>
::
_Tuple_impl<std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>&,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>&,std::__cxx11::string&,void>
((_Tuple_impl<0ul,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>,std::__cxx11::string>
*)this,(vector *)&local_d8,(vector *)&local_f8,(string *)&local_138);
if (local_138 != &local_128) {
operator_delete(local_138,CONCAT71(uStack_127,local_128) + 1);
}
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)&local_f8);
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)&local_d8);
return (_Tuple_impl<0ul,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>,std::__cxx11::string>
*)this;
}
local_158 = (byte *)local_148;
/* try { // try from 0011bf5d to 0011bf64 has its CatchHandler @ 0011c3c2 */
std::__cxx11::string::_M_construct<char*>(&local_158,*plVar6,plVar6[1] + *plVar6);
if (local_150 != 0) {
if (local_150 != 1) {
if (*local_158 == 0x2d) {
bVar1 = local_158[1];
if (bVar1 != 0x2d) {
if ((local_150 != 2) ||
((bVar1 < 0x22 && ((0x300000400U >> ((ulong)bVar1 & 0x3f) & 1) != 0)))) {
uVar4 = __cxa_allocate_exception(0x38);
local_50[0] = local_40;
/* try { // try from 0011c2ff to 0011c30b has its CatchHandler @ 0011c371 */
std::__cxx11::string::_M_construct<char*>(local_50,local_158,local_158 + local_150);
/* try { // try from 0011c30f to 0011c337 has its CatchHandler @ 0011c353 */
BadNameString::OneCharName(uVar4,local_50);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar4,&BadNameString::typeinfo,Error::~Error);
}
local_118 = 1;
/* try { // try from 0011c081 to 0011c092 has its CatchHandler @ 0011c33f */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::
emplace_back<int,char&>((int *)&local_d8,(char *)&local_118);
goto LAB_0011c029;
}
}
if (2 < local_150) {
/* try { // try from 0011bf95 to 0011bfab has its CatchHandler @ 0011c341 */
std::__cxx11::string::substr((ulong)&local_118,(ulong)&local_158);
iVar3 = std::__cxx11::string::compare((char *)&local_118);
if ((long *)CONCAT44(uStack_114,local_118) != local_108) {
operator_delete((long *)CONCAT44(uStack_114,local_118),local_108[0] + 1);
}
if (iVar3 == 0) {
/* try { // try from 0011c095 to 0011c0ad has its CatchHandler @ 0011c338 */
std::__cxx11::string::substr((ulong)&local_118,(ulong)&local_158);
std::__cxx11::string::operator=((string *)&local_158,(string *)&local_118);
if ((long *)CONCAT44(uStack_114,local_118) != local_108) {
operator_delete((long *)CONCAT44(uStack_114,local_118),local_108[0] + 1);
}
if ((local_150 == 0) ||
(((ulong)*local_158 < 0x2e &&
((0x200300000400U >> ((ulong)*local_158 & 0x3f) & 1) != 0)))) {
LAB_0011c1b4:
uVar4 = __cxa_allocate_exception(0x38);
local_70[0] = local_60;
/* try { // try from 0011c1d9 to 0011c1e5 has its CatchHandler @ 0011c3fd */
std::__cxx11::string::_M_construct<char*>(local_70,local_158,local_158 + local_150);
/* try { // try from 0011c1e9 to 0011c211 has its CatchHandler @ 0011c3cc */
BadNameString::BadLongName(uVar4,local_70);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar4,&BadNameString::typeinfo,Error::~Error);
}
uVar5 = 1;
while (local_150 != uVar5) {
bVar1 = local_158[uVar5];
if ((((ulong)bVar1 < 0x3e) &&
((0x2400000100000400U >> ((ulong)bVar1 & 0x3f) & 1) != 0)) ||
(uVar5 = uVar5 + 1, bVar1 == 0x7b)) goto LAB_0011c1b4;
}
/* try { // try from 0011c138 to 0011c144 has its CatchHandler @ 0011c3b8 */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::push_back
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)
&local_f8,(string *)&local_158);
goto LAB_0011c029;
}
}
}
iVar3 = std::__cxx11::string::compare((char *)&local_158);
if ((iVar3 == 0) || (iVar3 = std::__cxx11::string::compare((char *)&local_158), iVar3 == 0)) {
uVar4 = __cxa_allocate_exception(0x38);
local_90[0] = local_80;
/* try { // try from 0011c23c to 0011c248 has its CatchHandler @ 0011c3a9 */
std::__cxx11::string::_M_construct<char*>(local_90,local_158,local_158 + local_150);
/* try { // try from 0011c24c to 0011c274 has its CatchHandler @ 0011c38f */
BadNameString::DashesOnly(uVar4,local_90);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar4,&BadNameString::typeinfo,Error::~Error);
}
if (local_130 != 0) {
uVar4 = __cxa_allocate_exception(0x38);
local_b0[0] = local_a0;
/* try { // try from 0011c29f to 0011c2ab has its CatchHandler @ 0011c38d */
std::__cxx11::string::_M_construct<char*>(local_b0,local_158,local_158 + local_150);
/* try { // try from 0011c2af to 0011c2d7 has its CatchHandler @ 0011c373 */
BadNameString::MultiPositionalNames(uVar4,local_b0);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar4,&BadNameString::typeinfo,Error::~Error);
}
/* try { // try from 0011c01c to 0011c028 has its CatchHandler @ 0011c3b8 */
std::__cxx11::string::_M_assign((string *)&local_138);
}
LAB_0011c029:
if (local_158 != (byte *)local_148) {
operator_delete(local_158,local_148[0] + 1);
}
plVar6 = plVar6 + 4;
this = (detail *)local_b8;
} while( true );
}
| |
43,508 | my_strntoull10rnd_8bit | eloqsql/strings/ctype-simple.c | ulonglong
my_strntoull10rnd_8bit(CHARSET_INFO *cs __attribute__((unused)),
const char *str, size_t length, int unsigned_flag,
char **endptr, int *error)
{
const char *dot, *end9, *beg, *end= str + length;
ulonglong ull;
ulong ul;
uchar ch;
int shift= 0, digits= 0, negative, addon;
/* Skip leading spaces and tabs */
for ( ; str < end && my_isspace(&my_charset_latin1, *str) ; )
str++;
if (str >= end)
goto ret_edom;
if ((negative= (*str == '-')) || *str=='+') /* optional sign */
{
if (++str == end)
goto ret_edom;
}
beg= str;
end9= (str + 9) > end ? end : (str + 9);
/* Accumulate small number into ulong, for performance purposes */
for (ul= 0 ; str < end9 && (ch= (uchar) (*str - '0')) < 10; str++)
{
ul= ul * 10 + ch;
}
if (str >= end) /* Small number without dots and expanents */
{
*endptr= (char*) str;
if (negative)
{
if (unsigned_flag)
{
*error= ul ? MY_ERRNO_ERANGE : 0;
return 0;
}
else
{
*error= 0;
return (ulonglong) (longlong) -(long) ul;
}
}
else
{
*error=0;
return (ulonglong) ul;
}
}
digits= (int) (str - beg);
/* Continue to accumulate into ulonglong */
for (dot= NULL, ull= ul; str < end; str++)
{
if ((ch= (uchar) (*str - '0')) < 10)
{
if (ull < CUTOFF || (ull == CUTOFF && ch <= CUTLIM))
{
ull= ull * 10 + ch;
digits++;
continue;
}
/*
Adding the next digit would overflow.
Remember the next digit in "addon", for rounding.
Scan all digits with an optional single dot.
*/
if (ull == CUTOFF)
{
ull= ULONGLONG_MAX;
addon= 1;
str++;
}
else
addon= (*str >= '5');
if (!dot)
{
for ( ; str < end && (ch= (uchar) (*str - '0')) < 10; shift++, str++);
if (str < end && *str == '.')
{
str++;
for ( ; str < end && (ch= (uchar) (*str - '0')) < 10; str++);
}
}
else
{
shift= (int) (dot - str);
for ( ; str < end && (ch= (uchar) (*str - '0')) < 10; str++);
}
goto exp;
}
if (*str == '.')
{
if (dot)
{
/* The second dot character */
addon= 0;
goto exp;
}
else
{
dot= str + 1;
}
continue;
}
/* Unknown character, exit the loop */
break;
}
shift= dot ? (int)(dot - str) : 0; /* Right shift */
addon= 0;
exp: /* [ E [ <sign> ] <unsigned integer> ] */
if (!digits)
{
str= beg;
goto ret_edom;
}
if (str < end && (*str == 'e' || *str == 'E'))
{
str++;
if (str < end)
{
int negative_exp, exponent;
if ((negative_exp= (*str == '-')) || *str=='+')
{
if (++str == end)
{
str-= 2; /* 'e-' or 'e+' not followed by digits */
goto ret_sign;
}
}
if (shift > 0 && !negative_exp)
goto ret_too_big;
for (exponent= 0 ; str < end && (ch= (uchar) (*str - '0')) < 10; str++)
{
if (negative_exp)
{
if (exponent - shift > DIGITS_IN_ULONGLONG)
goto ret_zero;
}
else
{
if (exponent + shift > DIGITS_IN_ULONGLONG)
goto ret_too_big;
}
exponent= exponent * 10 + ch;
}
shift+= negative_exp ? -exponent : exponent;
}
else
str--; /* 'e' not followed by digits */
}
if (shift == 0) /* No shift, check addon digit */
{
if (addon)
{
if (ull == ULONGLONG_MAX)
goto ret_too_big;
ull++;
}
goto ret_sign;
}
if (shift < 0) /* Right shift */
{
ulonglong d, r;
if (-shift >= DIGITS_IN_ULONGLONG)
goto ret_zero; /* Exponent is a big negative number, return 0 */
d= d10[-shift];
r= (ull % d) * 2;
ull /= d;
if (r >= d)
ull++;
goto ret_sign;
}
if (shift > DIGITS_IN_ULONGLONG) /* Huge left shift */
{
if (!ull)
goto ret_sign;
goto ret_too_big;
}
for ( ; shift > 0; shift--, ull*= 10) /* Left shift */
{
if (ull > CUTOFF)
goto ret_too_big; /* Overflow, number too big */
}
ret_sign:
*endptr= (char*) str;
if (!unsigned_flag)
{
if (negative)
{
if (ull >= (ulonglong) LONGLONG_MIN)
{
if (ull != (ulonglong) LONGLONG_MIN)
*error= MY_ERRNO_ERANGE;
return (ulonglong) LONGLONG_MIN;
}
*error= 0;
return (ulonglong) -(longlong) ull;
}
else
{
if (ull > (ulonglong) LONGLONG_MAX)
{
*error= MY_ERRNO_ERANGE;
return (ulonglong) LONGLONG_MAX;
}
*error= 0;
return ull;
}
}
/* Unsigned number */
if (negative && ull)
{
*error= MY_ERRNO_ERANGE;
return 0;
}
*error= 0;
return ull;
ret_zero:
*endptr= (char*) str;
*error= 0;
return 0;
ret_edom:
*endptr= (char*) str;
*error= MY_ERRNO_EDOM;
return 0;
ret_too_big:
*endptr= (char*) str;
*error= MY_ERRNO_ERANGE;
return unsigned_flag ?
ULONGLONG_MAX :
negative ? (ulonglong) LONGLONG_MIN : (ulonglong) LONGLONG_MAX;
} | O3 | c | my_strntoull10rnd_8bit:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdx, %rdx
jle 0xbc247
leaq (%rsi,%rdx), %r11
leaq 0x30e0d3(%rip), %rax # 0x3ca060
movq 0x40(%rax), %rax
decq %rdx
movzbl (%rsi), %r10d
testb $0x8, 0x1(%rax,%r10)
je 0xbbfb0
incq %rsi
decq %rdx
cmpq %r11, %rsi
jb 0xbbf94
jmp 0xbc247
cmpl $0x2b, %r10d
je 0xbbfbc
cmpl $0x2d, %r10d
jne 0xbbfc8
testq %rdx, %rdx
je 0xbc09f
incq %rsi
leaq 0x9(%rsi), %rax
cmpq %r11, %rax
cmovaq %r11, %rax
xorl %edi, %edi
movq %rsi, %r14
cmpq %rax, %rsi
jae 0xbbffb
movb (%r14), %dl
addb $-0x30, %dl
cmpb $0x9, %dl
ja 0xbbffb
leaq (%rdi,%rdi,4), %rdi
movzbl %dl, %edx
leaq (%rdx,%rdi,2), %rdi
incq %r14
cmpq %rax, %r14
jb 0xbbfdd
cmpq %r11, %r14
jae 0xbc075
movabsq $0x1999999999999999, %r15 # imm = 0x1999999999999999
movl %r14d, %r12d
subl %esi, %r12d
xorl %ebx, %ebx
movl %r14d, %r13d
movb (%r14), %al
leal -0x30(%rax), %edx
cmpb $0x9, %dl
ja 0xbc044
cmpq %r15, %rdi
jb 0xbc034
jne 0xbc0b4
cmpb $0x5, %dl
ja 0xbc0b4
leaq (%rdi,%rdi,4), %rax
movzbl %dl, %edx
leaq (%rdx,%rax,2), %rdi
incl %r12d
jmp 0xbc051
cmpb $0x2e, %al
jne 0xbc05c
testq %rbx, %rbx
jne 0xbc0a7
leaq 0x1(%r14), %rbx
incq %r14
incl %r13d
cmpq %r11, %r14
jb 0xbc015
movl %ebx, %eax
subl %r14d, %eax
xorl %r13d, %r13d
testq %rbx, %rbx
cmovel %r13d, %eax
movl %eax, %ebx
movq %rdi, %rax
jmp 0xbc172
movq %r14, (%r8)
cmpl $0x2d, %r10d
jne 0xbc32a
testl %ecx, %ecx
je 0xbc316
xorl %eax, %eax
testq %rdi, %rdi
movl $0x22, %ecx
cmovel %eax, %ecx
movl %ecx, (%r9)
jmp 0xbc251
movq %r11, %rsi
jmp 0xbc247
xorl %ebx, %ebx
movq %rdi, %rax
xorl %r13d, %r13d
jmp 0xbc172
movl %ecx, -0x30(%rbp)
cmpb $0x35, %al
setae %al
movl %eax, -0x2c(%rbp)
xorl %ecx, %ecx
cmpq %r15, %rdi
movq $-0x1, %rax
cmovneq %rdi, %rax
sete %cl
movl -0x2c(%rbp), %edx
orb %cl, %dl
movl %edx, -0x2c(%rbp)
movq %rcx, %rdx
movq %r15, %rcx
leaq (%r14,%rdx), %r15
testq %rbx, %rbx
je 0xbc124
xorl %edx, %edx
cmpq %rcx, %rdi
sete %dl
subl %edx, %ebx
subl %r13d, %ebx
cmpq %r11, %r15
movl -0x30(%rbp), %ecx
jae 0xbc161
movl -0x2c(%rbp), %r13d
movb (%r15), %dl
addb $-0x30, %dl
cmpb $0x9, %dl
ja 0xbc115
incq %r15
cmpq %r11, %r15
jb 0xbc102
movq %r15, %r14
movabsq $0x1999999999999999, %r15 # imm = 0x1999999999999999
jmp 0xbc172
xorl %ebx, %ebx
cmpq %r11, %r15
movl -0x30(%rbp), %ecx
jae 0xbc161
leaq (%r14,%rdx), %rdi
xorl %ebx, %ebx
leaq (%rdx,%rbx), %r15
movb (%r14,%r15), %r15b
leal -0x30(%r15), %r13d
cmpb $0x9, %r13b
ja 0xbc36d
leaq (%rbx,%rdi), %r15
incq %r15
incq %rbx
cmpq %r11, %r15
jb 0xbc134
addq %rbx, %rdi
movq %rdi, %r14
jmp 0xbc164
movq %r15, %r14
movabsq $0x1999999999999999, %r15 # imm = 0x1999999999999999
movl -0x2c(%rbp), %r13d
testl %r12d, %r12d
je 0xbc247
cmpq %r11, %r14
jae 0xbc230
movzbl (%r14), %edx
orl $0x20, %edx
cmpl $0x65, %edx
jne 0xbc230
leaq 0x1(%r14), %rsi
cmpq %r11, %rsi
jae 0xbc230
movzbl (%rsi), %edi
cmpl $0x2d, %edi
je 0xbc1ae
cmpl $0x2b, %edi
jne 0xbc1bb
leaq 0x2(%r14), %rsi
cmpq %r11, %rsi
je 0xbc29a
testl %ebx, %ebx
jle 0xbc1c9
cmpb $0x2d, %dil
jne 0xbc2a2
xorl %r14d, %r14d
cmpq %r11, %rsi
jae 0xbc21c
xorl %r14d, %r14d
movb (%rsi), %dl
addb $-0x30, %dl
cmpb $0x9, %dl
ja 0xbc21c
movq %r15, %r12
cmpb $0x2d, %dil
jne 0xbc1f8
movl %r14d, %r15d
subl %ebx, %r15d
cmpl $0x14, %r15d
jle 0xbc206
jmp 0xbc279
leal (%r14,%rbx), %r15d
cmpl $0x14, %r15d
jg 0xbc2a2
movzbl %dl, %edx
leal (%r14,%r14,4), %r14d
leal (%rdx,%r14,2), %r14d
incq %rsi
cmpq %r11, %rsi
movq %r12, %r15
jb 0xbc1d4
movl %r14d, %edx
negl %edx
cmpb $0x2d, %dil
cmovnel %r14d, %edx
addl %ebx, %edx
movl %edx, %ebx
movq %rsi, %r14
testl %ebx, %ebx
je 0xbc261
js 0xbc271
cmpl $0x14, %ebx
jbe 0xbc285
testq %rax, %rax
jne 0xbc29f
xorl %edi, %edi
jmp 0xbc2ed
movq %rsi, (%r8)
movl $0x21, (%r9)
xorl %edi, %edi
movq %rdi, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testb %r13b, %r13b
je 0xbc29a
cmpq $-0x1, %rax
je 0xbc29f
incq %rax
jmp 0xbc29a
cmpl $-0x13, %ebx
jae 0xbc2ce
movq %r14, %rsi
movq %rsi, (%r8)
movl $0x0, (%r9)
jmp 0xbc251
incl %ebx
cmpq %r15, %rax
ja 0xbc29f
addq %rax, %rax
leaq (%rax,%rax,4), %rax
decl %ebx
cmpl $0x1, %ebx
jg 0xbc287
movq %rax, %rdi
jmp 0xbc2ed
movq %r14, %rsi
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
leaq -0x1(%rax), %rdx
cmpl $0x2d, %r10d
movq %rsi, (%r8)
movl $0x22, (%r9)
cmoveq %rax, %rdx
xorl %edi, %edi
negl %ecx
sbbq %rdi, %rdi
orq %rdx, %rdi
jmp 0xbc253
negl %ebx
leaq 0x1854f9(%rip), %rdx # 0x2417d0
movq (%rdx,%rbx,8), %rsi
xorl %edx, %edx
divq %rsi
movq %rax, %rdi
addq %rdx, %rdx
cmpq %rsi, %rdx
sbbq $-0x1, %rdi
movq %r14, (%r8)
testl %ecx, %ecx
je 0xbc30b
cmpl $0x2d, %r10d
jne 0xbc32a
testq %rdi, %rdi
je 0xbc32a
movl $0x22, (%r9)
jmp 0xbc251
cmpl $0x2d, %r10d
jne 0xbc325
testq %rdi, %rdi
js 0xbc336
movl $0x0, (%r9)
negq %rdi
jmp 0xbc253
testq %rdi, %rdi
js 0xbc354
movl $0x0, (%r9)
jmp 0xbc253
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
negq %rdi
jo 0xbc34c
movl $0x22, (%r9)
movq %rax, %rdi
jmp 0xbc253
movl $0x22, (%r9)
movabsq $-0x8000000000000000, %rdi # imm = 0x8000000000000000
decq %rdi
jmp 0xbc253
cmpb $0x2e, %r15b
movl -0x2c(%rbp), %r13d
jne 0xbc3aa
leaq (%rbx,%rdi), %rdx
incq %rdx
movabsq $0x1999999999999999, %r15 # imm = 0x1999999999999999
movq %rdx, %r14
cmpq %r11, %rdx
jae 0xbc172
movb (%r14), %dil
addb $-0x30, %dil
leaq 0x1(%r14), %rdx
cmpb $0xa, %dil
jb 0xbc388
jmp 0xbc172
addq %rbx, %rdi
movq %rdi, %r14
jmp 0xbc118
| my_strntoull10rnd_8bit:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
test rdx, rdx
jle loc_BC247
lea r11, [rsi+rdx]
lea rax, my_charset_latin1
mov rax, [rax+40h]
dec rdx
loc_BBF94:
movzx r10d, byte ptr [rsi]
test byte ptr [rax+r10+1], 8
jz short loc_BBFB0
inc rsi
dec rdx
cmp rsi, r11
jb short loc_BBF94
jmp loc_BC247
loc_BBFB0:
cmp r10d, 2Bh ; '+'
jz short loc_BBFBC
cmp r10d, 2Dh ; '-'
jnz short loc_BBFC8
loc_BBFBC:
test rdx, rdx
jz loc_BC09F
inc rsi
loc_BBFC8:
lea rax, [rsi+9]
cmp rax, r11
cmova rax, r11
xor edi, edi
mov r14, rsi
cmp rsi, rax
jnb short loc_BBFFB
loc_BBFDD:
mov dl, [r14]
add dl, 0D0h
cmp dl, 9
ja short loc_BBFFB
lea rdi, [rdi+rdi*4]
movzx edx, dl
lea rdi, [rdx+rdi*2]
inc r14
cmp r14, rax
jb short loc_BBFDD
loc_BBFFB:
cmp r14, r11
jnb short loc_BC075
mov r15, 1999999999999999h
mov r12d, r14d
sub r12d, esi
xor ebx, ebx
mov r13d, r14d
loc_BC015:
mov al, [r14]
lea edx, [rax-30h]
cmp dl, 9
ja short loc_BC044
cmp rdi, r15
jb short loc_BC034
jnz loc_BC0B4
cmp dl, 5
ja loc_BC0B4
loc_BC034:
lea rax, [rdi+rdi*4]
movzx edx, dl
lea rdi, [rdx+rax*2]
inc r12d
jmp short loc_BC051
loc_BC044:
cmp al, 2Eh ; '.'
jnz short loc_BC05C
test rbx, rbx
jnz short loc_BC0A7
lea rbx, [r14+1]
loc_BC051:
inc r14
inc r13d
cmp r14, r11
jb short loc_BC015
loc_BC05C:
mov eax, ebx
sub eax, r14d
xor r13d, r13d
test rbx, rbx
cmovz eax, r13d
mov ebx, eax
mov rax, rdi
jmp loc_BC172
loc_BC075:
mov [r8], r14
cmp r10d, 2Dh ; '-'
jnz loc_BC32A
test ecx, ecx
jz loc_BC316
xor eax, eax
test rdi, rdi
mov ecx, 22h ; '"'
cmovz ecx, eax
mov [r9], ecx
jmp loc_BC251
loc_BC09F:
mov rsi, r11
jmp loc_BC247
loc_BC0A7:
xor ebx, ebx
mov rax, rdi
xor r13d, r13d
jmp loc_BC172
loc_BC0B4:
mov [rbp+var_30], ecx
cmp al, 35h ; '5'
setnb al
mov [rbp+var_2C], eax
xor ecx, ecx
cmp rdi, r15
mov rax, 0FFFFFFFFFFFFFFFFh
cmovnz rax, rdi
setz cl
mov edx, [rbp+var_2C]
or dl, cl
mov [rbp+var_2C], edx
mov rdx, rcx
mov rcx, r15
lea r15, [r14+rdx]
test rbx, rbx
jz short loc_BC124
xor edx, edx
cmp rdi, rcx
setz dl
sub ebx, edx
sub ebx, r13d
cmp r15, r11
mov ecx, [rbp+var_30]
jnb short loc_BC161
mov r13d, [rbp+var_2C]
loc_BC102:
mov dl, [r15]
add dl, 0D0h
cmp dl, 9
ja short loc_BC115
inc r15
cmp r15, r11
jb short loc_BC102
loc_BC115:
mov r14, r15
loc_BC118:
mov r15, 1999999999999999h
jmp short loc_BC172
loc_BC124:
xor ebx, ebx
cmp r15, r11
mov ecx, [rbp+var_30]
jnb short loc_BC161
lea rdi, [r14+rdx]
xor ebx, ebx
loc_BC134:
lea r15, [rdx+rbx]
mov r15b, [r14+r15]
lea r13d, [r15-30h]
cmp r13b, 9
ja loc_BC36D
lea r15, [rbx+rdi]
inc r15
inc rbx
cmp r15, r11
jb short loc_BC134
add rdi, rbx
mov r14, rdi
jmp short loc_BC164
loc_BC161:
mov r14, r15
loc_BC164:
mov r15, 1999999999999999h
mov r13d, [rbp+var_2C]
loc_BC172:
test r12d, r12d
jz loc_BC247
cmp r14, r11
jnb loc_BC230
movzx edx, byte ptr [r14]
or edx, 20h
cmp edx, 65h ; 'e'
jnz loc_BC230
lea rsi, [r14+1]
cmp rsi, r11
jnb loc_BC230
movzx edi, byte ptr [rsi]
cmp edi, 2Dh ; '-'
jz short loc_BC1AE
cmp edi, 2Bh ; '+'
jnz short loc_BC1BB
loc_BC1AE:
lea rsi, [r14+2]
cmp rsi, r11
jz loc_BC29A
loc_BC1BB:
test ebx, ebx
jle short loc_BC1C9
cmp dil, 2Dh ; '-'
jnz loc_BC2A2
loc_BC1C9:
xor r14d, r14d
cmp rsi, r11
jnb short loc_BC21C
xor r14d, r14d
loc_BC1D4:
mov dl, [rsi]
add dl, 0D0h
cmp dl, 9
ja short loc_BC21C
mov r12, r15
cmp dil, 2Dh ; '-'
jnz short loc_BC1F8
mov r15d, r14d
sub r15d, ebx
cmp r15d, 14h
jle short loc_BC206
jmp loc_BC279
loc_BC1F8:
lea r15d, [r14+rbx]
cmp r15d, 14h
jg loc_BC2A2
loc_BC206:
movzx edx, dl
lea r14d, [r14+r14*4]
lea r14d, [rdx+r14*2]
inc rsi
cmp rsi, r11
mov r15, r12
jb short loc_BC1D4
loc_BC21C:
mov edx, r14d
neg edx
cmp dil, 2Dh ; '-'
cmovnz edx, r14d
add edx, ebx
mov ebx, edx
mov r14, rsi
loc_BC230:
test ebx, ebx
jz short loc_BC261
js short loc_BC271
cmp ebx, 14h
jbe short loc_BC285
test rax, rax
jnz short loc_BC29F
xor edi, edi
jmp loc_BC2ED
loc_BC247:
mov [r8], rsi
mov dword ptr [r9], 21h ; '!'
loc_BC251:
xor edi, edi
loc_BC253:
mov rax, rdi
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_BC261:
test r13b, r13b
jz short loc_BC29A
cmp rax, 0FFFFFFFFFFFFFFFFh
jz short loc_BC29F
inc rax
jmp short loc_BC29A
loc_BC271:
cmp ebx, 0FFFFFFEDh
jnb short loc_BC2CE
mov rsi, r14
loc_BC279:
mov [r8], rsi
mov dword ptr [r9], 0
jmp short loc_BC251
loc_BC285:
inc ebx
loc_BC287:
cmp rax, r15
ja short loc_BC29F
add rax, rax
lea rax, [rax+rax*4]
dec ebx
cmp ebx, 1
jg short loc_BC287
loc_BC29A:
mov rdi, rax
jmp short loc_BC2ED
loc_BC29F:
mov rsi, r14
loc_BC2A2:
mov rax, 8000000000000000h
lea rdx, [rax-1]
cmp r10d, 2Dh ; '-'
mov [r8], rsi
mov dword ptr [r9], 22h ; '"'
cmovz rdx, rax
xor edi, edi
neg ecx
sbb rdi, rdi
or rdi, rdx
jmp short loc_BC253
loc_BC2CE:
neg ebx
lea rdx, d10
mov rsi, [rdx+rbx*8]
xor edx, edx
div rsi
mov rdi, rax
add rdx, rdx
cmp rdx, rsi
sbb rdi, 0FFFFFFFFFFFFFFFFh
loc_BC2ED:
mov [r8], r14
test ecx, ecx
jz short loc_BC30B
cmp r10d, 2Dh ; '-'
jnz short loc_BC32A
test rdi, rdi
jz short loc_BC32A
mov dword ptr [r9], 22h ; '"'
jmp loc_BC251
loc_BC30B:
cmp r10d, 2Dh ; '-'
jnz short loc_BC325
test rdi, rdi
js short loc_BC336
loc_BC316:
mov dword ptr [r9], 0
neg rdi
jmp loc_BC253
loc_BC325:
test rdi, rdi
js short loc_BC354
loc_BC32A:
mov dword ptr [r9], 0
jmp loc_BC253
loc_BC336:
mov rax, 8000000000000000h
neg rdi
jo short loc_BC34C
mov dword ptr [r9], 22h ; '"'
loc_BC34C:
mov rdi, rax
jmp loc_BC253
loc_BC354:
mov dword ptr [r9], 22h ; '"'
mov rdi, 8000000000000000h
dec rdi
jmp loc_BC253
loc_BC36D:
cmp r15b, 2Eh ; '.'
mov r13d, [rbp+var_2C]
jnz short loc_BC3AA
lea rdx, [rbx+rdi]
inc rdx
mov r15, 1999999999999999h
loc_BC388:
mov r14, rdx
cmp rdx, r11
jnb loc_BC172
mov dil, [r14]
add dil, 0D0h
lea rdx, [r14+1]
cmp dil, 0Ah
jb short loc_BC388
jmp loc_BC172
loc_BC3AA:
add rdi, rbx
mov r14, rdi
jmp loc_BC118
| long long my_strntoull10rnd_8bit(
long long a1,
unsigned __int8 *a2,
long long a3,
int a4,
unsigned __int8 **a5,
int *a6)
{
unsigned long long v6; // r11
long long v7; // rdx
long long v8; // r10
unsigned __int8 *v9; // rax
long long v10; // rdi
unsigned __int8 *i; // r14
unsigned __int8 v12; // dl
int v13; // r12d
_BYTE *v14; // rbx
int v15; // r13d
unsigned __int8 v16; // al
unsigned __int8 v17; // dl
int v18; // eax
bool v19; // r13
unsigned long long v20; // rax
int v21; // ecx
long long v22; // rcx
long long v23; // rdx
unsigned __int8 *v24; // r15
unsigned __int8 *v25; // rdi
char v26; // r15
unsigned long long v27; // r15
unsigned __int8 *v28; // rsi
int v29; // edi
int v30; // r14d
unsigned __int8 v31; // dl
int v32; // edx
int v34; // ebx
unsigned long long v35; // rdx
unsigned long long v36; // rsi
unsigned __int8 *v37; // rdx
unsigned __int8 v38; // di
int v39; // [rsp+0h] [rbp-30h]
bool v40; // [rsp+4h] [rbp-2Ch]
bool v41; // [rsp+4h] [rbp-2Ch]
if ( a3 <= 0 )
goto LABEL_76;
v6 = (unsigned long long)&a2[a3];
v7 = a3 - 1;
while ( 1 )
{
v8 = *a2;
if ( (*(_BYTE *)(*(_QWORD *)&my_charset_latin1[16] + v8 + 1) & 8) == 0 )
break;
++a2;
--v7;
if ( (unsigned long long)a2 >= v6 )
goto LABEL_76;
}
if ( (_DWORD)v8 == 43 || (_DWORD)v8 == 45 )
{
if ( !v7 )
{
a2 = (unsigned __int8 *)v6;
goto LABEL_76;
}
++a2;
}
v9 = a2 + 9;
if ( (unsigned long long)(a2 + 9) > v6 )
v9 = (unsigned __int8 *)v6;
v10 = 0LL;
for ( i = a2; i < v9; ++i )
{
v12 = *i - 48;
if ( v12 > 9u )
break;
v10 = v12 + 10 * v10;
}
if ( (unsigned long long)i >= v6 )
{
*a5 = i;
if ( (_DWORD)v8 != 45 )
goto LABEL_102;
if ( a4 )
{
v21 = 34;
if ( !v10 )
v21 = 0;
*a6 = v21;
return 0LL;
}
goto LABEL_100;
}
v13 = (_DWORD)i - (_DWORD)a2;
v14 = 0LL;
v15 = (int)i;
while ( 1 )
{
v16 = *i;
v17 = *i - 48;
if ( v17 <= 9u )
break;
if ( v16 != 46 )
goto LABEL_26;
if ( v14 )
{
LODWORD(v14) = 0;
v20 = v10;
v19 = 0;
goto LABEL_51;
}
v14 = i + 1;
LABEL_25:
++i;
++v15;
if ( (unsigned long long)i >= v6 )
{
LABEL_26:
v18 = (_DWORD)v14 - (_DWORD)i;
v19 = 0;
if ( !v14 )
v18 = 0;
LODWORD(v14) = v18;
v20 = v10;
goto LABEL_51;
}
}
if ( (unsigned long long)v10 < 0x1999999999999999LL || v10 == 0x1999999999999999LL && v17 <= 5u )
{
v10 = v17 + 10 * v10;
++v13;
goto LABEL_25;
}
v39 = a4;
v40 = v16 >= 0x35u;
v22 = 0LL;
v20 = -1LL;
if ( v10 != 0x1999999999999999LL )
v20 = v10;
LOBYTE(v22) = v10 == 0x1999999999999999LL;
v41 = v10 == 0x1999999999999999LL || v40;
v23 = v22;
v24 = &i[v22];
if ( v14 )
{
LODWORD(v14) = (_DWORD)v14 - (v10 == 0x1999999999999999LL) - v15;
a4 = v39;
if ( (unsigned long long)v24 < v6 )
{
v19 = v41;
do
{
if ( (unsigned __int8)(*v24 - 48) > 9u )
break;
++v24;
}
while ( (unsigned long long)v24 < v6 );
i = v24;
goto LABEL_51;
}
LABEL_49:
i = v24;
LABEL_50:
v19 = v41;
}
else
{
LODWORD(v14) = 0;
a4 = v39;
if ( (unsigned long long)v24 >= v6 )
goto LABEL_49;
v25 = &i[v23];
v14 = 0LL;
while ( 1 )
{
v26 = v14[v23 + (_QWORD)i];
if ( (unsigned __int8)(v26 - 48) > 9u )
break;
v27 = (unsigned long long)&v25[(_QWORD)v14++ + 1];
if ( v27 >= v6 )
{
i = &v25[(_QWORD)v14];
goto LABEL_50;
}
}
v19 = v41;
if ( v26 == 46 )
{
v37 = &v25[(_QWORD)v14 + 1];
do
{
i = v37;
if ( (unsigned long long)v37 >= v6 )
break;
v38 = *v37++ - 48;
}
while ( v38 < 0xAu );
}
else
{
i = &v25[(_QWORD)v14];
}
}
LABEL_51:
if ( !v13 )
{
LABEL_76:
*a5 = a2;
*a6 = 33;
return 0LL;
}
if ( (unsigned long long)i >= v6 )
goto LABEL_71;
if ( (*i | 0x20) != 0x65 )
goto LABEL_71;
v28 = i + 1;
if ( (unsigned long long)(i + 1) >= v6 )
goto LABEL_71;
v29 = *v28;
if ( v29 == 45 || v29 == 43 )
{
v28 = i + 2;
if ( i + 2 == (unsigned __int8 *)v6 )
{
LABEL_88:
v10 = v20;
LABEL_94:
*a5 = i;
if ( a4 )
{
if ( (_DWORD)v8 == 45 && v10 )
{
*a6 = 34;
return 0LL;
}
LABEL_102:
*a6 = 0;
return v10;
}
if ( (_DWORD)v8 != 45 )
{
if ( v10 < 0 )
{
*a6 = 34;
return 0x7FFFFFFFFFFFFFFFLL;
}
goto LABEL_102;
}
if ( v10 < 0 )
{
if ( !__OFSUB__(-v10, 1LL) )
*a6 = 34;
return 0x8000000000000000LL;
}
LABEL_100:
*a6 = 0;
return -v10;
}
}
if ( (int)v14 > 0 && (_BYTE)v29 != 45 )
goto LABEL_90;
v30 = 0;
if ( (unsigned long long)v28 < v6 )
{
v30 = 0;
do
{
v31 = *v28 - 48;
if ( v31 > 9u )
break;
if ( (_BYTE)v29 == 45 )
{
if ( v30 - (int)v14 > 20 )
goto LABEL_84;
}
else if ( v30 + (int)v14 > 20 )
{
goto LABEL_90;
}
v30 = v31 + 10 * v30;
++v28;
}
while ( (unsigned long long)v28 < v6 );
}
v32 = -v30;
if ( (_BYTE)v29 != 45 )
v32 = v30;
LODWORD(v14) = (_DWORD)v14 + v32;
i = v28;
LABEL_71:
if ( !(_DWORD)v14 )
{
if ( v19 )
{
if ( v20 == -1LL )
goto LABEL_89;
++v20;
}
goto LABEL_88;
}
if ( (int)v14 < 0 )
{
if ( (unsigned int)v14 < 0xFFFFFFED )
{
v28 = i;
LABEL_84:
*a5 = v28;
*a6 = 0;
return 0LL;
}
v36 = d10[-(int)v14];
v10 = v20 / v36 - ((2 * (v20 % v36) < v36) - 1LL);
goto LABEL_94;
}
if ( (unsigned int)v14 <= 0x14 )
{
v34 = (_DWORD)v14 + 1;
while ( v20 <= 0x1999999999999999LL )
{
v20 *= 10LL;
if ( --v34 <= 1 )
goto LABEL_88;
}
}
else if ( !v20 )
{
v10 = 0LL;
goto LABEL_94;
}
LABEL_89:
v28 = i;
LABEL_90:
v35 = 0x7FFFFFFFFFFFFFFFLL;
*a5 = v28;
*a6 = 34;
if ( (_DWORD)v8 == 45 )
v35 = 0x8000000000000000LL;
return v35 | -(long long)(a4 != 0);
}
| my_strntoull10rnd_8bit:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
TEST RDX,RDX
JLE 0x001bc247
LEA R11,[RSI + RDX*0x1]
LEA RAX,[0x4ca060]
MOV RAX,qword ptr [RAX + 0x40]
DEC RDX
LAB_001bbf94:
MOVZX R10D,byte ptr [RSI]
TEST byte ptr [RAX + R10*0x1 + 0x1],0x8
JZ 0x001bbfb0
INC RSI
DEC RDX
CMP RSI,R11
JC 0x001bbf94
JMP 0x001bc247
LAB_001bbfb0:
CMP R10D,0x2b
JZ 0x001bbfbc
CMP R10D,0x2d
JNZ 0x001bbfc8
LAB_001bbfbc:
TEST RDX,RDX
JZ 0x001bc09f
INC RSI
LAB_001bbfc8:
LEA RAX,[RSI + 0x9]
CMP RAX,R11
CMOVA RAX,R11
XOR EDI,EDI
MOV R14,RSI
CMP RSI,RAX
JNC 0x001bbffb
LAB_001bbfdd:
MOV DL,byte ptr [R14]
ADD DL,0xd0
CMP DL,0x9
JA 0x001bbffb
LEA RDI,[RDI + RDI*0x4]
MOVZX EDX,DL
LEA RDI,[RDX + RDI*0x2]
INC R14
CMP R14,RAX
JC 0x001bbfdd
LAB_001bbffb:
CMP R14,R11
JNC 0x001bc075
MOV R15,0x1999999999999999
MOV R12D,R14D
SUB R12D,ESI
XOR EBX,EBX
MOV R13D,R14D
LAB_001bc015:
MOV AL,byte ptr [R14]
LEA EDX,[RAX + -0x30]
CMP DL,0x9
JA 0x001bc044
CMP RDI,R15
JC 0x001bc034
JNZ 0x001bc0b4
CMP DL,0x5
JA 0x001bc0b4
LAB_001bc034:
LEA RAX,[RDI + RDI*0x4]
MOVZX EDX,DL
LEA RDI,[RDX + RAX*0x2]
INC R12D
JMP 0x001bc051
LAB_001bc044:
CMP AL,0x2e
JNZ 0x001bc05c
TEST RBX,RBX
JNZ 0x001bc0a7
LEA RBX,[R14 + 0x1]
LAB_001bc051:
INC R14
INC R13D
CMP R14,R11
JC 0x001bc015
LAB_001bc05c:
MOV EAX,EBX
SUB EAX,R14D
XOR R13D,R13D
TEST RBX,RBX
CMOVZ EAX,R13D
MOV EBX,EAX
MOV RAX,RDI
JMP 0x001bc172
LAB_001bc075:
MOV qword ptr [R8],R14
CMP R10D,0x2d
JNZ 0x001bc32a
TEST ECX,ECX
JZ 0x001bc316
XOR EAX,EAX
TEST RDI,RDI
MOV ECX,0x22
CMOVZ ECX,EAX
MOV dword ptr [R9],ECX
JMP 0x001bc251
LAB_001bc09f:
MOV RSI,R11
JMP 0x001bc247
LAB_001bc0a7:
XOR EBX,EBX
MOV RAX,RDI
XOR R13D,R13D
JMP 0x001bc172
LAB_001bc0b4:
MOV dword ptr [RBP + -0x30],ECX
CMP AL,0x35
SETNC AL
MOV dword ptr [RBP + -0x2c],EAX
XOR ECX,ECX
CMP RDI,R15
MOV RAX,-0x1
CMOVNZ RAX,RDI
SETZ CL
MOV EDX,dword ptr [RBP + -0x2c]
OR DL,CL
MOV dword ptr [RBP + -0x2c],EDX
MOV RDX,RCX
MOV RCX,R15
LEA R15,[R14 + RDX*0x1]
TEST RBX,RBX
JZ 0x001bc124
XOR EDX,EDX
CMP RDI,RCX
SETZ DL
SUB EBX,EDX
SUB EBX,R13D
CMP R15,R11
MOV ECX,dword ptr [RBP + -0x30]
JNC 0x001bc161
MOV R13D,dword ptr [RBP + -0x2c]
LAB_001bc102:
MOV DL,byte ptr [R15]
ADD DL,0xd0
CMP DL,0x9
JA 0x001bc115
INC R15
CMP R15,R11
JC 0x001bc102
LAB_001bc115:
MOV R14,R15
LAB_001bc118:
MOV R15,0x1999999999999999
JMP 0x001bc172
LAB_001bc124:
XOR EBX,EBX
CMP R15,R11
MOV ECX,dword ptr [RBP + -0x30]
JNC 0x001bc161
LEA RDI,[R14 + RDX*0x1]
XOR EBX,EBX
LAB_001bc134:
LEA R15,[RDX + RBX*0x1]
MOV R15B,byte ptr [R14 + R15*0x1]
LEA R13D,[R15 + -0x30]
CMP R13B,0x9
JA 0x001bc36d
LEA R15,[RBX + RDI*0x1]
INC R15
INC RBX
CMP R15,R11
JC 0x001bc134
ADD RDI,RBX
MOV R14,RDI
JMP 0x001bc164
LAB_001bc161:
MOV R14,R15
LAB_001bc164:
MOV R15,0x1999999999999999
MOV R13D,dword ptr [RBP + -0x2c]
LAB_001bc172:
TEST R12D,R12D
JZ 0x001bc247
CMP R14,R11
JNC 0x001bc230
MOVZX EDX,byte ptr [R14]
OR EDX,0x20
CMP EDX,0x65
JNZ 0x001bc230
LEA RSI,[R14 + 0x1]
CMP RSI,R11
JNC 0x001bc230
MOVZX EDI,byte ptr [RSI]
CMP EDI,0x2d
JZ 0x001bc1ae
CMP EDI,0x2b
JNZ 0x001bc1bb
LAB_001bc1ae:
LEA RSI,[R14 + 0x2]
CMP RSI,R11
JZ 0x001bc29a
LAB_001bc1bb:
TEST EBX,EBX
JLE 0x001bc1c9
CMP DIL,0x2d
JNZ 0x001bc2a2
LAB_001bc1c9:
XOR R14D,R14D
CMP RSI,R11
JNC 0x001bc21c
XOR R14D,R14D
LAB_001bc1d4:
MOV DL,byte ptr [RSI]
ADD DL,0xd0
CMP DL,0x9
JA 0x001bc21c
MOV R12,R15
CMP DIL,0x2d
JNZ 0x001bc1f8
MOV R15D,R14D
SUB R15D,EBX
CMP R15D,0x14
JLE 0x001bc206
JMP 0x001bc279
LAB_001bc1f8:
LEA R15D,[R14 + RBX*0x1]
CMP R15D,0x14
JG 0x001bc2a2
LAB_001bc206:
MOVZX EDX,DL
LEA R14D,[R14 + R14*0x4]
LEA R14D,[RDX + R14*0x2]
INC RSI
CMP RSI,R11
MOV R15,R12
JC 0x001bc1d4
LAB_001bc21c:
MOV EDX,R14D
NEG EDX
CMP DIL,0x2d
CMOVNZ EDX,R14D
ADD EDX,EBX
MOV EBX,EDX
MOV R14,RSI
LAB_001bc230:
TEST EBX,EBX
JZ 0x001bc261
JS 0x001bc271
CMP EBX,0x14
JBE 0x001bc285
TEST RAX,RAX
JNZ 0x001bc29f
XOR EDI,EDI
JMP 0x001bc2ed
LAB_001bc247:
MOV qword ptr [R8],RSI
MOV dword ptr [R9],0x21
LAB_001bc251:
XOR EDI,EDI
LAB_001bc253:
MOV RAX,RDI
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001bc261:
TEST R13B,R13B
JZ 0x001bc29a
CMP RAX,-0x1
JZ 0x001bc29f
INC RAX
JMP 0x001bc29a
LAB_001bc271:
CMP EBX,-0x13
JNC 0x001bc2ce
MOV RSI,R14
LAB_001bc279:
MOV qword ptr [R8],RSI
MOV dword ptr [R9],0x0
JMP 0x001bc251
LAB_001bc285:
INC EBX
LAB_001bc287:
CMP RAX,R15
JA 0x001bc29f
ADD RAX,RAX
LEA RAX,[RAX + RAX*0x4]
DEC EBX
CMP EBX,0x1
JG 0x001bc287
LAB_001bc29a:
MOV RDI,RAX
JMP 0x001bc2ed
LAB_001bc29f:
MOV RSI,R14
LAB_001bc2a2:
MOV RAX,-0x8000000000000000
LEA RDX,[RAX + -0x1]
CMP R10D,0x2d
MOV qword ptr [R8],RSI
MOV dword ptr [R9],0x22
CMOVZ RDX,RAX
XOR EDI,EDI
NEG ECX
SBB RDI,RDI
OR RDI,RDX
JMP 0x001bc253
LAB_001bc2ce:
NEG EBX
LEA RDX,[0x3417d0]
MOV RSI,qword ptr [RDX + RBX*0x8]
XOR EDX,EDX
DIV RSI
MOV RDI,RAX
ADD RDX,RDX
CMP RDX,RSI
SBB RDI,-0x1
LAB_001bc2ed:
MOV qword ptr [R8],R14
TEST ECX,ECX
JZ 0x001bc30b
CMP R10D,0x2d
JNZ 0x001bc32a
TEST RDI,RDI
JZ 0x001bc32a
MOV dword ptr [R9],0x22
JMP 0x001bc251
LAB_001bc30b:
CMP R10D,0x2d
JNZ 0x001bc325
TEST RDI,RDI
JS 0x001bc336
LAB_001bc316:
MOV dword ptr [R9],0x0
NEG RDI
JMP 0x001bc253
LAB_001bc325:
TEST RDI,RDI
JS 0x001bc354
LAB_001bc32a:
MOV dword ptr [R9],0x0
JMP 0x001bc253
LAB_001bc336:
MOV RAX,-0x8000000000000000
NEG RDI
JO 0x001bc34c
MOV dword ptr [R9],0x22
LAB_001bc34c:
MOV RDI,RAX
JMP 0x001bc253
LAB_001bc354:
MOV dword ptr [R9],0x22
MOV RDI,-0x8000000000000000
DEC RDI
JMP 0x001bc253
LAB_001bc36d:
CMP R15B,0x2e
MOV R13D,dword ptr [RBP + -0x2c]
JNZ 0x001bc3aa
LEA RDX,[RBX + RDI*0x1]
INC RDX
MOV R15,0x1999999999999999
LAB_001bc388:
MOV R14,RDX
CMP RDX,R11
JNC 0x001bc172
MOV DIL,byte ptr [R14]
ADD DIL,0xd0
LEA RDX,[R14 + 0x1]
CMP DIL,0xa
JC 0x001bc388
JMP 0x001bc172
LAB_001bc3aa:
ADD RDI,RBX
MOV R14,RDI
JMP 0x001bc118
|
ulong my_strntoull10rnd_8bit
(int8 param_1,byte *param_2,long param_3,int param_4,ulong *param_5,
int4 *param_6)
{
byte *pbVar1;
byte bVar2;
byte bVar3;
long lVar4;
uint uVar5;
byte *pbVar6;
int4 uVar7;
ulong uVar8;
byte bVar9;
int iVar10;
ulong uVar11;
ulong uVar12;
byte *pbVar13;
ulong uVar14;
int iVar15;
byte *pbVar16;
byte *pbVar17;
bool bVar18;
if (param_3 < 1) {
LAB_001bc247:
*param_5 = (ulong)param_2;
*param_6 = 0x21;
return 0;
}
pbVar1 = param_2 + param_3;
param_3 = param_3 + -1;
pbVar13 = param_2;
while (bVar3 = *pbVar13, (PTR_ctype_latin1_004ca0a0[(ulong)bVar3 + 1] & 8) != 0) {
param_2 = pbVar13 + 1;
param_3 = param_3 + -1;
pbVar13 = param_2;
if (pbVar1 <= param_2) goto LAB_001bc247;
}
if ((bVar3 == 0x2b) || (bVar3 == 0x2d)) {
param_2 = pbVar1;
if (param_3 == 0) goto LAB_001bc247;
pbVar13 = pbVar13 + 1;
}
pbVar6 = pbVar13 + 9;
if (pbVar1 < pbVar13 + 9) {
pbVar6 = pbVar1;
}
uVar11 = 0;
for (pbVar16 = pbVar13; (pbVar16 < pbVar6 && ((byte)(*pbVar16 - 0x30) < 10));
pbVar16 = pbVar16 + 1) {
uVar11 = (ulong)(byte)(*pbVar16 - 0x30) + uVar11 * 10;
}
if (pbVar1 <= pbVar16) {
*param_5 = (ulong)pbVar16;
if (bVar3 == 0x2d) {
if (param_4 != 0) {
uVar7 = 0x22;
if (uVar11 == 0) {
uVar7 = 0;
}
*param_6 = uVar7;
return 0;
}
goto LAB_001bc316;
}
goto LAB_001bc32a;
}
iVar15 = (int)pbVar16 - (int)pbVar13;
pbVar6 = (byte *)0x0;
uVar12 = (ulong)pbVar16 & 0xffffffff;
uVar14 = uVar11;
LAB_001bc015:
bVar2 = *pbVar16;
bVar9 = bVar2 - 0x30;
if (9 < bVar9) {
if (bVar2 != 0x2e) goto LAB_001bc05c;
if (pbVar6 == (byte *)0x0) {
pbVar6 = pbVar16 + 1;
goto LAB_001bc051;
}
uVar12 = 0;
bVar18 = false;
uVar11 = uVar14;
pbVar17 = pbVar16;
goto LAB_001bc172;
}
if ((uVar14 < 0x1999999999999999) || ((uVar14 == 0x1999999999999999 && (bVar9 < 6))))
goto LAB_001bc034;
bVar18 = uVar14 == 0x1999999999999999;
uVar11 = 0xffffffffffffffff;
if (!bVar18) {
uVar11 = uVar14;
}
uVar8 = (ulong)bVar18;
bVar18 = 0x34 < bVar2 || bVar18;
pbVar17 = pbVar16 + uVar8;
if (pbVar6 != (byte *)0x0) {
uVar12 = (ulong)(((int)pbVar6 - (uint)(uVar14 == 0x1999999999999999)) - (int)uVar12);
for (; (pbVar17 < pbVar1 && ((byte)(*pbVar17 - 0x30) < 10)); pbVar17 = pbVar17 + 1) {
}
goto LAB_001bc172;
}
uVar12 = 0;
if (pbVar1 <= pbVar17) goto LAB_001bc172;
uVar12 = 0;
goto LAB_001bc134;
while (lVar4 = uVar12 + uVar8, uVar12 = uVar12 + 1, pbVar16 + lVar4 + 1 < pbVar1) {
LAB_001bc134:
if (9 < (byte)(pbVar16[uVar8 + uVar12] - 0x30)) {
if (pbVar16[uVar8 + uVar12] != 0x2e) {
pbVar17 = pbVar16 + uVar12 + uVar8;
goto LAB_001bc172;
}
pbVar17 = pbVar16 + uVar12 + uVar8;
goto LAB_001bc388;
}
}
pbVar17 = pbVar16 + uVar12 + uVar8;
goto LAB_001bc172;
LAB_001bc034:
uVar14 = (ulong)bVar9 + uVar14 * 10;
iVar15 = iVar15 + 1;
LAB_001bc051:
pbVar16 = pbVar16 + 1;
uVar12 = (ulong)((int)uVar12 + 1);
if (pbVar1 <= pbVar16) goto LAB_001bc05c;
goto LAB_001bc015;
LAB_001bc05c:
uVar5 = (int)pbVar6 - (int)pbVar16;
bVar18 = false;
if (pbVar6 == (byte *)0x0) {
uVar5 = 0;
}
uVar12 = (ulong)uVar5;
uVar11 = uVar14;
pbVar17 = pbVar16;
goto LAB_001bc172;
while ((byte)(*pbVar17 - 0x30) < 10) {
LAB_001bc388:
pbVar17 = pbVar17 + 1;
if (pbVar1 <= pbVar17) break;
}
LAB_001bc172:
uVar5 = (uint)uVar12;
param_2 = pbVar13;
if (iVar15 == 0) goto LAB_001bc247;
if (((pbVar17 < pbVar1) && ((*pbVar17 | 0x20) == 0x65)) &&
(pbVar13 = pbVar17 + 1, pbVar13 < pbVar1)) {
bVar2 = *pbVar13;
if (((bVar2 != 0x2d) && (bVar2 != 0x2b)) || (pbVar13 = pbVar17 + 2, pbVar13 != pbVar1)) {
if ((0 < (int)uVar5) && (bVar2 != 0x2d)) goto LAB_001bc2a2;
iVar15 = 0;
if (pbVar13 < pbVar1) {
iVar15 = 0;
do {
if (9 < (byte)(*pbVar13 - 0x30)) break;
if (bVar2 == 0x2d) {
if (0x14 < (int)(iVar15 - uVar5)) goto LAB_001bc279;
}
else if (0x14 < (int)(iVar15 + uVar5)) goto LAB_001bc2a2;
iVar15 = (uint)(byte)(*pbVar13 - 0x30) + iVar15 * 10;
pbVar13 = pbVar13 + 1;
} while (pbVar13 < pbVar1);
}
iVar10 = -iVar15;
if (bVar2 != 0x2d) {
iVar10 = iVar15;
}
uVar5 = iVar10 + uVar5;
pbVar17 = pbVar13;
goto LAB_001bc230;
}
}
else {
LAB_001bc230:
pbVar13 = pbVar17;
pbVar17 = pbVar13;
if (uVar5 == 0) {
if (bVar18) {
if (uVar11 == 0xffffffffffffffff) goto LAB_001bc2a2;
uVar11 = uVar11 + 1;
}
}
else if ((int)uVar5 < 0) {
if (uVar5 < 0xffffffed) {
LAB_001bc279:
*param_5 = (ulong)pbVar13;
*param_6 = 0;
return 0;
}
uVar14 = *(ulong *)(d10 + (ulong)-uVar5 * 8);
uVar11 = (uVar11 / uVar14 + 1) - (ulong)((uVar11 % uVar14) * 2 < uVar14);
}
else if (uVar5 < 0x15) {
iVar15 = uVar5 + 1;
do {
if (0x1999999999999999 < uVar11) goto LAB_001bc2a2;
uVar11 = uVar11 * 10;
iVar15 = iVar15 + -1;
} while (1 < iVar15);
}
else {
if (uVar11 != 0) {
LAB_001bc2a2:
uVar11 = 0x7fffffffffffffff;
*param_5 = (ulong)pbVar13;
*param_6 = 0x22;
if (bVar3 == 0x2d) {
uVar11 = 0x8000000000000000;
}
return -(ulong)(param_4 != 0) | uVar11;
}
uVar11 = 0;
}
}
*param_5 = (ulong)pbVar17;
if (param_4 == 0) {
if (bVar3 == 0x2d) {
if ((long)uVar11 < 0) {
*param_6 = 0x22;
return 0x8000000000000000;
}
LAB_001bc316:
*param_6 = 0;
return -uVar11;
}
if ((long)uVar11 < 0) {
*param_6 = 0x22;
return 0x7fffffffffffffff;
}
}
else if ((bVar3 == 0x2d) && (uVar11 != 0)) {
*param_6 = 0x22;
return 0;
}
LAB_001bc32a:
*param_6 = 0;
return uVar11;
}
| |
43,509 | LefDefParser::lefiMacro::clear() | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiMacro.cpp | void
lefiMacro::clear()
{
int i;
hasClass_ = 0;
hasGenerator_ = 0;
hasGenerate_ = 0;
hasPower_ = 0;
hasOrigin_ = 0;
hasSource_ = 0;
hasEEQ_ = 0;
hasLEQ_ = 0;
hasSymmetry_ = 0;
hasSiteName_ = 0;
hasClockType_ = 0;
hasSize_ = 0;
isInverter_ = 0;
isBuffer_ = 0;
for (i = 0; i < numForeigns_; i++) {
hasForeignOrigin_[i] = 0;
hasForeignPoint_[i] = 0;
foreignOrient_[i] = -1;
lefFree((char*) (foreign_[i]));
}
numForeigns_ = 0;
if (pattern_) {
for (i = 0; i < numSites_; i++) {
pattern_[i]->Destroy();
lefFree((char*) (pattern_[i]));
}
numSites_ = 0;
sitesAllocated_ = 0;
lefFree((char*) (pattern_));
pattern_ = 0;
}
for (i = 0; i < numProperties_; i++) {
lefFree(propNames_[i]);
lefFree(propValues_[i]);
}
numProperties_ = 0;
isFixedMask_ = 0;
} | O3 | cpp | LefDefParser::lefiMacro::clear():
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movq %r14, 0x4e(%rdi)
movq %r14, 0x48(%rdi)
cmpl $0x0, 0xd0(%rdi)
jle 0x37453
xorl %r15d, %r15d
movq 0xd8(%rbx), %rax
movl %r14d, (%rax,%r15,4)
movq 0xe0(%rbx), %rax
movl %r14d, (%rax,%r15,4)
movq 0xe8(%rbx), %rax
movl $0xffffffff, (%rax,%r15,4) # imm = 0xFFFFFFFF
movq 0x100(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x322d0
incq %r15
movslq 0xd0(%rbx), %rax
cmpq %rax, %r15
jl 0x3740f
movl $0x0, 0xd0(%rbx)
movq 0xc8(%rbx), %rdi
testq %rdi, %rdi
je 0x374c1
cmpl $0x0, 0xc0(%rbx)
jle 0x374ab
xorl %r14d, %r14d
movq 0xc8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0xd4fe
movq 0xc8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x322d0
incq %r14
movslq 0xc0(%rbx), %rax
cmpq %rax, %r14
jl 0x37475
movq 0xc8(%rbx), %rdi
xorl %r14d, %r14d
movq %r14, 0xc0(%rbx)
callq 0x322d0
movq %r14, 0xc8(%rbx)
cmpl $0x0, 0x124(%rbx)
jle 0x374fc
xorl %r14d, %r14d
movq 0x130(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x322d0
movq 0x138(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x322d0
incq %r14
movslq 0x124(%rbx), %rax
cmpq %rax, %r14
jl 0x374cd
xorl %eax, %eax
movl %eax, 0x124(%rbx)
movl %eax, 0x150(%rbx)
popq %rbx
popq %r14
popq %r15
retq
| _ZN12LefDefParser9lefiMacro5clearEv:
push r15
push r14
push rbx
mov rbx, rdi
xor r14d, r14d
mov [rdi+4Eh], r14
mov [rdi+48h], r14
cmp dword ptr [rdi+0D0h], 0
jle short loc_37453
xor r15d, r15d
loc_3740F:
mov rax, [rbx+0D8h]
mov [rax+r15*4], r14d
mov rax, [rbx+0E0h]
mov [rax+r15*4], r14d
mov rax, [rbx+0E8h]
mov dword ptr [rax+r15*4], 0FFFFFFFFh
mov rax, [rbx+100h]
mov rdi, [rax+r15*8]; this
call _ZN12LefDefParser7lefFreeEPv; LefDefParser::lefFree(void *)
inc r15
movsxd rax, dword ptr [rbx+0D0h]
cmp r15, rax
jl short loc_3740F
loc_37453:
mov dword ptr [rbx+0D0h], 0
mov rdi, [rbx+0C8h]
test rdi, rdi
jz short loc_374C1
cmp dword ptr [rbx+0C0h], 0
jle short loc_374AB
xor r14d, r14d
loc_37475:
mov rax, [rbx+0C8h]
mov rdi, [rax+r14*8]; this
call _ZN12LefDefParser15lefiSitePattern7DestroyEv; LefDefParser::lefiSitePattern::Destroy(void)
mov rax, [rbx+0C8h]
mov rdi, [rax+r14*8]; this
call _ZN12LefDefParser7lefFreeEPv; LefDefParser::lefFree(void *)
inc r14
movsxd rax, dword ptr [rbx+0C0h]
cmp r14, rax
jl short loc_37475
mov rdi, [rbx+0C8h]; this
loc_374AB:
xor r14d, r14d
mov [rbx+0C0h], r14
call _ZN12LefDefParser7lefFreeEPv; LefDefParser::lefFree(void *)
mov [rbx+0C8h], r14
loc_374C1:
cmp dword ptr [rbx+124h], 0
jle short loc_374FC
xor r14d, r14d
loc_374CD:
mov rax, [rbx+130h]
mov rdi, [rax+r14*8]; this
call _ZN12LefDefParser7lefFreeEPv; LefDefParser::lefFree(void *)
mov rax, [rbx+138h]
mov rdi, [rax+r14*8]; this
call _ZN12LefDefParser7lefFreeEPv; LefDefParser::lefFree(void *)
inc r14
movsxd rax, dword ptr [rbx+124h]
cmp r14, rax
jl short loc_374CD
loc_374FC:
xor eax, eax
mov [rbx+124h], eax
mov [rbx+150h], eax
pop rbx
pop r14
pop r15
retn
| long long LefDefParser::lefiMacro::clear(LefDefParser::lefiMacro *this, void *a2)
{
long long v3; // r15
LefDefParser *v4; // rdi
long long v5; // r14
long long v6; // r14
long long result; // rax
*(_QWORD *)((char *)this + 78) = 0LL;
*((_QWORD *)this + 9) = 0LL;
if ( *((int *)this + 52) > 0 )
{
v3 = 0LL;
do
{
*(_DWORD *)(*((_QWORD *)this + 27) + 4 * v3) = 0;
*(_DWORD *)(*((_QWORD *)this + 28) + 4 * v3) = 0;
*(_DWORD *)(*((_QWORD *)this + 29) + 4 * v3) = -1;
LefDefParser::lefFree(*(LefDefParser **)(*((_QWORD *)this + 32) + 8 * v3++), a2);
}
while ( v3 < *((int *)this + 52) );
}
*((_DWORD *)this + 52) = 0;
v4 = (LefDefParser *)*((_QWORD *)this + 25);
if ( v4 )
{
if ( *((int *)this + 48) > 0 )
{
v5 = 0LL;
do
{
LefDefParser::lefiSitePattern::Destroy(*(LefDefParser ***)(*((_QWORD *)this + 25) + 8 * v5), a2);
LefDefParser::lefFree(*(LefDefParser **)(*((_QWORD *)this + 25) + 8 * v5++), a2);
}
while ( v5 < *((int *)this + 48) );
v4 = (LefDefParser *)*((_QWORD *)this + 25);
}
*((_QWORD *)this + 24) = 0LL;
LefDefParser::lefFree(v4, a2);
*((_QWORD *)this + 25) = 0LL;
}
if ( *((int *)this + 73) > 0 )
{
v6 = 0LL;
do
{
LefDefParser::lefFree(*(LefDefParser **)(*((_QWORD *)this + 38) + 8 * v6), a2);
LefDefParser::lefFree(*(LefDefParser **)(*((_QWORD *)this + 39) + 8 * v6++), a2);
}
while ( v6 < *((int *)this + 73) );
}
result = 0LL;
*((_DWORD *)this + 73) = 0;
*((_DWORD *)this + 84) = 0;
return result;
}
| clear:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDI
XOR R14D,R14D
MOV qword ptr [RDI + 0x4e],R14
MOV qword ptr [RDI + 0x48],R14
CMP dword ptr [RDI + 0xd0],0x0
JLE 0x00137453
XOR R15D,R15D
LAB_0013740f:
MOV RAX,qword ptr [RBX + 0xd8]
MOV dword ptr [RAX + R15*0x4],R14D
MOV RAX,qword ptr [RBX + 0xe0]
MOV dword ptr [RAX + R15*0x4],R14D
MOV RAX,qword ptr [RBX + 0xe8]
MOV dword ptr [RAX + R15*0x4],0xffffffff
MOV RAX,qword ptr [RBX + 0x100]
MOV RDI,qword ptr [RAX + R15*0x8]
CALL 0x001322d0
INC R15
MOVSXD RAX,dword ptr [RBX + 0xd0]
CMP R15,RAX
JL 0x0013740f
LAB_00137453:
MOV dword ptr [RBX + 0xd0],0x0
MOV RDI,qword ptr [RBX + 0xc8]
TEST RDI,RDI
JZ 0x001374c1
CMP dword ptr [RBX + 0xc0],0x0
JLE 0x001374ab
XOR R14D,R14D
LAB_00137475:
MOV RAX,qword ptr [RBX + 0xc8]
MOV RDI,qword ptr [RAX + R14*0x8]
CALL 0x0010d4fe
MOV RAX,qword ptr [RBX + 0xc8]
MOV RDI,qword ptr [RAX + R14*0x8]
CALL 0x001322d0
INC R14
MOVSXD RAX,dword ptr [RBX + 0xc0]
CMP R14,RAX
JL 0x00137475
MOV RDI,qword ptr [RBX + 0xc8]
LAB_001374ab:
XOR R14D,R14D
MOV qword ptr [RBX + 0xc0],R14
CALL 0x001322d0
MOV qword ptr [RBX + 0xc8],R14
LAB_001374c1:
CMP dword ptr [RBX + 0x124],0x0
JLE 0x001374fc
XOR R14D,R14D
LAB_001374cd:
MOV RAX,qword ptr [RBX + 0x130]
MOV RDI,qword ptr [RAX + R14*0x8]
CALL 0x001322d0
MOV RAX,qword ptr [RBX + 0x138]
MOV RDI,qword ptr [RAX + R14*0x8]
CALL 0x001322d0
INC R14
MOVSXD RAX,dword ptr [RBX + 0x124]
CMP R14,RAX
JL 0x001374cd
LAB_001374fc:
XOR EAX,EAX
MOV dword ptr [RBX + 0x124],EAX
MOV dword ptr [RBX + 0x150],EAX
POP RBX
POP R14
POP R15
RET
|
/* LefDefParser::lefiMacro::clear() */
void __thiscall LefDefParser::lefiMacro::clear(lefiMacro *this)
{
void *pvVar1;
long lVar2;
*(int8 *)(this + 0x4e) = 0;
*(int8 *)(this + 0x48) = 0;
if (0 < *(int *)(this + 0xd0)) {
lVar2 = 0;
do {
*(int4 *)(*(long *)(this + 0xd8) + lVar2 * 4) = 0;
*(int4 *)(*(long *)(this + 0xe0) + lVar2 * 4) = 0;
*(int4 *)(*(long *)(this + 0xe8) + lVar2 * 4) = 0xffffffff;
lefFree(*(void **)(*(long *)(this + 0x100) + lVar2 * 8));
lVar2 = lVar2 + 1;
} while (lVar2 < *(int *)(this + 0xd0));
}
*(int4 *)(this + 0xd0) = 0;
pvVar1 = *(void **)(this + 200);
if (pvVar1 != (void *)0x0) {
if (0 < *(int *)(this + 0xc0)) {
lVar2 = 0;
do {
lefiSitePattern::Destroy(*(lefiSitePattern **)(*(long *)(this + 200) + lVar2 * 8));
lefFree(*(void **)(*(long *)(this + 200) + lVar2 * 8));
lVar2 = lVar2 + 1;
} while (lVar2 < *(int *)(this + 0xc0));
pvVar1 = *(void **)(this + 200);
}
*(int8 *)(this + 0xc0) = 0;
lefFree(pvVar1);
*(int8 *)(this + 200) = 0;
}
if (0 < *(int *)(this + 0x124)) {
lVar2 = 0;
do {
lefFree(*(void **)(*(long *)(this + 0x130) + lVar2 * 8));
lefFree(*(void **)(*(long *)(this + 0x138) + lVar2 * 8));
lVar2 = lVar2 + 1;
} while (lVar2 < *(int *)(this + 0x124));
}
*(int4 *)(this + 0x124) = 0;
*(int4 *)(this + 0x150) = 0;
return;
}
| |
43,510 | get_this_host | eloqsql/libmariadb/unittest/libmariadb/my_test.h | void get_this_host(MYSQL *mysql)
{
MYSQL_RES *res;
MYSQL_ROW row;
if (mysql_query(mysql, "select substr(current_user(), locate('@', current_user())+1)"))
return;
if ((res= mysql_store_result(mysql)))
{
if ((row= mysql_fetch_row(res)))
this_host= strdup(row[0]);
mysql_free_result(res);
}
} | O0 | c | get_this_host:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x50ac7(%rip), %rsi # 0x6567e
callq 0x38a70
cmpl $0x0, %eax
je 0x14bc3
jmp 0x14c05
movq -0x8(%rbp), %rdi
callq 0x3a0c0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x14c05
movq -0x10(%rbp), %rdi
callq 0x3a400
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x14bfc
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x147c0
movq %rax, 0x6c5cc(%rip) # 0x811c8
movq -0x10(%rbp), %rdi
callq 0x31900
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| get_this_host:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]
lea rsi, aSelectSubstrCu; "select substr(current_user(), locate('@"...
call mysql_query
cmp eax, 0
jz short loc_14BC3
jmp short loc_14C05
loc_14BC3:
mov rdi, [rbp+var_8]
call mysql_store_result
mov [rbp+var_10], rax
cmp rax, 0
jz short loc_14C05
mov rdi, [rbp+var_10]
call mysql_fetch_row
mov [rbp+var_18], rax
cmp rax, 0
jz short loc_14BFC
mov rax, [rbp+var_18]
mov rdi, [rax]
call _strdup
mov cs:this_host, rax
loc_14BFC:
mov rdi, [rbp+var_10]
call mysql_free_result
loc_14C05:
add rsp, 20h
pop rbp
retn
| long long get_this_host(long long a1)
{
long long result; // rax
_QWORD *row; // [rsp+8h] [rbp-18h]
long long v3; // [rsp+10h] [rbp-10h]
result = mysql_query(a1, "select substr(current_user(), locate('@', current_user())+1)");
if ( !(_DWORD)result )
{
result = mysql_store_result(a1);
v3 = result;
if ( result )
{
row = (_QWORD *)mysql_fetch_row(result);
if ( row )
this_host = strdup(*row);
return mysql_free_result(v3);
}
}
return result;
}
| get_this_host:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x16567e]
CALL 0x00138a70
CMP EAX,0x0
JZ 0x00114bc3
JMP 0x00114c05
LAB_00114bc3:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0013a0c0
MOV qword ptr [RBP + -0x10],RAX
CMP RAX,0x0
JZ 0x00114c05
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0013a400
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JZ 0x00114bfc
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX]
CALL 0x001147c0
MOV qword ptr [0x001811c8],RAX
LAB_00114bfc:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00131900
LAB_00114c05:
ADD RSP,0x20
POP RBP
RET
|
void get_this_host(int8 param_1)
{
int iVar1;
long lVar2;
int8 *puVar3;
iVar1 = mysql_query(param_1,"select substr(current_user(), locate(\'@\', current_user())+1)");
if ((iVar1 == 0) && (lVar2 = mysql_store_result(param_1), lVar2 != 0)) {
puVar3 = (int8 *)mysql_fetch_row(lVar2);
if (puVar3 != (int8 *)0x0) {
this_host = strdup((char *)*puVar3);
}
mysql_free_result(lVar2);
}
return;
}
| |
43,511 | compile_add_expr | fabiosvm[P]rak/src/compiler.c | static inline void compile_add_expr(RakCompiler *comp, RakError *err)
{
compile_mul_expr(comp, err);
if (!rak_is_ok(err)) return;
for (;;)
{
if (match(comp, RAK_TOKEN_KIND_PLUS))
{
next(comp, err);
compile_mul_expr(comp, err);
if (!rak_is_ok(err)) return;
emit_instr(comp, rak_add_instr(), err);
if (!rak_is_ok(err)) return;
continue;
}
if (match(comp, RAK_TOKEN_KIND_MINUS))
{
next(comp, err);
compile_mul_expr(comp, err);
if (!rak_is_ok(err)) return;
emit_instr(comp, rak_sub_instr(), err);
if (!rak_is_ok(err)) return;
continue;
}
break;
}
} | O2 | c | compile_add_expr:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x45ea
cmpb $0x1, (%rbx)
jne 0x45e1
leaq 0x27f8(%r14), %r15
pushq $0x14
popq %rbp
pushq $0x13
popq %r12
movl 0x2810(%r14), %eax
cmpl $0x1a, %eax
je 0x45af
cmpl $0x18, %eax
jne 0x45e1
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5512
cmpb $0x1, (%rbx)
jne 0x45e1
movq %r14, %rdi
movq %rbx, %rsi
callq 0x45ea
cmpb $0x1, (%rbx)
jne 0x45e1
movq %r14, %rdi
movl %r12d, %esi
jmp 0x45d4
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5512
cmpb $0x1, (%rbx)
jne 0x45e1
movq %r14, %rdi
movq %rbx, %rsi
callq 0x45ea
cmpb $0x1, (%rbx)
jne 0x45e1
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x3306
cmpb $0x0, (%rbx)
jne 0x4576
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| compile_add_expr:
push rbp
push r15
push r14
push r12
push rbx
mov rbx, rsi
mov r14, rdi
call compile_mul_expr
cmp byte ptr [rbx], 1
jnz short loc_45E1
lea r15, [r14+27F8h]
push 14h
pop rbp
push 13h
pop r12
loc_4576:
mov eax, [r14+2810h]
cmp eax, 1Ah
jz short loc_45AF
cmp eax, 18h
jnz short loc_45E1
mov rdi, r15
mov rsi, rbx
call rak_lexer_next
cmp byte ptr [rbx], 1
jnz short loc_45E1
mov rdi, r14
mov rsi, rbx
call compile_mul_expr
cmp byte ptr [rbx], 1
jnz short loc_45E1
mov rdi, r14
mov esi, r12d
jmp short loc_45D4
loc_45AF:
mov rdi, r15
mov rsi, rbx
call rak_lexer_next
cmp byte ptr [rbx], 1
jnz short loc_45E1
mov rdi, r14
mov rsi, rbx
call compile_mul_expr
cmp byte ptr [rbx], 1
jnz short loc_45E1
mov rdi, r14
mov esi, ebp
loc_45D4:
mov rdx, rbx
call rak_chunk_append_instr
cmp byte ptr [rbx], 0
jnz short loc_4576
loc_45E1:
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long compile_add_expr(long long a1, char *a2)
{
long long result; // rax
int v5; // ecx
int v6; // r8d
int v7; // r9d
long long v8; // rdi
int v9; // esi
result = ((long long (*)(void))compile_mul_expr)();
if ( *a2 == 1 )
{
do
{
result = *(unsigned int *)(a1 + 10256);
if ( (_DWORD)result == 26 )
{
result = rak_lexer_next(a1 + 10232, a2);
if ( *a2 != 1 )
return result;
result = compile_mul_expr(a1, a2);
if ( *a2 != 1 )
return result;
v8 = a1;
v9 = 20;
}
else
{
if ( (_DWORD)result != 24 )
return result;
result = rak_lexer_next(a1 + 10232, a2);
if ( *a2 != 1 )
return result;
result = compile_mul_expr(a1, a2);
if ( *a2 != 1 )
return result;
v8 = a1;
v9 = 19;
}
result = rak_chunk_append_instr(v8, v9, a2, v5, v6, v7);
}
while ( *a2 );
}
return result;
}
| compile_add_expr:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RBX,RSI
MOV R14,RDI
CALL 0x001045ea
CMP byte ptr [RBX],0x1
JNZ 0x001045e1
LEA R15,[R14 + 0x27f8]
PUSH 0x14
POP RBP
PUSH 0x13
POP R12
LAB_00104576:
MOV EAX,dword ptr [R14 + 0x2810]
CMP EAX,0x1a
JZ 0x001045af
CMP EAX,0x18
JNZ 0x001045e1
MOV RDI,R15
MOV RSI,RBX
CALL 0x00105512
CMP byte ptr [RBX],0x1
JNZ 0x001045e1
MOV RDI,R14
MOV RSI,RBX
CALL 0x001045ea
CMP byte ptr [RBX],0x1
JNZ 0x001045e1
MOV RDI,R14
MOV ESI,R12D
JMP 0x001045d4
LAB_001045af:
MOV RDI,R15
MOV RSI,RBX
CALL 0x00105512
CMP byte ptr [RBX],0x1
JNZ 0x001045e1
MOV RDI,R14
MOV RSI,RBX
CALL 0x001045ea
CMP byte ptr [RBX],0x1
JNZ 0x001045e1
MOV RDI,R14
MOV ESI,EBP
LAB_001045d4:
MOV RDX,RBX
CALL 0x00103306
CMP byte ptr [RBX],0x0
JNZ 0x00104576
LAB_001045e1:
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
void compile_add_expr(long param_1,char *param_2)
{
char cVar1;
int8 uVar2;
compile_mul_expr();
if (*param_2 != '\x01') {
return;
}
do {
if (*(int *)(param_1 + 0x2810) == 0x1a) {
rak_lexer_next(param_1 + 0x27f8,param_2);
if (*param_2 != '\x01') {
return;
}
compile_mul_expr(param_1,param_2);
cVar1 = *param_2;
uVar2 = 0x14;
}
else {
if (*(int *)(param_1 + 0x2810) != 0x18) {
return;
}
rak_lexer_next(param_1 + 0x27f8,param_2);
if (*param_2 != '\x01') {
return;
}
compile_mul_expr(param_1,param_2);
cVar1 = *param_2;
uVar2 = 0x13;
}
if (cVar1 != '\x01') {
return;
}
rak_chunk_append_instr(param_1,uVar2,param_2);
} while (*param_2 != '\0');
return;
}
| |
43,512 | compile_add_expr | fabiosvm[P]rak/src/compiler.c | static inline void compile_add_expr(RakCompiler *comp, RakError *err)
{
compile_mul_expr(comp, err);
if (!rak_is_ok(err)) return;
for (;;)
{
if (match(comp, RAK_TOKEN_KIND_PLUS))
{
next(comp, err);
compile_mul_expr(comp, err);
if (!rak_is_ok(err)) return;
emit_instr(comp, rak_add_instr(), err);
if (!rak_is_ok(err)) return;
continue;
}
if (match(comp, RAK_TOKEN_KIND_MINUS))
{
next(comp, err);
compile_mul_expr(comp, err);
if (!rak_is_ok(err)) return;
emit_instr(comp, rak_sub_instr(), err);
if (!rak_is_ok(err)) return;
continue;
}
break;
}
} | O3 | c | compile_add_expr:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x52c2
cmpb $0x1, (%rbx)
jne 0x52bc
leaq 0x27f8(%r14), %r15
movl 0x2810(%r14), %eax
cmpl $0x1a, %eax
je 0x5287
cmpl $0x18, %eax
jne 0x52bc
movq %r15, %rdi
movq %rbx, %rsi
callq 0x679a
cmpb $0x1, (%rbx)
jne 0x52bc
movq %r14, %rdi
movq %rbx, %rsi
callq 0x52c2
cmpb $0x1, (%rbx)
jne 0x52bc
movq %r14, %rdi
movl $0x13, %esi
jmp 0x52af
movq %r15, %rdi
movq %rbx, %rsi
callq 0x679a
cmpb $0x1, (%rbx)
jne 0x52bc
movq %r14, %rdi
movq %rbx, %rsi
callq 0x52c2
cmpb $0x1, (%rbx)
jne 0x52bc
movq %r14, %rdi
movl $0x14, %esi
movq %rbx, %rdx
callq 0x392d
cmpb $0x0, (%rbx)
jne 0x524c
popq %rbx
popq %r14
popq %r15
retq
| compile_add_expr:
push r15
push r14
push rbx
mov rbx, rsi
mov r14, rdi
call compile_mul_expr
cmp byte ptr [rbx], 1
jnz short loc_52BC
lea r15, [r14+27F8h]
loc_524C:
mov eax, [r14+2810h]
cmp eax, 1Ah
jz short loc_5287
cmp eax, 18h
jnz short loc_52BC
mov rdi, r15
mov rsi, rbx
call rak_lexer_next
cmp byte ptr [rbx], 1
jnz short loc_52BC
mov rdi, r14
mov rsi, rbx
call compile_mul_expr
cmp byte ptr [rbx], 1
jnz short loc_52BC
mov rdi, r14
mov esi, 13h
jmp short loc_52AF
loc_5287:
mov rdi, r15
mov rsi, rbx
call rak_lexer_next
cmp byte ptr [rbx], 1
jnz short loc_52BC
mov rdi, r14
mov rsi, rbx
call compile_mul_expr
cmp byte ptr [rbx], 1
jnz short loc_52BC
mov rdi, r14
mov esi, 14h
loc_52AF:
mov rdx, rbx
call rak_chunk_append_instr
cmp byte ptr [rbx], 0
jnz short loc_524C
loc_52BC:
pop rbx
pop r14
pop r15
retn
| long long compile_add_expr(long long a1, char *a2)
{
long long result; // rax
int v5; // ecx
int v6; // r8d
int v7; // r9d
long long v8; // rdi
int v9; // esi
result = ((long long (*)(void))compile_mul_expr)();
if ( *a2 == 1 )
{
do
{
result = *(unsigned int *)(a1 + 10256);
if ( (_DWORD)result == 26 )
{
result = rak_lexer_next(a1 + 10232, a2);
if ( *a2 != 1 )
return result;
result = compile_mul_expr(a1, a2);
if ( *a2 != 1 )
return result;
v8 = a1;
v9 = 20;
}
else
{
if ( (_DWORD)result != 24 )
return result;
result = rak_lexer_next(a1 + 10232, a2);
if ( *a2 != 1 )
return result;
result = compile_mul_expr(a1, a2);
if ( *a2 != 1 )
return result;
v8 = a1;
v9 = 19;
}
result = rak_chunk_append_instr(v8, v9, a2, v5, v6, v7);
}
while ( *a2 );
}
return result;
}
| compile_add_expr:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R14,RDI
CALL 0x001052c2
CMP byte ptr [RBX],0x1
JNZ 0x001052bc
LEA R15,[R14 + 0x27f8]
LAB_0010524c:
MOV EAX,dword ptr [R14 + 0x2810]
CMP EAX,0x1a
JZ 0x00105287
CMP EAX,0x18
JNZ 0x001052bc
MOV RDI,R15
MOV RSI,RBX
CALL 0x0010679a
CMP byte ptr [RBX],0x1
JNZ 0x001052bc
MOV RDI,R14
MOV RSI,RBX
CALL 0x001052c2
CMP byte ptr [RBX],0x1
JNZ 0x001052bc
MOV RDI,R14
MOV ESI,0x13
JMP 0x001052af
LAB_00105287:
MOV RDI,R15
MOV RSI,RBX
CALL 0x0010679a
CMP byte ptr [RBX],0x1
JNZ 0x001052bc
MOV RDI,R14
MOV RSI,RBX
CALL 0x001052c2
CMP byte ptr [RBX],0x1
JNZ 0x001052bc
MOV RDI,R14
MOV ESI,0x14
LAB_001052af:
MOV RDX,RBX
CALL 0x0010392d
CMP byte ptr [RBX],0x0
JNZ 0x0010524c
LAB_001052bc:
POP RBX
POP R14
POP R15
RET
|
void compile_add_expr(long param_1,char *param_2)
{
int8 uVar1;
compile_mul_expr();
if (*param_2 == '\x01') {
do {
if (*(int *)(param_1 + 0x2810) == 0x1a) {
rak_lexer_next(param_1 + 0x27f8,param_2);
if (*param_2 != '\x01') {
return;
}
compile_mul_expr(param_1,param_2);
if (*param_2 != '\x01') {
return;
}
uVar1 = 0x14;
}
else {
if (*(int *)(param_1 + 0x2810) != 0x18) {
return;
}
rak_lexer_next(param_1 + 0x27f8,param_2);
if (*param_2 != '\x01') {
return;
}
compile_mul_expr(param_1,param_2);
if (*param_2 != '\x01') {
return;
}
uVar1 = 0x13;
}
rak_chunk_append_instr(param_1,uVar1,param_2);
} while (*param_2 != '\0');
}
return;
}
| |
43,513 | minja::Value::at(minja::Value const&) | monkey531[P]llama/common/./minja.hpp | Value& at(const Value & index) {
if (!index.is_hashable()) throw std::runtime_error("Unashable type: " + dump());
if (is_array()) return array_->at(index.get<int>());
if (is_object()) return object_->at(index.primitive_);
throw std::runtime_error("Value is not an array or object: " + dump());
} | O0 | cpp | minja::Value::at(minja::Value const&):
subq $0xd8, %rsp
movq %rdi, 0xc8(%rsp)
movq %rsi, 0xc0(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0xc0(%rsp), %rdi
callq 0xcf6e0
testb $0x1, %al
jne 0xd9bcc
movb $0x1, 0x73(%rsp)
movl $0x10, %edi
callq 0x50540
movq 0x20(%rsp), %rsi
movq %rax, 0x18(%rsp)
leaq 0x80(%rsp), %rdi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x9feb0
jmp 0xd9b18
leaq 0xf7b27(%rip), %rsi # 0x1d1646
leaq 0xa0(%rsp), %rdi
leaq 0x80(%rsp), %rdx
callq 0x7a6e0
jmp 0xd9b36
movq 0x18(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x50390
jmp 0xd9b4a
movq 0x18(%rsp), %rdi
movb $0x0, 0x73(%rsp)
movq 0x17a455(%rip), %rsi # 0x253fb0
movq 0x17a416(%rip), %rdx # 0x253f78
callq 0x508f0
jmp 0xd9d3a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0xd9bb4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0xd9ba7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x510c0
leaq 0x80(%rsp), %rdi
callq 0x510c0
testb $0x1, 0x73(%rsp)
jne 0xd9bbd
jmp 0xd9bc7
movq 0x18(%rsp), %rdi
callq 0x50c40
jmp 0xd9d30
movq 0x20(%rsp), %rdi
callq 0xa4990
testb $0x1, %al
jne 0xd9bdc
jmp 0xd9c16
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
callq 0xa19f0
movq %rax, 0x10(%rsp)
movq 0xc0(%rsp), %rdi
callq 0xd41d0
movq 0x10(%rsp), %rdi
movslq %eax, %rsi
callq 0xd3f80
movq %rax, 0xd0(%rsp)
jmp 0xd9d20
movq 0x20(%rsp), %rdi
callq 0xa5180
testb $0x1, %al
jne 0xd9c26
jmp 0xd9c55
movq 0x20(%rsp), %rdi
addq $0x20, %rdi
callq 0xa1ad0
movq %rax, %rdi
movq 0xc0(%rsp), %rsi
addq $0x40, %rsi
callq 0xdd550
movq %rax, 0xd0(%rsp)
jmp 0xd9d20
movb $0x1, 0x2f(%rsp)
movl $0x10, %edi
callq 0x50540
movq 0x20(%rsp), %rsi
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x9feb0
jmp 0xd9c81
leaq 0xf7b0a(%rip), %rsi # 0x1d1792
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x7a6e0
jmp 0xd9c99
movq 0x8(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x50390
jmp 0xd9caa
movq 0x8(%rsp), %rdi
movb $0x0, 0x2f(%rsp)
movq 0x17a2f5(%rip), %rsi # 0x253fb0
movq 0x17a2b6(%rip), %rdx # 0x253f78
callq 0x508f0
jmp 0xd9d3a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0xd9d0b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0xd9d01
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x510c0
leaq 0x30(%rsp), %rdi
callq 0x510c0
testb $0x1, 0x2f(%rsp)
jne 0xd9d14
jmp 0xd9d1e
movq 0x8(%rsp), %rdi
callq 0x50c40
jmp 0xd9d30
movq 0xd0(%rsp), %rax
addq $0xd8, %rsp
retq
movq 0x78(%rsp), %rdi
callq 0x50940
nopw (%rax,%rax)
| _ZN5minja5Value2atERKS0_:
sub rsp, 0D8h
mov [rsp+0D8h+var_10], rdi
mov [rsp+0D8h+var_18], rsi
mov rax, [rsp+0D8h+var_10]
mov [rsp+0D8h+var_B8], rax
mov rdi, [rsp+0D8h+var_18]; this
call _ZNK5minja5Value11is_hashableEv; minja::Value::is_hashable(void)
test al, 1
jnz loc_D9BCC
mov [rsp+0D8h+var_65], 1
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rsi, [rsp+0D8h+var_B8]
mov [rsp+0D8h+var_C0], rax
lea rdi, [rsp+0D8h+var_58]
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
jmp short $+2
loc_D9B18:
lea rsi, aUnashableType; "Unashable type: "
lea rdi, [rsp+0D8h+var_38]
lea rdx, [rsp+0D8h+var_58]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
jmp short $+2
loc_D9B36:
mov rdi, [rsp+0D8h+var_C0]
lea rsi, [rsp+0D8h+var_38]
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
jmp short $+2
loc_D9B4A:
mov rdi, [rsp+0D8h+var_C0]; void *
mov [rsp+0D8h+var_65], 0
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
jmp loc_D9D3A
mov rcx, rax
mov eax, edx
mov [rsp+arg_70], rcx
mov [rsp+arg_6C], eax
jmp short loc_D9BB4
mov rcx, rax
mov eax, edx
mov [rsp+arg_70], rcx
mov [rsp+arg_6C], eax
jmp short loc_D9BA7
mov rcx, rax
mov eax, edx
mov [rsp+arg_70], rcx
mov [rsp+arg_6C], eax
lea rdi, [rsp+arg_98]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_D9BA7:
lea rdi, [rsp+arg_78]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_D9BB4:
test [rsp+arg_6B], 1
jnz short loc_D9BBD
jmp short loc_D9BC7
loc_D9BBD:
mov rdi, [rsp+arg_10]; void *
call ___cxa_free_exception
loc_D9BC7:
jmp loc_D9D30
loc_D9BCC:
mov rdi, [rsp+0D8h+var_B8]; this
call _ZNK5minja5Value8is_arrayEv; minja::Value::is_array(void)
test al, 1
jnz short loc_D9BDC
jmp short loc_D9C16
loc_D9BDC:
mov rdi, [rsp+0D8h+var_B8]
add rdi, 10h
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 [rsp+0D8h+var_C8], rax
mov rdi, [rsp+0D8h+var_18]
call _ZNK5minja5Value3getIiEET_v; minja::Value::get<int>(void)
mov rdi, [rsp+0D8h+var_C8]
movsxd rsi, eax
call _ZNSt6vectorIN5minja5ValueESaIS1_EE2atEm; std::vector<minja::Value>::at(ulong)
mov [rsp+0D8h+var_8], rax
jmp loc_D9D20
loc_D9C16:
mov rdi, [rsp+0D8h+var_B8]; this
call _ZNK5minja5Value9is_objectEv; minja::Value::is_object(void)
test al, 1
jnz short loc_D9C26
jmp short loc_D9C55
loc_D9C26:
mov rdi, [rsp+0D8h+var_B8]
add rdi, 20h ; ' '
call _ZNKSt19__shared_ptr_accessIN8nlohmann16json_abi_v3_11_311ordered_mapINS1_10basic_jsonIS2_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEN5minja5ValueESt4lessISE_ESaISt4pairIKSE_SG_EEEELN9__gnu_cxx12_Lock_policyE2ELb0ELb0EEptEv; std::__shared_ptr_access<nlohmann::json_abi_v3_11_3::ordered_map<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>,minja::Value,std::less<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<std::pair<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,minja::Value>>>,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(void)
mov rdi, rax
mov rsi, [rsp+0D8h+var_18]
add rsi, 40h ; '@'
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE2atERSJ_; nlohmann::json_abi_v3_11_3::ordered_map<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>,minja::Value,std::less<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<std::pair<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,minja::Value>>>::at(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 [rsp+0D8h+var_8], rax
jmp loc_D9D20
loc_D9C55:
mov [rsp+0D8h+var_A9], 1
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rsi, [rsp+0D8h+var_B8]
mov [rsp+0D8h+var_D0], rax
lea rdi, [rsp+0D8h+var_A8]
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
jmp short $+2
loc_D9C81:
lea rsi, aValueIsNotAnAr_0; "Value is not an array or object: "
lea rdi, [rsp+0D8h+var_88]
lea rdx, [rsp+0D8h+var_A8]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
jmp short $+2
loc_D9C99:
mov rdi, [rsp+0D8h+var_D0]
lea rsi, [rsp+0D8h+var_88]
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
jmp short $+2
loc_D9CAA:
mov rdi, [rsp+0D8h+var_D0]; void *
mov [rsp+0D8h+var_A9], 0
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
jmp short loc_D9D3A
mov rcx, rax
mov eax, edx
mov [rsp+arg_70], rcx
mov [rsp+arg_6C], eax
jmp short loc_D9D0B
mov rcx, rax
mov eax, edx
mov [rsp+arg_70], rcx
mov [rsp+arg_6C], eax
jmp short loc_D9D01
mov rcx, rax
mov eax, edx
mov [rsp+arg_70], rcx
mov [rsp+arg_6C], eax
lea rdi, [rsp+arg_48]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_D9D01:
lea rdi, [rsp+arg_28]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_D9D0B:
test [rsp+arg_27], 1
jnz short loc_D9D14
jmp short loc_D9D1E
loc_D9D14:
mov rdi, [rsp+arg_0]; void *
call ___cxa_free_exception
loc_D9D1E:
jmp short loc_D9D30
loc_D9D20:
mov rax, [rsp+0D8h+var_8]
add rsp, 0D8h
retn
loc_D9D30:
mov rdi, [rsp+arg_70]
call __Unwind_Resume
loc_D9D3A:
nop word ptr [rax+rax+00h]
| long long minja::Value::at(minja::Value *this, const minja::Value *a2)
{
int v2; // eax
long long v3; // rax
void *v5; // [rsp+8h] [rbp-D0h]
_QWORD *v6; // [rsp+10h] [rbp-C8h]
void *exception; // [rsp+18h] [rbp-C0h]
_BYTE v8[32]; // [rsp+30h] [rbp-A8h] BYREF
_BYTE v9[48]; // [rsp+50h] [rbp-88h] BYREF
_BYTE v10[32]; // [rsp+80h] [rbp-58h] BYREF
_BYTE v11[32]; // [rsp+A0h] [rbp-38h] BYREF
minja::Value *v12; // [rsp+C0h] [rbp-18h]
minja::Value *v13; // [rsp+C8h] [rbp-10h]
v13 = this;
v12 = a2;
if ( (minja::Value::is_hashable(a2) & 1) == 0 )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v10, (long long)this, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v11, (long long)"Unashable type: ", (long long)v10);
std::runtime_error::runtime_error(exception, v11);
v9[35] = 0;
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( minja::Value::is_array(this) )
{
v6 = (_QWORD *)std::__shared_ptr_access<std::vector<minja::Value>,(__gnu_cxx::_Lock_policy)2,false,false>::operator->((long long)this + 16);
v2 = minja::Value::get<int>(v12);
return std::vector<minja::Value>::at(v6, v2);
}
else
{
if ( !minja::Value::is_object(this) )
{
v5 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v8, (long long)this, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v9, (long long)"Value is not an array or object: ", (long long)v8);
std::runtime_error::runtime_error(v5, v9);
__cxa_throw(
v5,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v3 = std::__shared_ptr_access<nlohmann::json_abi_v3_11_3::ordered_map<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>,minja::Value,std::less<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<std::pair<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,minja::Value>>>,(__gnu_cxx::_Lock_policy)2,false,false>::operator->((long long)this + 32);
return nlohmann::json_abi_v3_11_3::ordered_map<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>,minja::Value,std::less<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<std::pair<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,minja::Value>>>::at(
v3,
(char *)v12 + 64);
}
}
| at:
SUB RSP,0xd8
MOV qword ptr [RSP + 0xc8],RDI
MOV qword ptr [RSP + 0xc0],RSI
MOV RAX,qword ptr [RSP + 0xc8]
MOV qword ptr [RSP + 0x20],RAX
MOV RDI,qword ptr [RSP + 0xc0]
CALL 0x001cf6e0
TEST AL,0x1
JNZ 0x001d9bcc
MOV byte ptr [RSP + 0x73],0x1
MOV EDI,0x10
CALL 0x00150540
MOV RSI,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x18],RAX
LAB_001d9b02:
LEA RDI,[RSP + 0x80]
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x0019feb0
JMP 0x001d9b18
LAB_001d9b18:
LEA RSI,[0x2d1646]
LEA RDI,[RSP + 0xa0]
LEA RDX,[RSP + 0x80]
CALL 0x0017a6e0
JMP 0x001d9b36
LAB_001d9b36:
MOV RDI,qword ptr [RSP + 0x18]
LEA RSI,[RSP + 0xa0]
CALL 0x00150390
JMP 0x001d9b4a
LAB_001d9b4a:
MOV RDI,qword ptr [RSP + 0x18]
MOV byte ptr [RSP + 0x73],0x0
MOV RSI,qword ptr [0x00353fb0]
MOV RDX,qword ptr [0x00353f78]
CALL 0x001508f0
LAB_001d9bcc:
MOV RDI,qword ptr [RSP + 0x20]
CALL 0x001a4990
TEST AL,0x1
JNZ 0x001d9bdc
JMP 0x001d9c16
LAB_001d9bdc:
MOV RDI,qword ptr [RSP + 0x20]
ADD RDI,0x10
CALL 0x001a19f0
MOV qword ptr [RSP + 0x10],RAX
MOV RDI,qword ptr [RSP + 0xc0]
CALL 0x001d41d0
MOV RDI,qword ptr [RSP + 0x10]
MOVSXD RSI,EAX
CALL 0x001d3f80
MOV qword ptr [RSP + 0xd0],RAX
JMP 0x001d9d20
LAB_001d9c16:
MOV RDI,qword ptr [RSP + 0x20]
CALL 0x001a5180
TEST AL,0x1
JNZ 0x001d9c26
JMP 0x001d9c55
LAB_001d9c26:
MOV RDI,qword ptr [RSP + 0x20]
ADD RDI,0x20
CALL 0x001a1ad0
MOV RDI,RAX
MOV RSI,qword ptr [RSP + 0xc0]
ADD RSI,0x40
CALL 0x001dd550
MOV qword ptr [RSP + 0xd0],RAX
JMP 0x001d9d20
LAB_001d9c55:
MOV byte ptr [RSP + 0x2f],0x1
MOV EDI,0x10
CALL 0x00150540
MOV RSI,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x8],RAX
LAB_001d9c6e:
LEA RDI,[RSP + 0x30]
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x0019feb0
JMP 0x001d9c81
LAB_001d9c81:
LEA RSI,[0x2d1792]
LEA RDI,[RSP + 0x50]
LEA RDX,[RSP + 0x30]
CALL 0x0017a6e0
JMP 0x001d9c99
LAB_001d9c99:
MOV RDI,qword ptr [RSP + 0x8]
LEA RSI,[RSP + 0x50]
CALL 0x00150390
JMP 0x001d9caa
LAB_001d9caa:
MOV RDI,qword ptr [RSP + 0x8]
MOV byte ptr [RSP + 0x2f],0x0
MOV RSI,qword ptr [0x00353fb0]
MOV RDX,qword ptr [0x00353f78]
CALL 0x001508f0
LAB_001d9d20:
MOV RAX,qword ptr [RSP + 0xd0]
ADD RSP,0xd8
RET
|
/* minja::Value::at(minja::Value const&) */
int8 __thiscall minja::Value::at(Value *this,Value *param_1)
{
int iVar1;
ulong uVar2;
runtime_error *prVar3;
vector<minja::Value,std::allocator<minja::Value>> *this_00;
ordered_map<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>,minja::Value,std::less<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<std::pair<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,minja::Value>>>
*this_01;
int1 local_a8 [32];
string local_88 [35];
int1 local_65;
int1 local_58 [32];
string local_38 [32];
Value *local_18;
Value *local_10;
int8 local_8;
local_18 = param_1;
local_10 = this;
uVar2 = is_hashable(param_1);
if ((uVar2 & 1) == 0) {
local_65 = 1;
prVar3 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001d9b02 to 001d9b15 has its CatchHandler @ 001d9b6c */
dump_abi_cxx11_((int)local_58,SUB81(this,0));
/* try { // try from 001d9b18 to 001d9b33 has its CatchHandler @ 001d9b7c */
std::operator+((char *)local_38,(string *)"Unashable type: ");
/* try { // try from 001d9b36 to 001d9b66 has its CatchHandler @ 001d9b8c */
std::runtime_error::runtime_error(prVar3,local_38);
local_65 = 0;
/* WARNING: Subroutine does not return */
__cxa_throw(prVar3,PTR_typeinfo_00353fb0,PTR__runtime_error_00353f78);
}
uVar2 = is_array(this);
if ((uVar2 & 1) == 0) {
uVar2 = is_object(this);
if ((uVar2 & 1) == 0) {
prVar3 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001d9c6e to 001d9c7e has its CatchHandler @ 001d9cc9 */
dump_abi_cxx11_((int)local_a8,SUB81(this,0));
/* try { // try from 001d9c81 to 001d9c96 has its CatchHandler @ 001d9cd9 */
std::operator+((char *)local_88,(string *)"Value is not an array or object: ");
/* try { // try from 001d9c99 to 001d9cc6 has its CatchHandler @ 001d9ce9 */
std::runtime_error::runtime_error(prVar3,local_88);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar3,PTR_typeinfo_00353fb0,PTR__runtime_error_00353f78);
}
this_01 = (ordered_map<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>,minja::Value,std::less<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<std::pair<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,minja::Value>>>
*)std::
__shared_ptr_access<nlohmann::json_abi_v3_11_3::ordered_map<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>,minja::Value,std::less<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<std::pair<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,minja::Value>>>,(__gnu_cxx::_Lock_policy)2,false,false>
::operator->((__shared_ptr_access<nlohmann::json_abi_v3_11_3::ordered_map<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>,minja::Value,std::less<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<std::pair<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,minja::Value>>>,(__gnu_cxx::_Lock_policy)2,false,false>
*)(this + 0x20));
local_8 = nlohmann::json_abi_v3_11_3::
ordered_map<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>,minja::Value,std::less<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<std::pair<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,minja::Value>>>
::at(this_01,(basic_json *)(local_18 + 0x40));
}
else {
this_00 = (vector<minja::Value,std::allocator<minja::Value>> *)
std::
__shared_ptr_access<std::vector<minja::Value,std::allocator<minja::Value>>,(__gnu_cxx::_Lock_policy)2,false,false>
::operator->((__shared_ptr_access<std::vector<minja::Value,std::allocator<minja::Value>>,(__gnu_cxx::_Lock_policy)2,false,false>
*)(this + 0x10));
iVar1 = get<int>(local_18);
local_8 = std::vector<minja::Value,std::allocator<minja::Value>>::at(this_00,(long)iVar1);
}
return local_8;
}
| |
43,514 | minja::Value::at(minja::Value const&) | monkey531[P]llama/common/./minja.hpp | Value& at(const Value & index) {
if (!index.is_hashable()) throw std::runtime_error("Unashable type: " + dump());
if (is_array()) return array_->at(index.get<int>());
if (is_object()) return object_->at(index.primitive_);
throw std::runtime_error("Value is not an array or object: " + dump());
} | O3 | cpp | minja::Value::at(minja::Value const&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
cmpq $0x0, 0x10(%rsi)
jne 0x54869
cmpq $0x0, 0x20(%rsi)
jne 0x54869
cmpq $0x0, 0x30(%rsi)
jne 0x54869
movq 0x10(%r14), %rbx
testq %rbx, %rbx
je 0x5484f
movq %rsi, %rdi
callq 0x51e3a
movslq %eax, %rsi
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rdx
cmpq %rsi, %rdx
jbe 0x548c6
leaq (%rsi,%rsi,4), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0x548d4
addq $0x40, %rsi
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x55d88
movl $0x10, %edi
callq 0x18360
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x3dcdc
leaq 0x66601(%rip), %rsi # 0xbae90
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x30c3b
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x18a80
xorl %ebp, %ebp
movq 0x9b73b(%rip), %rsi # 0xefff0
movq 0x9b6c4(%rip), %rdx # 0xeff80
movq %rbx, %rdi
callq 0x18b30
jmp 0x5492f
leaq 0x66731(%rip), %rdi # 0xbaffe
xorl %eax, %eax
callq 0x189e0
movl $0x10, %edi
callq 0x18360
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x3dcdc
leaq 0x666e2(%rip), %rsi # 0xbafdc
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x30c3b
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x18a80
xorl %ebp, %ebp
movq 0x9b6d0(%rip), %rsi # 0xefff0
movq 0x9b659(%rip), %rdx # 0xeff80
movq %rbx, %rdi
callq 0x18b30
jmp 0x54935
jmp 0x54975
jmp 0x54995
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x54953
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x186a0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5496e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x186a0
testb %bpl, %bpl
jne 0x54998
jmp 0x549a0
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x54998
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x186a0
jmp 0x54998
movq %rax, %r14
movq %rbx, %rdi
callq 0x18500
movq %r14, %rdi
callq 0x18b90
| _ZN5minja5Value2atERKS0_:
push rbp
push r14
push rbx
sub rsp, 40h
mov r14, rdi
cmp qword ptr [rsi+10h], 0
jnz short loc_54869
cmp qword ptr [rsi+20h], 0
jnz short loc_54869
cmp qword ptr [rsi+30h], 0
jnz short loc_54869
mov rbx, [r14+10h]
test rbx, rbx
jz short loc_5484F
mov rdi, rsi
call _ZNK5minja5Value3getIiEET_v; minja::Value::get<int>(void)
movsxd rsi, eax
mov rax, [rbx]
mov rcx, [rbx+8]
sub rcx, rax
sar rcx, 4
mov rdx, 0CCCCCCCCCCCCCCCDh
imul rdx, rcx
cmp rdx, rsi
jbe loc_548C6
lea rcx, [rsi+rsi*4]
shl rcx, 4
add rax, rcx
add rsp, 40h
pop rbx
pop r14
pop rbp
retn
loc_5484F:
mov rdi, [r14+20h]
test rdi, rdi
jz short loc_548D4
add rsi, 40h ; '@'
add rsp, 40h
pop rbx
pop r14
pop rbp
jmp _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE2atERSJ_; nlohmann::json_abi_v3_11_3::ordered_map<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>,minja::Value,std::less<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<std::pair<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,minja::Value>>>::at(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
loc_54869:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, rsp
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aUnashableType; "Unashable type: "
lea rdi, [rsp+58h+var_38]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+58h+var_38]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
jmp short loc_5492F
loc_548C6:
lea rdi, aVectorMRangeCh; "vector::_M_range_check: __n (which is %"...
xor eax, eax
call __ZSt24__throw_out_of_range_fmtPKcz; std::__throw_out_of_range_fmt(char const*,...)
loc_548D4:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, rsp
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aValueIsNotAnAr_0; "Value is not an array or object: "
lea rdi, [rsp+58h+var_38]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+58h+var_38]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_5492F:
jmp short loc_54935
jmp short loc_54975
jmp short loc_54995
loc_54935:
mov r14, rax
lea rax, [rsp+58h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_54953
mov rsi, [rsp+58h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_54953:
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_5496E
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5496E:
test bpl, bpl
jnz short loc_54998
jmp short loc_549A0
loc_54975:
mov r14, rax
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_54998
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_54998
loc_54995:
mov r14, rax
loc_54998:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_549A0:
mov rdi, r14
call __Unwind_Resume
| unsigned long long minja::Value::at(minja::Value *this, const minja::Value *a2)
{
_QWORD *v3; // rbx
unsigned long long v4; // rsi
unsigned long long v5; // rdx
long long v7; // rdi
void *exception; // rbx
void *v9; // rbx
_BYTE v10[16]; // [rsp+0h] [rbp-58h] BYREF
_BYTE v11[16]; // [rsp+20h] [rbp-38h] BYREF
if ( *((_QWORD *)a2 + 2) || *((_QWORD *)a2 + 4) || *((_QWORD *)a2 + 6) )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v10, (long long)this, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v11, (long long)"Unashable type: ", (long long)v10);
std::runtime_error::runtime_error(exception, v11);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v3 = (_QWORD *)*((_QWORD *)this + 2);
if ( v3 )
{
v4 = (int)minja::Value::get<int>(a2);
v5 = 0xCCCCCCCCCCCCCCCDLL * ((long long)(v3[1] - *v3) >> 4);
if ( v5 <= v4 )
std::__throw_out_of_range_fmt("vector::_M_range_check: __n (which is %zu) >= this->size() (which is %zu)", v4, v5);
return 80 * v4 + *v3;
}
else
{
v7 = *((_QWORD *)this + 4);
if ( !v7 )
{
v9 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v10, (long long)this, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v11, (long long)"Value is not an array or object: ", (long long)v10);
std::runtime_error::runtime_error(v9, v11);
__cxa_throw(
v9,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
return nlohmann::json_abi_v3_11_3::ordered_map<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>,minja::Value,std::less<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<std::pair<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,minja::Value>>>::at(
v7,
(char *)a2 + 64);
}
}
| at:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV R14,RDI
CMP qword ptr [RSI + 0x10],0x0
JNZ 0x00154869
CMP qword ptr [RSI + 0x20],0x0
JNZ 0x00154869
CMP qword ptr [RSI + 0x30],0x0
JNZ 0x00154869
MOV RBX,qword ptr [R14 + 0x10]
TEST RBX,RBX
JZ 0x0015484f
MOV RDI,RSI
CALL 0x00151e3a
MOVSXD RSI,EAX
MOV RAX,qword ptr [RBX]
MOV RCX,qword ptr [RBX + 0x8]
SUB RCX,RAX
SAR RCX,0x4
MOV RDX,-0x3333333333333333
IMUL RDX,RCX
CMP RDX,RSI
JBE 0x001548c6
LEA RCX,[RSI + RSI*0x4]
SHL RCX,0x4
ADD RAX,RCX
ADD RSP,0x40
POP RBX
POP R14
POP RBP
RET
LAB_0015484f:
MOV RDI,qword ptr [R14 + 0x20]
TEST RDI,RDI
JZ 0x001548d4
ADD RSI,0x40
ADD RSP,0x40
POP RBX
POP R14
POP RBP
JMP 0x00155d88
LAB_00154869:
MOV EDI,0x10
CALL 0x00118360
MOV RBX,RAX
LAB_00154876:
MOV RDI,RSP
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x0013dcdc
LAB_00154888:
LEA RSI,[0x1bae90]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x00130c3b
MOV BPL,0x1
LAB_0015489f:
LEA RSI,[RSP + 0x20]
MOV RDI,RBX
CALL 0x00118a80
XOR EBP,EBP
MOV RSI,qword ptr [0x001efff0]
MOV RDX,qword ptr [0x001eff80]
MOV RDI,RBX
CALL 0x00118b30
LAB_001548c6:
LEA RDI,[0x1baffe]
XOR EAX,EAX
CALL 0x001189e0
LAB_001548d4:
MOV EDI,0x10
CALL 0x00118360
MOV RBX,RAX
LAB_001548e1:
MOV RDI,RSP
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x0013dcdc
LAB_001548f3:
LEA RSI,[0x1bafdc]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x00130c3b
MOV BPL,0x1
LAB_0015490a:
LEA RSI,[RSP + 0x20]
MOV RDI,RBX
CALL 0x00118a80
XOR EBP,EBP
MOV RSI,qword ptr [0x001efff0]
MOV RDX,qword ptr [0x001eff80]
MOV RDI,RBX
CALL 0x00118b30
|
/* minja::Value::at(minja::Value const&) */
long __thiscall minja::Value::at(Value *this,Value *param_1)
{
long *plVar1;
int iVar2;
long lVar3;
runtime_error *prVar4;
ulong uVar5;
ulong uVar6;
int1 auStack_58 [32];
string local_38 [32];
if (((*(long *)(param_1 + 0x10) == 0) && (*(long *)(param_1 + 0x20) == 0)) &&
(*(long *)(param_1 + 0x30) == 0)) {
plVar1 = *(long **)(this + 0x10);
if (plVar1 == (long *)0x0) {
if (*(ordered_map<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>,minja::Value,std::less<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<std::pair<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,minja::Value>>>
**)(this + 0x20) !=
(ordered_map<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>,minja::Value,std::less<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<std::pair<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,minja::Value>>>
*)0x0) {
lVar3 = nlohmann::json_abi_v3_11_3::
ordered_map<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>,minja::Value,std::less<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<std::pair<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,minja::Value>>>
::at(*(ordered_map<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>,minja::Value,std::less<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<std::pair<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,minja::Value>>>
**)(this + 0x20),(basic_json *)(param_1 + 0x40));
return lVar3;
}
}
else {
iVar2 = get<int>(param_1);
uVar6 = (ulong)iVar2;
uVar5 = (plVar1[1] - *plVar1 >> 4) * -0x3333333333333333;
if (uVar6 <= uVar5 && uVar5 - uVar6 != 0) {
return *plVar1 + uVar6 * 0x50;
}
std::__throw_out_of_range_fmt
("vector::_M_range_check: __n (which is %zu) >= this->size() (which is %zu)");
}
prVar4 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001548e1 to 001548f2 has its CatchHandler @ 00154933 */
dump_abi_cxx11_((int)auStack_58,SUB81(this,0));
/* try { // try from 001548f3 to 00154906 has its CatchHandler @ 00154931 */
std::operator+((char *)local_38,(string *)"Value is not an array or object: ");
/* try { // try from 0015490a to 0015492e has its CatchHandler @ 0015492f */
std::runtime_error::runtime_error(prVar4,local_38);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar4,PTR_typeinfo_001efff0,PTR__runtime_error_001eff80);
}
prVar4 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00154876 to 00154887 has its CatchHandler @ 00154995 */
dump_abi_cxx11_((int)auStack_58,SUB81(this,0));
/* try { // try from 00154888 to 0015489b has its CatchHandler @ 00154975 */
std::operator+((char *)local_38,(string *)"Unashable type: ");
/* try { // try from 0015489f to 001548c3 has its CatchHandler @ 00154935 */
std::runtime_error::runtime_error(prVar4,local_38);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar4,PTR_typeinfo_001efff0,PTR__runtime_error_001eff80);
}
| |
43,515 | LefDefParser::defiPath::addShape(char const*) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defiPath.cpp | void defiPath::addShape(const char* l) {
int len = strlen(l)+1;
if (numUsed_ == numAllocated_)
bumpSize(numAllocated_ * 2);
keys_[numUsed_] = 'S' ;
data_[numUsed_] = malloc(len);
strcpy((char*)(data_[numUsed_]), defData->DEFCASE(l));
(numUsed_)++;
} | O3 | cpp | LefDefParser::defiPath::addShape(char const*):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x70d0
movq %rax, %r15
movl 0x10(%rbx), %esi
cmpl 0x14(%rbx), %esi
jne 0x14b43
addl %esi, %esi
movq %rbx, %rdi
callq 0x141a2
movl 0x10(%rbx), %esi
movq (%rbx), %rax
movslq %esi, %rcx
movl $0x53, (%rax,%rcx,4)
incl %r15d
movslq %r15d, %rdi
callq 0x7270
movq 0x8(%rbx), %rcx
movslq 0x10(%rbx), %rdx
movq %rax, (%rcx,%rdx,8)
movq 0x8(%rbx), %rax
movq 0x40(%rbx), %rdi
movq (%rax,%rdx,8), %r15
movq %r14, %rsi
callq 0x1b638
movq %r15, %rdi
movq %rax, %rsi
callq 0x7190
incl 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
| _ZN12LefDefParser8defiPath8addShapeEPKc:
push r15
push r14
push rbx
mov r14, rsi
mov rbx, rdi
mov rdi, rsi
call _strlen
mov r15, rax
mov esi, [rbx+10h]
cmp esi, [rbx+14h]
jnz short loc_14B43
add esi, esi; int
mov rdi, rbx; this
call _ZN12LefDefParser8defiPath8bumpSizeEi; LefDefParser::defiPath::bumpSize(int)
mov esi, [rbx+10h]
loc_14B43:
mov rax, [rbx]
movsxd rcx, esi
mov dword ptr [rax+rcx*4], 53h ; 'S'
inc r15d
movsxd rdi, r15d
call _malloc
mov rcx, [rbx+8]
movsxd rdx, dword ptr [rbx+10h]
mov [rcx+rdx*8], rax
mov rax, [rbx+8]
mov rdi, [rbx+40h]; this
mov r15, [rax+rdx*8]
mov rsi, r14; char *
call _ZN12LefDefParser8defrData7DEFCASEEPKc; LefDefParser::defrData::DEFCASE(char const*)
mov rdi, r15
mov rsi, rax
call _strcpy
inc dword ptr [rbx+10h]
pop rbx
pop r14
pop r15
retn
| long long LefDefParser::defiPath::addShape(LefDefParser::defiPath *this, const char *a2)
{
int v3; // r15d
int v4; // esi
long long v5; // rax
long long v6; // rdx
long long v7; // r15
long long v8; // rax
long long result; // rax
v3 = strlen(a2);
v4 = *((_DWORD *)this + 4);
if ( v4 == *((_DWORD *)this + 5) )
{
LefDefParser::defiPath::bumpSize(this, 2 * v4);
v4 = *((_DWORD *)this + 4);
}
*(_DWORD *)(*(_QWORD *)this + 4LL * v4) = 83;
v5 = malloc(v3 + 1);
v6 = *((int *)this + 4);
*(_QWORD *)(*((_QWORD *)this + 1) + 8 * v6) = v5;
v7 = *(_QWORD *)(*((_QWORD *)this + 1) + 8 * v6);
v8 = LefDefParser::defrData::DEFCASE(*((LefDefParser::defrData **)this + 8), a2);
result = strcpy(v7, v8);
++*((_DWORD *)this + 4);
return result;
}
| addShape:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RSI
MOV RBX,RDI
MOV RDI,RSI
CALL 0x001070d0
MOV R15,RAX
MOV ESI,dword ptr [RBX + 0x10]
CMP ESI,dword ptr [RBX + 0x14]
JNZ 0x00114b43
ADD ESI,ESI
MOV RDI,RBX
CALL 0x001141a2
MOV ESI,dword ptr [RBX + 0x10]
LAB_00114b43:
MOV RAX,qword ptr [RBX]
MOVSXD RCX,ESI
MOV dword ptr [RAX + RCX*0x4],0x53
INC R15D
MOVSXD RDI,R15D
CALL 0x00107270
MOV RCX,qword ptr [RBX + 0x8]
MOVSXD RDX,dword ptr [RBX + 0x10]
MOV qword ptr [RCX + RDX*0x8],RAX
MOV RAX,qword ptr [RBX + 0x8]
MOV RDI,qword ptr [RBX + 0x40]
MOV R15,qword ptr [RAX + RDX*0x8]
MOV RSI,R14
CALL 0x0011b638
MOV RDI,R15
MOV RSI,RAX
CALL 0x00107190
INC dword ptr [RBX + 0x10]
POP RBX
POP R14
POP R15
RET
|
/* LefDefParser::defiPath::addShape(char const*) */
void __thiscall LefDefParser::defiPath::addShape(defiPath *this,char *param_1)
{
char *__dest;
size_t sVar1;
void *pvVar2;
char *__src;
int iVar3;
sVar1 = strlen(param_1);
iVar3 = *(int *)(this + 0x10);
if (iVar3 == *(int *)(this + 0x14)) {
bumpSize(this,iVar3 * 2);
iVar3 = *(int *)(this + 0x10);
}
*(int4 *)(*(long *)this + (long)iVar3 * 4) = 0x53;
pvVar2 = malloc((long)((int)sVar1 + 1));
iVar3 = *(int *)(this + 0x10);
*(void **)(*(long *)(this + 8) + (long)iVar3 * 8) = pvVar2;
__dest = *(char **)(*(long *)(this + 8) + (long)iVar3 * 8);
__src = (char *)defrData::DEFCASE(*(defrData **)(this + 0x40),param_1);
strcpy(__dest,__src);
*(int *)(this + 0x10) = *(int *)(this + 0x10) + 1;
return;
}
| |
43,516 | bfdec_add_si | bluesky950520[P]quickjs/libbf.c | int bfdec_add_si(bfdec_t *r, const bfdec_t *a, int64_t b1, limb_t prec,
bf_flags_t flags)
{
bfdec_t b;
int ret;
bfdec_init(r->ctx, &b);
ret = bfdec_set_si(&b, b1);
ret |= bfdec_add(r, a, &b, prec, flags);
bfdec_delete(&b);
return ret;
} | O1 | c | bfdec_add_si:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq (%rdi), %rax
movq %rsp, %r13
movq %rax, (%r13)
movl $0x0, 0x8(%r13)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x10(%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r13)
movq %r13, %rdi
movq %rdx, %rsi
callq 0x8edcb
movl %eax, %ebx
leaq -0x429(%rip), %r9 # 0x8edfd
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %r14, %rcx
movl %ebp, %r8d
callq 0x87b3a
movl %eax, %ebp
movq (%r13), %rax
testq %rax, %rax
je 0x8f257
movq 0x20(%rsp), %rsi
testq %rsi, %rsi
je 0x8f257
movq (%rax), %rdi
xorl %edx, %edx
callq *0x8(%rax)
orl %ebx, %ebp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| bfdec_add_si:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov ebp, r8d
mov r14, rcx
mov r15, rsi
mov r12, rdi
mov rax, [rdi]
mov r13, rsp
mov [r13+0], rax
mov dword ptr [r13+8], 0
mov rax, 8000000000000000h
mov [r13+10h], rax
xorps xmm0, xmm0
movups xmmword ptr [r13+18h], xmm0
mov rdi, r13
mov rsi, rdx
call bfdec_set_si
mov ebx, eax
lea r9, __bfdec_add
mov rdi, r12
mov rsi, r15
mov rdx, r13
mov rcx, r14
mov r8d, ebp
call bf_op2
mov ebp, eax
mov rax, [r13+0]
test rax, rax
jz short loc_8F257
mov rsi, [rsp+58h+var_38]
test rsi, rsi
jz short loc_8F257
mov rdi, [rax]
xor edx, edx
call qword ptr [rax+8]
loc_8F257:
or ebp, ebx
mov eax, ebp
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long bfdec_add_si(__int128 *a1, __int128 *a2, signed long long a3, long long a4, unsigned int a5)
{
int v7; // ebx
unsigned int v8; // ebp
__int128 v10; // [rsp+0h] [rbp-58h] BYREF
unsigned long long v11; // [rsp+10h] [rbp-48h]
__int128 v12; // [rsp+18h] [rbp-40h]
*(_QWORD *)&v10 = *(_QWORD *)a1;
DWORD2(v10) = 0;
v11 = 0x8000000000000000LL;
v12 = 0LL;
v7 = bfdec_set_si((long long)&v10, a3);
v8 = bf_op2(a1, a2, &v10, a4, a5, (long long ( *)(__int128 *))_bfdec_add);
if ( (_QWORD)v10 && *((_QWORD *)&v12 + 1) )
(*(void ( **)(_QWORD, _QWORD, _QWORD))(v10 + 8))(*(_QWORD *)v10, *((_QWORD *)&v12 + 1), 0LL);
return v7 | v8;
}
| bfdec_add_si:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV EBP,R8D
MOV R14,RCX
MOV R15,RSI
MOV R12,RDI
MOV RAX,qword ptr [RDI]
MOV R13,RSP
MOV qword ptr [R13],RAX
MOV dword ptr [R13 + 0x8],0x0
MOV RAX,-0x8000000000000000
MOV qword ptr [R13 + 0x10],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R13 + 0x18],XMM0
MOV RDI,R13
MOV RSI,RDX
CALL 0x0018edcb
MOV EBX,EAX
LEA R9,[0x18edfd]
MOV RDI,R12
MOV RSI,R15
MOV RDX,R13
MOV RCX,R14
MOV R8D,EBP
CALL 0x00187b3a
MOV EBP,EAX
MOV RAX,qword ptr [R13]
TEST RAX,RAX
JZ 0x0018f257
MOV RSI,qword ptr [RSP + 0x20]
TEST RSI,RSI
JZ 0x0018f257
MOV RDI,qword ptr [RAX]
XOR EDX,EDX
CALL qword ptr [RAX + 0x8]
LAB_0018f257:
OR EBP,EBX
MOV EAX,EBP
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
uint bfdec_add_si(int8 *param_1,int8 param_2,int8 param_3,int8 param_4,
int4 param_5)
{
uint uVar1;
uint uVar2;
int8 *local_58;
int4 local_50;
int8 local_48;
int8 local_40;
long lStack_38;
local_58 = (int8 *)*param_1;
local_50 = 0;
local_48 = 0x8000000000000000;
local_40 = 0;
lStack_38 = 0;
uVar1 = bfdec_set_si(&local_58,param_3);
uVar2 = bf_op2(param_1,param_2,&local_58,param_4,param_5,__bfdec_add);
if ((local_58 != (int8 *)0x0) && (lStack_38 != 0)) {
(*(code *)local_58[1])(*local_58,lStack_38,0);
}
return uVar2 | uVar1;
}
| |
43,517 | bfdec_add_si | bluesky950520[P]quickjs/libbf.c | int bfdec_add_si(bfdec_t *r, const bfdec_t *a, int64_t b1, limb_t prec,
bf_flags_t flags)
{
bfdec_t b;
int ret;
bfdec_init(r->ctx, &b);
ret = bfdec_set_si(&b, b1);
ret |= bfdec_add(r, a, &b, prec, flags);
bfdec_delete(&b);
return ret;
} | O2 | c | bfdec_add_si:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebx
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq (%rdi), %rax
movq %rsp, %r13
movq %rax, (%r13)
andl $0x0, 0x8(%r13)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x10(%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r13)
movq %r13, %rdi
movq %rdx, %rsi
callq 0x77455
movl %eax, %ebp
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %r14, %rcx
movl %ebx, %r8d
callq 0x7747b
movl %eax, %ebx
orl %ebp, %ebx
movq %r13, %rdi
callq 0x7145e
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| bfdec_add_si:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov ebx, r8d
mov r14, rcx
mov r15, rsi
mov r12, rdi
mov rax, [rdi]
mov r13, rsp
mov [r13+0], rax
and dword ptr [r13+8], 0
mov rax, 8000000000000000h
mov [r13+10h], rax
xorps xmm0, xmm0
movups xmmword ptr [r13+18h], xmm0
mov rdi, r13
mov rsi, rdx
call bfdec_set_si
mov ebp, eax
mov rdi, r12
mov rsi, r15
mov rdx, r13
mov rcx, r14
mov r8d, ebx
call bfdec_add
mov ebx, eax
or ebx, ebp
mov rdi, r13
call bf_delete_0
mov eax, ebx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long bfdec_add_si(__int128 *a1, __int128 *a2, signed long long a3, long long a4, unsigned int a5)
{
int v7; // ebp
unsigned int v8; // ebx
__int128 v10; // [rsp+0h] [rbp-58h] BYREF
unsigned long long v11; // [rsp+10h] [rbp-48h]
__int128 v12; // [rsp+18h] [rbp-40h]
*(_QWORD *)&v10 = *(_QWORD *)a1;
DWORD2(v10) = 0;
v11 = 0x8000000000000000LL;
v12 = 0LL;
v7 = bfdec_set_si((long long)&v10, a3);
v8 = v7 | bfdec_add(a1, a2, &v10, a4, a5);
bf_delete_0((long long *)&v10);
return v8;
}
| bfdec_add_si:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV EBX,R8D
MOV R14,RCX
MOV R15,RSI
MOV R12,RDI
MOV RAX,qword ptr [RDI]
MOV R13,RSP
MOV qword ptr [R13],RAX
AND dword ptr [R13 + 0x8],0x0
MOV RAX,-0x8000000000000000
MOV qword ptr [R13 + 0x10],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R13 + 0x18],XMM0
MOV RDI,R13
MOV RSI,RDX
CALL 0x00177455
MOV EBP,EAX
MOV RDI,R12
MOV RSI,R15
MOV RDX,R13
MOV RCX,R14
MOV R8D,EBX
CALL 0x0017747b
MOV EBX,EAX
OR EBX,EBP
MOV RDI,R13
CALL 0x0017145e
MOV EAX,EBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
uint bfdec_add_si(int8 *param_1,int8 param_2,int8 param_3,int8 param_4,
int4 param_5)
{
uint uVar1;
uint uVar2;
int8 local_58;
int4 local_50;
int8 local_48;
int8 local_40;
int8 uStack_38;
local_58 = *param_1;
local_50 = 0;
local_48 = 0x8000000000000000;
local_40 = 0;
uStack_38 = 0;
uVar1 = bfdec_set_si(&local_58,param_3);
uVar2 = bfdec_add(param_1,param_2,&local_58,param_4,param_5);
bf_delete(&local_58);
return uVar2 | uVar1;
}
| |
43,518 | mysql_change_user | eloqsql/libmariadb/libmariadb/mariadb_lib.c | my_bool STDCALL mysql_change_user(MYSQL *mysql, const char *user,
const char *passwd, const char *db)
{
const MARIADB_CHARSET_INFO *s_cs= mysql->charset;
char *s_user= mysql->user,
*s_passwd= mysql->passwd,
*s_db= mysql->db;
int rc;
if (mysql->options.charset_name)
mysql->charset= mysql_find_charset_name(mysql->options.charset_name);
else
mysql->charset=mysql_find_charset_name(MARIADB_DEFAULT_CHARSET);
mysql->user= strdup(user ? user : "");
mysql->passwd= strdup(passwd ? passwd : "");
/* db will be set in run_plugin_auth */
mysql->db= 0;
rc= run_plugin_auth(mysql, 0, 0, 0, db);
/* COM_CHANGE_USER always releases prepared statements, so we need to invalidate them */
ma_invalidate_stmts(mysql, "mysql_change_user()");
if (rc==0)
{
free(s_user);
free(s_passwd);
free(s_db);
if (!mysql->db && db && !(mysql->db= strdup(db)))
{
SET_CLIENT_ERROR(mysql, CR_OUT_OF_MEMORY, SQLSTATE_UNKNOWN, 0);
rc= 1;
}
} else
{
free(mysql->user);
free(mysql->passwd);
free(mysql->db);
mysql->user= s_user;
mysql->passwd= s_passwd;
mysql->db= s_db;
mysql->charset= s_cs;
}
return(rc);
} | O3 | c | mysql_change_user:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x2f0(%rdi), %rax
movq %rax, -0x48(%rbp)
movq 0x2b8(%rdi), %rax
movq %rax, -0x30(%rbp)
movq 0x2c0(%rdi), %rax
movq %rax, -0x38(%rbp)
movq 0x2e8(%rdi), %rax
movq %rax, -0x40(%rbp)
movq 0x3f8(%rdi), %rax
testq %rax, %rax
leaq 0x1a736(%rip), %rdi # 0x34b31
cmovneq %rax, %rdi
callq 0x303ba
movq %rax, 0x2f0(%rbx)
testq %r12, %r12
leaq 0x1a1ca(%rip), %r13 # 0x345df
cmoveq %r13, %r12
movq %r12, %rdi
callq 0x137d0
movq %rax, 0x2b8(%rbx)
testq %r15, %r15
cmoveq %r13, %r15
movq %r15, %rdi
callq 0x137d0
movq %rax, 0x2c0(%rbx)
movq $0x0, 0x2e8(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r14, %r8
callq 0x2ddfd
movl %eax, %r15d
leaq 0x1a772(%rip), %rsi # 0x34bd6
movq %rbx, %rdi
callq 0x1a282
testl %r15d, %r15d
je 0x1a4d3
movq 0x2b8(%rbx), %rdi
callq 0x13570
movq 0x2c0(%rbx), %rdi
callq 0x13570
movq 0x2e8(%rbx), %rdi
callq 0x13570
movq -0x30(%rbp), %rax
movq %rax, 0x2b8(%rbx)
movq -0x38(%rbp), %rax
movq %rax, 0x2c0(%rbx)
movq -0x40(%rbp), %rax
movq %rax, 0x2e8(%rbx)
movq -0x48(%rbp), %rax
movq %rax, 0x2f0(%rbx)
movl %r15d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x13570
movq -0x38(%rbp), %rdi
callq 0x13570
movq -0x40(%rbp), %rdi
callq 0x13570
xorl %r15d, %r15d
testq %r14, %r14
je 0x1a4c1
cmpq $0x0, 0x2e8(%rbx)
jne 0x1a4c1
movq %r14, %rdi
callq 0x137d0
movq %rax, 0x2e8(%rbx)
testq %rax, %rax
je 0x1a519
xorl %r15d, %r15d
jmp 0x1a4c1
movl $0x7d8, 0x90(%rbx) # imm = 0x7D8
leaq 0x297(%rbx), %rdi
leaq 0x2e58f(%rip), %rax # 0x48ac0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13220
xorl %r14d, %r14d
movb %r14b, 0x29c(%rbx)
leaq 0x97(%rbx), %rdi
leaq 0x2e57a(%rip), %rax # 0x48ad0
movq 0x40(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x13220
movb %r14b, 0x296(%rbx)
movb $0x1, %r15b
jmp 0x1a4c1
| mysql_change_user:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r14, rcx
mov r15, rdx
mov r12, rsi
mov rbx, rdi
mov rax, [rdi+2F0h]
mov [rbp+var_48], rax
mov rax, [rdi+2B8h]
mov [rbp+var_30], rax
mov rax, [rdi+2C0h]
mov [rbp+var_38], rax
mov rax, [rdi+2E8h]
mov [rbp+var_40], rax
mov rax, [rdi+3F8h]
test rax, rax
lea rdi, aUtf8mb4; "utf8mb4"
cmovnz rdi, rax
call mysql_find_charset_name
mov [rbx+2F0h], rax
test r12, r12
lea r13, aExecuteTestWit+29h; ""
cmovz r12, r13
mov rdi, r12
call _strdup
mov [rbx+2B8h], rax
test r15, r15
cmovz r15, r13
mov rdi, r15
call _strdup
mov [rbx+2C0h], rax
mov qword ptr [rbx+2E8h], 0
mov rdi, rbx
xor esi, esi
xor edx, edx
xor ecx, ecx
mov r8, r14
call run_plugin_auth
mov r15d, eax
lea rsi, aMysqlChangeUse; "mysql_change_user()"
mov rdi, rbx
call ma_invalidate_stmts
test r15d, r15d
jz short loc_1A4D3
mov rdi, [rbx+2B8h]
call _free
mov rdi, [rbx+2C0h]
call _free
mov rdi, [rbx+2E8h]
call _free
mov rax, [rbp+var_30]
mov [rbx+2B8h], rax
mov rax, [rbp+var_38]
mov [rbx+2C0h], rax
mov rax, [rbp+var_40]
mov [rbx+2E8h], rax
mov rax, [rbp+var_48]
mov [rbx+2F0h], rax
loc_1A4C1:
mov eax, r15d
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1A4D3:
mov rdi, [rbp+var_30]
call _free
mov rdi, [rbp+var_38]
call _free
mov rdi, [rbp+var_40]
call _free
xor r15d, r15d
test r14, r14
jz short loc_1A4C1
cmp qword ptr [rbx+2E8h], 0
jnz short loc_1A4C1
mov rdi, r14
call _strdup
mov [rbx+2E8h], rax
test rax, rax
jz short loc_1A519
xor r15d, r15d
jmp short loc_1A4C1
loc_1A519:
mov dword ptr [rbx+90h], 7D8h
lea rdi, [rbx+297h]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
xor r14d, r14d
mov [rbx+29Ch], r14b
lea rdi, [rbx+97h]
lea rax, client_errors
mov rsi, [rax+40h]
mov edx, 1FFh
call _strncpy
mov [rbx+296h], r14b
mov r15b, 1
jmp loc_1A4C1
| long long mysql_change_user(long long a1, char *a2, char *a3, long long a4)
{
char *v6; // r12
const char *v8; // rax
const char *v9; // rdi
unsigned int v10; // r15d
long long v12; // rax
long long v13; // [rsp+8h] [rbp-48h]
long long v14; // [rsp+10h] [rbp-40h]
long long v15; // [rsp+18h] [rbp-38h]
long long v16; // [rsp+20h] [rbp-30h]
v6 = a2;
v13 = *(_QWORD *)(a1 + 752);
v16 = *(_QWORD *)(a1 + 696);
v15 = *(_QWORD *)(a1 + 704);
v14 = *(_QWORD *)(a1 + 744);
v8 = *(const char **)(a1 + 1016);
v9 = "utf8mb4";
if ( v8 )
v9 = v8;
*(_QWORD *)(a1 + 752) = mysql_find_charset_name(v9);
if ( !a2 )
v6 = "";
*(_QWORD *)(a1 + 696) = strdup(v6);
if ( !a3 )
a3 = "";
*(_QWORD *)(a1 + 704) = strdup(a3);
*(_QWORD *)(a1 + 744) = 0LL;
v10 = run_plugin_auth(a1, 0LL, 0LL, 0LL, a4);
ma_invalidate_stmts(a1, "mysql_change_user()");
if ( v10 )
{
free(*(_QWORD *)(a1 + 696));
free(*(_QWORD *)(a1 + 704));
free(*(_QWORD *)(a1 + 744));
*(_QWORD *)(a1 + 696) = v16;
*(_QWORD *)(a1 + 704) = v15;
*(_QWORD *)(a1 + 744) = v14;
*(_QWORD *)(a1 + 752) = v13;
}
else
{
free(v16);
free(v15);
free(v14);
v10 = 0;
if ( a4 && !*(_QWORD *)(a1 + 744) )
{
v12 = strdup(a4);
*(_QWORD *)(a1 + 744) = v12;
if ( v12 )
{
return 0;
}
else
{
*(_DWORD *)(a1 + 144) = 2008;
strncpy(a1 + 663, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 668) = 0;
strncpy(a1 + 151, client_errors[8], 511LL);
*(_BYTE *)(a1 + 662) = 0;
LOBYTE(v10) = 1;
}
}
}
return v10;
}
| mysql_change_user:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R14,RCX
MOV R15,RDX
MOV R12,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x2f0]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RDI + 0x2b8]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RDI + 0x2c0]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RDI + 0x2e8]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RDI + 0x3f8]
TEST RAX,RAX
LEA RDI,[0x134b31]
CMOVNZ RDI,RAX
CALL 0x001303ba
MOV qword ptr [RBX + 0x2f0],RAX
TEST R12,R12
LEA R13,[0x1345df]
CMOVZ R12,R13
MOV RDI,R12
CALL 0x001137d0
MOV qword ptr [RBX + 0x2b8],RAX
TEST R15,R15
CMOVZ R15,R13
MOV RDI,R15
CALL 0x001137d0
MOV qword ptr [RBX + 0x2c0],RAX
MOV qword ptr [RBX + 0x2e8],0x0
MOV RDI,RBX
XOR ESI,ESI
XOR EDX,EDX
XOR ECX,ECX
MOV R8,R14
CALL 0x0012ddfd
MOV R15D,EAX
LEA RSI,[0x134bd6]
MOV RDI,RBX
CALL 0x0011a282
TEST R15D,R15D
JZ 0x0011a4d3
MOV RDI,qword ptr [RBX + 0x2b8]
CALL 0x00113570
MOV RDI,qword ptr [RBX + 0x2c0]
CALL 0x00113570
MOV RDI,qword ptr [RBX + 0x2e8]
CALL 0x00113570
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBX + 0x2b8],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBX + 0x2c0],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBX + 0x2e8],RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBX + 0x2f0],RAX
LAB_0011a4c1:
MOV EAX,R15D
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0011a4d3:
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x00113570
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x00113570
MOV RDI,qword ptr [RBP + -0x40]
CALL 0x00113570
XOR R15D,R15D
TEST R14,R14
JZ 0x0011a4c1
CMP qword ptr [RBX + 0x2e8],0x0
JNZ 0x0011a4c1
MOV RDI,R14
CALL 0x001137d0
MOV qword ptr [RBX + 0x2e8],RAX
TEST RAX,RAX
JZ 0x0011a519
XOR R15D,R15D
JMP 0x0011a4c1
LAB_0011a519:
MOV dword ptr [RBX + 0x90],0x7d8
LEA RDI,[RBX + 0x297]
LEA RAX,[0x148ac0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113220
XOR R14D,R14D
MOV byte ptr [RBX + 0x29c],R14B
LEA RDI,[RBX + 0x97]
LEA RAX,[0x148ad0]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x1ff
CALL 0x00113220
MOV byte ptr [RBX + 0x296],R14B
MOV R15B,0x1
JMP 0x0011a4c1
|
int mysql_change_user(long param_1,char *param_2,char *param_3,char *param_4)
{
int8 uVar1;
void *__ptr;
void *__ptr_00;
void *__ptr_01;
int iVar2;
int8 uVar3;
char *pcVar4;
uVar1 = *(int8 *)(param_1 + 0x2f0);
__ptr = *(void **)(param_1 + 0x2b8);
__ptr_00 = *(void **)(param_1 + 0x2c0);
__ptr_01 = *(void **)(param_1 + 0x2e8);
pcVar4 = "utf8mb4";
if (*(char **)(param_1 + 0x3f8) != (char *)0x0) {
pcVar4 = *(char **)(param_1 + 0x3f8);
}
uVar3 = mysql_find_charset_name(pcVar4);
*(int8 *)(param_1 + 0x2f0) = uVar3;
if (param_2 == (char *)0x0) {
param_2 = "";
}
pcVar4 = strdup(param_2);
*(char **)(param_1 + 0x2b8) = pcVar4;
if (param_3 == (char *)0x0) {
param_3 = "";
}
pcVar4 = strdup(param_3);
*(char **)(param_1 + 0x2c0) = pcVar4;
*(int8 *)(param_1 + 0x2e8) = 0;
iVar2 = run_plugin_auth(param_1,0,0,0,param_4);
ma_invalidate_stmts(param_1,"mysql_change_user()");
if (iVar2 == 0) {
free(__ptr);
free(__ptr_00);
free(__ptr_01);
iVar2 = 0;
if ((param_4 != (char *)0x0) && (*(long *)(param_1 + 0x2e8) == 0)) {
pcVar4 = strdup(param_4);
*(char **)(param_1 + 0x2e8) = pcVar4;
if (pcVar4 == (char *)0x0) {
*(int4 *)(param_1 + 0x90) = 0x7d8;
strncpy((char *)(param_1 + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x29c) = 0;
strncpy((char *)(param_1 + 0x97),PTR_s_Client_run_out_of_memory_00148b10,0x1ff);
*(int1 *)(param_1 + 0x296) = 0;
iVar2 = 1;
}
else {
iVar2 = 0;
}
}
}
else {
free(*(void **)(param_1 + 0x2b8));
free(*(void **)(param_1 + 0x2c0));
free(*(void **)(param_1 + 0x2e8));
*(void **)(param_1 + 0x2b8) = __ptr;
*(void **)(param_1 + 0x2c0) = __ptr_00;
*(void **)(param_1 + 0x2e8) = __ptr_01;
*(int8 *)(param_1 + 0x2f0) = uVar1;
}
return iVar2;
}
| |
43,519 | crc32(unsigned char const*, unsigned long, unsigned int*) | msxemulator/build_O3/_deps/picotool-src/bintool/bintool.cpp | void crc32(const uint8_t *data, size_t len, uint32_t* cs_out) {
uint8_t rev_data[252] = {};
for (size_t i=0; i < sizeof(rev_data); i++) {
rev_data[i] = rev_8(data[i]);
}
uint32_t crc = crc32_byte(rev_data, sizeof(rev_data));
crc = rev_32(crc);
*cs_out = crc;
} | O3 | cpp | crc32(unsigned char const*, unsigned long, unsigned int*):
pushq %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp # imm = 0x100
movq %rdx, %rbx
movq %rdi, %r14
movq %rsp, %rdi
xorl %r15d, %r15d
movl $0xfc, %edx
xorl %esi, %esi
callq 0xf2b0
movb (%r14,%r15), %al
rolb $0x4, %al
movl %eax, %ecx
andb $0x33, %cl
shlb $0x2, %cl
shrb $0x2, %al
andb $0x33, %al
orb %cl, %al
movl %eax, %ecx
andb $0x55, %cl
addb %cl, %cl
shrb %al
andb $0x55, %al
orb %cl, %al
movb %al, (%rsp,%r15)
incq %r15
cmpq $0xfc, %r15
jne 0x73795
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
xorl %ecx, %ecx
leaq 0x71cba(%rip), %rdx # 0xe5490
movzbl %al, %esi
movzbl (%rsp,%rcx), %edi
xorl %esi, %edi
shrl $0x8, %eax
xorl (%rdx,%rdi,4), %eax
incq %rcx
cmpl $0xfc, %ecx
jne 0x737d6
bswapl %eax
movl %eax, %ecx
shrl $0x4, %ecx
movl $0xf0f0f0f, %edx # imm = 0xF0F0F0F
andl %edx, %ecx
andl %edx, %eax
shll $0x4, %eax
orl %ecx, %eax
movl $0x33333333, %ecx # imm = 0x33333333
movl %eax, %edx
andl %ecx, %edx
shrl $0x2, %eax
andl %ecx, %eax
leal (%rax,%rdx,4), %eax
movl $0x55555555, %ecx # imm = 0x55555555
movl %eax, %edx
andl %ecx, %edx
shrl %eax
andl %ecx, %eax
leal (%rax,%rdx,2), %eax
movl %eax, (%rbx)
addq $0x100, %rsp # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
| _Z5crc32PKhmPj:
push r15
push r14
push rbx
sub rsp, 100h
mov rbx, rdx
mov r14, rdi
mov rdi, rsp
xor r15d, r15d
mov edx, 0FCh
xor esi, esi
call _memset
loc_73795:
mov al, [r14+r15]
rol al, 4
mov ecx, eax
and cl, 33h
shl cl, 2
shr al, 2
and al, 33h
or al, cl
mov ecx, eax
and cl, 55h
add cl, cl
shr al, 1
and al, 55h
or al, cl
mov [rsp+r15+118h+var_118], al
inc r15
cmp r15, 0FCh
jnz short loc_73795
mov eax, 0FFFFFFFFh
xor ecx, ecx
lea rdx, poly8_lookup
loc_737D6:
movzx esi, al
movzx edi, [rsp+rcx+118h+var_118]
xor edi, esi
shr eax, 8
xor eax, [rdx+rdi*4]
inc rcx
cmp ecx, 0FCh
jnz short loc_737D6
bswap eax
mov ecx, eax
shr ecx, 4
mov edx, 0F0F0F0Fh
and ecx, edx
and eax, edx
shl eax, 4
or eax, ecx
mov ecx, 33333333h
mov edx, eax
and edx, ecx
shr eax, 2
and eax, ecx
lea eax, [rax+rdx*4]
mov ecx, 55555555h
mov edx, eax
and edx, ecx
shr eax, 1
and eax, ecx
lea eax, [rax+rdx*2]
mov [rbx], eax
add rsp, 100h
pop rbx
pop r14
pop r15
retn
| long long crc32(const unsigned __int8 *a1, unsigned long long a2, unsigned int *a3)
{
long long v4; // r15
unsigned __int8 v5; // al
unsigned __int8 v6; // al
unsigned int v7; // eax
long long v8; // rcx
unsigned __int32 v9; // eax
unsigned int v10; // eax
unsigned int v11; // eax
long long result; // rax
_BYTE v13[280]; // [rsp+0h] [rbp-118h] BYREF
v4 = 0LL;
memset(v13, 0LL, 252LL);
do
{
v5 = __ROL1__(a1[v4], 4);
v6 = (4 * (v5 & 0x33)) | (v5 >> 2) & 0x33;
v13[v4++] = (2 * (v6 & 0x55)) | (v6 >> 1) & 0x55;
}
while ( v4 != 252 );
v7 = -1;
v8 = 0LL;
do
v7 = poly8_lookup[(unsigned __int8)v7 ^ (unsigned __int8)v13[v8++]] ^ (v7 >> 8);
while ( (_DWORD)v8 != 252 );
v9 = _byteswap_ulong(v7);
v10 = (v9 >> 4) & 0xF0F0F0F | (16 * (v9 & 0xF0F0F0F));
v11 = ((v10 >> 2) & 0x33333333) + 4 * (v10 & 0x33333333);
result = ((v11 >> 1) & 0x55555555) + 2 * (v11 & 0x55555555);
*a3 = result;
return result;
}
| crc32:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x100
MOV RBX,RDX
MOV R14,RDI
MOV RDI,RSP
XOR R15D,R15D
MOV EDX,0xfc
XOR ESI,ESI
CALL 0x0010f2b0
LAB_00173795:
MOV AL,byte ptr [R14 + R15*0x1]
ROL AL,0x4
MOV ECX,EAX
AND CL,0x33
SHL CL,0x2
SHR AL,0x2
AND AL,0x33
OR AL,CL
MOV ECX,EAX
AND CL,0x55
ADD CL,CL
SHR AL,0x1
AND AL,0x55
OR AL,CL
MOV byte ptr [RSP + R15*0x1],AL
INC R15
CMP R15,0xfc
JNZ 0x00173795
MOV EAX,0xffffffff
XOR ECX,ECX
LEA RDX,[0x1e5490]
LAB_001737d6:
MOVZX ESI,AL
MOVZX EDI,byte ptr [RSP + RCX*0x1]
XOR EDI,ESI
SHR EAX,0x8
XOR EAX,dword ptr [RDX + RDI*0x4]
INC RCX
CMP ECX,0xfc
JNZ 0x001737d6
BSWAP EAX
MOV ECX,EAX
SHR ECX,0x4
MOV EDX,0xf0f0f0f
AND ECX,EDX
AND EAX,EDX
SHL EAX,0x4
OR EAX,ECX
MOV ECX,0x33333333
MOV EDX,EAX
AND EDX,ECX
SHR EAX,0x2
AND EAX,ECX
LEA EAX,[RAX + RDX*0x4]
MOV ECX,0x55555555
MOV EDX,EAX
AND EDX,ECX
SHR EAX,0x1
AND EAX,ECX
LEA EAX,[RAX + RDX*0x2]
MOV dword ptr [RBX],EAX
ADD RSP,0x100
POP RBX
POP R14
POP R15
RET
|
/* crc32(unsigned char const*, unsigned long, unsigned int*) */
void crc32(uchar *param_1,ulong param_2,uint *param_3)
{
byte *pbVar1;
byte bVar2;
uint uVar3;
uint uVar4;
long lVar5;
byte local_118 [256];
lVar5 = 0;
memset(local_118,0,0xfc);
do {
bVar2 = param_1[lVar5] << 4 | param_1[lVar5] >> 4;
bVar2 = bVar2 >> 2 & 0x33 | (bVar2 & 0x33) << 2;
local_118[lVar5] = bVar2 >> 1 & 0x55 | (bVar2 & 0x55) * '\x02';
lVar5 = lVar5 + 1;
} while (lVar5 != 0xfc);
uVar3 = 0xffffffff;
lVar5 = 0;
do {
uVar4 = uVar3 & 0xff;
pbVar1 = local_118 + lVar5;
uVar3 = uVar3 >> 8 ^ *(uint *)(poly8_lookup + (ulong)(*pbVar1 ^ uVar4) * 4);
lVar5 = lVar5 + 1;
} while ((int)lVar5 != 0xfc);
uVar3 = *(uint *)(poly8_lookup + (ulong)(*pbVar1 ^ uVar4) * 4) >> 0x18 | (uVar3 & 0xff0000) >> 8 |
(uVar3 & 0xff00) << 8 | uVar3 << 0x18;
uVar3 = (uVar3 & 0xf0f0f0f) << 4 | uVar3 >> 4 & 0xf0f0f0f;
uVar3 = (uVar3 >> 2 & 0x33333333) + (uVar3 & 0x33333333) * 4;
*param_3 = (uVar3 >> 1 & 0x55555555) + (uVar3 & 0x55555555) * 2;
return;
}
| |
43,520 | 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);
});
} | O2 | 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
andq $0x0, 0x8(%rax)
movq %rsi, (%rax)
leaq 0x174(%rip), %rcx # 0x8ccc8
movq %rcx, 0x18(%rax)
leaq 0x20d(%rip), %rcx # 0x8cd6c
movq %rcx, 0x10(%rax)
leaq 0xe(%rsp), %rdx
andw $0x0, (%rdx)
movq %rax, %rsi
callq 0x8cb9c
leaq 0x10(%rsp), %rdi
callq 0x4970c
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4970c
movq %rbx, %rdi
callq 0x24030
| _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]
and 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]
and 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&)
lea rdi, [rsp+38h+var_28]; this
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
mov rax, rbx
add rsp, 30h
pop rbx
retn
mov rbx, rax
lea rdi, [rsp+arg_8]; this
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
mov rdi, rbx
call __Unwind_Resume
| json_schema_to_grammar:
PUSH RBX
SUB RSP,0x30
MOV RBX,RDI
LEA RAX,[RSP + 0x10]
AND qword ptr [RAX + 0x8],0x0
MOV qword ptr [RAX],RSI
LEA RCX,[0x18ccc8]
MOV qword ptr [RAX + 0x18],RCX
LEA RCX,[0x18cd6c]
MOV qword ptr [RAX + 0x10],RCX
LEA RDX,[RSP + 0xe]
AND word ptr [RDX],0x0
LAB_0018cb6c:
MOV RSI,RAX
CALL 0x0018cb9c
LAB_0018cb74:
LEA RDI,[RSP + 0x10]
CALL 0x0014970c
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 0018cb6c to 0018cb73 has its CatchHandler @ 0018cb87 */
build_grammar_abi_cxx11_(param_1,(common_grammar_options *)&local_28);
std::_Function_base::~_Function_base((_Function_base *)&local_28);
return param_1;
}
| ||
43,521 | my_charpos_utf16 | eloqsql/strings/ctype-ucs2.c | static size_t
my_charpos_utf16(CHARSET_INFO *cs,
const char *b, const char *e, size_t pos)
{
const char *b0= b;
uint charlen;
for ( ; pos; b+= charlen, pos--)
{
if (!(charlen= my_ismbchar(cs, b, e)))
return (e + 2 - b0); /* Error, return pos outside the string */
}
return (size_t) (pos ? (e + 2 - b0) : (b - b0));
} | O3 | c | my_charpos_utf16:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rsi, %r12
testq %rcx, %rcx
je 0x4eedd
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %r13
movq %rbx, %r12
movq 0xb8(%r13), %rax
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq *0xc0(%rax)
cmpl $0x1, %eax
jle 0x4eed6
movl %eax, %eax
addq %rax, %r12
decq %r15
jne 0x4eeaf
jmp 0x4eedd
addq $0x2, %r14
movq %r14, %r12
subq %rbx, %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_charpos_utf16:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rsi
mov r12, rsi
test rcx, rcx
jz short loc_4EEDD
mov r15, rcx
mov r14, rdx
mov r13, rdi
mov r12, rbx
loc_4EEAF:
mov rax, [r13+0B8h]
mov rdi, r13
mov rsi, r12
mov rdx, r14
call qword ptr [rax+0C0h]
cmp eax, 1
jle short loc_4EED6
mov eax, eax
add r12, rax
dec r15
jnz short loc_4EEAF
jmp short loc_4EEDD
loc_4EED6:
add r14, 2
mov r12, r14
loc_4EEDD:
sub r12, rbx
mov rax, r12
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_charpos_utf16(long long a1, long long a2, long long a3, long long a4)
{
long long v4; // r12
long long v5; // r15
int v7; // eax
v4 = a2;
if ( a4 )
{
v5 = a4;
v4 = a2;
while ( 1 )
{
v7 = (*(long long ( **)(long long, long long, long long))(*(_QWORD *)(a1 + 184) + 192LL))(a1, v4, a3);
if ( v7 <= 1 )
break;
v4 += (unsigned int)v7;
if ( !--v5 )
return v4 - a2;
}
v4 = a3 + 2;
}
return v4 - a2;
}
| my_charpos_utf16:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R12,RSI
TEST RCX,RCX
JZ 0x0014eedd
MOV R15,RCX
MOV R14,RDX
MOV R13,RDI
MOV R12,RBX
LAB_0014eeaf:
MOV RAX,qword ptr [R13 + 0xb8]
MOV RDI,R13
MOV RSI,R12
MOV RDX,R14
CALL qword ptr [RAX + 0xc0]
CMP EAX,0x1
JLE 0x0014eed6
MOV EAX,EAX
ADD R12,RAX
DEC R15
JNZ 0x0014eeaf
JMP 0x0014eedd
LAB_0014eed6:
ADD R14,0x2
MOV R12,R14
LAB_0014eedd:
SUB R12,RBX
MOV RAX,R12
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long my_charpos_utf16(long param_1,long param_2,long param_3,long param_4)
{
uint uVar1;
long lVar2;
lVar2 = param_2;
if (param_4 != 0) {
do {
uVar1 = (**(code **)(*(long *)(param_1 + 0xb8) + 0xc0))(param_1,lVar2,param_3);
if ((int)uVar1 < 2) {
lVar2 = param_3 + 2;
break;
}
lVar2 = lVar2 + (ulong)uVar1;
param_4 = param_4 + -1;
} while (param_4 != 0);
}
return lVar2 - param_2;
}
| |
43,522 | common_sampler_clone(common_sampler*) | monkey531[P]llama/common/sampling.cpp | struct common_sampler * common_sampler_clone(common_sampler * gsmpl) {
return new common_sampler {
/* .params = */ gsmpl->params,
/* .grmr = */ llama_sampler_clone(gsmpl->grmr),
/* .chain = */ llama_sampler_clone(gsmpl->chain),
/* .prev = */ gsmpl->prev,
/* .cur = */ gsmpl->cur,
/* .cur_p = */ gsmpl->cur_p,
};
} | O2 | cpp | common_sampler_clone(common_sampler*):
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x1b8, %edi # imm = 0x1B8
callq 0x24900
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2b9ee
movq 0x138(%r14), %rdi
callq 0x24650
movq %rax, 0x138(%rbx)
movq 0x140(%r14), %rdi
callq 0x24650
movq %rax, 0x140(%rbx)
movl $0x148, %esi # imm = 0x148
leaq (%rbx,%rsi), %rdi
addq %r14, %rsi
callq 0x9cbdc
movl $0x180, %esi # imm = 0x180
leaq (%rbx,%rsi), %rdi
addq %r14, %rsi
callq 0x9cbf8
movups 0x198(%r14), %xmm0
movups 0x1a8(%r14), %xmm1
movups %xmm1, 0x1a8(%rbx)
movups %xmm0, 0x198(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
addq $0x168, %rdi # imm = 0x168
callq 0x2a66a
jmp 0x9be56
movq %rax, %r14
jmp 0x9be5e
movq %rax, %r14
movq %rbx, %rdi
callq 0x2ab4a
movl $0x1b8, %esi # imm = 0x1B8
movq %rbx, %rdi
callq 0x24920
movq %r14, %rdi
callq 0x25020
| _Z20common_sampler_cloneP14common_sampler:
push r14
push rbx
push rax
mov r14, rdi
mov edi, 1B8h; unsigned __int64
call __Znwm; operator new(ulong)
mov rbx, rax
mov rdi, rax; this
mov rsi, r14; common_params_sampling *
call _ZN22common_params_samplingC2ERKS_; common_params_sampling::common_params_sampling(common_params_sampling const&)
mov rdi, [r14+138h]
call _llama_sampler_clone
mov [rbx+138h], rax
mov rdi, [r14+140h]
call _llama_sampler_clone
mov [rbx+140h], rax
mov esi, 148h
lea rdi, [rbx+rsi]
add rsi, r14
call _ZN11ring_bufferIiEC2ERKS0_; ring_buffer<int>::ring_buffer(ring_buffer<int> const&)
mov esi, 180h
lea rdi, [rbx+rsi]
add rsi, r14
call _ZNSt6vectorI16llama_token_dataSaIS0_EEC2ERKS2_; std::vector<llama_token_data>::vector(std::vector<llama_token_data> const&)
movups xmm0, xmmword ptr [r14+198h]
movups xmm1, xmmword ptr [r14+1A8h]
movups xmmword ptr [rbx+1A8h], xmm1
movups xmmword ptr [rbx+198h], xmm0
mov rax, rbx
add rsp, 8
pop rbx
pop r14
retn
mov r14, rax
mov rdi, rbx
add rdi, 168h
call _ZNSt12_Vector_baseIiSaIiEED2Ev; std::_Vector_base<int>::~_Vector_base()
jmp short loc_9BE56
mov r14, rax
jmp short loc_9BE5E
mov r14, rax
loc_9BE56:
mov rdi, rbx; this
call _ZN22common_params_samplingD2Ev; common_params_sampling::~common_params_sampling()
loc_9BE5E:
mov esi, 1B8h; unsigned __int64
mov rdi, rbx; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rdi, r14
call __Unwind_Resume
| long long common_sampler_clone(common_sampler *a1)
{
long long v1; // rbx
__int128 v2; // xmm0
v1 = operator new(0x1B8uLL);
common_params_sampling::common_params_sampling((common_params_sampling *)v1, a1);
*(_QWORD *)(v1 + 312) = llama_sampler_clone(*((_QWORD *)a1 + 39));
*(_QWORD *)(v1 + 320) = llama_sampler_clone(*((_QWORD *)a1 + 40));
ring_buffer<int>::ring_buffer(v1 + 328, (char *)a1 + 328);
std::vector<llama_token_data>::vector(v1 + 384, (char *)a1 + 384);
v2 = *(_OWORD *)((char *)a1 + 408);
*(_OWORD *)(v1 + 424) = *(_OWORD *)((char *)a1 + 424);
*(_OWORD *)(v1 + 408) = v2;
return v1;
}
| common_sampler_clone:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RDI
MOV EDI,0x1b8
CALL 0x00124900
MOV RBX,RAX
LAB_0019bdbe:
MOV RDI,RAX
MOV RSI,R14
CALL 0x0012b9ee
MOV RDI,qword ptr [R14 + 0x138]
LAB_0019bdd0:
CALL 0x00124650
MOV qword ptr [RBX + 0x138],RAX
MOV RDI,qword ptr [R14 + 0x140]
CALL 0x00124650
MOV qword ptr [RBX + 0x140],RAX
MOV ESI,0x148
LEA RDI,[RBX + RSI*0x1]
ADD RSI,R14
CALL 0x0019cbdc
MOV ESI,0x180
LEA RDI,[RBX + RSI*0x1]
ADD RSI,R14
LAB_0019be0c:
CALL 0x0019cbf8
LAB_0019be11:
MOVUPS XMM0,xmmword ptr [R14 + 0x198]
MOVUPS XMM1,xmmword ptr [R14 + 0x1a8]
MOVUPS xmmword ptr [RBX + 0x1a8],XMM1
MOVUPS xmmword ptr [RBX + 0x198],XMM0
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* common_sampler_clone(common_sampler*) */
common_params_sampling * common_sampler_clone(common_sampler *param_1)
{
int8 uVar1;
int8 uVar2;
common_params_sampling *this;
int8 uVar3;
this = (common_params_sampling *)operator_new(0x1b8);
/* try { // try from 0019bdbe to 0019bdc8 has its CatchHandler @ 0019be4e */
common_params_sampling::common_params_sampling(this,(common_params_sampling *)param_1);
/* try { // try from 0019bdd0 to 0019bdff has its CatchHandler @ 0019be53 */
uVar3 = llama_sampler_clone(*(int8 *)(param_1 + 0x138));
*(int8 *)(this + 0x138) = uVar3;
uVar3 = llama_sampler_clone(*(int8 *)(param_1 + 0x140));
*(int8 *)(this + 0x140) = uVar3;
ring_buffer<int>::ring_buffer((ring_buffer<int> *)(this + 0x148),(ring_buffer *)(param_1 + 0x148))
;
/* try { // try from 0019be0c to 0019be10 has its CatchHandler @ 0019be3a */
std::vector<llama_token_data,std::allocator<llama_token_data>>::vector
((vector<llama_token_data,std::allocator<llama_token_data>> *)(this + 0x180),
(vector *)(param_1 + 0x180));
uVar3 = *(int8 *)(param_1 + 0x198);
uVar1 = *(int8 *)(param_1 + 0x1a0);
uVar2 = *(int8 *)(param_1 + 0x1b0);
*(int8 *)(this + 0x1a8) = *(int8 *)(param_1 + 0x1a8);
*(int8 *)(this + 0x1b0) = uVar2;
*(int8 *)(this + 0x198) = uVar3;
*(int8 *)(this + 0x1a0) = uVar1;
return this;
}
| |
43,523 | ggml_cross_entropy_loss | ngxson[P]ggml-easy/ggml/src/ggml.c | struct ggml_tensor * ggml_cross_entropy_loss(
struct ggml_context * ctx,
struct ggml_tensor * a,
struct ggml_tensor * b) {
GGML_ASSERT(ggml_are_same_shape(a, b));
struct ggml_tensor * result = ggml_new_tensor_1d(ctx, a->type, 1);
result->op = GGML_OP_CROSS_ENTROPY_LOSS;
result->src[0] = a;
result->src[1] = b;
return result;
} | O2 | c | ggml_cross_entropy_loss:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x1e740
testb %al, %al
je 0x255ea
movl (%r14), %esi
pushq $0x1
popq %rdx
movq %r15, %rdi
callq 0x1ef40
movl $0x4f, 0x50(%rax)
movq %r14, 0x98(%rax)
movq %rbx, 0xa0(%rax)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x25f92(%rip), %rdi # 0x4b583
leaq 0x25fd6(%rip), %rdx # 0x4b5ce
leaq 0x2611e(%rip), %rcx # 0x4b71d
movl $0x13eb, %esi # imm = 0x13EB
xorl %eax, %eax
callq 0x1e770
| ggml_cross_entropy_loss:
push r15
push r14
push rbx
mov rbx, rdx
mov r14, rsi
mov r15, rdi
mov rdi, rsi
mov rsi, rdx
call _ggml_are_same_shape
test al, al
jz short loc_255EA
mov esi, [r14]
push 1
pop rdx
mov rdi, r15
call _ggml_new_tensor_1d
mov dword ptr [rax+50h], 4Fh ; 'O'
mov [rax+98h], r14
mov [rax+0A0h], rbx
pop rbx
pop r14
pop r15
retn
loc_255EA:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlAreSameSha_0; "ggml_are_same_shape(a, b)"
mov esi, 13EBh
xor eax, eax
call _ggml_abort
| long long ggml_cross_entropy_loss(
long long a1,
_QWORD *a2,
_QWORD *a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11)
{
long long v12; // r8
long long v13; // r9
__m128 v14; // xmm4
__m128 v15; // xmm5
long long result; // rax
char v17; // [rsp+0h] [rbp-18h]
if ( !ggml_are_same_shape(a2, a3) )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml.c",
5099,
(long long)"GGML_ASSERT(%s) failed",
(long long)"ggml_are_same_shape(a, b)",
v12,
v13,
a4,
a5,
a6,
a7,
v14,
v15,
a10,
a11,
v17);
result = ggml_new_tensor_1d(a1, *(unsigned int *)a2, 1LL);
*(_DWORD *)(result + 80) = 79;
*(_QWORD *)(result + 152) = a2;
*(_QWORD *)(result + 160) = a3;
return result;
}
| ggml_cross_entropy_loss:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
MOV RDI,RSI
MOV RSI,RDX
CALL 0x0011e740
TEST AL,AL
JZ 0x001255ea
MOV ESI,dword ptr [R14]
PUSH 0x1
POP RDX
MOV RDI,R15
CALL 0x0011ef40
MOV dword ptr [RAX + 0x50],0x4f
MOV qword ptr [RAX + 0x98],R14
MOV qword ptr [RAX + 0xa0],RBX
POP RBX
POP R14
POP R15
RET
LAB_001255ea:
LEA RDI,[0x14b583]
LEA RDX,[0x14b5ce]
LEA RCX,[0x14b71d]
MOV ESI,0x13eb
XOR EAX,EAX
CALL 0x0011e770
|
void ggml_cross_entropy_loss(int8 param_1,int4 *param_2,int8 param_3)
{
char cVar1;
long lVar2;
cVar1 = ggml_are_same_shape(param_2,param_3);
if (cVar1 != '\0') {
lVar2 = ggml_new_tensor_1d(param_1,*param_2,1);
*(int4 *)(lVar2 + 0x50) = 0x4f;
*(int4 **)(lVar2 + 0x98) = param_2;
*(int8 *)(lVar2 + 0xa0) = param_3;
return;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml.c",0x13eb,
"GGML_ASSERT(%s) failed","ggml_are_same_shape(a, b)");
}
| |
43,524 | nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::insert(std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>> const&) | monkey531[P]llama/common/json.hpp | std::pair<iterator, bool> insert( const value_type& value )
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, value.first))
{
return {it, false};
}
}
Container::push_back(value);
return {--this->end(), true};
} | O2 | cpp | nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::insert(std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>> const&):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rbx
cmpq 0x8(%r14), %rbx
je 0x8bf57
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3def4
testb %al, %al
jne 0x8bf6e
addq $0x30, %rbx
jmp 0x8bf3c
movq %r14, %rdi
movq %r15, %rsi
callq 0x8bf7a
movq 0x8(%r14), %rbx
addq $-0x30, %rbx
movb $0x1, %dl
jmp 0x8bf70
xorl %edx, %edx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
| _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE6insertERKSI_:
push r15
push r14
push rbx
mov r15, rsi
mov r14, rdi
mov rbx, [rdi]
loc_8BF3C:
cmp rbx, [r14+8]
jz short loc_8BF57
mov rdi, rbx
mov rsi, r15
call _ZSteqIcEN9__gnu_cxx11__enable_ifIXsr9__is_charIT_EE7__valueEbE6__typeERKNSt7__cxx1112basic_stringIS2_St11char_traitsIS2_ESaIS2_EEESC_
test al, al
jnz short loc_8BF6E
add rbx, 30h ; '0'
jmp short loc_8BF3C
loc_8BF57:
mov rdi, r14
mov rsi, r15
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE9push_backERKSG_; std::vector<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>>>::push_back(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>> const&)
mov rbx, [r14+8]
add rbx, 0FFFFFFFFFFFFFFD0h
mov dl, 1
jmp short loc_8BF70
loc_8BF6E:
xor edx, edx
loc_8BF70:
mov rax, rbx
pop rbx
pop r14
pop r15
retn
| long long 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>>>>::insert(
_QWORD **a1,
_QWORD *a2)
{
_QWORD *i; // rbx
for ( i = *a1; i != a1[1]; i += 6 )
{
if ( std::operator==<char>(i, a2) )
return (long long)i;
}
std::vector<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>>>::push_back(
a1,
a2);
return (long long)(a1[1] - 6);
}
| insert:
PUSH R15
PUSH R14
PUSH RBX
MOV R15,RSI
MOV R14,RDI
MOV RBX,qword ptr [RDI]
LAB_0018bf3c:
CMP RBX,qword ptr [R14 + 0x8]
JZ 0x0018bf57
MOV RDI,RBX
MOV RSI,R15
CALL 0x0013def4
TEST AL,AL
JNZ 0x0018bf6e
ADD RBX,0x30
JMP 0x0018bf3c
LAB_0018bf57:
MOV RDI,R14
MOV RSI,R15
CALL 0x0018bf7a
MOV RBX,qword ptr [R14 + 0x8]
ADD RBX,-0x30
MOV DL,0x1
JMP 0x0018bf70
LAB_0018bf6e:
XOR EDX,EDX
LAB_0018bf70:
MOV RAX,RBX
POP RBX
POP R14
POP R15
RET
|
/* nlohmann::json_abi_v3_11_3::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> > > >::insert(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> > const&) */
int1 [16] __thiscall
nlohmann::json_abi_v3_11_3::
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>>>>
::insert(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>>>>
*this,pair *param_1)
{
char cVar1;
int8 extraout_RDX;
int8 uVar2;
string *psVar3;
int1 auVar4 [16];
psVar3 = *(string **)this;
do {
if (psVar3 == *(string **)(this + 8)) {
std::
vector<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>>,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>>>>
::push_back((vector<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>>,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>>>>
*)this,param_1);
psVar3 = (string *)(*(long *)(this + 8) + -0x30);
uVar2 = CONCAT71((int7)((ulong)extraout_RDX >> 8),1);
LAB_0018bf70:
auVar4._8_8_ = uVar2;
auVar4._0_8_ = psVar3;
return auVar4;
}
cVar1 = std::operator==(psVar3,(string *)param_1);
if (cVar1 != '\0') {
uVar2 = 0;
goto LAB_0018bf70;
}
psVar3 = psVar3 + 0x30;
} while( true );
}
| |
43,525 | minja::Parser::parseString[abi:cxx11]()::'lambda'(char)::operator()[abi:cxx11](char) const | monkey531[P]llama/common/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 0x8aed3
movl %edx, %ebp
cmpb %bpl, (%rax)
jne 0x8aed3
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x1(%rax), %rdx
movq %rdx, 0x20(%r12)
cmpq %rcx, %rdx
je 0x8aeec
xorl %edx, %edx
movl $0x1a29, %r13d # imm = 0x1A29
leaq 0x8(%rsp), %r14
movb 0x1(%rax), %cl
testb $0x1, %dl
je 0x8ae85
movsbl %cl, %eax
addl $-0x5c, %eax
rorl %eax
cmpl $0xc, %eax
ja 0x8ae91
btl %eax, %r13d
jae 0x8ae91
movl %eax, %eax
leaq 0x62774(%rip), %rcx # 0xed5f4
movb (%rax,%rcx), %cl
jmp 0x8ae91
movb $0x1, %dl
cmpb $0x5c, %cl
je 0x8ae9e
cmpb %bpl, %cl
je 0x8aef0
movsbl %cl, %esi
movq %r14, %rdi
callq 0x1a730
xorl %edx, %edx
movq 0x20(%r12), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%r12)
cmpq 0x18(%r12), %rcx
jne 0x8ae5c
movq 0x8(%rsp), %rdi
movq $0x0, (%rbx)
cmpq %r15, %rdi
je 0x8aeda
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a890
jmp 0x8aeda
movq $0x0, (%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x8af35
addq $0x2, %rax
movq %rax, 0x20(%r12)
movl $0x20, %edi
callq 0x1a870
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x8(%rsp), %rdx
cmpq %r15, %rdx
je 0x8af25
movq %rdx, (%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rax)
jmp 0x8af2c
movups (%r15), %xmm0
movups %xmm0, (%rcx)
movq 0x10(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rbx)
jmp 0x8aeda
jmp 0x8af3c
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x8af56
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a890
movq %rbx, %rdi
callq 0x1af20
| _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_8AED3
mov ebp, edx
cmp [rax], bpl
jnz loc_8AED3
lea r15, [rsp+58h+var_40]
mov [r15-10h], r15
mov qword ptr [r15-8], 0
mov byte ptr [r15], 0
lea rdx, [rax+1]
mov [r12+20h], rdx
cmp rdx, rcx
jz loc_8AEEC
xor edx, edx
mov r13d, 1A29h
lea r14, [rsp+58h+var_50]
loc_8AE5C:
mov cl, [rax+1]
test dl, 1
jz short loc_8AE85
movsx eax, cl
add eax, 0FFFFFFA4h
ror eax, 1
cmp eax, 0Ch
ja short loc_8AE91
bt r13d, eax
jnb short loc_8AE91
mov eax, eax
lea rcx, unk_ED5F4
mov cl, [rax+rcx]
jmp short loc_8AE91
loc_8AE85:
mov dl, 1
cmp cl, 5Ch ; '\'
jz short loc_8AE9E
cmp cl, bpl
jz short loc_8AEF0
loc_8AE91:
movsx esi, cl
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
xor edx, edx
loc_8AE9E:
mov rax, [r12+20h]
lea rcx, [rax+1]
mov [r12+20h], rcx
cmp rcx, [r12+18h]
jnz short loc_8AE5C
mov rdi, [rsp+58h+var_50]; void *
mov qword ptr [rbx], 0
cmp rdi, r15
jz short loc_8AEDA
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_8AEDA
loc_8AED3:
mov qword ptr [rbx], 0
loc_8AEDA:
mov rax, rbx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_8AEEC:
xor eax, eax
jmp short loc_8AF35
loc_8AEF0:
add rax, 2
mov [r12+20h], rax
mov edi, 20h ; ' '; unsigned __int64
call __Znwm; operator new(ulong)
mov rcx, rax
add rcx, 10h
mov [rax], rcx
mov rdx, [rsp+58h+var_50]
cmp rdx, r15
jz short loc_8AF25
mov [rax], rdx
mov rcx, [rsp+58h+var_40]
mov [rax+10h], rcx
jmp short loc_8AF2C
loc_8AF25:
movups xmm0, xmmword ptr [r15]
movups xmmword ptr [rcx], xmm0
loc_8AF2C:
mov rcx, [rsp+58h+var_48]
mov [rax+8], rcx
loc_8AF35:
mov [rbx], rax
jmp short loc_8AEDA
jmp short $+2
loc_8AF3C:
mov rbx, rax
mov rdi, [rsp+arg_0]; void *
cmp rdi, r15
jz short loc_8AF56
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_8AF56:
mov rdi, rbx
call __Unwind_Resume
| _QWORD * minja::Parser::parseString[abi:cxx11](void)::{lambda(char)#1}::operator()[abi:cxx11](
_QWORD *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
_OWORD *v12; // rdi
long long v14; // rax
void *v15; // [rsp+8h] [rbp-50h] BYREF
long long v16; // [rsp+10h] [rbp-48h]
_OWORD v17[4]; // [rsp+18h] [rbp-40h] BYREF
v4 = *a2;
v5 = *(_BYTE **)(*a2 + 24);
v6 = *(_BYTE **)(*a2 + 32);
if ( v6 == v5 || *v6 != a3 )
{
*a1 = 0LL;
return a1;
}
v15 = v17;
v16 = 0LL;
LOBYTE(v17[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_ED5F4[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 = v15;
*a1 = 0LL;
if ( v12 != v17 )
operator delete(v12, *(_QWORD *)&v17[0] + 1LL);
return a1;
}
}
if ( v10 != a3 )
{
LABEL_11:
std::string::push_back(&v15, (unsigned int)v10);
v8 = 0;
goto LABEL_12;
}
*(_QWORD *)(v4 + 32) = v6 + 2;
v14 = operator new(0x20uLL);
*(_QWORD *)v14 = v14 + 16;
if ( v15 == v17 )
{
*(_OWORD *)(v14 + 16) = v17[0];
}
else
{
*(_QWORD *)v14 = v15;
*(_QWORD *)(v14 + 16) = *(_QWORD *)&v17[0];
}
*(_QWORD *)(v14 + 8) = v16;
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 0x0018aed3
MOV EBP,EDX
CMP byte ptr [RAX],BPL
JNZ 0x0018aed3
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x10],R15
MOV qword ptr [R15 + -0x8],0x0
MOV byte ptr [R15],0x0
LEA RDX,[RAX + 0x1]
MOV qword ptr [R12 + 0x20],RDX
CMP RDX,RCX
JZ 0x0018aeec
XOR EDX,EDX
MOV R13D,0x1a29
LEA R14,[RSP + 0x8]
LAB_0018ae5c:
MOV CL,byte ptr [RAX + 0x1]
TEST DL,0x1
JZ 0x0018ae85
MOVSX EAX,CL
ADD EAX,-0x5c
ROR EAX,0x1
CMP EAX,0xc
JA 0x0018ae91
BT R13D,EAX
JNC 0x0018ae91
MOV EAX,EAX
LEA RCX,[0x1ed5f4]
MOV CL,byte ptr [RAX + RCX*0x1]
JMP 0x0018ae91
LAB_0018ae85:
MOV DL,0x1
CMP CL,0x5c
JZ 0x0018ae9e
CMP CL,BPL
JZ 0x0018aef0
LAB_0018ae91:
MOVSX ESI,CL
MOV RDI,R14
CALL 0x0011a730
XOR EDX,EDX
LAB_0018ae9e:
MOV RAX,qword ptr [R12 + 0x20]
LEA RCX,[RAX + 0x1]
MOV qword ptr [R12 + 0x20],RCX
CMP RCX,qword ptr [R12 + 0x18]
JNZ 0x0018ae5c
MOV RDI,qword ptr [RSP + 0x8]
MOV qword ptr [RBX],0x0
CMP RDI,R15
JZ 0x0018aeda
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011a890
JMP 0x0018aeda
LAB_0018aed3:
MOV qword ptr [RBX],0x0
LAB_0018aeda:
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0018aeec:
XOR EAX,EAX
JMP 0x0018af35
LAB_0018aef0:
ADD RAX,0x2
MOV qword ptr [R12 + 0x20],RAX
LAB_0018aef9:
MOV EDI,0x20
CALL 0x0011a870
LAB_0018af03:
MOV RCX,RAX
ADD RCX,0x10
MOV qword ptr [RAX],RCX
MOV RDX,qword ptr [RSP + 0x8]
CMP RDX,R15
JZ 0x0018af25
MOV qword ptr [RAX],RDX
MOV RCX,qword ptr [RSP + 0x18]
MOV qword ptr [RAX + 0x10],RCX
JMP 0x0018af2c
LAB_0018af25:
MOVUPS XMM0,xmmword ptr [R15]
MOVUPS xmmword ptr [RCX],XMM0
LAB_0018af2c:
MOV RCX,qword ptr [RSP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
LAB_0018af35:
MOV qword ptr [RBX],RAX
JMP 0x0018aeda
|
/* 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;
int8 local_48;
int1 local_40;
int7 uStack_3f;
int8 uStack_38;
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_0018af35:
*puVar5 = puVar3;
}
else {
bVar4 = false;
local_50 = &local_40;
do {
if (bVar4) {
LAB_0018ae91:
/* try { // try from 0018ae91 to 0018ae9b has its CatchHandler @ 0018af3c */
std::__cxx11::string::push_back((char)&local_50);
bVar4 = false;
}
else {
bVar4 = true;
if (pcVar2[1] != '\\') {
if (pcVar2[1] != in_DL) goto LAB_0018ae91;
*(char **)(lVar1 + 0x20) = pcVar2 + 2;
/* try { // try from 0018aef9 to 0018af02 has its CatchHandler @ 0018af3a */
puVar3 = (int8 *)operator_new(0x20);
*puVar3 = puVar3 + 2;
if (local_50 == &local_40) {
puVar3[2] = CONCAT71(uStack_3f,local_40);
puVar3[3] = uStack_38;
}
else {
*puVar3 = local_50;
puVar3[2] = CONCAT71(uStack_3f,local_40);
}
puVar3[1] = local_48;
goto LAB_0018af35;
}
}
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;
}
| |
43,526 | char const* fmt::v8::detail::parse_precision<char, fmt::v8::detail::specs_checker<fmt::v8::detail::specs_handler<char>>&>(char const*, char const*, fmt::v8::detail::specs_checker<fmt::v8::detail::specs_handler<char>>&) | aimrt_mujoco_sim/_deps/spdlog_lib-src/include/spdlog/fmt/bundled/core.h | FMT_CONSTEXPR auto parse_precision(const Char* begin, const Char* end,
Handler&& handler) -> const Char* {
using detail::auto_id;
struct precision_adapter {
Handler& handler;
FMT_CONSTEXPR void operator()() { handler.on_dynamic_precision(auto_id()); }
FMT_CONSTEXPR void operator()(int id) { handler.on_dynamic_precision(id); }
FMT_CONSTEXPR void operator()(basic_string_view<Char> id) {
handler.on_dynamic_precision(id);
}
FMT_CONSTEXPR void on_error(const char* message) {
if (message) handler.on_error(message);
}
};
++begin;
auto c = begin != end ? *begin : Char();
if ('0' <= c && c <= '9') {
auto precision = parse_nonnegative_int(begin, end, -1);
if (precision != -1)
handler.on_precision(precision);
else
handler.on_error("number is too big");
} else if (c == '{') {
++begin;
if (begin != end)
begin = parse_arg_id(begin, end, precision_adapter{handler});
if (begin == end || *begin++ != '}')
return handler.on_error("invalid format string"), begin;
} else {
return handler.on_error("missing precision specifier"), begin;
}
handler.end_precision();
return begin;
} | O3 | c | char const* fmt::v8::detail::parse_precision<char, fmt::v8::detail::specs_checker<fmt::v8::detail::specs_handler<char>>&>(char const*, char const*, fmt::v8::detail::specs_checker<fmt::v8::detail::specs_handler<char>>&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
leaq 0x1(%rdi), %rax
movq %rax, 0x20(%rsp)
cmpq %rsi, %rax
je 0x30700
movq %rdx, %rbx
movq %rsi, %r14
movsbl (%rax), %eax
leal -0x30(%rax), %ecx
cmpl $0x9, %ecx
ja 0x3064d
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
callq 0x30299
cmpl $-0x1, %eax
je 0x30712
movq (%rbx), %rcx
movl %eax, 0x4(%rcx)
jmp 0x306cc
cmpb $0x7b, %al
jne 0x30700
movq %rdi, %r15
addq $0x2, %r15
cmpq %r14, %r15
je 0x306b8
movq %rbx, 0x28(%rsp)
movzbl (%r15), %eax
cmpl $0x3a, %eax
je 0x30674
cmpl $0x7d, %eax
jne 0x306a5
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x30a04
movaps (%r12), %xmm0
movaps 0x10(%r12), %xmm1
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
callq 0x30b63
movq (%rbx), %rcx
movl %eax, 0x4(%rcx)
jmp 0x306b8
leaq 0x28(%rsp), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x30a36
movq %rax, %r15
cmpq %r14, %r15
je 0x30709
leaq 0x1(%r15), %rax
movq %rax, 0x20(%rsp)
cmpb $0x7d, (%r15)
jne 0x30709
movl 0x18(%rbx), %eax
cmpl $0xe, %eax
ja 0x306de
movl $0x41fe, %ecx # imm = 0x41FE
btl %eax, %ecx
jb 0x306ef
movq 0x20(%rsp), %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1a816(%rip), %rsi # 0x4af0c
leaq 0x30(%rsp), %rdi
callq 0x449b6
leaq 0x1a7bd(%rip), %rsi # 0x4aec4
jmp 0x306f6
leaq 0x1a655(%rip), %rsi # 0x4ad65
jmp 0x306f6
leaq 0x1a604(%rip), %rsi # 0x4ad1d
jmp 0x306f6
nop
| _ZN3fmt2v86detail15parse_precisionIcRNS1_13specs_checkerINS1_13specs_handlerIcEEEEEEPKT_SA_SA_OT0_:
push r15
push r14
push r12
push rbx
sub rsp, 58h
lea rax, [rdi+1]
mov [rsp+78h+var_58], rax
cmp rax, rsi
jz loc_30700
mov rbx, rdx
mov r14, rsi
movsx eax, byte ptr [rax]
lea ecx, [rax-30h]
cmp ecx, 9
ja short loc_3064D
lea rdi, [rsp+78h+var_58]
mov rsi, r14
mov edx, 0FFFFFFFFh
call _ZN3fmt2v86detail21parse_nonnegative_intIcEEiRPKT_S5_i; fmt::v8::detail::parse_nonnegative_int<char>(char const*&,char const*,int)
cmp eax, 0FFFFFFFFh
jz loc_30712
mov rcx, [rbx]
mov [rcx+4], eax
jmp short loc_306CC
loc_3064D:
cmp al, 7Bh ; '{'
jnz loc_30700
mov r15, rdi
add r15, 2
cmp r15, r14
jz short loc_306B8
mov [rsp+78h+var_50], rbx
movzx eax, byte ptr [r15]
cmp eax, 3Ah ; ':'
jz short loc_30674
cmp eax, 7Dh ; '}'
jnz short loc_306A5
loc_30674:
lea r12, [rsp+78h+var_48]
mov rdi, r12
mov rsi, rbx
call _ZN3fmt2v86detail13specs_handlerIcE7get_argENS1_7auto_idE; fmt::v8::detail::specs_handler<char>::get_arg(fmt::v8::detail::auto_id)
movaps xmm0, xmmword ptr [r12]
movaps xmm1, xmmword ptr [r12+10h]
movaps [rsp+78h+var_68], xmm1
movaps [rsp+78h+var_78], xmm0
call _ZN3fmt2v86detail16get_dynamic_specINS1_17precision_checkerENS0_16basic_format_argINS0_20basic_format_contextINS0_8appenderEcEEEENS1_13error_handlerEEEiT0_T1_; fmt::v8::detail::get_dynamic_spec<fmt::v8::detail::precision_checker,fmt::v8::basic_format_arg<fmt::v8::basic_format_context<fmt::v8::appender,char>>,fmt::v8::detail::error_handler>(fmt::v8::basic_format_arg<fmt::v8::basic_format_context<fmt::v8::appender,char>>,fmt::v8::detail::error_handler)
mov rcx, [rbx]
mov [rcx+4], eax
jmp short loc_306B8
loc_306A5:
lea rdx, [rsp+78h+var_50]
mov rdi, r15
mov rsi, r14
call _ZN3fmt2v86detail15do_parse_arg_idIcRZNS1_15parse_precisionIcRNS1_13specs_checkerINS1_13specs_handlerIcEEEEEEPKT_SB_SB_OT0_E17precision_adapterEESB_SB_SB_SD_; fmt::v8::detail::do_parse_arg_id<char,fmt::v8::detail::parse_precision<char,fmt::v8::detail::specs_checker<fmt::v8::detail::specs_handler<char>> &>(char const*,char const*,fmt::v8::detail::specs_checker<fmt::v8::detail::specs_handler<char>> &)::precision_adapter &>(char const*,char const*,fmt::v8::detail::parse_precision<char,fmt::v8::detail::specs_checker<fmt::v8::detail::specs_handler<char>> &>(char const*,char const*,fmt::v8::detail::specs_checker<fmt::v8::detail::specs_handler<char>> &)::precision_adapter)
mov r15, rax
loc_306B8:
cmp r15, r14
jz short loc_30709
lea rax, [r15+1]
mov [rsp+78h+var_58], rax
cmp byte ptr [r15], 7Dh ; '}'
jnz short loc_30709
loc_306CC:
mov eax, [rbx+18h]
cmp eax, 0Eh
ja short loc_306DE
mov ecx, 41FEh
bt ecx, eax
jb short loc_306EF
loc_306DE:
mov rax, [rsp+78h+var_58]
add rsp, 58h
pop rbx
pop r12
pop r14
pop r15
retn
loc_306EF:
lea rsi, aPrecisionNotAl; "precision not allowed for this argument"...
loc_306F6:
lea rdi, [rsp+78h+var_48]; this
call _ZN3fmt2v86detail13error_handler8on_errorEPKc; fmt::v8::detail::error_handler::on_error(char const*)
loc_30700:
lea rsi, aMissingPrecisi; "missing precision specifier"
jmp short loc_306F6
loc_30709:
lea rsi, aInvalidFormatS; "invalid format string"
jmp short loc_306F6
loc_30712:
lea rsi, aNumberIsTooBig; "number is too big"
jmp short loc_306F6
| char * fmt::v8::detail::parse_precision<char,fmt::v8::detail::specs_checker<fmt::v8::detail::specs_handler<char>> &>(
long long a1,
char *a2,
_DWORD *a3)
{
int v5; // eax
int v6; // eax
char *v7; // r15
int v8; // eax
int v9; // esi
int v10; // edx
int v11; // ecx
int v12; // r8d
int v13; // r9d
unsigned int v14; // eax
int v15; // ecx
const char *v17; // rsi
char *v18; // [rsp+20h] [rbp-58h] BYREF
_DWORD *v19; // [rsp+28h] [rbp-50h] BYREF
char v20[8]; // [rsp+30h] [rbp-48h] BYREF
__int16 v21; // [rsp+38h] [rbp-40h]
int v22; // [rsp+40h] [rbp-38h]
v18 = (char *)(a1 + 1);
if ( (char *)(a1 + 1) == a2 )
goto LABEL_18;
v5 = *(char *)(a1 + 1);
if ( (unsigned int)(v5 - 48) <= 9 )
{
v6 = fmt::v8::detail::parse_nonnegative_int<char>(&v18, a2, 0xFFFFFFFF);
if ( v6 != -1 )
{
*(_DWORD *)(*(_QWORD *)a3 + 4LL) = v6;
goto LABEL_13;
}
v17 = "number is too big";
LABEL_17:
fmt::v8::detail::error_handler::on_error((fmt::v8::detail::error_handler *)v20, v17);
}
if ( (_BYTE)v5 != 123 )
{
LABEL_18:
v17 = "missing precision specifier";
goto LABEL_17;
}
v7 = (char *)(a1 + 2);
if ( (char *)(a1 + 2) != a2 )
{
v19 = a3;
v8 = (unsigned __int8)*v7;
if ( v8 == 58 || v8 == 125 )
{
v9 = (int)a3;
fmt::v8::detail::specs_handler<char>::get_arg(v20, a3);
*(_DWORD *)(*(_QWORD *)a3 + 4LL) = fmt::v8::detail::get_dynamic_spec<fmt::v8::detail::precision_checker,fmt::v8::basic_format_arg<fmt::v8::basic_format_context<fmt::v8::appender,char>>,fmt::v8::detail::error_handler>(
(unsigned int)v20,
v9,
v10,
v11,
v12,
v13,
v20[0],
v21,
v22);
}
else
{
v7 = (char *)fmt::v8::detail::do_parse_arg_id<char,char const* fmt::v8::detail::parse_precision<char,fmt::v8::detail::specs_checker<fmt::v8::detail::specs_handler<char>> &>(char const*,char const*,fmt::v8::detail::specs_checker<fmt::v8::detail::specs_handler<char>> &)::precision_adapter &>(
a1 + 2,
a2,
&v19);
}
}
if ( v7 == a2 || (v18 = v7 + 1, *v7 != 125) )
{
v17 = "invalid format string";
goto LABEL_17;
}
LABEL_13:
v14 = a3[6];
if ( v14 <= 0xE )
{
v15 = 16894;
if ( _bittest(&v15, v14) )
{
v17 = "precision not allowed for this argument type";
goto LABEL_17;
}
}
return v18;
}
| parse_precision<char,fmt::v8::detail::specs_checker<fmt::v8::detail::specs_handler<char>>&>:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x58
LEA RAX,[RDI + 0x1]
MOV qword ptr [RSP + 0x20],RAX
CMP RAX,RSI
JZ 0x00130700
MOV RBX,RDX
MOV R14,RSI
MOVSX EAX,byte ptr [RAX]
LEA ECX,[RAX + -0x30]
CMP ECX,0x9
JA 0x0013064d
LEA RDI,[RSP + 0x20]
MOV RSI,R14
MOV EDX,0xffffffff
CALL 0x00130299
CMP EAX,-0x1
JZ 0x00130712
MOV RCX,qword ptr [RBX]
MOV dword ptr [RCX + 0x4],EAX
JMP 0x001306cc
LAB_0013064d:
CMP AL,0x7b
JNZ 0x00130700
MOV R15,RDI
ADD R15,0x2
CMP R15,R14
JZ 0x001306b8
MOV qword ptr [RSP + 0x28],RBX
MOVZX EAX,byte ptr [R15]
CMP EAX,0x3a
JZ 0x00130674
CMP EAX,0x7d
JNZ 0x001306a5
LAB_00130674:
LEA R12,[RSP + 0x30]
MOV RDI,R12
MOV RSI,RBX
CALL 0x00130a04
MOVAPS XMM0,xmmword ptr [R12]
MOVAPS XMM1,xmmword ptr [R12 + 0x10]
MOVAPS xmmword ptr [RSP + 0x10],XMM1
MOVAPS xmmword ptr [RSP],XMM0
CALL 0x00130b63
MOV RCX,qword ptr [RBX]
MOV dword ptr [RCX + 0x4],EAX
JMP 0x001306b8
LAB_001306a5:
LEA RDX,[RSP + 0x28]
MOV RDI,R15
MOV RSI,R14
CALL 0x00130a36
MOV R15,RAX
LAB_001306b8:
CMP R15,R14
JZ 0x00130709
LEA RAX,[R15 + 0x1]
MOV qword ptr [RSP + 0x20],RAX
CMP byte ptr [R15],0x7d
JNZ 0x00130709
LAB_001306cc:
MOV EAX,dword ptr [RBX + 0x18]
CMP EAX,0xe
JA 0x001306de
MOV ECX,0x41fe
BT ECX,EAX
JC 0x001306ef
LAB_001306de:
MOV RAX,qword ptr [RSP + 0x20]
ADD RSP,0x58
POP RBX
POP R12
POP R14
POP R15
RET
LAB_001306ef:
LEA RSI,[0x14af0c]
LAB_001306f6:
LEA RDI,[RSP + 0x30]
CALL 0x001449b6
LAB_00130700:
LEA RSI,[0x14aec4]
JMP 0x001306f6
LAB_00130709:
LEA RSI,[0x14ad65]
JMP 0x001306f6
LAB_00130712:
LEA RSI,[0x14ad1d]
JMP 0x001306f6
|
/* char const* fmt::v8::detail::parse_precision<char,
fmt::v8::detail::specs_checker<fmt::v8::detail::specs_handler<char> >&>(char const*, char const*,
fmt::v8::detail::specs_checker<fmt::v8::detail::specs_handler<char> >&) */
char * fmt::v8::detail::
parse_precision<char,fmt::v8::detail::specs_checker<fmt::v8::detail::specs_handler<char>>&>
(char *param_1,char *param_2,specs_checker *param_3)
{
int iVar1;
char *pcVar2;
char *local_58;
specs_checker *local_50;
specs_handler<char> local_48 [40];
local_58 = param_1 + 1;
if (local_58 == param_2) {
LAB_00130700:
pcVar2 = "missing precision specifier";
}
else {
if ((int)*local_58 - 0x30U < 10) {
iVar1 = parse_nonnegative_int<char>(&local_58,param_2,-1);
if (iVar1 == -1) {
pcVar2 = "number is too big";
goto LAB_001306f6;
}
*(int *)(*(long *)param_3 + 4) = iVar1;
}
else {
if (*local_58 != '{') goto LAB_00130700;
pcVar2 = param_1 + 2;
if (pcVar2 != param_2) {
local_50 = param_3;
if ((*pcVar2 == ':') || (*pcVar2 == '}')) {
specs_handler<char>::get_arg(local_48,param_3);
iVar1 = get_dynamic_spec<fmt::v8::detail::precision_checker,fmt::v8::basic_format_arg<fmt::v8::basic_format_context<fmt::v8::appender,char>>,fmt::v8::detail::error_handler>
();
*(int *)(*(long *)param_3 + 4) = iVar1;
}
else {
pcVar2 = do_parse_arg_id<char,fmt::v8::detail::parse_precision<char,fmt::v8::detail::specs_checker<fmt::v8::detail::specs_handler<char>>&>(char_const*,char_const*,fmt::v8::detail::specs_checker<fmt::v8::detail::specs_handler<char>>&)::precision_adapter&>
(pcVar2,param_2,(specs_checker *)&local_50);
}
}
if ((pcVar2 == param_2) || (local_58 = pcVar2 + 1, *pcVar2 != '}')) {
pcVar2 = "invalid format string";
goto LAB_001306f6;
}
}
if ((0xe < *(uint *)(param_3 + 0x18)) ||
((0x41feU >> (*(uint *)(param_3 + 0x18) & 0x1f) & 1) == 0)) {
return local_58;
}
pcVar2 = "precision not allowed for this argument type";
}
LAB_001306f6:
/* WARNING: Subroutine does not return */
error_handler::on_error((error_handler *)local_48,pcVar2);
}
| |
43,527 | minja::Parser::peekSymbols(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&) const | monkey531[P]llama/common/minja.hpp | MacroNode(const Location & location, std::shared_ptr<VariableExpr> && n, Expression::Parameters && p, std::shared_ptr<TemplateNode> && b)
: TemplateNode(location), name(std::move(n)), params(std::move(p)), body(std::move(b)) {
for (size_t i = 0; i < params.size(); ++i) {
const auto & name = params[i].first;
if (!name.empty()) {
named_param_positions[name] = i;
}
}
} | O3 | cpp | minja::Parser::peekSymbols(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq (%rsi), %r12
movq 0x8(%rsi), %r13
cmpq %r13, %r12
je 0x8988d
movq %rdi, %rbx
leaq 0x18(%rsp), %rbp
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rsi
subq %rsi, %rax
movq 0x8(%r12), %rdx
cmpq %rdx, %rax
jl 0x89880
addq %rsi, %rdx
movq %rbp, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x7003a
movq 0x10(%rsp), %rdx
cmpq 0x8(%r12), %rdx
jne 0x89859
movq 0x8(%rsp), %r15
testq %rdx, %rdx
je 0x89863
movq (%r12), %rsi
movq %r15, %rdi
callq 0x1a900
testl %eax, %eax
sete %r14b
jmp 0x89866
movq 0x8(%rsp), %r15
xorl %r14d, %r14d
jmp 0x89866
movb $0x1, %r14b
cmpq %rbp, %r15
je 0x8987b
movq 0x18(%rsp), %rsi
incq %rsi
movq %r15, %rdi
callq 0x1a8c0
testb %r14b, %r14b
jne 0x89891
addq $0x20, %r12
cmpq %r13, %r12
jne 0x89808
xorl %eax, %eax
jmp 0x89893
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZNK5minja6Parser11peekSymbolsERKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS7_EE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r12, [rsi]
mov r13, [rsi+8]
cmp r12, r13
jz loc_8988D
mov rbx, rdi
lea rbp, [rsp+58h+var_40]
loc_89808:
mov rax, [rbx+18h]
mov rsi, [rbx+20h]
sub rax, rsi
mov rdx, [r12+8]
cmp rax, rdx
jl short loc_89880
add rdx, rsi
mov [rsp+58h+var_50], rbp
lea rdi, [rsp+58h+var_50]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIN9__gnu_cxx17__normal_iteratorIPKcS4_EEEEvT_SB_St20forward_iterator_tag; std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::forward_iterator_tag)
mov rdx, [rsp+58h+var_48]
cmp rdx, [r12+8]
jnz short loc_89859
mov r15, [rsp+58h+var_50]
test rdx, rdx
jz short loc_89863
mov rsi, [r12]
mov rdi, r15
call _bcmp
test eax, eax
setz r14b
jmp short loc_89866
loc_89859:
mov r15, [rsp+58h+var_50]
xor r14d, r14d
jmp short loc_89866
loc_89863:
mov r14b, 1
loc_89866:
cmp r15, rbp
jz short loc_8987B
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
mov rdi, r15; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_8987B:
test r14b, r14b
jnz short loc_89891
loc_89880:
add r12, 20h ; ' '
cmp r12, r13
jnz loc_89808
loc_8988D:
xor eax, eax
jmp short loc_89893
loc_89891:
mov al, 1
loc_89893:
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| char minja::Parser::peekSymbols(long long a1, _QWORD *a2)
{
_QWORD *v2; // r12
_QWORD *v3; // r13
_BYTE *v4; // rsi
long long v5; // rdx
_QWORD *v6; // r15
bool v7; // r14
void *v9; // [rsp+8h] [rbp-50h] BYREF
long long v10; // [rsp+10h] [rbp-48h]
_QWORD v11[8]; // [rsp+18h] [rbp-40h] BYREF
v2 = (_QWORD *)*a2;
v3 = (_QWORD *)a2[1];
if ( (_QWORD *)*a2 == v3 )
return 0;
while ( 1 )
{
v4 = *(_BYTE **)(a1 + 32);
v5 = v2[1];
if ( *(_QWORD *)(a1 + 24) - (_QWORD)v4 >= v5 )
{
v9 = v11;
std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>(
(long long)&v9,
v4,
(long long)&v4[v5]);
if ( v10 == v2[1] )
{
v6 = v9;
v7 = !v10 || (unsigned int)bcmp(v9, *v2) == 0;
}
else
{
v6 = v9;
v7 = 0;
}
if ( v6 != v11 )
operator delete(v6, v11[0] + 1LL);
if ( v7 )
break;
}
v2 += 4;
if ( v2 == v3 )
return 0;
}
return 1;
}
| peekSymbols:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R12,qword ptr [RSI]
MOV R13,qword ptr [RSI + 0x8]
CMP R12,R13
JZ 0x0018988d
MOV RBX,RDI
LEA RBP,[RSP + 0x18]
LAB_00189808:
MOV RAX,qword ptr [RBX + 0x18]
MOV RSI,qword ptr [RBX + 0x20]
SUB RAX,RSI
MOV RDX,qword ptr [R12 + 0x8]
CMP RAX,RDX
JL 0x00189880
ADD RDX,RSI
MOV qword ptr [RSP + 0x8],RBP
LEA RDI,[RSP + 0x8]
CALL 0x0017003a
MOV RDX,qword ptr [RSP + 0x10]
CMP RDX,qword ptr [R12 + 0x8]
JNZ 0x00189859
MOV R15,qword ptr [RSP + 0x8]
TEST RDX,RDX
JZ 0x00189863
MOV RSI,qword ptr [R12]
MOV RDI,R15
CALL 0x0011a900
TEST EAX,EAX
SETZ R14B
JMP 0x00189866
LAB_00189859:
MOV R15,qword ptr [RSP + 0x8]
XOR R14D,R14D
JMP 0x00189866
LAB_00189863:
MOV R14B,0x1
LAB_00189866:
CMP R15,RBP
JZ 0x0018987b
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
MOV RDI,R15
CALL 0x0011a8c0
LAB_0018987b:
TEST R14B,R14B
JNZ 0x00189891
LAB_00189880:
ADD R12,0x20
CMP R12,R13
JNZ 0x00189808
LAB_0018988d:
XOR EAX,EAX
JMP 0x00189893
LAB_00189891:
MOV AL,0x1
LAB_00189893:
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* minja::Parser::peekSymbols(std::vector<std::__cxx11::string, std::allocator<std::__cxx11::string
> > const&) const */
int8 __thiscall minja::Parser::peekSymbols(Parser *this,vector *param_1)
{
int8 *puVar1;
long lVar2;
long *plVar3;
int iVar4;
int8 *puVar5;
bool bVar6;
long *local_50;
size_t local_48;
long local_40 [2];
puVar5 = *(int8 **)param_1;
puVar1 = *(int8 **)(param_1 + 8);
if (puVar5 != puVar1) {
do {
lVar2 = *(long *)(this + 0x20);
if ((long)puVar5[1] <= *(long *)(this + 0x18) - lVar2) {
local_50 = local_40;
std::__cxx11::string::
_M_construct<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>
(&local_50,lVar2,puVar5[1] + lVar2);
plVar3 = local_50;
if (local_48 == puVar5[1]) {
if (local_48 == 0) {
bVar6 = true;
}
else {
iVar4 = bcmp(local_50,(void *)*puVar5,local_48);
bVar6 = iVar4 == 0;
}
}
else {
bVar6 = false;
}
if (plVar3 != local_40) {
operator_delete(plVar3,local_40[0] + 1);
}
if (bVar6) {
return 1;
}
}
puVar5 = puVar5 + 4;
} while (puVar5 != puVar1);
}
return 0;
}
| |
43,528 | ma_cmp_block_unique | eloqsql/storage/maria/ma_blockrec.c | my_bool _ma_cmp_block_unique(MARIA_HA *info, MARIA_UNIQUEDEF *def,
const uchar *record, MARIA_RECORD_POS pos)
{
uchar *org_rec_buff, *old_record;
size_t org_rec_buff_size;
int error;
my_bool buff_alloced;
DBUG_ENTER("_ma_cmp_block_unique");
alloc_on_stack(*info->stack_end_ptr, old_record, buff_alloced,
info->s->base.reclength);
if (!old_record)
DBUG_RETURN(1);
/* Don't let the compare destroy blobs that may be in use */
org_rec_buff= info->rec_buff;
org_rec_buff_size= info->rec_buff_size;
if (info->s->base.blobs)
{
/* Force realloc of record buffer*/
info->rec_buff= 0;
info->rec_buff_size= 0;
}
error= _ma_read_block_record(info, old_record, pos);
if (!error)
error= _ma_unique_comp(def, record, old_record, def->null_are_equal);
if (info->s->base.blobs)
{
my_free(info->rec_buff);
info->rec_buff= org_rec_buff;
info->rec_buff_size= org_rec_buff_size;
}
DBUG_PRINT("exit", ("result: %d", error));
stack_alloc_free(old_record, buff_alloced);
DBUG_RETURN(error != 0);
} | O3 | c | ma_cmp_block_unique:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq (%rdi), %rax
movq 0x398(%rax), %rsi
leaq -0x50(%rbp), %rdx
movq %rsi, (%rdx)
movq 0x78(%rdi), %rcx
movq (%rcx), %rcx
subq %rdx, %rcx
subq %rsi, %rcx
jbe 0x4cd27
cmpq $0x10000, %rcx # imm = 0x10000
ja 0x4cd07
cmpq $0x1000, %rsi # imm = 0x1000
jb 0x4cd27
cmpq $0x8001, %rcx # imm = 0x8001
jb 0x4cd27
movq %r15, -0x40(%rbp)
movq %r14, -0x48(%rbp)
movq %rsp, %r13
addq $0xf, %rsi
andq $-0x10, %rsi
subq %rsi, %r13
movq %r13, %rsp
movb $0x1, %cl
movl %ecx, -0x34(%rbp)
jmp 0x4cd51
movl $0x10010, %edx # imm = 0x10010
xorl %edi, %edi
callq 0x9ff21
testq %rax, %rax
je 0x4cddd
movq %rax, %r13
movq %r15, -0x40(%rbp)
movq %r14, -0x48(%rbp)
movq (%rbx), %rax
movl $0x0, -0x34(%rbp)
movq 0x3a0(%rbx), %r15
movq 0x460(%rbx), %r14
cmpl $0x0, 0x3f0(%rax)
je 0x4cd78
xorl %eax, %eax
movq %rax, 0x3a0(%rbx)
movq %rax, 0x460(%rbx)
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x4cb81
movb $0x1, %r12b
testl %eax, %eax
jne 0x4cda7
movq -0x40(%rbp), %rdi
movsbl 0x3(%rdi), %ecx
movq -0x48(%rbp), %rsi
movq %r13, %rdx
callq 0x58c0d
testb %al, %al
setne %r12b
movq (%rbx), %rax
cmpl $0x0, 0x3f0(%rax)
je 0x4cdcd
movq 0x3a0(%rbx), %rdi
callq 0xa014e
movq %r15, 0x3a0(%rbx)
movq %r14, 0x460(%rbx)
cmpb $0x0, -0x34(%rbp)
jne 0x4cde0
movq %r13, %rdi
callq 0xa014e
jmp 0x4cde0
movb $0x1, %r12b
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x4ce01
movl %r12d, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x29260
| _ma_cmp_block_unique:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r12, rcx
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov rax, [rdi]
mov rsi, [rax+398h]
lea rdx, [rbp+var_50]
mov [rdx], rsi
mov rcx, [rdi+78h]
mov rcx, [rcx]
sub rcx, rdx
sub rcx, rsi
jbe short loc_4CD27
cmp rcx, 10000h
ja short loc_4CD07
cmp rsi, 1000h
jb short loc_4CD27
cmp rcx, 8001h
jb short loc_4CD27
loc_4CD07:
mov [rbp+var_40], r15
mov [rbp+var_48], r14
mov r13, rsp
add rsi, 0Fh
and rsi, 0FFFFFFFFFFFFFFF0h
sub r13, rsi
mov rsp, r13
mov cl, 1
mov [rbp+var_34], ecx
jmp short loc_4CD51
loc_4CD27:
mov edx, 10010h
xor edi, edi
call my_malloc
test rax, rax
jz loc_4CDDD
mov r13, rax
mov [rbp+var_40], r15
mov [rbp+var_48], r14
mov rax, [rbx]
mov [rbp+var_34], 0
loc_4CD51:
mov r15, [rbx+3A0h]
mov r14, [rbx+460h]
cmp dword ptr [rax+3F0h], 0
jz short loc_4CD78
xor eax, eax
mov [rbx+3A0h], rax
mov [rbx+460h], rax
loc_4CD78:
mov rdi, rbx
mov rsi, r13
mov rdx, r12
call _ma_read_block_record
mov r12b, 1
test eax, eax
jnz short loc_4CDA7
mov rdi, [rbp+var_40]
movsx ecx, byte ptr [rdi+3]
mov rsi, [rbp+var_48]
mov rdx, r13
call _ma_unique_comp
test al, al
setnz r12b
loc_4CDA7:
mov rax, [rbx]
cmp dword ptr [rax+3F0h], 0
jz short loc_4CDCD
mov rdi, [rbx+3A0h]
call my_free
mov [rbx+3A0h], r15
mov [rbx+460h], r14
loc_4CDCD:
cmp byte ptr [rbp+var_34], 0
jnz short loc_4CDE0
mov rdi, r13
call my_free
jmp short loc_4CDE0
loc_4CDDD:
mov r12b, 1
loc_4CDE0:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_4CE01
mov eax, r12d
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_4CE01:
call ___stack_chk_fail
| long long ma_cmp_block_unique(long long *a1, long long a2, long long a3, unsigned long long a4)
{
long long v7; // rax
unsigned long long v8; // rsi
unsigned long long v9; // rcx
bool v10; // cc
unsigned long long v11; // rcx
char *v12; // r13
long long v13; // rax
long long v14; // r15
long long v15; // r14
int block_record; // eax
unsigned long long v18; // [rsp+0h] [rbp-50h] BYREF
long long v19; // [rsp+8h] [rbp-48h]
long long v20; // [rsp+10h] [rbp-40h]
int v21; // [rsp+1Ch] [rbp-34h]
unsigned long long v22; // [rsp+20h] [rbp-30h]
v22 = __readfsqword(0x28u);
v7 = *a1;
v8 = *(_QWORD *)(*a1 + 920);
v18 = v8;
v9 = *(_QWORD *)a1[15] - (_QWORD)&v18;
v10 = v9 <= v8;
v11 = v9 - v8;
if ( v10 || v11 <= 0x10000 && (v8 < 0x1000 || v11 < 0x8001) )
{
v13 = my_malloc(0LL, v8, 65552LL);
if ( !v13 )
{
LOBYTE(a4) = 1;
return (unsigned int)a4;
}
v12 = (char *)v13;
v20 = a2;
v19 = a3;
v7 = *a1;
v21 = 0;
}
else
{
v20 = a2;
v19 = a3;
v12 = (char *)&v18 - ((v8 + 15) & 0xFFFFFFFFFFFFFFF0LL);
LOBYTE(v11) = 1;
v21 = v11;
}
v14 = a1[116];
v15 = a1[140];
if ( *(_DWORD *)(v7 + 1008) )
{
a1[116] = 0LL;
a1[140] = 0LL;
}
block_record = ma_read_block_record(a1, (long long)v12, a4);
LOBYTE(a4) = 1;
if ( !block_record )
LOBYTE(a4) = (unsigned __int8)ma_unique_comp(v20, v19, v12, (unsigned int)*(char *)(v20 + 3)) != 0;
if ( *(_DWORD *)(*a1 + 1008) )
{
my_free(a1[116]);
a1[116] = v14;
a1[140] = v15;
}
if ( !(_BYTE)v21 )
my_free(v12);
return (unsigned int)a4;
}
| _ma_cmp_block_unique:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R12,RCX
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RDI]
MOV RSI,qword ptr [RAX + 0x398]
LEA RDX,[RBP + -0x50]
MOV qword ptr [RDX],RSI
MOV RCX,qword ptr [RDI + 0x78]
MOV RCX,qword ptr [RCX]
SUB RCX,RDX
SUB RCX,RSI
JBE 0x0014cd27
CMP RCX,0x10000
JA 0x0014cd07
CMP RSI,0x1000
JC 0x0014cd27
CMP RCX,0x8001
JC 0x0014cd27
LAB_0014cd07:
MOV qword ptr [RBP + -0x40],R15
MOV qword ptr [RBP + -0x48],R14
MOV R13,RSP
ADD RSI,0xf
AND RSI,-0x10
SUB R13,RSI
MOV RSP,R13
MOV CL,0x1
MOV dword ptr [RBP + -0x34],ECX
JMP 0x0014cd51
LAB_0014cd27:
MOV EDX,0x10010
XOR EDI,EDI
CALL 0x0019ff21
TEST RAX,RAX
JZ 0x0014cddd
MOV R13,RAX
MOV qword ptr [RBP + -0x40],R15
MOV qword ptr [RBP + -0x48],R14
MOV RAX,qword ptr [RBX]
MOV dword ptr [RBP + -0x34],0x0
LAB_0014cd51:
MOV R15,qword ptr [RBX + 0x3a0]
MOV R14,qword ptr [RBX + 0x460]
CMP dword ptr [RAX + 0x3f0],0x0
JZ 0x0014cd78
XOR EAX,EAX
MOV qword ptr [RBX + 0x3a0],RAX
MOV qword ptr [RBX + 0x460],RAX
LAB_0014cd78:
MOV RDI,RBX
MOV RSI,R13
MOV RDX,R12
CALL 0x0014cb81
MOV R12B,0x1
TEST EAX,EAX
JNZ 0x0014cda7
MOV RDI,qword ptr [RBP + -0x40]
MOVSX ECX,byte ptr [RDI + 0x3]
MOV RSI,qword ptr [RBP + -0x48]
MOV RDX,R13
CALL 0x00158c0d
TEST AL,AL
SETNZ R12B
LAB_0014cda7:
MOV RAX,qword ptr [RBX]
CMP dword ptr [RAX + 0x3f0],0x0
JZ 0x0014cdcd
MOV RDI,qword ptr [RBX + 0x3a0]
CALL 0x001a014e
MOV qword ptr [RBX + 0x3a0],R15
MOV qword ptr [RBX + 0x460],R14
LAB_0014cdcd:
CMP byte ptr [RBP + -0x34],0x0
JNZ 0x0014cde0
MOV RDI,R13
CALL 0x001a014e
JMP 0x0014cde0
LAB_0014cddd:
MOV R12B,0x1
LAB_0014cde0:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0014ce01
MOV EAX,R12D
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0014ce01:
CALL 0x00129260
|
ulong _ma_cmp_block_unique(long *param_1,long param_2,int8 param_3,int8 param_4)
{
long lVar1;
long lVar2;
int8 uVar3;
char cVar4;
int iVar5;
int1 *puVar6;
long lVar7;
ulong uVar8;
ulong *puVar9;
int7 uVar10;
long in_FS_OFFSET;
ulong local_58;
int8 local_50;
long local_48;
int4 local_3c;
long local_38;
puVar9 = &local_58;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
lVar7 = *param_1;
local_58 = *(ulong *)(lVar7 + 0x398);
uVar8 = (*(long *)param_1[0xf] - (long)&local_58) - local_58;
uVar10 = (int7)((ulong)param_4 >> 8);
if (((ulong)(*(long *)param_1[0xf] - (long)&local_58) < local_58 || uVar8 == 0) ||
((uVar8 < 0x10001 && ((local_58 < 0x1000 || (uVar8 < 0x8001)))))) {
puVar6 = (int1 *)my_malloc(0,local_58,0x10010);
if (puVar6 == (int1 *)0x0) {
uVar8 = CONCAT71(uVar10,1);
goto LAB_0014cde0;
}
lVar7 = *param_1;
local_3c = 0;
puVar9 = &local_58;
}
else {
puVar6 = (int1 *)((long)&local_58 - (local_58 + 0xf & 0xfffffffffffffff0));
local_3c = (int4)CONCAT71((int7)(uVar8 >> 8),1);
puVar9 = (ulong *)puVar6;
}
lVar1 = param_1[0x74];
lVar2 = param_1[0x8c];
if (*(int *)(lVar7 + 0x3f0) != 0) {
param_1[0x74] = 0;
param_1[0x8c] = 0;
}
local_50 = param_3;
local_48 = param_2;
*(int8 *)((long)puVar9 + -8) = 0x14cd86;
iVar5 = _ma_read_block_record(param_1,puVar6,param_4);
lVar7 = local_48;
uVar3 = local_50;
uVar8 = CONCAT71(uVar10,1);
if (iVar5 == 0) {
cVar4 = *(char *)(local_48 + 3);
*(int8 *)((long)puVar9 + -8) = 0x14cda1;
cVar4 = _ma_unique_comp(lVar7,uVar3,puVar6,(int)cVar4);
uVar8 = CONCAT71(uVar10,cVar4 != '\0');
}
if (*(int *)(*param_1 + 0x3f0) != 0) {
lVar7 = param_1[0x74];
*(int8 *)((long)puVar9 + -8) = 0x14cdbf;
my_free(lVar7);
param_1[0x74] = lVar1;
param_1[0x8c] = lVar2;
}
if ((char)local_3c == '\0') {
*(int8 *)((long)puVar9 + -8) = 0x14cddb;
my_free(puVar6);
}
LAB_0014cde0:
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return uVar8 & 0xffffffff;
}
/* WARNING: Subroutine does not return */
*(code **)((long)puVar9 + -8) = _ma_scan_init_block_record;
__stack_chk_fail();
}
| |
43,529 | blst_pairing_init | corpus-core[P]colibri-stateless/build_O0/_deps/blst-src/src/aggregate.c | void blst_pairing_init(PAIRING *ctx, int hash_or_encode,
const void *DST, size_t DST_len)
{
ctx->ctrl = AGGR_UNDEFINED | (hash_or_encode ? AGGR_HASH_OR_ENCODE : 0);
ctx->nelems = 0;
ctx->DST = (uptr_t)DST==(uptr_t)((byte *)ctx+sizeof_pairing) ? (void *)42
: DST;
ctx->DST_len = DST_len;
} | O0 | c | blst_pairing_init:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl -0xc(%rbp), %edx
xorl %ecx, %ecx
movl $0x40, %eax
cmpl $0x0, %edx
cmovnel %eax, %ecx
orl $0x0, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
addq $0xc78, %rcx # imm = 0xC78
cmpq %rcx, %rax
jne 0x2b3d6
movl $0x2a, %eax
movq %rax, -0x28(%rbp)
jmp 0x2b3de
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
popq %rbp
retq
nopl (%rax,%rax)
| blst_pairing_init:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov edx, [rbp+var_C]
xor ecx, ecx
mov eax, 40h ; '@'
cmp edx, 0
cmovnz ecx, eax
or ecx, 0
mov rax, [rbp+var_8]
mov [rax], ecx
mov rax, [rbp+var_8]
mov dword ptr [rax+4], 0
mov rax, [rbp+var_18]
mov rcx, [rbp+var_8]
add rcx, 0C78h
cmp rax, rcx
jnz short loc_2B3D6
mov eax, 2Ah ; '*'
mov [rbp+var_28], rax
jmp short loc_2B3DE
loc_2B3D6:
mov rax, [rbp+var_18]
mov [rbp+var_28], rax
loc_2B3DE:
mov rcx, [rbp+var_28]
mov rax, [rbp+var_8]
mov [rax+8], rcx
mov rcx, [rbp+var_20]
mov rax, [rbp+var_8]
mov [rax+10h], rcx
pop rbp
retn
| long long blst_pairing_init(long long a1, int a2, long long a3, long long a4)
{
int v4; // ecx
long long result; // rax
long long v6; // [rsp+0h] [rbp-28h]
v4 = 0;
if ( a2 )
v4 = 64;
*(_DWORD *)a1 = v4;
*(_DWORD *)(a1 + 4) = 0;
if ( a3 == a1 + 3192 )
v6 = 42LL;
else
v6 = a3;
*(_QWORD *)(a1 + 8) = v6;
result = a1;
*(_QWORD *)(a1 + 16) = a4;
return result;
}
| blst_pairing_init:
PUSH RBP
MOV RBP,RSP
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 EDX,dword ptr [RBP + -0xc]
XOR ECX,ECX
MOV EAX,0x40
CMP EDX,0x0
CMOVNZ ECX,EAX
OR ECX,0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x4],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x8]
ADD RCX,0xc78
CMP RAX,RCX
JNZ 0x0012b3d6
MOV EAX,0x2a
MOV qword ptr [RBP + -0x28],RAX
JMP 0x0012b3de
LAB_0012b3d6:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x28],RAX
LAB_0012b3de:
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x10],RCX
POP RBP
RET
|
void blst_pairing_init(int4 *param_1,int param_2,int4 *param_3,int8 param_4)
{
int4 uVar1;
int4 *local_30;
uVar1 = 0;
if (param_2 != 0) {
uVar1 = 0x40;
}
*param_1 = uVar1;
param_1[1] = 0;
local_30 = param_3;
if (param_3 == param_1 + 0x31e) {
local_30 = (int4 *)0x2a;
}
*(int4 **)(param_1 + 2) = local_30;
*(int8 *)(param_1 + 4) = param_4;
return;
}
| |
43,530 | translog_flush_set_new_goal_and_wait | eloqsql/storage/maria/ma_loghandler.c | void translog_flush_set_new_goal_and_wait(TRANSLOG_ADDRESS lsn)
{
int flush_no= log_descriptor.flush_no;
DBUG_ENTER("translog_flush_set_new_goal_and_wait");
DBUG_PRINT("enter", ("LSN: " LSN_FMT, LSN_IN_PARTS(lsn)));
mysql_mutex_assert_owner(&log_descriptor.log_flush_lock);
if (cmp_translog_addr(lsn, log_descriptor.next_pass_max_lsn) > 0)
{
log_descriptor.next_pass_max_lsn= lsn;
log_descriptor.max_lsn_requester= pthread_self();
mysql_cond_broadcast(&log_descriptor.new_goal_cond);
}
while (flush_no == log_descriptor.flush_no)
{
mysql_cond_wait(&log_descriptor.log_flush_cond,
&log_descriptor.log_flush_lock);
}
DBUG_VOID_RETURN;
} | O0 | c | translog_flush_set_new_goal_and_wait:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl 0xc242a2(%rip), %eax # 0xc7b534
movl %eax, -0xc(%rbp)
jmp 0x57297
jmp 0x57299
jmp 0x5729b
movq -0x8(%rbp), %rax
subq 0xc24292(%rip), %rax # 0xc7b538
cmpq $0x0, %rax
jle 0x572d6
movq -0x8(%rbp), %rax
movq %rax, 0xc24281(%rip) # 0xc7b538
callq 0x2a540
movq %rax, 0xc2427d(%rip) # 0xc7b540
leaq 0x423396(%rip), %rdi # 0x47a660
addq $0x800d88, %rdi # imm = 0x800D88
callq 0x57320
jmp 0x572d8
movl -0xc(%rbp), %eax
movl 0xc24253(%rip), %ecx # 0xc7b534
cmpl %ecx, %eax
jne 0x57310
leaq 0x423374(%rip), %rsi # 0x47a660
movq %rsi, %rdi
addq $0x800d50, %rdi # imm = 0x800D50
addq $0x800d08, %rsi # imm = 0x800D08
leaq 0xfbcb5(%rip), %rdx # 0x152fb9
movl $0x1eac, %ecx # imm = 0x1EAC
callq 0x51400
jmp 0x572d8
jmp 0x57312
jmp 0x57314
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| translog_flush_set_new_goal_and_wait:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov eax, cs:dword_C7B534
mov [rbp+var_C], eax
jmp short $+2
loc_57297:
jmp short $+2
loc_57299:
jmp short $+2
loc_5729B:
mov rax, [rbp+var_8]
sub rax, cs:qword_C7B538
cmp rax, 0
jle short loc_572D6
mov rax, [rbp+var_8]
mov cs:qword_C7B538, rax
call _pthread_self
mov cs:qword_C7B540, rax
lea rdi, log_descriptor
add rdi, 800D88h
call inline_mysql_cond_broadcast_0
loc_572D6:
jmp short $+2
loc_572D8:
mov eax, [rbp+var_C]
mov ecx, cs:dword_C7B534
cmp eax, ecx
jnz short loc_57310
lea rsi, log_descriptor
mov rdi, rsi
add rdi, 800D50h
add rsi, 800D08h
lea rdx, aWorkspaceLlm4b_11; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 1EACh
call inline_mysql_cond_wait_1
jmp short loc_572D8
loc_57310:
jmp short $+2
loc_57312:
jmp short $+2
loc_57314:
add rsp, 10h
pop rbp
retn
| long long translog_flush_set_new_goal_and_wait(long long a1)
{
long long result; // rax
unsigned int v2; // [rsp+4h] [rbp-Ch]
v2 = dword_C7B534;
if ( a1 - qword_C7B538 > 0 )
{
qword_C7B538 = a1;
qword_C7B540 = pthread_self();
inline_mysql_cond_broadcast_0(&log_descriptor[1049009]);
}
while ( 1 )
{
result = v2;
if ( v2 != dword_C7B534 )
break;
inline_mysql_cond_wait_1(
(long long)&log_descriptor[1049002],
(long long)&log_descriptor[1048993],
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
0x1EACu);
}
return result;
}
| translog_flush_set_new_goal_and_wait:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV EAX,dword ptr [0x00d7b534]
MOV dword ptr [RBP + -0xc],EAX
JMP 0x00157297
LAB_00157297:
JMP 0x00157299
LAB_00157299:
JMP 0x0015729b
LAB_0015729b:
MOV RAX,qword ptr [RBP + -0x8]
SUB RAX,qword ptr [0x00d7b538]
CMP RAX,0x0
JLE 0x001572d6
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [0x00d7b538],RAX
CALL 0x0012a540
MOV qword ptr [0x00d7b540],RAX
LEA RDI,[0x57a660]
ADD RDI,0x800d88
CALL 0x00157320
LAB_001572d6:
JMP 0x001572d8
LAB_001572d8:
MOV EAX,dword ptr [RBP + -0xc]
MOV ECX,dword ptr [0x00d7b534]
CMP EAX,ECX
JNZ 0x00157310
LEA RSI,[0x57a660]
MOV RDI,RSI
ADD RDI,0x800d50
ADD RSI,0x800d08
LEA RDX,[0x252fb9]
MOV ECX,0x1eac
CALL 0x00151400
JMP 0x001572d8
LAB_00157310:
JMP 0x00157312
LAB_00157312:
JMP 0x00157314
LAB_00157314:
ADD RSP,0x10
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void translog_flush_set_new_goal_and_wait(long param_1)
{
int iVar1;
iVar1 = _DAT_00d7b534;
if (0 < param_1 - _DAT_00d7b538) {
_DAT_00d7b538 = param_1;
_DAT_00d7b540 = pthread_self();
inline_mysql_cond_broadcast(&DAT_00d7b3e8);
}
while (iVar1 == _DAT_00d7b534) {
inline_mysql_cond_wait
(&DAT_00d7b3b0,&DAT_00d7b368,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",0x1eac);
}
return;
}
| |
43,531 | arena_alloc_aligned | tsotchke[P]eshkol/src/core/memory/arena.c | void* arena_alloc_aligned(Arena* arena, size_t size, size_t alignment) {
assert(arena != NULL);
// Add debug output for zero-sized allocations
if (size == 0) {
fprintf(stderr, "ERROR: Attempted to allocate 0 bytes in arena_alloc_aligned\n");
// Print stack trace if possible
void* buffer[100];
int nptrs = backtrace(buffer, 100);
backtrace_symbols_fd(buffer, nptrs, STDERR_FILENO);
// Continue with a minimum size of 1 instead of failing
size = 1;
}
assert(alignment > 0 && (alignment & (alignment - 1)) == 0); // Power of 2
// Try to allocate from current block
void* result = arena_alloc_from_block(arena, arena->current, size, alignment);
if (result) return result;
// Need a new block
size_t min_size = size + alignment - 1; // Ensure enough space for alignment
Block* block = arena_add_block(arena, min_size);
if (!block) return NULL;
// Allocate from the new block
result = arena_alloc_from_block(arena, block, size, alignment);
assert(result != NULL); // Should always succeed
return result;
} | O0 | c | arena_alloc_aligned:
pushq %rbp
movq %rsp, %rbp
subq $0x360, %rsp # imm = 0x360
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4100
jmp 0x411f
leaq 0x33b9(%rip), %rdi # 0x74c0
leaq 0x398e(%rip), %rsi # 0x7a9c
movl $0x8b, %edx
leaq 0x39d4(%rip), %rcx # 0x7aee
callq 0x2170
cmpq $0x0, -0x18(%rbp)
jne 0x4174
movq 0x5ec3(%rip), %rax # 0x9ff0
movq (%rax), %rdi
leaq 0x39ea(%rip), %rsi # 0x7b21
movb $0x0, %al
callq 0x21e0
leaq -0x340(%rbp), %rdi
movl $0x64, %esi
callq 0x2110
movl %eax, -0x344(%rbp)
leaq -0x340(%rbp), %rdi
movl -0x344(%rbp), %esi
movl $0x2, %edx
callq 0x2050
movq $0x1, -0x18(%rbp)
cmpq $0x0, -0x20(%rbp)
jbe 0x4192
movq -0x20(%rbp), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
jne 0x4192
jmp 0x41b1
leaq 0x39c5(%rip), %rdi # 0x7b5e
leaq 0x38fc(%rip), %rsi # 0x7a9c
movl $0x98, %edx
leaq 0x3942(%rip), %rcx # 0x7aee
callq 0x2170
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x4290
movq %rax, -0x350(%rbp)
cmpq $0x0, -0x350(%rbp)
je 0x41ea
movq -0x350(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x427d
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x358(%rbp)
movq -0x10(%rbp), %rdi
movq -0x358(%rbp), %rsi
callq 0x4410
movq %rax, -0x360(%rbp)
cmpq $0x0, -0x360(%rbp)
jne 0x4228
movq $0x0, -0x8(%rbp)
jmp 0x427d
movq -0x10(%rbp), %rdi
movq -0x360(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x4290
movq %rax, -0x350(%rbp)
cmpq $0x0, -0x350(%rbp)
je 0x4253
jmp 0x4272
leaq 0x3938(%rip), %rdi # 0x7b92
leaq 0x383b(%rip), %rsi # 0x7a9c
movl $0xa5, %edx
leaq 0x3881(%rip), %rcx # 0x7aee
callq 0x2170
movq -0x350(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x360, %rsp # imm = 0x360
popq %rbp
retq
nopw (%rax,%rax)
| arena_alloc_aligned:
push rbp
mov rbp, rsp
sub rsp, 360h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
cmp [rbp+var_10], 0
jz short loc_4100
jmp short loc_411F
loc_4100:
lea rdi, aArenaNull; "arena != NULL"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov edx, 8Bh
lea rcx, aVoidArenaAlloc; "void *arena_alloc_aligned(Arena *, size"...
call ___assert_fail
loc_411F:
cmp [rbp+var_18], 0
jnz short loc_4174
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aErrorAttempted; "ERROR: Attempted to allocate 0 bytes in"...
mov al, 0
call _fprintf
lea rdi, [rbp+var_340]
mov esi, 64h ; 'd'
call _backtrace
mov [rbp+var_344], eax
lea rdi, [rbp+var_340]
mov esi, [rbp+var_344]
mov edx, 2
call _backtrace_symbols_fd
mov [rbp+var_18], 1
loc_4174:
cmp [rbp+var_20], 0
jbe short loc_4192
mov rax, [rbp+var_20]
mov rcx, [rbp+var_20]
sub rcx, 1
and rax, rcx
cmp rax, 0
jnz short loc_4192
jmp short loc_41B1
loc_4192:
lea rdi, aAlignment0Alig; "alignment > 0 && (alignment & (alignmen"...
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov edx, 98h
lea rcx, aVoidArenaAlloc; "void *arena_alloc_aligned(Arena *, size"...
call ___assert_fail
loc_41B1:
mov rdi, [rbp+var_10]
mov rax, [rbp+var_10]
mov rsi, [rax]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
call arena_alloc_from_block
mov [rbp+var_350], rax
cmp [rbp+var_350], 0
jz short loc_41EA
mov rax, [rbp+var_350]
mov [rbp+var_8], rax
jmp loc_427D
loc_41EA:
mov rax, [rbp+var_18]
add rax, [rbp+var_20]
sub rax, 1
mov [rbp+var_358], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_358]
call arena_add_block
mov [rbp+var_360], rax
cmp [rbp+var_360], 0
jnz short loc_4228
mov [rbp+var_8], 0
jmp short loc_427D
loc_4228:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_360]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
call arena_alloc_from_block
mov [rbp+var_350], rax
cmp [rbp+var_350], 0
jz short loc_4253
jmp short loc_4272
loc_4253:
lea rdi, aResultNull; "result != NULL"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov edx, 0A5h
lea rcx, aVoidArenaAlloc; "void *arena_alloc_aligned(Arena *, size"...
call ___assert_fail
loc_4272:
mov rax, [rbp+var_350]
mov [rbp+var_8], rax
loc_427D:
mov rax, [rbp+var_8]
add rsp, 360h
pop rbp
retn
| long long arena_alloc_aligned(_QWORD *a1, long long a2, long long a3)
{
long long v4; // [rsp+0h] [rbp-360h]
long long v5; // [rsp+10h] [rbp-350h]
long long v6; // [rsp+10h] [rbp-350h]
unsigned int v7; // [rsp+1Ch] [rbp-344h]
_BYTE v8[800]; // [rsp+20h] [rbp-340h] BYREF
long long v9; // [rsp+340h] [rbp-20h]
long long v10; // [rsp+348h] [rbp-18h]
_QWORD *v11; // [rsp+350h] [rbp-10h]
v11 = a1;
v10 = a2;
v9 = a3;
if ( !a1 )
__assert_fail(
"arena != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/core/memory/arena.c",
139LL,
"void *arena_alloc_aligned(Arena *, size_t, size_t)");
if ( !v10 )
{
fprintf(stderr, "ERROR: Attempted to allocate 0 bytes in arena_alloc_aligned\n");
v7 = backtrace(v8, 100LL);
backtrace_symbols_fd(v8, v7, 2LL);
v10 = 1LL;
}
if ( !v9 || ((v9 - 1) & v9) != 0 )
__assert_fail(
"alignment > 0 && (alignment & (alignment - 1)) == 0",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/core/memory/arena.c",
152LL,
"void *arena_alloc_aligned(Arena *, size_t, size_t)");
v5 = arena_alloc_from_block(v11, *v11, v10, v9);
if ( v5 )
return v5;
v4 = arena_add_block(v11, v9 + v10 - 1);
if ( !v4 )
return 0LL;
v6 = arena_alloc_from_block(v11, v4, v10, v9);
if ( !v6 )
__assert_fail(
"result != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/core/memory/arena.c",
165LL,
"void *arena_alloc_aligned(Arena *, size_t, size_t)");
return v6;
}
| arena_alloc_aligned:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x360
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
CMP qword ptr [RBP + -0x10],0x0
JZ 0x00104100
JMP 0x0010411f
LAB_00104100:
LEA RDI,[0x1074ae]
LEA RSI,[0x107a8a]
MOV EDX,0x8b
LEA RCX,[0x107aca]
CALL 0x00102170
LAB_0010411f:
CMP qword ptr [RBP + -0x18],0x0
JNZ 0x00104174
MOV RAX,qword ptr [0x00109ff0]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x107afd]
MOV AL,0x0
CALL 0x001021e0
LEA RDI,[RBP + -0x340]
MOV ESI,0x64
CALL 0x00102110
MOV dword ptr [RBP + -0x344],EAX
LEA RDI,[RBP + -0x340]
MOV ESI,dword ptr [RBP + -0x344]
MOV EDX,0x2
CALL 0x00102050
MOV qword ptr [RBP + -0x18],0x1
LAB_00104174:
CMP qword ptr [RBP + -0x20],0x0
JBE 0x00104192
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x20]
SUB RCX,0x1
AND RAX,RCX
CMP RAX,0x0
JNZ 0x00104192
JMP 0x001041b1
LAB_00104192:
LEA RDI,[0x107b3a]
LEA RSI,[0x107a8a]
MOV EDX,0x98
LEA RCX,[0x107aca]
CALL 0x00102170
LAB_001041b1:
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
CALL 0x00104290
MOV qword ptr [RBP + -0x350],RAX
CMP qword ptr [RBP + -0x350],0x0
JZ 0x001041ea
MOV RAX,qword ptr [RBP + -0x350]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0010427d
LAB_001041ea:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,qword ptr [RBP + -0x20]
SUB RAX,0x1
MOV qword ptr [RBP + -0x358],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x358]
CALL 0x00104410
MOV qword ptr [RBP + -0x360],RAX
CMP qword ptr [RBP + -0x360],0x0
JNZ 0x00104228
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0010427d
LAB_00104228:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x360]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
CALL 0x00104290
MOV qword ptr [RBP + -0x350],RAX
CMP qword ptr [RBP + -0x350],0x0
JZ 0x00104253
JMP 0x00104272
LAB_00104253:
LEA RDI,[0x107b6e]
LEA RSI,[0x107a8a]
MOV EDX,0xa5
LEA RCX,[0x107aca]
CALL 0x00102170
LAB_00104272:
MOV RAX,qword ptr [RBP + -0x350]
MOV qword ptr [RBP + -0x8],RAX
LAB_0010427d:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x360
POP RBP
RET
|
long arena_alloc_aligned(int8 *param_1,long param_2,ulong param_3)
{
int4 uVar1;
long lVar2;
int1 local_348 [800];
ulong local_28;
long local_20;
int8 *local_18;
long local_10;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
if (param_1 == (int8 *)0x0) {
/* WARNING: Subroutine does not return */
__assert_fail("arena != NULL","/workspace/llm4binary/github2025/eshkol/src/core/memory/arena.c",
0x8b,"void *arena_alloc_aligned(Arena *, size_t, size_t)");
}
if (param_2 == 0) {
fprintf(*(FILE **)PTR_stderr_00109ff0,
"ERROR: Attempted to allocate 0 bytes in arena_alloc_aligned\n");
uVar1 = backtrace(local_348,100);
backtrace_symbols_fd(local_348,uVar1,2);
local_20 = 1;
}
if ((local_28 != 0) && ((local_28 & local_28 - 1) == 0)) {
local_10 = arena_alloc_from_block(local_18,*local_18,local_20,local_28);
if (local_10 == 0) {
lVar2 = arena_add_block(local_18,local_20 + local_28 + -1);
if (lVar2 == 0) {
local_10 = 0;
}
else {
local_10 = arena_alloc_from_block(local_18,lVar2,local_20,local_28);
if (local_10 == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("result != NULL",
"/workspace/llm4binary/github2025/eshkol/src/core/memory/arena.c",0xa5,
"void *arena_alloc_aligned(Arena *, size_t, size_t)");
}
}
}
return local_10;
}
/* WARNING: Subroutine does not return */
__assert_fail("alignment > 0 && (alignment & (alignment - 1)) == 0",
"/workspace/llm4binary/github2025/eshkol/src/core/memory/arena.c",0x98,
"void *arena_alloc_aligned(Arena *, size_t, size_t)");
}
| |
43,532 | rpl_slave_state::free_gtid_pos_tables(rpl_slave_state::gtid_pos_table*) | eloqsql/sql/rpl_gtid.cc | void
rpl_slave_state::free_gtid_pos_tables(struct rpl_slave_state::gtid_pos_table *list)
{
struct gtid_pos_table *cur, *next;
cur= list;
while (cur)
{
next= cur->next;
my_free(cur);
cur= next;
}
} | O0 | cpp | rpl_slave_state::free_gtid_pos_tables(rpl_slave_state::gtid_pos_table*):
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xbcfc1d
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1324630
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xbcfbf8
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZN15rpl_slave_state20free_gtid_pos_tablesEPNS_14gtid_pos_tableE:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
mov [rbp+var_18], rax
loc_BCFBF8:
cmp [rbp+var_18], 0
jz short loc_BCFC1D
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rbp+var_20], rax
mov rdi, [rbp+var_18]
call my_free
mov rax, [rbp+var_20]
mov [rbp+var_18], rax
jmp short loc_BCFBF8
loc_BCFC1D:
add rsp, 20h
pop rbp
retn
| _QWORD * rpl_slave_state::free_gtid_pos_tables(long long a1, _QWORD *a2)
{
_QWORD *result; // rax
_QWORD *v3; // [rsp+0h] [rbp-20h]
_QWORD *i; // [rsp+8h] [rbp-18h]
result = a2;
for ( i = a2; i; i = v3 )
{
v3 = (_QWORD *)*i;
my_free(i);
result = v3;
}
return result;
}
| remove:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x009cef60
ADD RSP,0x10
POP RBP
RET
|
/* List_iterator<Create_field>::remove() */
void __thiscall List_iterator<Create_field>::remove(List_iterator<Create_field> *this)
{
base_list_iterator::remove((base_list_iterator *)this);
return;
}
| |
43,533 | js_os_pipe | bluesky950520[P]quickjs/quickjs-libc.c | static JSValue js_os_pipe(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
int pipe_fds[2], ret;
JSValue obj;
ret = pipe(pipe_fds);
if (ret < 0)
return JS_NULL;
obj = JS_NewArray(ctx);
if (JS_IsException(obj))
return obj;
JS_DefinePropertyValueUint32(ctx, obj, 0, JS_NewInt32(ctx, pipe_fds[0]),
JS_PROP_C_W_E);
JS_DefinePropertyValueUint32(ctx, obj, 1, JS_NewInt32(ctx, pipe_fds[1]),
JS_PROP_C_W_E);
return obj;
} | O2 | c | js_os_pipe:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r15
leaq 0x8(%rsp), %rdi
callq 0xe3d0
testl %eax, %eax
js 0x1562e
movabsq $-0x100000000, %r12 # imm = 0xFFFFFFFF00000000
movq %r15, %rdi
callq 0x1b2bb
movq %rax, %r14
movq %rdx, %rbx
cmpl $0x6, %ebx
je 0x15626
movl 0x8(%rsp), %r8d
pushq $0x7
popq %rbp
movl %ebp, (%rsp)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
xorl %r9d, %r9d
callq 0x20972
movl 0xc(%rsp), %r8d
movl %ebp, (%rsp)
pushq $0x1
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %r9d, %r9d
callq 0x20972
movq %r14, %rcx
andq %r12, %rcx
jmp 0x15636
pushq $0x2
popq %rbx
xorl %r14d, %r14d
xorl %ecx, %ecx
movl %r14d, %eax
orq %rcx, %rax
movq %rbx, %rdx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| js_os_pipe:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 10h
mov r15, rdi
lea rdi, [rsp+38h+var_30]
call _pipe
test eax, eax
js short loc_1562E
mov r12, 0FFFFFFFF00000000h
mov rdi, r15
call JS_NewArray
mov r14, rax
mov rbx, rdx
cmp ebx, 6
jz short loc_15626
mov r8d, [rsp+38h+var_30]
push 7
pop rbp
mov [rsp+38h+var_38], ebp
mov rdi, r15
mov rsi, r14
mov rdx, rbx
xor ecx, ecx
xor r9d, r9d
call JS_DefinePropertyValueUint32
mov r8d, [rsp+38h+var_2C]
mov [rsp+38h+var_38], ebp
push 1
pop rcx
mov rdi, r15
mov rsi, r14
mov rdx, rbx
xor r9d, r9d
call JS_DefinePropertyValueUint32
loc_15626:
mov rcx, r14
and rcx, r12
jmp short loc_15636
loc_1562E:
push 2
pop rbx
xor r14d, r14d
xor ecx, ecx
loc_15636:
mov eax, r14d
or rax, rcx
mov rdx, rbx
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| unsigned long long js_os_pipe(long long a1)
{
long long v1; // rax
int v2; // edx
long long v3; // r14
int v4; // ebx
unsigned long long v5; // rcx
_DWORD v7[12]; // [rsp+8h] [rbp-30h] BYREF
if ( (int)pipe(v7) < 0 )
{
LODWORD(v3) = 0;
v5 = 0LL;
}
else
{
v1 = JS_NewArray(a1);
v3 = v1;
v4 = v2;
if ( v2 != 6 )
{
JS_DefinePropertyValueUint32(a1, v1, v2, 0, v7[0], 0, 7);
JS_DefinePropertyValueUint32(a1, v3, v4, 1, v7[1], 0, 7);
}
v5 = v3 & 0xFFFFFFFF00000000LL;
}
return v5 | (unsigned int)v3;
}
| js_os_pipe:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV R15,RDI
LEA RDI,[RSP + 0x8]
CALL 0x0010e3d0
TEST EAX,EAX
JS 0x0011562e
MOV R12,-0x100000000
MOV RDI,R15
CALL 0x0011b2bb
MOV R14,RAX
MOV RBX,RDX
CMP EBX,0x6
JZ 0x00115626
MOV R8D,dword ptr [RSP + 0x8]
PUSH 0x7
POP RBP
MOV dword ptr [RSP],EBP
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
XOR ECX,ECX
XOR R9D,R9D
CALL 0x00120972
MOV R8D,dword ptr [RSP + 0xc]
MOV dword ptr [RSP],EBP
PUSH 0x1
POP RCX
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
XOR R9D,R9D
CALL 0x00120972
LAB_00115626:
MOV RCX,R14
AND RCX,R12
JMP 0x00115636
LAB_0011562e:
PUSH 0x2
POP RBX
XOR R14D,R14D
XOR ECX,ECX
LAB_00115636:
MOV EAX,R14D
OR RAX,RCX
MOV RDX,RBX
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
int1 [16] js_os_pipe(int8 param_1)
{
int iVar1;
ulong uVar2;
int1 auVar3 [16];
int1 auVar4 [16];
int local_30;
int4 local_2c;
iVar1 = pipe(&local_30);
if (iVar1 < 0) {
auVar3 = ZEXT816(2) << 0x40;
uVar2 = 0;
}
else {
auVar3 = JS_NewArray(param_1);
uVar2 = auVar3._0_8_;
if (auVar3._8_4_ != 6) {
JS_DefinePropertyValueUint32(param_1,uVar2,auVar3._8_8_,0,local_30,0,7);
JS_DefinePropertyValueUint32(param_1,uVar2,auVar3._8_8_,1,local_2c,0,7);
}
uVar2 = uVar2 & 0xffffffff00000000;
}
auVar4._0_8_ = auVar3._0_8_ & 0xffffffff | uVar2;
auVar4._8_8_ = auVar3._8_8_;
return auVar4;
}
| |
43,534 | ma_hashtbl_search | eloqsql/libmariadb/libmariadb/ma_hashtbl.c | void* ma_hashtbl_search(MA_HASHTBL *hash,const uchar *key,uint length)
{
MA_HASHTBL_LINK *pos;
uint flag,idx;
flag=1;
if (hash->records)
{
idx=hash_mask((*hash->calc_hashnr)(key,length ? length :
hash->key_length),
hash->blength,hash->records);
do
{
pos= dynamic_element(&hash->array,idx,MA_HASHTBL_LINK*);
if (!hashcmp(hash,pos,key,length))
{
hash->current_record= idx;
return (pos->data);
}
if (flag)
{
flag=0; /* Reset flag */
if (hash_rec_mask(hash,pos,hash->blength,hash->records) != idx)
break; /* Wrong link */
}
}
while ((idx=pos->next) != NO_RECORD);
}
hash->current_record= NO_RECORD;
return(0);
} | O3 | c | ma_hashtbl_search:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, -0x30(%rbp)
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
je 0x8dd50
movl %edx, %r14d
movq 0x40(%rbx), %rax
movl %edx, %esi
testl %edx, %edx
jne 0x8dcdb
movl 0x4(%rbx), %esi
movq -0x30(%rbp), %rdi
callq *%rax
movl 0xc(%rbx), %r12d
leal -0x1(%r12), %ecx
andl %eax, %ecx
shrl %r12d
decl %r12d
andl %eax, %r12d
cmpl 0x8(%rbx), %ecx
cmovbl %ecx, %r12d
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
movl %r12d, %ecx
shlq $0x4, %rcx
leaq (%rax,%rcx), %r13
movq 0x8(%rax,%rcx), %rsi
movq %rbx, %rdi
movq -0x30(%rbp), %rdx
movl %r14d, %ecx
callq 0x8dd72
testl %eax, %eax
je 0x8dd5b
testb $0x1, %r15b
jne 0x8dd43
movl 0x8(%rbx), %ecx
movl 0xc(%rbx), %edx
movq 0x8(%r13), %rsi
movq %rbx, %rdi
callq 0x8dde8
cmpl %r12d, %eax
jne 0x8dd50
movl (%r13), %r12d
movb $0x1, %r15b
cmpl $-0x1, %r12d
jne 0x8dcff
movl $0xffffffff, 0x10(%rbx) # imm = 0xFFFFFFFF
xorl %eax, %eax
jmp 0x8dd63
movl %r12d, 0x10(%rbx)
movq 0x8(%r13), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| ma_hashtbl_search:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov [rbp+var_30], rsi
mov rbx, rdi
cmp dword ptr [rdi+8], 0
jz loc_8DD50
mov r14d, edx
mov rax, [rbx+40h]
mov esi, edx
test edx, edx
jnz short loc_8DCDB
mov esi, [rbx+4]
loc_8DCDB:
mov rdi, [rbp+var_30]
call rax
mov r12d, [rbx+0Ch]
lea ecx, [r12-1]
and ecx, eax
shr r12d, 1
dec r12d
and r12d, eax
cmp ecx, [rbx+8]
cmovb r12d, ecx
xor r15d, r15d
loc_8DCFF:
mov rax, [rbx+18h]
mov ecx, r12d
shl rcx, 4
lea r13, [rax+rcx]
mov rsi, [rax+rcx+8]
mov rdi, rbx
mov rdx, [rbp+var_30]
mov ecx, r14d
call hashcmp
test eax, eax
jz short loc_8DD5B
test r15b, 1
jnz short loc_8DD43
mov ecx, [rbx+8]
mov edx, [rbx+0Ch]
mov rsi, [r13+8]
mov rdi, rbx
call hash_rec_mask
cmp eax, r12d
jnz short loc_8DD50
loc_8DD43:
mov r12d, [r13+0]
mov r15b, 1
cmp r12d, 0FFFFFFFFh
jnz short loc_8DCFF
loc_8DD50:
mov dword ptr [rbx+10h], 0FFFFFFFFh
xor eax, eax
jmp short loc_8DD63
loc_8DD5B:
mov [rbx+10h], r12d
mov rax, [r13+8]
loc_8DD63:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ma_hashtbl_search(long long a1, long long a2, unsigned int a3)
{
long long v4; // rsi
int v5; // eax
unsigned int v6; // r12d
unsigned int v7; // ecx
unsigned int v8; // r12d
char v9; // r15
long long v10; // r13
if ( *(_DWORD *)(a1 + 8) )
{
v4 = a3;
if ( !a3 )
v4 = *(unsigned int *)(a1 + 4);
v5 = (*(long long ( **)(long long, long long))(a1 + 64))(a2, v4);
v6 = *(_DWORD *)(a1 + 12);
v7 = v5 & (v6 - 1);
v8 = v5 & ((v6 >> 1) - 1);
if ( v7 < *(_DWORD *)(a1 + 8) )
v8 = v7;
v9 = 0;
while ( 1 )
{
v10 = *(_QWORD *)(a1 + 24) + 16LL * v8;
if ( !(unsigned int)hashcmp(a1, *(_QWORD *)(v10 + 8), a2, a3) )
break;
if ( (v9 & 1) != 0
|| (unsigned int)hash_rec_mask(a1, *(_QWORD *)(v10 + 8), *(unsigned int *)(a1 + 12), *(unsigned int *)(a1 + 8)) == v8 )
{
v8 = *(_DWORD *)v10;
v9 = 1;
if ( *(_DWORD *)v10 != -1 )
continue;
}
goto LABEL_11;
}
*(_DWORD *)(a1 + 16) = v8;
return *(_QWORD *)(v10 + 8);
}
else
{
LABEL_11:
*(_DWORD *)(a1 + 16) = -1;
return 0LL;
}
}
| ma_hashtbl_search:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV qword ptr [RBP + -0x30],RSI
MOV RBX,RDI
CMP dword ptr [RDI + 0x8],0x0
JZ 0x0018dd50
MOV R14D,EDX
MOV RAX,qword ptr [RBX + 0x40]
MOV ESI,EDX
TEST EDX,EDX
JNZ 0x0018dcdb
MOV ESI,dword ptr [RBX + 0x4]
LAB_0018dcdb:
MOV RDI,qword ptr [RBP + -0x30]
CALL RAX
MOV R12D,dword ptr [RBX + 0xc]
LEA ECX,[R12 + -0x1]
AND ECX,EAX
SHR R12D,0x1
DEC R12D
AND R12D,EAX
CMP ECX,dword ptr [RBX + 0x8]
CMOVC R12D,ECX
XOR R15D,R15D
LAB_0018dcff:
MOV RAX,qword ptr [RBX + 0x18]
MOV ECX,R12D
SHL RCX,0x4
LEA R13,[RAX + RCX*0x1]
MOV RSI,qword ptr [RAX + RCX*0x1 + 0x8]
MOV RDI,RBX
MOV RDX,qword ptr [RBP + -0x30]
MOV ECX,R14D
CALL 0x0018dd72
TEST EAX,EAX
JZ 0x0018dd5b
TEST R15B,0x1
JNZ 0x0018dd43
MOV ECX,dword ptr [RBX + 0x8]
MOV EDX,dword ptr [RBX + 0xc]
MOV RSI,qword ptr [R13 + 0x8]
MOV RDI,RBX
CALL 0x0018dde8
CMP EAX,R12D
JNZ 0x0018dd50
LAB_0018dd43:
MOV R12D,dword ptr [R13]
MOV R15B,0x1
CMP R12D,-0x1
JNZ 0x0018dcff
LAB_0018dd50:
MOV dword ptr [RBX + 0x10],0xffffffff
XOR EAX,EAX
JMP 0x0018dd63
LAB_0018dd5b:
MOV dword ptr [RBX + 0x10],R12D
MOV RAX,qword ptr [R13 + 0x8]
LAB_0018dd63:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 ma_hashtbl_search(long param_1,int8 param_2,int param_3)
{
uint *puVar1;
uint uVar2;
int iVar3;
uint uVar4;
bool bVar5;
if (*(int *)(param_1 + 8) != 0) {
iVar3 = param_3;
if (param_3 == 0) {
iVar3 = *(int *)(param_1 + 4);
}
uVar2 = (**(code **)(param_1 + 0x40))(param_2,iVar3);
uVar4 = *(uint *)(param_1 + 0xc) - 1 & uVar2;
uVar2 = (*(uint *)(param_1 + 0xc) >> 1) - 1 & uVar2;
if (uVar4 < *(uint *)(param_1 + 8)) {
uVar2 = uVar4;
}
bVar5 = false;
do {
puVar1 = (uint *)(*(long *)(param_1 + 0x18) + (ulong)uVar2 * 0x10);
iVar3 = hashcmp(param_1,*(int8 *)(*(long *)(param_1 + 0x18) + 8 + (ulong)uVar2 * 0x10),
param_2,param_3);
if (iVar3 == 0) {
*(uint *)(param_1 + 0x10) = uVar2;
return *(int8 *)(puVar1 + 2);
}
if ((!bVar5) &&
(uVar4 = hash_rec_mask(param_1,*(int8 *)(puVar1 + 2),*(int4 *)(param_1 + 0xc),
*(int4 *)(param_1 + 8)), uVar4 != uVar2)) break;
uVar2 = *puVar1;
bVar5 = true;
} while (uVar2 != 0xffffffff);
}
*(int4 *)(param_1 + 0x10) = 0xffffffff;
return 0;
}
| |
43,535 | str2int | eloqsql/strings/str2int.c | char *str2int(register const char *src, register int radix, long int lower,
long int upper, long int *val)
{
int sign; /* is number negative (+1) or positive (-1) */
int n; /* number of digits yet to be converted */
long limit; /* "largest" possible valid input */
long scale; /* the amount to multiply next digit by */
long sofar; /* the running value */
register int d; /* (negative of) next digit */
char *start;
int digits[32]; /* Room for numbers */
/* Make sure *val is sensible in case of error */
*val = 0;
/* Check that the radix is in the range 2..36 */
#ifndef DBUG_OFF
if (radix < 2 || radix > 36) {
errno=EDOM;
return NullS;
}
#endif
/* The basic problem is: how do we handle the conversion of
a number without resorting to machine-specific code to
check for overflow? Obviously, we have to ensure that
no calculation can overflow. We are guaranteed that the
"lower" and "upper" arguments are valid machine integers.
On sign-and-magnitude, twos-complement, and ones-complement
machines all, if +|n| is representable, so is -|n|, but on
twos complement machines the converse is not true. So the
"maximum" representable number has a negative representative.
Limit is set to MY_MIN(-|lower|,-|upper|); this is the "largest"
number we are concerned with. */
/* Calculate Limit using Scale as a scratch variable */
if ((limit = lower) > 0) limit = -limit;
if ((scale = upper) > 0) scale = -scale;
if (scale < limit) limit = scale;
/* Skip leading spaces and check for a sign.
Note: because on a 2s complement machine MinLong is a valid
integer but |MinLong| is not, we have to keep the current
converted value (and the scale!) as *negative* numbers,
so the sign is the opposite of what you might expect.
*/
while (my_isspace(&my_charset_latin1,*src)) src++;
sign = -1;
if (*src == '+') src++; else
if (*src == '-') src++, sign = 1;
/* Skip leading zeros so that we never compute a power of radix
in scale that we won't have a need for. Otherwise sticking
enough 0s in front of a number could cause the multiplication
to overflow when it neededn't.
*/
start=(char*) src;
while (*src == '0') src++;
/* Move over the remaining digits. We have to convert from left
to left in order to avoid overflow. Answer is after last digit.
*/
for (n = 0; (digits[n]=char_val(*src)) < radix && n < 20; n++,src++) ;
/* Check that there is at least one digit */
if (start == src) {
errno=EDOM;
return NullS;
}
/* The invariant we want to maintain is that src is just
to the right of n digits, we've converted k digits to
sofar, scale = -radix**k, and scale < sofar < 0. Now
if the final number is to be within the original
Limit, we must have (to the left)*scale+sofar >= Limit,
or (to the left)*scale >= Limit-sofar, i.e. the digits
to the left of src must form an integer <= (Limit-sofar)/(scale).
In particular, this is true of the next digit. In our
incremental calculation of Limit,
IT IS VITAL that (-|N|)/(-|D|) = |N|/|D|
*/
for (sofar = 0, scale = -1; --n >= 1;)
{
if ((long) -(d=digits[n]) < limit) {
errno=ERANGE;
return NullS;
}
limit = (limit+d)/radix, sofar += d*scale; scale *= radix;
}
if (n == 0)
{
if ((long) -(d=digits[n]) < limit) /* get last digit */
{
errno=ERANGE;
return NullS;
}
sofar+=d*scale;
}
/* Now it might still happen that sofar = -32768 or its equivalent,
so we can't just multiply by the sign and check that the result
is in the range lower..upper. All of this caution is a right
pain in the neck. If only there were a standard routine which
says generate thus and such a signal on integer overflow...
But not enough machines can do it *SIGH*.
*/
if (sign < 0)
{
if (sofar < -LONG_MAX || (sofar= -sofar) > upper)
{
errno=ERANGE;
return NullS;
}
}
else if (sofar < lower)
{
errno=ERANGE;
return NullS;
}
*val = sofar;
errno=0; /* indicate that all went well */
return (char*) src;
} | O0 | c | str2int:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jle 0x86021
xorl %eax, %eax
subq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
jle 0x86039
xorl %eax, %eax
subq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x40(%rbp), %rax
jge 0x8604b
movq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x8604d
leaq 0x266d5c(%rip), %rax # 0x2ecdb0
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
movzbl 0x1(%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x8607a
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x8604d
movl $0xffffffff, -0x34(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x8609b
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x860bc
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x860ba
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movl $0x1, -0x34(%rbp)
jmp 0x860bc
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0x860de
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x860c4
movl $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x8610f
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jg 0x8610f
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
subl $0x30, %eax
movl %eax, -0xe4(%rbp)
jmp 0x8618e
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x41, %eax
jl 0x8613c
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5a, %eax
jg 0x8613c
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
subl $0x41, %eax
addl $0xa, %eax
movl %eax, -0xe8(%rbp)
jmp 0x86182
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x61, %eax
jl 0x86169
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7a, %eax
jg 0x86169
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
subl $0x61, %eax
addl $0xa, %eax
movl %eax, -0xec(%rbp)
jmp 0x86176
movl $0x7f, %eax
movl %eax, -0xec(%rbp)
jmp 0x86176
movl -0xec(%rbp), %eax
movl %eax, -0xe8(%rbp)
movl -0xe8(%rbp), %eax
movl %eax, -0xe4(%rbp)
movl -0xe4(%rbp), %ecx
movslq -0x38(%rbp), %rax
movl %ecx, -0xe0(%rbp,%rax,4)
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0xed(%rbp)
jge 0x861b9
cmpl $0x14, -0x38(%rbp)
setl %al
movb %al, -0xed(%rbp)
movb -0xed(%rbp), %al
testb $0x1, %al
jne 0x861c5
jmp 0x861e1
jmp 0x861c7
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x860e5
movq -0x60(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x86203
callq 0x29040
movl $0x21, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x86350
movq $0x0, -0x50(%rbp)
movq $-0x1, -0x48(%rbp)
movl -0x38(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x38(%rbp)
cmpl $0x1, %eax
jl 0x8628b
movslq -0x38(%rbp), %rax
movl -0xe0(%rbp,%rax,4), %ecx
movl %ecx, -0x54(%rbp)
xorl %eax, %eax
subl %ecx, %eax
cltq
cmpq -0x40(%rbp), %rax
jge 0x86253
callq 0x29040
movl $0x22, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x86350
movq -0x40(%rbp), %rax
movslq -0x54(%rbp), %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
cqto
idivq %rcx
movq %rax, -0x40(%rbp)
movslq -0x54(%rbp), %rax
imulq -0x48(%rbp), %rax
addq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
movslq -0x14(%rbp), %rax
imulq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x86213
cmpl $0x0, -0x38(%rbp)
jne 0x862d4
movslq -0x38(%rbp), %rax
movl -0xe0(%rbp,%rax,4), %ecx
movl %ecx, -0x54(%rbp)
xorl %eax, %eax
subl %ecx, %eax
cltq
cmpq -0x40(%rbp), %rax
jge 0x862c3
callq 0x29040
movl $0x22, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x86350
movslq -0x54(%rbp), %rax
imulq -0x48(%rbp), %rax
addq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpl $0x0, -0x34(%rbp)
jge 0x86311
movabsq $-0x7fffffffffffffff, %rax # imm = 0x8000000000000001
cmpq %rax, -0x50(%rbp)
jl 0x862fa
xorl %eax, %eax
subq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq -0x28(%rbp), %rax
jle 0x8630f
callq 0x29040
movl $0x22, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x86350
jmp 0x86332
movq -0x50(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x86330
callq 0x29040
movl $0x22, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x86350
jmp 0x86332
movq -0x50(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
callq 0x29040
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax)
| str2int:
push rbp
mov rbp, rsp
sub rsp, 0F0h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov rax, [rbp+var_30]
mov qword ptr [rax], 0
mov rax, [rbp+var_20]
mov [rbp+var_40], rax
cmp rax, 0
jle short loc_86021
xor eax, eax
sub rax, [rbp+var_40]
mov [rbp+var_40], rax
loc_86021:
mov rax, [rbp+var_28]
mov [rbp+var_48], rax
cmp rax, 0
jle short loc_86039
xor eax, eax
sub rax, [rbp+var_48]
mov [rbp+var_48], rax
loc_86039:
mov rax, [rbp+var_48]
cmp rax, [rbp+var_40]
jge short loc_8604B
mov rax, [rbp+var_48]
mov [rbp+var_40], rax
loc_8604B:
jmp short $+2
loc_8604D:
lea rax, my_charset_latin1
mov rax, [rax+40h]
mov rcx, [rbp+var_10]
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx+1]
and eax, 8
cmp eax, 0
jz short loc_8607A
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp short loc_8604D
loc_8607A:
mov [rbp+var_34], 0FFFFFFFFh
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 2Bh ; '+'
jnz short loc_8609B
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp short loc_860BC
loc_8609B:
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 2Dh ; '-'
jnz short loc_860BA
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
mov [rbp+var_34], 1
loc_860BA:
jmp short $+2
loc_860BC:
mov rax, [rbp+var_10]
mov [rbp+var_60], rax
loc_860C4:
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 30h ; '0'
jnz short loc_860DE
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp short loc_860C4
loc_860DE:
mov [rbp+var_38], 0
loc_860E5:
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 30h ; '0'
jl short loc_8610F
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 39h ; '9'
jg short loc_8610F
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
sub eax, 30h ; '0'
mov [rbp+var_E4], eax
jmp short loc_8618E
loc_8610F:
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 41h ; 'A'
jl short loc_8613C
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 5Ah ; 'Z'
jg short loc_8613C
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
sub eax, 41h ; 'A'
add eax, 0Ah
mov [rbp+var_E8], eax
jmp short loc_86182
loc_8613C:
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 61h ; 'a'
jl short loc_86169
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 7Ah ; 'z'
jg short loc_86169
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
sub eax, 61h ; 'a'
add eax, 0Ah
mov [rbp+var_EC], eax
jmp short loc_86176
loc_86169:
mov eax, 7Fh
mov [rbp+var_EC], eax
jmp short $+2
loc_86176:
mov eax, [rbp+var_EC]
mov [rbp+var_E8], eax
loc_86182:
mov eax, [rbp+var_E8]
mov [rbp+var_E4], eax
loc_8618E:
mov ecx, [rbp+var_E4]
movsxd rax, [rbp+var_38]
mov [rbp+rax*4+var_E0], ecx
xor eax, eax
cmp ecx, [rbp+var_14]
mov [rbp+var_ED], al
jge short loc_861B9
cmp [rbp+var_38], 14h
setl al
mov [rbp+var_ED], al
loc_861B9:
mov al, [rbp+var_ED]
test al, 1
jnz short loc_861C5
jmp short loc_861E1
loc_861C5:
jmp short $+2
loc_861C7:
mov eax, [rbp+var_38]
add eax, 1
mov [rbp+var_38], eax
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp loc_860E5
loc_861E1:
mov rax, [rbp+var_60]
cmp rax, [rbp+var_10]
jnz short loc_86203
call ___errno_location
mov dword ptr [rax], 21h ; '!'
mov [rbp+var_8], 0
jmp loc_86350
loc_86203:
mov [rbp+var_50], 0
mov [rbp+var_48], 0FFFFFFFFFFFFFFFFh
loc_86213:
mov eax, [rbp+var_38]
add eax, 0FFFFFFFFh
mov [rbp+var_38], eax
cmp eax, 1
jl short loc_8628B
movsxd rax, [rbp+var_38]
mov ecx, [rbp+rax*4+var_E0]
mov [rbp+var_54], ecx
xor eax, eax
sub eax, ecx
cdqe
cmp rax, [rbp+var_40]
jge short loc_86253
call ___errno_location
mov dword ptr [rax], 22h ; '"'
mov [rbp+var_8], 0
jmp loc_86350
loc_86253:
mov rax, [rbp+var_40]
movsxd rcx, [rbp+var_54]
add rax, rcx
movsxd rcx, [rbp+var_14]
cqo
idiv rcx
mov [rbp+var_40], rax
movsxd rax, [rbp+var_54]
imul rax, [rbp+var_48]
add rax, [rbp+var_50]
mov [rbp+var_50], rax
movsxd rax, [rbp+var_14]
imul rax, [rbp+var_48]
mov [rbp+var_48], rax
jmp short loc_86213
loc_8628B:
cmp [rbp+var_38], 0
jnz short loc_862D4
movsxd rax, [rbp+var_38]
mov ecx, [rbp+rax*4+var_E0]
mov [rbp+var_54], ecx
xor eax, eax
sub eax, ecx
cdqe
cmp rax, [rbp+var_40]
jge short loc_862C3
call ___errno_location
mov dword ptr [rax], 22h ; '"'
mov [rbp+var_8], 0
jmp loc_86350
loc_862C3:
movsxd rax, [rbp+var_54]
imul rax, [rbp+var_48]
add rax, [rbp+var_50]
mov [rbp+var_50], rax
loc_862D4:
cmp [rbp+var_34], 0
jge short loc_86311
mov rax, 8000000000000001h
cmp [rbp+var_50], rax
jl short loc_862FA
xor eax, eax
sub rax, [rbp+var_50]
mov [rbp+var_50], rax
cmp rax, [rbp+var_28]
jle short loc_8630F
loc_862FA:
call ___errno_location
mov dword ptr [rax], 22h ; '"'
mov [rbp+var_8], 0
jmp short loc_86350
loc_8630F:
jmp short loc_86332
loc_86311:
mov rax, [rbp+var_50]
cmp rax, [rbp+var_20]
jge short loc_86330
call ___errno_location
mov dword ptr [rax], 22h ; '"'
mov [rbp+var_8], 0
jmp short loc_86350
loc_86330:
jmp short $+2
loc_86332:
mov rcx, [rbp+var_50]
mov rax, [rbp+var_30]
mov [rax], rcx
call ___errno_location
mov dword ptr [rax], 0
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
loc_86350:
mov rax, [rbp+var_8]
add rsp, 0F0h
pop rbp
retn
| _BYTE * str2int(_BYTE *a1, int a2, long long a3, long long a4, long long *a5)
{
bool v6; // [rsp+3h] [rbp-EDh]
int v7; // [rsp+4h] [rbp-ECh]
int v8; // [rsp+8h] [rbp-E8h]
int v9; // [rsp+Ch] [rbp-E4h]
_DWORD v10[32]; // [rsp+10h] [rbp-E0h]
_BYTE *v11; // [rsp+90h] [rbp-60h]
int v12; // [rsp+9Ch] [rbp-54h]
long long v13; // [rsp+A0h] [rbp-50h]
long long i; // [rsp+A8h] [rbp-48h]
long long v15; // [rsp+B0h] [rbp-40h]
int v16; // [rsp+B8h] [rbp-38h]
int v17; // [rsp+BCh] [rbp-34h]
long long *v18; // [rsp+C0h] [rbp-30h]
long long v19; // [rsp+C8h] [rbp-28h]
long long v20; // [rsp+D0h] [rbp-20h]
int v21; // [rsp+DCh] [rbp-14h]
_BYTE *v22; // [rsp+E0h] [rbp-10h]
v22 = a1;
v21 = a2;
v20 = a3;
v19 = a4;
v18 = a5;
*a5 = 0LL;
v15 = v20;
if ( v20 > 0 )
v15 = -v15;
i = v19;
if ( v19 > 0 )
i = -i;
if ( i < v15 )
v15 = i;
while ( (*(_BYTE *)(*(_QWORD *)&my_charset_latin1[16] + (unsigned __int8)*v22 + 1LL) & 8) != 0 )
++v22;
v17 = -1;
if ( *v22 == 43 )
{
++v22;
}
else if ( *v22 == 45 )
{
++v22;
v17 = 1;
}
v11 = v22;
while ( *v22 == 48 )
++v22;
v16 = 0;
while ( 1 )
{
if ( (char)*v22 < 48 || (char)*v22 > 57 )
{
if ( (char)*v22 < 65 || (char)*v22 > 90 )
{
v7 = (char)*v22 < 97 || (char)*v22 > 122 ? 127 : (char)*v22 - 97 + 10;
v8 = v7;
}
else
{
v8 = (char)*v22 - 65 + 10;
}
v9 = v8;
}
else
{
v9 = (char)*v22 - 48;
}
v10[v16] = v9;
v6 = 0;
if ( v9 < v21 )
v6 = v16 < 20;
if ( !v6 )
break;
++v16;
++v22;
}
if ( v11 != v22 )
{
v13 = 0LL;
for ( i = -1LL; --v16 >= 1; i *= v21 )
{
v12 = v10[v16];
if ( -v12 < v15 )
goto LABEL_49;
v15 = (v12 + v15) / v21;
v13 += i * v12;
}
if ( !v16 )
{
v12 = v10[0];
if ( -v10[0] < v15 )
goto LABEL_49;
v13 += i * v12;
}
if ( v17 < 0 )
{
if ( v13 == 0x8000000000000000LL )
goto LABEL_49;
v13 = -v13;
if ( v13 > v19 )
goto LABEL_49;
LABEL_50:
*v18 = v13;
*(_DWORD *)__errno_location() = 0;
return v22;
}
if ( v13 >= v20 )
goto LABEL_50;
LABEL_49:
*(_DWORD *)__errno_location() = 34;
return 0LL;
}
*(_DWORD *)__errno_location() = 33;
return 0LL;
}
| str2int:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xf0
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x40],RAX
CMP RAX,0x0
JLE 0x00186021
XOR EAX,EAX
SUB RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x40],RAX
LAB_00186021:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x48],RAX
CMP RAX,0x0
JLE 0x00186039
XOR EAX,EAX
SUB RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x48],RAX
LAB_00186039:
MOV RAX,qword ptr [RBP + -0x48]
CMP RAX,qword ptr [RBP + -0x40]
JGE 0x0018604b
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x40],RAX
LAB_0018604b:
JMP 0x0018604d
LAB_0018604d:
LEA RAX,[0x3ecdb0]
MOV RAX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RCX]
MOVZX EAX,byte ptr [RAX + RCX*0x1 + 0x1]
AND EAX,0x8
CMP EAX,0x0
JZ 0x0018607a
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x0018604d
LAB_0018607a:
MOV dword ptr [RBP + -0x34],0xffffffff
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2b
JNZ 0x0018609b
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001860bc
LAB_0018609b:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2d
JNZ 0x001860ba
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
MOV dword ptr [RBP + -0x34],0x1
LAB_001860ba:
JMP 0x001860bc
LAB_001860bc:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x60],RAX
LAB_001860c4:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x30
JNZ 0x001860de
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001860c4
LAB_001860de:
MOV dword ptr [RBP + -0x38],0x0
LAB_001860e5:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x30
JL 0x0018610f
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x39
JG 0x0018610f
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
SUB EAX,0x30
MOV dword ptr [RBP + -0xe4],EAX
JMP 0x0018618e
LAB_0018610f:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x41
JL 0x0018613c
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x5a
JG 0x0018613c
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
SUB EAX,0x41
ADD EAX,0xa
MOV dword ptr [RBP + -0xe8],EAX
JMP 0x00186182
LAB_0018613c:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x61
JL 0x00186169
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x7a
JG 0x00186169
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
SUB EAX,0x61
ADD EAX,0xa
MOV dword ptr [RBP + -0xec],EAX
JMP 0x00186176
LAB_00186169:
MOV EAX,0x7f
MOV dword ptr [RBP + -0xec],EAX
JMP 0x00186176
LAB_00186176:
MOV EAX,dword ptr [RBP + -0xec]
MOV dword ptr [RBP + -0xe8],EAX
LAB_00186182:
MOV EAX,dword ptr [RBP + -0xe8]
MOV dword ptr [RBP + -0xe4],EAX
LAB_0018618e:
MOV ECX,dword ptr [RBP + -0xe4]
MOVSXD RAX,dword ptr [RBP + -0x38]
MOV dword ptr [RBP + RAX*0x4 + -0xe0],ECX
XOR EAX,EAX
CMP ECX,dword ptr [RBP + -0x14]
MOV byte ptr [RBP + -0xed],AL
JGE 0x001861b9
CMP dword ptr [RBP + -0x38],0x14
SETL AL
MOV byte ptr [RBP + -0xed],AL
LAB_001861b9:
MOV AL,byte ptr [RBP + -0xed]
TEST AL,0x1
JNZ 0x001861c5
JMP 0x001861e1
LAB_001861c5:
JMP 0x001861c7
LAB_001861c7:
MOV EAX,dword ptr [RBP + -0x38]
ADD EAX,0x1
MOV dword ptr [RBP + -0x38],EAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001860e5
LAB_001861e1:
MOV RAX,qword ptr [RBP + -0x60]
CMP RAX,qword ptr [RBP + -0x10]
JNZ 0x00186203
CALL 0x00129040
MOV dword ptr [RAX],0x21
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00186350
LAB_00186203:
MOV qword ptr [RBP + -0x50],0x0
MOV qword ptr [RBP + -0x48],-0x1
LAB_00186213:
MOV EAX,dword ptr [RBP + -0x38]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x38],EAX
CMP EAX,0x1
JL 0x0018628b
MOVSXD RAX,dword ptr [RBP + -0x38]
MOV ECX,dword ptr [RBP + RAX*0x4 + -0xe0]
MOV dword ptr [RBP + -0x54],ECX
XOR EAX,EAX
SUB EAX,ECX
CDQE
CMP RAX,qword ptr [RBP + -0x40]
JGE 0x00186253
CALL 0x00129040
MOV dword ptr [RAX],0x22
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00186350
LAB_00186253:
MOV RAX,qword ptr [RBP + -0x40]
MOVSXD RCX,dword ptr [RBP + -0x54]
ADD RAX,RCX
MOVSXD RCX,dword ptr [RBP + -0x14]
CQO
IDIV RCX
MOV qword ptr [RBP + -0x40],RAX
MOVSXD RAX,dword ptr [RBP + -0x54]
IMUL RAX,qword ptr [RBP + -0x48]
ADD RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x50],RAX
MOVSXD RAX,dword ptr [RBP + -0x14]
IMUL RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x48],RAX
JMP 0x00186213
LAB_0018628b:
CMP dword ptr [RBP + -0x38],0x0
JNZ 0x001862d4
MOVSXD RAX,dword ptr [RBP + -0x38]
MOV ECX,dword ptr [RBP + RAX*0x4 + -0xe0]
MOV dword ptr [RBP + -0x54],ECX
XOR EAX,EAX
SUB EAX,ECX
CDQE
CMP RAX,qword ptr [RBP + -0x40]
JGE 0x001862c3
CALL 0x00129040
MOV dword ptr [RAX],0x22
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00186350
LAB_001862c3:
MOVSXD RAX,dword ptr [RBP + -0x54]
IMUL RAX,qword ptr [RBP + -0x48]
ADD RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x50],RAX
LAB_001862d4:
CMP dword ptr [RBP + -0x34],0x0
JGE 0x00186311
MOV RAX,-0x7fffffffffffffff
CMP qword ptr [RBP + -0x50],RAX
JL 0x001862fa
XOR EAX,EAX
SUB RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x50],RAX
CMP RAX,qword ptr [RBP + -0x28]
JLE 0x0018630f
LAB_001862fa:
CALL 0x00129040
MOV dword ptr [RAX],0x22
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00186350
LAB_0018630f:
JMP 0x00186332
LAB_00186311:
MOV RAX,qword ptr [RBP + -0x50]
CMP RAX,qword ptr [RBP + -0x20]
JGE 0x00186330
CALL 0x00129040
MOV dword ptr [RAX],0x22
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00186350
LAB_00186330:
JMP 0x00186332
LAB_00186332:
MOV RCX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RCX
CALL 0x00129040
MOV dword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
LAB_00186350:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0xf0
POP RBP
RET
|
byte * str2int(byte *param_1,int param_2,long param_3,long param_4,long *param_5)
{
int *piVar1;
int local_f4;
int local_f0;
int local_ec;
int aiStack_e8 [32];
byte *local_68;
int local_5c;
long local_58;
long local_50;
long local_48;
int local_40;
int local_3c;
long *local_38;
long local_30;
long local_28;
int local_1c;
byte *local_18;
byte *local_10;
*param_5 = 0;
local_48 = param_3;
if (0 < param_3) {
local_48 = -param_3;
}
local_50 = param_4;
if (0 < param_4) {
local_50 = -param_4;
}
local_18 = param_1;
if (local_50 < local_48) {
local_48 = local_50;
}
while ((PTR_ctype_latin1_003ecdf0[(ulong)*local_18 + 1] & 8) != 0) {
local_18 = local_18 + 1;
}
local_3c = -1;
if (*local_18 == 0x2b) {
local_18 = local_18 + 1;
}
else if (*local_18 == 0x2d) {
local_18 = local_18 + 1;
local_3c = 1;
}
local_68 = local_18;
for (; *local_18 == 0x30; local_18 = local_18 + 1) {
}
local_40 = 0;
local_38 = param_5;
local_30 = param_4;
local_28 = param_3;
local_1c = param_2;
while( true ) {
if (((char)*local_18 < '0') || ('9' < (char)*local_18)) {
if (((char)*local_18 < 'A') || ('Z' < (char)*local_18)) {
if (((char)*local_18 < 'a') || ('z' < (char)*local_18)) {
local_f4 = 0x7f;
}
else {
local_f4 = (char)*local_18 + -0x57;
}
local_f0 = local_f4;
}
else {
local_f0 = (char)*local_18 + -0x37;
}
local_ec = local_f0;
}
else {
local_ec = (char)*local_18 + -0x30;
}
aiStack_e8[local_40] = local_ec;
if (local_1c <= local_ec || 0x13 < local_40) break;
local_40 = local_40 + 1;
local_18 = local_18 + 1;
}
if (local_68 == local_18) {
piVar1 = __errno_location();
*piVar1 = 0x21;
local_10 = (byte *)0x0;
}
else {
local_58 = 0;
local_50 = -1;
while (local_40 = local_40 + -1, 0 < local_40) {
local_5c = aiStack_e8[local_40];
if (-local_5c < local_48) {
piVar1 = __errno_location();
*piVar1 = 0x22;
return (byte *)0x0;
}
local_48 = (local_48 + local_5c) / (long)local_1c;
local_58 = local_5c * local_50 + local_58;
local_50 = local_1c * local_50;
}
if (local_40 == 0) {
local_5c = aiStack_e8[0];
if (-aiStack_e8[0] < local_48) {
piVar1 = __errno_location();
*piVar1 = 0x22;
return (byte *)0x0;
}
local_58 = aiStack_e8[0] * local_50 + local_58;
}
if (local_3c < 0) {
if ((local_58 < -0x7fffffffffffffff) || (local_58 = -local_58, local_30 < local_58)) {
piVar1 = __errno_location();
*piVar1 = 0x22;
return (byte *)0x0;
}
}
else if (local_58 < local_28) {
piVar1 = __errno_location();
*piVar1 = 0x22;
return (byte *)0x0;
}
*local_38 = local_58;
piVar1 = __errno_location();
*piVar1 = 0;
local_10 = local_18;
}
return local_10;
}
| |
43,536 | mi_search_next | eloqsql/storage/myisam/mi_search.c | int _mi_search_next(register MI_INFO *info, register MI_KEYDEF *keyinfo,
uchar *key, uint key_length, uint nextflag, my_off_t pos)
{
int error;
uint nod_flag;
uchar lastkey[HA_MAX_KEY_BUFF];
DBUG_ENTER("_mi_search_next");
DBUG_PRINT("enter",("nextflag: %u lastpos: %llu int_keypos: %p",
nextflag, info->lastpos,
info->int_keypos));
DBUG_EXECUTE("key",_mi_print_key(DBUG_FILE,keyinfo->seg,key,key_length););
/* Force full read if we are at last key or if we are not on a leaf
and the key tree has changed since we used it last time
Note that even if the key tree has changed since last read, we can use
the last read data from the leaf if we haven't used the buffer for
something else.
*/
if (((nextflag & SEARCH_BIGGER) && info->int_keypos >= info->int_maxpos) ||
info->page_changed ||
(info->int_keytree_version != keyinfo->version &&
(info->int_nod_flag || info->buff_used)))
DBUG_RETURN(_mi_search(info,keyinfo,key, USE_WHOLE_KEY,
nextflag | SEARCH_SAVE_BUFF, pos));
if (info->buff_used)
{
if (!_mi_fetch_keypage(info,keyinfo,info->last_search_keypage,
DFLT_INIT_HITS,info->buff,0))
DBUG_RETURN(-1);
info->buff_used=0;
}
/* Last used buffer is in info->buff */
nod_flag=mi_test_if_nod(info->buff);
if (nextflag & SEARCH_BIGGER) /* Next key */
{
my_off_t tmp_pos=_mi_kpos(nod_flag,info->int_keypos);
if (tmp_pos != HA_OFFSET_ERROR)
{
if ((error=_mi_search(info,keyinfo,key, USE_WHOLE_KEY,
nextflag | SEARCH_SAVE_BUFF, tmp_pos)) <=0)
DBUG_RETURN(error);
}
memcpy(lastkey,key,key_length);
if (!(info->lastkey_length=(*keyinfo->get_key)(keyinfo,nod_flag,
&info->int_keypos,lastkey)))
DBUG_RETURN(-1);
}
else /* Previous key */
{
uint length;
/* Find start of previous key */
info->int_keypos=_mi_get_last_key(info,keyinfo,info->buff,lastkey,
info->int_keypos, &length);
if (!info->int_keypos)
DBUG_RETURN(-1);
if (info->int_keypos == info->buff+2)
DBUG_RETURN(_mi_search(info,keyinfo,key, USE_WHOLE_KEY,
nextflag | SEARCH_SAVE_BUFF, pos));
if ((error=_mi_search(info,keyinfo,key, USE_WHOLE_KEY,
nextflag | SEARCH_SAVE_BUFF,
_mi_kpos(nod_flag,info->int_keypos))) <= 0)
DBUG_RETURN(error);
/* QQ: We should be able to optimize away the following call */
if (! _mi_get_last_key(info,keyinfo,info->buff,lastkey,
info->int_keypos,&info->lastkey_length))
DBUG_RETURN(-1);
}
memcpy(info->lastkey,lastkey,info->lastkey_length);
info->lastpos=_mi_dpos(info,0,info->lastkey+info->lastkey_length);
DBUG_PRINT("exit",("found key at %lu",(ulong) info->lastpos));
DBUG_RETURN(0);
} | O0 | c | mi_search_next:
pushq %rbp
movq %rsp, %rbp
subq $0x530, %rsp # imm = 0x530
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x4d0(%rbp)
movq %rsi, -0x4d8(%rbp)
movq %rdx, -0x4e0(%rbp)
movl %ecx, -0x4e4(%rbp)
movl %r8d, -0x4e8(%rbp)
movq %r9, -0x4f0(%rbp)
jmp 0xc3c23
jmp 0xc3c25
jmp 0xc3c27
movl -0x4e8(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0xc3c53
movq -0x4d0(%rbp), %rax
movq 0x128(%rax), %rax
movq -0x4d0(%rbp), %rcx
cmpq 0x130(%rcx), %rax
jae 0xc3ca2
movq -0x4d0(%rbp), %rax
movsbl 0x33c(%rax), %eax
cmpl $0x0, %eax
jne 0xc3ca2
movq -0x4d0(%rbp), %rax
movl 0x13c(%rax), %eax
movq -0x4d8(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
je 0xc3ce0
movq -0x4d0(%rbp), %rax
cmpl $0x0, 0x138(%rax)
jne 0xc3ca2
movq -0x4d0(%rbp), %rax
movsbl 0x33d(%rax), %eax
cmpl $0x0, %eax
je 0xc3ce0
jmp 0xc3ca4
movq -0x4d0(%rbp), %rdi
movq -0x4d8(%rbp), %rsi
movq -0x4e0(%rbp), %rdx
movl -0x4e8(%rbp), %r8d
orl $0x20, %r8d
movq -0x4f0(%rbp), %r9
movl $0x970, %ecx # imm = 0x970
callq 0xc05e0
movl %eax, -0x4c4(%rbp)
jmp 0xc40ce
movq -0x4d0(%rbp), %rax
cmpb $0x0, 0x33d(%rax)
je 0xc3d4c
movq -0x4d0(%rbp), %rdi
movq -0x4d8(%rbp), %rsi
movq -0x4d0(%rbp), %rax
movq 0x198(%rax), %rdx
movq -0x4d0(%rbp), %rax
movq 0x100(%rax), %r8
movl $0x3, %ecx
xorl %r9d, %r9d
callq 0xbfe30
cmpq $0x0, %rax
jne 0xc3d3e
jmp 0xc3d2f
movl $0xffffffff, -0x4c4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc40ce
movq -0x4d0(%rbp), %rax
movb $0x0, 0x33d(%rax)
movq -0x4d0(%rbp), %rax
movq 0x100(%rax), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0xc3d7f
movq -0x4d0(%rbp), %rax
movq (%rax), %rax
movl 0x17c(%rax), %eax
movl %eax, -0x508(%rbp)
jmp 0xc3d89
xorl %eax, %eax
movl %eax, -0x508(%rbp)
jmp 0xc3d89
movl -0x508(%rbp), %eax
movl %eax, -0x4f8(%rbp)
movl -0x4e8(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0xc3e94
movl -0x4f8(%rbp), %edi
movq -0x4d0(%rbp), %rax
movq 0x128(%rax), %rsi
callq 0xc0da0
movq %rax, -0x500(%rbp)
cmpq $-0x1, -0x500(%rbp)
je 0xc3e22
movq -0x4d0(%rbp), %rdi
movq -0x4d8(%rbp), %rsi
movq -0x4e0(%rbp), %rdx
movl -0x4e8(%rbp), %r8d
orl $0x20, %r8d
movq -0x500(%rbp), %r9
movl $0x970, %ecx # imm = 0x970
callq 0xc05e0
movl %eax, -0x4f4(%rbp)
cmpl $0x0, %eax
jg 0xc3e20
jmp 0xc3e0f
movl -0x4f4(%rbp), %eax
movl %eax, -0x4c4(%rbp)
jmp 0xc40ce
jmp 0xc3e22
leaq -0x4c0(%rbp), %rdi
movq -0x4e0(%rbp), %rsi
movl -0x4e4(%rbp), %eax
movl %eax, %edx
callq 0x2a0b0
movq -0x4d8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x4d8(%rbp), %rdi
movl -0x4f8(%rbp), %esi
movq -0x4d0(%rbp), %rdx
addq $0x128, %rdx # imm = 0x128
leaq -0x4c0(%rbp), %rcx
callq *%rax
movq -0x4d0(%rbp), %rcx
movl %eax, 0x1d8(%rcx)
cmpl $0x0, %eax
jne 0xc3e8f
jmp 0xc3e80
movl $0xffffffff, -0x4c4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc40ce
jmp 0xc405a
movq -0x4d0(%rbp), %rdi
movq -0x4d8(%rbp), %rsi
movq -0x4d0(%rbp), %rax
movq 0x100(%rax), %rdx
leaq -0x4c0(%rbp), %rcx
movq -0x4d0(%rbp), %rax
movq 0x128(%rax), %r8
leaq -0x504(%rbp), %r9
callq 0xc37c0
movq %rax, %rcx
movq -0x4d0(%rbp), %rax
movq %rcx, 0x128(%rax)
movq -0x4d0(%rbp), %rax
cmpq $0x0, 0x128(%rax)
jne 0xc3f04
jmp 0xc3ef5
movl $0xffffffff, -0x4c4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc40ce
movq -0x4d0(%rbp), %rax
movq 0x128(%rax), %rax
movq -0x4d0(%rbp), %rcx
movq 0x100(%rcx), %rcx
addq $0x2, %rcx
cmpq %rcx, %rax
jne 0xc3f67
jmp 0xc3f2b
movq -0x4d0(%rbp), %rdi
movq -0x4d8(%rbp), %rsi
movq -0x4e0(%rbp), %rdx
movl -0x4e8(%rbp), %r8d
orl $0x20, %r8d
movq -0x4f0(%rbp), %r9
movl $0x970, %ecx # imm = 0x970
callq 0xc05e0
movl %eax, -0x4c4(%rbp)
jmp 0xc40ce
movq -0x4d0(%rbp), %rax
movq %rax, -0x528(%rbp)
movq -0x4d8(%rbp), %rax
movq %rax, -0x520(%rbp)
movq -0x4e0(%rbp), %rax
movq %rax, -0x518(%rbp)
movl -0x4e8(%rbp), %eax
orl $0x20, %eax
movl %eax, -0x50c(%rbp)
movl -0x4f8(%rbp), %edi
movq -0x4d0(%rbp), %rax
movq 0x128(%rax), %rsi
callq 0xc0da0
movq -0x528(%rbp), %rdi
movq -0x520(%rbp), %rsi
movq -0x518(%rbp), %rdx
movl -0x50c(%rbp), %r8d
movq %rax, %r9
movl $0x970, %ecx # imm = 0x970
callq 0xc05e0
movl %eax, -0x4f4(%rbp)
cmpl $0x0, %eax
jg 0xc4000
jmp 0xc3fef
movl -0x4f4(%rbp), %eax
movl %eax, -0x4c4(%rbp)
jmp 0xc40ce
movq -0x4d0(%rbp), %rdi
movq -0x4d8(%rbp), %rsi
movq -0x4d0(%rbp), %rax
movq 0x100(%rax), %rdx
leaq -0x4c0(%rbp), %rcx
movq -0x4d0(%rbp), %rax
movq 0x128(%rax), %r8
movq -0x4d0(%rbp), %r9
addq $0x1d8, %r9 # imm = 0x1D8
callq 0xc37c0
cmpq $0x0, %rax
jne 0xc4058
jmp 0xc404c
movl $0xffffffff, -0x4c4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc40ce
jmp 0xc405a
movq -0x4d0(%rbp), %rax
movq 0x108(%rax), %rdi
leaq -0x4c0(%rbp), %rsi
movq -0x4d0(%rbp), %rax
movl 0x1d8(%rax), %eax
movl %eax, %edx
callq 0x2a0b0
movq -0x4d0(%rbp), %rdi
movq -0x4d0(%rbp), %rax
movq 0x108(%rax), %rdx
movq -0x4d0(%rbp), %rax
movl 0x1d8(%rax), %eax
addq %rax, %rdx
xorl %esi, %esi
callq 0xc1020
movq %rax, %rcx
movq -0x4d0(%rbp), %rax
movq %rcx, 0x170(%rax)
jmp 0xc40c2
jmp 0xc40c4
movl $0x0, -0x4c4(%rbp)
movl -0x4c4(%rbp), %eax
movl %eax, -0x52c(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xc40fb
movl -0x52c(%rbp), %eax
addq $0x530, %rsp # imm = 0x530
popq %rbp
retq
callq 0x2a270
| _mi_search_next:
push rbp
mov rbp, rsp
sub rsp, 530h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_4D0], rdi
mov [rbp+var_4D8], rsi
mov [rbp+var_4E0], rdx
mov [rbp+var_4E4], ecx
mov [rbp+var_4E8], r8d
mov [rbp+var_4F0], r9
jmp short $+2
loc_C3C23:
jmp short $+2
loc_C3C25:
jmp short $+2
loc_C3C27:
mov eax, [rbp+var_4E8]
and eax, 8
cmp eax, 0
jz short loc_C3C53
mov rax, [rbp+var_4D0]
mov rax, [rax+128h]
mov rcx, [rbp+var_4D0]
cmp rax, [rcx+130h]
jnb short loc_C3CA2
loc_C3C53:
mov rax, [rbp+var_4D0]
movsx eax, byte ptr [rax+33Ch]
cmp eax, 0
jnz short loc_C3CA2
mov rax, [rbp+var_4D0]
mov eax, [rax+13Ch]
mov rcx, [rbp+var_4D8]
cmp eax, [rcx+1Ch]
jz short loc_C3CE0
mov rax, [rbp+var_4D0]
cmp dword ptr [rax+138h], 0
jnz short loc_C3CA2
mov rax, [rbp+var_4D0]
movsx eax, byte ptr [rax+33Dh]
cmp eax, 0
jz short loc_C3CE0
loc_C3CA2:
jmp short $+2
loc_C3CA4:
mov rdi, [rbp+var_4D0]
mov rsi, [rbp+var_4D8]
mov rdx, [rbp+var_4E0]
mov r8d, [rbp+var_4E8]
or r8d, 20h
mov r9, [rbp+var_4F0]
mov ecx, 970h
call _mi_search
mov [rbp+var_4C4], eax
jmp loc_C40CE
loc_C3CE0:
mov rax, [rbp+var_4D0]
cmp byte ptr [rax+33Dh], 0
jz short loc_C3D4C
mov rdi, [rbp+var_4D0]
mov rsi, [rbp+var_4D8]
mov rax, [rbp+var_4D0]
mov rdx, [rax+198h]
mov rax, [rbp+var_4D0]
mov r8, [rax+100h]
mov ecx, 3
xor r9d, r9d
call _mi_fetch_keypage
cmp rax, 0
jnz short loc_C3D3E
jmp short $+2
loc_C3D2F:
mov [rbp+var_4C4], 0FFFFFFFFh
jmp loc_C40CE
loc_C3D3E:
mov rax, [rbp+var_4D0]
mov byte ptr [rax+33Dh], 0
loc_C3D4C:
mov rax, [rbp+var_4D0]
mov rax, [rax+100h]
movzx eax, byte ptr [rax]
and eax, 80h
cmp eax, 0
jz short loc_C3D7F
mov rax, [rbp+var_4D0]
mov rax, [rax]
mov eax, [rax+17Ch]
mov [rbp+var_508], eax
jmp short loc_C3D89
loc_C3D7F:
xor eax, eax
mov [rbp+var_508], eax
jmp short $+2
loc_C3D89:
mov eax, [rbp+var_508]
mov [rbp+var_4F8], eax
mov eax, [rbp+var_4E8]
and eax, 8
cmp eax, 0
jz loc_C3E94
mov edi, [rbp+var_4F8]
mov rax, [rbp+var_4D0]
mov rsi, [rax+128h]
call _mi_kpos
mov [rbp+var_500], rax
cmp [rbp+var_500], 0FFFFFFFFFFFFFFFFh
jz short loc_C3E22
mov rdi, [rbp+var_4D0]
mov rsi, [rbp+var_4D8]
mov rdx, [rbp+var_4E0]
mov r8d, [rbp+var_4E8]
or r8d, 20h
mov r9, [rbp+var_500]
mov ecx, 970h
call _mi_search
mov [rbp+var_4F4], eax
cmp eax, 0
jg short loc_C3E20
jmp short $+2
loc_C3E0F:
mov eax, [rbp+var_4F4]
mov [rbp+var_4C4], eax
jmp loc_C40CE
loc_C3E20:
jmp short $+2
loc_C3E22:
lea rdi, [rbp+var_4C0]
mov rsi, [rbp+var_4E0]
mov eax, [rbp+var_4E4]
mov edx, eax
call _memcpy
mov rax, [rbp+var_4D8]
mov rax, [rax+48h]
mov rdi, [rbp+var_4D8]
mov esi, [rbp+var_4F8]
mov rdx, [rbp+var_4D0]
add rdx, 128h
lea rcx, [rbp+var_4C0]
call rax
mov rcx, [rbp+var_4D0]
mov [rcx+1D8h], eax
cmp eax, 0
jnz short loc_C3E8F
jmp short $+2
loc_C3E80:
mov [rbp+var_4C4], 0FFFFFFFFh
jmp loc_C40CE
loc_C3E8F:
jmp loc_C405A
loc_C3E94:
mov rdi, [rbp+var_4D0]
mov rsi, [rbp+var_4D8]
mov rax, [rbp+var_4D0]
mov rdx, [rax+100h]
lea rcx, [rbp+var_4C0]
mov rax, [rbp+var_4D0]
mov r8, [rax+128h]
lea r9, [rbp+var_504]
call _mi_get_last_key
mov rcx, rax
mov rax, [rbp+var_4D0]
mov [rax+128h], rcx
mov rax, [rbp+var_4D0]
cmp qword ptr [rax+128h], 0
jnz short loc_C3F04
jmp short $+2
loc_C3EF5:
mov [rbp+var_4C4], 0FFFFFFFFh
jmp loc_C40CE
loc_C3F04:
mov rax, [rbp+var_4D0]
mov rax, [rax+128h]
mov rcx, [rbp+var_4D0]
mov rcx, [rcx+100h]
add rcx, 2
cmp rax, rcx
jnz short loc_C3F67
jmp short $+2
loc_C3F2B:
mov rdi, [rbp+var_4D0]
mov rsi, [rbp+var_4D8]
mov rdx, [rbp+var_4E0]
mov r8d, [rbp+var_4E8]
or r8d, 20h
mov r9, [rbp+var_4F0]
mov ecx, 970h
call _mi_search
mov [rbp+var_4C4], eax
jmp loc_C40CE
loc_C3F67:
mov rax, [rbp+var_4D0]
mov [rbp+var_528], rax
mov rax, [rbp+var_4D8]
mov [rbp+var_520], rax
mov rax, [rbp+var_4E0]
mov [rbp+var_518], rax
mov eax, [rbp+var_4E8]
or eax, 20h
mov [rbp+var_50C], eax
mov edi, [rbp+var_4F8]
mov rax, [rbp+var_4D0]
mov rsi, [rax+128h]
call _mi_kpos
mov rdi, [rbp+var_528]
mov rsi, [rbp+var_520]
mov rdx, [rbp+var_518]
mov r8d, [rbp+var_50C]
mov r9, rax
mov ecx, 970h
call _mi_search
mov [rbp+var_4F4], eax
cmp eax, 0
jg short loc_C4000
jmp short $+2
loc_C3FEF:
mov eax, [rbp+var_4F4]
mov [rbp+var_4C4], eax
jmp loc_C40CE
loc_C4000:
mov rdi, [rbp+var_4D0]
mov rsi, [rbp+var_4D8]
mov rax, [rbp+var_4D0]
mov rdx, [rax+100h]
lea rcx, [rbp+var_4C0]
mov rax, [rbp+var_4D0]
mov r8, [rax+128h]
mov r9, [rbp+var_4D0]
add r9, 1D8h
call _mi_get_last_key
cmp rax, 0
jnz short loc_C4058
jmp short $+2
loc_C404C:
mov [rbp+var_4C4], 0FFFFFFFFh
jmp short loc_C40CE
loc_C4058:
jmp short $+2
loc_C405A:
mov rax, [rbp+var_4D0]
mov rdi, [rax+108h]
lea rsi, [rbp+var_4C0]
mov rax, [rbp+var_4D0]
mov eax, [rax+1D8h]
mov edx, eax
call _memcpy
mov rdi, [rbp+var_4D0]
mov rax, [rbp+var_4D0]
mov rdx, [rax+108h]
mov rax, [rbp+var_4D0]
mov eax, [rax+1D8h]
add rdx, rax
xor esi, esi
call _mi_dpos
mov rcx, rax
mov rax, [rbp+var_4D0]
mov [rax+170h], rcx
jmp short $+2
loc_C40C2:
jmp short $+2
loc_C40C4:
mov [rbp+var_4C4], 0
loc_C40CE:
mov eax, [rbp+var_4C4]
mov [rbp+var_52C], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_C40FB
mov eax, [rbp+var_52C]
add rsp, 530h
pop rbp
retn
loc_C40FB:
call ___stack_chk_fail
| long long mi_search_next(_QWORD *a1, const char *a2, long long a3, unsigned int a4, int a5, long long a6)
{
int v6; // eax
_BYTE *last_key; // rax
long long v8; // rax
long long v9; // rax
_QWORD *v11; // [rsp+8h] [rbp-528h]
const char *v12; // [rsp+10h] [rbp-520h]
long long v13; // [rsp+18h] [rbp-518h]
unsigned int v14; // [rsp+24h] [rbp-50Ch]
unsigned int v15; // [rsp+28h] [rbp-508h]
int v16; // [rsp+2Ch] [rbp-504h] BYREF
long long v17; // [rsp+30h] [rbp-500h]
unsigned int v18; // [rsp+38h] [rbp-4F8h]
int v19; // [rsp+3Ch] [rbp-4F4h]
long long v20; // [rsp+40h] [rbp-4F0h]
int v21; // [rsp+48h] [rbp-4E8h]
unsigned int v22; // [rsp+4Ch] [rbp-4E4h]
long long v23; // [rsp+50h] [rbp-4E0h]
const char *v24; // [rsp+58h] [rbp-4D8h]
_QWORD *v25; // [rsp+60h] [rbp-4D0h]
_BYTE v27[1208]; // [rsp+70h] [rbp-4C0h] BYREF
unsigned long long v28; // [rsp+528h] [rbp-8h]
v28 = __readfsqword(0x28u);
v25 = a1;
v24 = a2;
v23 = a3;
v22 = a4;
v21 = a5;
v20 = a6;
if ( ((a5 & 8) == 0 || v25[37] < v25[38])
&& !*((_BYTE *)v25 + 828)
&& (*((_DWORD *)v25 + 79) == *((_DWORD *)v24 + 7) || !*((_DWORD *)v25 + 78) && !*((_BYTE *)v25 + 829)) )
{
if ( *((_BYTE *)v25 + 829) )
{
if ( !mi_fetch_keypage(v25, (long long)v24, v25[51], 3, v25[32], 0) )
return (unsigned int)-1;
*((_BYTE *)v25 + 829) = 0;
}
if ( (*(_BYTE *)v25[32] & 0x80) != 0 )
v15 = *(_DWORD *)(*v25 + 380LL);
else
v15 = 0;
v18 = v15;
if ( (v21 & 8) != 0 )
{
v17 = mi_kpos(v18, v25[37]);
if ( v17 != -1 )
{
v19 = mi_search(v25, v24, v23, 0x970u, v21 | 0x20u, v17);
if ( v19 <= 0 )
return (unsigned int)v19;
}
memcpy(v27, v23, v22);
v6 = (*((long long ( **)(const char *, _QWORD, _QWORD *, _BYTE *))v24 + 9))(v24, v18, v25 + 37, v27);
*((_DWORD *)v25 + 118) = v6;
if ( !v6 )
return (unsigned int)-1;
}
else
{
last_key = mi_get_last_key((long long)v25, (long long)v24, (_BYTE *)v25[32], v27, v25[37], &v16);
v25[37] = last_key;
if ( !v25[37] )
return (unsigned int)-1;
if ( v25[37] == v25[32] + 2LL )
return (unsigned int)mi_search(v25, v24, v23, 0x970u, v21 | 0x20u, v20);
v11 = v25;
v12 = v24;
v13 = v23;
v14 = v21 | 0x20;
v8 = mi_kpos(v18, v25[37]);
v19 = mi_search(v11, v12, v13, 0x970u, v14, v8);
if ( v19 <= 0 )
return (unsigned int)v19;
if ( !mi_get_last_key((long long)v25, (long long)v24, (_BYTE *)v25[32], v27, v25[37], (_DWORD *)v25 + 118) )
return (unsigned int)-1;
}
memcpy(v25[33], v27, *((unsigned int *)v25 + 118));
v9 = mi_dpos((long long)v25, 0, *((unsigned int *)v25 + 118) + v25[33]);
v25[46] = v9;
return 0;
}
return (unsigned int)mi_search(v25, v24, v23, 0x970u, v21 | 0x20u, v20);
}
| _mi_search_next:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x530
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x4d0],RDI
MOV qword ptr [RBP + -0x4d8],RSI
MOV qword ptr [RBP + -0x4e0],RDX
MOV dword ptr [RBP + -0x4e4],ECX
MOV dword ptr [RBP + -0x4e8],R8D
MOV qword ptr [RBP + -0x4f0],R9
JMP 0x001c3c23
LAB_001c3c23:
JMP 0x001c3c25
LAB_001c3c25:
JMP 0x001c3c27
LAB_001c3c27:
MOV EAX,dword ptr [RBP + -0x4e8]
AND EAX,0x8
CMP EAX,0x0
JZ 0x001c3c53
MOV RAX,qword ptr [RBP + -0x4d0]
MOV RAX,qword ptr [RAX + 0x128]
MOV RCX,qword ptr [RBP + -0x4d0]
CMP RAX,qword ptr [RCX + 0x130]
JNC 0x001c3ca2
LAB_001c3c53:
MOV RAX,qword ptr [RBP + -0x4d0]
MOVSX EAX,byte ptr [RAX + 0x33c]
CMP EAX,0x0
JNZ 0x001c3ca2
MOV RAX,qword ptr [RBP + -0x4d0]
MOV EAX,dword ptr [RAX + 0x13c]
MOV RCX,qword ptr [RBP + -0x4d8]
CMP EAX,dword ptr [RCX + 0x1c]
JZ 0x001c3ce0
MOV RAX,qword ptr [RBP + -0x4d0]
CMP dword ptr [RAX + 0x138],0x0
JNZ 0x001c3ca2
MOV RAX,qword ptr [RBP + -0x4d0]
MOVSX EAX,byte ptr [RAX + 0x33d]
CMP EAX,0x0
JZ 0x001c3ce0
LAB_001c3ca2:
JMP 0x001c3ca4
LAB_001c3ca4:
MOV RDI,qword ptr [RBP + -0x4d0]
MOV RSI,qword ptr [RBP + -0x4d8]
MOV RDX,qword ptr [RBP + -0x4e0]
MOV R8D,dword ptr [RBP + -0x4e8]
OR R8D,0x20
MOV R9,qword ptr [RBP + -0x4f0]
MOV ECX,0x970
CALL 0x001c05e0
MOV dword ptr [RBP + -0x4c4],EAX
JMP 0x001c40ce
LAB_001c3ce0:
MOV RAX,qword ptr [RBP + -0x4d0]
CMP byte ptr [RAX + 0x33d],0x0
JZ 0x001c3d4c
MOV RDI,qword ptr [RBP + -0x4d0]
MOV RSI,qword ptr [RBP + -0x4d8]
MOV RAX,qword ptr [RBP + -0x4d0]
MOV RDX,qword ptr [RAX + 0x198]
MOV RAX,qword ptr [RBP + -0x4d0]
MOV R8,qword ptr [RAX + 0x100]
MOV ECX,0x3
XOR R9D,R9D
CALL 0x001bfe30
CMP RAX,0x0
JNZ 0x001c3d3e
JMP 0x001c3d2f
LAB_001c3d2f:
MOV dword ptr [RBP + -0x4c4],0xffffffff
JMP 0x001c40ce
LAB_001c3d3e:
MOV RAX,qword ptr [RBP + -0x4d0]
MOV byte ptr [RAX + 0x33d],0x0
LAB_001c3d4c:
MOV RAX,qword ptr [RBP + -0x4d0]
MOV RAX,qword ptr [RAX + 0x100]
MOVZX EAX,byte ptr [RAX]
AND EAX,0x80
CMP EAX,0x0
JZ 0x001c3d7f
MOV RAX,qword ptr [RBP + -0x4d0]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x17c]
MOV dword ptr [RBP + -0x508],EAX
JMP 0x001c3d89
LAB_001c3d7f:
XOR EAX,EAX
MOV dword ptr [RBP + -0x508],EAX
JMP 0x001c3d89
LAB_001c3d89:
MOV EAX,dword ptr [RBP + -0x508]
MOV dword ptr [RBP + -0x4f8],EAX
MOV EAX,dword ptr [RBP + -0x4e8]
AND EAX,0x8
CMP EAX,0x0
JZ 0x001c3e94
MOV EDI,dword ptr [RBP + -0x4f8]
MOV RAX,qword ptr [RBP + -0x4d0]
MOV RSI,qword ptr [RAX + 0x128]
CALL 0x001c0da0
MOV qword ptr [RBP + -0x500],RAX
CMP qword ptr [RBP + -0x500],-0x1
JZ 0x001c3e22
MOV RDI,qword ptr [RBP + -0x4d0]
MOV RSI,qword ptr [RBP + -0x4d8]
MOV RDX,qword ptr [RBP + -0x4e0]
MOV R8D,dword ptr [RBP + -0x4e8]
OR R8D,0x20
MOV R9,qword ptr [RBP + -0x500]
MOV ECX,0x970
CALL 0x001c05e0
MOV dword ptr [RBP + -0x4f4],EAX
CMP EAX,0x0
JG 0x001c3e20
JMP 0x001c3e0f
LAB_001c3e0f:
MOV EAX,dword ptr [RBP + -0x4f4]
MOV dword ptr [RBP + -0x4c4],EAX
JMP 0x001c40ce
LAB_001c3e20:
JMP 0x001c3e22
LAB_001c3e22:
LEA RDI,[RBP + -0x4c0]
MOV RSI,qword ptr [RBP + -0x4e0]
MOV EAX,dword ptr [RBP + -0x4e4]
MOV EDX,EAX
CALL 0x0012a0b0
MOV RAX,qword ptr [RBP + -0x4d8]
MOV RAX,qword ptr [RAX + 0x48]
MOV RDI,qword ptr [RBP + -0x4d8]
MOV ESI,dword ptr [RBP + -0x4f8]
MOV RDX,qword ptr [RBP + -0x4d0]
ADD RDX,0x128
LEA RCX,[RBP + -0x4c0]
CALL RAX
MOV RCX,qword ptr [RBP + -0x4d0]
MOV dword ptr [RCX + 0x1d8],EAX
CMP EAX,0x0
JNZ 0x001c3e8f
JMP 0x001c3e80
LAB_001c3e80:
MOV dword ptr [RBP + -0x4c4],0xffffffff
JMP 0x001c40ce
LAB_001c3e8f:
JMP 0x001c405a
LAB_001c3e94:
MOV RDI,qword ptr [RBP + -0x4d0]
MOV RSI,qword ptr [RBP + -0x4d8]
MOV RAX,qword ptr [RBP + -0x4d0]
MOV RDX,qword ptr [RAX + 0x100]
LEA RCX,[RBP + -0x4c0]
MOV RAX,qword ptr [RBP + -0x4d0]
MOV R8,qword ptr [RAX + 0x128]
LEA R9,[RBP + -0x504]
CALL 0x001c37c0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x4d0]
MOV qword ptr [RAX + 0x128],RCX
MOV RAX,qword ptr [RBP + -0x4d0]
CMP qword ptr [RAX + 0x128],0x0
JNZ 0x001c3f04
JMP 0x001c3ef5
LAB_001c3ef5:
MOV dword ptr [RBP + -0x4c4],0xffffffff
JMP 0x001c40ce
LAB_001c3f04:
MOV RAX,qword ptr [RBP + -0x4d0]
MOV RAX,qword ptr [RAX + 0x128]
MOV RCX,qword ptr [RBP + -0x4d0]
MOV RCX,qword ptr [RCX + 0x100]
ADD RCX,0x2
CMP RAX,RCX
JNZ 0x001c3f67
JMP 0x001c3f2b
LAB_001c3f2b:
MOV RDI,qword ptr [RBP + -0x4d0]
MOV RSI,qword ptr [RBP + -0x4d8]
MOV RDX,qword ptr [RBP + -0x4e0]
MOV R8D,dword ptr [RBP + -0x4e8]
OR R8D,0x20
MOV R9,qword ptr [RBP + -0x4f0]
MOV ECX,0x970
CALL 0x001c05e0
MOV dword ptr [RBP + -0x4c4],EAX
JMP 0x001c40ce
LAB_001c3f67:
MOV RAX,qword ptr [RBP + -0x4d0]
MOV qword ptr [RBP + -0x528],RAX
MOV RAX,qword ptr [RBP + -0x4d8]
MOV qword ptr [RBP + -0x520],RAX
MOV RAX,qword ptr [RBP + -0x4e0]
MOV qword ptr [RBP + -0x518],RAX
MOV EAX,dword ptr [RBP + -0x4e8]
OR EAX,0x20
MOV dword ptr [RBP + -0x50c],EAX
MOV EDI,dword ptr [RBP + -0x4f8]
MOV RAX,qword ptr [RBP + -0x4d0]
MOV RSI,qword ptr [RAX + 0x128]
CALL 0x001c0da0
MOV RDI,qword ptr [RBP + -0x528]
MOV RSI,qword ptr [RBP + -0x520]
MOV RDX,qword ptr [RBP + -0x518]
MOV R8D,dword ptr [RBP + -0x50c]
MOV R9,RAX
MOV ECX,0x970
CALL 0x001c05e0
MOV dword ptr [RBP + -0x4f4],EAX
CMP EAX,0x0
JG 0x001c4000
JMP 0x001c3fef
LAB_001c3fef:
MOV EAX,dword ptr [RBP + -0x4f4]
MOV dword ptr [RBP + -0x4c4],EAX
JMP 0x001c40ce
LAB_001c4000:
MOV RDI,qword ptr [RBP + -0x4d0]
MOV RSI,qword ptr [RBP + -0x4d8]
MOV RAX,qword ptr [RBP + -0x4d0]
MOV RDX,qword ptr [RAX + 0x100]
LEA RCX,[RBP + -0x4c0]
MOV RAX,qword ptr [RBP + -0x4d0]
MOV R8,qword ptr [RAX + 0x128]
MOV R9,qword ptr [RBP + -0x4d0]
ADD R9,0x1d8
CALL 0x001c37c0
CMP RAX,0x0
JNZ 0x001c4058
JMP 0x001c404c
LAB_001c404c:
MOV dword ptr [RBP + -0x4c4],0xffffffff
JMP 0x001c40ce
LAB_001c4058:
JMP 0x001c405a
LAB_001c405a:
MOV RAX,qword ptr [RBP + -0x4d0]
MOV RDI,qword ptr [RAX + 0x108]
LEA RSI,[RBP + -0x4c0]
MOV RAX,qword ptr [RBP + -0x4d0]
MOV EAX,dword ptr [RAX + 0x1d8]
MOV EDX,EAX
CALL 0x0012a0b0
MOV RDI,qword ptr [RBP + -0x4d0]
MOV RAX,qword ptr [RBP + -0x4d0]
MOV RDX,qword ptr [RAX + 0x108]
MOV RAX,qword ptr [RBP + -0x4d0]
MOV EAX,dword ptr [RAX + 0x1d8]
ADD RDX,RAX
XOR ESI,ESI
CALL 0x001c1020
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x4d0]
MOV qword ptr [RAX + 0x170],RCX
JMP 0x001c40c2
LAB_001c40c2:
JMP 0x001c40c4
LAB_001c40c4:
MOV dword ptr [RBP + -0x4c4],0x0
LAB_001c40ce:
MOV EAX,dword ptr [RBP + -0x4c4]
MOV dword ptr [RBP + -0x52c],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001c40fb
MOV EAX,dword ptr [RBP + -0x52c]
ADD RSP,0x530
POP RBP
RET
LAB_001c40fb:
CALL 0x0012a270
|
int _mi_search_next(long *param_1,long param_2,void *param_3,uint param_4,uint param_5,
int8 param_6)
{
void *pvVar1;
long *plVar2;
int iVar3;
uint uVar4;
long lVar5;
long lVar6;
int8 uVar7;
long in_FS_OFFSET;
int4 local_510;
int1 local_50c [4];
long local_508;
int4 local_500;
int local_4fc;
int8 local_4f8;
uint local_4f0;
uint local_4ec;
void *local_4e8;
long local_4e0;
long *local_4d8;
int local_4cc;
int1 local_4c8 [1208];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_4f8 = param_6;
local_4f0 = param_5;
local_4ec = param_4;
local_4e8 = param_3;
local_4e0 = param_2;
local_4d8 = param_1;
if (((((param_5 & 8) != 0) && ((ulong)param_1[0x26] <= (ulong)param_1[0x25])) ||
(*(char *)((long)param_1 + 0x33c) != '\0')) ||
((*(int *)((long)param_1 + 0x13c) != *(int *)(param_2 + 0x1c) &&
(((int)param_1[0x27] != 0 || (*(char *)((long)param_1 + 0x33d) != '\0')))))) {
local_4cc = _mi_search(param_1,param_2,param_3,0x970,param_5 | 0x20,param_6);
goto LAB_001c40ce;
}
if (*(char *)((long)param_1 + 0x33d) != '\0') {
lVar5 = _mi_fetch_keypage(param_1,param_2,param_1[0x33],3,param_1[0x20],0);
if (lVar5 == 0) {
local_4cc = -1;
goto LAB_001c40ce;
}
*(int1 *)((long)local_4d8 + 0x33d) = 0;
}
if ((*(byte *)local_4d8[0x20] & 0x80) == 0) {
local_510 = 0;
}
else {
local_510 = *(int4 *)(*local_4d8 + 0x17c);
}
local_500 = local_510;
if ((local_4f0 & 8) == 0) {
lVar6 = _mi_get_last_key(local_4d8,local_4e0,local_4d8[0x20],local_4c8,local_4d8[0x25],local_50c
);
plVar2 = local_4d8;
lVar5 = local_4e0;
pvVar1 = local_4e8;
local_4d8[0x25] = lVar6;
if (local_4d8[0x25] == 0) {
local_4cc = -1;
goto LAB_001c40ce;
}
if (local_4d8[0x25] == local_4d8[0x20] + 2) {
local_4cc = _mi_search(local_4d8,local_4e0,local_4e8,0x970,local_4f0 | 0x20,local_4f8);
goto LAB_001c40ce;
}
uVar4 = local_4f0 | 0x20;
uVar7 = _mi_kpos(local_500,local_4d8[0x25]);
local_4fc = _mi_search(plVar2,lVar5,pvVar1,0x970,uVar4,uVar7);
local_4cc = local_4fc;
if (local_4fc < 1) goto LAB_001c40ce;
lVar5 = _mi_get_last_key(local_4d8,local_4e0,local_4d8[0x20],local_4c8,local_4d8[0x25],
local_4d8 + 0x3b);
if (lVar5 == 0) {
local_4cc = -1;
goto LAB_001c40ce;
}
}
else {
local_508 = _mi_kpos(local_510,local_4d8[0x25]);
if ((local_508 != -1) &&
(local_4fc = _mi_search(local_4d8,local_4e0,local_4e8,0x970,local_4f0 | 0x20,local_508),
local_4cc = local_4fc, local_4fc < 1)) goto LAB_001c40ce;
memcpy(local_4c8,local_4e8,(ulong)local_4ec);
iVar3 = (**(code **)(local_4e0 + 0x48))(local_4e0,local_500,local_4d8 + 0x25,local_4c8);
*(int *)(local_4d8 + 0x3b) = iVar3;
if (iVar3 == 0) {
local_4cc = -1;
goto LAB_001c40ce;
}
}
memcpy((void *)local_4d8[0x21],local_4c8,(ulong)*(uint *)(local_4d8 + 0x3b));
lVar5 = _mi_dpos(local_4d8,0,local_4d8[0x21] + (ulong)*(uint *)(local_4d8 + 0x3b));
local_4d8[0x2e] = lVar5;
local_4cc = 0;
LAB_001c40ce:
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_4cc;
}
| |
43,537 | my_hash_sort_utf32_nopad | eloqsql/strings/ctype-ucs2.c | static void
my_hash_sort_utf32_nopad(CHARSET_INFO *cs, const uchar *s, size_t slen,
ulong *nr1, ulong *nr2)
{
my_wc_t wc;
int res;
const uchar *e= s + slen;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
register ulong m1= *nr1, m2= *nr2;
while ((res= my_utf32_uni(cs, &wc, (uchar*) s, (uchar*) e)) > 0)
{
my_tosort_utf32(uni_plane, &wc);
MY_HASH_ADD(m1, m2, (uint) (wc >> 24));
MY_HASH_ADD(m1, m2, (uint) (wc >> 16) & 0xFF);
MY_HASH_ADD(m1, m2, (uint) (wc >> 8) & 0xFF);
MY_HASH_ADD(m1, m2, (uint) (wc & 0xFF));
s+= res;
}
*nr1= m1;
*nr2= m2;
} | O3 | c | my_hash_sort_utf32_nopad:
movq (%rcx), %r10
movq (%r8), %rax
cmpq $0x4, %rdx
jl 0xce6a9
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
addq %rsi, %rdx
movq 0x78(%rdi), %rdi
movl $0xff, %r9d
movzbl (%rsi), %ebx
shll $0x18, %ebx
movzbl 0x1(%rsi), %r11d
shll $0x10, %r11d
orl %ebx, %r11d
cmpl $0x10ffff, %r11d # imm = 0x10FFFF
ja 0xce6a3
movzbl 0x2(%rsi), %r14d
shll $0x8, %r14d
movzbl 0x3(%rsi), %ebx
orq %rbx, %r14
orq %r11, %r14
movl $0xfffd, %r11d # imm = 0xFFFD
cmpq (%rdi), %r14
ja 0xce5f9
movq 0x8(%rdi), %r11
movl %r14d, %r15d
shrl $0x8, %r15d
movq (%r11,%r15,8), %r15
movq %r14, %r11
testq %r15, %r15
je 0xce5f9
leaq (%rbx,%rbx,2), %r11
movl 0x8(%r15,%r11,4), %r11d
movl %r10d, %ebx
andl $0x3f, %ebx
addq %rax, %rbx
movl %r11d, %r14d
shrl $0x18, %r14d
imulq %rbx, %r14
movq %r10, %rbx
shlq $0x8, %rbx
addq %r14, %rbx
xorq %r10, %rbx
movl %ebx, %r10d
andl $0x3f, %r10d
addq %rax, %r10
addq $0x3, %r10
movl %r11d, %r14d
shrl $0x10, %r14d
andl %r9d, %r14d
imulq %r10, %r14
movq %rbx, %r10
shlq $0x8, %r10
addq %r14, %r10
xorq %rbx, %r10
movl %r10d, %ebx
andl $0x3f, %ebx
addq %rax, %rbx
addq $0x6, %rbx
movl %r11d, %r14d
shrl $0x8, %r14d
andl %r9d, %r14d
imulq %rbx, %r14
movq %r10, %rbx
shlq $0x8, %rbx
addq %r14, %rbx
xorq %r10, %rbx
movl %ebx, %r10d
andl $0x3f, %r10d
addq %rax, %r10
addq $0x9, %r10
movzbl %r11b, %r11d
imulq %r10, %r11
movq %rbx, %r10
shlq $0x8, %r10
addq %r11, %r10
xorq %rbx, %r10
addq $0xc, %rax
leaq 0x8(%rsi), %r11
addq $0x4, %rsi
cmpq %rdx, %r11
jbe 0xce59c
popq %rbx
popq %r14
popq %r15
popq %rbp
movq %r10, (%rcx)
movq %rax, (%r8)
retq
| my_hash_sort_utf32_nopad:
mov r10, [rcx]
mov rax, [r8]
cmp rdx, 4
jl loc_CE6A9
push rbp
mov rbp, rsp
push r15
push r14
push rbx
add rdx, rsi
mov rdi, [rdi+78h]
mov r9d, 0FFh
loc_CE59C:
movzx ebx, byte ptr [rsi]
shl ebx, 18h
movzx r11d, byte ptr [rsi+1]
shl r11d, 10h
or r11d, ebx
cmp r11d, offset unk_10FFFF
ja loc_CE6A3
movzx r14d, byte ptr [rsi+2]
shl r14d, 8
movzx ebx, byte ptr [rsi+3]
or r14, rbx
or r14, r11
mov r11d, 0FFFDh
cmp r14, [rdi]
ja short loc_CE5F9
mov r11, [rdi+8]
mov r15d, r14d
shr r15d, 8
mov r15, [r11+r15*8]
mov r11, r14
test r15, r15
jz short loc_CE5F9
lea r11, [rbx+rbx*2]
mov r11d, [r15+r11*4+8]
loc_CE5F9:
mov ebx, r10d
and ebx, 3Fh
add rbx, rax
mov r14d, r11d
shr r14d, 18h
imul r14, rbx
mov rbx, r10
shl rbx, 8
add rbx, r14
xor rbx, r10
mov r10d, ebx
and r10d, 3Fh
add r10, rax
add r10, 3
mov r14d, r11d
shr r14d, 10h
and r14d, r9d
imul r14, r10
mov r10, rbx
shl r10, 8
add r10, r14
xor r10, rbx
mov ebx, r10d
and ebx, 3Fh
add rbx, rax
add rbx, 6
mov r14d, r11d
shr r14d, 8
and r14d, r9d
imul r14, rbx
mov rbx, r10
shl rbx, 8
add rbx, r14
xor rbx, r10
mov r10d, ebx
and r10d, 3Fh
add r10, rax
add r10, 9
movzx r11d, r11b
imul r11, r10
mov r10, rbx
shl r10, 8
add r10, r11
xor r10, rbx
add rax, 0Ch
lea r11, [rsi+8]
add rsi, 4
cmp r11, rdx
jbe loc_CE59C
loc_CE6A3:
pop rbx
pop r14
pop r15
pop rbp
loc_CE6A9:
mov [rcx], r10
mov [r8], rax
retn
| long long my_hash_sort_utf32_nopad(long long a1, unsigned __int8 *a2, long long a3, long long *a4, long long *a5)
{
long long v5; // r10
long long result; // rax
unsigned __int8 *v7; // rdx
unsigned long long *v8; // rdi
long long v9; // r11
long long v10; // rbx
unsigned long long v11; // r14
unsigned int v12; // r11d
long long v13; // r15
long long v14; // r10
long long v15; // r14
unsigned __int8 *v16; // r11
v5 = *a4;
result = *a5;
if ( a3 >= 4 )
{
v7 = &a2[a3];
v8 = *(unsigned long long **)(a1 + 120);
do
{
v9 = (*a2 << 24) | (a2[1] << 16);
if ( (unsigned int)v9 > (unsigned int)&unk_10FFFF )
break;
v10 = a2[3];
v11 = v9 | v10 | (a2[2] << 8);
v12 = 65533;
if ( v11 <= *v8 )
{
v13 = *(_QWORD *)(v8[1] + 8LL * ((unsigned int)v11 >> 8));
v12 = v11;
if ( v13 )
v12 = *(_DWORD *)(v13 + 12 * v10 + 8);
}
v14 = v5 ^ ((result + (v5 & 0x3F)) * HIBYTE(v12) + (v5 << 8)) ^ ((result
+ (((unsigned __int8)v5 ^ (unsigned __int8)((result + (v5 & 0x3F)) * HIBYTE(v12))) & 0x3F)
+ 3)
* BYTE2(v12)
+ ((v5 ^ ((result + (v5 & 0x3F)) * HIBYTE(v12)
+ (v5 << 8))) << 8));
v15 = (result + (v14 & 0x3F) + 6) * BYTE1(v12);
v5 = v14 ^ (v15 + (v14 << 8)) ^ ((result + (((unsigned __int8)v14 ^ (unsigned __int8)v15) & 0x3F) + 9)
* (unsigned __int8)v12
+ ((v14 ^ (v15 + (v14 << 8))) << 8));
result += 12LL;
v16 = a2 + 8;
a2 += 4;
}
while ( v16 <= v7 );
}
*a4 = v5;
*a5 = result;
return result;
}
| my_hash_sort_utf32_nopad:
MOV R10,qword ptr [RCX]
MOV RAX,qword ptr [R8]
CMP RDX,0x4
JL 0x001ce6a9
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
ADD RDX,RSI
MOV RDI,qword ptr [RDI + 0x78]
MOV R9D,0xff
LAB_001ce59c:
MOVZX EBX,byte ptr [RSI]
SHL EBX,0x18
MOVZX R11D,byte ptr [RSI + 0x1]
SHL R11D,0x10
OR R11D,EBX
CMP R11D,0x10ffff
JA 0x001ce6a3
MOVZX R14D,byte ptr [RSI + 0x2]
SHL R14D,0x8
MOVZX EBX,byte ptr [RSI + 0x3]
OR R14,RBX
OR R14,R11
MOV R11D,0xfffd
CMP R14,qword ptr [RDI]
JA 0x001ce5f9
MOV R11,qword ptr [RDI + 0x8]
MOV R15D,R14D
SHR R15D,0x8
MOV R15,qword ptr [R11 + R15*0x8]
MOV R11,R14
TEST R15,R15
JZ 0x001ce5f9
LEA R11,[RBX + RBX*0x2]
MOV R11D,dword ptr [R15 + R11*0x4 + 0x8]
LAB_001ce5f9:
MOV EBX,R10D
AND EBX,0x3f
ADD RBX,RAX
MOV R14D,R11D
SHR R14D,0x18
IMUL R14,RBX
MOV RBX,R10
SHL RBX,0x8
ADD RBX,R14
XOR RBX,R10
MOV R10D,EBX
AND R10D,0x3f
ADD R10,RAX
ADD R10,0x3
MOV R14D,R11D
SHR R14D,0x10
AND R14D,R9D
IMUL R14,R10
MOV R10,RBX
SHL R10,0x8
ADD R10,R14
XOR R10,RBX
MOV EBX,R10D
AND EBX,0x3f
ADD RBX,RAX
ADD RBX,0x6
MOV R14D,R11D
SHR R14D,0x8
AND R14D,R9D
IMUL R14,RBX
MOV RBX,R10
SHL RBX,0x8
ADD RBX,R14
XOR RBX,R10
MOV R10D,EBX
AND R10D,0x3f
ADD R10,RAX
ADD R10,0x9
MOVZX R11D,R11B
IMUL R11,R10
MOV R10,RBX
SHL R10,0x8
ADD R10,R11
XOR R10,RBX
ADD RAX,0xc
LEA R11,[RSI + 0x8]
ADD RSI,0x4
CMP R11,RDX
JBE 0x001ce59c
LAB_001ce6a3:
POP RBX
POP R14
POP R15
POP RBP
LAB_001ce6a9:
MOV qword ptr [RCX],R10
MOV qword ptr [R8],RAX
RET
|
void my_hash_sort_utf32_nopad(long param_1,byte *param_2,long param_3,ulong *param_4,long *param_5)
{
byte *pbVar1;
long lVar2;
long lVar3;
byte *pbVar4;
ulong uVar5;
uint uVar6;
ulong uVar7;
ulong uVar8;
uVar5 = *param_4;
lVar3 = *param_5;
if (3 < param_3) {
pbVar4 = param_2 + param_3;
do {
uVar6 = (uint)param_2[1] << 0x10 | (uint)*param_2 << 0x18;
if (0x10ffff < uVar6) break;
uVar8 = (ulong)CONCAT11(param_2[2],param_2[3]) | (ulong)uVar6;
uVar7 = 0xfffd;
if ((uVar8 <= **(ulong **)(param_1 + 0x78)) &&
(lVar2 = *(long *)((*(ulong **)(param_1 + 0x78))[1] + (uVar8 >> 8) * 8), uVar7 = uVar8,
lVar2 != 0)) {
uVar7 = (ulong)*(uint *)(lVar2 + 8 + (ulong)param_2[3] * 0xc);
}
uVar5 = uVar5 * 0x100 + (uVar7 >> 0x18) * ((ulong)((uint)uVar5 & 0x3f) + lVar3) ^ uVar5;
uVar5 = uVar5 * 0x100 +
(ulong)((uint)(uVar7 >> 0x10) & 0xff) * ((ulong)((uint)uVar5 & 0x3f) + lVar3 + 3) ^
uVar5;
uVar5 = uVar5 * 0x100 +
(ulong)((uint)(uVar7 >> 8) & 0xff) * ((ulong)((uint)uVar5 & 0x3f) + lVar3 + 6) ^ uVar5
;
uVar5 = uVar5 * 0x100 + (uVar7 & 0xff) * ((ulong)((uint)uVar5 & 0x3f) + lVar3 + 9) ^ uVar5;
lVar3 = lVar3 + 0xc;
pbVar1 = param_2 + 8;
param_2 = param_2 + 4;
} while (pbVar1 <= pbVar4);
}
*param_4 = uVar5;
*param_5 = lVar3;
return;
}
| |
43,538 | testing::internal::UnitTestImpl::RecordProperty(testing::TestProperty const&) | AlayaLite/build_O0/_deps/googletest-src/googletest/src/gtest.cc | void UnitTestImpl::RecordProperty(const TestProperty& test_property) {
std::string xml_element;
TestResult* test_result; // TestResult appropriate for property recording.
if (current_test_info_ != nullptr) {
xml_element = "testcase";
test_result = &(current_test_info_->result_);
} else if (current_test_suite_ != nullptr) {
xml_element = "testsuite";
test_result = &(current_test_suite_->ad_hoc_test_result_);
} else {
xml_element = "testsuites";
test_result = &ad_hoc_test_result_;
}
test_result->RecordProperty(xml_element, test_property);
} | O0 | cpp | testing::internal::UnitTestImpl::RecordProperty(testing::TestProperty const&):
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x117b0
movq 0x8(%rsp), %rax
cmpq $0x0, 0x1e0(%rax)
je 0x3ba0a
leaq 0x39a75(%rip), %rsi # 0x7543d
leaq 0x28(%rsp), %rdi
callq 0x464f0
jmp 0x3b9d4
movq 0x8(%rsp), %rax
movq 0x1e0(%rax), %rax
addq $0x90, %rax
movq %rax, 0x20(%rsp)
jmp 0x3ba6a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xec60
jmp 0x3ba8f
movq 0x8(%rsp), %rax
cmpq $0x0, 0x1d8(%rax)
je 0x3ba45
leaq 0x399d8(%rip), %rsi # 0x753f8
leaq 0x28(%rsp), %rdi
callq 0x464f0
jmp 0x3ba2c
movq 0x8(%rsp), %rax
movq 0x1d8(%rax), %rax
addq $0x88, %rax
movq %rax, 0x20(%rsp)
jmp 0x3ba68
leaq 0x39ac5(%rip), %rsi # 0x75511
leaq 0x28(%rsp), %rdi
callq 0x464f0
jmp 0x3ba58
movq 0x8(%rsp), %rax
addq $0x1e8, %rax # imm = 0x1E8
movq %rax, 0x20(%rsp)
jmp 0x3ba6a
movq 0x20(%rsp), %rdi
movq 0x48(%rsp), %rdx
leaq 0x28(%rsp), %rsi
callq 0x27830
jmp 0x3ba80
leaq 0x28(%rsp), %rdi
callq 0xec60
addq $0x58, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0xb910
nopl (%rax)
| _ZN7testing8internal12UnitTestImpl14RecordPropertyERKNS_12TestPropertyE:
sub rsp, 58h
mov [rsp+58h+var_8], rdi
mov [rsp+58h+var_10], rsi
mov rax, [rsp+58h+var_8]
mov [rsp+58h+var_50], rax
lea rdi, [rsp+58h+var_30]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2Ev; std::string::basic_string(void)
mov rax, [rsp+58h+var_50]
cmp qword ptr [rax+1E0h], 0
jz short loc_3BA0A
lea rsi, aTestcase+5; "testcase"
lea rdi, [rsp+58h+var_30]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEPKc; std::string::operator=(char const*)
jmp short $+2
loc_3B9D4:
mov rax, [rsp+58h+var_50]
mov rax, [rax+1E0h]
add rax, 90h
mov [rsp+58h+var_38], rax
jmp short loc_3BA6A
mov rcx, rax
mov eax, edx
mov [rsp+arg_10], rcx
mov [rsp+arg_C], eax
lea rdi, [rsp+arg_20]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp loc_3BA8F
loc_3BA0A:
mov rax, [rsp+58h+var_50]
cmp qword ptr [rax+1D8h], 0
jz short loc_3BA45
lea rsi, aTestsuite+3; "testsuite"
lea rdi, [rsp+58h+var_30]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEPKc; std::string::operator=(char const*)
jmp short $+2
loc_3BA2C:
mov rax, [rsp+58h+var_50]
mov rax, [rax+1D8h]
add rax, 88h
mov [rsp+58h+var_38], rax
jmp short loc_3BA68
loc_3BA45:
lea rsi, aTestsuites; "testsuites"
lea rdi, [rsp+58h+var_30]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEPKc; std::string::operator=(char const*)
jmp short $+2
loc_3BA58:
mov rax, [rsp+58h+var_50]
add rax, 1E8h
mov [rsp+58h+var_38], rax
loc_3BA68:
jmp short $+2
loc_3BA6A:
mov rdi, [rsp+58h+var_38]
mov rdx, [rsp+58h+var_10]
lea rsi, [rsp+58h+var_30]
call _ZN7testing10TestResult14RecordPropertyERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_12TestPropertyE; testing::TestResult::RecordProperty(std::string const&,testing::TestProperty const&)
jmp short $+2
loc_3BA80:
lea rdi, [rsp+58h+var_30]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
add rsp, 58h
retn
loc_3BA8F:
mov rdi, [rsp+arg_10]
call __Unwind_Resume
| void testing::internal::UnitTestImpl::RecordProperty(
testing::internal::UnitTestImpl *this,
const testing::TestProperty *a2)
{
int v2; // ecx
int v3; // r8d
int v4; // r9d
int v5; // ecx
int v6; // r8d
int v7; // r9d
int v8; // ecx
int v9; // r8d
int v10; // r9d
_QWORD v11[4]; // [rsp+28h] [rbp-30h] BYREF
testing::TestProperty *v12; // [rsp+48h] [rbp-10h]
testing::internal::UnitTestImpl *v13; // [rsp+50h] [rbp-8h]
v13 = this;
v12 = a2;
std::string::basic_string(v11);
if ( *((_QWORD *)this + 60) )
{
std::string::operator=(v11, "testcase");
testing::TestResult::RecordProperty(
(testing::internal::MutexBase *)(*((_QWORD *)this + 60) + 144LL),
(long long)v11,
v12,
v2,
v3,
v4);
}
else if ( *((_QWORD *)this + 59) )
{
std::string::operator=(v11, "testsuite");
testing::TestResult::RecordProperty(
(testing::internal::MutexBase *)(*((_QWORD *)this + 59) + 136LL),
(long long)v11,
v12,
v5,
v6,
v7);
}
else
{
std::string::operator=(v11, "testsuites");
testing::TestResult::RecordProperty(
(testing::internal::UnitTestImpl *)((char *)this + 488),
(long long)v11,
v12,
v8,
v9,
v10);
}
std::string::~string(v11);
}
| RecordProperty:
SUB RSP,0x58
MOV qword ptr [RSP + 0x50],RDI
MOV qword ptr [RSP + 0x48],RSI
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x8],RAX
LEA RDI,[RSP + 0x28]
CALL 0x001117b0
MOV RAX,qword ptr [RSP + 0x8]
CMP qword ptr [RAX + 0x1e0],0x0
JZ 0x0013ba0a
LAB_0013b9c1:
LEA RSI,[0x17543d]
LEA RDI,[RSP + 0x28]
CALL 0x001464f0
JMP 0x0013b9d4
LAB_0013b9d4:
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX + 0x1e0]
ADD RAX,0x90
MOV qword ptr [RSP + 0x20],RAX
JMP 0x0013ba6a
LAB_0013ba0a:
MOV RAX,qword ptr [RSP + 0x8]
CMP qword ptr [RAX + 0x1d8],0x0
JZ 0x0013ba45
LEA RSI,[0x1753f8]
LEA RDI,[RSP + 0x28]
CALL 0x001464f0
JMP 0x0013ba2c
LAB_0013ba2c:
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX + 0x1d8]
ADD RAX,0x88
MOV qword ptr [RSP + 0x20],RAX
JMP 0x0013ba68
LAB_0013ba45:
LEA RSI,[0x175511]
LEA RDI,[RSP + 0x28]
CALL 0x001464f0
JMP 0x0013ba58
LAB_0013ba58:
MOV RAX,qword ptr [RSP + 0x8]
ADD RAX,0x1e8
MOV qword ptr [RSP + 0x20],RAX
LAB_0013ba68:
JMP 0x0013ba6a
LAB_0013ba6a:
MOV RDI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x48]
LEA RSI,[RSP + 0x28]
CALL 0x00127830
LAB_0013ba7e:
JMP 0x0013ba80
LAB_0013ba80:
LEA RDI,[RSP + 0x28]
CALL 0x0010ec60
ADD RSP,0x58
RET
|
/* testing::internal::UnitTestImpl::RecordProperty(testing::TestProperty const&) */
void __thiscall
testing::internal::UnitTestImpl::RecordProperty(UnitTestImpl *this,TestProperty *param_1)
{
TestResult *local_38;
string local_30 [32];
TestProperty *local_10;
UnitTestImpl *local_8;
local_10 = param_1;
local_8 = this;
std::__cxx11::string::string(local_30);
if (*(long *)(this + 0x1e0) == 0) {
if (*(long *)(this + 0x1d8) == 0) {
std::__cxx11::string::operator=(local_30,"testsuites");
local_38 = (TestResult *)(this + 0x1e8);
}
else {
std::__cxx11::string::operator=(local_30,"testsuite");
local_38 = (TestResult *)(*(long *)(this + 0x1d8) + 0x88);
}
}
else {
/* try { // try from 0013b9c1 to 0013ba7d has its CatchHandler @ 0013b9ed */
std::__cxx11::string::operator=(local_30,"testcase");
local_38 = (TestResult *)(*(long *)(this + 0x1e0) + 0x90);
}
TestResult::RecordProperty(local_38,local_30,local_10);
std::__cxx11::string::~string(local_30);
return;
}
| |
43,539 | minja::ArgumentsValue::get_named(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | llama.cpp/common/minja/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 0x7b5ba
movq (%rdx), %r15
movq 0x8(%rdx), %r12
cmpq %r12, 0x8(%r14)
jne 0x7b5b1
testq %r12, %r12
je 0x7b5f8
movq (%r14), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1c880
testl %eax, %eax
je 0x7b5f8
addq $0x70, %r14
cmpq %r13, %r14
jne 0x7b594
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 0x732fc
movq %r14, %rdi
movl $0x1, %esi
callq 0x732fc
jmp 0x7b607
addq $0x20, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x74a14
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_7B5BA
mov r15, [rdx]
mov r12, [rdx+8]
loc_7B594:
cmp [r14+8], r12
jnz short loc_7B5B1
test r12, r12
jz short loc_7B5F8
mov rdi, [r14]
mov rsi, r15
mov rdx, r12
call _bcmp
test eax, eax
jz short loc_7B5F8
loc_7B5B1:
add r14, 70h ; 'p'
cmp r14, r13
jnz short loc_7B594
loc_7B5BA:
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_7B607
loc_7B5F8:
add r14, 20h ; ' '
mov rdi, rbx; this
mov rsi, r14; minja::Value *
call _ZN5minja5ValueC2ERKS0_; minja::Value::Value(minja::Value const&)
loc_7B607:
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 0x0017b5ba
MOV R15,qword ptr [RDX]
MOV R12,qword ptr [RDX + 0x8]
LAB_0017b594:
CMP qword ptr [R14 + 0x8],R12
JNZ 0x0017b5b1
TEST R12,R12
JZ 0x0017b5f8
MOV RDI,qword ptr [R14]
MOV RSI,R15
MOV RDX,R12
CALL 0x0011c880
TEST EAX,EAX
JZ 0x0017b5f8
LAB_0017b5b1:
ADD R14,0x70
CMP R14,R13
JNZ 0x0017b594
LAB_0017b5ba:
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 0x001732fc
MOV RDI,R14
MOV ESI,0x1
CALL 0x001732fc
JMP 0x0017b607
LAB_0017b5f8:
ADD R14,0x20
MOV RDI,RBX
MOV RSI,R14
CALL 0x00174a14
LAB_0017b607:
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)))
) {
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;
}
| |
43,540 | mysql_real_query_start | eloqsql/libmariadb/libmariadb/mariadb_async.c | int STDCALL
mysql_real_query_start(int *ret, MYSQL *mysql, const char *stmt_str, unsigned long length)
{
int res;
struct mysql_async_context *b;
struct mysql_real_query_params parms;
b= mysql->options.extension->async_context;
{
WIN_SET_NONBLOCKING(mysql)
parms.mysql= mysql;
parms.stmt_str= stmt_str;
parms.length= length;
}
b->active= 1;
res= my_context_spawn(&b->async_context, mysql_real_query_start_internal, &parms);
b->active= b->suspended= 0;
if (res > 0)
{
/* Suspended. */
b->suspended= 1;
return b->events_to_wait_for;
}
if (res < 0)
{
set_mariadb_error((mysql), CR_OUT_OF_MEMORY, unknown_sqlstate);
*ret= 1;
}
else
*ret= b->ret_result.r_int;
return 0;
} | O0 | c | mysql_real_query_start:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movb $0x1, 0x14(%rax)
movq -0x38(%rbp), %rdi
addq $0x38, %rdi
leaq 0xd6(%rip), %rsi # 0x38190
leaq -0x50(%rbp), %rdx
callq 0x3f310
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rax
movb $0x0, 0x15(%rax)
movq -0x38(%rbp), %rax
movb $0x0, 0x14(%rax)
cmpl $0x0, -0x2c(%rbp)
jle 0x380f2
movq -0x38(%rbp), %rax
movb $0x1, 0x15(%rax)
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x3817d
cmpl $0x0, -0x2c(%rbp)
jge 0x38169
jmp 0x380fa
movq -0x18(%rbp), %rax
movl $0x7d8, 0x90(%rax) # imm = 0x7D8
movq -0x18(%rbp), %rdi
addq $0x297, %rdi # imm = 0x297
leaq 0x27d66(%rip), %rax # 0x5fe80
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13210
movq -0x18(%rbp), %rax
movb $0x0, 0x29c(%rax)
movq -0x18(%rbp), %rdi
addq $0x97, %rdi
leaq 0x27d4c(%rip), %rax # 0x5fe90
movq 0x40(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x13210
movq -0x18(%rbp), %rax
movb $0x0, 0x296(%rax)
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
jmp 0x38176
movq -0x38(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| mysql_real_query_start:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_18]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov [rbp+var_38], rax
mov rax, [rbp+var_18]
mov [rbp+var_50], rax
mov rax, [rbp+var_20]
mov [rbp+var_48], rax
mov rax, [rbp+var_28]
mov [rbp+var_40], rax
mov rax, [rbp+var_38]
mov byte ptr [rax+14h], 1
mov rdi, [rbp+var_38]
add rdi, 38h ; '8'
lea rsi, mysql_real_query_start_internal
lea rdx, [rbp+var_50]
call my_context_spawn
mov [rbp+var_2C], eax
mov rax, [rbp+var_38]
mov byte ptr [rax+15h], 0
mov rax, [rbp+var_38]
mov byte ptr [rax+14h], 0
cmp [rbp+var_2C], 0
jle short loc_380F2
mov rax, [rbp+var_38]
mov byte ptr [rax+15h], 1
mov rax, [rbp+var_38]
mov eax, [rax]
mov [rbp+var_4], eax
jmp loc_3817D
loc_380F2:
cmp [rbp+var_2C], 0
jge short loc_38169
jmp short $+2
loc_380FA:
mov rax, [rbp+var_18]
mov dword ptr [rax+90h], 7D8h
mov rdi, [rbp+var_18]
add rdi, 297h
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [rbp+var_18]
mov byte ptr [rax+29Ch], 0
mov rdi, [rbp+var_18]
add rdi, 97h
lea rax, client_errors
mov rsi, [rax+40h]
mov edx, 1FFh
call _strncpy
mov rax, [rbp+var_18]
mov byte ptr [rax+296h], 0
mov rax, [rbp+var_10]
mov dword ptr [rax], 1
jmp short loc_38176
loc_38169:
mov rax, [rbp+var_38]
mov ecx, [rax+8]
mov rax, [rbp+var_10]
mov [rax], ecx
loc_38176:
mov [rbp+var_4], 0
loc_3817D:
mov eax, [rbp+var_4]
add rsp, 50h
pop rbp
retn
| long long mysql_real_query_start(_DWORD *a1, long long a2, long long a3, long long a4)
{
_QWORD v5[3]; // [rsp+0h] [rbp-50h] BYREF
unsigned int *v6; // [rsp+18h] [rbp-38h]
int v7; // [rsp+24h] [rbp-2Ch]
long long v8; // [rsp+28h] [rbp-28h]
long long v9; // [rsp+30h] [rbp-20h]
long long v10; // [rsp+38h] [rbp-18h]
_DWORD *v11; // [rsp+40h] [rbp-10h]
v11 = a1;
v10 = a2;
v9 = a3;
v8 = a4;
v6 = *(unsigned int **)(*(_QWORD *)(a2 + 1152) + 40LL);
v5[0] = a2;
v5[1] = a3;
v5[2] = a4;
*((_BYTE *)v6 + 20) = 1;
v7 = my_context_spawn(v6 + 14, mysql_real_query_start_internal, v5);
*((_BYTE *)v6 + 21) = 0;
*((_BYTE *)v6 + 20) = 0;
if ( v7 <= 0 )
{
if ( v7 >= 0 )
{
*v11 = v6[2];
}
else
{
*(_DWORD *)(v10 + 144) = 2008;
strncpy(v10 + 663, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(v10 + 668) = 0;
strncpy(v10 + 151, client_errors[8], 511LL);
*(_BYTE *)(v10 + 662) = 0;
*v11 = 1;
}
return 0;
}
else
{
*((_BYTE *)v6 + 21) = 1;
return *v6;
}
}
| mysql_real_query_start:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX + 0x14],0x1
MOV RDI,qword ptr [RBP + -0x38]
ADD RDI,0x38
LEA RSI,[0x138190]
LEA RDX,[RBP + -0x50]
CALL 0x0013f310
MOV dword ptr [RBP + -0x2c],EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX + 0x15],0x0
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX + 0x14],0x0
CMP dword ptr [RBP + -0x2c],0x0
JLE 0x001380f2
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX + 0x15],0x1
MOV RAX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0013817d
LAB_001380f2:
CMP dword ptr [RBP + -0x2c],0x0
JGE 0x00138169
JMP 0x001380fa
LAB_001380fa:
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x90],0x7d8
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x297
LEA RAX,[0x15fe80]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113210
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x29c],0x0
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x97
LEA RAX,[0x15fe90]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x1ff
CALL 0x00113210
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x296],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],0x1
JMP 0x00138176
LAB_00138169:
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],ECX
LAB_00138176:
MOV dword ptr [RBP + -0x4],0x0
LAB_0013817d:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x50
POP RBP
RET
|
int4
mysql_real_query_start(int4 *param_1,long param_2,int8 param_3,int8 param_4)
{
long local_58;
int8 local_50;
int8 local_48;
int4 *local_40;
int local_34;
int8 local_30;
int8 local_28;
long local_20;
int4 *local_18;
int4 local_c;
local_40 = *(int4 **)(*(long *)(param_2 + 0x480) + 0x28);
*(int1 *)(local_40 + 5) = 1;
local_58 = param_2;
local_50 = param_3;
local_48 = param_4;
local_30 = param_4;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
local_34 = my_context_spawn(local_40 + 0xe,mysql_real_query_start_internal,&local_58);
*(int1 *)((long)local_40 + 0x15) = 0;
*(int1 *)(local_40 + 5) = 0;
if (local_34 < 1) {
if (local_34 < 0) {
*(int4 *)(local_20 + 0x90) = 0x7d8;
strncpy((char *)(local_20 + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(local_20 + 0x29c) = 0;
strncpy((char *)(local_20 + 0x97),PTR_s_Client_run_out_of_memory_0015fed0,0x1ff);
*(int1 *)(local_20 + 0x296) = 0;
*local_18 = 1;
}
else {
*local_18 = local_40[2];
}
local_c = 0;
}
else {
*(int1 *)((long)local_40 + 0x15) = 1;
local_c = *local_40;
}
return local_c;
}
| |
43,541 | mysql_stmt_attr_get | eloqsql/libmariadb/libmariadb/mariadb_stmt.c | my_bool STDCALL mysql_stmt_attr_get(MYSQL_STMT *stmt, enum enum_stmt_attr_type attr_type, void *value)
{
switch (attr_type) {
case STMT_ATTR_STATE:
*(enum mysql_stmt_state *)value= stmt->state;
break;
case STMT_ATTR_UPDATE_MAX_LENGTH:
*(my_bool *)value= stmt->update_max_length;
break;
case STMT_ATTR_CURSOR_TYPE:
*(unsigned long *)value= stmt->flags;
break;
case STMT_ATTR_PREFETCH_ROWS:
*(unsigned long *)value= stmt->prefetch_rows;
break;
case STMT_ATTR_PREBIND_PARAMS:
*(unsigned int *)value= stmt->prebind_params;
break;
case STMT_ATTR_ARRAY_SIZE:
*(unsigned int *)value= stmt->array_size;
break;
case STMT_ATTR_ROW_SIZE:
*(size_t *)value= stmt->row_size;
break;
case STMT_ATTR_CB_USER_DATA:
*((void **)value) = stmt->user_data;
break;
default:
return(1);
}
return(0);
} | O0 | c | mysql_stmt_attr_get:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x29638
jmp 0x295bb
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0x2964a
jmp 0x295c9
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0x2965b
jmp 0x295d7
movl -0x24(%rbp), %eax
subl $0xc8, %eax
je 0x2966f
jmp 0x295e7
movl -0x24(%rbp), %eax
subl $0xc9, %eax
je 0x29681
jmp 0x295f7
movl -0x24(%rbp), %eax
subl $0xca, %eax
je 0x29693
jmp 0x29607
movl -0x24(%rbp), %eax
subl $0xcb, %eax
je 0x29626
jmp 0x29613
movl -0x24(%rbp), %eax
subl $0xcc, %eax
je 0x296a7
jmp 0x296bb
movq -0x10(%rbp), %rax
movl 0x50(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0x296c1
movq -0x10(%rbp), %rax
movb 0x313(%rax), %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
jmp 0x296c1
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x296c1
movq -0x10(%rbp), %rax
movq 0x318(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x296c1
movq -0x10(%rbp), %rax
movl 0x378(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0x296c1
movq -0x10(%rbp), %rax
movl 0x368(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0x296c1
movq -0x10(%rbp), %rax
movq 0x370(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x296c1
movq -0x10(%rbp), %rax
movq 0x380(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x296c1
movb $0x1, -0x1(%rbp)
jmp 0x296c5
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw (%rax,%rax)
| mysql_stmt_attr_get:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov eax, [rbp+var_14]
mov [rbp+var_24], eax
test eax, eax
jz short loc_29638
jmp short $+2
loc_295BB:
mov eax, [rbp+var_24]
sub eax, 1
jz loc_2964A
jmp short $+2
loc_295C9:
mov eax, [rbp+var_24]
sub eax, 2
jz loc_2965B
jmp short $+2
loc_295D7:
mov eax, [rbp+var_24]
sub eax, 0C8h
jz loc_2966F
jmp short $+2
loc_295E7:
mov eax, [rbp+var_24]
sub eax, 0C9h
jz loc_29681
jmp short $+2
loc_295F7:
mov eax, [rbp+var_24]
sub eax, 0CAh
jz loc_29693
jmp short $+2
loc_29607:
mov eax, [rbp+var_24]
sub eax, 0CBh
jz short loc_29626
jmp short $+2
loc_29613:
mov eax, [rbp+var_24]
sub eax, 0CCh
jz loc_296A7
jmp loc_296BB
loc_29626:
mov rax, [rbp+var_10]
mov ecx, [rax+50h]
mov rax, [rbp+var_20]
mov [rax], ecx
jmp loc_296C1
loc_29638:
mov rax, [rbp+var_10]
mov cl, [rax+313h]
mov rax, [rbp+var_20]
mov [rax], cl
jmp short loc_296C1
loc_2964A:
mov rax, [rbp+var_10]
mov rcx, [rax+48h]
mov rax, [rbp+var_20]
mov [rax], rcx
jmp short loc_296C1
loc_2965B:
mov rax, [rbp+var_10]
mov rcx, [rax+318h]
mov rax, [rbp+var_20]
mov [rax], rcx
jmp short loc_296C1
loc_2966F:
mov rax, [rbp+var_10]
mov ecx, [rax+378h]
mov rax, [rbp+var_20]
mov [rax], ecx
jmp short loc_296C1
loc_29681:
mov rax, [rbp+var_10]
mov ecx, [rax+368h]
mov rax, [rbp+var_20]
mov [rax], ecx
jmp short loc_296C1
loc_29693:
mov rax, [rbp+var_10]
mov rcx, [rax+370h]
mov rax, [rbp+var_20]
mov [rax], rcx
jmp short loc_296C1
loc_296A7:
mov rax, [rbp+var_10]
mov rcx, [rax+380h]
mov rax, [rbp+var_20]
mov [rax], rcx
jmp short loc_296C1
loc_296BB:
mov [rbp+var_1], 1
jmp short loc_296C5
loc_296C1:
mov [rbp+var_1], 0
loc_296C5:
mov al, [rbp+var_1]
pop rbp
retn
| char mysql_stmt_attr_get(long long a1, int a2, _BYTE *a3)
{
switch ( a2 )
{
case 0:
*a3 = *(_BYTE *)(a1 + 787);
return 0;
case 1:
*(_QWORD *)a3 = *(_QWORD *)(a1 + 72);
return 0;
case 2:
*(_QWORD *)a3 = *(_QWORD *)(a1 + 792);
return 0;
case 200:
*(_DWORD *)a3 = *(_DWORD *)(a1 + 888);
return 0;
case 201:
*(_DWORD *)a3 = *(_DWORD *)(a1 + 872);
return 0;
case 202:
*(_QWORD *)a3 = *(_QWORD *)(a1 + 880);
return 0;
case 203:
*(_DWORD *)a3 = *(_DWORD *)(a1 + 80);
return 0;
case 204:
*(_QWORD *)a3 = *(_QWORD *)(a1 + 896);
return 0;
}
return 1;
}
| mysql_stmt_attr_get:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x24],EAX
TEST EAX,EAX
JZ 0x00129638
JMP 0x001295bb
LAB_001295bb:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0x1
JZ 0x0012964a
JMP 0x001295c9
LAB_001295c9:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0x2
JZ 0x0012965b
JMP 0x001295d7
LAB_001295d7:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0xc8
JZ 0x0012966f
JMP 0x001295e7
LAB_001295e7:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0xc9
JZ 0x00129681
JMP 0x001295f7
LAB_001295f7:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0xca
JZ 0x00129693
JMP 0x00129607
LAB_00129607:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0xcb
JZ 0x00129626
JMP 0x00129613
LAB_00129613:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0xcc
JZ 0x001296a7
JMP 0x001296bb
LAB_00129626:
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x50]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],ECX
JMP 0x001296c1
LAB_00129638:
MOV RAX,qword ptr [RBP + -0x10]
MOV CL,byte ptr [RAX + 0x313]
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],CL
JMP 0x001296c1
LAB_0012964a:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x48]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
JMP 0x001296c1
LAB_0012965b:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x318]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
JMP 0x001296c1
LAB_0012966f:
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x378]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],ECX
JMP 0x001296c1
LAB_00129681:
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x368]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],ECX
JMP 0x001296c1
LAB_00129693:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x370]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
JMP 0x001296c1
LAB_001296a7:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x380]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
JMP 0x001296c1
LAB_001296bb:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001296c5
LAB_001296c1:
MOV byte ptr [RBP + -0x1],0x0
LAB_001296c5:
MOV AL,byte ptr [RBP + -0x1]
POP RBP
RET
|
int1 mysql_stmt_attr_get(long param_1,int param_2,int8 *param_3)
{
if (param_2 == 0) {
*(int1 *)param_3 = *(int1 *)(param_1 + 0x313);
}
else if (param_2 == 1) {
*param_3 = *(int8 *)(param_1 + 0x48);
}
else if (param_2 == 2) {
*param_3 = *(int8 *)(param_1 + 0x318);
}
else if (param_2 == 200) {
*(int4 *)param_3 = *(int4 *)(param_1 + 0x378);
}
else if (param_2 == 0xc9) {
*(int4 *)param_3 = *(int4 *)(param_1 + 0x368);
}
else if (param_2 == 0xca) {
*param_3 = *(int8 *)(param_1 + 0x370);
}
else if (param_2 == 0xcb) {
*(int4 *)param_3 = *(int4 *)(param_1 + 0x50);
}
else {
if (param_2 != 0xcc) {
return 1;
}
*param_3 = *(int8 *)(param_1 + 0x380);
}
return 0;
}
| |
43,542 | spdlog::details::fmt_helper::pad2(int, fmt::v8::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | aimrt_mujoco_sim/_deps/spdlog_lib-src/include/spdlog/details/fmt_helper.h | inline void pad2(int n, memory_buf_t &dest)
{
if (n >= 0 && n < 100) // 0-99
{
dest.push_back(static_cast<char>('0' + n / 10));
dest.push_back(static_cast<char>('0' + n % 10));
}
else // unlikely, but just in case, let fmt deal with it
{
fmt::format_to(std::back_inserter(dest), SPDLOG_FMT_RUNTIME("{:02}"), n);
}
} | O0 | c | spdlog::details::fmt_helper::pad2(int, fmt::v8::basic_memory_buffer<char, 250ul, std::allocator<char>>&):
subq $0x108, %rsp # imm = 0x108
movl %edi, 0x4c(%rsp)
movq %rsi, 0x40(%rsp)
cmpl $0x0, 0x4c(%rsp)
jl 0xdaff9
cmpl $0x64, 0x4c(%rsp)
jge 0xdaff9
movq 0x40(%rsp), %rdi
movl 0x4c(%rsp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
addl $0x30, %eax
movb %al, 0x3f(%rsp)
leaq 0x3f(%rsp), %rsi
callq 0x9a6a0
movq 0x40(%rsp), %rdi
movl 0x4c(%rsp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
addl $0x30, %edx
movb %dl, %al
movb %al, 0x3e(%rsp)
leaq 0x3e(%rsp), %rsi
callq 0x9a6a0
jmp 0xdb17b
movq 0x40(%rsp), %rdi
callq 0xdb470
movq %rax, 0x30(%rsp)
leaq 0x38014(%rip), %rdi # 0x113023
callq 0xdb4a0
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x20(%rsp), %rdi
callq 0xdb500
movq 0x30(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rdx, 0xa8(%rsp)
movq %rcx, 0x98(%rsp)
movq %rax, 0xa0(%rsp)
leaq 0x4c(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x88(%rsp)
leaq 0x98(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq 0xb8(%rsp), %rax
movups (%rax), %xmm0
movaps %xmm0, 0xc0(%rsp)
movq 0xc0(%rsp), %rcx
movq 0xc8(%rsp), %rax
movq %rcx, 0x78(%rsp)
movq %rax, 0x80(%rsp)
movq 0x90(%rsp), %rdi
callq 0xdb600
movq %rax, 0x50(%rsp)
movq %rdx, 0x58(%rsp)
leaq 0x68(%rsp), %rax
movq %rax, 0xe0(%rsp)
leaq 0x50(%rsp), %rax
movq %rax, 0xd8(%rsp)
movq 0xe0(%rsp), %rcx
movq 0xd8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
movq %rcx, 0x100(%rsp)
movq $0x1, 0xf8(%rsp)
movq %rax, 0xf0(%rsp)
movq 0x100(%rsp), %rax
movq 0xf8(%rsp), %rcx
movq %rcx, (%rax)
movq 0xf0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x88(%rsp), %rdi
movq 0x78(%rsp), %rsi
movq 0x80(%rsp), %rdx
movq 0x68(%rsp), %rcx
movq 0x70(%rsp), %r8
callq 0xdb530
movq %rax, 0xb0(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x108, %rsp # imm = 0x108
retq
nopw %cs:(%rax,%rax)
| _ZN6spdlog7details10fmt_helper4pad2EiRN3fmt2v819basic_memory_bufferIcLm250ESaIcEEE:
sub rsp, 108h
mov [rsp+108h+var_BC], edi
mov [rsp+108h+var_C8], rsi
cmp [rsp+108h+var_BC], 0
jl short loc_DAFF9
cmp [rsp+108h+var_BC], 64h ; 'd'
jge short loc_DAFF9
mov rdi, [rsp+108h+var_C8]
mov eax, [rsp+108h+var_BC]
mov ecx, 0Ah
cdq
idiv ecx
add eax, 30h ; '0'
mov [rsp+108h+var_C9], al
lea rsi, [rsp+108h+var_C9]
call _ZN3fmt2v86detail6bufferIcE9push_backERKc; fmt::v8::detail::buffer<char>::push_back(char const&)
mov rdi, [rsp+108h+var_C8]
mov eax, [rsp+108h+var_BC]
mov ecx, 0Ah
cdq
idiv ecx
add edx, 30h ; '0'
mov al, dl
mov [rsp+108h+var_CA], al
lea rsi, [rsp+108h+var_CA]
call _ZN3fmt2v86detail6bufferIcE9push_backERKc; fmt::v8::detail::buffer<char>::push_back(char const&)
jmp loc_DB17B
loc_DAFF9:
mov rdi, [rsp+108h+var_C8]
call _ZSt13back_inserterIN3fmt2v819basic_memory_bufferIcLm250ESaIcEEEESt20back_insert_iteratorIT_ERS6_; std::back_inserter<fmt::v8::basic_memory_buffer<char,250ul,std::allocator<char>>>(fmt::v8::basic_memory_buffer<char,250ul,std::allocator<char>>&)
mov [rsp+108h+var_D8], rax
lea rdi, a02; "{:02}"
call _ZN3fmt2v87runtimeIA6_cEENS0_13basic_runtimeINS0_6detail11char_t_implIT_vE4typeEEERKS6_; fmt::v8::runtime<char [6]>(char [6] const&)
mov [rsp+108h+var_F8], rax
mov [rsp+108h+var_F0], rdx
mov rsi, [rsp+108h+var_F8]
mov rdx, [rsp+108h+var_F0]
lea rdi, [rsp+108h+var_E8]
call _ZN3fmt2v819basic_format_stringIcJRiEEC2ENS0_13basic_runtimeIcEE; fmt::v8::basic_format_string<char,int &>::basic_format_string(fmt::v8::basic_runtime<char>)
mov rdx, [rsp+108h+var_D8]
mov rcx, [rsp+108h+var_E8]
mov rax, [rsp+108h+var_E0]
mov [rsp+108h+var_60], rdx
mov [rsp+108h+var_70], rcx
mov [rsp+108h+var_68], rax
lea rax, [rsp+108h+var_BC]
mov [rsp+108h+var_78], rax
mov rax, [rsp+108h+var_60]
mov [rsp+108h+var_80], rax
lea rax, [rsp+108h+var_70]
mov [rsp+108h+var_50], rax
mov rax, [rsp+108h+var_50]
movups xmm0, xmmword ptr [rax]
movaps [rsp+108h+var_48], xmm0
mov rcx, qword ptr [rsp+108h+var_48]
mov rax, qword ptr [rsp+108h+var_48+8]
mov [rsp+108h+var_90], rcx
mov [rsp+108h+var_88], rax
mov rdi, [rsp+108h+var_78]
call _ZN3fmt2v816make_format_argsINS0_20basic_format_contextINS0_8appenderEcEEJiEEENS0_16format_arg_storeIT_JDpT0_EEEDpRKS7_; fmt::v8::make_format_args<fmt::v8::basic_format_context<fmt::v8::appender,char>,int>(int const&)
mov [rsp+108h+var_B8], rax
mov [rsp+108h+var_B0], rdx
lea rax, [rsp+108h+var_A0]
mov [rsp+108h+var_28], rax
lea rax, [rsp+108h+var_B8]
mov [rsp+108h+var_30], rax
mov rcx, [rsp+108h+var_28]
mov rax, [rsp+108h+var_30]
mov [rsp+108h+var_20], rax
mov rax, [rsp+108h+var_20]
mov [rsp+108h+var_8], rcx
mov [rsp+108h+var_10], 1
mov [rsp+108h+var_18], rax
mov rax, [rsp+108h+var_8]
mov rcx, [rsp+108h+var_10]
mov [rax], rcx
mov rcx, [rsp+108h+var_18]
mov [rax+8], rcx
mov rdi, [rsp+108h+var_80]
mov rsi, [rsp+108h+var_90]
mov rdx, [rsp+108h+var_88]
mov rcx, [rsp+108h+var_A0]
mov r8, [rsp+108h+var_98]
call _ZN3fmt2v810vformat_toISt20back_insert_iteratorINS0_19basic_memory_bufferIcLm250ESaIcEEEETnNSt9enable_ifIXsr6detail18is_output_iteratorIT_cEE5valueEiE4typeELi0EEES8_S8_NS0_17basic_string_viewIcEENS0_17basic_format_argsINS0_20basic_format_contextINS0_8appenderEcEEEE
mov [rsp+108h+var_58], rax
mov rax, [rsp+108h+var_58]
mov [rsp+108h+var_100], rax
loc_DB17B:
add rsp, 108h
retn
| long long spdlog::details::fmt_helper::pad2(int a1, long long a2)
{
long long v3; // rdx
long long v4; // rdx
long long v5; // [rsp+10h] [rbp-F8h]
__int128 v6; // [rsp+20h] [rbp-E8h] BYREF
long long v7; // [rsp+30h] [rbp-D8h]
char v8; // [rsp+3Eh] [rbp-CAh] BYREF
char v9; // [rsp+3Fh] [rbp-C9h] BYREF
long long v10; // [rsp+40h] [rbp-C8h]
int v11; // [rsp+4Ch] [rbp-BCh] BYREF
_QWORD v12[3]; // [rsp+50h] [rbp-B8h] BYREF
_QWORD v13[2]; // [rsp+68h] [rbp-A0h] BYREF
__int128 v14; // [rsp+78h] [rbp-90h]
long long v15; // [rsp+88h] [rbp-80h]
int *v16; // [rsp+90h] [rbp-78h]
__int128 v17; // [rsp+98h] [rbp-70h] BYREF
long long v18; // [rsp+A8h] [rbp-60h]
__int128 *v19; // [rsp+B8h] [rbp-50h]
__int128 v20; // [rsp+C0h] [rbp-48h]
_QWORD *v21; // [rsp+D8h] [rbp-30h]
_QWORD *v22; // [rsp+E0h] [rbp-28h]
_QWORD *v23; // [rsp+E8h] [rbp-20h]
_QWORD *v24; // [rsp+F0h] [rbp-18h]
long long v25; // [rsp+F8h] [rbp-10h]
_QWORD *v26; // [rsp+100h] [rbp-8h]
v11 = a1;
v10 = a2;
if ( a1 < 0 || v11 >= 100 )
{
v7 = std::back_inserter<fmt::v8::basic_memory_buffer<char,250ul,std::allocator<char>>>(v10);
v5 = fmt::v8::runtime<char [6]>("{:02}");
fmt::v8::basic_format_string<char,int &>::basic_format_string(&v6, v5, v3);
v18 = v7;
v17 = v6;
v16 = &v11;
v15 = v7;
v19 = &v17;
v20 = v6;
v14 = v6;
v12[0] = fmt::v8::make_format_args<fmt::v8::basic_format_context<fmt::v8::appender,char>,int>(&v11);
v12[1] = v4;
v22 = v13;
v21 = v12;
v23 = v12;
v26 = v13;
v25 = 1LL;
v24 = v12;
v13[0] = 1LL;
v13[1] = v12;
return ZN3fmt2v810vformat_toISt20back_insert_iteratorINS0_19basic_memory_bufferIcLm250ESaIcEEEETnNSt9enable_ifIXsr6detail18is_output_iteratorIT_cEE5valueEiE4typeELi0EEES8_S8_NS0_17basic_string_viewIcEENS0_17basic_format_argsINS0_20basic_format_contextINS0_8appenderEcEEEE(
v15,
v14,
*((_QWORD *)&v14 + 1),
1LL,
v12);
}
else
{
v9 = v11 / 10 + 48;
fmt::v8::detail::buffer<char>::push_back(v10, &v9);
v8 = v11 % 10 + 48;
return fmt::v8::detail::buffer<char>::push_back(v10, &v8);
}
}
| pad2:
SUB RSP,0x108
MOV dword ptr [RSP + 0x4c],EDI
MOV qword ptr [RSP + 0x40],RSI
CMP dword ptr [RSP + 0x4c],0x0
JL 0x001daff9
CMP dword ptr [RSP + 0x4c],0x64
JGE 0x001daff9
MOV RDI,qword ptr [RSP + 0x40]
MOV EAX,dword ptr [RSP + 0x4c]
MOV ECX,0xa
CDQ
IDIV ECX
ADD EAX,0x30
MOV byte ptr [RSP + 0x3f],AL
LEA RSI,[RSP + 0x3f]
CALL 0x0019a6a0
MOV RDI,qword ptr [RSP + 0x40]
MOV EAX,dword ptr [RSP + 0x4c]
MOV ECX,0xa
CDQ
IDIV ECX
ADD EDX,0x30
MOV AL,DL
MOV byte ptr [RSP + 0x3e],AL
LEA RSI,[RSP + 0x3e]
CALL 0x0019a6a0
JMP 0x001db17b
LAB_001daff9:
MOV RDI,qword ptr [RSP + 0x40]
CALL 0x001db470
MOV qword ptr [RSP + 0x30],RAX
LEA RDI,[0x213023]
CALL 0x001db4a0
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x18],RDX
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x18]
LEA RDI,[RSP + 0x20]
CALL 0x001db500
MOV RDX,qword ptr [RSP + 0x30]
MOV RCX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0xa8],RDX
MOV qword ptr [RSP + 0x98],RCX
MOV qword ptr [RSP + 0xa0],RAX
LEA RAX,[RSP + 0x4c]
MOV qword ptr [RSP + 0x90],RAX
MOV RAX,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0x88],RAX
LEA RAX,[RSP + 0x98]
MOV qword ptr [RSP + 0xb8],RAX
MOV RAX,qword ptr [RSP + 0xb8]
MOVUPS XMM0,xmmword ptr [RAX]
MOVAPS xmmword ptr [RSP + 0xc0],XMM0
MOV RCX,qword ptr [RSP + 0xc0]
MOV RAX,qword ptr [RSP + 0xc8]
MOV qword ptr [RSP + 0x78],RCX
MOV qword ptr [RSP + 0x80],RAX
MOV RDI,qword ptr [RSP + 0x90]
CALL 0x001db600
MOV qword ptr [RSP + 0x50],RAX
MOV qword ptr [RSP + 0x58],RDX
LEA RAX,[RSP + 0x68]
MOV qword ptr [RSP + 0xe0],RAX
LEA RAX,[RSP + 0x50]
MOV qword ptr [RSP + 0xd8],RAX
MOV RCX,qword ptr [RSP + 0xe0]
MOV RAX,qword ptr [RSP + 0xd8]
MOV qword ptr [RSP + 0xe8],RAX
MOV RAX,qword ptr [RSP + 0xe8]
MOV qword ptr [RSP + 0x100],RCX
MOV qword ptr [RSP + 0xf8],0x1
MOV qword ptr [RSP + 0xf0],RAX
MOV RAX,qword ptr [RSP + 0x100]
MOV RCX,qword ptr [RSP + 0xf8]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RSP + 0xf0]
MOV qword ptr [RAX + 0x8],RCX
MOV RDI,qword ptr [RSP + 0x88]
MOV RSI,qword ptr [RSP + 0x78]
MOV RDX,qword ptr [RSP + 0x80]
MOV RCX,qword ptr [RSP + 0x68]
MOV R8,qword ptr [RSP + 0x70]
CALL 0x001db530
MOV qword ptr [RSP + 0xb0],RAX
MOV RAX,qword ptr [RSP + 0xb0]
MOV qword ptr [RSP + 0x8],RAX
LAB_001db17b:
ADD RSP,0x108
RET
|
/* WARNING: Restarted to delay deadcode elimination for space: stack */
/* spdlog::details::fmt_helper::pad2(int, fmt::v8::basic_memory_buffer<char, 250ul,
std::allocator<char> >&) */
void spdlog::details::fmt_helper::pad2(int param_1,basic_memory_buffer *param_2)
{
int1 auVar1 [16];
int8 local_e8;
int8 local_e0;
int8 local_d8;
char local_ca;
char local_c9;
buffer<char> *local_c8;
int local_bc;
int1 local_b8 [16];
int1 local_a0 [16];
int8 local_90;
int8 local_88;
int8 local_80;
int *local_78;
int8 local_70;
int8 uStack_68;
int8 local_60;
int8 *local_50;
int1 *local_30;
int1 *local_28;
int1 *local_20;
int1 *local_18;
int8 local_10;
int1 *local_8;
local_c8 = (buffer<char> *)param_2;
local_bc = param_1;
if ((param_1 < 0) || (99 < param_1)) {
local_d8 = std::back_inserter<fmt::v8::basic_memory_buffer<char,250ul,std::allocator<char>>>
(param_2);
auVar1 = fmt::v8::runtime<char[6]>("{:02}");
fmt::v8::basic_format_string<char,int&>::basic_format_string
(&local_e8,auVar1._0_8_,auVar1._8_8_);
local_60 = local_d8;
local_70 = local_e8;
uStack_68 = local_e0;
local_78 = &local_bc;
local_80 = local_d8;
local_50 = &local_70;
local_90 = local_e8;
local_88 = local_e0;
local_b8 = fmt::v8::make_format_args<fmt::v8::basic_format_context<fmt::v8::appender,char>,int>
(local_78);
local_28 = local_a0;
local_30 = local_b8;
local_10 = 1;
local_20 = local_30;
local_18 = local_30;
local_8 = local_28;
_ZN3fmt2v810vformat_toISt20back_insert_iteratorINS0_19basic_memory_bufferIcLm250ESaIcEEEETnNSt9enable_ifIXsr6detail18is_output_iteratorIT_cEE5valueEiE4typeELi0EEES8_S8_NS0_17basic_string_viewIcEENS0_17basic_format_argsINS0_20basic_format_contextINS0_8appenderEcEEEE
(local_80,local_90,local_88,1,local_30);
}
else {
local_c9 = (char)(param_1 / 10) + '0';
fmt::v8::detail::buffer<char>::push_back((buffer<char> *)param_2,&local_c9);
local_ca = (char)(local_bc % 10) + '0';
fmt::v8::detail::buffer<char>::push_back(local_c8,&local_ca);
}
return;
}
| |
43,543 | Conv::report_error(char const*) const | eloqsql/client/mariadb-conv.cc | void report_error(const char *from) const
{
if (well_formed_error_pos())
{
fflush(stdout);
fprintf(stderr,
"Illegal %s byte sequence at position %d\n",
m_fromcs->cs_name.str,
(uint) (well_formed_error_pos() - from));
}
else if (cannot_convert_error_pos())
{
fflush(stdout);
fprintf(stderr,
"Conversion from %s to %s failed at position %d\n",
m_fromcs->cs_name.str, m_tocs->cs_name.str,
(uint) (cannot_convert_error_pos() - from));
}
} | O3 | cpp | Conv::report_error(char const*) const:
pushq %rbp
movq %rsp, %rbp
movq %rsi, %rdx
cmpq $0x0, 0x8(%rdi)
jne 0x263b3
cmpq $0x0, 0x10(%rdi)
jne 0x263be
popq %rbp
retq
leaq 0x8(%rdi), %rsi
callq 0x247ef
jmp 0x263b1
leaq 0x10(%rdi), %rsi
callq 0x24843
jmp 0x263b1
nop
| _ZNK4Conv12report_errorEPKc:
push rbp
mov rbp, rsp
mov rdx, rsi
cmp qword ptr [rdi+8], 0
jnz short loc_263B3
cmp qword ptr [rdi+10h], 0
jnz short loc_263BE
loc_263B1:
pop rbp
retn
loc_263B3:
lea rsi, [rdi+8]
call _ZNK4Conv12report_errorEPKc_cold_1; Conv::report_error(char const*) [clone]
jmp short loc_263B1
loc_263BE:
lea rsi, [rdi+10h]
call _ZNK4Conv12report_errorEPKc_cold_2; Conv::report_error(char const*) [clone]
jmp short loc_263B1
| long long Conv::report_error(Conv *this, const char *a2)
{
long long result; // rax
if ( *((_QWORD *)this + 1) )
return Conv::report_error((long long)this, (_DWORD *)this + 2, (int)a2);
if ( *((_QWORD *)this + 2) )
return Conv::report_error((long long)this, (_DWORD *)this + 4, (int)a2);
return result;
}
| report_error:
PUSH RBP
MOV RBP,RSP
MOV RDX,RSI
CMP qword ptr [RDI + 0x8],0x0
JNZ 0x001263b3
CMP qword ptr [RDI + 0x10],0x0
JNZ 0x001263be
LAB_001263b1:
POP RBP
RET
LAB_001263b3:
LEA RSI,[RDI + 0x8]
CALL 0x001247ef
JMP 0x001263b1
LAB_001263be:
LEA RSI,[RDI + 0x10]
CALL 0x00124843
JMP 0x001263b1
|
/* Conv::report_error(char const*) const */
void Conv::report_error(char *param_1)
{
if (*(long *)(param_1 + 8) == 0) {
if (*(long *)(param_1 + 0x10) != 0) {
report_error(param_1);
}
}
else {
report_error(param_1);
}
return;
}
| |
43,544 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> var_to_str<int, 4ul>(std::array<int, 4ul> const&) | llama.cpp/tests/test-backend-ops.cpp | static std::string var_to_str(const std::array<T, N> & x) {
std::string s = "[";
for (size_t i = 0; i < N; i++) {
if (i > 0) {
s += ",";
}
s += var_to_str(x[i]);
}
s += "]";
return s;
} | O3 | cpp | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> var_to_str<int, 4ul>(std::array<int, 4ul> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
leaq 0x40eac(%rip), %rsi # 0x68ec2
leaq 0x40ea6(%rip), %rdx # 0x68ec3
callq 0x2b8c2
leaq 0x18(%rsp), %rbp
xorl %r13d, %r13d
leaq 0x8(%rsp), %r15
leaq 0x40e84(%rip), %r12 # 0x68eba
testq %r13, %r13
je 0x28046
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1c720
movl (%r14,%r13,4), %esi
movq %r15, %rdi
callq 0x27e46
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x1c350
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2807b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1c100
incq %r13
cmpq $0x4, %r13
jne 0x28036
leaq 0x40e39(%rip), %rsi # 0x68ec4
movq %rbx, %rdi
callq 0x1c720
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x280a4
movq %rax, %r14
jmp 0x280c3
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x280c3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1c100
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x280db
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x1c100
movq %r14, %rdi
callq 0x1c6d0
| _ZL10var_to_strIiLm4EENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKSt5arrayIT_XT0_EE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r14, rsi
mov rbx, rdi
lea rax, [rdi+10h]
mov [rsp+58h+var_58], rax
mov [rdi], rax
lea rsi, asc_68EC2; "["
lea rdx, asc_68EC2+1; ""
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rbp, [rsp+58h+var_40]
xor r13d, r13d
lea r15, [rsp+58h+var_50]
lea r12, asc_68EBA; ","
loc_28036:
test r13, r13
jz short loc_28046
mov rdi, rbx
mov rsi, r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
loc_28046:
mov esi, [r14+r13*4]
mov rdi, r15
call _ZL10var_to_strIiENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKT_; var_to_str<int>(int const&)
mov rsi, [rsp+58h+var_50]
mov rdx, [rsp+58h+var_48]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKcm; std::string::append(char const*,ulong)
mov rdi, [rsp+58h+var_50]; void *
cmp rdi, rbp
jz short loc_2807B
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2807B:
inc r13
cmp r13, 4
jnz short loc_28036
lea rsi, asc_68EC4; "]"
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short $+2
loc_280A4:
mov r14, rax
jmp short loc_280C3
mov r14, rax
mov rdi, [rsp+arg_0]; void *
cmp rdi, rbp
jz short loc_280C3
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_280C3:
mov rdi, [rbx]; void *
cmp rdi, [rsp+0]
jz short loc_280DB
mov rax, [rsp+0]
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_280DB:
mov rdi, r14
call __Unwind_Resume
| long long var_to_str<int,4ul>(_QWORD *a1, long long a2)
{
long long i; // r13
void *v4[2]; // [rsp+8h] [rbp-50h] BYREF
long long v5; // [rsp+18h] [rbp-40h] BYREF
*a1 = a1 + 2;
std::string::_M_construct<char const*>(a1, "[", "");
for ( i = 0LL; i != 4; ++i )
{
if ( i )
std::string::append(a1, ",");
var_to_str<int>(v4, *(_DWORD *)(a2 + 4 * i));
std::string::append(a1, v4[0], v4[1]);
if ( v4[0] != &v5 )
operator delete(v4[0], v5 + 1);
}
return std::string::append(a1, "]");
}
| var_to_str<int,4ul>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R14,RSI
MOV RBX,RDI
LEA RAX,[RDI + 0x10]
MOV qword ptr [RSP],RAX
MOV qword ptr [RDI],RAX
LEA RSI,[0x168ec2]
LEA RDX,[0x168ec3]
CALL 0x0012b8c2
LEA RBP,[RSP + 0x18]
XOR R13D,R13D
LEA R15,[RSP + 0x8]
LEA R12,[0x168eba]
LAB_00128036:
TEST R13,R13
JZ 0x00128046
LAB_0012803b:
MOV RDI,RBX
MOV RSI,R12
CALL 0x0011c720
LAB_00128046:
MOV ESI,dword ptr [R14 + R13*0x4]
MOV RDI,R15
CALL 0x00127e46
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
LAB_0012805c:
MOV RDI,RBX
CALL 0x0011c350
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,RBP
JZ 0x0012807b
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011c100
LAB_0012807b:
INC R13
CMP R13,0x4
JNZ 0x00128036
LAB_00128084:
LEA RSI,[0x168ec4]
MOV RDI,RBX
CALL 0x0011c720
LAB_00128093:
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* std::__cxx11::string var_to_str<int, 4ul>(std::array<int, 4ul> const&) */
void var_to_str<int,4ul>(array *param_1)
{
long lVar1;
long *local_50 [2];
long local_40 [2];
*(array **)param_1 = param_1 + 0x10;
std::__cxx11::string::_M_construct<char_const*>(param_1,&DAT_00168ec2,&DAT_00168ec3);
lVar1 = 0;
do {
if (lVar1 != 0) {
/* try { // try from 0012803b to 00128045 has its CatchHandler @ 001280a4 */
std::__cxx11::string::append((char *)param_1);
}
var_to_str<int>((int *)local_50);
/* try { // try from 0012805c to 00128063 has its CatchHandler @ 001280a9 */
std::__cxx11::string::append((char *)param_1,(ulong)local_50[0]);
if (local_50[0] != local_40) {
operator_delete(local_50[0],local_40[0] + 1);
}
lVar1 = lVar1 + 1;
} while (lVar1 != 4);
/* try { // try from 00128084 to 00128092 has its CatchHandler @ 001280a2 */
std::__cxx11::string::append((char *)param_1);
return;
}
| |
43,545 | ZNK5chess9PieceTypecvNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEv | Razamindset[P]pawnstar-chess-engine/src/engine/../chess-library/include/chess.hpp | explicit operator std::string() const {
switch (pt) {
case underlying::PAWN:
return "p";
case underlying::KNIGHT:
return "n";
case underlying::BISHOP:
return "b";
case underlying::ROOK:
return "r";
case underlying::QUEEN:
return "q";
case underlying::KING:
return "k";
default:
return " ";
}
} | O0 | cpp | ZNK5chess9PieceTypecvNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEv:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movq %rax, -0x38(%rbp)
subq $0x5, %rax
ja 0x19fd3
movq -0x38(%rbp), %rax
leaq 0xb126(%rip), %rcx # 0x24f34
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq -0x11(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x34e0
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x8f90(%rip), %rsi # 0x22dc3
callq 0xe9e0
jmp 0x19e3a
leaq -0x11(%rbp), %rdi
callq 0x3320
jmp 0x1a018
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x3320
jmp 0x1a025
leaq -0x25(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x34e0
movq -0x48(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0x8f9f(%rip), %rsi # 0x22e1d
callq 0xe9e0
jmp 0x19e85
leaq -0x25(%rbp), %rdi
callq 0x3320
jmp 0x1a018
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x25(%rbp), %rdi
callq 0x3320
jmp 0x1a025
leaq -0x26(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x34e0
movq -0x48(%rbp), %rdi
movq -0x60(%rbp), %rdx
leaq 0xb150(%rip), %rsi # 0x25019
callq 0xe9e0
jmp 0x19ed0
leaq -0x26(%rbp), %rdi
callq 0x3320
jmp 0x1a018
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x26(%rbp), %rdi
callq 0x3320
jmp 0x1a025
leaq -0x27(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x34e0
movq -0x48(%rbp), %rdi
movq -0x68(%rbp), %rdx
leaq 0x8eda(%rip), %rsi # 0x22dee
callq 0xe9e0
jmp 0x19f1b
leaq -0x27(%rbp), %rdi
callq 0x3320
jmp 0x1a018
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x27(%rbp), %rdi
callq 0x3320
jmp 0x1a025
leaq -0x28(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x34e0
movq -0x48(%rbp), %rdi
movq -0x70(%rbp), %rdx
leaq 0xb0bc(%rip), %rsi # 0x2501b
callq 0xe9e0
jmp 0x19f66
leaq -0x28(%rbp), %rdi
callq 0x3320
jmp 0x1a018
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3320
jmp 0x1a025
leaq -0x29(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x34e0
movq -0x48(%rbp), %rdi
movq -0x78(%rbp), %rdx
leaq 0x8e60(%rip), %rsi # 0x22e0a
callq 0xe9e0
jmp 0x19fb1
leaq -0x29(%rbp), %rdi
callq 0x3320
jmp 0x1a018
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x3320
jmp 0x1a025
leaq -0x2a(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x34e0
movq -0x48(%rbp), %rdi
movq -0x80(%rbp), %rdx
leaq 0xb019(%rip), %rsi # 0x25008
callq 0xe9e0
jmp 0x19ff6
leaq -0x2a(%rbp), %rdi
callq 0x3320
jmp 0x1a018
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x2a(%rbp), %rdi
callq 0x3320
jmp 0x1a025
movq -0x40(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x34d0
nop
| _ZNK5chess9PieceTypecvNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEv:
push rbp
mov rbp, rsp
sub rsp, 80h
mov [rbp+var_48], rdi
mov rax, rdi
mov [rbp+var_40], rax
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax]
mov [rbp+var_38], rax
sub rax, 5; switch 6 cases
ja def_19E15; jumptable 0000000000019E15 default case
mov rax, [rbp+var_38]
lea rcx, jpt_19E15
movsxd rax, ds:(jpt_19E15 - 24F34h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_19E17:
lea rdi, [rbp+var_11]; jumptable 0000000000019E15 case 0
mov [rbp+var_50], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdi, [rbp+var_48]
mov rdx, [rbp+var_50]
lea rsi, aStop+3; "p"
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_19E3A:
lea rdi, [rbp+var_11]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp loc_1A018
mov rcx, rax
mov eax, edx
mov [rbp+var_20], rcx
mov [rbp+var_24], eax
lea rdi, [rbp+var_11]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp loc_1A025
loc_19E62:
lea rdi, [rbp+var_25]; jumptable 0000000000019E15 case 1
mov [rbp+var_58], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdi, [rbp+var_48]
mov rdx, [rbp+var_58]
lea rsi, aFen+2; "n"
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_19E85:
lea rdi, [rbp+var_25]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp loc_1A018
mov rcx, rax
mov eax, edx
mov [rbp+var_20], rcx
mov [rbp+var_24], eax
lea rdi, [rbp+var_25]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp loc_1A025
loc_19EAD:
lea rdi, [rbp+var_26]; jumptable 0000000000019E15 case 2
mov [rbp+var_60], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdi, [rbp+var_48]
mov rdx, [rbp+var_60]
lea rsi, aB_0; "b"
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_19ED0:
lea rdi, [rbp+var_26]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp loc_1A018
mov rcx, rax
mov eax, edx
mov [rbp+var_20], rcx
mov [rbp+var_24], eax
lea rdi, [rbp+var_26]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp loc_1A025
loc_19EF8:
lea rdi, [rbp+var_27]; jumptable 0000000000019E15 case 3
mov [rbp+var_68], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdi, [rbp+var_48]
mov rdx, [rbp+var_68]
lea rsi, aIdNamePawnstar+0Fh; "r"
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_19F1B:
lea rdi, [rbp+var_27]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp loc_1A018
mov rcx, rax
mov eax, edx
mov [rbp+var_20], rcx
mov [rbp+var_24], eax
lea rdi, [rbp+var_27]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp loc_1A025
loc_19F43:
lea rdi, [rbp+var_28]; jumptable 0000000000019E15 case 4
mov [rbp+var_70], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdi, [rbp+var_48]
mov rdx, [rbp+var_70]
lea rsi, aQ_0; "q"
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_19F66:
lea rdi, [rbp+var_28]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp loc_1A018
mov rcx, rax
mov eax, edx
mov [rbp+var_20], rcx
mov [rbp+var_24], eax
lea rdi, [rbp+var_28]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp loc_1A025
loc_19F8E:
lea rdi, [rbp+var_29]; jumptable 0000000000019E15 case 5
mov [rbp+var_78], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdi, [rbp+var_48]
mov rdx, [rbp+var_78]
lea rsi, aUciok+4; "k"
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_19FB1:
lea rdi, [rbp+var_29]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp short loc_1A018
mov rcx, rax
mov eax, edx
mov [rbp+var_20], rcx
mov [rbp+var_24], eax
lea rdi, [rbp+var_29]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp short loc_1A025
def_19E15:
lea rdi, [rbp+var_2A]; jumptable 0000000000019E15 default case
mov [rbp+var_80], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdi, [rbp+var_48]
mov rdx, [rbp+var_80]
lea rsi, aEp+3; " "
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_19FF6:
lea rdi, [rbp+var_2A]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp short loc_1A018
mov rcx, rax
mov eax, edx
mov [rbp+var_20], rcx
mov [rbp+var_24], eax
lea rdi, [rbp+var_2A]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp short loc_1A025
loc_1A018:
mov rax, [rbp+var_40]
add rsp, 80h
pop rbp
retn
loc_1A025:
mov rdi, [rbp+var_20]
call __Unwind_Resume
| long long chess::PieceType::operator std::string(long long a1, _BYTE *a2)
{
char v3; // [rsp+56h] [rbp-2Ah] BYREF
char v4; // [rsp+57h] [rbp-29h] BYREF
char v5; // [rsp+58h] [rbp-28h] BYREF
char v6; // [rsp+59h] [rbp-27h] BYREF
char v7; // [rsp+5Ah] [rbp-26h] BYREF
char v8; // [rsp+5Bh] [rbp-25h] BYREF
char v9; // [rsp+6Fh] [rbp-11h] BYREF
_BYTE *v10; // [rsp+70h] [rbp-10h]
long long v11; // [rsp+78h] [rbp-8h]
v11 = a1;
v10 = a2;
switch ( *a2 )
{
case 0:
std::allocator<char>::allocator();
std::string::basic_string<std::allocator<char>>(a1, (long long)"p", (long long)&v9);
std::allocator<char>::~allocator(&v9);
break;
case 1:
std::allocator<char>::allocator();
std::string::basic_string<std::allocator<char>>(a1, (long long)"n", (long long)&v8);
std::allocator<char>::~allocator(&v8);
break;
case 2:
std::allocator<char>::allocator();
std::string::basic_string<std::allocator<char>>(a1, (long long)"b", (long long)&v7);
std::allocator<char>::~allocator(&v7);
break;
case 3:
std::allocator<char>::allocator();
std::string::basic_string<std::allocator<char>>(a1, (long long)"r", (long long)&v6);
std::allocator<char>::~allocator(&v6);
break;
case 4:
std::allocator<char>::allocator();
std::string::basic_string<std::allocator<char>>(a1, (long long)"q", (long long)&v5);
std::allocator<char>::~allocator(&v5);
break;
case 5:
std::allocator<char>::allocator();
std::string::basic_string<std::allocator<char>>(a1, (long long)"k", (long long)&v4);
std::allocator<char>::~allocator(&v4);
break;
default:
std::allocator<char>::allocator();
std::string::basic_string<std::allocator<char>>(a1, (long long)" ", (long long)&v3);
std::allocator<char>::~allocator(&v3);
break;
}
return a1;
}
| operator.cast.to.string:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV qword ptr [RBP + -0x48],RDI
MOV RAX,RDI
MOV qword ptr [RBP + -0x40],RAX
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
SUB RAX,0x5
JA 0x00119fd3
MOV RAX,qword ptr [RBP + -0x38]
LEA RCX,[0x124f34]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_0:
LEA RDI,[RBP + -0x11]
MOV qword ptr [RBP + -0x50],RDI
CALL 0x001034e0
MOV RDI,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RBP + -0x50]
LAB_00119e2c:
LEA RSI,[0x122dc3]
CALL 0x0010e9e0
JMP 0x00119e3a
LAB_00119e3a:
LEA RDI,[RBP + -0x11]
CALL 0x00103320
JMP 0x0011a018
caseD_1:
LEA RDI,[RBP + -0x25]
MOV qword ptr [RBP + -0x58],RDI
CALL 0x001034e0
MOV RDI,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RBP + -0x58]
LAB_00119e77:
LEA RSI,[0x122e1d]
CALL 0x0010e9e0
JMP 0x00119e85
LAB_00119e85:
LEA RDI,[RBP + -0x25]
CALL 0x00103320
JMP 0x0011a018
caseD_2:
LEA RDI,[RBP + -0x26]
MOV qword ptr [RBP + -0x60],RDI
CALL 0x001034e0
MOV RDI,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RBP + -0x60]
LAB_00119ec2:
LEA RSI,[0x125019]
CALL 0x0010e9e0
JMP 0x00119ed0
LAB_00119ed0:
LEA RDI,[RBP + -0x26]
CALL 0x00103320
JMP 0x0011a018
caseD_3:
LEA RDI,[RBP + -0x27]
MOV qword ptr [RBP + -0x68],RDI
CALL 0x001034e0
MOV RDI,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RBP + -0x68]
LAB_00119f0d:
LEA RSI,[0x122dee]
CALL 0x0010e9e0
JMP 0x00119f1b
LAB_00119f1b:
LEA RDI,[RBP + -0x27]
CALL 0x00103320
JMP 0x0011a018
caseD_4:
LEA RDI,[RBP + -0x28]
MOV qword ptr [RBP + -0x70],RDI
CALL 0x001034e0
MOV RDI,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RBP + -0x70]
LAB_00119f58:
LEA RSI,[0x12501b]
CALL 0x0010e9e0
JMP 0x00119f66
LAB_00119f66:
LEA RDI,[RBP + -0x28]
CALL 0x00103320
JMP 0x0011a018
caseD_5:
LEA RDI,[RBP + -0x29]
MOV qword ptr [RBP + -0x78],RDI
CALL 0x001034e0
MOV RDI,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RBP + -0x78]
LAB_00119fa3:
LEA RSI,[0x122e0a]
CALL 0x0010e9e0
JMP 0x00119fb1
LAB_00119fb1:
LEA RDI,[RBP + -0x29]
CALL 0x00103320
JMP 0x0011a018
default:
LEA RDI,[RBP + -0x2a]
MOV qword ptr [RBP + -0x80],RDI
CALL 0x001034e0
MOV RDI,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RBP + -0x80]
LAB_00119fe8:
LEA RSI,[0x125008]
CALL 0x0010e9e0
LAB_00119ff4:
JMP 0x00119ff6
LAB_00119ff6:
LEA RDI,[RBP + -0x2a]
CALL 0x00103320
JMP 0x0011a018
LAB_0011a018:
MOV RAX,qword ptr [RBP + -0x40]
ADD RSP,0x80
POP RBP
RET
|
/* chess::PieceType::operator std::__cxx11::string() const */
PieceType * __thiscall chess::PieceType::operator_cast_to_string(PieceType *this)
{
int1 *in_RSI;
allocator local_32;
allocator local_31;
allocator local_30;
allocator local_2f;
allocator local_2e;
allocator local_2d [20];
allocator local_19 [9];
PieceType *local_10;
local_10 = this;
switch(*in_RSI) {
case 0:
std::allocator<char>::allocator();
/* try { // try from 00119e2c to 00119e37 has its CatchHandler @ 00119e48 */
std::__cxx11::string::string<std::allocator<char>>((string *)this,"p",local_19);
std::allocator<char>::~allocator((allocator<char> *)local_19);
break;
case 1:
std::allocator<char>::allocator();
/* try { // try from 00119e77 to 00119e82 has its CatchHandler @ 00119e93 */
std::__cxx11::string::string<std::allocator<char>>((string *)this,"n",local_2d);
std::allocator<char>::~allocator((allocator<char> *)local_2d);
break;
case 2:
std::allocator<char>::allocator();
/* try { // try from 00119ec2 to 00119ecd has its CatchHandler @ 00119ede */
std::__cxx11::string::string<std::allocator<char>>((string *)this,"b",&local_2e);
std::allocator<char>::~allocator((allocator<char> *)&local_2e);
break;
case 3:
std::allocator<char>::allocator();
/* try { // try from 00119f0d to 00119f18 has its CatchHandler @ 00119f29 */
std::__cxx11::string::string<std::allocator<char>>((string *)this,"r",&local_2f);
std::allocator<char>::~allocator((allocator<char> *)&local_2f);
break;
case 4:
std::allocator<char>::allocator();
/* try { // try from 00119f58 to 00119f63 has its CatchHandler @ 00119f74 */
std::__cxx11::string::string<std::allocator<char>>((string *)this,"q",&local_30);
std::allocator<char>::~allocator((allocator<char> *)&local_30);
break;
case 5:
std::allocator<char>::allocator();
/* try { // try from 00119fa3 to 00119fae has its CatchHandler @ 00119fbc */
std::__cxx11::string::string<std::allocator<char>>((string *)this,"k",&local_31);
std::allocator<char>::~allocator((allocator<char> *)&local_31);
break;
default:
std::allocator<char>::allocator();
/* try { // try from 00119fe8 to 00119ff3 has its CatchHandler @ 0011a001 */
std::__cxx11::string::string<std::allocator<char>>((string *)this," ",&local_32);
std::allocator<char>::~allocator((allocator<char> *)&local_32);
}
return this;
}
| |
43,546 | ZNK5chess9PieceTypecvNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEv | Razamindset[P]pawnstar-chess-engine/src/engine/../chess-library/include/chess.hpp | explicit operator std::string() const {
switch (pt) {
case underlying::PAWN:
return "p";
case underlying::KNIGHT:
return "n";
case underlying::BISHOP:
return "b";
case underlying::ROOK:
return "r";
case underlying::QUEEN:
return "q";
case underlying::KING:
return "k";
default:
return " ";
}
} | O3 | cpp | ZNK5chess9PieceTypecvNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEv:
pushq %rbx
movq %rdi, %rbx
movzbl (%rsi), %eax
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
cmpq $0x5, %rax
ja 0x993a
leaq 0x52c3(%rip), %rcx # 0xeb94
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x322d(%rip), %rsi # 0xcb0e
leaq 0x3227(%rip), %rdx # 0xcb0f
jmp 0x9948
leaq 0x538a(%rip), %rsi # 0xec7b
leaq 0x5384(%rip), %rdx # 0xec7c
jmp 0x9948
leaq 0x5378(%rip), %rsi # 0xec79
leaq 0x5372(%rip), %rdx # 0xec7a
jmp 0x9948
leaq 0x3228(%rip), %rsi # 0xcb39
leaq 0x3222(%rip), %rdx # 0xcb3a
jmp 0x9948
leaq 0x3247(%rip), %rsi # 0xcb68
leaq 0x3241(%rip), %rdx # 0xcb69
jmp 0x9948
leaq 0x3224(%rip), %rsi # 0xcb55
leaq 0x321e(%rip), %rdx # 0xcb56
jmp 0x9948
leaq 0x5327(%rip), %rsi # 0xec68
leaq 0x5321(%rip), %rdx # 0xec69
movq %rbx, %rdi
callq 0x3ff8
movq %rbx, %rax
popq %rbx
retq
nop
| _ZNK5chess9PieceTypecvNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEv:
push rbx
mov rbx, rdi
movzx eax, byte ptr [rsi]
lea rcx, [rdi+10h]
mov [rdi], rcx
cmp rax, 5; switch 6 cases
ja short def_98D8; jumptable 00000000000098D8 default case
lea rcx, jpt_98D8
movsxd rax, ds:(jpt_98D8 - 0EB94h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_98DA:
lea rsi, aStop+3; jumptable 00000000000098D8 case 0
lea rdx, aStop+4; ""
jmp short loc_9948
loc_98EA:
lea rsi, aQ_0; jumptable 00000000000098D8 case 4
lea rdx, aQ_0+1; ""
jmp short loc_9948
loc_98FA:
lea rsi, aB_0; jumptable 00000000000098D8 case 2
lea rdx, aB_0+1; ""
jmp short loc_9948
loc_990A:
lea rsi, aIdNamePawnstar+0Fh; jumptable 00000000000098D8 case 3
lea rdx, aIdNamePawnstar+10h; ""
jmp short loc_9948
loc_991A:
lea rsi, aFen+2; jumptable 00000000000098D8 case 1
lea rdx, aFen+3; ""
jmp short loc_9948
loc_992A:
lea rsi, aUciok+4; jumptable 00000000000098D8 case 5
lea rdx, aUciok+5; ""
jmp short loc_9948
def_98D8:
lea rsi, aEp+3; jumptable 00000000000098D8 default case
lea rdx, aEp+4; ""
loc_9948:
mov rdi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rax, rbx
pop rbx
retn
| _QWORD * chess::PieceType::operator std::string(_QWORD *a1, unsigned __int8 *a2)
{
long long v2; // rax
char *v3; // rsi
char *v4; // rdx
v2 = *a2;
*a1 = a1 + 2;
switch ( v2 )
{
case 0LL:
v3 = "p";
v4 = "";
break;
case 1LL:
v3 = "n";
v4 = "";
break;
case 2LL:
v3 = "b";
v4 = "";
break;
case 3LL:
v3 = "r";
v4 = "";
break;
case 4LL:
v3 = "q";
v4 = "";
break;
case 5LL:
v3 = "k";
v4 = "";
break;
default:
v3 = " ";
v4 = "";
break;
}
std::string::_M_construct<char const*>((long long)a1, v3, (long long)v4);
return a1;
}
| operator.cast.to.string:
PUSH RBX
MOV RBX,RDI
MOVZX EAX,byte ptr [RSI]
LEA RCX,[RDI + 0x10]
MOV qword ptr [RDI],RCX
CMP RAX,0x5
JA 0x0010993a
LEA RCX,[0x10eb94]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_0:
LEA RSI,[0x10cb0e]
LEA RDX,[0x10cb0f]
JMP 0x00109948
caseD_4:
LEA RSI,[0x10ec7b]
LEA RDX,[0x10ec7c]
JMP 0x00109948
caseD_2:
LEA RSI,[0x10ec79]
LEA RDX,[0x10ec7a]
JMP 0x00109948
caseD_3:
LEA RSI,[0x10cb39]
LEA RDX,[0x10cb3a]
JMP 0x00109948
caseD_1:
LEA RSI,[0x10cb68]
LEA RDX,[0x10cb69]
JMP 0x00109948
caseD_5:
LEA RSI,[0x10cb55]
LEA RDX,[0x10cb56]
JMP 0x00109948
default:
LEA RSI,[0x10ec68]
LEA RDX,[0x10ec69]
LAB_00109948:
MOV RDI,RBX
CALL 0x00103ff8
MOV RAX,RBX
POP RBX
RET
|
/* chess::PieceType::operator std::__cxx11::string() const */
PieceType * __thiscall chess::PieceType::operator_cast_to_string(PieceType *this)
{
int1 uVar1;
char *pcVar2;
int1 *in_RSI;
char *pcVar3;
uVar1 = *in_RSI;
*(PieceType **)this = this + 0x10;
switch(uVar1) {
case 0:
pcVar3 = "p";
pcVar2 = "";
break;
case 1:
pcVar3 = "n";
pcVar2 = "";
break;
case 2:
pcVar3 = "b";
pcVar2 = "";
break;
case 3:
pcVar3 = "r";
pcVar2 = "";
break;
case 4:
pcVar3 = "q";
pcVar2 = "";
break;
case 5:
pcVar3 = "k";
pcVar2 = "";
break;
default:
pcVar3 = " ";
pcVar2 = "";
}
std::__cxx11::string::_M_construct<char_const*>(this,pcVar3,pcVar2);
return this;
}
| |
43,547 | ma_bitmap_flush_all | eloqsql/storage/maria/ma_bitmap.c | my_bool _ma_bitmap_flush_all(MARIA_SHARE *share)
{
my_bool res= 0;
uint send_signal= 0;
MARIA_FILE_BITMAP *bitmap= &share->bitmap;
DBUG_ENTER("_ma_bitmap_flush_all");
#ifdef EXTRA_DEBUG_BITMAP
{
char buff[160];
uint len= my_sprintf(buff,
(buff, "bitmap_flush: fd: %d id: %u "
"changed: %d changed_not_flushed: %d "
"flush_all_requested: %d",
share->bitmap.file.file,
share->id,
bitmap->changed,
bitmap->changed_not_flushed,
bitmap->flush_all_requested));
(void) translog_log_debug_info(0, LOGREC_DEBUG_INFO_QUERY,
(uchar*) buff, len);
}
#endif
mysql_mutex_lock(&bitmap->bitmap_lock);
if (!bitmap->changed && !bitmap->changed_not_flushed)
{
mysql_mutex_unlock(&bitmap->bitmap_lock);
DBUG_RETURN(0);
}
_ma_bitmap_mark_file_changed(share, 0);
/*
The following should be true as it was tested above. We have to test
this again as _ma_bitmap_mark_file_changed() did temporarly release
the bitmap mutex.
*/
if (bitmap->changed || bitmap->changed_not_flushed)
{
bitmap->flush_all_requested++;
bitmap->waiting_for_non_flushable++;
#if !WRONG_BITMAP_FLUSH
while (bitmap->non_flushable > 0)
{
DBUG_PRINT("info", ("waiting for bitmap to be flushable"));
mysql_cond_wait(&bitmap->bitmap_cond, &bitmap->bitmap_lock);
}
#endif
bitmap->waiting_for_non_flushable--;
#ifdef EXTRA_DEBUG_BITMAP
{
char tmp[MAX_BITMAP_INFO_LENGTH];
size_t len;
len= _ma_get_bitmap_description(bitmap, bitmap->map, bitmap->page, tmp);
(void) translog_log_debug_info(0, LOGREC_DEBUG_INFO_QUERY,
(uchar*) tmp, len);
}
#endif
DBUG_ASSERT(bitmap->flush_all_requested == 1);
/*
Bitmap is in a flushable state: its contents in memory are reflected by
log records (complete REDO-UNDO groups) and all bitmap pages are
unpinned. We keep the mutex to preserve this situation, and flush to the
file.
*/
if (bitmap->changed)
{
bitmap->changed= FALSE;
res= write_changed_bitmap(share, bitmap);
}
/*
We do NOT use FLUSH_KEEP_LAZY because we must be sure that bitmap
pages have been flushed. That's a condition of correctness of
Recovery: data pages may have been all flushed, if we write the
checkpoint record Recovery will start from after their REDOs. If
bitmap page was not flushed, as the REDOs about it will be skipped, it
will wrongly not be recovered. If bitmap pages had a rec_lsn it would
be different.
There should be no pinned pages as bitmap->non_flushable==0.
*/
if (flush_pagecache_blocks_with_filter(share->pagecache,
&bitmap->file, FLUSH_KEEP,
filter_flush_bitmap_pages,
&bitmap->pages_covered) &
PCFLUSH_PINNED_AND_ERROR)
res= TRUE;
bitmap->changed_not_flushed= FALSE;
bitmap->flush_all_requested--;
/*
Some well-behaved threads may be waiting for flush_all_requested to
become false, wake them up.
*/
DBUG_PRINT("info", ("bitmap flusher waking up others"));
send_signal= (bitmap->waiting_for_flush_all_requested |
bitmap->waiting_for_non_flushable);
}
mysql_mutex_unlock(&bitmap->bitmap_lock);
if (send_signal)
mysql_cond_broadcast(&bitmap->bitmap_cond);
DBUG_RETURN(res);
} | O3 | c | ma_bitmap_flush_all:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0xa98(%rdi), %r14
cmpq $0x0, 0xad8(%rdi)
jne 0x4e33a
movq %r14, %rdi
callq 0x291d0
movb 0xa30(%rbx), %al
testb %al, %al
jne 0x4e181
cmpb $0x0, 0xa31(%rbx)
je 0x4e307
cmpb $0x0, 0x7df(%rbx)
jne 0x4e197
testb $0x1, 0x170(%rbx)
jne 0x4e37a
testb %al, %al
jne 0x4e1a8
cmpb $0x0, 0xa31(%rbx)
je 0x4e332
incl 0xa40(%rbx)
movl 0xa4c(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0xa4c(%rbx)
cmpl $0x0, 0xa48(%rbx)
je 0x4e217
leaq 0xae0(%rbx), %r15
leaq 0x8c3de(%rip), %r12 # 0xda5b2
cmpq $0x0, 0xb10(%rbx)
jne 0x4e1f4
movq %r15, %rdi
movq %r14, %rsi
callq 0x293d0
cmpl $0x0, 0xa48(%rbx)
jne 0x4e1d4
jmp 0x4e209
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl $0x204, %ecx # imm = 0x204
callq 0x2f180
jmp 0x4e1e9
movl 0xa4c(%rbx), %ecx
movb 0xa30(%rbx), %al
decl %ecx
movl %ecx, 0xa4c(%rbx)
xorl %r15d, %r15d
testb %al, %al
je 0x4e281
movw $0x100, 0xa30(%rbx) # imm = 0x100
movq 0x600(%rbx), %rdi
leaq 0xa50(%rbx), %rsi
movq 0xa20(%rbx), %rdx
movq 0xa18(%rbx), %r8
movl 0x80(%rdi), %eax
movl %eax, 0x30(%rsp)
movl %r15d, 0x28(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rsp)
movl %r15d, 0x10(%rsp)
movl %r15d, (%rsp)
movl $0x1, 0x8(%rsp)
xorl %ecx, %ecx
movl $0x1, %r9d
callq 0x6e646
movl %eax, %r15d
movq 0x600(%rbx), %rdi
leaq 0xa50(%rbx), %rsi
leaq 0xb48(%rbx), %r8
leaq 0x158(%rip), %rcx # 0x4e3f5
xorl %edx, %edx
callq 0x6ed3c
testb $0x3, %al
movzbl %r15b, %eax
movl $0x1, %r15d
cmovel %eax, %r15d
movb $0x0, 0xa31(%rbx)
decl 0xa40(%rbx)
movl 0xa4c(%rbx), %eax
orl 0xa44(%rbx), %eax
sete %r12b
movq 0xad8(%rbx), %rdi
testq %rdi, %rdi
jne 0x4e353
movq %r14, %rdi
callq 0x291a0
testb %r12b, %r12b
jne 0x4e322
movq 0xb10(%rbx), %rdi
addq $0xae0, %rbx # imm = 0xAE0
testq %rdi, %rdi
jne 0x4e368
movq %rbx, %rdi
callq 0x29660
jmp 0x4e322
movq 0xad8(%rbx), %rdi
testq %rdi, %rdi
jne 0x4e3ae
movq %r14, %rdi
callq 0x291a0
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %r12b
xorl %r15d, %r15d
jmp 0x4e2d1
leaq 0x8c271(%rip), %rsi # 0xda5b2
movq %r14, %rdi
movl $0x1ee, %edx # imm = 0x1EE
callq 0x2ee6f
jmp 0x4e16a
leaq 0x338cf6(%rip), %rax # 0x387050
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x4e2dd
leaq 0x338ce1(%rip), %rax # 0x387050
movq (%rax), %rax
callq *0x178(%rax)
jmp 0x4e2fd
movq 0xad8(%rbx), %rdi
testq %rdi, %rdi
jne 0x4e3c3
movq %r14, %rdi
callq 0x291a0
movq %rbx, %rdi
callq 0x3d913
movq %r14, %rdi
movl $0x184, %esi # imm = 0x184
callq 0x4e11b
movb 0xa30(%rbx), %al
jmp 0x4e197
leaq 0x338c9b(%rip), %rax # 0x387050
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x4e317
leaq 0x338c86(%rip), %rax # 0x387050
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x4e386
| _ma_bitmap_flush_all:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 40h
mov rbx, rdi
lea r14, [rdi+0A98h]
cmp qword ptr [rdi+0AD8h], 0
jnz loc_4E33A
mov rdi, r14
call _pthread_mutex_lock
loc_4E16A:
mov al, [rbx+0A30h]
test al, al
jnz short loc_4E181
cmp byte ptr [rbx+0A31h], 0
jz loc_4E307
loc_4E181:
cmp byte ptr [rbx+7DFh], 0
jnz short loc_4E197
test byte ptr [rbx+170h], 1
jnz loc_4E37A
loc_4E197:
test al, al
jnz short loc_4E1A8
cmp byte ptr [rbx+0A31h], 0
jz loc_4E332
loc_4E1A8:
inc dword ptr [rbx+0A40h]
mov ecx, [rbx+0A4Ch]
lea edx, [rcx+1]
mov [rbx+0A4Ch], edx
cmp dword ptr [rbx+0A48h], 0
jz short loc_4E217
lea r15, [rbx+0AE0h]
lea r12, aWorkspaceLlm4b_4; "/workspace/llm4binary/github2025/eloqsq"...
loc_4E1D4:
cmp qword ptr [rbx+0B10h], 0
jnz short loc_4E1F4
mov rdi, r15
mov rsi, r14
call _pthread_cond_wait
loc_4E1E9:
cmp dword ptr [rbx+0A48h], 0
jnz short loc_4E1D4
jmp short loc_4E209
loc_4E1F4:
mov rdi, r15
mov rsi, r14
mov rdx, r12
mov ecx, 204h
call psi_cond_wait
jmp short loc_4E1E9
loc_4E209:
mov ecx, [rbx+0A4Ch]
mov al, [rbx+0A30h]
dec ecx
loc_4E217:
mov [rbx+0A4Ch], ecx
xor r15d, r15d
test al, al
jz short loc_4E281
mov word ptr [rbx+0A30h], 100h
mov rdi, [rbx+600h]
lea rsi, [rbx+0A50h]
mov rdx, [rbx+0A20h]
mov r8, [rbx+0A18h]
mov eax, [rdi+80h]
mov [rsp+60h+var_30], eax
mov [rsp+60h+var_38], r15d
xorps xmm0, xmm0
movups [rsp+60h+var_48], xmm0
mov [rsp+60h+var_50], r15d
mov [rsp+60h+var_60], r15d
mov [rsp+60h+var_58], 1
xor ecx, ecx
mov r9d, 1
call pagecache_write_part
mov r15d, eax
loc_4E281:
mov rdi, [rbx+600h]
lea rsi, [rbx+0A50h]
lea r8, [rbx+0B48h]
lea rcx, filter_flush_bitmap_pages
xor edx, edx
call flush_pagecache_blocks_with_filter
test al, 3
movzx eax, r15b
mov r15d, 1
cmovz r15d, eax
mov byte ptr [rbx+0A31h], 0
dec dword ptr [rbx+0A40h]
mov eax, [rbx+0A4Ch]
or eax, [rbx+0A44h]
setz r12b
loc_4E2D1:
mov rdi, [rbx+0AD8h]
test rdi, rdi
jnz short loc_4E353
loc_4E2DD:
mov rdi, r14
call _pthread_mutex_unlock
test r12b, r12b
jnz short loc_4E322
mov rdi, [rbx+0B10h]
add rbx, 0AE0h
test rdi, rdi
jnz short loc_4E368
loc_4E2FD:
mov rdi, rbx
call _pthread_cond_broadcast
jmp short loc_4E322
loc_4E307:
mov rdi, [rbx+0AD8h]
test rdi, rdi
jnz loc_4E3AE
loc_4E317:
mov rdi, r14
call _pthread_mutex_unlock
xor r15d, r15d
loc_4E322:
mov eax, r15d
add rsp, 40h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_4E332:
mov r12b, 1
xor r15d, r15d
jmp short loc_4E2D1
loc_4E33A:
lea rsi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r14
mov edx, 1EEh
call psi_mutex_lock
jmp loc_4E16A
loc_4E353:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp loc_4E2DD
loc_4E368:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+178h]
jmp short loc_4E2FD
loc_4E37A:
mov rdi, [rbx+0AD8h]
test rdi, rdi
jnz short loc_4E3C3
loc_4E386:
mov rdi, r14
call _pthread_mutex_unlock
mov rdi, rbx
call _ma_mark_file_changed_now
mov rdi, r14
mov esi, 184h
call inline_mysql_mutex_lock_0
mov al, [rbx+0A30h]
jmp loc_4E197
loc_4E3AE:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp loc_4E317
loc_4E3C3:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_4E386
| long long ma_bitmap_flush_all(long long a1)
{
long long v1; // r14
char v2; // al
int v3; // ecx
unsigned __int8 v4; // r15
bool v5; // zf
unsigned int v6; // eax
unsigned int v7; // r15d
bool v8; // r12
v1 = a1 + 2712;
if ( *(_QWORD *)(a1 + 2776) )
psi_mutex_lock(a1 + 2712, (long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_bitmap.c", 0x1EEu);
else
pthread_mutex_lock(a1 + 2712);
v2 = *(_BYTE *)(a1 + 2608);
if ( v2 || *(_BYTE *)(a1 + 2609) )
{
if ( !*(_BYTE *)(a1 + 2015) && (*(_BYTE *)(a1 + 368) & 1) != 0 )
{
if ( *(_QWORD *)(a1 + 2776) )
PSI_server[44]();
pthread_mutex_unlock(v1);
ma_mark_file_changed_now(a1);
inline_mysql_mutex_lock_0(v1, 0x184u);
v2 = *(_BYTE *)(a1 + 2608);
}
if ( v2 || *(_BYTE *)(a1 + 2609) )
{
++*(_DWORD *)(a1 + 2624);
v3 = *(_DWORD *)(a1 + 2636);
*(_DWORD *)(a1 + 2636) = v3 + 1;
if ( *(_DWORD *)(a1 + 2632) )
{
do
{
if ( *(_QWORD *)(a1 + 2832) )
psi_cond_wait(
a1 + 2784,
v1,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_bitmap.c",
0x204u);
else
pthread_cond_wait(a1 + 2784, v1);
}
while ( *(_DWORD *)(a1 + 2632) );
v2 = *(_BYTE *)(a1 + 2608);
v3 = *(_DWORD *)(a1 + 2636) - 1;
}
*(_DWORD *)(a1 + 2636) = v3;
v4 = 0;
if ( v2 )
{
*(_WORD *)(a1 + 2608) = 256;
v4 = pagecache_write_part(
*(_QWORD *)(a1 + 1536),
(int)a1 + 2640,
*(_QWORD *)(a1 + 2592),
0,
*(_QWORD *)(a1 + 2584),
1,
0,
1,
0,
0LL,
0LL,
0,
*(_DWORD *)(*(_QWORD *)(a1 + 1536) + 128LL));
}
v5 = (flush_pagecache_blocks_with_filter(
*(_QWORD *)(a1 + 1536),
a1 + 2640,
0LL,
filter_flush_bitmap_pages,
a1 + 2888) & 3) == 0;
v6 = v4;
v7 = 1;
if ( v5 )
v7 = v6;
*(_BYTE *)(a1 + 2609) = 0;
--*(_DWORD *)(a1 + 2624);
v8 = (*(_DWORD *)(a1 + 2628) | *(_DWORD *)(a1 + 2636)) == 0;
}
else
{
v8 = 1;
v7 = 0;
}
if ( *(_QWORD *)(a1 + 2776) )
PSI_server[44]();
pthread_mutex_unlock(v1);
if ( !v8 )
{
if ( *(_QWORD *)(a1 + 2832) )
PSI_server[47]();
pthread_cond_broadcast(a1 + 2784);
}
}
else
{
if ( *(_QWORD *)(a1 + 2776) )
PSI_server[44]();
pthread_mutex_unlock(v1);
return 0;
}
return v7;
}
| _ma_bitmap_flush_all:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x40
MOV RBX,RDI
LEA R14,[RDI + 0xa98]
CMP qword ptr [RDI + 0xad8],0x0
JNZ 0x0014e33a
MOV RDI,R14
CALL 0x001291d0
LAB_0014e16a:
MOV AL,byte ptr [RBX + 0xa30]
TEST AL,AL
JNZ 0x0014e181
CMP byte ptr [RBX + 0xa31],0x0
JZ 0x0014e307
LAB_0014e181:
CMP byte ptr [RBX + 0x7df],0x0
JNZ 0x0014e197
TEST byte ptr [RBX + 0x170],0x1
JNZ 0x0014e37a
LAB_0014e197:
TEST AL,AL
JNZ 0x0014e1a8
CMP byte ptr [RBX + 0xa31],0x0
JZ 0x0014e332
LAB_0014e1a8:
INC dword ptr [RBX + 0xa40]
MOV ECX,dword ptr [RBX + 0xa4c]
LEA EDX,[RCX + 0x1]
MOV dword ptr [RBX + 0xa4c],EDX
CMP dword ptr [RBX + 0xa48],0x0
JZ 0x0014e217
LEA R15,[RBX + 0xae0]
LEA R12,[0x1da5b2]
LAB_0014e1d4:
CMP qword ptr [RBX + 0xb10],0x0
JNZ 0x0014e1f4
MOV RDI,R15
MOV RSI,R14
CALL 0x001293d0
LAB_0014e1e9:
CMP dword ptr [RBX + 0xa48],0x0
JNZ 0x0014e1d4
JMP 0x0014e209
LAB_0014e1f4:
MOV RDI,R15
MOV RSI,R14
MOV RDX,R12
MOV ECX,0x204
CALL 0x0012f180
JMP 0x0014e1e9
LAB_0014e209:
MOV ECX,dword ptr [RBX + 0xa4c]
MOV AL,byte ptr [RBX + 0xa30]
DEC ECX
LAB_0014e217:
MOV dword ptr [RBX + 0xa4c],ECX
XOR R15D,R15D
TEST AL,AL
JZ 0x0014e281
MOV word ptr [RBX + 0xa30],0x100
MOV RDI,qword ptr [RBX + 0x600]
LEA RSI,[RBX + 0xa50]
MOV RDX,qword ptr [RBX + 0xa20]
MOV R8,qword ptr [RBX + 0xa18]
MOV EAX,dword ptr [RDI + 0x80]
MOV dword ptr [RSP + 0x30],EAX
MOV dword ptr [RSP + 0x28],R15D
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSP + 0x18],XMM0
MOV dword ptr [RSP + 0x10],R15D
MOV dword ptr [RSP],R15D
MOV dword ptr [RSP + 0x8],0x1
XOR ECX,ECX
MOV R9D,0x1
CALL 0x0016e646
MOV R15D,EAX
LAB_0014e281:
MOV RDI,qword ptr [RBX + 0x600]
LEA RSI,[RBX + 0xa50]
LEA R8,[RBX + 0xb48]
LEA RCX,[0x14e3f5]
XOR EDX,EDX
CALL 0x0016ed3c
TEST AL,0x3
MOVZX EAX,R15B
MOV R15D,0x1
CMOVZ R15D,EAX
MOV byte ptr [RBX + 0xa31],0x0
DEC dword ptr [RBX + 0xa40]
MOV EAX,dword ptr [RBX + 0xa4c]
OR EAX,dword ptr [RBX + 0xa44]
SETZ R12B
LAB_0014e2d1:
MOV RDI,qword ptr [RBX + 0xad8]
TEST RDI,RDI
JNZ 0x0014e353
LAB_0014e2dd:
MOV RDI,R14
CALL 0x001291a0
TEST R12B,R12B
JNZ 0x0014e322
MOV RDI,qword ptr [RBX + 0xb10]
ADD RBX,0xae0
TEST RDI,RDI
JNZ 0x0014e368
LAB_0014e2fd:
MOV RDI,RBX
CALL 0x00129660
JMP 0x0014e322
LAB_0014e307:
MOV RDI,qword ptr [RBX + 0xad8]
TEST RDI,RDI
JNZ 0x0014e3ae
LAB_0014e317:
MOV RDI,R14
CALL 0x001291a0
XOR R15D,R15D
LAB_0014e322:
MOV EAX,R15D
ADD RSP,0x40
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0014e332:
MOV R12B,0x1
XOR R15D,R15D
JMP 0x0014e2d1
LAB_0014e33a:
LEA RSI,[0x1da5b2]
MOV RDI,R14
MOV EDX,0x1ee
CALL 0x0012ee6f
JMP 0x0014e16a
LAB_0014e353:
LEA RAX,[0x487050]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x0014e2dd
LAB_0014e368:
LEA RAX,[0x487050]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x178]
JMP 0x0014e2fd
LAB_0014e37a:
MOV RDI,qword ptr [RBX + 0xad8]
TEST RDI,RDI
JNZ 0x0014e3c3
LAB_0014e386:
MOV RDI,R14
CALL 0x001291a0
MOV RDI,RBX
CALL 0x0013d913
MOV RDI,R14
MOV ESI,0x184
CALL 0x0014e11b
MOV AL,byte ptr [RBX + 0xa30]
JMP 0x0014e197
LAB_0014e3ae:
LEA RAX,[0x487050]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x0014e317
LAB_0014e3c3:
LEA RAX,[0x487050]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x0014e386
|
int1 _ma_bitmap_flush_all(long param_1)
{
pthread_mutex_t *__mutex;
char cVar1;
int1 uVar2;
ulong uVar3;
int iVar4;
int1 uVar5;
bool bVar6;
__mutex = (pthread_mutex_t *)(param_1 + 0xa98);
if (*(long *)(param_1 + 0xad8) == 0) {
pthread_mutex_lock(__mutex);
}
else {
psi_mutex_lock(__mutex,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_bitmap.c",
0x1ee);
}
cVar1 = *(char *)(param_1 + 0xa30);
if ((cVar1 == '\0') && (*(char *)(param_1 + 0xa31) == '\0')) {
if (*(long *)(param_1 + 0xad8) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
uVar5 = 0;
}
else {
if ((*(char *)(param_1 + 0x7df) == '\0') && ((*(byte *)(param_1 + 0x170) & 1) != 0)) {
if (*(long *)(param_1 + 0xad8) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
_ma_mark_file_changed_now(param_1);
inline_mysql_mutex_lock(__mutex,0x184);
cVar1 = *(char *)(param_1 + 0xa30);
}
if ((cVar1 == '\0') && (*(char *)(param_1 + 0xa31) == '\0')) {
bVar6 = true;
uVar5 = 0;
}
else {
*(int *)(param_1 + 0xa40) = *(int *)(param_1 + 0xa40) + 1;
iVar4 = *(int *)(param_1 + 0xa4c);
*(int *)(param_1 + 0xa4c) = iVar4 + 1;
if (*(int *)(param_1 + 0xa48) != 0) {
do {
if (*(long *)(param_1 + 0xb10) == 0) {
pthread_cond_wait((pthread_cond_t *)(param_1 + 0xae0),__mutex);
}
else {
psi_cond_wait((pthread_cond_t *)(param_1 + 0xae0),__mutex,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_bitmap.c",0x204
);
}
} while (*(int *)(param_1 + 0xa48) != 0);
cVar1 = *(char *)(param_1 + 0xa30);
iVar4 = *(int *)(param_1 + 0xa4c) + -1;
}
*(int *)(param_1 + 0xa4c) = iVar4;
uVar2 = 0;
if (cVar1 != '\0') {
*(int2 *)(param_1 + 0xa30) = 0x100;
uVar2 = pagecache_write_part
(*(long *)(param_1 + 0x600),param_1 + 0xa50,
*(int8 *)(param_1 + 0xa20),0,*(int8 *)(param_1 + 0xa18),1,0,1
,0,0,0,0,*(int4 *)(*(long *)(param_1 + 0x600) + 0x80));
}
uVar3 = flush_pagecache_blocks_with_filter
(*(int8 *)(param_1 + 0x600),param_1 + 0xa50,0,
filter_flush_bitmap_pages,param_1 + 0xb48);
uVar5 = 1;
if ((uVar3 & 3) == 0) {
uVar5 = uVar2;
}
*(int1 *)(param_1 + 0xa31) = 0;
*(int *)(param_1 + 0xa40) = *(int *)(param_1 + 0xa40) + -1;
bVar6 = *(int *)(param_1 + 0xa4c) == 0 && *(int *)(param_1 + 0xa44) == 0;
}
if (*(long *)(param_1 + 0xad8) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
if (!bVar6) {
if (*(long *)(param_1 + 0xb10) != 0) {
(**(code **)(PSI_server + 0x178))();
}
pthread_cond_broadcast((pthread_cond_t *)(param_1 + 0xae0));
}
}
return uVar5;
}
| |
43,548 | pvio_socket_is_alive | eloqsql/libmariadb/plugins/pvio/pvio_socket.c | my_bool pvio_socket_is_alive(MARIADB_PVIO *pvio)
{
struct st_pvio_socket *csock= NULL;
#ifndef _WIN32
struct pollfd poll_fd;
#else
FD_SET sfds;
struct timeval tv= {0,0};
#endif
int res;
if (!pvio || !pvio->data)
return 0;
csock= (struct st_pvio_socket *)pvio->data;
#ifndef _WIN32
memset(&poll_fd, 0, sizeof(struct pollfd));
poll_fd.events= POLLPRI | POLLIN;
poll_fd.fd= csock->socket;
res= poll(&poll_fd, 1, 0);
if (res <= 0) /* timeout or error */
return FALSE;
if (!(poll_fd.revents & (POLLIN | POLLPRI)))
return FALSE;
return TRUE;
#else
/* We can't use the WSAPoll function, it's broken :-(
(see Windows 8 Bugs 309411 - WSAPoll does not report failed connections)
Instead we need to use select function:
If TIMEVAL is initialized to {0, 0}, select will return immediately;
this is used to poll the state of the selected sockets.
*/
FD_ZERO(&sfds);
FD_SET(csock->socket, &sfds);
res= select((int)csock->socket + 1, &sfds, NULL, NULL, &tv);
if (res > 0 && FD_ISSET(csock->socket, &sfds))
return TRUE;
return FALSE;
#endif
} | O3 | c | pvio_socket_is_alive:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x5e2a5
movq (%rdi), %rax
testq %rax, %rax
je 0x5e2a5
movabsq $0x300000000, %rcx # imm = 0x300000000
leaq -0x10(%rbp), %rdi
movq %rcx, (%rdi)
movl (%rax), %eax
movl %eax, (%rdi)
xorl %ebx, %ebx
movl $0x1, %esi
xorl %edx, %edx
callq 0x372d0
testl %eax, %eax
jle 0x5e2a7
testb $0x3, -0xa(%rbp)
setne %bl
jmp 0x5e2a7
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| pvio_socket_is_alive:
push rbp
mov rbp, rsp
push rbx
push rax
test rdi, rdi
jz short loc_5E2A5
mov rax, [rdi]
test rax, rax
jz short loc_5E2A5
mov rcx, 300000000h
lea rdi, [rbp+var_10]
mov [rdi], rcx
mov eax, [rax]
mov [rdi], eax
xor ebx, ebx
mov esi, 1
xor edx, edx
call _poll
test eax, eax
jle short loc_5E2A7
test [rbp+var_A], 3
setnz bl
jmp short loc_5E2A7
loc_5E2A5:
xor ebx, ebx
loc_5E2A7:
mov eax, ebx
add rsp, 8
pop rbx
pop rbp
retn
| long long pvio_socket_is_alive(_DWORD **a1)
{
long long v1; // rax
_DWORD *v2; // rax
unsigned int v3; // ebx
long long v5; // [rsp+0h] [rbp-10h] BYREF
v5 = v1;
if ( a1 && (v2 = *a1) != 0LL )
{
v5 = 0x300000000LL;
LODWORD(v5) = *v2;
v3 = 0;
if ( (int)poll(&v5, 1LL, 0LL) > 0 )
LOBYTE(v3) = (v5 & 0x3000000000000LL) != 0;
}
else
{
return 0;
}
return v3;
}
| pvio_socket_is_alive:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
TEST RDI,RDI
JZ 0x0015e2a5
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x0015e2a5
MOV RCX,0x300000000
LEA RDI,[RBP + -0x10]
MOV qword ptr [RDI],RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDI],EAX
XOR EBX,EBX
MOV ESI,0x1
XOR EDX,EDX
CALL 0x001372d0
TEST EAX,EAX
JLE 0x0015e2a7
TEST byte ptr [RBP + -0xa],0x3
SETNZ BL
JMP 0x0015e2a7
LAB_0015e2a5:
XOR EBX,EBX
LAB_0015e2a7:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP RBP
RET
|
bool pvio_socket_is_alive(int8 *param_1)
{
int iVar1;
bool bVar2;
pollfd local_18;
if ((param_1 == (int8 *)0x0) || ((int *)*param_1 == (int *)0x0)) {
bVar2 = false;
}
else {
local_18.events = 3;
local_18.revents = 0;
local_18.fd = *(int *)*param_1;
bVar2 = false;
iVar1 = poll(&local_18,1,0);
if (0 < iVar1) {
bVar2 = ((ulong)local_18 & 0x3000000000000) != 0;
}
}
return bVar2;
}
| |
43,549 | cpu_get_num_math() | monkey531[P]llama/common/common.cpp | int32_t cpu_get_num_math() {
#if defined(__x86_64__) && defined(__linux__) && !defined(__ANDROID__)
int n_cpu = sysconf(_SC_NPROCESSORS_ONLN);
if (n_cpu < 1) {
return cpu_get_num_physical_cores();
}
if (is_hybrid_cpu()) {
cpu_set_t affinity;
if (!pthread_getaffinity_np(pthread_self(), sizeof(affinity), &affinity)) {
int result = cpu_count_math_cpus(n_cpu);
pthread_setaffinity_np(pthread_self(), sizeof(affinity), &affinity);
if (result > 0) {
return result;
}
}
}
#endif
return cpu_get_num_physical_cores();
} | O1 | cpp | cpu_get_num_math():
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x100, %rsp # imm = 0x100
movl $0x54, %edi
callq 0x1b5b0
movq %rax, %rbx
testl %ebx, %ebx
jle 0x70cb0
movl $0x7, %eax
xorl %ecx, %ecx
movq %rbx, %rsi
cpuid
xchgq %rbx, %rsi
testw %dx, %dx
jns 0x70cb0
callq 0x1b7a0
movq %rax, %r14
leaq 0x80(%rsp), %rdx
movl $0x80, %esi
movq %rax, %rdi
callq 0x1bfa0
testl %eax, %eax
je 0x70bf8
movb $0x1, %al
jmp 0x70cac
xorl %r15d, %r15d
movq %rsp, %r12
xorl %ebp, %ebp
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
cmpl $0x3ff, %r15d # imm = 0x3FF
ja 0x70c48
movl $0x1, %eax
movl %r15d, %ecx
shlq %cl, %rax
movl %r15d, %ecx
shrl $0x6, %ecx
orq %rax, (%rsp,%rcx,8)
movl $0x80, %esi
movq %r14, %rdi
movq %r12, %rdx
callq 0x1bf50
testl %eax, %eax
jne 0x70c8d
xorl %ecx, %ecx
movl $0x1a, %eax
movq %rbx, %rsi
cpuid
xchgq %rbx, %rsi
andl $0xff000000, %eax # imm = 0xFF000000
xorl %ecx, %ecx
cmpl $0x20000000, %eax # imm = 0x20000000
setne %cl
addl %ecx, %ebp
addl %ecx, %r15d
incl %r15d
cmpl %ebx, %r15d
jl 0x70c00
jmp 0x70c92
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
leaq 0x80(%rsp), %rdx
movl $0x80, %esi
movq %r14, %rdi
callq 0x1bf50
testl %ebp, %ebp
setle %al
testb %al, %al
je 0x70cb7
callq 0x70814
movl %eax, %ebp
movl %ebp, %eax
addq $0x100, %rsp # imm = 0x100
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| _Z16cpu_get_num_mathv:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 100h
mov edi, 54h ; 'T'
call _sysconf
mov rbx, rax
test ebx, ebx
jle loc_70CB0
mov eax, 7
xor ecx, ecx
mov rsi, rbx
cpuid
xchg rsi, rbx
test dx, dx
jns loc_70CB0
call _pthread_self
mov r14, rax
lea rdx, [rsp+128h+var_A8]
mov esi, 80h
mov rdi, rax
call _pthread_getaffinity_np
test eax, eax
jz short loc_70BF8
mov al, 1
jmp loc_70CAC
loc_70BF8:
xor r15d, r15d
mov r12, rsp
xor ebp, ebp
loc_70C00:
xorps xmm0, xmm0
movaps [rsp+128h+var_B8], xmm0
movaps [rsp+128h+var_C8], xmm0
movaps [rsp+128h+var_D8], xmm0
movaps [rsp+128h+var_E8], xmm0
movaps [rsp+128h+var_F8], xmm0
movaps [rsp+128h+var_108], xmm0
movaps [rsp+128h+var_118], xmm0
movaps [rsp+128h+var_128], xmm0
cmp r15d, 3FFh
ja short loc_70C48
mov eax, 1
mov ecx, r15d
shl rax, cl
mov ecx, r15d
shr ecx, 6
or qword ptr [rsp+rcx*8+128h+var_128], rax
loc_70C48:
mov esi, 80h
mov rdi, r14
mov rdx, r12
call _pthread_setaffinity_np
test eax, eax
jnz short loc_70C8D
xor ecx, ecx
mov eax, 1Ah
mov rsi, rbx
cpuid
xchg rsi, rbx
and eax, 0FF000000h
xor ecx, ecx
cmp eax, 20000000h
setnz cl
add ebp, ecx
add r15d, ecx
inc r15d
cmp r15d, ebx
jl loc_70C00
jmp short loc_70C92
loc_70C8D:
mov ebp, 0FFFFFFFFh
loc_70C92:
lea rdx, [rsp+128h+var_A8]
mov esi, 80h
mov rdi, r14
call _pthread_setaffinity_np
test ebp, ebp
setle al
loc_70CAC:
test al, al
jz short loc_70CB7
loc_70CB0:
call _Z26cpu_get_num_physical_coresv; cpu_get_num_physical_cores(void)
mov ebp, eax
loc_70CB7:
mov eax, ebp
add rsp, 100h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long cpu_get_num_math()
{
int v0; // ebp
long long v1; // rbx
long long v3; // rsi
long long v8; // rbx
long long v9; // rsi
long long v10; // rt0
long long v11; // r14
bool v12; // al
unsigned int v13; // r15d
long long v14; // rcx
long long v15; // r8
long long v16; // r9
long long v18; // rsi
__int128 v24; // [rsp+0h] [rbp-128h] BYREF
__int128 v25; // [rsp+10h] [rbp-118h]
__int128 v26; // [rsp+20h] [rbp-108h]
__int128 v27; // [rsp+30h] [rbp-F8h]
__int128 v28; // [rsp+40h] [rbp-E8h]
__int128 v29; // [rsp+50h] [rbp-D8h]
__int128 v30; // [rsp+60h] [rbp-C8h]
__int128 v31; // [rsp+70h] [rbp-B8h]
_BYTE v32[168]; // [rsp+80h] [rbp-A8h] BYREF
v1 = sysconf(84LL);
if ( (int)v1 <= 0 )
return (unsigned int)cpu_get_num_physical_cores();
_RAX = 7LL;
v3 = v1;
__asm { cpuid }
v10 = v3;
v9 = _RBX;
v8 = v10;
if ( (_RDX & 0x8000u) == 0LL )
return (unsigned int)cpu_get_num_physical_cores();
v11 = pthread_self(84LL, v9, _RDX, _RCX);
if ( (unsigned int)pthread_getaffinity_np(v11, 128LL, v32) )
{
v12 = 1;
}
else
{
v13 = 0;
v0 = 0;
while ( 1 )
{
v31 = 0LL;
v30 = 0LL;
v29 = 0LL;
v28 = 0LL;
v27 = 0LL;
v26 = 0LL;
v25 = 0LL;
v24 = 0LL;
if ( v13 <= 0x3FF )
*((_QWORD *)&v24 + (v13 >> 6)) |= 1LL << v13;
if ( (unsigned int)((long long ( *)(long long, long long, __int128 *))pthread_setaffinity_np)(
v11,
128LL,
&v24) )
break;
_RAX = 26LL;
v18 = v8;
__asm { cpuid }
v8 = v18;
v14 = (_RAX & 0xFF000000) != 0x20000000;
v0 += v14;
v13 += v14 + 1;
if ( (int)v13 >= (int)v18 )
goto LABEL_12;
}
v0 = -1;
LABEL_12:
pthread_setaffinity_np(
v11,
128LL,
v32,
v14,
v15,
v16,
v24,
*((_QWORD *)&v24 + 1),
v25,
*((_QWORD *)&v25 + 1),
v26,
*((_QWORD *)&v26 + 1),
v27,
*((_QWORD *)&v27 + 1),
v28,
*((_QWORD *)&v28 + 1),
v29,
*((_QWORD *)&v29 + 1),
v30,
*((_QWORD *)&v30 + 1),
v31,
*((_QWORD *)&v31 + 1));
v12 = v0 <= 0;
}
if ( v12 )
return (unsigned int)cpu_get_num_physical_cores();
return (unsigned int)v0;
}
| cpu_get_num_math:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x100
MOV EDI,0x54
CALL 0x0011b5b0
MOV RBX,RAX
TEST EBX,EBX
JLE 0x00170cb0
MOV EAX,0x7
XOR ECX,ECX
MOV RSI,RBX
CPUID
XCHG RBX,RSI
TEST DX,DX
JNS 0x00170cb0
CALL 0x0011b7a0
MOV R14,RAX
LEA RDX,[RSP + 0x80]
MOV ESI,0x80
MOV RDI,RAX
CALL 0x0011bfa0
TEST EAX,EAX
JZ 0x00170bf8
MOV AL,0x1
JMP 0x00170cac
LAB_00170bf8:
XOR R15D,R15D
MOV R12,RSP
XOR EBP,EBP
LAB_00170c00:
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x70],XMM0
MOVAPS xmmword ptr [RSP + 0x60],XMM0
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOVAPS xmmword ptr [RSP + 0x40],XMM0
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOVAPS xmmword ptr [RSP],XMM0
CMP R15D,0x3ff
JA 0x00170c48
MOV EAX,0x1
MOV ECX,R15D
SHL RAX,CL
MOV ECX,R15D
SHR ECX,0x6
OR qword ptr [RSP + RCX*0x8],RAX
LAB_00170c48:
MOV ESI,0x80
MOV RDI,R14
MOV RDX,R12
CALL 0x0011bf50
TEST EAX,EAX
JNZ 0x00170c8d
XOR ECX,ECX
MOV EAX,0x1a
MOV RSI,RBX
CPUID
XCHG RBX,RSI
AND EAX,0xff000000
XOR ECX,ECX
CMP EAX,0x20000000
SETNZ CL
ADD EBP,ECX
ADD R15D,ECX
INC R15D
CMP R15D,EBX
JL 0x00170c00
JMP 0x00170c92
LAB_00170c8d:
MOV EBP,0xffffffff
LAB_00170c92:
LEA RDX,[RSP + 0x80]
MOV ESI,0x80
MOV RDI,R14
CALL 0x0011bf50
TEST EBP,EBP
SETLE AL
LAB_00170cac:
TEST AL,AL
JZ 0x00170cb7
LAB_00170cb0:
CALL 0x00170814
MOV EBP,EAX
LAB_00170cb7:
MOV EAX,EBP
ADD RSP,0x100
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Removing unreachable block (ram,0x00170c66) */
/* WARNING: Removing unreachable block (ram,0x00170bc2) */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* cpu_get_num_math() */
int cpu_get_num_math(void)
{
bool bVar1;
long lVar2;
uint *puVar3;
uint uVar4;
int iVar5;
long lVar6;
pthread_t __th;
int unaff_EBP;
uint uVar7;
cpu_set_t local_128;
cpu_set_t local_a8;
lVar6 = sysconf(0x54);
if ((0 < (int)lVar6) &&
(lVar2 = cpuid_Extended_Feature_Enumeration_info(7), (short)*(int4 *)(lVar2 + 8) < 0)) {
__th = pthread_self();
iVar5 = pthread_getaffinity_np(__th,0x80,&local_a8);
if (iVar5 == 0) {
uVar7 = 0;
unaff_EBP = 0;
do {
local_128.__bits[0xe] = 0;
local_128.__bits[0xf] = 0;
local_128.__bits[0xc] = 0;
local_128.__bits[0xd] = 0;
local_128.__bits[10] = 0;
local_128.__bits[0xb] = 0;
local_128.__bits[8] = 0;
local_128.__bits[9] = 0;
local_128.__bits[6] = 0;
local_128.__bits[7] = 0;
local_128.__bits[4] = 0;
local_128.__bits[5] = 0;
local_128.__bits[2] = 0;
local_128.__bits[3] = 0;
local_128.__bits[0] = 0;
local_128.__bits[1] = 0;
if (uVar7 < 0x400) {
local_128.__bits[uVar7 >> 6] = local_128.__bits[uVar7 >> 6] | 1L << ((byte)uVar7 & 0x3f);
}
iVar5 = pthread_setaffinity_np(__th,0x80,&local_128);
if (iVar5 != 0) {
unaff_EBP = -1;
break;
}
puVar3 = (uint *)cpuid(0x1a);
uVar4 = (uint)((*puVar3 & 0xff000000) != 0x20000000);
unaff_EBP = unaff_EBP + uVar4;
uVar7 = uVar7 + uVar4 + 1;
} while ((int)uVar7 < (int)lVar6);
pthread_setaffinity_np(__th,0x80,&local_a8);
bVar1 = unaff_EBP < 1;
}
else {
bVar1 = true;
}
if (!bVar1) {
return unaff_EBP;
}
}
iVar5 = cpu_get_num_physical_cores();
return iVar5;
}
| |
43,550 | cpu_get_num_math() | monkey531[P]llama/common/common.cpp | int32_t cpu_get_num_math() {
#if defined(__x86_64__) && defined(__linux__) && !defined(__ANDROID__)
int n_cpu = sysconf(_SC_NPROCESSORS_ONLN);
if (n_cpu < 1) {
return cpu_get_num_physical_cores();
}
if (is_hybrid_cpu()) {
cpu_set_t affinity;
if (!pthread_getaffinity_np(pthread_self(), sizeof(affinity), &affinity)) {
int result = cpu_count_math_cpus(n_cpu);
pthread_setaffinity_np(pthread_self(), sizeof(affinity), &affinity);
if (result > 0) {
return result;
}
}
}
#endif
return cpu_get_num_physical_cores();
} | O3 | cpp | cpu_get_num_math():
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x100, %rsp # imm = 0x100
movl $0x54, %edi
callq 0x1b5b0
movq %rax, %rbx
testl %ebx, %ebx
jle 0x71479
movl $0x7, %eax
xorl %ecx, %ecx
movq %rbx, %rsi
cpuid
xchgq %rbx, %rsi
testw %dx, %dx
jns 0x714a2
callq 0x1b7a0
movq %rax, %r14
leaq 0x80(%rsp), %rdx
movl $0x80, %esi
movq %rax, %rdi
callq 0x1bfa0
testl %eax, %eax
jne 0x714a2
xorl %r15d, %r15d
movq %rsp, %r12
xorl %ebp, %ebp
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
cmpl $0x3ff, %r15d # imm = 0x3FF
ja 0x7141b
movl $0x1, %eax
movl %r15d, %ecx
shlq %cl, %rax
movl %r15d, %ecx
shrl $0x6, %ecx
orq %rax, (%rsp,%rcx,8)
movl $0x80, %esi
movq %r14, %rdi
movq %r12, %rdx
callq 0x1bf50
testl %eax, %eax
jne 0x7148d
xorl %ecx, %ecx
movl $0x1a, %eax
movq %rbx, %rsi
cpuid
xchgq %rbx, %rsi
andl $0xff000000, %eax # imm = 0xFF000000
xorl %ecx, %ecx
cmpl $0x20000000, %eax # imm = 0x20000000
setne %cl
addl %ecx, %ebp
addl %ecx, %r15d
incl %r15d
cmpl %ebx, %r15d
jl 0x713d3
leaq 0x80(%rsp), %rdx
movl $0x80, %esi
movq %r14, %rdi
callq 0x1bf50
testl %ebp, %ebp
jne 0x714a9
jmp 0x714a2
addq $0x100, %rsp # imm = 0x100
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x70ff8
leaq 0x80(%rsp), %rdx
movl $0x80, %esi
movq %r14, %rdi
callq 0x1bf50
callq 0x70ff8
movl %eax, %ebp
movl %ebp, %eax
addq $0x100, %rsp # imm = 0x100
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| _Z16cpu_get_num_mathv:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 100h
mov edi, 54h ; 'T'
call _sysconf
mov rbx, rax
test ebx, ebx
jle loc_71479
mov eax, 7
xor ecx, ecx
mov rsi, rbx
cpuid
xchg rsi, rbx
test dx, dx
jns loc_714A2
call _pthread_self
mov r14, rax
lea rdx, [rsp+128h+var_A8]
mov esi, 80h
mov rdi, rax
call _pthread_getaffinity_np
test eax, eax
jnz loc_714A2
xor r15d, r15d
mov r12, rsp
xor ebp, ebp
loc_713D3:
xorps xmm0, xmm0
movaps [rsp+128h+var_B8], xmm0
movaps [rsp+128h+var_C8], xmm0
movaps [rsp+128h+var_D8], xmm0
movaps [rsp+128h+var_E8], xmm0
movaps [rsp+128h+var_F8], xmm0
movaps [rsp+128h+var_108], xmm0
movaps [rsp+128h+var_118], xmm0
movaps [rsp+128h+var_128], xmm0
cmp r15d, 3FFh
ja short loc_7141B
mov eax, 1
mov ecx, r15d
shl rax, cl
mov ecx, r15d
shr ecx, 6
or qword ptr [rsp+rcx*8+128h+var_128], rax
loc_7141B:
mov esi, 80h
mov rdi, r14
mov rdx, r12
call _pthread_setaffinity_np
test eax, eax
jnz short loc_7148D
xor ecx, ecx
mov eax, 1Ah
mov rsi, rbx
cpuid
xchg rsi, rbx
and eax, 0FF000000h
xor ecx, ecx
cmp eax, 20000000h
setnz cl
add ebp, ecx
add r15d, ecx
inc r15d
cmp r15d, ebx
jl loc_713D3
lea rdx, [rsp+128h+var_A8]
mov esi, 80h
mov rdi, r14
call _pthread_setaffinity_np
test ebp, ebp
jnz short loc_714A9
jmp short loc_714A2
loc_71479:
add rsp, 100h
pop rbx
pop r12
pop r14
pop r15
pop rbp
jmp _Z26cpu_get_num_physical_coresv; cpu_get_num_physical_cores(void)
loc_7148D:
lea rdx, [rsp+128h+var_A8]
mov esi, 80h
mov rdi, r14
call _pthread_setaffinity_np
loc_714A2:
call _Z26cpu_get_num_physical_coresv; cpu_get_num_physical_cores(void)
mov ebp, eax
loc_714A9:
mov eax, ebp
add rsp, 100h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long cpu_get_num_math(void)
{
long long v0; // rbx
long long v2; // rsi
long long v7; // rbx
long long v8; // rsi
long long v9; // rt0
long long v10; // r14
unsigned int v11; // r15d
unsigned int v12; // ebp
long long v13; // rcx
long long v14; // r8
long long v15; // r9
long long v17; // rsi
long long v22; // rcx
__int128 v24; // [rsp+0h] [rbp-128h] BYREF
__int128 v25; // [rsp+10h] [rbp-118h]
__int128 v26; // [rsp+20h] [rbp-108h]
__int128 v27; // [rsp+30h] [rbp-F8h]
__int128 v28; // [rsp+40h] [rbp-E8h]
__int128 v29; // [rsp+50h] [rbp-D8h]
__int128 v30; // [rsp+60h] [rbp-C8h]
__int128 v31; // [rsp+70h] [rbp-B8h]
_BYTE v32[168]; // [rsp+80h] [rbp-A8h] BYREF
v0 = sysconf(84LL);
if ( (int)v0 <= 0 )
return cpu_get_num_physical_cores();
_RAX = 7LL;
v2 = v0;
__asm { cpuid }
v9 = v2;
v8 = _RBX;
v7 = v9;
if ( (_RDX & 0x8000u) != 0LL )
{
v10 = pthread_self(84LL, v8, _RDX, _RCX);
if ( !(unsigned int)pthread_getaffinity_np(v10, 128LL, v32) )
{
v11 = 0;
v12 = 0;
do
{
v31 = 0LL;
v30 = 0LL;
v29 = 0LL;
v28 = 0LL;
v27 = 0LL;
v26 = 0LL;
v25 = 0LL;
v24 = 0LL;
if ( v11 <= 0x3FF )
*((_QWORD *)&v24 + (v11 >> 6)) |= 1LL << v11;
if ( (unsigned int)((long long ( *)(long long, long long, __int128 *))pthread_setaffinity_np)(
v10,
128LL,
&v24) )
{
pthread_setaffinity_np(
v10,
128LL,
v32,
v13,
v14,
v15,
v24,
*((_QWORD *)&v24 + 1),
v25,
*((_QWORD *)&v25 + 1),
v26,
*((_QWORD *)&v26 + 1),
v27,
*((_QWORD *)&v27 + 1),
v28,
*((_QWORD *)&v28 + 1),
v29,
*((_QWORD *)&v29 + 1),
v30,
*((_QWORD *)&v30 + 1),
v31,
*((_QWORD *)&v31 + 1));
return (unsigned int)cpu_get_num_physical_cores();
}
_RAX = 26LL;
v17 = v7;
__asm { cpuid }
v7 = v17;
v22 = (_RAX & 0xFF000000) != 0x20000000;
v12 += v22;
v11 += v22 + 1;
}
while ( (int)v11 < (int)v17 );
pthread_setaffinity_np(
v10,
128LL,
v32,
v22,
v14,
v15,
v24,
*((_QWORD *)&v24 + 1),
v25,
*((_QWORD *)&v25 + 1),
v26,
*((_QWORD *)&v26 + 1),
v27,
*((_QWORD *)&v27 + 1),
v28,
*((_QWORD *)&v28 + 1),
v29,
*((_QWORD *)&v29 + 1),
v30,
*((_QWORD *)&v30 + 1),
v31,
*((_QWORD *)&v31 + 1));
if ( v12 )
return v12;
}
}
return (unsigned int)cpu_get_num_physical_cores();
}
| cpu_get_num_math:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x100
MOV EDI,0x54
CALL 0x0011b5b0
MOV RBX,RAX
TEST EBX,EBX
JLE 0x00171479
MOV EAX,0x7
XOR ECX,ECX
MOV RSI,RBX
CPUID
XCHG RBX,RSI
TEST DX,DX
JNS 0x001714a2
CALL 0x0011b7a0
MOV R14,RAX
LEA RDX,[RSP + 0x80]
MOV ESI,0x80
MOV RDI,RAX
CALL 0x0011bfa0
TEST EAX,EAX
JNZ 0x001714a2
XOR R15D,R15D
MOV R12,RSP
XOR EBP,EBP
LAB_001713d3:
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x70],XMM0
MOVAPS xmmword ptr [RSP + 0x60],XMM0
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOVAPS xmmword ptr [RSP + 0x40],XMM0
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOVAPS xmmword ptr [RSP],XMM0
CMP R15D,0x3ff
JA 0x0017141b
MOV EAX,0x1
MOV ECX,R15D
SHL RAX,CL
MOV ECX,R15D
SHR ECX,0x6
OR qword ptr [RSP + RCX*0x8],RAX
LAB_0017141b:
MOV ESI,0x80
MOV RDI,R14
MOV RDX,R12
CALL 0x0011bf50
TEST EAX,EAX
JNZ 0x0017148d
XOR ECX,ECX
MOV EAX,0x1a
MOV RSI,RBX
CPUID
XCHG RBX,RSI
AND EAX,0xff000000
XOR ECX,ECX
CMP EAX,0x20000000
SETNZ CL
ADD EBP,ECX
ADD R15D,ECX
INC R15D
CMP R15D,EBX
JL 0x001713d3
LEA RDX,[RSP + 0x80]
MOV ESI,0x80
MOV RDI,R14
CALL 0x0011bf50
TEST EBP,EBP
JNZ 0x001714a9
JMP 0x001714a2
LAB_00171479:
ADD RSP,0x100
POP RBX
POP R12
POP R14
POP R15
POP RBP
JMP 0x00170ff8
LAB_0017148d:
LEA RDX,[RSP + 0x80]
MOV ESI,0x80
MOV RDI,R14
CALL 0x0011bf50
LAB_001714a2:
CALL 0x00170ff8
MOV EBP,EAX
LAB_001714a9:
MOV EAX,EBP
ADD RSP,0x100
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Removing unreachable block (ram,0x00171439) */
/* WARNING: Removing unreachable block (ram,0x00171398) */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* cpu_get_num_math() */
ulong cpu_get_num_math(void)
{
long lVar1;
uint *puVar2;
uint uVar3;
int iVar4;
long lVar5;
pthread_t __th;
ulong uVar6;
uint uVar7;
uint uVar8;
cpu_set_t local_128;
cpu_set_t local_a8;
lVar5 = sysconf(0x54);
if ((int)lVar5 < 1) {
uVar6 = cpu_get_num_physical_cores();
return uVar6;
}
lVar1 = cpuid_Extended_Feature_Enumeration_info(7);
if ((short)*(int4 *)(lVar1 + 8) < 0) {
__th = pthread_self();
iVar4 = pthread_getaffinity_np(__th,0x80,&local_a8);
if (iVar4 == 0) {
uVar8 = 0;
uVar7 = 0;
do {
local_128.__bits[0xe] = 0;
local_128.__bits[0xf] = 0;
local_128.__bits[0xc] = 0;
local_128.__bits[0xd] = 0;
local_128.__bits[10] = 0;
local_128.__bits[0xb] = 0;
local_128.__bits[8] = 0;
local_128.__bits[9] = 0;
local_128.__bits[6] = 0;
local_128.__bits[7] = 0;
local_128.__bits[4] = 0;
local_128.__bits[5] = 0;
local_128.__bits[2] = 0;
local_128.__bits[3] = 0;
local_128.__bits[0] = 0;
local_128.__bits[1] = 0;
if (uVar8 < 0x400) {
local_128.__bits[uVar8 >> 6] = local_128.__bits[uVar8 >> 6] | 1L << ((byte)uVar8 & 0x3f);
}
iVar4 = pthread_setaffinity_np(__th,0x80,&local_128);
if (iVar4 != 0) {
pthread_setaffinity_np(__th,0x80,&local_a8);
goto LAB_001714a2;
}
puVar2 = (uint *)cpuid(0x1a);
uVar3 = (uint)((*puVar2 & 0xff000000) != 0x20000000);
uVar7 = uVar7 + uVar3;
uVar8 = uVar8 + uVar3 + 1;
} while ((int)uVar8 < (int)lVar5);
pthread_setaffinity_np(__th,0x80,&local_a8);
if (uVar7 != 0) goto LAB_001714a9;
}
}
LAB_001714a2:
uVar7 = cpu_get_num_physical_cores();
LAB_001714a9:
return (ulong)uVar7;
}
| |
43,551 | translog_page_next | eloqsql/storage/maria/ma_loghandler.c | static my_bool translog_page_next(TRANSLOG_ADDRESS *horizon,
struct st_buffer_cursor *cursor,
struct st_translog_buffer **prev_buffer)
{
struct st_translog_buffer *buffer= cursor->buffer;
DBUG_ENTER("translog_page_next");
*prev_buffer= NULL;
if ((cursor->ptr + TRANSLOG_PAGE_SIZE >
cursor->buffer->buffer + TRANSLOG_WRITE_BUFFER) ||
(LSN_OFFSET(*horizon) >
log_descriptor.log_file_max_size - TRANSLOG_PAGE_SIZE))
{
DBUG_PRINT("info", ("Switch to next buffer Buffer Size: %lu (%lu) => %d "
"File size: %lu max: %lu => %d",
(ulong) cursor->buffer->size,
(ulong) (cursor->ptr - cursor->buffer->buffer),
(cursor->ptr + TRANSLOG_PAGE_SIZE >
cursor->buffer->buffer + TRANSLOG_WRITE_BUFFER),
(ulong) LSN_OFFSET(*horizon),
(ulong) log_descriptor.log_file_max_size,
(LSN_OFFSET(*horizon) >
(log_descriptor.log_file_max_size -
TRANSLOG_PAGE_SIZE))));
if (translog_buffer_next(horizon, cursor,
LSN_OFFSET(*horizon) >
(log_descriptor.log_file_max_size -
TRANSLOG_PAGE_SIZE)))
DBUG_RETURN(1);
*prev_buffer= buffer;
DBUG_PRINT("info", ("Buffer #%u (%p): have to be flushed",
(uint) buffer->buffer_no, buffer));
}
else
{
DBUG_PRINT("info", ("Use the same buffer #%u (%p): "
"Buffer Size: %lu (%lu)",
(uint) buffer->buffer_no,
buffer,
(ulong) cursor->buffer->size,
(ulong) (cursor->ptr - cursor->buffer->buffer)));
translog_finish_page(horizon, cursor);
translog_new_page_header(horizon, cursor);
}
DBUG_RETURN(0);
} | O0 | c | translog_page_next:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
addq $0x2000, %rax # imm = 0x2000
movq -0x18(%rbp), %rcx
movq 0x28(%rcx), %rcx
addq $0x100000, %rcx # imm = 0x100000
cmpq %rcx, %rax
ja 0x5ae51
movq -0x10(%rbp), %rcx
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq (%rcx), %rax
movl 0x41f82c(%rip), %ecx # 0x47a670
subl $0x2000, %ecx # imm = 0x2000
movl %ecx, %ecx
cmpq %rcx, %rax
jbe 0x5aeaa
jmp 0x5ae53
jmp 0x5ae55
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rcx
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq (%rcx), %rax
movl 0x41f7fc(%rip), %ecx # 0x47a670
subl $0x2000, %ecx # imm = 0x2000
movl %ecx, %ecx
cmpq %rcx, %rax
seta %al
andb $0x1, %al
movzbl %al, %eax
movsbl %al, %edx
callq 0x59130
cmpb $0x0, %al
je 0x5ae9b
jmp 0x5ae95
movb $0x1, -0x1(%rbp)
jmp 0x5aece
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x5aea8
jmp 0x5aec8
jmp 0x5aeac
jmp 0x5aeae
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x54f60
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x53ed0
jmp 0x5aeca
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| translog_page_next:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_18]
mov rax, [rax+28h]
mov [rbp+var_28], rax
mov rax, [rbp+var_20]
mov qword ptr [rax], 0
mov rax, [rbp+var_18]
mov rax, [rax+20h]
add rax, 2000h
mov rcx, [rbp+var_18]
mov rcx, [rcx+28h]
add rcx, 100000h
cmp rax, rcx
ja short loc_5AE51
mov rcx, [rbp+var_10]
mov rax, 0FFFFFFFFh
and rax, [rcx]
mov ecx, cs:dword_47A670
sub ecx, 2000h
mov ecx, ecx
cmp rax, rcx
jbe short loc_5AEAA
loc_5AE51:
jmp short $+2
loc_5AE53:
jmp short $+2
loc_5AE55:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rcx, [rbp+var_10]
mov rax, 0FFFFFFFFh
and rax, [rcx]
mov ecx, cs:dword_47A670
sub ecx, 2000h
mov ecx, ecx
cmp rax, rcx
setnbe al
and al, 1
movzx eax, al
movsx edx, al
call translog_buffer_next
cmp al, 0
jz short loc_5AE9B
jmp short $+2
loc_5AE95:
mov [rbp+var_1], 1
jmp short loc_5AECE
loc_5AE9B:
mov rcx, [rbp+var_28]
mov rax, [rbp+var_20]
mov [rax], rcx
jmp short $+2
loc_5AEA8:
jmp short loc_5AEC8
loc_5AEAA:
jmp short $+2
loc_5AEAC:
jmp short $+2
loc_5AEAE:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call translog_finish_page
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call translog_new_page_header
loc_5AEC8:
jmp short $+2
loc_5AECA:
mov [rbp+var_1], 0
loc_5AECE:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
| char translog_page_next(long long *a1, long long a2, _QWORD *a3)
{
long long v4; // [rsp+8h] [rbp-28h]
v4 = *(_QWORD *)(a2 + 40);
*a3 = 0LL;
if ( *(_QWORD *)(a2 + 32) + 0x2000LL <= (unsigned long long)(*(_QWORD *)(a2 + 40) + 0x100000LL)
&& (unsigned int)*a1 <= (unsigned long long)(unsigned int)(dword_47A670 - 0x2000) )
{
translog_finish_page(a1, a2);
translog_new_page_header(a1, a2);
return 0;
}
if ( !translog_buffer_next(a1, a2, (unsigned int)*a1 > (unsigned long long)(unsigned int)(dword_47A670 - 0x2000)) )
{
*a3 = v4;
return 0;
}
return 1;
}
| translog_page_next:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x20]
ADD RAX,0x2000
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX + 0x28]
ADD RCX,0x100000
CMP RAX,RCX
JA 0x0015ae51
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,0xffffffff
AND RAX,qword ptr [RCX]
MOV ECX,dword ptr [0x0057a670]
SUB ECX,0x2000
MOV ECX,ECX
CMP RAX,RCX
JBE 0x0015aeaa
LAB_0015ae51:
JMP 0x0015ae53
LAB_0015ae53:
JMP 0x0015ae55
LAB_0015ae55:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,0xffffffff
AND RAX,qword ptr [RCX]
MOV ECX,dword ptr [0x0057a670]
SUB ECX,0x2000
MOV ECX,ECX
CMP RAX,RCX
SETA AL
AND AL,0x1
MOVZX EAX,AL
MOVSX EDX,AL
CALL 0x00159130
CMP AL,0x0
JZ 0x0015ae9b
JMP 0x0015ae95
LAB_0015ae95:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0015aece
LAB_0015ae9b:
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
JMP 0x0015aea8
LAB_0015aea8:
JMP 0x0015aec8
LAB_0015aeaa:
JMP 0x0015aeac
LAB_0015aeac:
JMP 0x0015aeae
LAB_0015aeae:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00154f60
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00153ed0
LAB_0015aec8:
JMP 0x0015aeca
LAB_0015aeca:
MOV byte ptr [RBP + -0x1],0x0
LAB_0015aece:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int1 translog_page_next(ulong *param_1,long param_2,int8 *param_3)
{
int8 uVar1;
char cVar2;
uVar1 = *(int8 *)(param_2 + 0x28);
*param_3 = 0;
if ((*(long *)(param_2 + 0x28) + 0x100000U < *(long *)(param_2 + 0x20) + 0x2000U) ||
((ulong)(DAT_0057a670 - 0x2000) < (*param_1 & 0xffffffff))) {
cVar2 = translog_buffer_next
(param_1,param_2,(ulong)(DAT_0057a670 - 0x2000) < (*param_1 & 0xffffffff));
if (cVar2 != '\0') {
return 1;
}
*param_3 = uVar1;
}
else {
translog_finish_page(param_1,param_2);
translog_new_page_header(param_1,param_2);
}
return 0;
}
| |
43,552 | intx::internal::udivrem_by2(unsigned long*, int, intx::uint<128u>) | corpus-core[P]colibri-stateless/build_O0/_deps/intx-src/include/intx/intx.hpp | inline uint128 udivrem_by2(uint64_t u[], int len, uint128 d) noexcept
{
INTX_REQUIRE(len >= 3);
const auto reciprocal = reciprocal_3by2(d);
auto rem = uint128{u[len - 2], u[len - 1]}; // Set the 2 top words as remainder.
u[len - 1] = u[len - 2] = 0; // Reset these words being a part of the result quotient.
auto it = &u[len - 3];
do
{
std::tie(*it, rem) = udivrem_3by2(rem[1], rem[0], *it, d, reciprocal);
} while (it-- != &u[0]);
return rem;
} | O0 | cpp | intx::internal::udivrem_by2(unsigned long*, int, intx::uint<128u>):
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdx, -0x20(%rbp)
movq %rcx, -0x18(%rbp)
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
cmpl $0x3, -0x2c(%rbp)
jl 0x61082
jmp 0x610a1
leaq 0x7c350(%rip), %rdi # 0xdd3d9
leaq 0x7c1d8(%rip), %rsi # 0xdd268
movl $0x65c, %edx # imm = 0x65C
leaq 0x7c2fe(%rip), %rcx # 0xdd39a
callq 0x23160
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x620a0
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rsi
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
leaq -0x10(%rbp), %rdi
callq 0x60120
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
subl $0x3, %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
leaq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x60150
movq (%rax), %rax
movq %rax, -0xa0(%rbp)
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x60150
movq -0xa0(%rbp), %rsi
movq (%rax), %rdx
movq -0x50(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x38(%rbp), %rax
movq -0x88(%rbp), %r8
movq -0x80(%rbp), %r9
leaq -0x78(%rbp), %rdi
movq %rax, (%rsp)
callq 0x62290
leaq -0x60(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x625d0
movq -0x50(%rbp), %rsi
leaq -0x98(%rbp), %rdi
leaq -0x10(%rbp), %rdx
callq 0x62610
leaq -0x98(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x62650
movq -0x50(%rbp), %rax
movq %rax, %rcx
addq $-0x8, %rcx
movq %rcx, -0x50(%rbp)
movq -0x28(%rbp), %rcx
cmpq %rcx, %rax
jne 0x6112f
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| _ZN4intx8internal11udivrem_by2EPmiNS_4uintILj128EEE:
push rbp
mov rbp, rsp
sub rsp, 0B0h
mov [rbp+var_20], rdx
mov [rbp+var_18], rcx
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
cmp [rbp+var_2C], 3
jl short loc_61082
jmp short loc_610A1
loc_61082:
lea rdi, aDlen3+1; "len >= 3"
lea rsi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
mov edx, 65Ch
lea rcx, aUint128IntxInt; "uint128 intx::internal::udivrem_by2(uin"...
call ___assert_fail
loc_610A1:
mov rax, [rbp+var_20]
mov [rbp+var_48], rax
mov rax, [rbp+var_18]
mov [rbp+var_40], rax
mov rdi, [rbp+var_48]
mov rsi, [rbp+var_40]
call _ZN4intx15reciprocal_3by2ENS_4uintILj128EEE; intx::reciprocal_3by2(intx::uint<128u>)
mov [rbp+var_38], rax
mov rax, [rbp+var_28]
mov ecx, [rbp+var_2C]
sub ecx, 2
movsxd rcx, ecx
mov rsi, [rax+rcx*8]
mov rax, [rbp+var_28]
mov ecx, [rbp+var_2C]
sub ecx, 1
movsxd rcx, ecx
mov rdx, [rax+rcx*8]
lea rdi, [rbp+var_10]
call _ZN4intx4uintILj128EEC2Emm; intx::uint<128u>::uint(ulong,ulong)
mov rax, [rbp+var_28]
mov ecx, [rbp+var_2C]
sub ecx, 2
movsxd rcx, ecx
mov qword ptr [rax+rcx*8], 0
mov rax, [rbp+var_28]
mov ecx, [rbp+var_2C]
sub ecx, 1
movsxd rcx, ecx
mov qword ptr [rax+rcx*8], 0
mov rax, [rbp+var_28]
mov ecx, [rbp+var_2C]
sub ecx, 3
movsxd rcx, ecx
shl rcx, 3
add rax, rcx
mov [rbp+var_50], rax
loc_6112F:
lea rdi, [rbp+var_10]
mov esi, 1
call _ZN4intx4uintILj128EEixEm; intx::uint<128u>::operator[](ulong)
mov rax, [rax]
mov qword ptr [rbp+var_A0], rax
lea rdi, [rbp+var_10]
xor eax, eax
mov esi, eax
call _ZN4intx4uintILj128EEixEm; intx::uint<128u>::operator[](ulong)
mov rsi, qword ptr [rbp+var_A0]; int
mov rdx, [rax]; int
mov rax, [rbp+var_50]
mov rcx, [rax]; int
mov rax, [rbp+var_20]
mov qword ptr [rbp+var_88], rax
mov rax, [rbp+var_18]
mov qword ptr [rbp+var_80], rax
mov rax, [rbp+var_38]
mov r8, qword ptr [rbp+var_88]; int
mov r9, qword ptr [rbp+var_80]; int
lea rdi, [rbp+var_78]; int
mov [rsp+0B0h+var_B0], rax; intx *
call _ZN4intx12udivrem_3by2EmmmNS_4uintILj128EEEm; intx::udivrem_3by2(ulong,ulong,ulong,intx::uint<128u>,ulong)
lea rdi, [rbp+var_60]
lea rsi, [rbp+var_78]
call _ZN4intx10div_resultImNS_4uintILj128EEEEcvSt5tupleIJRmRS2_EEEv; intx::div_result<ulong,intx::uint<128u>>::operator std::tuple<ulong &,intx::uint<128u>&>(void)
mov rsi, [rbp+var_50]
lea rdi, [rbp+var_98]
lea rdx, [rbp+var_10]
call _ZSt3tieIJmN4intx4uintILj128EEEEESt5tupleIJDpRT_EES6_; std::tie<ulong,intx::uint<128u>>(ulong,intx::uint<128u> &)
lea rdi, [rbp+var_98]
lea rsi, [rbp+var_60]
call _ZNSt5tupleIJRmRN4intx4uintILj128EEEEEaSEOS5_; std::tuple<ulong &,intx::uint<128u> &>::operator=(std::tuple<ulong &,intx::uint<128u> &>&&)
mov rax, [rbp+var_50]
mov rcx, rax
add rcx, 0FFFFFFFFFFFFFFF8h
mov [rbp+var_50], rcx
mov rcx, [rbp+var_28]
cmp rax, rcx
jnz loc_6112F
mov rax, [rbp+var_10]
mov rdx, [rbp+var_8]
add rsp, 0B0h
pop rbp
retn
| long long intx::internal::udivrem_by2(long long *a1, int a2, long long a3, long long a4)
{
long long v4; // rdx
long long v5; // rcx
long long *v6; // rax
int v8[2]; // [rsp+10h] [rbp-A0h]
_BYTE v9[16]; // [rsp+18h] [rbp-98h] BYREF
int v10[2]; // [rsp+28h] [rbp-88h]
int v11[2]; // [rsp+30h] [rbp-80h]
int v12[6]; // [rsp+38h] [rbp-78h] BYREF
_BYTE v13[16]; // [rsp+50h] [rbp-60h] BYREF
long long *v14; // [rsp+60h] [rbp-50h]
long long v15; // [rsp+68h] [rbp-48h]
long long v16; // [rsp+70h] [rbp-40h]
intx *v17; // [rsp+78h] [rbp-38h]
int v18; // [rsp+84h] [rbp-2Ch]
long long *v19; // [rsp+88h] [rbp-28h]
long long v20; // [rsp+90h] [rbp-20h]
long long v21; // [rsp+98h] [rbp-18h]
long long v22; // [rsp+A0h] [rbp-10h] BYREF
v20 = a3;
v21 = a4;
v19 = a1;
v18 = a2;
if ( a2 < 3 )
__assert_fail(
"len >= 3",
"/workspace/llm4binary/github/2025_star3/corpus-core[P]colibri-stateless/build_O0/_deps/intx-src/include/intx/intx.hpp",
1628LL,
"uint128 intx::internal::udivrem_by2(uint64_t *, int, uint128)");
v15 = v20;
v16 = v21;
v17 = (intx *)intx::reciprocal_3by2(v20, v21);
intx::uint<128u>::uint(&v22, v19[v18 - 2], v19[v18 - 1]);
v19[v18 - 2] = 0LL;
v19[v18 - 1] = 0LL;
v14 = &v19[v18 - 3];
do
{
*(_QWORD *)v8 = *(_QWORD *)intx::uint<128u>::operator[]((long long)&v22, 1LL);
v4 = *(_QWORD *)intx::uint<128u>::operator[]((long long)&v22, 0LL);
v5 = *v14;
*(_QWORD *)v10 = v20;
*(_QWORD *)v11 = v21;
intx::udivrem_3by2((int)v12, v8[0], v4, v5, v20, v21, v17);
intx::div_result<unsigned long,intx::uint<128u>>::operator std::tuple<unsigned long &,intx::uint<128u>&>(v13, v12);
std::tie<unsigned long,intx::uint<128u>>(v9, v14, &v22);
std::tuple<unsigned long &,intx::uint<128u> &>::operator=(v9, v13);
v6 = v14--;
}
while ( v6 != v19 );
return v22;
}
| udivrem_by2:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xb0
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x18],RCX
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
CMP dword ptr [RBP + -0x2c],0x3
JL 0x00161082
JMP 0x001610a1
LAB_00161082:
LEA RDI,[0x1dd3d9]
LEA RSI,[0x1dd268]
MOV EDX,0x65c
LEA RCX,[0x1dd39a]
CALL 0x00123160
LAB_001610a1:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x48]
MOV RSI,qword ptr [RBP + -0x40]
CALL 0x001620a0
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RBP + -0x2c]
SUB ECX,0x2
MOVSXD RCX,ECX
MOV RSI,qword ptr [RAX + RCX*0x8]
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RBP + -0x2c]
SUB ECX,0x1
MOVSXD RCX,ECX
MOV RDX,qword ptr [RAX + RCX*0x8]
LEA RDI,[RBP + -0x10]
CALL 0x00160120
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RBP + -0x2c]
SUB ECX,0x2
MOVSXD RCX,ECX
MOV qword ptr [RAX + RCX*0x8],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RBP + -0x2c]
SUB ECX,0x1
MOVSXD RCX,ECX
MOV qword ptr [RAX + RCX*0x8],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RBP + -0x2c]
SUB ECX,0x3
MOVSXD RCX,ECX
SHL RCX,0x3
ADD RAX,RCX
MOV qword ptr [RBP + -0x50],RAX
LAB_0016112f:
LEA RDI,[RBP + -0x10]
MOV ESI,0x1
CALL 0x00160150
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0xa0],RAX
LEA RDI,[RBP + -0x10]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x00160150
MOV RSI,qword ptr [RBP + -0xa0]
MOV RDX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x50]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x88],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x80],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV R8,qword ptr [RBP + -0x88]
MOV R9,qword ptr [RBP + -0x80]
LEA RDI,[RBP + -0x78]
MOV qword ptr [RSP],RAX
CALL 0x00162290
LEA RDI,[RBP + -0x60]
LEA RSI,[RBP + -0x78]
CALL 0x001625d0
MOV RSI,qword ptr [RBP + -0x50]
LEA RDI,[RBP + -0x98]
LEA RDX,[RBP + -0x10]
CALL 0x00162610
LEA RDI,[RBP + -0x98]
LEA RSI,[RBP + -0x60]
CALL 0x00162650
MOV RAX,qword ptr [RBP + -0x50]
MOV RCX,RAX
ADD RCX,-0x8
MOV qword ptr [RBP + -0x50],RCX
MOV RCX,qword ptr [RBP + -0x28]
CMP RAX,RCX
JNZ 0x0016112f
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x8]
ADD RSP,0xb0
POP RBP
RET
|
/* intx::internal::udivrem_by2(unsigned long*, int, intx::uint<128u>) */
int1 [16] __thiscall
intx::internal::udivrem_by2(internal *this,int param_2,intx *param_3,int8 param_4)
{
int8 uVar1;
int8 *puVar2;
bool bVar3;
int1 auVar4 [16];
tuple<unsigned_long&,intx::uint<128u>&> local_a0 [16];
intx *local_90;
int8 local_88;
int1 local_80 [24];
div_result local_68 [16];
internal *local_58;
intx *local_50;
int8 local_48;
int8 local_40;
int local_34;
internal *local_30;
intx *local_28;
int8 local_20;
uint<128u> local_18 [16];
int1 auVar5 [15];
int8 uVar6;
local_34 = param_2;
local_30 = this;
local_28 = param_3;
local_20 = param_4;
if (2 < param_2) {
local_50 = param_3;
local_48 = param_4;
local_40 = reciprocal_3by2(param_3,param_4);
uint<128u>::uint(local_18,*(ulong *)(local_30 + (long)(local_34 + -2) * 8),
*(ulong *)(local_30 + (long)(local_34 + -1) * 8));
*(int8 *)(local_30 + (long)(local_34 + -2) * 8) = 0;
*(int8 *)(local_30 + (long)(local_34 + -1) * 8) = 0;
local_58 = local_30 + (long)(local_34 + -3) * 8;
do {
puVar2 = (int8 *)uint<128u>::operator[](local_18,1);
uVar1 = *puVar2;
puVar2 = (int8 *)uint<128u>::operator[](local_18,0);
local_90 = local_28;
local_88 = local_20;
udivrem_3by2(local_80,uVar1,*puVar2,*(int8 *)local_58,local_28,local_20,local_40);
div_result::operator_cast_to_tuple(local_68);
std::tie<unsigned_long,intx::uint<128u>>((ulong *)local_a0,(uint *)local_58);
std::tuple<unsigned_long&,intx::uint<128u>&>::operator=(local_a0,(tuple *)local_68);
bVar3 = local_58 != local_30;
local_58 = local_58 + -8;
} while (bVar3);
auVar4[0] = local_18[0];
auVar5[1] = local_18[1];
auVar5[2] = local_18[2];
auVar5[3] = local_18[3];
auVar5[4] = local_18[4];
auVar5[5] = local_18[5];
auVar5[6] = local_18[6];
auVar5[7] = local_18[7];
register0x00000010 = local_18[8];
register0x00000011 = local_18[9];
register0x00000012 = local_18[10];
register0x00000013 = local_18[0xb];
register0x00000014 = local_18[0xc];
register0x00000015 = local_18[0xd];
register0x00000016 = local_18[0xe];
register0x00000017 = local_18[0xf];
return auVar4;
}
/* WARNING: Subroutine does not return */
__assert_fail("len >= 3",
"/workspace/llm4binary/github/2025_star3/corpus-core[P]colibri-stateless/build_O0/_deps/intx-src/include/intx/intx.hpp"
,0x65c,"uint128 intx::internal::udivrem_by2(uint64_t *, int, uint128)");
}
| |
43,553 | kv_cache_type_from_str(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | llama.cpp/common/arg.cpp | static ggml_type kv_cache_type_from_str(const std::string & s) {
for (const auto & type : kv_cache_types) {
if (ggml_type_name(type) == s) {
return type;
}
}
throw std::runtime_error("Unsupported cache type: " + s);
} | O3 | cpp | kv_cache_type_from_str(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq 0x101eda(%rip), %rbx # 0x167fd8
movq 0x101edb(%rip), %r15 # 0x167fe0
cmpq %r15, %rbx
je 0x66133
movl (%rbx), %edi
callq 0x22460
movq %r14, %rdi
movq %rax, %rsi
callq 0x22090
testl %eax, %eax
je 0x66126
addq $0x4, %rbx
jmp 0x66105
movl (%rbx), %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x216a0
movq %rax, %rbx
leaq 0xba114(%rip), %rsi # 0x12025b
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x6a481
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x21490
xorl %ebp, %ebp
movq 0x100e4b(%rip), %rsi # 0x166fb8
movq 0x100dfc(%rip), %rdx # 0x166f70
movq %rbx, %rdi
callq 0x21ae0
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6619a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21180
testb %bpl, %bpl
jne 0x661a4
jmp 0x661ac
movq %rax, %r14
movq %rbx, %rdi
callq 0x22020
movq %r14, %rdi
callq 0x21b80
| _ZL22kv_cache_type_from_strRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
push r15
push r14
push rbx
sub rsp, 28h
mov r14, rdi
mov rbx, cs:_ZL14kv_cache_types; kv_cache_types
mov r15, cs:qword_167FE0
loc_66105:
cmp rbx, r15
jz short loc_66133
mov edi, [rbx]
call _ggml_type_name
mov rdi, r14
mov rsi, rax
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_66126
add rbx, 4
jmp short loc_66105
loc_66126:
mov eax, [rbx]
add rsp, 28h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_66133:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aUnsupportedCac; "Unsupported cache type: "
lea rdi, [rsp+48h+var_40]
mov rdx, r14
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
mov bpl, 1
lea rsi, [rsp+48h+var_40]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+48h+var_30]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_6619A
mov rsi, [rsp+48h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_6619A:
test bpl, bpl
jnz short loc_661A4
jmp short loc_661AC
mov r14, rax
loc_661A4:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_661AC:
mov rdi, r14
call __Unwind_Resume
| long long kv_cache_type_from_str(long long a1)
{
unsigned int *v1; // rbx
long long v2; // r15
long long v3; // rax
void *exception; // rbx
_BYTE v6[16]; // [rsp+8h] [rbp-40h] BYREF
v1 = (unsigned int *)kv_cache_types;
v2 = qword_167FE0;
while ( 1 )
{
if ( v1 == (unsigned int *)v2 )
{
exception = __cxa_allocate_exception(0x10uLL);
std::operator+<char>(v6, "Unsupported cache type: ", a1);
std::runtime_error::runtime_error(exception, v6);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v3 = ggml_type_name(*v1);
if ( !(unsigned int)std::string::compare(a1, v3) )
break;
++v1;
}
return *v1;
}
| kv_cache_type_from_str:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV R14,RDI
MOV RBX,qword ptr [0x00267fd8]
MOV R15,qword ptr [0x00267fe0]
LAB_00166105:
CMP RBX,R15
JZ 0x00166133
MOV EDI,dword ptr [RBX]
CALL 0x00122460
MOV RDI,R14
MOV RSI,RAX
CALL 0x00122090
TEST EAX,EAX
JZ 0x00166126
ADD RBX,0x4
JMP 0x00166105
LAB_00166126:
MOV EAX,dword ptr [RBX]
ADD RSP,0x28
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00166133:
MOV EDI,0x10
CALL 0x001216a0
MOV RBX,RAX
LAB_00166140:
LEA RSI,[0x22025b]
LEA RDI,[RSP + 0x8]
MOV RDX,R14
CALL 0x0016a481
MOV BPL,0x1
LAB_00166157:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x00121490
XOR EBP,EBP
MOV RSI,qword ptr [0x00266fb8]
MOV RDX,qword ptr [0x00266f70]
MOV RDI,RBX
CALL 0x00121ae0
|
/* kv_cache_type_from_str(std::__cxx11::string const&) */
int4 kv_cache_type_from_str(string *param_1)
{
int4 *puVar1;
int iVar2;
runtime_error *this;
int4 *puVar3;
string local_40 [32];
puVar1 = DAT_00267fe0;
puVar3 = kv_cache_types;
while( true ) {
if (puVar3 == puVar1) {
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00166140 to 00166153 has its CatchHandler @ 001661a1 */
std::operator+((char *)local_40,(string *)"Unsupported cache type: ");
/* try { // try from 00166157 to 0016617b has its CatchHandler @ 0016617c */
std::runtime_error::runtime_error(this,local_40);
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_00266fb8,PTR__runtime_error_00266f70);
}
ggml_type_name(*puVar3);
iVar2 = std::__cxx11::string::compare((char *)param_1);
if (iVar2 == 0) break;
puVar3 = puVar3 + 1;
}
return *puVar3;
}
| |
43,554 | ggml_backend_cpu_get_proc_address(ggml_backend_reg*, char const*) | ngxson[P]ggml-easy/ggml/src/ggml-cpu/ggml-cpu.cpp | static void * ggml_backend_cpu_get_proc_address(ggml_backend_reg_t reg, const char * name) {
if (strcmp(name, "ggml_backend_set_n_threads") == 0) {
ggml_backend_set_n_threads_t fct = ggml_backend_cpu_set_n_threads;
return (void *)fct;
}
if (strcmp(name, "ggml_backend_dev_get_extra_bufts") == 0) {
ggml_backend_dev_get_extra_bufts_t fct = ggml_backend_cpu_device_get_extra_buffers_type;
return (void *)fct;
}
if (strcmp(name, "ggml_backend_get_features") == 0) {
return (void *)ggml_backend_cpu_get_features;
}
if (strcmp(name, "ggml_backend_set_abort_callback") == 0) {
return (void *)ggml_backend_cpu_set_abort_callback;
}
if (strcmp(name, "ggml_backend_cpu_numa_init") == 0) {
return (void *)ggml_numa_init;
}
if (strcmp(name, "ggml_backend_cpu_is_numa") == 0) {
return (void *)ggml_is_numa;
}
// threadpool - TODO: move to ggml-base
if (strcmp(name, "ggml_threadpool_new") == 0) {
return (void *)ggml_threadpool_new;
}
if (strcmp(name, "ggml_threadpool_free") == 0) {
return (void *)ggml_threadpool_free;
}
if (strcmp(name, "ggml_backend_cpu_set_threadpool") == 0) {
return (void *)ggml_backend_cpu_set_threadpool;
}
return NULL;
GGML_UNUSED(reg);
} | O1 | cpp | ggml_backend_cpu_get_proc_address(ggml_backend_reg*, char const*):
pushq %rbx
movq %rsi, %rbx
leaq 0x391f7(%rip), %rsi # 0x49b43
movq %rbx, %rdi
callq 0xac10
testl %eax, %eax
je 0x10a09
leaq 0x391fb(%rip), %rsi # 0x49b5e
movq %rbx, %rdi
callq 0xac10
testl %eax, %eax
je 0x10a12
leaq 0x39205(%rip), %rsi # 0x49b7f
movq %rbx, %rdi
callq 0xac10
testl %eax, %eax
je 0x10a1b
leaq 0x39208(%rip), %rsi # 0x49b99
movq %rbx, %rdi
callq 0xac10
testl %eax, %eax
je 0x10a24
leaq 0x39211(%rip), %rsi # 0x49bb9
movq %rbx, %rdi
callq 0xac10
testl %eax, %eax
je 0x10a2d
leaq 0x39219(%rip), %rsi # 0x49bd4
movq %rbx, %rdi
callq 0xac10
testl %eax, %eax
je 0x10a36
leaq 0x3921f(%rip), %rsi # 0x49bed
movq %rbx, %rdi
callq 0xac10
testl %eax, %eax
je 0x10a3f
leaq 0x39220(%rip), %rsi # 0x49c01
movq %rbx, %rdi
callq 0xac10
testl %eax, %eax
je 0x10a48
leaq 0x39222(%rip), %rsi # 0x49c16
movq %rbx, %rdi
callq 0xac10
testl %eax, %eax
jne 0x10a51
movq 0x4b561(%rip), %rax # 0x5bf68
jmp 0x10a53
movq 0x4b5d0(%rip), %rax # 0x5bfe0
jmp 0x10a53
leaq 0x43f(%rip), %rax # 0x10e58
jmp 0x10a53
leaq 0x445(%rip), %rax # 0x10e67
jmp 0x10a53
movq 0x4b56d(%rip), %rax # 0x5bf98
jmp 0x10a53
movq 0x4b554(%rip), %rax # 0x5bf88
jmp 0x10a53
movq 0x4b543(%rip), %rax # 0x5bf80
jmp 0x10a53
movq 0x4b56a(%rip), %rax # 0x5bfb0
jmp 0x10a53
movq 0x4b541(%rip), %rax # 0x5bf90
jmp 0x10a53
xorl %eax, %eax
popq %rbx
retq
| _ZL33ggml_backend_cpu_get_proc_addressP16ggml_backend_regPKc:
push rbx
mov rbx, rsi
lea rsi, aGgmlBackendSet; "ggml_backend_set_n_threads"
mov rdi, rbx
call _strcmp
test eax, eax
jz loc_10A09
lea rsi, aGgmlBackendDev; "ggml_backend_dev_get_extra_bufts"
mov rdi, rbx
call _strcmp
test eax, eax
jz loc_10A12
lea rsi, aGgmlBackendGet; "ggml_backend_get_features"
mov rdi, rbx
call _strcmp
test eax, eax
jz loc_10A1B
lea rsi, aGgmlBackendSet_0; "ggml_backend_set_abort_callback"
mov rdi, rbx
call _strcmp
test eax, eax
jz loc_10A24
lea rsi, aGgmlBackendCpu_6; "ggml_backend_cpu_numa_init"
mov rdi, rbx
call _strcmp
test eax, eax
jz short loc_10A2D
lea rsi, aGgmlBackendCpu_7; "ggml_backend_cpu_is_numa"
mov rdi, rbx
call _strcmp
test eax, eax
jz short loc_10A36
lea rsi, aGgmlThreadpool_4; "ggml_threadpool_new"
mov rdi, rbx
call _strcmp
test eax, eax
jz short loc_10A3F
lea rsi, aGgmlThreadpool_5; "ggml_threadpool_free"
mov rdi, rbx
call _strcmp
test eax, eax
jz short loc_10A48
lea rsi, aGgmlBackendCpu_8; "ggml_backend_cpu_set_threadpool"
mov rdi, rbx
call _strcmp
test eax, eax
jnz short loc_10A51
mov rax, cs:ggml_backend_cpu_set_threadpool_ptr
jmp short loc_10A53
loc_10A09:
mov rax, cs:ggml_backend_cpu_set_n_threads_ptr
jmp short loc_10A53
loc_10A12:
lea rax, _ZL46ggml_backend_cpu_device_get_extra_buffers_typeP19ggml_backend_device; ggml_backend_cpu_device_get_extra_buffers_type(ggml_backend_device *)
jmp short loc_10A53
loc_10A1B:
lea rax, _ZL29ggml_backend_cpu_get_featuresP16ggml_backend_reg; ggml_backend_cpu_get_features(ggml_backend_reg *)
jmp short loc_10A53
loc_10A24:
mov rax, cs:ggml_backend_cpu_set_abort_callback_ptr
jmp short loc_10A53
loc_10A2D:
mov rax, cs:ggml_numa_init_ptr
jmp short loc_10A53
loc_10A36:
mov rax, cs:ggml_is_numa_ptr
jmp short loc_10A53
loc_10A3F:
mov rax, cs:ggml_threadpool_new_ptr
jmp short loc_10A53
loc_10A48:
mov rax, cs:ggml_threadpool_free_ptr
jmp short loc_10A53
loc_10A51:
xor eax, eax
loc_10A53:
pop rbx
retn
| long long ( * ggml_backend_cpu_get_proc_address(long long a1, long long a2))(long long a1)
{
if ( !(unsigned int)strcmp(a2, "ggml_backend_set_n_threads") )
return (long long ( *)(long long))ggml_backend_cpu_set_n_threads;
if ( !(unsigned int)strcmp(a2, "ggml_backend_dev_get_extra_bufts") )
return (long long ( *)(long long))ggml_backend_cpu_device_get_extra_buffers_type;
if ( !(unsigned int)strcmp(a2, "ggml_backend_get_features") )
return (long long ( *)(long long))ggml_backend_cpu_get_features;
if ( !(unsigned int)strcmp(a2, "ggml_backend_set_abort_callback") )
return (long long ( *)(long long))ggml_backend_cpu_set_abort_callback;
if ( !(unsigned int)strcmp(a2, "ggml_backend_cpu_numa_init") )
return (long long ( *)(long long))ggml_numa_init;
if ( !(unsigned int)strcmp(a2, "ggml_backend_cpu_is_numa") )
return (long long ( *)(long long))ggml_is_numa;
if ( !(unsigned int)strcmp(a2, "ggml_threadpool_new") )
return ggml_threadpool_new;
if ( !(unsigned int)strcmp(a2, "ggml_threadpool_free") )
return ggml_threadpool_free;
if ( !(unsigned int)strcmp(a2, "ggml_backend_cpu_set_threadpool") )
return (long long ( *)(long long))ggml_backend_cpu_set_threadpool;
return 0LL;
}
| ggml_backend_cpu_get_proc_address:
PUSH RBX
MOV RBX,RSI
LEA RSI,[0x149b43]
MOV RDI,RBX
CALL 0x0010ac10
TEST EAX,EAX
JZ 0x00110a09
LEA RSI,[0x149b5e]
MOV RDI,RBX
CALL 0x0010ac10
TEST EAX,EAX
JZ 0x00110a12
LEA RSI,[0x149b7f]
MOV RDI,RBX
CALL 0x0010ac10
TEST EAX,EAX
JZ 0x00110a1b
LEA RSI,[0x149b99]
MOV RDI,RBX
CALL 0x0010ac10
TEST EAX,EAX
JZ 0x00110a24
LEA RSI,[0x149bb9]
MOV RDI,RBX
CALL 0x0010ac10
TEST EAX,EAX
JZ 0x00110a2d
LEA RSI,[0x149bd4]
MOV RDI,RBX
CALL 0x0010ac10
TEST EAX,EAX
JZ 0x00110a36
LEA RSI,[0x149bed]
MOV RDI,RBX
CALL 0x0010ac10
TEST EAX,EAX
JZ 0x00110a3f
LEA RSI,[0x149c01]
MOV RDI,RBX
CALL 0x0010ac10
TEST EAX,EAX
JZ 0x00110a48
LEA RSI,[0x149c16]
MOV RDI,RBX
CALL 0x0010ac10
TEST EAX,EAX
JNZ 0x00110a51
MOV RAX,qword ptr [0x0015bf68]
JMP 0x00110a53
LAB_00110a09:
MOV RAX,qword ptr [0x0015bfe0]
JMP 0x00110a53
LAB_00110a12:
LEA RAX,[0x110e58]
JMP 0x00110a53
LAB_00110a1b:
LEA RAX,[0x110e67]
JMP 0x00110a53
LAB_00110a24:
MOV RAX,qword ptr [0x0015bf98]
JMP 0x00110a53
LAB_00110a2d:
MOV RAX,qword ptr [0x0015bf88]
JMP 0x00110a53
LAB_00110a36:
MOV RAX,qword ptr [0x0015bf80]
JMP 0x00110a53
LAB_00110a3f:
MOV RAX,qword ptr [0x0015bfb0]
JMP 0x00110a53
LAB_00110a48:
MOV RAX,qword ptr [0x0015bf90]
JMP 0x00110a53
LAB_00110a51:
XOR EAX,EAX
LAB_00110a53:
POP RBX
RET
|
/* ggml_backend_cpu_get_proc_address(ggml_backend_reg*, char const*) */
code * ggml_backend_cpu_get_proc_address(ggml_backend_reg *param_1,char *param_2)
{
int iVar1;
code *pcVar2;
iVar1 = strcmp(param_2,"ggml_backend_set_n_threads");
pcVar2 = (code *)PTR_ggml_backend_cpu_set_n_threads_0015bfe0;
if (iVar1 != 0) {
iVar1 = strcmp(param_2,"ggml_backend_dev_get_extra_bufts");
if (iVar1 == 0) {
pcVar2 = ggml_backend_cpu_device_get_extra_buffers_type;
}
else {
iVar1 = strcmp(param_2,"ggml_backend_get_features");
if (iVar1 == 0) {
pcVar2 = ggml_backend_cpu_get_features;
}
else {
iVar1 = strcmp(param_2,"ggml_backend_set_abort_callback");
pcVar2 = (code *)PTR_ggml_backend_cpu_set_abort_callback_0015bf98;
if ((((iVar1 != 0) &&
(iVar1 = strcmp(param_2,"ggml_backend_cpu_numa_init"),
pcVar2 = (code *)PTR_ggml_numa_init_0015bf88, iVar1 != 0)) &&
(iVar1 = strcmp(param_2,"ggml_backend_cpu_is_numa"),
pcVar2 = (code *)PTR_ggml_is_numa_0015bf80, iVar1 != 0)) &&
(((iVar1 = strcmp(param_2,"ggml_threadpool_new"),
pcVar2 = (code *)PTR_ggml_threadpool_new_0015bfb0, iVar1 != 0 &&
(iVar1 = strcmp(param_2,"ggml_threadpool_free"),
pcVar2 = (code *)PTR_ggml_threadpool_free_0015bf90, iVar1 != 0)) &&
(iVar1 = strcmp(param_2,"ggml_backend_cpu_set_threadpool"),
pcVar2 = (code *)PTR_ggml_backend_cpu_set_threadpool_0015bf68, iVar1 != 0)))) {
pcVar2 = (code *)0x0;
}
}
}
}
return pcVar2;
}
| |
43,555 | ggml_backend_cpu_get_proc_address(ggml_backend_reg*, char const*) | ngxson[P]ggml-easy/ggml/src/ggml-cpu/ggml-cpu.cpp | static void * ggml_backend_cpu_get_proc_address(ggml_backend_reg_t reg, const char * name) {
if (strcmp(name, "ggml_backend_set_n_threads") == 0) {
ggml_backend_set_n_threads_t fct = ggml_backend_cpu_set_n_threads;
return (void *)fct;
}
if (strcmp(name, "ggml_backend_dev_get_extra_bufts") == 0) {
ggml_backend_dev_get_extra_bufts_t fct = ggml_backend_cpu_device_get_extra_buffers_type;
return (void *)fct;
}
if (strcmp(name, "ggml_backend_get_features") == 0) {
return (void *)ggml_backend_cpu_get_features;
}
if (strcmp(name, "ggml_backend_set_abort_callback") == 0) {
return (void *)ggml_backend_cpu_set_abort_callback;
}
if (strcmp(name, "ggml_backend_cpu_numa_init") == 0) {
return (void *)ggml_numa_init;
}
if (strcmp(name, "ggml_backend_cpu_is_numa") == 0) {
return (void *)ggml_is_numa;
}
// threadpool - TODO: move to ggml-base
if (strcmp(name, "ggml_threadpool_new") == 0) {
return (void *)ggml_threadpool_new;
}
if (strcmp(name, "ggml_threadpool_free") == 0) {
return (void *)ggml_threadpool_free;
}
if (strcmp(name, "ggml_backend_cpu_set_threadpool") == 0) {
return (void *)ggml_backend_cpu_set_threadpool;
}
return NULL;
GGML_UNUSED(reg);
} | O2 | cpp | ggml_backend_cpu_get_proc_address(ggml_backend_reg*, char const*):
pushq %rbx
movq %rsi, %rbx
leaq 0x33ea9(%rip), %rsi # 0x44a8b
movq %rbx, %rdi
callq 0xbd00
testl %eax, %eax
je 0x10c9f
leaq 0x33ead(%rip), %rsi # 0x44aa6
movq %rbx, %rdi
callq 0xbd00
testl %eax, %eax
je 0x10ca8
leaq 0x33eb7(%rip), %rsi # 0x44ac7
movq %rbx, %rdi
callq 0xbd00
testl %eax, %eax
je 0x10cb1
leaq 0x33eba(%rip), %rsi # 0x44ae1
movq %rbx, %rdi
callq 0xbd00
testl %eax, %eax
je 0x10cba
leaq 0x33ec3(%rip), %rsi # 0x44b01
movq %rbx, %rdi
callq 0xbd00
testl %eax, %eax
je 0x10cc3
leaq 0x33ecb(%rip), %rsi # 0x44b1c
movq %rbx, %rdi
callq 0xbd00
testl %eax, %eax
je 0x10ccc
leaq 0x33ed1(%rip), %rsi # 0x44b35
movq %rbx, %rdi
callq 0xbd00
testl %eax, %eax
je 0x10cd5
leaq 0x33ed2(%rip), %rsi # 0x44b49
movq %rbx, %rdi
callq 0xbd00
testl %eax, %eax
je 0x10cde
leaq 0x33ed4(%rip), %rsi # 0x44b5e
movq %rbx, %rdi
callq 0xbd00
testl %eax, %eax
jne 0x10ce7
movq 0x462cb(%rip), %rax # 0x56f68
jmp 0x10ce9
movq 0x4633a(%rip), %rax # 0x56fe0
jmp 0x10ce9
leaq 0x3f9(%rip), %rax # 0x110a8
jmp 0x10ce9
leaq 0x3ff(%rip), %rax # 0x110b7
jmp 0x10ce9
movq 0x462d7(%rip), %rax # 0x56f98
jmp 0x10ce9
movq 0x462be(%rip), %rax # 0x56f88
jmp 0x10ce9
movq 0x462ad(%rip), %rax # 0x56f80
jmp 0x10ce9
movq 0x462d4(%rip), %rax # 0x56fb0
jmp 0x10ce9
movq 0x462ab(%rip), %rax # 0x56f90
jmp 0x10ce9
xorl %eax, %eax
popq %rbx
retq
| _ZL33ggml_backend_cpu_get_proc_addressP16ggml_backend_regPKc:
push rbx
mov rbx, rsi
lea rsi, aGgmlBackendSet; "ggml_backend_set_n_threads"
mov rdi, rbx
call _strcmp
test eax, eax
jz loc_10C9F
lea rsi, aGgmlBackendDev; "ggml_backend_dev_get_extra_bufts"
mov rdi, rbx
call _strcmp
test eax, eax
jz loc_10CA8
lea rsi, aGgmlBackendGet; "ggml_backend_get_features"
mov rdi, rbx
call _strcmp
test eax, eax
jz loc_10CB1
lea rsi, aGgmlBackendSet_0; "ggml_backend_set_abort_callback"
mov rdi, rbx
call _strcmp
test eax, eax
jz loc_10CBA
lea rsi, aGgmlBackendCpu_6; "ggml_backend_cpu_numa_init"
mov rdi, rbx
call _strcmp
test eax, eax
jz short loc_10CC3
lea rsi, aGgmlBackendCpu_7; "ggml_backend_cpu_is_numa"
mov rdi, rbx
call _strcmp
test eax, eax
jz short loc_10CCC
lea rsi, aGgmlThreadpool_4; "ggml_threadpool_new"
mov rdi, rbx
call _strcmp
test eax, eax
jz short loc_10CD5
lea rsi, aGgmlThreadpool_5; "ggml_threadpool_free"
mov rdi, rbx
call _strcmp
test eax, eax
jz short loc_10CDE
lea rsi, aGgmlBackendCpu_8; "ggml_backend_cpu_set_threadpool"
mov rdi, rbx
call _strcmp
test eax, eax
jnz short loc_10CE7
mov rax, cs:ggml_backend_cpu_set_threadpool_ptr
jmp short loc_10CE9
loc_10C9F:
mov rax, cs:ggml_backend_cpu_set_n_threads_ptr
jmp short loc_10CE9
loc_10CA8:
lea rax, _ZL46ggml_backend_cpu_device_get_extra_buffers_typeP19ggml_backend_device; ggml_backend_cpu_device_get_extra_buffers_type(ggml_backend_device *)
jmp short loc_10CE9
loc_10CB1:
lea rax, _ZL29ggml_backend_cpu_get_featuresP16ggml_backend_reg; ggml_backend_cpu_get_features(ggml_backend_reg *)
jmp short loc_10CE9
loc_10CBA:
mov rax, cs:ggml_backend_cpu_set_abort_callback_ptr
jmp short loc_10CE9
loc_10CC3:
mov rax, cs:ggml_numa_init_ptr
jmp short loc_10CE9
loc_10CCC:
mov rax, cs:ggml_is_numa_ptr
jmp short loc_10CE9
loc_10CD5:
mov rax, cs:ggml_threadpool_new_ptr
jmp short loc_10CE9
loc_10CDE:
mov rax, cs:ggml_threadpool_free_ptr
jmp short loc_10CE9
loc_10CE7:
xor eax, eax
loc_10CE9:
pop rbx
retn
| bool (* ggml_backend_cpu_get_proc_address(long long a1, long long a2))()
{
if ( !(unsigned int)strcmp(a2, "ggml_backend_set_n_threads") )
return (bool (*)())ggml_backend_cpu_set_n_threads;
if ( !(unsigned int)strcmp(a2, "ggml_backend_dev_get_extra_bufts") )
return (bool (*)())ggml_backend_cpu_device_get_extra_buffers_type;
if ( !(unsigned int)strcmp(a2, "ggml_backend_get_features") )
return (bool (*)())ggml_backend_cpu_get_features;
if ( !(unsigned int)strcmp(a2, "ggml_backend_set_abort_callback") )
return (bool (*)())ggml_backend_cpu_set_abort_callback;
if ( !(unsigned int)strcmp(a2, "ggml_backend_cpu_numa_init") )
return (bool (*)())ggml_numa_init;
if ( !(unsigned int)strcmp(a2, "ggml_backend_cpu_is_numa") )
return ggml_is_numa;
if ( !(unsigned int)strcmp(a2, "ggml_threadpool_new") )
return (bool (*)())ggml_threadpool_new;
if ( !(unsigned int)strcmp(a2, "ggml_threadpool_free") )
return (bool (*)())ggml_threadpool_free;
if ( !(unsigned int)strcmp(a2, "ggml_backend_cpu_set_threadpool") )
return (bool (*)())ggml_backend_cpu_set_threadpool;
return 0LL;
}
| ggml_backend_cpu_get_proc_address:
PUSH RBX
MOV RBX,RSI
LEA RSI,[0x144a8b]
MOV RDI,RBX
CALL 0x0010bd00
TEST EAX,EAX
JZ 0x00110c9f
LEA RSI,[0x144aa6]
MOV RDI,RBX
CALL 0x0010bd00
TEST EAX,EAX
JZ 0x00110ca8
LEA RSI,[0x144ac7]
MOV RDI,RBX
CALL 0x0010bd00
TEST EAX,EAX
JZ 0x00110cb1
LEA RSI,[0x144ae1]
MOV RDI,RBX
CALL 0x0010bd00
TEST EAX,EAX
JZ 0x00110cba
LEA RSI,[0x144b01]
MOV RDI,RBX
CALL 0x0010bd00
TEST EAX,EAX
JZ 0x00110cc3
LEA RSI,[0x144b1c]
MOV RDI,RBX
CALL 0x0010bd00
TEST EAX,EAX
JZ 0x00110ccc
LEA RSI,[0x144b35]
MOV RDI,RBX
CALL 0x0010bd00
TEST EAX,EAX
JZ 0x00110cd5
LEA RSI,[0x144b49]
MOV RDI,RBX
CALL 0x0010bd00
TEST EAX,EAX
JZ 0x00110cde
LEA RSI,[0x144b5e]
MOV RDI,RBX
CALL 0x0010bd00
TEST EAX,EAX
JNZ 0x00110ce7
MOV RAX,qword ptr [0x00156f68]
JMP 0x00110ce9
LAB_00110c9f:
MOV RAX,qword ptr [0x00156fe0]
JMP 0x00110ce9
LAB_00110ca8:
LEA RAX,[0x1110a8]
JMP 0x00110ce9
LAB_00110cb1:
LEA RAX,[0x1110b7]
JMP 0x00110ce9
LAB_00110cba:
MOV RAX,qword ptr [0x00156f98]
JMP 0x00110ce9
LAB_00110cc3:
MOV RAX,qword ptr [0x00156f88]
JMP 0x00110ce9
LAB_00110ccc:
MOV RAX,qword ptr [0x00156f80]
JMP 0x00110ce9
LAB_00110cd5:
MOV RAX,qword ptr [0x00156fb0]
JMP 0x00110ce9
LAB_00110cde:
MOV RAX,qword ptr [0x00156f90]
JMP 0x00110ce9
LAB_00110ce7:
XOR EAX,EAX
LAB_00110ce9:
POP RBX
RET
|
/* ggml_backend_cpu_get_proc_address(ggml_backend_reg*, char const*) */
code * ggml_backend_cpu_get_proc_address(ggml_backend_reg *param_1,char *param_2)
{
int iVar1;
code *pcVar2;
iVar1 = strcmp(param_2,"ggml_backend_set_n_threads");
pcVar2 = (code *)PTR_ggml_backend_cpu_set_n_threads_00156fe0;
if (iVar1 != 0) {
iVar1 = strcmp(param_2,"ggml_backend_dev_get_extra_bufts");
if (iVar1 == 0) {
pcVar2 = ggml_backend_cpu_device_get_extra_buffers_type;
}
else {
iVar1 = strcmp(param_2,"ggml_backend_get_features");
if (iVar1 == 0) {
pcVar2 = ggml_backend_cpu_get_features;
}
else {
iVar1 = strcmp(param_2,"ggml_backend_set_abort_callback");
pcVar2 = (code *)PTR_ggml_backend_cpu_set_abort_callback_00156f98;
if ((((iVar1 != 0) &&
(iVar1 = strcmp(param_2,"ggml_backend_cpu_numa_init"),
pcVar2 = (code *)PTR_ggml_numa_init_00156f88, iVar1 != 0)) &&
(iVar1 = strcmp(param_2,"ggml_backend_cpu_is_numa"),
pcVar2 = (code *)PTR_ggml_is_numa_00156f80, iVar1 != 0)) &&
(((iVar1 = strcmp(param_2,"ggml_threadpool_new"),
pcVar2 = (code *)PTR_ggml_threadpool_new_00156fb0, iVar1 != 0 &&
(iVar1 = strcmp(param_2,"ggml_threadpool_free"),
pcVar2 = (code *)PTR_ggml_threadpool_free_00156f90, iVar1 != 0)) &&
(iVar1 = strcmp(param_2,"ggml_backend_cpu_set_threadpool"),
pcVar2 = (code *)PTR_ggml_backend_cpu_set_threadpool_00156f68, iVar1 != 0)))) {
pcVar2 = (code *)0x0;
}
}
}
}
return pcVar2;
}
| |
43,556 | ggml_backend_cpu_get_proc_address(ggml_backend_reg*, char const*) | ngxson[P]ggml-easy/ggml/src/ggml-cpu/ggml-cpu.cpp | static void * ggml_backend_cpu_get_proc_address(ggml_backend_reg_t reg, const char * name) {
if (strcmp(name, "ggml_backend_set_n_threads") == 0) {
ggml_backend_set_n_threads_t fct = ggml_backend_cpu_set_n_threads;
return (void *)fct;
}
if (strcmp(name, "ggml_backend_dev_get_extra_bufts") == 0) {
ggml_backend_dev_get_extra_bufts_t fct = ggml_backend_cpu_device_get_extra_buffers_type;
return (void *)fct;
}
if (strcmp(name, "ggml_backend_get_features") == 0) {
return (void *)ggml_backend_cpu_get_features;
}
if (strcmp(name, "ggml_backend_set_abort_callback") == 0) {
return (void *)ggml_backend_cpu_set_abort_callback;
}
if (strcmp(name, "ggml_backend_cpu_numa_init") == 0) {
return (void *)ggml_numa_init;
}
if (strcmp(name, "ggml_backend_cpu_is_numa") == 0) {
return (void *)ggml_is_numa;
}
// threadpool - TODO: move to ggml-base
if (strcmp(name, "ggml_threadpool_new") == 0) {
return (void *)ggml_threadpool_new;
}
if (strcmp(name, "ggml_threadpool_free") == 0) {
return (void *)ggml_threadpool_free;
}
if (strcmp(name, "ggml_backend_cpu_set_threadpool") == 0) {
return (void *)ggml_backend_cpu_set_threadpool;
}
return NULL;
GGML_UNUSED(reg);
} | O3 | cpp | ggml_backend_cpu_get_proc_address(ggml_backend_reg*, char const*):
pushq %rbx
movq %rsi, %rbx
leaq 0x38253(%rip), %rsi # 0x48b43
movq %rbx, %rdi
callq 0xac10
testl %eax, %eax
je 0x109ad
leaq 0x38257(%rip), %rsi # 0x48b5e
movq %rbx, %rdi
callq 0xac10
testl %eax, %eax
je 0x109b6
leaq 0x38261(%rip), %rsi # 0x48b7f
movq %rbx, %rdi
callq 0xac10
testl %eax, %eax
je 0x109bf
leaq 0x38264(%rip), %rsi # 0x48b99
movq %rbx, %rdi
callq 0xac10
testl %eax, %eax
je 0x109c8
leaq 0x3826d(%rip), %rsi # 0x48bb9
movq %rbx, %rdi
callq 0xac10
testl %eax, %eax
je 0x109d1
leaq 0x38275(%rip), %rsi # 0x48bd4
movq %rbx, %rdi
callq 0xac10
testl %eax, %eax
je 0x109da
leaq 0x3827b(%rip), %rsi # 0x48bed
movq %rbx, %rdi
callq 0xac10
testl %eax, %eax
je 0x109e3
leaq 0x3827c(%rip), %rsi # 0x48c01
movq %rbx, %rdi
callq 0xac10
testl %eax, %eax
je 0x109ec
leaq 0x3827e(%rip), %rsi # 0x48c16
movq %rbx, %rdi
callq 0xac10
testl %eax, %eax
jne 0x109f5
movq 0x4a5bd(%rip), %rax # 0x5af68
jmp 0x109f7
movq 0x4a62c(%rip), %rax # 0x5afe0
jmp 0x109f7
leaq 0x410(%rip), %rax # 0x10dcd
jmp 0x109f7
leaq 0x416(%rip), %rax # 0x10ddc
jmp 0x109f7
movq 0x4a5c9(%rip), %rax # 0x5af98
jmp 0x109f7
movq 0x4a5b0(%rip), %rax # 0x5af88
jmp 0x109f7
movq 0x4a59f(%rip), %rax # 0x5af80
jmp 0x109f7
movq 0x4a5c6(%rip), %rax # 0x5afb0
jmp 0x109f7
movq 0x4a59d(%rip), %rax # 0x5af90
jmp 0x109f7
xorl %eax, %eax
popq %rbx
retq
| _ZL33ggml_backend_cpu_get_proc_addressP16ggml_backend_regPKc:
push rbx
mov rbx, rsi
lea rsi, aGgmlBackendSet; "ggml_backend_set_n_threads"
mov rdi, rbx
call _strcmp
test eax, eax
jz loc_109AD
lea rsi, aGgmlBackendDev; "ggml_backend_dev_get_extra_bufts"
mov rdi, rbx
call _strcmp
test eax, eax
jz loc_109B6
lea rsi, aGgmlBackendGet; "ggml_backend_get_features"
mov rdi, rbx
call _strcmp
test eax, eax
jz loc_109BF
lea rsi, aGgmlBackendSet_0; "ggml_backend_set_abort_callback"
mov rdi, rbx
call _strcmp
test eax, eax
jz loc_109C8
lea rsi, aGgmlBackendCpu_6; "ggml_backend_cpu_numa_init"
mov rdi, rbx
call _strcmp
test eax, eax
jz short loc_109D1
lea rsi, aGgmlBackendCpu_7; "ggml_backend_cpu_is_numa"
mov rdi, rbx
call _strcmp
test eax, eax
jz short loc_109DA
lea rsi, aGgmlThreadpool_4; "ggml_threadpool_new"
mov rdi, rbx
call _strcmp
test eax, eax
jz short loc_109E3
lea rsi, aGgmlThreadpool_5; "ggml_threadpool_free"
mov rdi, rbx
call _strcmp
test eax, eax
jz short loc_109EC
lea rsi, aGgmlBackendCpu_8; "ggml_backend_cpu_set_threadpool"
mov rdi, rbx
call _strcmp
test eax, eax
jnz short loc_109F5
mov rax, cs:ggml_backend_cpu_set_threadpool_ptr
jmp short loc_109F7
loc_109AD:
mov rax, cs:ggml_backend_cpu_set_n_threads_ptr
jmp short loc_109F7
loc_109B6:
lea rax, _ZL46ggml_backend_cpu_device_get_extra_buffers_typeP19ggml_backend_device; ggml_backend_cpu_device_get_extra_buffers_type(ggml_backend_device *)
jmp short loc_109F7
loc_109BF:
lea rax, _ZL29ggml_backend_cpu_get_featuresP16ggml_backend_reg; ggml_backend_cpu_get_features(ggml_backend_reg *)
jmp short loc_109F7
loc_109C8:
mov rax, cs:ggml_backend_cpu_set_abort_callback_ptr
jmp short loc_109F7
loc_109D1:
mov rax, cs:ggml_numa_init_ptr
jmp short loc_109F7
loc_109DA:
mov rax, cs:ggml_is_numa_ptr
jmp short loc_109F7
loc_109E3:
mov rax, cs:ggml_threadpool_new_ptr
jmp short loc_109F7
loc_109EC:
mov rax, cs:ggml_threadpool_free_ptr
jmp short loc_109F7
loc_109F5:
xor eax, eax
loc_109F7:
pop rbx
retn
| long long ( * ggml_backend_cpu_get_proc_address(long long a1, long long a2))(long long a1)
{
if ( !(unsigned int)strcmp(a2, "ggml_backend_set_n_threads") )
return (long long ( *)(long long))ggml_backend_cpu_set_n_threads;
if ( !(unsigned int)strcmp(a2, "ggml_backend_dev_get_extra_bufts") )
return (long long ( *)(long long))ggml_backend_cpu_device_get_extra_buffers_type;
if ( !(unsigned int)strcmp(a2, "ggml_backend_get_features") )
return (long long ( *)(long long))ggml_backend_cpu_get_features;
if ( !(unsigned int)strcmp(a2, "ggml_backend_set_abort_callback") )
return (long long ( *)(long long))ggml_backend_cpu_set_abort_callback;
if ( !(unsigned int)strcmp(a2, "ggml_backend_cpu_numa_init") )
return (long long ( *)(long long))ggml_numa_init;
if ( !(unsigned int)strcmp(a2, "ggml_backend_cpu_is_numa") )
return (long long ( *)(long long))ggml_is_numa;
if ( !(unsigned int)strcmp(a2, "ggml_threadpool_new") )
return ggml_threadpool_new;
if ( !(unsigned int)strcmp(a2, "ggml_threadpool_free") )
return ggml_threadpool_free;
if ( !(unsigned int)strcmp(a2, "ggml_backend_cpu_set_threadpool") )
return (long long ( *)(long long))ggml_backend_cpu_set_threadpool;
return 0LL;
}
| ggml_backend_cpu_get_proc_address:
PUSH RBX
MOV RBX,RSI
LEA RSI,[0x148b43]
MOV RDI,RBX
CALL 0x0010ac10
TEST EAX,EAX
JZ 0x001109ad
LEA RSI,[0x148b5e]
MOV RDI,RBX
CALL 0x0010ac10
TEST EAX,EAX
JZ 0x001109b6
LEA RSI,[0x148b7f]
MOV RDI,RBX
CALL 0x0010ac10
TEST EAX,EAX
JZ 0x001109bf
LEA RSI,[0x148b99]
MOV RDI,RBX
CALL 0x0010ac10
TEST EAX,EAX
JZ 0x001109c8
LEA RSI,[0x148bb9]
MOV RDI,RBX
CALL 0x0010ac10
TEST EAX,EAX
JZ 0x001109d1
LEA RSI,[0x148bd4]
MOV RDI,RBX
CALL 0x0010ac10
TEST EAX,EAX
JZ 0x001109da
LEA RSI,[0x148bed]
MOV RDI,RBX
CALL 0x0010ac10
TEST EAX,EAX
JZ 0x001109e3
LEA RSI,[0x148c01]
MOV RDI,RBX
CALL 0x0010ac10
TEST EAX,EAX
JZ 0x001109ec
LEA RSI,[0x148c16]
MOV RDI,RBX
CALL 0x0010ac10
TEST EAX,EAX
JNZ 0x001109f5
MOV RAX,qword ptr [0x0015af68]
JMP 0x001109f7
LAB_001109ad:
MOV RAX,qword ptr [0x0015afe0]
JMP 0x001109f7
LAB_001109b6:
LEA RAX,[0x110dcd]
JMP 0x001109f7
LAB_001109bf:
LEA RAX,[0x110ddc]
JMP 0x001109f7
LAB_001109c8:
MOV RAX,qword ptr [0x0015af98]
JMP 0x001109f7
LAB_001109d1:
MOV RAX,qword ptr [0x0015af88]
JMP 0x001109f7
LAB_001109da:
MOV RAX,qword ptr [0x0015af80]
JMP 0x001109f7
LAB_001109e3:
MOV RAX,qword ptr [0x0015afb0]
JMP 0x001109f7
LAB_001109ec:
MOV RAX,qword ptr [0x0015af90]
JMP 0x001109f7
LAB_001109f5:
XOR EAX,EAX
LAB_001109f7:
POP RBX
RET
|
/* ggml_backend_cpu_get_proc_address(ggml_backend_reg*, char const*) */
code * ggml_backend_cpu_get_proc_address(ggml_backend_reg *param_1,char *param_2)
{
int iVar1;
code *pcVar2;
iVar1 = strcmp(param_2,"ggml_backend_set_n_threads");
pcVar2 = (code *)PTR_ggml_backend_cpu_set_n_threads_0015afe0;
if (iVar1 != 0) {
iVar1 = strcmp(param_2,"ggml_backend_dev_get_extra_bufts");
if (iVar1 == 0) {
pcVar2 = ggml_backend_cpu_device_get_extra_buffers_type;
}
else {
iVar1 = strcmp(param_2,"ggml_backend_get_features");
if (iVar1 == 0) {
pcVar2 = ggml_backend_cpu_get_features;
}
else {
iVar1 = strcmp(param_2,"ggml_backend_set_abort_callback");
pcVar2 = (code *)PTR_ggml_backend_cpu_set_abort_callback_0015af98;
if ((((iVar1 != 0) &&
(iVar1 = strcmp(param_2,"ggml_backend_cpu_numa_init"),
pcVar2 = (code *)PTR_ggml_numa_init_0015af88, iVar1 != 0)) &&
(iVar1 = strcmp(param_2,"ggml_backend_cpu_is_numa"),
pcVar2 = (code *)PTR_ggml_is_numa_0015af80, iVar1 != 0)) &&
(((iVar1 = strcmp(param_2,"ggml_threadpool_new"),
pcVar2 = (code *)PTR_ggml_threadpool_new_0015afb0, iVar1 != 0 &&
(iVar1 = strcmp(param_2,"ggml_threadpool_free"),
pcVar2 = (code *)PTR_ggml_threadpool_free_0015af90, iVar1 != 0)) &&
(iVar1 = strcmp(param_2,"ggml_backend_cpu_set_threadpool"),
pcVar2 = (code *)PTR_ggml_backend_cpu_set_threadpool_0015af68, iVar1 != 0)))) {
pcVar2 = (code *)0x0;
}
}
}
}
return pcVar2;
}
| |
43,557 | ma_unpin_all_pages | eloqsql/storage/maria/ma_key_recover.c | void _ma_unpin_all_pages(MARIA_HA *info, LSN undo_lsn)
{
MARIA_PINNED_PAGE *page_link= ((MARIA_PINNED_PAGE*)
dynamic_array_ptr(&info->pinned_pages, 0));
MARIA_PINNED_PAGE *pinned_page= page_link + info->pinned_pages.elements;
DBUG_ENTER("_ma_unpin_all_pages");
DBUG_PRINT("info", ("undo_lsn: %lu", (ulong) undo_lsn));
if (!info->s->now_transactional)
DBUG_ASSERT(undo_lsn == LSN_IMPOSSIBLE || maria_in_recovery);
while (pinned_page-- != page_link)
{
/*
Note this assert fails if we got a disk error or the record file
is corrupted, which means we should have this enabled only in debug
builds.
*/
#ifdef EXTRA_DEBUG
DBUG_ASSERT((!pinned_page->changed ||
undo_lsn != LSN_IMPOSSIBLE || !info->s->now_transactional) ||
(info->s->state.changed & STATE_CRASHED_FLAGS));
#endif
pagecache_unlock_by_link(info->s->pagecache, pinned_page->link,
pinned_page->unlock, PAGECACHE_UNPIN,
info->trn->rec_lsn, undo_lsn,
pinned_page->changed, FALSE);
}
info->pinned_pages.elements= 0;
DBUG_VOID_RETURN;
} | O3 | c | ma_unpin_all_pages:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x2f0(%rdi), %eax
testq %rax, %rax
je 0x411de
movq %rsi, %r14
movq 0x2e8(%rbx), %r15
shlq $0x3, %rax
leaq (%rax,%rax,2), %r12
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq 0x600(%rax), %rdi
movq -0x18(%r15,%r12), %rsi
movl -0x10(%r15,%r12), %edx
movq 0x90(%rcx), %r8
movsbl -0x8(%r15,%r12), %eax
movl $0x3, %ecx
movq %r14, %r9
pushq $0x0
pushq %rax
callq 0x3c261
addq $0x10, %rsp
addq $-0x18, %r12
jne 0x4119f
movl $0x0, 0x2f0(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| _ma_unpin_all_pages:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov rbx, rdi
mov eax, [rdi+2F0h]
test rax, rax
jz short loc_411DE
mov r14, rsi
mov r15, [rbx+2E8h]
shl rax, 3
lea r12, [rax+rax*2]
loc_4119F:
mov rax, [rbx]
mov rcx, [rbx+8]
mov rdi, [rax+600h]
mov rsi, [r15+r12-18h]
mov edx, [r15+r12-10h]
mov r8, [rcx+90h]
movsx eax, byte ptr [r15+r12-8]
mov ecx, 3
mov r9, r14
push 0
push rax
call pagecache_unlock_by_link
add rsp, 10h
add r12, 0FFFFFFFFFFFFFFE8h
jnz short loc_4119F
loc_411DE:
mov dword ptr [rbx+2F0h], 0
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long ma_unpin_all_pages(long long a1, signed long long a2)
{
long long result; // rax
long long v3; // r15
long long v4; // r12
result = *(unsigned int *)(a1 + 752);
if ( *(_DWORD *)(a1 + 752) )
{
v3 = *(_QWORD *)(a1 + 744);
v4 = 24 * result;
do
{
result = pagecache_unlock_by_link(
*(_QWORD *)(*(_QWORD *)a1 + 1536LL),
*(_QWORD *)(v3 + v4 - 24),
*(_DWORD *)(v3 + v4 - 16),
3,
*(_QWORD *)(*(_QWORD *)(a1 + 8) + 144LL),
a2,
*(_BYTE *)(v3 + v4 - 8));
v4 -= 24LL;
}
while ( v4 );
}
*(_DWORD *)(a1 + 752) = 0;
return result;
}
| _ma_unpin_all_pages:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RBX,RDI
MOV EAX,dword ptr [RDI + 0x2f0]
TEST RAX,RAX
JZ 0x001411de
MOV R14,RSI
MOV R15,qword ptr [RBX + 0x2e8]
SHL RAX,0x3
LEA R12,[RAX + RAX*0x2]
LAB_0014119f:
MOV RAX,qword ptr [RBX]
MOV RCX,qword ptr [RBX + 0x8]
MOV RDI,qword ptr [RAX + 0x600]
MOV RSI,qword ptr [R15 + R12*0x1 + -0x18]
MOV EDX,dword ptr [R15 + R12*0x1 + -0x10]
MOV R8,qword ptr [RCX + 0x90]
MOVSX EAX,byte ptr [R15 + R12*0x1 + -0x8]
MOV ECX,0x3
MOV R9,R14
PUSH 0x0
PUSH RAX
CALL 0x0013c261
ADD RSP,0x10
ADD R12,-0x18
JNZ 0x0014119f
LAB_001411de:
MOV dword ptr [RBX + 0x2f0],0x0
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
void _ma_unpin_all_pages(long *param_1,int8 param_2)
{
long lVar1;
long lVar2;
if ((ulong)*(uint *)(param_1 + 0x5e) != 0) {
lVar1 = param_1[0x5d];
lVar2 = (ulong)*(uint *)(param_1 + 0x5e) * 0x18;
do {
pagecache_unlock_by_link
(*(int8 *)(*param_1 + 0x600),*(int8 *)(lVar1 + -0x18 + lVar2),
*(int4 *)(lVar1 + -0x10 + lVar2),3,*(int8 *)(param_1[1] + 0x90),param_2
,(int)*(char *)(lVar1 + -8 + lVar2),0);
lVar2 = lVar2 + -0x18;
} while (lVar2 != 0);
}
*(int4 *)(param_1 + 0x5e) = 0;
return;
}
| |
43,558 | reset_root_defaults | eloqsql/mysys/my_alloc.c | void reset_root_defaults(MEM_ROOT *mem_root, size_t block_size,
size_t pre_alloc_size __attribute__((unused)))
{
DBUG_ENTER("reset_root_defaults");
DBUG_ASSERT(alloc_root_inited(mem_root));
mem_root->block_size= (((block_size - ALLOC_ROOT_MIN_BLOCK_SIZE) & ~1) |
(mem_root->block_size & 1));
#if !(defined(HAVE_valgrind) && defined(EXTRA_DEBUG))
if (pre_alloc_size)
{
size_t size= pre_alloc_size + ALIGN_SIZE(sizeof(USED_MEM));
if (!mem_root->pre_alloc || mem_root->pre_alloc->size != size)
{
USED_MEM *mem, **prev= &mem_root->free;
/*
Free unused blocks, so that consequent calls
to reset_root_defaults won't eat away memory.
*/
while (*prev)
{
mem= *prev;
if (mem->size == size)
{
/* We found a suitable block, no need to do anything else */
mem_root->pre_alloc= mem;
DBUG_VOID_RETURN;
}
if (mem->left + ALIGN_SIZE(sizeof(USED_MEM)) == mem->size)
{
/* remove block from the list and free it */
*prev= mem->next;
my_free(mem);
}
else
prev= &mem->next;
}
/* Allocate new prealloc block and add it to the end of free list */
if ((mem= (USED_MEM *) my_malloc(mem_root->m_psi_key, size,
MYF(MALLOC_FLAG(mem_root->
block_size)))))
{
mem->size= size;
mem->left= pre_alloc_size;
mem->next= *prev;
*prev= mem_root->pre_alloc= mem;
TRASH_MEM(mem);
}
else
{
mem_root->pre_alloc= 0;
}
}
}
else
#endif
mem_root->pre_alloc= 0;
DBUG_VOID_RETURN;
} | O0 | c | reset_root_defaults:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0xed1f6
movq -0x10(%rbp), %rcx
subq $0x28, %rcx
andq $-0x2, %rcx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
andq $0x1, %rax
orq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
cmpq $0x0, -0x18(%rbp)
je 0xed34f
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xed251
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
cmpq -0x20(%rbp), %rax
je 0xed34d
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
je 0xed2c6
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0xed28d
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0xed35f
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
addq $0x18, %rax
movq -0x28(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0xed2bc
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rdi
callq 0xf3d70
jmp 0xed2c4
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0xed259
movq -0x8(%rbp), %rax
movl 0x38(%rax), %edi
movq -0x20(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdx
andq $0x1, %rdx
xorl %eax, %eax
movl $0x10000, %ecx # imm = 0x10000
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movl %eax, %eax
movl %eax, %edx
callq 0xf39f0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xed33f
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movq (%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
jmp 0xed339
jmp 0xed33b
jmp 0xed33d
jmp 0xed34b
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
jmp 0xed34d
jmp 0xed35b
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
jmp 0xed35d
jmp 0xed35f
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| reset_root_defaults:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
jmp short $+2
loc_ED1F6:
mov rcx, [rbp+var_10]
sub rcx, 28h ; '('
and rcx, 0FFFFFFFFFFFFFFFEh
mov rax, [rbp+var_8]
mov rax, [rax+20h]
and rax, 1
or rcx, rax
mov rax, [rbp+var_8]
mov [rax+20h], rcx
cmp [rbp+var_18], 0
jz loc_ED34F
mov rax, [rbp+var_18]
add rax, 18h
mov [rbp+var_20], rax
mov rax, [rbp+var_8]
cmp qword ptr [rax+10h], 0
jz short loc_ED251
mov rax, [rbp+var_8]
mov rax, [rax+10h]
mov rax, [rax+10h]
cmp rax, [rbp+var_20]
jz loc_ED34D
loc_ED251:
mov rax, [rbp+var_8]
mov [rbp+var_30], rax
loc_ED259:
mov rax, [rbp+var_30]
cmp qword ptr [rax], 0
jz short loc_ED2C6
mov rax, [rbp+var_30]
mov rax, [rax]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
mov rax, [rax+10h]
cmp rax, [rbp+var_20]
jnz short loc_ED28D
mov rcx, [rbp+var_28]
mov rax, [rbp+var_8]
mov [rax+10h], rcx
jmp loc_ED35F
loc_ED28D:
mov rax, [rbp+var_28]
mov rax, [rax+8]
add rax, 18h
mov rcx, [rbp+var_28]
cmp rax, [rcx+10h]
jnz short loc_ED2BC
mov rax, [rbp+var_28]
mov rcx, [rax]
mov rax, [rbp+var_30]
mov [rax], rcx
mov rdi, [rbp+var_28]
call my_free
jmp short loc_ED2C4
loc_ED2BC:
mov rax, [rbp+var_28]
mov [rbp+var_30], rax
loc_ED2C4:
jmp short loc_ED259
loc_ED2C6:
mov rax, [rbp+var_8]
mov edi, [rax+38h]
mov rsi, [rbp+var_20]
mov rax, [rbp+var_8]
mov rdx, [rax+20h]
and rdx, 1
xor eax, eax
mov ecx, 10000h
cmp rdx, 0
cmovnz eax, ecx
mov eax, eax
mov edx, eax
call my_malloc
mov [rbp+var_28], rax
cmp rax, 0
jz short loc_ED33F
mov rcx, [rbp+var_20]
mov rax, [rbp+var_28]
mov [rax+10h], rcx
mov rcx, [rbp+var_18]
mov rax, [rbp+var_28]
mov [rax+8], rcx
mov rax, [rbp+var_30]
mov rcx, [rax]
mov rax, [rbp+var_28]
mov [rax], rcx
mov rcx, [rbp+var_28]
mov rax, [rbp+var_8]
mov [rax+10h], rcx
mov rax, [rbp+var_30]
mov [rax], rcx
jmp short $+2
loc_ED339:
jmp short $+2
loc_ED33B:
jmp short $+2
loc_ED33D:
jmp short loc_ED34B
loc_ED33F:
mov rax, [rbp+var_8]
mov qword ptr [rax+10h], 0
loc_ED34B:
jmp short $+2
loc_ED34D:
jmp short loc_ED35B
loc_ED34F:
mov rax, [rbp+var_8]
mov qword ptr [rax+10h], 0
loc_ED35B:
jmp short $+2
loc_ED35D:
jmp short $+2
loc_ED35F:
add rsp, 30h
pop rbp
retn
| long long * reset_root_defaults(long long *a1, long long a2, long long a3)
{
long long *result; // rax
long long v4; // rdi
unsigned int v5; // eax
long long *v6; // [rsp+0h] [rbp-30h]
long long *v7; // [rsp+8h] [rbp-28h]
_QWORD *v8; // [rsp+8h] [rbp-28h]
long long *v9; // [rsp+10h] [rbp-20h]
a1[4] = a1[4] & 1 | (a2 - 40) & 0xFFFFFFFFFFFFFFFELL;
if ( a3 )
{
v9 = (long long *)(a3 + 24);
if ( !a1[2] || (result = *(long long **)(a1[2] + 16), result != v9) )
{
v6 = a1;
while ( *v6 )
{
v7 = (long long *)*v6;
if ( *(long long **)(*v6 + 16) == v9 )
{
result = a1;
a1[2] = (long long)v7;
return result;
}
if ( v7[1] + 24 == v7[2] )
{
*v6 = *v7;
my_free(v7);
}
else
{
v6 = (long long *)*v6;
}
}
v4 = *((unsigned int *)a1 + 14);
v5 = 0;
if ( (a1[4] & 1) != 0 )
v5 = 0x10000;
v8 = (_QWORD *)my_malloc(v4, v9, v5);
if ( v8 )
{
v8[2] = v9;
v8[1] = a3;
*v8 = *v6;
a1[2] = (long long)v8;
result = v6;
*v6 = (long long)v8;
}
else
{
result = a1;
a1[2] = 0LL;
}
}
}
else
{
result = a1;
a1[2] = 0LL;
}
return result;
}
| reset_root_defaults:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
JMP 0x001ed1f6
LAB_001ed1f6:
MOV RCX,qword ptr [RBP + -0x10]
SUB RCX,0x28
AND RCX,-0x2
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x20]
AND RAX,0x1
OR RCX,RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x20],RCX
CMP qword ptr [RBP + -0x18],0x0
JZ 0x001ed34f
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x18
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x10],0x0
JZ 0x001ed251
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RAX + 0x10]
CMP RAX,qword ptr [RBP + -0x20]
JZ 0x001ed34d
LAB_001ed251:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x30],RAX
LAB_001ed259:
MOV RAX,qword ptr [RBP + -0x30]
CMP qword ptr [RAX],0x0
JZ 0x001ed2c6
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x10]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x001ed28d
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x10],RCX
JMP 0x001ed35f
LAB_001ed28d:
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
ADD RAX,0x18
MOV RCX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RCX + 0x10]
JNZ 0x001ed2bc
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RCX
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x001f3d70
JMP 0x001ed2c4
LAB_001ed2bc:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x30],RAX
LAB_001ed2c4:
JMP 0x001ed259
LAB_001ed2c6:
MOV RAX,qword ptr [RBP + -0x8]
MOV EDI,dword ptr [RAX + 0x38]
MOV RSI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RAX + 0x20]
AND RDX,0x1
XOR EAX,EAX
MOV ECX,0x10000
CMP RDX,0x0
CMOVNZ EAX,ECX
MOV EAX,EAX
MOV EDX,EAX
CALL 0x001f39f0
MOV qword ptr [RBP + -0x28],RAX
CMP RAX,0x0
JZ 0x001ed33f
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RCX
JMP 0x001ed339
LAB_001ed339:
JMP 0x001ed33b
LAB_001ed33b:
JMP 0x001ed33d
LAB_001ed33d:
JMP 0x001ed34b
LAB_001ed33f:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x10],0x0
LAB_001ed34b:
JMP 0x001ed34d
LAB_001ed34d:
JMP 0x001ed35b
LAB_001ed34f:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x10],0x0
LAB_001ed35b:
JMP 0x001ed35d
LAB_001ed35d:
JMP 0x001ed35f
LAB_001ed35f:
ADD RSP,0x30
POP RBP
RET
|
void reset_root_defaults(long *param_1,long param_2,long param_3)
{
int4 uVar1;
long lVar2;
long *plVar3;
long *local_38;
param_1[4] = param_2 - 0x28U & 0xfffffffffffffffe | param_1[4] & 1U;
if (param_3 == 0) {
param_1[2] = 0;
}
else {
lVar2 = param_3 + 0x18;
plVar3 = param_1;
if ((param_1[2] == 0) || (plVar3 = param_1, *(long *)(param_1[2] + 0x10) != lVar2)) {
while (local_38 = plVar3, *local_38 != 0) {
plVar3 = (long *)*local_38;
if (plVar3[2] == lVar2) {
param_1[2] = (long)plVar3;
return;
}
if (plVar3[1] + 0x18 == plVar3[2]) {
*local_38 = *plVar3;
my_free(plVar3);
plVar3 = local_38;
}
}
uVar1 = 0;
if ((param_1[4] & 1U) != 0) {
uVar1 = 0x10000;
}
plVar3 = (long *)my_malloc((int)param_1[7],lVar2,uVar1);
if (plVar3 == (long *)0x0) {
param_1[2] = 0;
}
else {
plVar3[2] = lVar2;
plVar3[1] = param_3;
*plVar3 = *local_38;
param_1[2] = (long)plVar3;
*local_38 = (long)plVar3;
}
}
}
return;
}
| |
43,559 | minja::Parser::parseNumber(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&) | monkey531[P]llama/common/minja.hpp | json parseNumber(CharIterator& it, const CharIterator& end) {
auto before = it;
consumeSpaces();
auto start = it;
bool hasDecimal = false;
bool hasExponent = false;
if (it != end && (*it == '-' || *it == '+')) ++it;
while (it != end) {
if (std::isdigit(*it)) {
++it;
} else if (*it == '.') {
if (hasDecimal) throw std::runtime_error("Multiple decimal points");
hasDecimal = true;
++it;
} else if (it != start && (*it == 'e' || *it == 'E')) {
if (hasExponent) throw std::runtime_error("Multiple exponents");
hasExponent = true;
++it;
} else {
break;
}
}
if (start == it) {
it = before;
return json(); // No valid characters found
}
std::string str(start, it);
try {
return json::parse(str);
} catch (json::parse_error& e) {
throw std::runtime_error("Failed to parse number: '" + str + "' (" + std::string(e.what()) + ")");
return json();
}
} | O2 | cpp | minja::Parser::parseNumber(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xf0, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rax
movq %rdi, %rbx
movq (%rdx), %r12
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0x62156
movq (%r14), %rsi
cmpq %rsi, (%r15)
je 0x67890
movzbl (%rsi), %edi
xorl %eax, %eax
movq %rsi, %rdx
cmpl $0x2d, %edi
je 0x67899
movl $0x0, %ecx
cmpl $0x2b, %edi
je 0x6789b
jmp 0x678a1
xorl %eax, %eax
movq %rsi, %rdx
xorl %ecx, %ecx
jmp 0x678a1
xorl %ecx, %ecx
incq %rdx
movq %rdx, (%r14)
cmpq (%r15), %rdx
je 0x67922
movsbl (%rdx), %edi
leal -0x30(%rdi), %r8d
cmpl $0xa, %r8d
jb 0x6789b
movzbl %dil, %edi
cmpl $0x2e, %edi
jne 0x678df
testb $0x1, %cl
movb $0x1, %cl
je 0x6789b
pushq $0x10
popq %rdi
callq 0x24460
movq %rax, %rbx
leaq 0x4e675(%rip), %rsi # 0xb5f4a
movq %rax, %rdi
callq 0x24320
jmp 0x6790c
cmpq %rsi, %rdx
je 0x67922
orl $0x20, %edi
cmpl $0x65, %edi
jne 0x67922
testb $0x1, %al
movb $0x1, %al
je 0x6789b
pushq $0x10
popq %rdi
callq 0x24460
movq %rax, %rbx
leaq 0x4e65e(%rip), %rsi # 0xb5f62
movq %rax, %rdi
callq 0x24320
movq 0x996dd(%rip), %rsi # 0x100ff0
movq 0x99636(%rip), %rdx # 0x100f50
movq %rbx, %rdi
callq 0x24ef0
cmpq %rsi, %rdx
je 0x67972
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x10(%rsp), %rdi
callq 0x53190
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
leaq 0x10(%rsp), %rsi
pushq $0x1
popq %rcx
movq %rbx, %rdi
xorl %r8d, %r8d
callq 0x68022
leaq 0x30(%rsp), %rdi
callq 0x48930
leaq 0x10(%rsp), %rdi
callq 0x251d8
jmp 0x6797f
movq %r12, (%r14)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3defe
movq %rbx, %rax
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %rbx
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x48930
cmpl $0x1, %ebx
jne 0x67ae1
movq %r14, %rdi
callq 0x24380
movq %rax, %r14
pushq $0x10
popq %rdi
callq 0x24460
movq %rax, %rbx
leaq 0x4e5ad(%rip), %rsi # 0xb5f75
leaq 0x70(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x3a1e4
leaq 0x4e5b1(%rip), %rdx # 0xb5f8f
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x38f88
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
leaq 0x50(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rax, %rsi
callq 0x27fde
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x3a017
leaq 0x52b42(%rip), %rdx # 0xba56e
leaq 0xd0(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x38f88
movb $0x1, %bpl
leaq 0xd0(%rsp), %rsi
movq %rbx, %rdi
callq 0x24e20
xorl %ebp, %ebp
movq 0x99593(%rip), %rsi # 0x100ff0
movq 0x994ec(%rip), %rdx # 0x100f50
movq %rbx, %rdi
callq 0x24ef0
movq %rax, %r14
leaq 0xd0(%rsp), %rdi
callq 0x251d8
jmp 0x67a84
movq %rax, %r14
movb $0x1, %bpl
leaq 0xb0(%rsp), %rdi
callq 0x251d8
jmp 0x67a99
movq %rax, %r14
movb $0x1, %bpl
leaq 0x50(%rsp), %rdi
callq 0x251d8
jmp 0x67aab
movq %rax, %r14
movb $0x1, %bpl
leaq 0x90(%rsp), %rdi
callq 0x251d8
jmp 0x67ac0
movq %rax, %r14
movb $0x1, %bpl
leaq 0x70(%rsp), %rdi
callq 0x251d8
testb %bpl, %bpl
jne 0x67ad4
jmp 0x67adc
movq %rax, %r14
movq %rbx, %rdi
callq 0x24680
callq 0x24e40
leaq 0x10(%rsp), %rdi
callq 0x251d8
jmp 0x67b07
movq %rax, %rdi
callq 0x27965
movq %rax, %r14
jmp 0x67b07
jmp 0x67afc
movq %rax, %r14
movq %rbx, %rdi
callq 0x24680
movq %r14, %rdi
callq 0x24f80
| _ZN5minja6Parser11parseNumberERN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEERKSB_:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 0F0h
mov r15, rcx
mov r14, rdx
mov rax, rsi
mov rbx, rdi
mov r12, [rdx]
push 1
pop rsi
mov rdi, rax
call _ZN5minja6Parser13consumeSpacesENS_13SpaceHandlingE; minja::Parser::consumeSpaces(minja::SpaceHandling)
mov rsi, [r14]
cmp [r15], rsi
jz short loc_67890
movzx edi, byte ptr [rsi]
xor eax, eax
mov rdx, rsi
cmp edi, 2Dh ; '-'
jz short loc_67899
mov ecx, 0
cmp edi, 2Bh ; '+'
jz short loc_6789B
jmp short loc_678A1
loc_67890:
xor eax, eax
mov rdx, rsi
xor ecx, ecx
jmp short loc_678A1
loc_67899:
xor ecx, ecx
loc_6789B:
inc rdx
mov [r14], rdx
loc_678A1:
cmp rdx, [r15]
jz short loc_67922
movsx edi, byte ptr [rdx]
lea r8d, [rdi-30h]
cmp r8d, 0Ah
jb short loc_6789B
movzx edi, dil
cmp edi, 2Eh ; '.'
jnz short loc_678DF
test cl, 1
mov cl, 1
jz short loc_6789B
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aMultipleDecima; "Multiple decimal points"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short loc_6790C
loc_678DF:
cmp rdx, rsi
jz short loc_67922
or edi, 20h
cmp edi, 65h ; 'e'
jnz short loc_67922
test al, 1
mov al, 1
jz short loc_6789B
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aMultipleExpone; "Multiple exponents"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
loc_6790C:
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_67922:
cmp rdx, rsi
jz short loc_67972
lea rax, [rsp+118h+var_F8]
mov [rax-10h], rax
lea rdi, [rsp+118h+var_108]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIN9__gnu_cxx17__normal_iteratorIPKcS4_EEEEvT_SB_St20forward_iterator_tag; std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::forward_iterator_tag)
xorps xmm0, xmm0
lea rdx, [rsp+118h+var_E8]
movaps xmmword ptr [rdx+10h], xmm0
movaps xmmword ptr [rdx], xmm0
lea rsi, [rsp+118h+var_108]
push 1
pop rcx
mov rdi, rbx
xor r8d, r8d
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5parseIRS9_EESD_OT_St8functionIFbiNS0_6detail13parse_event_tERSD_EEbb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::parse<std::string&>(std::string&,std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&)>,bool,bool)
lea rdi, [rsp+118h+var_E8]; this
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
lea rdi, [rsp+118h+var_108]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_6797F
loc_67972:
mov [r14], r12
mov rdi, rbx
xor esi, esi
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2EDn; 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(decltype(nullptr))
loc_6797F:
mov rax, rbx
add rsp, 0F0h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
mov rbx, rdx
mov r14, rax
lea rdi, [rsp+118h+var_E8]; this
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
cmp ebx, 1
jnz loc_67AE1
mov rdi, r14; void *
call ___cxa_begin_catch
mov r14, rax
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aFailedToParseN; "Failed to parse number: '"
lea rdi, [rsp+118h+var_A8]
lea rdx, [rsp+118h+var_108]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
lea rdx, asc_B5F8F; "' ("
lea rdi, [rsp+118h+var_88]
lea rsi, [rsp+118h+var_A8]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
mov rax, [r14]
mov rdi, r14
call qword ptr [rax+10h]
lea rdi, [rsp+118h+var_C8]
lea rdx, [rsp+118h+var_109]
mov rsi, rax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rdi, [rsp+118h+var_68]
lea rsi, [rsp+118h+var_88]
lea rdx, [rsp+118h+var_C8]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_S9_; std::operator+<char>(std::string&&,std::string&)
lea rdx, a09401910201912+51h; ")"
lea rdi, [rsp+118h+var_48]
lea rsi, [rsp+118h+var_68]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
mov bpl, 1
lea rsi, [rsp+118h+var_48]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rdi, [rsp+118h+var_48]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_67A84
mov r14, rax
mov bpl, 1
loc_67A84:
lea rdi, [rsp+118h+var_68]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_67A99
mov r14, rax
mov bpl, 1
loc_67A99:
lea rdi, [rsp+118h+var_C8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_67AAB
mov r14, rax
mov bpl, 1
loc_67AAB:
lea rdi, [rsp+118h+var_88]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_67AC0
mov r14, rax
mov bpl, 1
loc_67AC0:
lea rdi, [rsp+118h+var_A8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_67AD4
jmp short loc_67ADC
mov r14, rax
loc_67AD4:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_67ADC:
call ___cxa_end_catch
loc_67AE1:
lea rdi, [rsp+118h+var_108]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_67B07
mov rdi, rax
call __clang_call_terminate
mov r14, rax
jmp short loc_67B07
jmp short $+2
loc_67AFC:
mov r14, rax
mov rdi, rbx; void *
call ___cxa_free_exception
loc_67B07:
mov rdi, r14
call __Unwind_Resume
| long long minja::Parser::parseNumber(long long a1, long long a2, char **a3, char **a4)
{
char *v7; // r12
char *v8; // rsi
int v9; // edi
char v10; // al
char *v11; // rdx
char v12; // cl
int v13; // edi
bool v14; // zf
std::runtime_error *exception; // rbx
int v16; // r9d
_QWORD v18[2]; // [rsp+10h] [rbp-108h] BYREF
char v19; // [rsp+20h] [rbp-F8h] BYREF
_BYTE v20[32]; // [rsp+30h] [rbp-E8h] BYREF
v7 = *a3;
minja::Parser::consumeSpaces(a2, 1);
v8 = *a3;
if ( *a4 == *a3 )
{
v10 = 0;
v11 = *a3;
v12 = 0;
}
else
{
v9 = (unsigned __int8)*v8;
v10 = 0;
v11 = *a3;
if ( v9 == 45 )
{
v12 = 0;
goto LABEL_7;
}
v12 = 0;
if ( v9 == 43 )
goto LABEL_7;
}
while ( v11 != *a4 )
{
v13 = *v11;
if ( (unsigned int)(v13 - 48) >= 0xA )
{
if ( (unsigned __int8)v13 == 46 )
{
v14 = (v12 & 1) == 0;
v12 = 1;
if ( !v14 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Multiple decimal points");
goto LABEL_17;
}
}
else
{
if ( v11 == v8 || ((unsigned __int8)v13 | 0x20) != 0x65 )
break;
v14 = (v10 & 1) == 0;
v10 = 1;
if ( !v14 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Multiple exponents");
LABEL_17:
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
}
}
LABEL_7:
*a3 = ++v11;
}
if ( v11 == v8 )
{
*a3 = v7;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(a1);
}
else
{
v18[0] = &v19;
std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>((long long)v18, v8, (long long)v11);
memset(v20, 0, sizeof(v20));
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::parse<std::string&>(
a1,
(unsigned int)v18,
(unsigned int)v20,
1,
0,
v16);
std::_Function_base::~_Function_base((std::_Function_base *)v20);
std::string::~string(v18);
}
return a1;
}
| parseNumber:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0xf0
MOV R15,RCX
MOV R14,RDX
MOV RAX,RSI
MOV RBX,RDI
MOV R12,qword ptr [RDX]
PUSH 0x1
POP RSI
MOV RDI,RAX
CALL 0x00162156
MOV RSI,qword ptr [R14]
CMP qword ptr [R15],RSI
JZ 0x00167890
MOVZX EDI,byte ptr [RSI]
XOR EAX,EAX
MOV RDX,RSI
CMP EDI,0x2d
JZ 0x00167899
MOV ECX,0x0
CMP EDI,0x2b
JZ 0x0016789b
JMP 0x001678a1
LAB_00167890:
XOR EAX,EAX
MOV RDX,RSI
XOR ECX,ECX
JMP 0x001678a1
LAB_00167899:
XOR ECX,ECX
LAB_0016789b:
INC RDX
MOV qword ptr [R14],RDX
LAB_001678a1:
CMP RDX,qword ptr [R15]
JZ 0x00167922
MOVSX EDI,byte ptr [RDX]
LEA R8D,[RDI + -0x30]
CMP R8D,0xa
JC 0x0016789b
MOVZX EDI,DIL
CMP EDI,0x2e
JNZ 0x001678df
TEST CL,0x1
MOV CL,0x1
JZ 0x0016789b
PUSH 0x10
POP RDI
CALL 0x00124460
MOV RBX,RAX
LAB_001678ce:
LEA RSI,[0x1b5f4a]
MOV RDI,RAX
CALL 0x00124320
LAB_001678dd:
JMP 0x0016790c
LAB_001678df:
CMP RDX,RSI
JZ 0x00167922
OR EDI,0x20
CMP EDI,0x65
JNZ 0x00167922
TEST AL,0x1
MOV AL,0x1
JZ 0x0016789b
PUSH 0x10
POP RDI
CALL 0x00124460
MOV RBX,RAX
LAB_001678fd:
LEA RSI,[0x1b5f62]
MOV RDI,RAX
CALL 0x00124320
LAB_0016790c:
MOV RSI,qword ptr [0x00200ff0]
MOV RDX,qword ptr [0x00200f50]
MOV RDI,RBX
CALL 0x00124ef0
LAB_00167922:
CMP RDX,RSI
JZ 0x00167972
LEA RAX,[RSP + 0x20]
MOV qword ptr [RAX + -0x10],RAX
LAB_00167930:
LEA RDI,[RSP + 0x10]
CALL 0x00153190
XORPS XMM0,XMM0
LEA RDX,[RSP + 0x30]
MOVAPS xmmword ptr [RDX + 0x10],XMM0
MOVAPS xmmword ptr [RDX],XMM0
LAB_00167949:
LEA RSI,[RSP + 0x10]
PUSH 0x1
POP RCX
MOV RDI,RBX
XOR R8D,R8D
CALL 0x00168022
LAB_0016795c:
LEA RDI,[RSP + 0x30]
CALL 0x00148930
LEA RDI,[RSP + 0x10]
CALL 0x001251d8
JMP 0x0016797f
LAB_00167972:
MOV qword ptr [R14],R12
MOV RDI,RBX
XOR ESI,ESI
CALL 0x0013defe
LAB_0016797f:
MOV RAX,RBX
ADD RSP,0xf0
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
/* minja::Parser::parseNumber(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::string >&,
__gnu_cxx::__normal_iterator<char const*, std::__cxx11::string > const&) */
__normal_iterator *
minja::Parser::parseNumber(__normal_iterator *param_1,__normal_iterator *param_2)
{
byte bVar1;
int8 uVar2;
byte *pbVar3;
bool bVar4;
bool bVar5;
bool bVar6;
runtime_error *this;
bool bVar7;
int8 *in_RCX;
int8 *in_RDX;
byte *pbVar8;
int1 *local_108 [2];
int1 local_f8 [16];
int8 local_e8;
int8 uStack_e0;
int8 local_d8;
int8 uStack_d0;
uVar2 = *in_RDX;
consumeSpaces((Parser *)param_2,1);
pbVar3 = (byte *)*in_RDX;
pbVar8 = pbVar3;
if ((byte *)*in_RCX == pbVar3) {
bVar6 = false;
bVar7 = false;
}
else {
bVar6 = false;
bVar5 = bVar6;
if (*pbVar3 == 0x2d) {
bVar4 = false;
goto LAB_0016789b;
}
bVar7 = false;
bVar4 = bVar7;
if (*pbVar3 == 0x2b) goto LAB_0016789b;
}
while (pbVar8 != (byte *)*in_RCX) {
bVar1 = *pbVar8;
bVar4 = bVar7;
bVar5 = bVar6;
if (9 < (int)(char)bVar1 - 0x30U) {
if (bVar1 == 0x2e) {
bVar4 = true;
if (bVar7) {
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001678ce to 001678dc has its CatchHandler @ 00167afc */
std::runtime_error::runtime_error(this,"Multiple decimal points");
LAB_0016790c:
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_00200ff0,PTR__runtime_error_00200f50);
}
}
else {
if ((pbVar8 == pbVar3) || ((bVar1 | 0x20) != 0x65)) break;
bVar5 = true;
if (bVar6) {
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001678fd to 0016790b has its CatchHandler @ 00167afa */
std::runtime_error::runtime_error(this,"Multiple exponents");
goto LAB_0016790c;
}
}
}
LAB_0016789b:
bVar6 = bVar5;
bVar7 = bVar4;
*in_RDX = pbVar8 + 1;
pbVar8 = pbVar8 + 1;
}
if (pbVar8 == pbVar3) {
*in_RDX = uVar2;
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((_func_decltype_nullptr *)param_1);
}
else {
local_108[0] = local_f8;
/* try { // try from 00167930 to 00167939 has its CatchHandler @ 00167af5 */
std::__cxx11::string::
_M_construct<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>(local_108);
local_d8 = 0;
uStack_d0 = 0;
local_e8 = 0;
uStack_e0 = 0;
/* try { // try from 00167949 to 0016795b has its CatchHandler @ 00167992 */
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::parse<std::__cxx11::string&>
((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)param_1,local_108,&local_e8,1,0);
std::_Function_base::~_Function_base((_Function_base *)&local_e8);
std::__cxx11::string::~string((string *)local_108);
}
return param_1;
}
| |
43,560 | ma_unique_comp | eloqsql/storage/maria/ma_unique.c | my_bool _ma_unique_comp(MARIA_UNIQUEDEF *def, const uchar *a, const uchar *b,
my_bool null_are_equal)
{
const uchar *pos_a, *pos_b, *end;
HA_KEYSEG *keyseg;
for (keyseg=def->seg ; keyseg < def->end ; keyseg++)
{
enum ha_base_keytype type=(enum ha_base_keytype) keyseg->type;
uint a_length, b_length;
a_length= b_length= keyseg->length;
/* If part is NULL it's regarded as different */
if (keyseg->null_bit)
{
uint tmp;
if ((tmp=(a[keyseg->null_pos] & keyseg->null_bit)) !=
(uint) (b[keyseg->null_pos] & keyseg->null_bit))
return 1;
if (tmp)
{
if (!null_are_equal)
return 1;
continue;
}
}
pos_a= a+keyseg->start;
pos_b= b+keyseg->start;
if (keyseg->flag & HA_VAR_LENGTH_PART)
{
uint pack_length= keyseg->bit_start;
if (pack_length == 1)
{
a_length= (uint) *pos_a++;
b_length= (uint) *pos_b++;
}
else
{
a_length= uint2korr(pos_a);
b_length= uint2korr(pos_b);
pos_a+= 2; /* Skip VARCHAR length */
pos_b+= 2;
}
set_if_smaller(a_length, keyseg->length); /* Safety */
set_if_smaller(b_length, keyseg->length); /* safety */
}
else if (keyseg->flag & HA_BLOB_PART)
{
/* Only compare 'length' characters if length != 0 */
a_length= _ma_calc_blob_length(keyseg->bit_start,pos_a);
b_length= _ma_calc_blob_length(keyseg->bit_start,pos_b);
/* Check that a and b are of equal length */
if (keyseg->length)
{
/*
This is used in some cases when we are not interested in comparing
the whole length of the blob.
*/
set_if_smaller(a_length, keyseg->length);
set_if_smaller(b_length, keyseg->length);
}
memcpy((void*) &pos_a, pos_a+keyseg->bit_start, sizeof(char*));
memcpy((void*) &pos_b, pos_b+keyseg->bit_start, sizeof(char*));
}
if (type == HA_KEYTYPE_TEXT || type == HA_KEYTYPE_VARTEXT1 ||
type == HA_KEYTYPE_VARTEXT2)
{
if (ha_compare_text(keyseg->charset, pos_a, a_length,
pos_b, b_length, 0))
return 1;
}
else
{
if (a_length != b_length)
return 1;
end= pos_a+a_length;
while (pos_a != end)
{
if (*pos_a++ != *pos_b++)
return 1;
}
}
}
return 0;
} | O3 | c | ma_unique_comp:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x8(%rdi), %r15
movq %rdi, -0x48(%rbp)
cmpq 0x10(%rdi), %r15
jae 0x58d34
movl %ecx, %r14d
movq %rdx, -0x40(%rbp)
movq %rsi, -0x38(%rbp)
movl %ecx, -0x2c(%rbp)
movzbl 0x18(%r15), %r12d
movzwl 0x14(%r15), %ecx
movb 0x19(%r15), %dil
testb %dil, %dil
je 0x58c1e
movl 0xc(%r15), %eax
movb (%rsi,%rax), %r8b
andb %dil, %r8b
andb (%rdx,%rax), %dil
movb $0x1, %al
cmpb %dil, %r8b
jne 0x58d36
testb %r8b, %r8b
je 0x58c1e
testb %r14b, %r14b
jne 0x58cf4
jmp 0x58d36
movl 0x8(%r15), %r13d
leaq (%rsi,%r13), %rbx
addq %rdx, %r13
movzwl 0x12(%r15), %eax
testb $0x8, %al
jne 0x58c3d
testb $0x20, %al
jne 0x58c54
movl %ecx, %esi
jmp 0x58cc1
cmpb $0x1, 0x1a(%r15)
jne 0x58ca3
movzbl (%rbx), %eax
incq %rbx
movzbl (%r13), %edx
incq %r13
jmp 0x58cb3
movzbl 0x1a(%r15), %edi
movq %rbx, %rsi
callq 0x48dc7
movq %rax, %r14
movzbl 0x1a(%r15), %edi
movq %r13, %rsi
callq 0x48dc7
movzwl 0x14(%r15), %edx
cmpl %edx, %r14d
movl %edx, %ecx
cmovbl %r14d, %ecx
cmpl %edx, %eax
movl %edx, %esi
cmovbl %eax, %esi
testl %edx, %edx
cmovel %r14d, %ecx
movl -0x2c(%rbp), %r14d
cmovel %eax, %esi
movzbl 0x1a(%r15), %eax
movq (%rbx,%rax), %rbx
movq (%r13,%rax), %r13
jmp 0x58cc1
movzwl (%rbx), %eax
movzwl (%r13), %edx
addq $0x2, %rbx
addq $0x2, %r13
cmpl %ecx, %eax
cmovael %ecx, %eax
cmpl %ecx, %edx
movl %ecx, %esi
cmovbl %edx, %esi
movl %eax, %ecx
cmpl $0x11, %r12d
ja 0x58d08
movl $0x28002, %eax # imm = 0x28002
btl %r12d, %eax
jae 0x58d08
movq (%r15), %rdi
movl %ecx, %edx
movl %esi, %r8d
movq %rbx, %rsi
movq %r13, %rcx
xorl %r9d, %r9d
callq 0x9e910
testl %eax, %eax
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rsi
jne 0x58d45
addq $0x20, %r15
movq -0x48(%rbp), %rax
cmpq 0x10(%rax), %r15
jb 0x58bde
jmp 0x58d34
movb $0x1, %al
cmpl %esi, %ecx
jne 0x58d36
movl %ecx, %ecx
xorl %r8d, %r8d
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rsi
cmpq %r8, %rcx
je 0x58cf4
movb (%rbx,%r8), %r9b
leaq 0x1(%r8), %rdi
cmpb (%r13,%r8), %r9b
movq %rdi, %r8
je 0x58d1b
jmp 0x58d36
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %al
jmp 0x58d36
nopl (%rax)
| _ma_unique_comp:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r15, [rdi+8]
mov [rbp+var_48], rdi
cmp r15, [rdi+10h]
jnb loc_58D34
mov r14d, ecx
mov [rbp+var_40], rdx
mov [rbp+var_38], rsi
mov [rbp+var_2C], ecx
loc_58BDE:
movzx r12d, byte ptr [r15+18h]
movzx ecx, word ptr [r15+14h]
mov dil, [r15+19h]
test dil, dil
jz short loc_58C1E
mov eax, [r15+0Ch]
mov r8b, [rsi+rax]
and r8b, dil
and dil, [rdx+rax]
mov al, 1
cmp r8b, dil
jnz loc_58D36
test r8b, r8b
jz short loc_58C1E
test r14b, r14b
jnz loc_58CF4
jmp loc_58D36
loc_58C1E:
mov r13d, [r15+8]
lea rbx, [rsi+r13]
add r13, rdx
movzx eax, word ptr [r15+12h]
test al, 8
jnz short loc_58C3D
test al, 20h
jnz short loc_58C54
mov esi, ecx
jmp loc_58CC1
loc_58C3D:
cmp byte ptr [r15+1Ah], 1
jnz short loc_58CA3
movzx eax, byte ptr [rbx]
inc rbx
movzx edx, byte ptr [r13+0]
inc r13
jmp short loc_58CB3
loc_58C54:
movzx edi, byte ptr [r15+1Ah]
mov rsi, rbx
call _ma_calc_blob_length
mov r14, rax
movzx edi, byte ptr [r15+1Ah]
mov rsi, r13
call _ma_calc_blob_length
movzx edx, word ptr [r15+14h]
cmp r14d, edx
mov ecx, edx
cmovb ecx, r14d
cmp eax, edx
mov esi, edx
cmovb esi, eax
test edx, edx
cmovz ecx, r14d
mov r14d, [rbp+var_2C]
cmovz esi, eax
movzx eax, byte ptr [r15+1Ah]
mov rbx, [rbx+rax]
mov r13, [r13+rax+0]
jmp short loc_58CC1
loc_58CA3:
movzx eax, word ptr [rbx]
movzx edx, word ptr [r13+0]
add rbx, 2
add r13, 2
loc_58CB3:
cmp eax, ecx
cmovnb eax, ecx
cmp edx, ecx
mov esi, ecx
cmovb esi, edx
mov ecx, eax
loc_58CC1:
cmp r12d, 11h
ja short loc_58D08
mov eax, 28002h
bt eax, r12d
jnb short loc_58D08
mov rdi, [r15]
mov edx, ecx
mov r8d, esi
mov rsi, rbx
mov rcx, r13
xor r9d, r9d
call ha_compare_text
test eax, eax
mov rdx, [rbp+var_40]
mov rsi, [rbp+var_38]
jnz short loc_58D45
loc_58CF4:
add r15, 20h ; ' '
mov rax, [rbp+var_48]
cmp r15, [rax+10h]
jb loc_58BDE
jmp short loc_58D34
loc_58D08:
mov al, 1
cmp ecx, esi
jnz short loc_58D36
mov ecx, ecx
xor r8d, r8d
mov rdx, [rbp+var_40]
mov rsi, [rbp+var_38]
loc_58D1B:
cmp rcx, r8
jz short loc_58CF4
mov r9b, [rbx+r8]
lea rdi, [r8+1]
cmp r9b, [r13+r8+0]
mov r8, rdi
jz short loc_58D1B
jmp short loc_58D36
loc_58D34:
xor eax, eax
loc_58D36:
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_58D45:
mov al, 1
jmp short loc_58D36
| char ma_unique_comp(long long a1, long long a2, long long a3, char a4)
{
unsigned long long v4; // r15
char v5; // r14
unsigned int v6; // r12d
unsigned int v7; // ecx
char v8; // di
long long v9; // rax
char v10; // r8
char v11; // di
char result; // al
long long v13; // r13
unsigned __int8 *v14; // rbx
unsigned __int8 *v15; // r13
__int16 v16; // ax
unsigned int v17; // esi
unsigned int v18; // eax
unsigned int v19; // edx
unsigned int v20; // r14d
unsigned int v21; // eax
unsigned int v22; // edx
long long v23; // rax
int v24; // eax
int v25; // eax
long long v26; // r8
bool v27; // zf
long long v29; // [rsp+10h] [rbp-40h]
long long v30; // [rsp+18h] [rbp-38h]
v4 = *(_QWORD *)(a1 + 8);
if ( v4 < *(_QWORD *)(a1 + 16) )
{
v5 = a4;
v29 = a3;
v30 = a2;
do
{
v6 = *(unsigned __int8 *)(v4 + 24);
v7 = *(unsigned __int16 *)(v4 + 20);
v8 = *(_BYTE *)(v4 + 25);
if ( !v8 )
goto LABEL_8;
v9 = *(unsigned int *)(v4 + 12);
v10 = v8 & *(_BYTE *)(a2 + v9);
v11 = *(_BYTE *)(a3 + v9) & v8;
result = 1;
if ( v10 != v11 )
return result;
if ( v10 )
{
if ( !v5 )
return result;
}
else
{
LABEL_8:
v13 = *(unsigned int *)(v4 + 8);
v14 = (unsigned __int8 *)(a2 + v13);
v15 = (unsigned __int8 *)(a3 + v13);
v16 = *(_WORD *)(v4 + 18);
if ( (v16 & 8) != 0 )
{
if ( *(_BYTE *)(v4 + 26) == 1 )
{
v18 = *v14++;
v19 = *v15++;
}
else
{
v18 = *(unsigned __int16 *)v14;
v19 = *(unsigned __int16 *)v15;
v14 += 2;
v15 += 2;
}
if ( v18 >= v7 )
v18 = *(unsigned __int16 *)(v4 + 20);
v17 = *(unsigned __int16 *)(v4 + 20);
if ( v19 < v7 )
v17 = v19;
v7 = v18;
}
else if ( (v16 & 0x20) != 0 )
{
v20 = ma_calc_blob_length(*(unsigned __int8 *)(v4 + 26), v14);
v21 = ma_calc_blob_length(*(unsigned __int8 *)(v4 + 26), v15);
v22 = *(unsigned __int16 *)(v4 + 20);
v7 = v22;
if ( v20 < v22 )
v7 = v20;
v17 = *(unsigned __int16 *)(v4 + 20);
if ( v21 < v22 )
v17 = v21;
if ( !*(_WORD *)(v4 + 20) )
v7 = v20;
v5 = a4;
if ( !*(_WORD *)(v4 + 20) )
v17 = v21;
v23 = *(unsigned __int8 *)(v4 + 26);
v14 = *(unsigned __int8 **)&v14[v23];
v15 = *(unsigned __int8 **)&v15[v23];
}
else
{
v17 = *(unsigned __int16 *)(v4 + 20);
}
if ( v6 <= 0x11 && (v24 = 163842, _bittest(&v24, v6)) )
{
v25 = ha_compare_text(*(_QWORD *)v4, v14, v7, v15, v17, 0LL);
a3 = v29;
a2 = v30;
if ( v25 )
return 1;
}
else
{
result = 1;
if ( v7 != v17 )
return result;
v26 = 0LL;
a3 = v29;
a2 = v30;
while ( v7 != v26 )
{
v27 = v14[v26] == v15[v26];
++v26;
if ( !v27 )
return result;
}
}
}
v4 += 32LL;
}
while ( v4 < *(_QWORD *)(a1 + 16) );
}
return 0;
}
| _ma_unique_comp:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R15,qword ptr [RDI + 0x8]
MOV qword ptr [RBP + -0x48],RDI
CMP R15,qword ptr [RDI + 0x10]
JNC 0x00158d34
MOV R14D,ECX
MOV qword ptr [RBP + -0x40],RDX
MOV qword ptr [RBP + -0x38],RSI
MOV dword ptr [RBP + -0x2c],ECX
LAB_00158bde:
MOVZX R12D,byte ptr [R15 + 0x18]
MOVZX ECX,word ptr [R15 + 0x14]
MOV DIL,byte ptr [R15 + 0x19]
TEST DIL,DIL
JZ 0x00158c1e
MOV EAX,dword ptr [R15 + 0xc]
MOV R8B,byte ptr [RSI + RAX*0x1]
AND R8B,DIL
AND DIL,byte ptr [RDX + RAX*0x1]
MOV AL,0x1
CMP R8B,DIL
JNZ 0x00158d36
TEST R8B,R8B
JZ 0x00158c1e
TEST R14B,R14B
JNZ 0x00158cf4
JMP 0x00158d36
LAB_00158c1e:
MOV R13D,dword ptr [R15 + 0x8]
LEA RBX,[RSI + R13*0x1]
ADD R13,RDX
MOVZX EAX,word ptr [R15 + 0x12]
TEST AL,0x8
JNZ 0x00158c3d
TEST AL,0x20
JNZ 0x00158c54
MOV ESI,ECX
JMP 0x00158cc1
LAB_00158c3d:
CMP byte ptr [R15 + 0x1a],0x1
JNZ 0x00158ca3
MOVZX EAX,byte ptr [RBX]
INC RBX
MOVZX EDX,byte ptr [R13]
INC R13
JMP 0x00158cb3
LAB_00158c54:
MOVZX EDI,byte ptr [R15 + 0x1a]
MOV RSI,RBX
CALL 0x00148dc7
MOV R14,RAX
MOVZX EDI,byte ptr [R15 + 0x1a]
MOV RSI,R13
CALL 0x00148dc7
MOVZX EDX,word ptr [R15 + 0x14]
CMP R14D,EDX
MOV ECX,EDX
CMOVC ECX,R14D
CMP EAX,EDX
MOV ESI,EDX
CMOVC ESI,EAX
TEST EDX,EDX
CMOVZ ECX,R14D
MOV R14D,dword ptr [RBP + -0x2c]
CMOVZ ESI,EAX
MOVZX EAX,byte ptr [R15 + 0x1a]
MOV RBX,qword ptr [RBX + RAX*0x1]
MOV R13,qword ptr [R13 + RAX*0x1]
JMP 0x00158cc1
LAB_00158ca3:
MOVZX EAX,word ptr [RBX]
MOVZX EDX,word ptr [R13]
ADD RBX,0x2
ADD R13,0x2
LAB_00158cb3:
CMP EAX,ECX
CMOVNC EAX,ECX
CMP EDX,ECX
MOV ESI,ECX
CMOVC ESI,EDX
MOV ECX,EAX
LAB_00158cc1:
CMP R12D,0x11
JA 0x00158d08
MOV EAX,0x28002
BT EAX,R12D
JNC 0x00158d08
MOV RDI,qword ptr [R15]
MOV EDX,ECX
MOV R8D,ESI
MOV RSI,RBX
MOV RCX,R13
XOR R9D,R9D
CALL 0x0019e910
TEST EAX,EAX
MOV RDX,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x38]
JNZ 0x00158d45
LAB_00158cf4:
ADD R15,0x20
MOV RAX,qword ptr [RBP + -0x48]
CMP R15,qword ptr [RAX + 0x10]
JC 0x00158bde
JMP 0x00158d34
LAB_00158d08:
MOV AL,0x1
CMP ECX,ESI
JNZ 0x00158d36
MOV ECX,ECX
XOR R8D,R8D
MOV RDX,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x38]
LAB_00158d1b:
CMP RCX,R8
JZ 0x00158cf4
MOV R9B,byte ptr [RBX + R8*0x1]
LEA RDI,[R8 + 0x1]
CMP R9B,byte ptr [R13 + R8*0x1]
MOV R8,RDI
JZ 0x00158d1b
JMP 0x00158d36
LAB_00158d34:
XOR EAX,EAX
LAB_00158d36:
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00158d45:
MOV AL,0x1
JMP 0x00158d36
|
int8 _ma_unique_comp(long param_1,long param_2,long param_3,char param_4)
{
byte *pbVar1;
byte *pbVar2;
byte bVar3;
byte bVar4;
ushort uVar5;
uint uVar6;
uint uVar7;
uint uVar8;
int iVar9;
uint uVar10;
ulong uVar11;
uint uVar12;
ushort *puVar13;
byte bVar14;
ulong uVar15;
ushort *puVar16;
int8 *puVar17;
puVar17 = *(int8 **)(param_1 + 8);
if (puVar17 < *(int8 **)(param_1 + 0x10)) {
do {
bVar4 = *(byte *)(puVar17 + 3);
uVar5 = *(ushort *)((long)puVar17 + 0x14);
uVar11 = (ulong)uVar5;
bVar3 = *(byte *)((long)puVar17 + 0x19);
if (bVar3 == 0) {
LAB_00158c1e:
puVar13 = (ushort *)(param_2 + (ulong)*(uint *)(puVar17 + 1));
puVar16 = (ushort *)((ulong)*(uint *)(puVar17 + 1) + param_3);
if ((*(ushort *)((long)puVar17 + 0x12) & 8) == 0) {
if ((*(ushort *)((long)puVar17 + 0x12) & 0x20) == 0) {
uVar10 = (uint)uVar5;
}
else {
uVar7 = _ma_calc_blob_length(*(int1 *)((long)puVar17 + 0x1a),puVar13);
uVar8 = _ma_calc_blob_length(*(int1 *)((long)puVar17 + 0x1a),puVar16);
uVar5 = *(ushort *)((long)puVar17 + 0x14);
uVar6 = (uint)uVar5;
if (uVar7 < uVar5) {
uVar6 = uVar7;
}
uVar12 = (uint)uVar5;
uVar10 = uVar12;
if (uVar8 < uVar12) {
uVar10 = uVar8;
}
if (uVar12 == 0) {
uVar10 = uVar8;
uVar6 = uVar7;
}
uVar11 = (ulong)uVar6;
puVar13 = *(ushort **)((long)puVar13 + (ulong)*(byte *)((long)puVar17 + 0x1a));
puVar16 = *(ushort **)((long)puVar16 + (ulong)*(byte *)((long)puVar17 + 0x1a));
}
}
else {
if (*(char *)((long)puVar17 + 0x1a) == '\x01') {
uVar6 = (uint)(byte)*puVar13;
puVar13 = (ushort *)((long)puVar13 + 1);
uVar7 = (uint)(byte)*puVar16;
puVar16 = (ushort *)((long)puVar16 + 1);
}
else {
uVar6 = (uint)*puVar13;
uVar7 = (uint)*puVar16;
puVar13 = puVar13 + 1;
puVar16 = puVar16 + 1;
}
uVar10 = (uint)uVar5;
if (uVar10 <= uVar6) {
uVar6 = uVar10;
}
if (uVar7 < uVar10) {
uVar10 = uVar7;
}
uVar11 = (ulong)uVar6;
}
if ((bVar4 < 0x12) && ((0x28002U >> (bVar4 & 0x1f) & 1) != 0)) {
iVar9 = ha_compare_text(*puVar17,puVar13,uVar11,puVar16,uVar10,0);
if (iVar9 != 0) {
return 1;
}
}
else {
if ((uint)uVar11 != uVar10) {
return 1;
}
uVar15 = 0;
while (uVar11 != uVar15) {
pbVar1 = (byte *)((long)puVar13 + uVar15);
pbVar2 = (byte *)((long)puVar16 + uVar15);
uVar15 = uVar15 + 1;
if (*pbVar1 != *pbVar2) {
return 1;
}
}
}
}
else {
bVar14 = *(byte *)(param_2 + (ulong)*(uint *)((long)puVar17 + 0xc)) & bVar3;
if (bVar14 != (bVar3 & *(byte *)(param_3 + (ulong)*(uint *)((long)puVar17 + 0xc)))) {
return 1;
}
if (bVar14 == 0) goto LAB_00158c1e;
if (param_4 == '\0') {
return 1;
}
}
puVar17 = puVar17 + 4;
} while (puVar17 < *(int8 **)(param_1 + 0x10));
}
return 0;
}
| |
43,561 | my_casefold_mb | eloqsql/strings/ctype-mb.c | static size_t
my_casefold_mb(CHARSET_INFO *cs,
const char *src, size_t srclen,
char *dst, size_t dstlen __attribute__((unused)),
const uchar *map,
size_t is_upper)
{
const char *srcend= src + srclen;
char *dst0= dst;
DBUG_ASSERT(cs->mbmaxlen == 2);
while (src < srcend)
{
size_t mblen= my_ismbchar(cs, src, srcend);
if (mblen)
{
MY_UNICASE_CHARACTER *ch;
if ((ch= get_case_info_for_ch(cs, (uchar) src[0], (uchar) src[1])))
{
int code= is_upper ? ch->toupper : ch->tolower;
src+= 2;
if (code > 0xFF)
*dst++= code >> 8;
*dst++= code & 0xFF;
}
else
{
*dst++= *src++;
*dst++= *src++;
}
}
else
{
*dst++= (char) map[(uchar) *src++];
}
}
return (size_t) (dst - dst0);
} | O0 | c | my_casefold_mb:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x465fa
jmp 0x465fc
movq -0x10(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x46730
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x46460
movl %eax, %eax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x46701
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movzbl (%rax), %esi
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %edx
callq 0x49140
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x466bb
cmpq $0x0, 0x10(%rbp)
je 0x46660
movq -0x50(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x58(%rbp)
jmp 0x4666a
movq -0x50(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x58(%rbp)
movl -0x58(%rbp), %eax
movl %eax, -0x54(%rbp)
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x10(%rbp)
cmpl $0xff, -0x54(%rbp)
jle 0x4669e
movl -0x54(%rbp), %eax
sarl $0x8, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movl -0x54(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
jmp 0x466ff
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
jmp 0x4672b
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movzbl (%rcx), %ecx
movb (%rax,%rcx), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
jmp 0x465fc
movq -0x20(%rbp), %rax
movq -0x40(%rbp), %rcx
subq %rcx, %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_casefold_mb:
push rbp
mov rbp, rsp
sub rsp, 60h
mov rax, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_38], rax
mov rax, [rbp+var_20]
mov [rbp+var_40], rax
jmp short $+2
loc_465FA:
jmp short $+2
loc_465FC:
mov rax, [rbp+var_10]
cmp rax, [rbp+var_38]
jnb loc_46730
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_38]
call my_ismbchar_0
mov eax, eax
mov [rbp+var_48], rax
cmp [rbp+var_48], 0
jz loc_46701
mov rdi, [rbp+var_8]
mov rax, [rbp+var_10]
movzx esi, byte ptr [rax]
mov rax, [rbp+var_10]
movzx edx, byte ptr [rax+1]
call get_case_info_for_ch
mov [rbp+var_50], rax
cmp rax, 0
jz short loc_466BB
cmp [rbp+arg_0], 0
jz short loc_46660
mov rax, [rbp+var_50]
mov eax, [rax]
mov [rbp+var_58], eax
jmp short loc_4666A
loc_46660:
mov rax, [rbp+var_50]
mov eax, [rax+4]
mov [rbp+var_58], eax
loc_4666A:
mov eax, [rbp+var_58]
mov [rbp+var_54], eax
mov rax, [rbp+var_10]
add rax, 2
mov [rbp+var_10], rax
cmp [rbp+var_54], 0FFh
jle short loc_4669E
mov eax, [rbp+var_54]
sar eax, 8
mov cl, al
mov rax, [rbp+var_20]
mov rdx, rax
add rdx, 1
mov [rbp+var_20], rdx
mov [rax], cl
loc_4669E:
mov eax, [rbp+var_54]
and eax, 0FFh
mov cl, al
mov rax, [rbp+var_20]
mov rdx, rax
add rdx, 1
mov [rbp+var_20], rdx
mov [rax], cl
jmp short loc_466FF
loc_466BB:
mov rax, [rbp+var_10]
mov rcx, rax
add rcx, 1
mov [rbp+var_10], rcx
mov cl, [rax]
mov rax, [rbp+var_20]
mov rdx, rax
add rdx, 1
mov [rbp+var_20], rdx
mov [rax], cl
mov rax, [rbp+var_10]
mov rcx, rax
add rcx, 1
mov [rbp+var_10], rcx
mov cl, [rax]
mov rax, [rbp+var_20]
mov rdx, rax
add rdx, 1
mov [rbp+var_20], rdx
mov [rax], cl
loc_466FF:
jmp short loc_4672B
loc_46701:
mov rax, [rbp+var_30]
mov rcx, [rbp+var_10]
mov rdx, rcx
add rdx, 1
mov [rbp+var_10], rdx
movzx ecx, byte ptr [rcx]
mov cl, [rax+rcx]
mov rax, [rbp+var_20]
mov rdx, rax
add rdx, 1
mov [rbp+var_20], rdx
mov [rax], cl
loc_4672B:
jmp loc_465FC
loc_46730:
mov rax, [rbp+var_20]
mov rcx, [rbp+var_40]
sub rax, rcx
add rsp, 60h
pop rbp
retn
| _BYTE * my_casefold_mb(
long long a1,
unsigned __int8 *a2,
long long a3,
unsigned __int8 *a4,
long long a5,
long long a6,
long long a7)
{
unsigned __int8 *v7; // rax
unsigned __int8 *v8; // rax
char *v9; // rax
char v10; // cl
_BYTE *v11; // rax
unsigned __int8 *v12; // rcx
unsigned __int8 *v13; // rax
int v15; // [rsp+8h] [rbp-58h]
int *case_info_for_ch; // [rsp+10h] [rbp-50h]
unsigned long long v18; // [rsp+28h] [rbp-38h]
unsigned __int8 *v20; // [rsp+40h] [rbp-20h]
unsigned __int8 *v21; // [rsp+50h] [rbp-10h]
v21 = a2;
v20 = a4;
v18 = (unsigned long long)&a2[a3];
while ( (unsigned long long)v21 < v18 )
{
if ( (unsigned int)my_ismbchar_0(a1, (long long)v21, v18) )
{
case_info_for_ch = (int *)get_case_info_for_ch(a1, *v21, v21[1]);
if ( case_info_for_ch )
{
if ( a7 )
v15 = *case_info_for_ch;
else
v15 = case_info_for_ch[1];
v21 += 2;
if ( v15 > 255 )
{
v7 = v20++;
*v7 = BYTE1(v15);
}
v8 = v20++;
*v8 = v15;
}
else
{
*v20 = *v21;
v9 = (char *)(v21 + 1);
v21 += 2;
v10 = *v9;
v11 = v20 + 1;
v20 += 2;
*v11 = v10;
}
}
else
{
v12 = v21++;
v13 = v20++;
*v13 = *(_BYTE *)(a6 + *v12);
}
}
return (_BYTE *)(v20 - a4);
}
| my_casefold_mb:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x40],RAX
JMP 0x001465fa
LAB_001465fa:
JMP 0x001465fc
LAB_001465fc:
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x38]
JNC 0x00146730
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x38]
CALL 0x00146460
MOV EAX,EAX
MOV qword ptr [RBP + -0x48],RAX
CMP qword ptr [RBP + -0x48],0x0
JZ 0x00146701
MOV RDI,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOVZX ESI,byte ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EDX,byte ptr [RAX + 0x1]
CALL 0x00149140
MOV qword ptr [RBP + -0x50],RAX
CMP RAX,0x0
JZ 0x001466bb
CMP qword ptr [RBP + 0x10],0x0
JZ 0x00146660
MOV RAX,qword ptr [RBP + -0x50]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x58],EAX
JMP 0x0014666a
LAB_00146660:
MOV RAX,qword ptr [RBP + -0x50]
MOV EAX,dword ptr [RAX + 0x4]
MOV dword ptr [RBP + -0x58],EAX
LAB_0014666a:
MOV EAX,dword ptr [RBP + -0x58]
MOV dword ptr [RBP + -0x54],EAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x2
MOV qword ptr [RBP + -0x10],RAX
CMP dword ptr [RBP + -0x54],0xff
JLE 0x0014669e
MOV EAX,dword ptr [RBP + -0x54]
SAR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x20],RDX
MOV byte ptr [RAX],CL
LAB_0014669e:
MOV EAX,dword ptr [RBP + -0x54]
AND EAX,0xff
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x20],RDX
MOV byte ptr [RAX],CL
JMP 0x001466ff
LAB_001466bb:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x10],RCX
MOV CL,byte ptr [RAX]
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x20],RDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x10],RCX
MOV CL,byte ptr [RAX]
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x20],RDX
MOV byte ptr [RAX],CL
LAB_001466ff:
JMP 0x0014672b
LAB_00146701:
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x10]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x10],RDX
MOVZX ECX,byte ptr [RCX]
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x20],RDX
MOV byte ptr [RAX],CL
LAB_0014672b:
JMP 0x001465fc
LAB_00146730:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x40]
SUB RAX,RCX
ADD RSP,0x60
POP RBP
RET
|
long my_casefold_mb(int8 param_1,byte *param_2,long param_3,byte *param_4,int8 param_5,
long param_6,long param_7)
{
int iVar1;
int *piVar2;
byte *pbVar3;
int local_60;
byte *local_28;
byte *local_18;
local_28 = param_4;
local_18 = param_2;
while (local_18 < param_2 + param_3) {
iVar1 = my_ismbchar(param_1,local_18,param_2 + param_3);
if (iVar1 == 0) {
*local_28 = *(byte *)(param_6 + (ulong)*local_18);
local_28 = local_28 + 1;
local_18 = local_18 + 1;
}
else {
piVar2 = (int *)get_case_info_for_ch(param_1,*local_18,local_18[1]);
if (piVar2 == (int *)0x0) {
pbVar3 = local_28 + 1;
*local_28 = *local_18;
local_28 = local_28 + 2;
*pbVar3 = local_18[1];
}
else {
if (param_7 == 0) {
local_60 = piVar2[1];
}
else {
local_60 = *piVar2;
}
if (0xff < local_60) {
*local_28 = (byte)((uint)local_60 >> 8);
local_28 = local_28 + 1;
}
*local_28 = (byte)local_60;
local_28 = local_28 + 1;
}
local_18 = local_18 + 2;
}
}
return (long)local_28 - (long)param_4;
}
| |
43,562 | GL_MeshingTask::finalize() | untodesu[P]voxelius/game/client/chunk_mesher.cc | void GL_MeshingTask::finalize(void)
{
if(!globals::dimension || !globals::dimension->chunks.valid(m_entity)) {
// We either disconnected or something
// else happened that invalidated the entity
return;
}
auto &component = globals::dimension->chunks.emplace_or_replace<ChunkMeshComponent>(m_entity);
const std::size_t plane_count_nb = m_quads_s.size();
const std::size_t plane_count_b = m_quads_b.size();
bool has_no_submeshes_b = true;
bool has_no_submeshes_nb = true;
component.quad_nb.resize(plane_count_nb);
component.quad_b.resize(plane_count_b);
for(std::size_t plane = 0; plane < plane_count_nb; ++plane) {
QuadBuilder &builder = m_quads_s[plane];
ChunkVBO &buffer = component.quad_nb[plane];
if(builder.empty()) {
if(buffer.handle) {
glDeleteBuffers(1, &buffer.handle);
buffer.handle = 0;
buffer.size = 0;
}
}
else {
if(!buffer.handle)
glGenBuffers(1, &buffer.handle);
glBindBuffer(GL_ARRAY_BUFFER, buffer.handle);
glBufferData(GL_ARRAY_BUFFER, sizeof(ChunkQuad) * builder.size(), builder.data(), GL_STATIC_DRAW);
buffer.size = builder.size();
has_no_submeshes_nb = false;
}
}
for(std::size_t plane = 0; plane < plane_count_b; ++plane) {
QuadBuilder &builder = m_quads_b[plane];
ChunkVBO &buffer = component.quad_b[plane];
if(builder.empty()) {
if(buffer.handle) {
glDeleteBuffers(1, &buffer.handle);
buffer.handle = 0;
buffer.size = 0;
}
}
else {
if(!buffer.handle)
glGenBuffers(1, &buffer.handle);
glBindBuffer(GL_ARRAY_BUFFER, buffer.handle);
glBufferData(GL_ARRAY_BUFFER, sizeof(ChunkQuad) * builder.size(), builder.data(), GL_STATIC_DRAW);
buffer.size = builder.size();
has_no_submeshes_b = false;
}
}
if(has_no_submeshes_b && has_no_submeshes_nb) {
globals::dimension->chunks.remove<ChunkMeshComponent>(m_entity);
}
} | O0 | cpp | GL_MeshingTask::finalize():
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq 0x4acbf2(%rip), %rax # 0x50e230
cmpq $0x0, (%rax)
je 0x61665
movq -0x60(%rbp), %rax
leaq 0x4acbe1(%rip), %rcx # 0x50e230
movq (%rcx), %rdi
addq $0x8, %rdi
movl 0xe050(%rax), %esi
callq 0x638e0
testb $0x1, %al
jne 0x6166a
jmp 0x61966
movq -0x60(%rbp), %rax
leaq 0x4acbbb(%rip), %rcx # 0x50e230
movq (%rcx), %rdi
addq $0x8, %rdi
movl 0xe050(%rax), %esi
callq 0x63940
movq -0x60(%rbp), %rdi
movq %rax, -0x10(%rbp)
addq $0xe038, %rdi # imm = 0xE038
callq 0x639e0
movq -0x60(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0xe020, %rdi # imm = 0xE020
callq 0x639e0
movq %rax, -0x20(%rbp)
movb $0x1, -0x21(%rbp)
movb $0x1, -0x22(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x63a10
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
movq -0x20(%rbp), %rsi
callq 0x63a10
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x61809
movq -0x60(%rbp), %rdi
addq $0xe038, %rdi # imm = 0xE038
movq -0x30(%rbp), %rsi
callq 0x63aa0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x63ac0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x63ae0
testb $0x1, %al
jne 0x61727
jmp 0x61765
movq -0x40(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x61760
leaq 0x4b0178(%rip), %rax # 0x5118b0
movq (%rax), %rax
movq -0x40(%rbp), %rsi
addq $0x8, %rsi
movl $0x1, %edi
callq *%rax
movq -0x40(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x40(%rbp), %rax
movq $0x0, (%rax)
jmp 0x617f6
movq -0x40(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x61788
leaq 0x4b029a(%rip), %rax # 0x511a10
movq (%rax), %rax
movq -0x40(%rbp), %rsi
addq $0x8, %rsi
movl $0x1, %edi
callq *%rax
leaq 0x4aff91(%rip), %rax # 0x511720
movq (%rax), %rax
movq -0x40(%rbp), %rcx
movl 0x8(%rcx), %esi
movl $0x8892, %edi # imm = 0x8892
callq *%rax
leaq 0x4afff9(%rip), %rax # 0x5117a0
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x38(%rbp), %rdi
callq 0x63b20
shlq $0x3, %rax
movq %rax, -0x70(%rbp)
movq -0x38(%rbp), %rdi
callq 0x63b40
movq -0x70(%rbp), %rsi
movq %rax, %rdx
movq -0x68(%rbp), %rax
movl $0x8892, %edi # imm = 0x8892
movl $0x88e4, %ecx # imm = 0x88E4
callq *%rax
movq -0x38(%rbp), %rdi
callq 0x63b20
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movb $0x0, -0x22(%rbp)
jmp 0x617f8
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x616e1
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x6193d
movq -0x60(%rbp), %rdi
addq $0xe020, %rdi # imm = 0xE020
movq -0x48(%rbp), %rsi
callq 0x63aa0
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
movq -0x48(%rbp), %rsi
callq 0x63ac0
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x63ae0
testb $0x1, %al
jne 0x6185b
jmp 0x61899
movq -0x58(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x61894
leaq 0x4b0044(%rip), %rax # 0x5118b0
movq (%rax), %rax
movq -0x58(%rbp), %rsi
addq $0x8, %rsi
movl $0x1, %edi
callq *%rax
movq -0x58(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x58(%rbp), %rax
movq $0x0, (%rax)
jmp 0x6192a
movq -0x58(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x618bc
leaq 0x4b0166(%rip), %rax # 0x511a10
movq (%rax), %rax
movq -0x58(%rbp), %rsi
addq $0x8, %rsi
movl $0x1, %edi
callq *%rax
leaq 0x4afe5d(%rip), %rax # 0x511720
movq (%rax), %rax
movq -0x58(%rbp), %rcx
movl 0x8(%rcx), %esi
movl $0x8892, %edi # imm = 0x8892
callq *%rax
leaq 0x4afec5(%rip), %rax # 0x5117a0
movq (%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x50(%rbp), %rdi
callq 0x63b20
shlq $0x3, %rax
movq %rax, -0x80(%rbp)
movq -0x50(%rbp), %rdi
callq 0x63b40
movq -0x80(%rbp), %rsi
movq %rax, %rdx
movq -0x78(%rbp), %rax
movl $0x8892, %edi # imm = 0x8892
movl $0x88e4, %ecx # imm = 0x88E4
callq *%rax
movq -0x50(%rbp), %rdi
callq 0x63b20
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, (%rax)
movb $0x0, -0x21(%rbp)
jmp 0x6192c
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x61811
testb $0x1, -0x21(%rbp)
je 0x61966
testb $0x1, -0x22(%rbp)
je 0x61966
movq -0x60(%rbp), %rax
leaq 0x4ac8dc(%rip), %rcx # 0x50e230
movq (%rcx), %rdi
addq $0x8, %rdi
movl 0xe050(%rax), %esi
callq 0x63b60
addq $0x80, %rsp
popq %rbp
retq
nop
| _ZN14GL_MeshingTask8finalizeEv:
push rbp
mov rbp, rsp
sub rsp, 80h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_60], rax
lea rax, _ZN7globals9dimensionE; globals::dimension
cmp qword ptr [rax], 0
jz short loc_61665
mov rax, [rbp+var_60]
lea rcx, _ZN7globals9dimensionE; globals::dimension
mov rdi, [rcx]
add rdi, 8
mov esi, [rax+0E050h]
call _ZNK4entt14basic_registryINS_6entityESaIS1_EE5validES1_; entt::basic_registry<entt::entity,std::allocator<entt::entity>>::valid(entt::entity)
test al, 1
jnz short loc_6166A
loc_61665:
jmp loc_61966
loc_6166A:
mov rax, [rbp+var_60]
lea rcx, _ZN7globals9dimensionE; globals::dimension
mov rdi, [rcx]
add rdi, 8
mov esi, [rax+0E050h]
call _ZN4entt14basic_registryINS_6entityESaIS1_EE18emplace_or_replaceI18ChunkMeshComponentJEEEDcS1_DpOT0_
mov rdi, [rbp+var_60]
mov [rbp+var_10], rax
add rdi, 0E038h
call _ZNKSt6vectorIS_ISt5arrayIjLm2EESaIS1_EESaIS3_EE4sizeEv; std::vector<std::vector<std::array<uint,2ul>>>::size(void)
mov rdi, [rbp+var_60]
mov [rbp+var_18], rax
add rdi, 0E020h
call _ZNKSt6vectorIS_ISt5arrayIjLm2EESaIS1_EESaIS3_EE4sizeEv; std::vector<std::vector<std::array<uint,2ul>>>::size(void)
mov [rbp+var_20], rax
mov [rbp+var_21], 1
mov [rbp+var_22], 1
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call _ZNSt6vectorI8ChunkVBOSaIS0_EE6resizeEm; std::vector<ChunkVBO>::resize(ulong)
mov rdi, [rbp+var_10]
add rdi, 18h
mov rsi, [rbp+var_20]
call _ZNSt6vectorI8ChunkVBOSaIS0_EE6resizeEm; std::vector<ChunkVBO>::resize(ulong)
mov [rbp+var_30], 0
loc_616E1:
mov rax, [rbp+var_30]
cmp rax, [rbp+var_18]
jnb loc_61809
mov rdi, [rbp+var_60]
add rdi, 0E038h
mov rsi, [rbp+var_30]
call _ZNSt6vectorIS_ISt5arrayIjLm2EESaIS1_EESaIS3_EEixEm; std::vector<std::vector<std::array<uint,2ul>>>::operator[](ulong)
mov [rbp+var_38], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_30]
call _ZNSt6vectorI8ChunkVBOSaIS0_EEixEm; std::vector<ChunkVBO>::operator[](ulong)
mov [rbp+var_40], rax
mov rdi, [rbp+var_38]
call _ZNKSt6vectorISt5arrayIjLm2EESaIS1_EE5emptyEv; std::vector<std::array<uint,2ul>>::empty(void)
test al, 1
jnz short loc_61727
jmp short loc_61765
loc_61727:
mov rax, [rbp+var_40]
cmp dword ptr [rax+8], 0
jz short loc_61760
lea rax, glad_glDeleteBuffers
mov rax, [rax]
mov rsi, [rbp+var_40]
add rsi, 8
mov edi, 1
call rax
mov rax, [rbp+var_40]
mov dword ptr [rax+8], 0
mov rax, [rbp+var_40]
mov qword ptr [rax], 0
loc_61760:
jmp loc_617F6
loc_61765:
mov rax, [rbp+var_40]
cmp dword ptr [rax+8], 0
jnz short loc_61788
lea rax, glad_glGenBuffers
mov rax, [rax]
mov rsi, [rbp+var_40]
add rsi, 8
mov edi, 1
call rax
loc_61788:
lea rax, glad_glBindBuffer
mov rax, [rax]
mov rcx, [rbp+var_40]
mov esi, [rcx+8]
mov edi, 8892h
call rax
lea rax, glad_glBufferData
mov rax, [rax]
mov [rbp+var_68], rax
mov rdi, [rbp+var_38]
call _ZNKSt6vectorISt5arrayIjLm2EESaIS1_EE4sizeEv; std::vector<std::array<uint,2ul>>::size(void)
shl rax, 3
mov [rbp+var_70], rax
mov rdi, [rbp+var_38]
call _ZNSt6vectorISt5arrayIjLm2EESaIS1_EE4dataEv; std::vector<std::array<uint,2ul>>::data(void)
mov rsi, [rbp+var_70]
mov rdx, rax
mov rax, [rbp+var_68]
mov edi, 8892h
mov ecx, 88E4h
call rax
mov rdi, [rbp+var_38]
call _ZNKSt6vectorISt5arrayIjLm2EESaIS1_EE4sizeEv; std::vector<std::array<uint,2ul>>::size(void)
mov rcx, rax
mov rax, [rbp+var_40]
mov [rax], rcx
mov [rbp+var_22], 0
loc_617F6:
jmp short $+2
loc_617F8:
mov rax, [rbp+var_30]
add rax, 1
mov [rbp+var_30], rax
jmp loc_616E1
loc_61809:
mov [rbp+var_48], 0
loc_61811:
mov rax, [rbp+var_48]
cmp rax, [rbp+var_20]
jnb loc_6193D
mov rdi, [rbp+var_60]
add rdi, 0E020h
mov rsi, [rbp+var_48]
call _ZNSt6vectorIS_ISt5arrayIjLm2EESaIS1_EESaIS3_EEixEm; std::vector<std::vector<std::array<uint,2ul>>>::operator[](ulong)
mov [rbp+var_50], rax
mov rdi, [rbp+var_10]
add rdi, 18h
mov rsi, [rbp+var_48]
call _ZNSt6vectorI8ChunkVBOSaIS0_EEixEm; std::vector<ChunkVBO>::operator[](ulong)
mov [rbp+var_58], rax
mov rdi, [rbp+var_50]
call _ZNKSt6vectorISt5arrayIjLm2EESaIS1_EE5emptyEv; std::vector<std::array<uint,2ul>>::empty(void)
test al, 1
jnz short loc_6185B
jmp short loc_61899
loc_6185B:
mov rax, [rbp+var_58]
cmp dword ptr [rax+8], 0
jz short loc_61894
lea rax, glad_glDeleteBuffers
mov rax, [rax]
mov rsi, [rbp+var_58]
add rsi, 8
mov edi, 1
call rax
mov rax, [rbp+var_58]
mov dword ptr [rax+8], 0
mov rax, [rbp+var_58]
mov qword ptr [rax], 0
loc_61894:
jmp loc_6192A
loc_61899:
mov rax, [rbp+var_58]
cmp dword ptr [rax+8], 0
jnz short loc_618BC
lea rax, glad_glGenBuffers
mov rax, [rax]
mov rsi, [rbp+var_58]
add rsi, 8
mov edi, 1
call rax
loc_618BC:
lea rax, glad_glBindBuffer
mov rax, [rax]
mov rcx, [rbp+var_58]
mov esi, [rcx+8]
mov edi, 8892h
call rax
lea rax, glad_glBufferData
mov rax, [rax]
mov [rbp+var_78], rax
mov rdi, [rbp+var_50]
call _ZNKSt6vectorISt5arrayIjLm2EESaIS1_EE4sizeEv; std::vector<std::array<uint,2ul>>::size(void)
shl rax, 3
mov [rbp+var_80], rax
mov rdi, [rbp+var_50]
call _ZNSt6vectorISt5arrayIjLm2EESaIS1_EE4dataEv; std::vector<std::array<uint,2ul>>::data(void)
mov rsi, [rbp+var_80]
mov rdx, rax
mov rax, [rbp+var_78]
mov edi, 8892h
mov ecx, 88E4h
call rax
mov rdi, [rbp+var_50]
call _ZNKSt6vectorISt5arrayIjLm2EESaIS1_EE4sizeEv; std::vector<std::array<uint,2ul>>::size(void)
mov rcx, rax
mov rax, [rbp+var_58]
mov [rax], rcx
mov [rbp+var_21], 0
loc_6192A:
jmp short $+2
loc_6192C:
mov rax, [rbp+var_48]
add rax, 1
mov [rbp+var_48], rax
jmp loc_61811
loc_6193D:
test [rbp+var_21], 1
jz short loc_61966
test [rbp+var_22], 1
jz short loc_61966
mov rax, [rbp+var_60]
lea rcx, _ZN7globals9dimensionE; globals::dimension
mov rdi, [rcx]
add rdi, 8
mov esi, [rax+0E050h]
call _ZN4entt14basic_registryINS_6entityESaIS1_EE6removeI18ChunkMeshComponentJEEEmS1_; entt::basic_registry<entt::entity,std::allocator<entt::entity>>::remove<ChunkMeshComponent>(entt::entity)
loc_61966:
add rsp, 80h
pop rbp
retn
| unsigned long long GL_MeshingTask::finalize(GL_MeshingTask *this)
{
unsigned long long result; // rax
long long v2; // rax
long long v3; // rax
long long v4; // [rsp+0h] [rbp-80h]
void ( *v5)(long long, long long, long long, long long); // [rsp+8h] [rbp-78h]
long long v6; // [rsp+10h] [rbp-70h]
void ( *v7)(long long, long long, long long, long long); // [rsp+18h] [rbp-68h]
long long v8; // [rsp+28h] [rbp-58h]
long long v9; // [rsp+30h] [rbp-50h]
unsigned long long j; // [rsp+38h] [rbp-48h]
long long v11; // [rsp+40h] [rbp-40h]
long long v12; // [rsp+48h] [rbp-38h]
unsigned long long i; // [rsp+50h] [rbp-30h]
char v14; // [rsp+5Eh] [rbp-22h]
char v15; // [rsp+5Fh] [rbp-21h]
unsigned long long v16; // [rsp+60h] [rbp-20h]
unsigned long long v17; // [rsp+68h] [rbp-18h]
long long v18; // [rsp+70h] [rbp-10h]
result = (unsigned long long)&globals::dimension;
if ( globals::dimension )
{
result = entt::basic_registry<entt::entity,std::allocator<entt::entity>>::valid(
globals::dimension + 8LL,
*((unsigned int *)this + 14356));
if ( (result & 1) != 0 )
{
v18 = entt::basic_registry<entt::entity,std::allocator<entt::entity>>::emplace_or_replace<ChunkMeshComponent>(
globals::dimension + 8LL,
*((unsigned int *)this + 14356));
v17 = std::vector<std::vector<std::array<unsigned int,2ul>>>::size((char *)this + 57400);
v16 = std::vector<std::vector<std::array<unsigned int,2ul>>>::size((char *)this + 57376);
v15 = 1;
v14 = 1;
std::vector<ChunkVBO>::resize(v18, v17);
std::vector<ChunkVBO>::resize(v18 + 24, v16);
for ( i = 0LL; i < v17; ++i )
{
v12 = std::vector<std::vector<std::array<unsigned int,2ul>>>::operator[]((char *)this + 57400, i);
v11 = std::vector<ChunkVBO>::operator[](v18, i);
if ( (std::vector<std::array<unsigned int,2ul>>::empty(v12) & 1) != 0 )
{
if ( *(_DWORD *)(v11 + 8) )
{
glad_glDeleteBuffers(1LL, v11 + 8);
*(_DWORD *)(v11 + 8) = 0;
*(_QWORD *)v11 = 0LL;
}
}
else
{
if ( !*(_DWORD *)(v11 + 8) )
glad_glGenBuffers(1LL, v11 + 8);
glad_glBindBuffer(34962LL, *(unsigned int *)(v11 + 8));
v7 = (void ( *)(long long, long long, long long, long long))glad_glBufferData;
v6 = 8 * std::vector<std::array<unsigned int,2ul>>::size(v12);
v2 = std::vector<std::array<unsigned int,2ul>>::data(v12);
v7(34962LL, v6, v2, 35044LL);
*(_QWORD *)v11 = std::vector<std::array<unsigned int,2ul>>::size(v12);
v14 = 0;
}
}
for ( j = 0LL; ; ++j )
{
result = j;
if ( j >= v16 )
break;
v9 = std::vector<std::vector<std::array<unsigned int,2ul>>>::operator[]((char *)this + 57376, j);
v8 = std::vector<ChunkVBO>::operator[](v18 + 24, j);
if ( (std::vector<std::array<unsigned int,2ul>>::empty(v9) & 1) != 0 )
{
if ( *(_DWORD *)(v8 + 8) )
{
glad_glDeleteBuffers(1LL, v8 + 8);
*(_DWORD *)(v8 + 8) = 0;
*(_QWORD *)v8 = 0LL;
}
}
else
{
if ( !*(_DWORD *)(v8 + 8) )
glad_glGenBuffers(1LL, v8 + 8);
glad_glBindBuffer(34962LL, *(unsigned int *)(v8 + 8));
v5 = (void ( *)(long long, long long, long long, long long))glad_glBufferData;
v4 = 8 * std::vector<std::array<unsigned int,2ul>>::size(v9);
v3 = std::vector<std::array<unsigned int,2ul>>::data(v9);
v5(34962LL, v4, v3, 35044LL);
*(_QWORD *)v8 = std::vector<std::array<unsigned int,2ul>>::size(v9);
v15 = 0;
}
}
if ( (v15 & 1) != 0 && (v14 & 1) != 0 )
return entt::basic_registry<entt::entity,std::allocator<entt::entity>>::remove<ChunkMeshComponent>(
globals::dimension + 8LL,
*((unsigned int *)this + 14356));
}
}
return result;
}
| finalize:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x60],RAX
LEA RAX,[0x60e230]
CMP qword ptr [RAX],0x0
JZ 0x00161665
MOV RAX,qword ptr [RBP + -0x60]
LEA RCX,[0x60e230]
MOV RDI,qword ptr [RCX]
ADD RDI,0x8
MOV ESI,dword ptr [RAX + 0xe050]
CALL 0x001638e0
TEST AL,0x1
JNZ 0x0016166a
LAB_00161665:
JMP 0x00161966
LAB_0016166a:
MOV RAX,qword ptr [RBP + -0x60]
LEA RCX,[0x60e230]
MOV RDI,qword ptr [RCX]
ADD RDI,0x8
MOV ESI,dword ptr [RAX + 0xe050]
CALL 0x00163940
MOV RDI,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x10],RAX
ADD RDI,0xe038
CALL 0x001639e0
MOV RDI,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x18],RAX
ADD RDI,0xe020
CALL 0x001639e0
MOV qword ptr [RBP + -0x20],RAX
MOV byte ptr [RBP + -0x21],0x1
MOV byte ptr [RBP + -0x22],0x1
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00163a10
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x18
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x00163a10
MOV qword ptr [RBP + -0x30],0x0
LAB_001616e1:
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x18]
JNC 0x00161809
MOV RDI,qword ptr [RBP + -0x60]
ADD RDI,0xe038
MOV RSI,qword ptr [RBP + -0x30]
CALL 0x00163aa0
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x30]
CALL 0x00163ac0
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x00163ae0
TEST AL,0x1
JNZ 0x00161727
JMP 0x00161765
LAB_00161727:
MOV RAX,qword ptr [RBP + -0x40]
CMP dword ptr [RAX + 0x8],0x0
JZ 0x00161760
LEA RAX,[0x6118b0]
MOV RAX,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x40]
ADD RSI,0x8
MOV EDI,0x1
CALL RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV dword ptr [RAX + 0x8],0x0
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RAX],0x0
LAB_00161760:
JMP 0x001617f6
LAB_00161765:
MOV RAX,qword ptr [RBP + -0x40]
CMP dword ptr [RAX + 0x8],0x0
JNZ 0x00161788
LEA RAX,[0x611a10]
MOV RAX,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x40]
ADD RSI,0x8
MOV EDI,0x1
CALL RAX
LAB_00161788:
LEA RAX,[0x611720]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x40]
MOV ESI,dword ptr [RCX + 0x8]
MOV EDI,0x8892
CALL RAX
LEA RAX,[0x6117a0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x68],RAX
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x00163b20
SHL RAX,0x3
MOV qword ptr [RBP + -0x70],RAX
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x00163b40
MOV RSI,qword ptr [RBP + -0x70]
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x68]
MOV EDI,0x8892
MOV ECX,0x88e4
CALL RAX
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x00163b20
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RAX],RCX
MOV byte ptr [RBP + -0x22],0x0
LAB_001617f6:
JMP 0x001617f8
LAB_001617f8:
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x1
MOV qword ptr [RBP + -0x30],RAX
JMP 0x001616e1
LAB_00161809:
MOV qword ptr [RBP + -0x48],0x0
LAB_00161811:
MOV RAX,qword ptr [RBP + -0x48]
CMP RAX,qword ptr [RBP + -0x20]
JNC 0x0016193d
MOV RDI,qword ptr [RBP + -0x60]
ADD RDI,0xe020
MOV RSI,qword ptr [RBP + -0x48]
CALL 0x00163aa0
MOV qword ptr [RBP + -0x50],RAX
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x18
MOV RSI,qword ptr [RBP + -0x48]
CALL 0x00163ac0
MOV qword ptr [RBP + -0x58],RAX
MOV RDI,qword ptr [RBP + -0x50]
CALL 0x00163ae0
TEST AL,0x1
JNZ 0x0016185b
JMP 0x00161899
LAB_0016185b:
MOV RAX,qword ptr [RBP + -0x58]
CMP dword ptr [RAX + 0x8],0x0
JZ 0x00161894
LEA RAX,[0x6118b0]
MOV RAX,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x58]
ADD RSI,0x8
MOV EDI,0x1
CALL RAX
MOV RAX,qword ptr [RBP + -0x58]
MOV dword ptr [RAX + 0x8],0x0
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RAX],0x0
LAB_00161894:
JMP 0x0016192a
LAB_00161899:
MOV RAX,qword ptr [RBP + -0x58]
CMP dword ptr [RAX + 0x8],0x0
JNZ 0x001618bc
LEA RAX,[0x611a10]
MOV RAX,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x58]
ADD RSI,0x8
MOV EDI,0x1
CALL RAX
LAB_001618bc:
LEA RAX,[0x611720]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x58]
MOV ESI,dword ptr [RCX + 0x8]
MOV EDI,0x8892
CALL RAX
LEA RAX,[0x6117a0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x78],RAX
MOV RDI,qword ptr [RBP + -0x50]
CALL 0x00163b20
SHL RAX,0x3
MOV qword ptr [RBP + -0x80],RAX
MOV RDI,qword ptr [RBP + -0x50]
CALL 0x00163b40
MOV RSI,qword ptr [RBP + -0x80]
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x78]
MOV EDI,0x8892
MOV ECX,0x88e4
CALL RAX
MOV RDI,qword ptr [RBP + -0x50]
CALL 0x00163b20
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RAX],RCX
MOV byte ptr [RBP + -0x21],0x0
LAB_0016192a:
JMP 0x0016192c
LAB_0016192c:
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,0x1
MOV qword ptr [RBP + -0x48],RAX
JMP 0x00161811
LAB_0016193d:
TEST byte ptr [RBP + -0x21],0x1
JZ 0x00161966
TEST byte ptr [RBP + -0x22],0x1
JZ 0x00161966
MOV RAX,qword ptr [RBP + -0x60]
LEA RCX,[0x60e230]
MOV RDI,qword ptr [RCX]
ADD RDI,0x8
MOV ESI,dword ptr [RAX + 0xe050]
CALL 0x00163b60
LAB_00161966:
ADD RSP,0x80
POP RBP
RET
|
/* GL_MeshingTask::finalize() */
void __thiscall GL_MeshingTask::finalize(GL_MeshingTask *this)
{
bool bVar1;
bool bVar2;
code *pcVar3;
ulong uVar4;
vector<ChunkVBO,std::allocator<ChunkVBO>> *this_00;
ulong uVar5;
vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>> *pvVar6;
int8 *puVar7;
ulong uVar8;
long lVar9;
int8 uVar10;
ulong local_50;
ulong local_38;
if ((globals::dimension != 0) &&
(uVar4 = entt::basic_registry<entt::entity,std::allocator<entt::entity>>::valid
((basic_registry<entt::entity,std::allocator<entt::entity>> *)
(globals::dimension + 8),*(int4 *)(this + 0xe050)), (uVar4 & 1) != 0)
) {
this_00 = (vector<ChunkVBO,std::allocator<ChunkVBO>> *)
entt::basic_registry<entt::entity,std::allocator<entt::entity>>::
emplace_or_replace<ChunkMeshComponent>
((basic_registry<entt::entity,std::allocator<entt::entity>> *)
(globals::dimension + 8),*(int4 *)(this + 0xe050));
uVar4 = std::
vector<std::vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>,std::allocator<std::vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>>>
::size((vector<std::vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>,std::allocator<std::vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>>>
*)(this + 0xe038));
uVar5 = std::
vector<std::vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>,std::allocator<std::vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>>>
::size((vector<std::vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>,std::allocator<std::vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>>>
*)(this + 0xe020));
bVar1 = true;
bVar2 = true;
std::vector<ChunkVBO,std::allocator<ChunkVBO>>::resize(this_00,uVar4);
std::vector<ChunkVBO,std::allocator<ChunkVBO>>::resize(this_00 + 0x18,uVar5);
for (local_38 = 0; local_38 < uVar4; local_38 = local_38 + 1) {
pvVar6 = (vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>> *)
std::
vector<std::vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>,std::allocator<std::vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>>>
::operator[]((vector<std::vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>,std::allocator<std::vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>>>
*)(this + 0xe038),local_38);
puVar7 = (int8 *)
std::vector<ChunkVBO,std::allocator<ChunkVBO>>::operator[](this_00,local_38);
uVar8 = std::vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>
::empty(pvVar6);
if ((uVar8 & 1) == 0) {
if (*(int *)(puVar7 + 1) == 0) {
(*glad_glGenBuffers)(1,puVar7 + 1);
}
(*glad_glBindBuffer)(0x8892,*(int4 *)(puVar7 + 1));
pcVar3 = glad_glBufferData;
lVar9 = std::
vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>::
size(pvVar6);
uVar10 = std::
vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>::
data(pvVar6);
(*pcVar3)(0x8892,lVar9 << 3,uVar10,0x88e4);
uVar10 = std::
vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>::
size(pvVar6);
*puVar7 = uVar10;
bVar2 = false;
}
else if (*(int *)(puVar7 + 1) != 0) {
(*glad_glDeleteBuffers)(1,puVar7 + 1);
*(int4 *)(puVar7 + 1) = 0;
*puVar7 = 0;
}
}
for (local_50 = 0; local_50 < uVar5; local_50 = local_50 + 1) {
pvVar6 = (vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>> *)
std::
vector<std::vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>,std::allocator<std::vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>>>
::operator[]((vector<std::vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>,std::allocator<std::vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>>>
*)(this + 0xe020),local_50);
puVar7 = (int8 *)
std::vector<ChunkVBO,std::allocator<ChunkVBO>>::operator[](this_00 + 0x18,local_50);
uVar4 = std::vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>
::empty(pvVar6);
if ((uVar4 & 1) == 0) {
if (*(int *)(puVar7 + 1) == 0) {
(*glad_glGenBuffers)(1,puVar7 + 1);
}
(*glad_glBindBuffer)(0x8892,*(int4 *)(puVar7 + 1));
pcVar3 = glad_glBufferData;
lVar9 = std::
vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>::
size(pvVar6);
uVar10 = std::
vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>::
data(pvVar6);
(*pcVar3)(0x8892,lVar9 << 3,uVar10,0x88e4);
uVar10 = std::
vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>::
size(pvVar6);
*puVar7 = uVar10;
bVar1 = false;
}
else if (*(int *)(puVar7 + 1) != 0) {
(*glad_glDeleteBuffers)(1,puVar7 + 1);
*(int4 *)(puVar7 + 1) = 0;
*puVar7 = 0;
}
}
if ((bVar1) && (bVar2)) {
entt::basic_registry<entt::entity,std::allocator<entt::entity>>::remove<ChunkMeshComponent>
((basic_registry<entt::entity,std::allocator<entt::entity>> *)
(globals::dimension + 8),*(int4 *)(this + 0xe050));
}
}
return;
}
| |
43,563 | nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2(char*, int&, int&, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp) | monkey531[P]llama/common/json.hpp | inline void grisu2(char* buf, int& len, int& decimal_exponent,
diyfp m_minus, diyfp v, diyfp m_plus)
{
JSON_ASSERT(m_plus.e == m_minus.e);
JSON_ASSERT(m_plus.e == v.e);
// --------(-----------------------+-----------------------)-------- (A)
// m- v m+
//
// --------------------(-----------+-----------------------)-------- (B)
// m- v m+
//
// First scale v (and m- and m+) such that the exponent is in the range
// [alpha, gamma].
const cached_power cached = get_cached_power_for_binary_exponent(m_plus.e);
const diyfp c_minus_k(cached.f, cached.e); // = c ~= 10^-k
// The exponent of the products is = v.e + c_minus_k.e + q and is in the range [alpha,gamma]
const diyfp w = diyfp::mul(v, c_minus_k);
const diyfp w_minus = diyfp::mul(m_minus, c_minus_k);
const diyfp w_plus = diyfp::mul(m_plus, c_minus_k);
// ----(---+---)---------------(---+---)---------------(---+---)----
// w- w w+
// = c*m- = c*v = c*m+
//
// diyfp::mul rounds its result and c_minus_k is approximated too. w, w- and
// w+ are now off by a small amount.
// In fact:
//
// w - v * 10^k < 1 ulp
//
// To account for this inaccuracy, add resp. subtract 1 ulp.
//
// --------+---[---------------(---+---)---------------]---+--------
// w- M- w M+ w+
//
// Now any number in [M-, M+] (bounds included) will round to w when input,
// regardless of how the input rounding algorithm breaks ties.
//
// And digit_gen generates the shortest possible such number in [M-, M+].
// Note that this does not mean that Grisu2 always generates the shortest
// possible number in the interval (m-, m+).
const diyfp M_minus(w_minus.f + 1, w_minus.e);
const diyfp M_plus (w_plus.f - 1, w_plus.e );
decimal_exponent = -cached.k; // = -(-k) = k
grisu2_digit_gen(buf, len, decimal_exponent, M_minus, w, M_plus);
} | O1 | cpp | nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2(char*, int&, int&, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rax
movq %rcx, 0x58(%rsp)
movl %r8d, 0x60(%rsp)
movl 0xc8(%rsp), %edi
cmpl %r8d, %edi
jne 0x7bf18
movq %rax, 0x20(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
leaq 0xb0(%rsp), %r13
cmpl 0x8(%r13), %edi
jne 0x7bf34
callq 0x7bfef
movq %rdx, %r12
leaq 0x68(%rsp), %r14
movq %rax, (%r14)
movl %r12d, 0x8(%r14)
movq %r13, %rdi
movq %r14, %rsi
callq 0x7c130
movq %rax, %r15
movl %edx, %ebx
leaq 0x58(%rsp), %rdi
movq %r14, %rsi
callq 0x7c130
movq %rax, %r13
movl %edx, %ebp
leaq 0xc0(%rsp), %rdi
movq %r14, %rsi
callq 0x7c130
incq %r13
decq %rax
shrq $0x20, %r12
negl %r12d
movq 0x30(%rsp), %rcx
movl %r12d, (%rcx)
movq %r15, 0x48(%rsp)
movl %ebx, 0x50(%rsp)
movq %rax, 0x38(%rsp)
movl %edx, 0x40(%rsp)
movups 0x38(%rsp), %xmm0
movups %xmm0, 0x10(%rsp)
movups 0x48(%rsp), %xmm0
movups %xmm0, (%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq %rcx, %rdx
movq %r13, %rcx
movl %ebp, %r8d
callq 0x7c18c
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2f738(%rip), %rdi # 0xab657
leaq 0x2deeb(%rip), %rdx # 0xa9e11
leaq 0x323c4(%rip), %rcx # 0xae2f1
movl $0x454b, %esi # imm = 0x454B
jmp 0x7bf4e
leaq 0x2f71c(%rip), %rdi # 0xab657
leaq 0x2decf(%rip), %rdx # 0xa9e11
leaq 0x323be(%rip), %rcx # 0xae307
movl $0x454c, %esi # imm = 0x454C
xorl %eax, %eax
callq 0x18ad0
nop
| _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl6grisu2EPcRiS4_NS2_5diyfpES5_S5_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 78h
mov rax, rdi
mov [rsp+0A8h+var_50], rcx
mov [rsp+0A8h+var_48], r8d
mov edi, dword ptr [rsp+0A8h+arg_18]; this
cmp edi, r8d
jnz loc_7BF18
mov [rsp+0A8h+var_88], rax
mov [rsp+0A8h+var_80], rsi
mov [rsp+0A8h+var_78], rdx
lea r13, [rsp+0A8h+arg_0]
cmp edi, [r13+8]
jnz loc_7BF34
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl36get_cached_power_for_binary_exponentEi; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::get_cached_power_for_binary_exponent(int)
mov r12, rdx
lea r14, [rsp+0A8h+var_40]
mov [r14], rax
mov [r14+8], r12d
mov rdi, r13
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl5diyfp3mulERKS3_S5_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&)
mov r15, rax
mov ebx, edx
lea rdi, [rsp+0A8h+var_50]
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl5diyfp3mulERKS3_S5_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&)
mov r13, rax
mov ebp, edx
lea rdi, [rsp+0A8h+arg_10]
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl5diyfp3mulERKS3_S5_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&)
inc r13
dec rax
shr r12, 20h
neg r12d
mov rcx, [rsp+0A8h+var_78]
mov [rcx], r12d
mov qword ptr [rsp+0A8h+var_60], r15
mov dword ptr [rsp+0A8h+var_60+8], ebx
mov qword ptr [rsp+0A8h+var_70], rax
mov dword ptr [rsp+0A8h+var_70+8], edx
movups xmm0, [rsp+0A8h+var_70]
movups [rsp+0A8h+var_98], xmm0
movups xmm0, [rsp+0A8h+var_60]
movups [rsp+0A8h+var_A8], xmm0
mov rdi, [rsp+0A8h+var_88]
mov rsi, [rsp+0A8h+var_80]
mov rdx, rcx
mov rcx, r13
mov r8d, ebp
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl16grisu2_digit_genEPcRiS4_NS2_5diyfpES5_S5_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_digit_gen(char *,int &,int &,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp)
add rsp, 78h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_7BF18:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aMPlusEMMinusE; "m_plus.e == m_minus.e"
mov esi, 454Bh
jmp short loc_7BF4E
loc_7BF34:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aMPlusEVE; "m_plus.e == v.e"
mov esi, 454Ch
loc_7BF4E:
xor eax, eax
call _ggml_abort
nop
| long long nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2(
int a1,
int a2,
_DWORD *a3,
long long a4,
int a5,
int a6,
char a7,
int a8,
char a9,
nlohmann::json_abi_v3_11_3::detail::dtoa_impl *a10)
{
long long cached_power_for_binary_exponent; // rax
int v11; // rdx^4
int v12; // r12^4
int v13; // edx
char v14; // r15
int v15; // edx
int v16; // ebx
int v17; // r13d
int v18; // edx
int v19; // ebp
char v20; // al
int v21; // edx
int v22; // r9d
long long v24; // rsi
long long v26; // [rsp+58h] [rbp-50h] BYREF
int v27; // [rsp+60h] [rbp-48h]
long long v28; // [rsp+68h] [rbp-40h] BYREF
int v29; // [rsp+70h] [rbp-38h]
v26 = a4;
v27 = a5;
if ( (_DWORD)a10 == a5 )
{
if ( (_DWORD)a10 == a8 )
{
cached_power_for_binary_exponent = nlohmann::json_abi_v3_11_3::detail::dtoa_impl::get_cached_power_for_binary_exponent(
(nlohmann::json_abi_v3_11_3::detail::dtoa_impl *)(unsigned int)a10,
a2);
v12 = v11;
v28 = cached_power_for_binary_exponent;
v29 = v13;
v14 = nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(&a7, &v28);
v16 = v15;
v17 = nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(&v26, &v28);
v19 = v18;
v20 = nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(&a9, &v28);
*a3 = -v12;
return nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_digit_gen(
a1,
a2,
(_DWORD)a3,
v17 + 1,
v19,
v22,
v14,
v16,
v20 - 1,
v21);
}
v24 = 17740LL;
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
17740LL,
"GGML_ASSERT(%s) failed",
"m_plus.e == v.e");
}
else
{
v24 = 17739LL;
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
17739LL,
"GGML_ASSERT(%s) failed",
"m_plus.e == m_minus.e");
}
return nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::normalize(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
v24);
}
| grisu2:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x78
MOV RAX,RDI
MOV qword ptr [RSP + 0x58],RCX
MOV dword ptr [RSP + 0x60],R8D
MOV EDI,dword ptr [RSP + 0xc8]
CMP EDI,R8D
JNZ 0x0017bf18
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x28],RSI
MOV qword ptr [RSP + 0x30],RDX
LEA R13,[RSP + 0xb0]
CMP EDI,dword ptr [R13 + 0x8]
JNZ 0x0017bf34
CALL 0x0017bfef
MOV R12,RDX
LEA R14,[RSP + 0x68]
MOV qword ptr [R14],RAX
MOV dword ptr [R14 + 0x8],R12D
MOV RDI,R13
MOV RSI,R14
CALL 0x0017c130
MOV R15,RAX
MOV EBX,EDX
LEA RDI,[RSP + 0x58]
MOV RSI,R14
CALL 0x0017c130
MOV R13,RAX
MOV EBP,EDX
LEA RDI,[RSP + 0xc0]
MOV RSI,R14
CALL 0x0017c130
INC R13
DEC RAX
SHR R12,0x20
NEG R12D
MOV RCX,qword ptr [RSP + 0x30]
MOV dword ptr [RCX],R12D
MOV qword ptr [RSP + 0x48],R15
MOV dword ptr [RSP + 0x50],EBX
MOV qword ptr [RSP + 0x38],RAX
MOV dword ptr [RSP + 0x40],EDX
MOVUPS XMM0,xmmword ptr [RSP + 0x38]
MOVUPS xmmword ptr [RSP + 0x10],XMM0
MOVUPS XMM0,xmmword ptr [RSP + 0x48]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,RCX
MOV RCX,R13
MOV R8D,EBP
CALL 0x0017c18c
ADD RSP,0x78
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0017bf18:
LEA RDI,[0x1ab657]
LEA RDX,[0x1a9e11]
LEA RCX,[0x1ae2f1]
MOV ESI,0x454b
JMP 0x0017bf4e
LAB_0017bf34:
LEA RDI,[0x1ab657]
LEA RDX,[0x1a9e11]
LEA RCX,[0x1ae307]
MOV ESI,0x454c
LAB_0017bf4e:
XOR EAX,EAX
CALL 0x00118ad0
|
/* nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2(char*, int&, int&,
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp,
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp,
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp) */
void nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2
(int8 param_1,int8 param_2,int *param_3,int8 param_4,int param_5,
int8 param_6,int8 param_7,int param_8,int8 param_9,int param_10)
{
int4 uVar1;
char *pcVar2;
int4 extraout_EDX;
int8 uVar3;
int1 auVar4 [16];
int1 auVar5 [12];
int1 auVar6 [12];
int4 uStack_64;
int8 local_50;
int local_48;
int8 local_40;
int4 local_38;
local_50 = param_4;
local_48 = param_5;
if (param_10 == param_5) {
if (param_10 == param_8) {
auVar4 = get_cached_power_for_binary_exponent(param_10);
local_40 = auVar4._0_8_;
local_38 = auVar4._8_4_;
uVar1 = diyfp::mul((diyfp *)¶m_7,(diyfp *)&local_40);
auVar5 = diyfp::mul((diyfp *)&local_50,(diyfp *)&local_40);
auVar6 = diyfp::mul((diyfp *)¶m_9,(diyfp *)&local_40);
*param_3 = -auVar4._12_4_;
grisu2_digit_gen(param_1,param_2,param_3,auVar5._0_8_ + 1,auVar5._8_4_,param_6,uVar1,
extraout_EDX,auVar6._0_8_ + -1,CONCAT44(uStack_64,auVar6._8_4_));
return;
}
pcVar2 = "m_plus.e == v.e";
uVar3 = 0x454c;
}
else {
pcVar2 = "m_plus.e == m_minus.e";
uVar3 = 0x454b;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",uVar3,
"GGML_ASSERT(%s) failed",pcVar2);
}
| |
43,564 | nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2(char*, int&, int&, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp) | monkey531[P]llama/common/json.hpp | inline void grisu2(char* buf, int& len, int& decimal_exponent,
diyfp m_minus, diyfp v, diyfp m_plus)
{
JSON_ASSERT(m_plus.e == m_minus.e);
JSON_ASSERT(m_plus.e == v.e);
// --------(-----------------------+-----------------------)-------- (A)
// m- v m+
//
// --------------------(-----------+-----------------------)-------- (B)
// m- v m+
//
// First scale v (and m- and m+) such that the exponent is in the range
// [alpha, gamma].
const cached_power cached = get_cached_power_for_binary_exponent(m_plus.e);
const diyfp c_minus_k(cached.f, cached.e); // = c ~= 10^-k
// The exponent of the products is = v.e + c_minus_k.e + q and is in the range [alpha,gamma]
const diyfp w = diyfp::mul(v, c_minus_k);
const diyfp w_minus = diyfp::mul(m_minus, c_minus_k);
const diyfp w_plus = diyfp::mul(m_plus, c_minus_k);
// ----(---+---)---------------(---+---)---------------(---+---)----
// w- w w+
// = c*m- = c*v = c*m+
//
// diyfp::mul rounds its result and c_minus_k is approximated too. w, w- and
// w+ are now off by a small amount.
// In fact:
//
// w - v * 10^k < 1 ulp
//
// To account for this inaccuracy, add resp. subtract 1 ulp.
//
// --------+---[---------------(---+---)---------------]---+--------
// w- M- w M+ w+
//
// Now any number in [M-, M+] (bounds included) will round to w when input,
// regardless of how the input rounding algorithm breaks ties.
//
// And digit_gen generates the shortest possible such number in [M-, M+].
// Note that this does not mean that Grisu2 always generates the shortest
// possible number in the interval (m-, m+).
const diyfp M_minus(w_minus.f + 1, w_minus.e);
const diyfp M_plus (w_plus.f - 1, w_plus.e );
decimal_exponent = -cached.k; // = -(-k) = k
grisu2_digit_gen(buf, len, decimal_exponent, M_minus, w, M_plus);
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2(char*, int&, int&, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, 0x58(%rsp)
movl %r8d, 0x60(%rsp)
cmpl %r8d, 0xc8(%rsp)
jne 0x7accc
movq %rdi, 0x20(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
leaq 0xb0(%rsp), %r13
cmpl %r8d, 0x8(%r13)
jne 0x7ace8
movl %r8d, %edi
callq 0x7ada3
movq %rdx, %r12
leaq 0x68(%rsp), %r14
movq %rax, (%r14)
movl %r12d, 0x8(%r14)
movq %r13, %rdi
movq %r14, %rsi
callq 0x7aee4
movq %rax, %r15
movl %edx, %ebx
leaq 0x58(%rsp), %rdi
movq %r14, %rsi
callq 0x7aee4
movq %rax, %r13
movl %edx, %ebp
leaq 0xc0(%rsp), %rdi
movq %r14, %rsi
callq 0x7aee4
incq %r13
decq %rax
shrq $0x20, %r12
negl %r12d
movq 0x30(%rsp), %rcx
movl %r12d, (%rcx)
movq %r15, 0x48(%rsp)
movl %ebx, 0x50(%rsp)
movq %rax, 0x38(%rsp)
movl %edx, 0x40(%rsp)
movups 0x38(%rsp), %xmm0
movups %xmm0, 0x10(%rsp)
movups 0x48(%rsp), %xmm0
movups %xmm0, (%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq %rcx, %rdx
movq %r13, %rcx
movl %ebp, %r8d
callq 0x7af40
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2e974(%rip), %rdi # 0xa9647
leaq 0x2d127(%rip), %rdx # 0xa7e01
leaq 0x31600(%rip), %rcx # 0xac2e1
movl $0x454b, %esi # imm = 0x454B
jmp 0x7ad02
leaq 0x2e958(%rip), %rdi # 0xa9647
leaq 0x2d10b(%rip), %rdx # 0xa7e01
leaq 0x315fa(%rip), %rcx # 0xac2f7
movl $0x454c, %esi # imm = 0x454C
xorl %eax, %eax
callq 0x18ad0
nop
| _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl6grisu2EPcRiS4_NS2_5diyfpES5_S5_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 78h
mov [rsp+0A8h+var_50], rcx
mov [rsp+0A8h+var_48], r8d
cmp [rsp+0A8h+arg_18], r8d
jnz loc_7ACCC
mov [rsp+0A8h+var_88], rdi
mov [rsp+0A8h+var_80], rsi
mov [rsp+0A8h+var_78], rdx
lea r13, [rsp+0A8h+arg_0]
cmp [r13+8], r8d
jnz loc_7ACE8
mov edi, r8d; this
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl36get_cached_power_for_binary_exponentEi; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::get_cached_power_for_binary_exponent(int)
mov r12, rdx
lea r14, [rsp+0A8h+var_40]
mov [r14], rax
mov [r14+8], r12d
mov rdi, r13
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl5diyfp3mulERKS3_S5_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&)
mov r15, rax
mov ebx, edx
lea rdi, [rsp+0A8h+var_50]
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl5diyfp3mulERKS3_S5_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&)
mov r13, rax
mov ebp, edx
lea rdi, [rsp+0A8h+arg_10]
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl5diyfp3mulERKS3_S5_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&)
inc r13
dec rax
shr r12, 20h
neg r12d
mov rcx, [rsp+0A8h+var_78]
mov [rcx], r12d
mov qword ptr [rsp+0A8h+var_60], r15
mov dword ptr [rsp+0A8h+var_60+8], ebx
mov qword ptr [rsp+0A8h+var_70], rax
mov dword ptr [rsp+0A8h+var_70+8], edx
movups xmm0, xmmword ptr [rsp+0A8h+var_70]
movups xmmword ptr [rsp+0A8h+var_98], xmm0; char
movups xmm0, xmmword ptr [rsp+0A8h+var_60]
movups xmmword ptr [rsp+0A8h+var_A8], xmm0; char
mov rdi, [rsp+0A8h+var_88]; this
mov rsi, [rsp+0A8h+var_80]
mov rdx, rcx
mov rcx, r13
mov r8d, ebp
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl16grisu2_digit_genEPcRiS4_NS2_5diyfpES5_S5_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_digit_gen(char *,int &,int &,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp)
add rsp, 78h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_7ACCC:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aMPlusEMMinusE; "m_plus.e == m_minus.e"
mov esi, 454Bh
jmp short loc_7AD02
loc_7ACE8:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aMPlusEVE; "m_plus.e == v.e"
mov esi, 454Ch
loc_7AD02:
xor eax, eax
call _ggml_abort
nop
| long long nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2(
nlohmann::json_abi_v3_11_3::detail::dtoa_impl *a1,
int a2,
_DWORD *a3,
long long a4,
unsigned int a5,
long long a6,
char a7,
int a8,
char a9,
int a10)
{
long long cached_power_for_binary_exponent; // rax
int v11; // rdx^4
int v12; // r12^4
int v13; // edx
char v14; // r15
int v15; // edx
int v16; // ebx
char v17; // al
int v18; // edx
long long v20; // rsi
long long v22; // [rsp+58h] [rbp-50h] BYREF
unsigned int v23; // [rsp+60h] [rbp-48h]
long long v24; // [rsp+68h] [rbp-40h] BYREF
int v25; // [rsp+70h] [rbp-38h]
v22 = a4;
v23 = a5;
if ( a10 == a5 )
{
if ( a8 == a5 )
{
cached_power_for_binary_exponent = nlohmann::json_abi_v3_11_3::detail::dtoa_impl::get_cached_power_for_binary_exponent(
(nlohmann::json_abi_v3_11_3::detail::dtoa_impl *)a5,
a2);
v12 = v11;
v24 = cached_power_for_binary_exponent;
v25 = v13;
v14 = nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(&a7, &v24);
v16 = v15;
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(&v22, &v24);
v17 = nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(&a9, &v24);
*a3 = -v12;
return nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_digit_gen(a1, v14, v16, v17 - 1, v18);
}
v20 = 17740LL;
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
17740LL,
"GGML_ASSERT(%s) failed",
"m_plus.e == v.e");
}
else
{
v20 = 17739LL;
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
17739LL,
"GGML_ASSERT(%s) failed",
"m_plus.e == m_minus.e");
}
return nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::normalize(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
v20);
}
| grisu2:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x78
MOV qword ptr [RSP + 0x58],RCX
MOV dword ptr [RSP + 0x60],R8D
CMP dword ptr [RSP + 0xc8],R8D
JNZ 0x0017accc
MOV qword ptr [RSP + 0x20],RDI
MOV qword ptr [RSP + 0x28],RSI
MOV qword ptr [RSP + 0x30],RDX
LEA R13,[RSP + 0xb0]
CMP dword ptr [R13 + 0x8],R8D
JNZ 0x0017ace8
MOV EDI,R8D
CALL 0x0017ada3
MOV R12,RDX
LEA R14,[RSP + 0x68]
MOV qword ptr [R14],RAX
MOV dword ptr [R14 + 0x8],R12D
MOV RDI,R13
MOV RSI,R14
CALL 0x0017aee4
MOV R15,RAX
MOV EBX,EDX
LEA RDI,[RSP + 0x58]
MOV RSI,R14
CALL 0x0017aee4
MOV R13,RAX
MOV EBP,EDX
LEA RDI,[RSP + 0xc0]
MOV RSI,R14
CALL 0x0017aee4
INC R13
DEC RAX
SHR R12,0x20
NEG R12D
MOV RCX,qword ptr [RSP + 0x30]
MOV dword ptr [RCX],R12D
MOV qword ptr [RSP + 0x48],R15
MOV dword ptr [RSP + 0x50],EBX
MOV qword ptr [RSP + 0x38],RAX
MOV dword ptr [RSP + 0x40],EDX
MOVUPS XMM0,xmmword ptr [RSP + 0x38]
MOVUPS xmmword ptr [RSP + 0x10],XMM0
MOVUPS XMM0,xmmword ptr [RSP + 0x48]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,RCX
MOV RCX,R13
MOV R8D,EBP
CALL 0x0017af40
ADD RSP,0x78
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0017accc:
LEA RDI,[0x1a9647]
LEA RDX,[0x1a7e01]
LEA RCX,[0x1ac2e1]
MOV ESI,0x454b
JMP 0x0017ad02
LAB_0017ace8:
LEA RDI,[0x1a9647]
LEA RDX,[0x1a7e01]
LEA RCX,[0x1ac2f7]
MOV ESI,0x454c
LAB_0017ad02:
XOR EAX,EAX
CALL 0x00118ad0
|
/* nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2(char*, int&, int&,
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp,
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp,
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp) */
void nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2
(int8 param_1,int8 param_2,int *param_3,int8 param_4,int param_5,
int8 param_6,int8 param_7,int param_8,int8 param_9,int param_10)
{
int4 uVar1;
char *pcVar2;
int4 extraout_EDX;
int8 uVar3;
int1 auVar4 [16];
int1 auVar5 [12];
int1 auVar6 [12];
int4 uStack_64;
int8 local_50;
int local_48;
int8 local_40;
int4 local_38;
local_50 = param_4;
local_48 = param_5;
if (param_10 == param_5) {
if (param_8 == param_5) {
auVar4 = get_cached_power_for_binary_exponent(param_5);
local_40 = auVar4._0_8_;
local_38 = auVar4._8_4_;
uVar1 = diyfp::mul((diyfp *)¶m_7,(diyfp *)&local_40);
auVar5 = diyfp::mul((diyfp *)&local_50,(diyfp *)&local_40);
auVar6 = diyfp::mul((diyfp *)¶m_9,(diyfp *)&local_40);
*param_3 = -auVar4._12_4_;
grisu2_digit_gen(param_1,param_2,param_3,auVar5._0_8_ + 1,auVar5._8_4_,param_6,uVar1,
extraout_EDX,auVar6._0_8_ + -1,CONCAT44(uStack_64,auVar6._8_4_));
return;
}
pcVar2 = "m_plus.e == v.e";
uVar3 = 0x454c;
}
else {
pcVar2 = "m_plus.e == m_minus.e";
uVar3 = 0x454b;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",uVar3,
"GGML_ASSERT(%s) failed",pcVar2);
}
| |
43,565 | Field_medium::val_int() | eloqsql/sql/field.cc | longlong Field_medium::val_int(void)
{
DBUG_ASSERT(marked_for_read());
long j= unsigned_flag ? (long) uint3korr(ptr) : sint3korr(ptr);
return (longlong) j;
} | O0 | cpp | Field_medium::val_int():
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x8b2ad2
movq -0x18(%rbp), %rax
testb $0x1, 0xcb(%rax)
je 0x8b2b0c
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rax
movzbl (%rax), %eax
movq 0x8(%rcx), %rdx
movzbl 0x1(%rdx), %edx
shll $0x8, %edx
orl %edx, %eax
movq 0x8(%rcx), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x8b2b82
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movzbl 0x2(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x8b2b51
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rax
movzbl 0x2(%rax), %eax
shll $0x10, %eax
orl $0xff000000, %eax # imm = 0xFF000000
movq 0x8(%rcx), %rdx
movzbl 0x1(%rdx), %edx
shll $0x8, %edx
orl %edx, %eax
movq 0x8(%rcx), %rcx
movzbl (%rcx), %ecx
orl %ecx, %eax
movl %eax, -0x24(%rbp)
jmp 0x8b2b79
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rax
movzbl 0x2(%rax), %eax
shll $0x10, %eax
movq 0x8(%rcx), %rdx
movzbl 0x1(%rdx), %edx
shll $0x8, %edx
orl %edx, %eax
movq 0x8(%rcx), %rcx
movzbl (%rcx), %ecx
orl %ecx, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cltq
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
| _ZN12Field_medium7val_intEv:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_18], rax
jmp short $+2
loc_8B2AD2:
mov rax, [rbp+var_18]
test byte ptr [rax+0CBh], 1
jz short loc_8B2B0C
mov rcx, [rbp+var_18]
mov rax, [rcx+8]
movzx eax, byte ptr [rax]
mov rdx, [rcx+8]
movzx edx, byte ptr [rdx+1]
shl edx, 8
or eax, edx
mov rcx, [rcx+8]
movzx ecx, byte ptr [rcx+2]
shl ecx, 10h
or eax, ecx
mov eax, eax
mov [rbp+var_20], rax
jmp short loc_8B2B82
loc_8B2B0C:
mov rax, [rbp+var_18]
mov rax, [rax+8]
movzx eax, byte ptr [rax+2]
and eax, 80h
cmp eax, 0
jz short loc_8B2B51
mov rcx, [rbp+var_18]
mov rax, [rcx+8]
movzx eax, byte ptr [rax+2]
shl eax, 10h
or eax, 0FF000000h
mov rdx, [rcx+8]
movzx edx, byte ptr [rdx+1]
shl edx, 8
or eax, edx
mov rcx, [rcx+8]
movzx ecx, byte ptr [rcx]
or eax, ecx
mov [rbp+var_24], eax
jmp short loc_8B2B79
loc_8B2B51:
mov rcx, [rbp+var_18]
mov rax, [rcx+8]
movzx eax, byte ptr [rax+2]
shl eax, 10h
mov rdx, [rcx+8]
movzx edx, byte ptr [rdx+1]
shl edx, 8
or eax, edx
mov rcx, [rcx+8]
movzx ecx, byte ptr [rcx]
or eax, ecx
mov [rbp+var_24], eax
loc_8B2B79:
mov eax, [rbp+var_24]
cdqe
mov [rbp+var_20], rax
loc_8B2B82:
mov rax, [rbp+var_20]
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
pop rbp
retn
| long long Field_medium::val_int(Field_medium *this)
{
if ( (*((_BYTE *)this + 203) & 1) != 0 )
return (*(unsigned __int8 *)(*((_QWORD *)this + 1) + 2LL) << 16) | (unsigned int)**((unsigned __int16 **)this + 1);
if ( (*(_BYTE *)(*((_QWORD *)this + 1) + 2LL) & 0x80) != 0 )
return (int)(**((unsigned __int8 **)this + 1) | (*(unsigned __int8 *)(*((_QWORD *)this + 1) + 1LL) << 8) | (*(unsigned __int8 *)(*((_QWORD *)this + 1) + 2LL) << 16) | 0xFF000000);
else
return **((unsigned __int8 **)this + 1) | (*(unsigned __int8 *)(*((_QWORD *)this + 1) + 1LL) << 8) | (*(unsigned __int8 *)(*((_QWORD *)this + 1) + 2LL) << 16);
}
| Key_part_spec_init_primary:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x18]
MOV ECX,dword ptr [RAX + 0x9c]
MOV RAX,qword ptr [RBP + -0x10]
IMUL ECX,dword ptr [RAX + 0x10]
MOV dword ptr [RAX + 0x10],ECX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x008ca030
AND AL,0x1
ADD RSP,0x20
POP RBP
RET
|
/* Type_handler_blob_common::Key_part_spec_init_primary(Key_part_spec*, Column_definition const&,
handler const*) const */
ulong __thiscall
Type_handler_blob_common::Key_part_spec_init_primary
(Type_handler_blob_common *this,Key_part_spec *param_1,Column_definition *param_2,
handler *param_3)
{
ulong uVar1;
*(int *)(param_1 + 0x10) = *(int *)(*(long *)(param_2 + 0x18) + 0x9c) * *(int *)(param_1 + 0x10);
uVar1 = Key_part_spec::check_primary_key_for_blob(param_1,param_3);
return uVar1 & 0xffffffffffffff01;
}
| |
43,566 | mysql_set_character_set_start_internal | eloqsql/libmariadb/libmariadb/mariadb_async.c | static void
mysql_set_character_set_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_set_character_set,
(parms->mysql, parms->csname),
parms->mysql,
int,
r_int)
} | O3 | c | mysql_set_character_set_start_internal:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq 0x8(%rdi), %rsi
movq 0x480(%rax), %rcx
movq 0x28(%rcx), %rbx
movq %rax, %rdi
callq 0x19e6f
movl %eax, 0x8(%rbx)
movl $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| mysql_set_character_set_start_internal:
push rbp
mov rbp, rsp
push rbx
push rax
mov rax, [rdi]
mov rsi, [rdi+8]
mov rcx, [rax+480h]
mov rbx, [rcx+28h]
mov rdi, rax
call mysql_set_character_set
mov [rbx+8], eax
mov dword ptr [rbx], 0
add rsp, 8
pop rbx
pop rbp
retn
| long long mysql_set_character_set_start_internal(long long *a1)
{
_DWORD *v1; // rbx
long long result; // rax
v1 = *(_DWORD **)(*(_QWORD *)(*a1 + 1152) + 40LL);
result = mysql_set_character_set(*a1, a1[1]);
v1[2] = result;
*v1 = 0;
return result;
}
| mysql_set_character_set_start_internal:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RAX,qword ptr [RDI]
MOV RSI,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RAX + 0x480]
MOV RBX,qword ptr [RCX + 0x28]
MOV RDI,RAX
CALL 0x00119e6f
MOV dword ptr [RBX + 0x8],EAX
MOV dword ptr [RBX],0x0
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void mysql_set_character_set_start_internal(long *param_1)
{
int4 *puVar1;
int4 uVar2;
puVar1 = *(int4 **)(*(long *)(*param_1 + 0x480) + 0x28);
uVar2 = mysql_set_character_set(*param_1,param_1[1]);
puVar1[2] = uVar2;
*puVar1 = 0;
return;
}
| |
43,567 | js_atomics_op | bluesky950520[P]quickjs/quickjs.c | static JSValue js_atomics_op(JSContext *ctx,
JSValue this_obj,
int argc, JSValue *argv, int op)
{
int size_log2;
uint64_t v, a, rep_val;
void *ptr;
JSValue ret;
JSClassID class_id;
JSArrayBuffer *abuf;
ptr = js_atomics_get_ptr(ctx, &abuf, &size_log2, &class_id,
argv[0], argv[1], 0);
if (!ptr)
return JS_EXCEPTION;
rep_val = 0;
if (op == ATOMICS_OP_LOAD) {
v = 0;
} else {
if (size_log2 == 3) {
int64_t v64;
if (JS_ToBigInt64(ctx, &v64, argv[2]))
return JS_EXCEPTION;
v = v64;
if (op == ATOMICS_OP_COMPARE_EXCHANGE) {
if (JS_ToBigInt64(ctx, &v64, argv[3]))
return JS_EXCEPTION;
rep_val = v64;
}
} else {
uint32_t v32;
if (JS_ToUint32(ctx, &v32, argv[2]))
return JS_EXCEPTION;
v = v32;
if (op == ATOMICS_OP_COMPARE_EXCHANGE) {
if (JS_ToUint32(ctx, &v32, argv[3]))
return JS_EXCEPTION;
rep_val = v32;
}
}
if (abuf->detached)
return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
}
switch(op | (size_log2 << 3)) {
#define OP(op_name, func_name) \
case ATOMICS_OP_ ## op_name | (0 << 3): \
a = func_name((_Atomic uint8_t *)ptr, v); \
break; \
case ATOMICS_OP_ ## op_name | (1 << 3): \
a = func_name((_Atomic uint16_t *)ptr, v); \
break; \
case ATOMICS_OP_ ## op_name | (2 << 3): \
a = func_name((_Atomic uint32_t *)ptr, v); \
break; \
case ATOMICS_OP_ ## op_name | (3 << 3): \
a = func_name((_Atomic uint64_t *)ptr, v); \
break;
OP(ADD, atomic_fetch_add)
OP(AND, atomic_fetch_and)
OP(OR, atomic_fetch_or)
OP(SUB, atomic_fetch_sub)
OP(XOR, atomic_fetch_xor)
OP(EXCHANGE, atomic_exchange)
#undef OP
case ATOMICS_OP_LOAD | (0 << 3):
a = atomic_load((_Atomic uint8_t *)ptr);
break;
case ATOMICS_OP_LOAD | (1 << 3):
a = atomic_load((_Atomic uint16_t *)ptr);
break;
case ATOMICS_OP_LOAD | (2 << 3):
a = atomic_load((_Atomic uint32_t *)ptr);
break;
case ATOMICS_OP_LOAD | (3 << 3):
a = atomic_load((_Atomic uint64_t *)ptr);
break;
case ATOMICS_OP_COMPARE_EXCHANGE | (0 << 3):
{
uint8_t v1 = v;
atomic_compare_exchange_strong((_Atomic uint8_t *)ptr, &v1, rep_val);
a = v1;
}
break;
case ATOMICS_OP_COMPARE_EXCHANGE | (1 << 3):
{
uint16_t v1 = v;
atomic_compare_exchange_strong((_Atomic uint16_t *)ptr, &v1, rep_val);
a = v1;
}
break;
case ATOMICS_OP_COMPARE_EXCHANGE | (2 << 3):
{
uint32_t v1 = v;
atomic_compare_exchange_strong((_Atomic uint32_t *)ptr, &v1, rep_val);
a = v1;
}
break;
case ATOMICS_OP_COMPARE_EXCHANGE | (3 << 3):
{
uint64_t v1 = v;
atomic_compare_exchange_strong((_Atomic uint64_t *)ptr, &v1, rep_val);
a = v1;
}
break;
default:
abort();
}
switch(class_id) {
case JS_CLASS_INT8_ARRAY:
a = (int8_t)a;
goto done;
case JS_CLASS_UINT8_ARRAY:
a = (uint8_t)a;
goto done;
case JS_CLASS_INT16_ARRAY:
a = (int16_t)a;
goto done;
case JS_CLASS_UINT16_ARRAY:
a = (uint16_t)a;
goto done;
case JS_CLASS_INT32_ARRAY:
done:
ret = js_int32(a);
break;
case JS_CLASS_UINT32_ARRAY:
ret = js_uint32(a);
break;
case JS_CLASS_BIG_INT64_ARRAY:
ret = JS_NewBigInt64(ctx, a);
break;
case JS_CLASS_BIG_UINT64_ARRAY:
ret = JS_NewBigUint64(ctx, a);
break;
default:
abort();
}
return ret;
} | O2 | c | js_atomics_op:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, %ebp
movq %r8, %r13
movq %rdi, %rbx
movq (%r8), %r8
movq 0x8(%r13), %r9
movupd 0x10(%r13), %xmm0
movupd %xmm0, (%rsp)
andl $0x0, 0x10(%rsp)
leaq 0x30(%rsp), %rsi
leaq 0x28(%rsp), %rdx
leaq 0x2c(%rsp), %rcx
callq 0x6f018
pushq $0x6
popq %r12
testq %rax, %rax
je 0x6e700
movq %rax, %r14
cmpl $0x7, %ebp
jne 0x6e657
xorl %ecx, %ecx
xorl %r15d, %r15d
movl 0x28(%rsp), %eax
shll $0x3, %eax
orl %ebp, %eax
cmpl $0x1f, %eax
ja 0x6e913
leaq 0x1928a(%rip), %rdx # 0x878c4
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movb (%r14), %al
movl %eax, %ecx
andb %r15b, %cl
lock
cmpxchgb %cl, (%r14)
jne 0x6e646
jmp 0x6e7fd
cmpl $0x3, 0x28(%rsp)
jne 0x6e6a5
movq 0x20(%r13), %rdx
movq 0x28(%r13), %rcx
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x25177
testl %eax, %eax
jne 0x6e700
movq 0x20(%rsp), %r15
cmpl $0x6, %ebp
jne 0x6e6e7
movq 0x30(%r13), %rdx
movq 0x38(%r13), %rcx
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x25177
testl %eax, %eax
jne 0x6e700
movq 0x20(%rsp), %rcx
jmp 0x6e6e9
movq 0x20(%r13), %rdx
movq 0x28(%r13), %rcx
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x25187
testl %eax, %eax
jne 0x6e700
movl 0x20(%rsp), %r15d
cmpl $0x6, %ebp
jne 0x6e6e7
movq 0x30(%r13), %rdx
movq 0x38(%r13), %rcx
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x25187
testl %eax, %eax
jne 0x6e700
movl 0x20(%rsp), %ecx
jmp 0x6e6e9
xorl %ecx, %ecx
movq 0x30(%rsp), %rax
cmpb $0x0, 0x8(%rax)
je 0x6e621
movq %rbx, %rdi
callq 0x35cd1
xorl %eax, %eax
xorl %ecx, %ecx
jmp 0x6e8e9
negq %r15
lock
xaddq %r15, (%r14)
jmp 0x6e863
movl %r15d, %eax
lock cmpxchgw %cx, (%r14)
jmp 0x6e799
negl %r15d
lock xaddw %r15w, (%r14)
jmp 0x6e7ef
movb (%r14), %al
movl %eax, %ecx
xorb %r15b, %cl
lock
cmpxchgb %cl, (%r14)
jne 0x6e732
jmp 0x6e7fd
movzwl (%r14), %eax
movl %eax, %ecx
xorl %r15d, %ecx
lock cmpxchgw %cx, (%r14)
jne 0x6e747
jmp 0x6e824
movzwl (%r14), %eax
movl %eax, %ecx
andl %r15d, %ecx
lock cmpxchgw %cx, (%r14)
jne 0x6e75d
jmp 0x6e824
movq (%r14), %rax
movq %rax, %rcx
andq %r15, %rcx
lock
cmpxchgq %rcx, (%r14)
jne 0x6e772
jmp 0x6e866
movb (%r14), %al
movl %eax, %ecx
orb %r15b, %cl
lock
cmpxchgb %cl, (%r14)
jne 0x6e787
jmp 0x6e7fd
movzwl (%r14), %eax
movzwl %ax, %eax
jmp 0x6e866
negb %r15b
lock
xaddb %r15b, (%r14)
jmp 0x6e7dd
movb (%r14), %al
jmp 0x6e7fd
movq (%r14), %rax
jmp 0x6e866
movl (%r14), %eax
movl %eax, %ecx
andl %r15d, %ecx
lock
cmpxchgl %ecx, (%r14)
jne 0x6e7bb
jmp 0x6e83b
movl (%r14), %eax
movl %eax, %ecx
xorl %r15d, %ecx
lock
cmpxchgl %ecx, (%r14)
jne 0x6e7cc
jmp 0x6e83b
xchgb %r15b, (%r14)
movzbl %r15b, %eax
jmp 0x6e866
xchgl %r15d, (%r14)
jmp 0x6e863
xchgw %r15w, (%r14)
movzwl %r15w, %eax
jmp 0x6e866
movl %r15d, %eax
lock
cmpxchgb %cl, (%r14)
movzbl %al, %eax
jmp 0x6e866
movl (%r14), %eax
movl %eax, %ecx
orl %r15d, %ecx
lock
cmpxchgl %ecx, (%r14)
jne 0x6e805
jmp 0x6e83b
movzwl (%r14), %eax
movl %eax, %ecx
orl %r15d, %ecx
lock cmpxchgw %cx, (%r14)
jne 0x6e817
movzwl %ax, %eax
jmp 0x6e866
movq %r15, %rax
lock
cmpxchgq %rcx, (%r14)
jmp 0x6e866
movl %r15d, %eax
lock
cmpxchgl %ecx, (%r14)
movl %eax, %eax
jmp 0x6e866
negl %r15d
lock
xaddl %r15d, (%r14)
jmp 0x6e863
movl (%r14), %eax
jmp 0x6e866
movq (%r14), %rax
movq %rax, %rcx
xorq %r15, %rcx
lock
cmpxchgq %rcx, (%r14)
jne 0x6e851
jmp 0x6e866
xchgq %r15, (%r14)
movq %r15, %rax
movl 0x2c(%rsp), %ecx
addl $-0x16, %ecx
cmpl $0x7, %ecx
ja 0x6e913
leaq 0x190c7(%rip), %rdx # 0x87944
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movsbq %al, %rax
jmp 0x6e89a
movzwl %ax, %eax
jmp 0x6e89a
movzbl %al, %eax
jmp 0x6e89a
movswq %ax, %rax
movl %eax, %eax
xorl %r12d, %r12d
jmp 0x6e8da
movq %rbx, %rdi
movq %rax, %rsi
callq 0x259aa
jmp 0x6e8d7
xorl %ecx, %ecx
movl %eax, %edx
cvtsi2sd %rdx, %xmm0
testl %eax, %eax
movq %xmm0, %rax
cmovnsq %rdx, %rax
pushq $0x7
popq %r12
cmovnsq %rcx, %r12
jmp 0x6e8da
movq %rbx, %rdi
movq %rax, %rsi
callq 0x25906
movq %rdx, %r12
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rax, %rcx
movl %eax, %eax
orq %rcx, %rax
movq %r12, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r14), %rax
movq %rax, %rcx
orq %r15, %rcx
lock
cmpxchgq %rcx, (%r14)
jne 0x6e901
jmp 0x6e866
callq 0xe090
| js_atomics_op:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov ebp, r9d
mov r13, r8
mov rbx, rdi
mov r8, [r8]
mov r9, [r13+8]
movupd xmm0, xmmword ptr [r13+10h]
movupd [rsp+68h+var_68], xmm0
and [rsp+68h+var_58], 0
lea rsi, [rsp+68h+var_38]
lea rdx, [rsp+68h+var_40]
lea rcx, [rsp+68h+var_3C]
call js_atomics_get_ptr
push 6
pop r12
test rax, rax
jz loc_6E700
mov r14, rax
cmp ebp, 7
jnz short loc_6E657
xor ecx, ecx
xor r15d, r15d
loc_6E621:
mov eax, [rsp+68h+var_40]
shl eax, 3
or eax, ebp
cmp eax, 1Fh; switch 32 cases
ja def_6E641; jumptable 000000000006E641 default case
lea rdx, jpt_6E641
movsxd rax, ds:(jpt_6E641 - 878C4h)[rdx+rax*4]
add rax, rdx
jmp rax; switch jump
loc_6E643:
mov al, [r14]; jumptable 000000000006E641 case 1
loc_6E646:
mov ecx, eax
and cl, r15b
lock cmpxchg [r14], cl
jnz short loc_6E646
jmp loc_6E7FD
loc_6E657:
cmp [rsp+68h+var_40], 3
jnz short loc_6E6A5
mov rdx, [r13+20h]
mov rcx, [r13+28h]
lea rsi, [rsp+68h+var_48]
mov rdi, rbx
call JS_ToBigInt64
test eax, eax
jnz loc_6E700
mov r15, [rsp+68h+var_48]
cmp ebp, 6
jnz short loc_6E6E7
mov rdx, [r13+30h]
mov rcx, [r13+38h]
lea rsi, [rsp+68h+var_48]
mov rdi, rbx
call JS_ToBigInt64
test eax, eax
jnz short loc_6E700
mov rcx, [rsp+68h+var_48]
jmp short loc_6E6E9
loc_6E6A5:
mov rdx, [r13+20h]
mov rcx, [r13+28h]
lea rsi, [rsp+68h+var_48]
mov rdi, rbx
call JS_ToInt32
test eax, eax
jnz short loc_6E700
mov r15d, dword ptr [rsp+68h+var_48]
cmp ebp, 6
jnz short loc_6E6E7
mov rdx, [r13+30h]
mov rcx, [r13+38h]
lea rsi, [rsp+68h+var_48]
mov rdi, rbx
call JS_ToInt32
test eax, eax
jnz short loc_6E700
mov ecx, dword ptr [rsp+68h+var_48]
jmp short loc_6E6E9
loc_6E6E7:
xor ecx, ecx
loc_6E6E9:
mov rax, [rsp+68h+var_38]
cmp byte ptr [rax+8], 0
jz loc_6E621
mov rdi, rbx
call JS_ThrowTypeErrorDetachedArrayBuffer
loc_6E700:
xor eax, eax
xor ecx, ecx
jmp loc_6E8E9
loc_6E709:
neg r15; jumptable 000000000006E641 case 27
loc_6E70C:
lock xadd [r14], r15; jumptable 000000000006E641 case 24
jmp loc_6E863
loc_6E716:
mov eax, r15d; jumptable 000000000006E641 case 14
lock cmpxchg [r14], cx
jmp short loc_6E799
loc_6E721:
neg r15d; jumptable 000000000006E641 case 11
loc_6E724:
lock xadd [r14], r15w; jumptable 000000000006E641 case 8
jmp loc_6E7EF
loc_6E72F:
mov al, [r14]; jumptable 000000000006E641 case 4
loc_6E732:
mov ecx, eax
xor cl, r15b
lock cmpxchg [r14], cl
jnz short loc_6E732
jmp loc_6E7FD
loc_6E743:
movzx eax, word ptr [r14]; jumptable 000000000006E641 case 12
loc_6E747:
mov ecx, eax
xor ecx, r15d
lock cmpxchg [r14], cx
jnz short loc_6E747
jmp loc_6E824
loc_6E759:
movzx eax, word ptr [r14]; jumptable 000000000006E641 case 9
loc_6E75D:
mov ecx, eax
and ecx, r15d
lock cmpxchg [r14], cx
jnz short loc_6E75D
jmp loc_6E824
loc_6E76F:
mov rax, [r14]; jumptable 000000000006E641 case 25
loc_6E772:
mov rcx, rax
and rcx, r15
lock cmpxchg [r14], rcx
jnz short loc_6E772
jmp loc_6E866
loc_6E784:
mov al, [r14]; jumptable 000000000006E641 case 2
loc_6E787:
mov ecx, eax
or cl, r15b
lock cmpxchg [r14], cl
jnz short loc_6E787
jmp short loc_6E7FD
loc_6E795:
movzx eax, word ptr [r14]; jumptable 000000000006E641 case 15
loc_6E799:
movzx eax, ax
jmp loc_6E866
loc_6E7A1:
neg r15b; jumptable 000000000006E641 case 3
loc_6E7A4:
lock xadd [r14], r15b; jumptable 000000000006E641 case 0
jmp short loc_6E7DD
loc_6E7AB:
mov al, [r14]; jumptable 000000000006E641 case 7
jmp short loc_6E7FD
loc_6E7B0:
mov rax, [r14]; jumptable 000000000006E641 case 31
jmp loc_6E866
loc_6E7B8:
mov eax, [r14]; jumptable 000000000006E641 case 17
loc_6E7BB:
mov ecx, eax
and ecx, r15d
lock cmpxchg [r14], ecx
jnz short loc_6E7BB
jmp short loc_6E83B
loc_6E7C9:
mov eax, [r14]; jumptable 000000000006E641 case 20
loc_6E7CC:
mov ecx, eax
xor ecx, r15d
lock cmpxchg [r14], ecx
jnz short loc_6E7CC
jmp short loc_6E83B
loc_6E7DA:
xchg r15b, [r14]; jumptable 000000000006E641 case 5
loc_6E7DD:
movzx eax, r15b
jmp loc_6E866
loc_6E7E6:
xchg r15d, [r14]; jumptable 000000000006E641 case 21
jmp short loc_6E863
loc_6E7EB:
xchg r15w, [r14]; jumptable 000000000006E641 case 13
loc_6E7EF:
movzx eax, r15w
jmp short loc_6E866
loc_6E7F5:
mov eax, r15d; jumptable 000000000006E641 case 6
lock cmpxchg [r14], cl
loc_6E7FD:
movzx eax, al
jmp short loc_6E866
loc_6E802:
mov eax, [r14]; jumptable 000000000006E641 case 18
loc_6E805:
mov ecx, eax
or ecx, r15d
lock cmpxchg [r14], ecx
jnz short loc_6E805
jmp short loc_6E83B
loc_6E813:
movzx eax, word ptr [r14]; jumptable 000000000006E641 case 10
loc_6E817:
mov ecx, eax
or ecx, r15d
lock cmpxchg [r14], cx
jnz short loc_6E817
loc_6E824:
movzx eax, ax
jmp short loc_6E866
loc_6E829:
mov rax, r15; jumptable 000000000006E641 case 30
lock cmpxchg [r14], rcx
jmp short loc_6E866
loc_6E833:
mov eax, r15d; jumptable 000000000006E641 case 22
lock cmpxchg [r14], ecx
loc_6E83B:
mov eax, eax
jmp short loc_6E866
loc_6E83F:
neg r15d; jumptable 000000000006E641 case 19
loc_6E842:
lock xadd [r14], r15d; jumptable 000000000006E641 case 16
jmp short loc_6E863
loc_6E849:
mov eax, [r14]; jumptable 000000000006E641 case 23
jmp short loc_6E866
loc_6E84E:
mov rax, [r14]; jumptable 000000000006E641 case 28
loc_6E851:
mov rcx, rax
xor rcx, r15
lock cmpxchg [r14], rcx
jnz short loc_6E851
jmp short loc_6E866
loc_6E860:
xchg r15, [r14]; jumptable 000000000006E641 case 29
loc_6E863:
mov rax, r15
loc_6E866:
mov ecx, [rsp+68h+var_3C]
add ecx, 0FFFFFFEAh; switch 8 cases
cmp ecx, 7
ja def_6E641; jumptable 000000000006E641 default case
lea rdx, jpt_6E884
movsxd rcx, ds:(jpt_6E884 - 87944h)[rdx+rcx*4]
add rcx, rdx
jmp rcx; switch jump
loc_6E886:
movsx rax, al; jumptable 000000000006E884 case 22
jmp short loc_6E89A; jumptable 000000000006E884 case 26
loc_6E88C:
movzx eax, ax; jumptable 000000000006E884 case 25
jmp short loc_6E89A; jumptable 000000000006E884 case 26
loc_6E891:
movzx eax, al; jumptable 000000000006E884 case 23
jmp short loc_6E89A; jumptable 000000000006E884 case 26
loc_6E896:
movsx rax, ax; jumptable 000000000006E884 case 24
loc_6E89A:
mov eax, eax; jumptable 000000000006E884 case 26
xor r12d, r12d
jmp short loc_6E8DA
loc_6E8A1:
mov rdi, rbx; jumptable 000000000006E884 case 29
mov rsi, rax
call JS_NewBigUint64
jmp short loc_6E8D7
loc_6E8AE:
xor ecx, ecx; jumptable 000000000006E884 case 27
mov edx, eax
cvtsi2sd xmm0, rdx
test eax, eax
movq rax, xmm0
cmovns rax, rdx
push 7
pop r12
cmovns r12, rcx
jmp short loc_6E8DA
loc_6E8CC:
mov rdi, rbx; jumptable 000000000006E884 case 28
mov rsi, rax
call JS_NewBigInt64
loc_6E8D7:
mov r12, rdx
loc_6E8DA:
mov rcx, 0FFFFFFFF00000000h
and rcx, rax
mov eax, eax
loc_6E8E9:
or rax, rcx
mov rdx, r12
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_6E8FE:
mov rax, [r14]; jumptable 000000000006E641 case 26
loc_6E901:
mov rcx, rax
or rcx, r15
lock cmpxchg [r14], rcx
jnz short loc_6E901
jmp loc_6E866
def_6E641:
call _abort; jumptable 000000000006E641 default case
| unsigned long long js_atomics_op(
const char *a1,
double a2,
__m128 a3,
__m128 a4,
__m128 a5,
double a6,
double a7,
__m128 a8,
__m128 a9,
long long a10,
long long a11,
long long a12,
long long a13,
int a14)
{
__m128 v16; // xmm0
unsigned long long *v17; // rsi
long long ptr; // rax
long long v19; // rdx
volatile signed __int8 *v20; // r14
signed long long v21; // rcx
unsigned long long v22; // r15
double v23; // rax
char v24; // tt
long long v25; // r8
long long v26; // r9
__m128 v27; // xmm4
__m128 v28; // xmm5
unsigned long long v29; // rcx
long long v30; // r15
unsigned __int16 v31; // r15
char v32; // tt
__int16 v33; // tt
__int16 v34; // tt
char v35; // tt
unsigned __int8 v36; // r15
volatile signed __int8 v37; // t0
__int16 v38; // t2
__int16 v39; // tt
double v40; // rdx
bool v41; // sf
char v43; // [rsp+0h] [rbp-68h]
unsigned long long v44; // [rsp+20h] [rbp-48h] BYREF
int v45; // [rsp+28h] [rbp-40h] BYREF
int v46; // [rsp+2Ch] [rbp-3Ch] BYREF
_QWORD v47[7]; // [rsp+30h] [rbp-38h] BYREF
v16 = *(__m128 *)(a13 + 16);
v17 = v47;
ptr = js_atomics_get_ptr(
(_DWORD)a1,
(unsigned int)v47,
(unsigned int)&v45,
(unsigned int)&v46,
*(_QWORD *)a13,
*(_QWORD *)(a13 + 8),
*(_OWORD *)(a13 + 16),
*(_QWORD *)(a13 + 24),
0);
if ( !ptr )
goto LABEL_20;
v20 = (volatile signed __int8 *)ptr;
if ( a14 == 7 )
{
v21 = 0LL;
v22 = 0LL;
goto LABEL_4;
}
if ( v45 == 3 )
{
v17 = &v44;
if ( (unsigned int)JS_ToBigInt64((long long)a1, (long long)&v44, *(_DWORD **)(a13 + 32), *(_QWORD *)(a13 + 40)) )
goto LABEL_20;
v22 = v44;
if ( a14 == 6 )
{
v17 = &v44;
if ( (unsigned int)JS_ToBigInt64((long long)a1, (long long)&v44, *(_DWORD **)(a13 + 48), *(_QWORD *)(a13 + 56)) )
goto LABEL_20;
v21 = v44;
goto LABEL_18;
}
}
else
{
v17 = &v44;
if ( (unsigned int)JS_ToInt32((long long)a1, (long long)&v44, *(_DWORD **)(a13 + 32), *(_QWORD *)(a13 + 40)) )
goto LABEL_20;
v22 = (unsigned int)v44;
if ( a14 == 6 )
{
v17 = &v44;
if ( (unsigned int)JS_ToInt32((long long)a1, (long long)&v44, *(_DWORD **)(a13 + 48), *(_QWORD *)(a13 + 56)) )
goto LABEL_20;
v21 = (unsigned int)v44;
goto LABEL_18;
}
}
v21 = 0LL;
LABEL_18:
if ( !*(_BYTE *)(v47[0] + 8LL) )
{
LABEL_4:
switch ( a14 | (8 * v45) )
{
case 0:
goto LABEL_42;
case 1:
LOBYTE(v23) = *v20;
do
{
v24 = LOBYTE(v23);
LOBYTE(v23) = _InterlockedCompareExchange8(v20, v22 & LOBYTE(v23), SLOBYTE(v23));
}
while ( v24 != LOBYTE(v23) );
goto LABEL_53;
case 2:
LOBYTE(v23) = *v20;
do
{
v35 = LOBYTE(v23);
LOBYTE(v23) = _InterlockedCompareExchange8(v20, v22 | LOBYTE(v23), SLOBYTE(v23));
}
while ( v35 != LOBYTE(v23) );
goto LABEL_53;
case 3:
LOBYTE(v22) = -(char)v22;
LABEL_42:
v36 = _InterlockedExchangeAdd8(v20, v22);
goto LABEL_48;
case 4:
LOBYTE(v23) = *v20;
do
{
v32 = LOBYTE(v23);
LOBYTE(v23) = _InterlockedCompareExchange8(v20, v22 ^ LOBYTE(v23), SLOBYTE(v23));
}
while ( v32 != LOBYTE(v23) );
goto LABEL_53;
case 5:
v37 = v22;
v36 = *v20;
*v20 = v37;
LABEL_48:
*(_QWORD *)&v23 = v36;
break;
case 6:
LOBYTE(v23) = _InterlockedCompareExchange8(v20, v21, v22);
goto LABEL_53;
case 7:
LOBYTE(v23) = *v20;
LABEL_53:
*(_QWORD *)&v23 = LOBYTE(v23);
break;
case 8:
goto LABEL_25;
case 9:
LOWORD(v23) = *(_WORD *)v20;
do
{
v34 = LOWORD(v23);
LOWORD(v23) = _InterlockedCompareExchange16((volatile signed __int16 *)v20, v22 & LOWORD(v23), SLOWORD(v23));
}
while ( v34 != LOWORD(v23) );
goto LABEL_57;
case 0xA:
LOWORD(v23) = *(_WORD *)v20;
do
{
v39 = LOWORD(v23);
LOWORD(v23) = _InterlockedCompareExchange16((volatile signed __int16 *)v20, v22 | LOWORD(v23), SLOWORD(v23));
}
while ( v39 != LOWORD(v23) );
goto LABEL_57;
case 0xB:
LODWORD(v22) = -(int)v22;
LABEL_25:
v31 = _InterlockedExchangeAdd16((volatile signed __int16 *)v20, v22);
goto LABEL_51;
case 0xC:
LOWORD(v23) = *(_WORD *)v20;
do
{
v33 = LOWORD(v23);
LOWORD(v23) = _InterlockedCompareExchange16((volatile signed __int16 *)v20, v22 ^ LOWORD(v23), SLOWORD(v23));
}
while ( v33 != LOWORD(v23) );
LABEL_57:
*(_QWORD *)&v23 = LOWORD(v23);
break;
case 0xD:
v38 = v22;
v31 = *(_WORD *)v20;
*(_WORD *)v20 = v38;
LABEL_51:
*(_QWORD *)&v23 = v31;
break;
case 0xE:
LOWORD(v23) = _InterlockedCompareExchange16((volatile signed __int16 *)v20, v21, v22);
goto LABEL_40;
case 0xF:
LOWORD(v23) = *(_WORD *)v20;
LABEL_40:
*(_QWORD *)&v23 = LOWORD(v23);
break;
case 0x10:
goto LABEL_62;
case 0x11:
LODWORD(v23) = _InterlockedAnd((volatile signed __int32 *)v20, v22);
goto LABEL_60;
case 0x12:
LODWORD(v23) = _InterlockedOr((volatile signed __int32 *)v20, v22);
goto LABEL_60;
case 0x13:
LODWORD(v22) = -(int)v22;
LABEL_62:
v30 = (unsigned int)_InterlockedExchangeAdd((volatile signed __int32 *)v20, v22);
goto LABEL_66;
case 0x14:
LODWORD(v23) = _InterlockedXor((volatile signed __int32 *)v20, v22);
goto LABEL_60;
case 0x15:
v30 = (unsigned int)_InterlockedExchange((volatile __int32 *)v20, v22);
goto LABEL_66;
case 0x16:
LODWORD(v23) = _InterlockedCompareExchange((volatile signed __int32 *)v20, v21, v22);
LABEL_60:
*(_QWORD *)&v23 = LODWORD(v23);
break;
case 0x17:
*(_QWORD *)&v23 = *(unsigned int *)v20;
break;
case 0x18:
goto LABEL_22;
case 0x19:
v23 = COERCE_DOUBLE(_InterlockedAnd64((volatile signed long long *)v20, v22));
break;
case 0x1A:
v23 = COERCE_DOUBLE(_InterlockedOr64((volatile signed long long *)v20, v22));
break;
case 0x1B:
v22 = -(long long)v22;
LABEL_22:
*(double *)&v30 = COERCE_DOUBLE(_InterlockedExchangeAdd64((volatile signed long long *)v20, v22));
goto LABEL_66;
case 0x1C:
v23 = COERCE_DOUBLE(_InterlockedXor64((volatile signed long long *)v20, v22));
break;
case 0x1D:
*(double *)&v30 = COERCE_DOUBLE(_InterlockedExchange64((volatile long long *)v20, v22));
LABEL_66:
v23 = *(double *)&v30;
break;
case 0x1E:
v23 = COERCE_DOUBLE(_InterlockedCompareExchange64((volatile signed long long *)v20, v21, v22));
break;
case 0x1F:
v23 = *(double *)v20;
break;
default:
LABEL_81:
abort(a1, v17, v19, v21);
}
v21 = (unsigned int)(v46 - 22);
switch ( v46 )
{
case 22:
LODWORD(v23) = SLOBYTE(v23);
goto LABEL_72;
case 23:
LODWORD(v23) = LOBYTE(v23);
goto LABEL_72;
case 24:
LODWORD(v23) = SLOWORD(v23);
goto LABEL_72;
case 25:
LODWORD(v23) = LOWORD(v23);
goto LABEL_72;
case 26:
LABEL_72:
*(_QWORD *)&v23 = LODWORD(v23);
goto LABEL_78;
case 27:
*(_QWORD *)&v40 = LODWORD(v23);
v41 = SLODWORD(v23) < 0;
v23 = (double)SLODWORD(v23);
if ( !v41 )
v23 = v40;
goto LABEL_78;
case 28:
v23 = COERCE_DOUBLE(JS_NewBigInt64((long long)a1, *(long long *)&v23));
goto LABEL_78;
case 29:
v23 = COERCE_DOUBLE(JS_NewBigUint64((long long)a1, *(long long *)&v23));
LABEL_78:
v29 = *(_QWORD *)&v23 & 0xFFFFFFFF00000000LL;
*(_QWORD *)&v23 = LODWORD(v23);
return v29 | *(_QWORD *)&v23;
default:
goto LABEL_81;
}
}
JS_ThrowTypeErrorDetachedArrayBuffer(
(long long)a1,
v16,
a3,
a4,
a5,
v27,
v28,
a8,
a9,
(long long)&v44,
v19,
v21,
v25,
v26,
v43);
LABEL_20:
v23 = 0.0;
v29 = 0LL;
return v29 | *(_QWORD *)&v23;
}
| js_atomics_op:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV EBP,R9D
MOV R13,R8
MOV RBX,RDI
MOV R8,qword ptr [R8]
MOV R9,qword ptr [R13 + 0x8]
MOVUPD XMM0,xmmword ptr [R13 + 0x10]
MOVUPD xmmword ptr [RSP],XMM0
AND dword ptr [RSP + 0x10],0x0
LEA RSI,[RSP + 0x30]
LEA RDX,[RSP + 0x28]
LEA RCX,[RSP + 0x2c]
CALL 0x0016f018
PUSH 0x6
POP R12
TEST RAX,RAX
JZ 0x0016e700
MOV R14,RAX
CMP EBP,0x7
JNZ 0x0016e657
XOR ECX,ECX
XOR R15D,R15D
LAB_0016e621:
MOV EAX,dword ptr [RSP + 0x28]
SHL EAX,0x3
OR EAX,EBP
CMP EAX,0x1f
JA 0x0016e913
LEA RDX,[0x1878c4]
MOVSXD RAX,dword ptr [RDX + RAX*0x4]
ADD RAX,RDX
switchD:
JMP RAX
caseD_1:
MOV AL,byte ptr [R14]
LAB_0016e646:
MOV ECX,EAX
AND CL,R15B
CMPXCHG.LOCK byte ptr [R14],CL
JNZ 0x0016e646
JMP 0x0016e7fd
LAB_0016e657:
CMP dword ptr [RSP + 0x28],0x3
JNZ 0x0016e6a5
MOV RDX,qword ptr [R13 + 0x20]
MOV RCX,qword ptr [R13 + 0x28]
LEA RSI,[RSP + 0x20]
MOV RDI,RBX
CALL 0x00125177
TEST EAX,EAX
JNZ 0x0016e700
MOV R15,qword ptr [RSP + 0x20]
CMP EBP,0x6
JNZ 0x0016e6e7
MOV RDX,qword ptr [R13 + 0x30]
MOV RCX,qword ptr [R13 + 0x38]
LEA RSI,[RSP + 0x20]
MOV RDI,RBX
CALL 0x00125177
TEST EAX,EAX
JNZ 0x0016e700
MOV RCX,qword ptr [RSP + 0x20]
JMP 0x0016e6e9
LAB_0016e6a5:
MOV RDX,qword ptr [R13 + 0x20]
MOV RCX,qword ptr [R13 + 0x28]
LEA RSI,[RSP + 0x20]
MOV RDI,RBX
CALL 0x00125187
TEST EAX,EAX
JNZ 0x0016e700
MOV R15D,dword ptr [RSP + 0x20]
CMP EBP,0x6
JNZ 0x0016e6e7
MOV RDX,qword ptr [R13 + 0x30]
MOV RCX,qword ptr [R13 + 0x38]
LEA RSI,[RSP + 0x20]
MOV RDI,RBX
CALL 0x00125187
TEST EAX,EAX
JNZ 0x0016e700
MOV ECX,dword ptr [RSP + 0x20]
JMP 0x0016e6e9
LAB_0016e6e7:
XOR ECX,ECX
LAB_0016e6e9:
MOV RAX,qword ptr [RSP + 0x30]
CMP byte ptr [RAX + 0x8],0x0
JZ 0x0016e621
MOV RDI,RBX
CALL 0x00135cd1
LAB_0016e700:
XOR EAX,EAX
XOR ECX,ECX
JMP 0x0016e8e9
caseD_1b:
NEG R15
caseD_18:
XADD.LOCK qword ptr [R14],R15
JMP 0x0016e863
caseD_e:
MOV EAX,R15D
CMPXCHG.LOCK word ptr [R14],CX
JMP 0x0016e799
caseD_b:
NEG R15D
caseD_8:
XADD.LOCK word ptr [R14],R15W
JMP 0x0016e7ef
caseD_4:
MOV AL,byte ptr [R14]
LAB_0016e732:
MOV ECX,EAX
XOR CL,R15B
CMPXCHG.LOCK byte ptr [R14],CL
JNZ 0x0016e732
JMP 0x0016e7fd
caseD_c:
MOVZX EAX,word ptr [R14]
LAB_0016e747:
MOV ECX,EAX
XOR ECX,R15D
CMPXCHG.LOCK word ptr [R14],CX
JNZ 0x0016e747
JMP 0x0016e824
caseD_9:
MOVZX EAX,word ptr [R14]
LAB_0016e75d:
MOV ECX,EAX
AND ECX,R15D
CMPXCHG.LOCK word ptr [R14],CX
JNZ 0x0016e75d
JMP 0x0016e824
caseD_19:
MOV RAX,qword ptr [R14]
LAB_0016e772:
MOV RCX,RAX
AND RCX,R15
CMPXCHG.LOCK qword ptr [R14],RCX
JNZ 0x0016e772
JMP 0x0016e866
caseD_2:
MOV AL,byte ptr [R14]
LAB_0016e787:
MOV ECX,EAX
OR CL,R15B
CMPXCHG.LOCK byte ptr [R14],CL
JNZ 0x0016e787
JMP 0x0016e7fd
caseD_f:
MOVZX EAX,word ptr [R14]
LAB_0016e799:
MOVZX EAX,AX
JMP 0x0016e866
caseD_3:
NEG R15B
caseD_0:
XADD.LOCK byte ptr [R14],R15B
JMP 0x0016e7dd
caseD_7:
MOV AL,byte ptr [R14]
JMP 0x0016e7fd
caseD_1f:
MOV RAX,qword ptr [R14]
JMP 0x0016e866
caseD_11:
MOV EAX,dword ptr [R14]
LAB_0016e7bb:
MOV ECX,EAX
AND ECX,R15D
CMPXCHG.LOCK dword ptr [R14],ECX
JNZ 0x0016e7bb
JMP 0x0016e83b
caseD_14:
MOV EAX,dword ptr [R14]
LAB_0016e7cc:
MOV ECX,EAX
XOR ECX,R15D
CMPXCHG.LOCK dword ptr [R14],ECX
JNZ 0x0016e7cc
JMP 0x0016e83b
caseD_5:
XCHG byte ptr [R14],R15B
LAB_0016e7dd:
MOVZX EAX,R15B
JMP 0x0016e866
caseD_15:
XCHG dword ptr [R14],R15D
JMP 0x0016e863
caseD_d:
XCHG word ptr [R14],R15W
LAB_0016e7ef:
MOVZX EAX,R15W
JMP 0x0016e866
caseD_6:
MOV EAX,R15D
CMPXCHG.LOCK byte ptr [R14],CL
LAB_0016e7fd:
MOVZX EAX,AL
JMP 0x0016e866
caseD_12:
MOV EAX,dword ptr [R14]
LAB_0016e805:
MOV ECX,EAX
OR ECX,R15D
CMPXCHG.LOCK dword ptr [R14],ECX
JNZ 0x0016e805
JMP 0x0016e83b
caseD_a:
MOVZX EAX,word ptr [R14]
LAB_0016e817:
MOV ECX,EAX
OR ECX,R15D
CMPXCHG.LOCK word ptr [R14],CX
JNZ 0x0016e817
LAB_0016e824:
MOVZX EAX,AX
JMP 0x0016e866
caseD_1e:
MOV RAX,R15
CMPXCHG.LOCK qword ptr [R14],RCX
JMP 0x0016e866
caseD_16:
MOV EAX,R15D
CMPXCHG.LOCK dword ptr [R14],ECX
LAB_0016e83b:
MOV EAX,EAX
JMP 0x0016e866
caseD_13:
NEG R15D
caseD_10:
XADD.LOCK dword ptr [R14],R15D
JMP 0x0016e863
caseD_17:
MOV EAX,dword ptr [R14]
JMP 0x0016e866
caseD_1c:
MOV RAX,qword ptr [R14]
LAB_0016e851:
MOV RCX,RAX
XOR RCX,R15
CMPXCHG.LOCK qword ptr [R14],RCX
JNZ 0x0016e851
JMP 0x0016e866
caseD_1d:
XCHG qword ptr [R14],R15
LAB_0016e863:
MOV RAX,R15
LAB_0016e866:
MOV ECX,dword ptr [RSP + 0x2c]
ADD ECX,-0x16
CMP ECX,0x7
JA 0x0016e913
LEA RDX,[0x187944]
MOVSXD RCX,dword ptr [RDX + RCX*0x4]
ADD RCX,RDX
switchD:
JMP RCX
caseD_16:
MOVSX RAX,AL
JMP 0x0016e89a
caseD_19:
MOVZX EAX,AX
JMP 0x0016e89a
caseD_17:
MOVZX EAX,AL
JMP 0x0016e89a
caseD_18:
MOVSX RAX,AX
caseD_1a:
MOV EAX,EAX
XOR R12D,R12D
JMP 0x0016e8da
caseD_1d:
MOV RDI,RBX
MOV RSI,RAX
CALL 0x001259aa
JMP 0x0016e8d7
caseD_1b:
XOR ECX,ECX
MOV EDX,EAX
CVTSI2SD XMM0,RDX
TEST EAX,EAX
MOVQ RAX,XMM0
CMOVNS RAX,RDX
PUSH 0x7
POP R12
CMOVNS R12,RCX
JMP 0x0016e8da
caseD_1c:
MOV RDI,RBX
MOV RSI,RAX
CALL 0x00125906
LAB_0016e8d7:
MOV R12,RDX
LAB_0016e8da:
MOV RCX,-0x100000000
AND RCX,RAX
MOV EAX,EAX
LAB_0016e8e9:
OR RAX,RCX
MOV RDX,R12
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
caseD_1a:
MOV RAX,qword ptr [R14]
LAB_0016e901:
MOV RCX,RAX
OR RCX,R15
CMPXCHG.LOCK qword ptr [R14],RCX
JNZ 0x0016e901
JMP 0x0016e866
default:
CALL 0x0010e090
|
int1 [16] js_atomics_op(int8 param_1)
{
int1 auVar1 [16];
byte bVar2;
ushort uVar3;
int iVar4;
uint uVar5;
uint uVar6;
ulong *puVar7;
ulong uVar8;
double dVar9;
ulong uVar10;
int8 *in_R8;
uint in_R9D;
int8 uVar11;
byte bVar12;
byte bVar13;
ushort uVar15;
ulong uVar17;
bool bVar18;
int1 auVar19 [16];
int1 auVar20 [16];
uint local_48;
int4 uStack_44;
int local_40;
int4 local_3c;
long local_38;
ushort uVar14;
uint uVar16;
puVar7 = (ulong *)js_atomics_get_ptr(param_1,&local_38,&local_40,&local_3c,*in_R8,in_R8[1],
in_R8[2],in_R8[3],0);
uVar11 = 6;
if (puVar7 == (ulong *)0x0) {
LAB_0016e700:
uVar17 = 0;
uVar10 = 0;
goto LAB_0016e8e9;
}
if (in_R9D != 7) {
if (local_40 == 3) {
iVar4 = JS_ToBigInt64(param_1,&local_48,in_R8[4]);
if (iVar4 == 0) {
uVar17 = CONCAT44(uStack_44,local_48);
if (in_R9D == 6) {
iVar4 = JS_ToBigInt64(param_1,&local_48,in_R8[6],in_R8[7]);
if (iVar4 != 0) goto LAB_0016e700;
uVar10 = CONCAT44(uStack_44,local_48);
}
else {
LAB_0016e6e7:
uVar10 = 0;
}
LAB_0016e6e9:
if (*(char *)(local_38 + 8) == '\0') goto LAB_0016e621;
JS_ThrowTypeErrorDetachedArrayBuffer(param_1);
}
}
else {
iVar4 = JS_ToInt32(param_1,&local_48,in_R8[4]);
if (iVar4 == 0) {
uVar17 = (ulong)local_48;
if (in_R9D != 6) goto LAB_0016e6e7;
iVar4 = JS_ToInt32(param_1,&local_48,in_R8[6],in_R8[7]);
if (iVar4 == 0) {
uVar10 = (ulong)local_48;
goto LAB_0016e6e9;
}
}
}
goto LAB_0016e700;
}
uVar10 = 0;
uVar17 = 0;
LAB_0016e621:
bVar12 = (byte)uVar17;
uVar16 = (uint)uVar17;
uVar14 = (ushort)uVar17;
switch(local_40 << 3 | in_R9D) {
case 1:
bVar13 = (byte)*puVar7;
do {
LOCK();
bVar2 = (byte)*puVar7;
bVar18 = bVar13 == bVar2;
if (bVar18) {
*(byte *)puVar7 = bVar13 & bVar12;
bVar2 = bVar13;
}
bVar13 = bVar2;
UNLOCK();
} while (!bVar18);
goto LAB_0016e7fd;
case 2:
bVar13 = (byte)*puVar7;
do {
LOCK();
bVar2 = (byte)*puVar7;
bVar18 = bVar13 == bVar2;
if (bVar18) {
*(byte *)puVar7 = bVar13 | bVar12;
bVar2 = bVar13;
}
bVar13 = bVar2;
UNLOCK();
} while (!bVar18);
goto LAB_0016e7fd;
case 3:
uVar17 = (ulong)(byte)-bVar12;
case 0:
LOCK();
bVar13 = (byte)*puVar7;
*(char *)puVar7 = (char)*puVar7 + (char)uVar17;
UNLOCK();
goto LAB_0016e7dd;
case 4:
bVar13 = (byte)*puVar7;
do {
LOCK();
bVar2 = (byte)*puVar7;
bVar18 = bVar13 == bVar2;
if (bVar18) {
*(byte *)puVar7 = bVar13 ^ bVar12;
bVar2 = bVar13;
}
bVar13 = bVar2;
UNLOCK();
} while (!bVar18);
goto LAB_0016e7fd;
case 5:
LOCK();
bVar13 = (byte)*puVar7;
*(byte *)puVar7 = bVar12;
UNLOCK();
LAB_0016e7dd:
uVar8 = (ulong)bVar13;
break;
case 6:
LOCK();
bVar13 = (byte)*puVar7;
if (bVar12 == bVar13) {
*(char *)puVar7 = (char)uVar10;
bVar13 = bVar12;
}
UNLOCK();
goto LAB_0016e7fd;
case 7:
bVar13 = (byte)*puVar7;
LAB_0016e7fd:
uVar8 = (ulong)bVar13;
break;
case 9:
uVar15 = (ushort)*puVar7;
do {
LOCK();
uVar3 = (ushort)*puVar7;
bVar18 = uVar15 == uVar3;
if (bVar18) {
*(ushort *)puVar7 = uVar15 & uVar14;
uVar3 = uVar15;
}
uVar15 = uVar3;
UNLOCK();
} while (!bVar18);
goto LAB_0016e824;
case 10:
uVar15 = (ushort)*puVar7;
do {
LOCK();
uVar3 = (ushort)*puVar7;
bVar18 = uVar15 == uVar3;
if (bVar18) {
*(ushort *)puVar7 = uVar15 | uVar14;
uVar3 = uVar15;
}
uVar15 = uVar3;
UNLOCK();
} while (!bVar18);
goto LAB_0016e824;
case 0xb:
uVar17 = (ulong)-uVar16;
case 8:
LOCK();
uVar15 = (ushort)*puVar7;
*(short *)puVar7 = (short)*puVar7 + (short)uVar17;
UNLOCK();
goto LAB_0016e7ef;
case 0xc:
uVar15 = (ushort)*puVar7;
do {
LOCK();
uVar3 = (ushort)*puVar7;
bVar18 = uVar15 == uVar3;
if (bVar18) {
*(ushort *)puVar7 = uVar15 ^ uVar14;
uVar3 = uVar15;
}
uVar15 = uVar3;
UNLOCK();
} while (!bVar18);
LAB_0016e824:
uVar8 = (ulong)uVar15;
break;
case 0xd:
LOCK();
uVar15 = (ushort)*puVar7;
*(ushort *)puVar7 = uVar14;
UNLOCK();
LAB_0016e7ef:
uVar8 = (ulong)uVar15;
break;
case 0xe:
LOCK();
uVar15 = (ushort)*puVar7;
if (uVar14 == uVar15) {
*(short *)puVar7 = (short)uVar10;
uVar15 = uVar14;
}
UNLOCK();
goto LAB_0016e799;
case 0xf:
uVar15 = (ushort)*puVar7;
LAB_0016e799:
uVar8 = (ulong)uVar15;
break;
case 0x11:
uVar5 = (uint)*puVar7;
do {
LOCK();
uVar6 = (uint)*puVar7;
bVar18 = uVar5 == uVar6;
if (bVar18) {
*(uint *)puVar7 = uVar5 & uVar16;
uVar6 = uVar5;
}
uVar5 = uVar6;
UNLOCK();
} while (!bVar18);
goto LAB_0016e83b;
case 0x12:
uVar6 = (uint)*puVar7;
do {
LOCK();
uVar5 = (uint)*puVar7;
bVar18 = uVar6 == uVar5;
if (bVar18) {
*(uint *)puVar7 = uVar6 | uVar16;
uVar5 = uVar6;
}
UNLOCK();
uVar6 = uVar5;
} while (!bVar18);
goto LAB_0016e83b;
case 0x13:
uVar17 = (ulong)-uVar16;
case 0x10:
LOCK();
uVar8 = CONCAT44((int)(uVar17 >> 0x20),(uint)*puVar7);
*(uint *)puVar7 = (uint)*puVar7 + (int)uVar17;
UNLOCK();
break;
case 0x14:
uVar6 = (uint)*puVar7;
do {
LOCK();
uVar5 = (uint)*puVar7;
bVar18 = uVar6 == uVar5;
if (bVar18) {
*(uint *)puVar7 = uVar6 ^ uVar16;
uVar5 = uVar6;
}
UNLOCK();
uVar6 = uVar5;
} while (!bVar18);
goto LAB_0016e83b;
case 0x15:
LOCK();
uVar10 = *puVar7;
*(uint *)puVar7 = uVar16;
uVar8 = CONCAT44((int)(uVar17 >> 0x20),(uint)uVar10);
UNLOCK();
break;
case 0x16:
LOCK();
uVar5 = (uint)*puVar7;
if (uVar16 == uVar5) {
*(uint *)puVar7 = (uint)uVar10;
uVar5 = uVar16;
}
UNLOCK();
LAB_0016e83b:
uVar8 = (ulong)uVar5;
break;
case 0x17:
uVar8 = (ulong)(uint)*puVar7;
break;
case 0x19:
uVar10 = *puVar7;
do {
LOCK();
uVar8 = *puVar7;
bVar18 = uVar10 == uVar8;
if (bVar18) {
*puVar7 = uVar10 & uVar17;
uVar8 = uVar10;
}
UNLOCK();
uVar10 = uVar8;
} while (!bVar18);
break;
case 0x1a:
uVar10 = *puVar7;
do {
LOCK();
uVar8 = *puVar7;
bVar18 = uVar10 == uVar8;
if (bVar18) {
*puVar7 = uVar10 | uVar17;
uVar8 = uVar10;
}
UNLOCK();
uVar10 = uVar8;
} while (!bVar18);
break;
case 0x1b:
uVar17 = -uVar17;
case 0x18:
LOCK();
uVar8 = *puVar7;
*puVar7 = *puVar7 + uVar17;
UNLOCK();
break;
case 0x1c:
uVar10 = *puVar7;
do {
LOCK();
uVar8 = *puVar7;
bVar18 = uVar10 == uVar8;
if (bVar18) {
*puVar7 = uVar10 ^ uVar17;
uVar8 = uVar10;
}
UNLOCK();
uVar10 = uVar8;
} while (!bVar18);
break;
case 0x1d:
LOCK();
uVar8 = *puVar7;
*puVar7 = uVar17;
UNLOCK();
break;
case 0x1e:
LOCK();
uVar8 = *puVar7;
if (uVar17 == uVar8) {
*puVar7 = uVar10;
uVar8 = uVar17;
}
UNLOCK();
break;
case 0x1f:
uVar8 = *puVar7;
break;
default:
goto switchD_0016e641_default;
}
switch(local_3c) {
case 0x16:
uVar8 = (ulong)(char)uVar8;
break;
case 0x17:
uVar8 = uVar8 & 0xff;
break;
case 0x18:
uVar8 = (ulong)(short)uVar8;
break;
case 0x19:
uVar8 = uVar8 & 0xffff;
break;
case 0x1a:
break;
case 0x1b:
bVar18 = -1 < (int)uVar8;
dVar9 = (double)(uVar8 & 0xffffffff);
if (bVar18) {
dVar9 = (double)(uVar8 & 0xffffffff);
}
auVar1._8_8_ = 0;
auVar1._0_8_ = dVar9;
auVar19._8_8_ = 7;
auVar19._0_8_ = dVar9;
if (bVar18) {
auVar19 = auVar1;
}
goto LAB_0016e8da;
case 0x1c:
auVar19 = JS_NewBigInt64(param_1,uVar8);
goto LAB_0016e8da;
case 0x1d:
auVar19 = JS_NewBigUint64(param_1,uVar8);
goto LAB_0016e8da;
default:
switchD_0016e641_default:
/* WARNING: Subroutine does not return */
abort();
}
auVar19._8_8_ = 0;
auVar19._0_8_ = uVar8 & 0xffffffff;
LAB_0016e8da:
uVar11 = auVar19._8_8_;
uVar10 = auVar19._0_8_ & 0xffffffff00000000;
uVar17 = auVar19._0_8_ & 0xffffffff;
LAB_0016e8e9:
auVar20._0_8_ = uVar17 | uVar10;
auVar20._8_8_ = uVar11;
return auVar20;
}
| |
43,568 | nglog::tools::(anonymous namespace)::LineReader::ReadLine(char const**, char const**) | ng-log[P]ng-log/src/symbolize.cc | bool ReadLine(const char** bol, const char** eol) {
if (BufferIsEmpty()) { // First time.
const ssize_t num_bytes = ReadFromOffset(fd_, buf_, buf_len_, offset_);
if (num_bytes <= 0) { // EOF or error.
return false;
}
offset_ += static_cast<size_t>(num_bytes);
eod_ = buf_ + num_bytes;
bol_ = buf_;
} else {
bol_ = eol_ + 1; // Advance to the next line in the buffer.
NGLOG_SAFE_ASSERT(bol_ <= eod_); // "bol_" can point to "eod_".
if (!HasCompleteLine()) {
const auto incomplete_line_length = static_cast<size_t>(eod_ - bol_);
// Move the trailing incomplete line to the beginning.
memmove(buf_, bol_, incomplete_line_length);
// Read text from file and append it.
char* const append_pos = buf_ + incomplete_line_length;
const size_t capacity_left = buf_len_ - incomplete_line_length;
const ssize_t num_bytes =
ReadFromOffset(fd_, append_pos, capacity_left, offset_);
if (num_bytes <= 0) { // EOF or error.
return false;
}
offset_ += static_cast<size_t>(num_bytes);
eod_ = append_pos + num_bytes;
bol_ = buf_;
}
}
eol_ = FindLineFeed();
if (eol_ == nullptr) { // '\n' not found. Malformed line.
return false;
}
*eol_ = '\0'; // Replace '\n' with '\0'.
*bol = bol_;
*eol = eol_;
return true;
} | O0 | cpp | nglog::tools::(anonymous namespace)::LineReader::ReadLine(char const**, char const**):
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x6a460
testb $0x1, %al
jne 0x6a167
jmp 0x6a1bb
movq -0x50(%rbp), %rax
movl (%rax), %edi
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rcx
callq 0x69180
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jg 0x6a192
movb $0x0, -0x1(%rbp)
jmp 0x6a2bd
movq -0x50(%rbp), %rax
movq -0x28(%rbp), %rcx
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movq 0x8(%rax), %rcx
addq -0x28(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq 0x8(%rax), %rcx
movq %rcx, 0x20(%rax)
jmp 0x6a277
movq -0x50(%rbp), %rcx
movq 0x28(%rcx), %rax
addq $0x1, %rax
movq %rax, 0x20(%rcx)
movq 0x20(%rcx), %rax
cmpq 0x30(%rcx), %rax
ja 0x6a1d7
jmp 0x6a1dc
callq 0xa440
movq -0x50(%rbp), %rdi
callq 0x6a480
testb $0x1, %al
jne 0x6a275
movq -0x50(%rbp), %rax
movq 0x30(%rax), %rcx
movq 0x20(%rax), %rdx
subq %rdx, %rcx
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rdi
movq 0x20(%rax), %rsi
movq -0x30(%rbp), %rdx
callq 0xae40
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rcx
addq -0x30(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movq 0x10(%rax), %rcx
subq -0x30(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movl (%rax), %edi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq 0x18(%rax), %rcx
callq 0x69180
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jg 0x6a251
movb $0x0, -0x1(%rbp)
jmp 0x6a2bd
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rcx
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rcx
addq -0x48(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq 0x8(%rax), %rcx
movq %rcx, 0x20(%rax)
jmp 0x6a277
movq -0x50(%rbp), %rdi
callq 0x6a4d0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, 0x28(%rax)
cmpq $0x0, 0x28(%rax)
jne 0x6a298
movb $0x0, -0x1(%rbp)
jmp 0x6a2bd
movq -0x50(%rbp), %rax
movq 0x28(%rax), %rcx
movb $0x0, (%rcx)
movq 0x20(%rax), %rdx
movq -0x18(%rbp), %rcx
movq %rdx, (%rcx)
movq 0x28(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| _ZN5nglog5tools12_GLOBAL__N_110LineReader8ReadLineEPPKcS5_:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rdi, [rbp+var_10]; this
mov [rbp+var_50], rdi
call _ZN5nglog5tools12_GLOBAL__N_110LineReader13BufferIsEmptyEv; nglog::tools::`anonymous namespace'::LineReader::BufferIsEmpty(void)
test al, 1
jnz short loc_6A167
jmp short loc_6A1BB
loc_6A167:
mov rax, [rbp+var_50]
mov edi, [rax]; this
mov rsi, [rax+8]; int
mov rdx, [rax+10h]; void *
mov rcx, [rax+18h]; unsigned __int64
call _ZN5nglog5toolsL14ReadFromOffsetEiPvmm; nglog::tools::ReadFromOffset(int,void *,ulong,ulong)
mov [rbp+var_28], rax
cmp [rbp+var_28], 0
jg short loc_6A192
mov [rbp+var_1], 0
jmp loc_6A2BD
loc_6A192:
mov rax, [rbp+var_50]
mov rcx, [rbp+var_28]
add rcx, [rax+18h]
mov [rax+18h], rcx
mov rcx, [rax+8]
add rcx, [rbp+var_28]
mov [rax+30h], rcx
mov rcx, [rax+8]
mov [rax+20h], rcx
jmp loc_6A277
loc_6A1BB:
mov rcx, [rbp+var_50]
mov rax, [rcx+28h]
add rax, 1
mov [rcx+20h], rax
mov rax, [rcx+20h]
cmp rax, [rcx+30h]
ja short loc_6A1D7
jmp short loc_6A1DC
loc_6A1D7:
call _abort
loc_6A1DC:
mov rdi, [rbp+var_50]; this
call _ZN5nglog5tools12_GLOBAL__N_110LineReader15HasCompleteLineEv; nglog::tools::`anonymous namespace'::LineReader::HasCompleteLine(void)
test al, 1
jnz loc_6A275
mov rax, [rbp+var_50]
mov rcx, [rax+30h]
mov rdx, [rax+20h]
sub rcx, rdx
mov [rbp+var_30], rcx
mov rdi, [rax+8]
mov rsi, [rax+20h]
mov rdx, [rbp+var_30]
call _memmove
mov rax, [rbp+var_50]
mov rcx, [rax+8]
add rcx, [rbp+var_30]
mov qword ptr [rbp+var_38], rcx
mov rcx, [rax+10h]
sub rcx, [rbp+var_30]
mov [rbp+var_40], rcx
mov edi, [rax]; this
mov rsi, qword ptr [rbp+var_38]; int
mov rdx, [rbp+var_40]; void *
mov rcx, [rax+18h]; unsigned __int64
call _ZN5nglog5toolsL14ReadFromOffsetEiPvmm; nglog::tools::ReadFromOffset(int,void *,ulong,ulong)
mov [rbp+var_48], rax
cmp [rbp+var_48], 0
jg short loc_6A251
mov [rbp+var_1], 0
jmp short loc_6A2BD
loc_6A251:
mov rax, [rbp+var_50]
mov rcx, [rbp+var_48]
add rcx, [rax+18h]
mov [rax+18h], rcx
mov rcx, qword ptr [rbp+var_38]
add rcx, [rbp+var_48]
mov [rax+30h], rcx
mov rcx, [rax+8]
mov [rax+20h], rcx
loc_6A275:
jmp short $+2
loc_6A277:
mov rdi, [rbp+var_50]; this
call _ZN5nglog5tools12_GLOBAL__N_110LineReader12FindLineFeedEv; nglog::tools::`anonymous namespace'::LineReader::FindLineFeed(void)
mov rcx, rax
mov rax, [rbp+var_50]
mov [rax+28h], rcx
cmp qword ptr [rax+28h], 0
jnz short loc_6A298
mov [rbp+var_1], 0
jmp short loc_6A2BD
loc_6A298:
mov rax, [rbp+var_50]
mov rcx, [rax+28h]
mov byte ptr [rcx], 0
mov rdx, [rax+20h]
mov rcx, [rbp+var_18]
mov [rcx], rdx
mov rcx, [rax+28h]
mov rax, [rbp+var_20]
mov [rax], rcx
mov [rbp+var_1], 1
loc_6A2BD:
mov al, [rbp+var_1]
and al, 1
add rsp, 50h
pop rbp
retn
| char nglog::tools::`anonymous namespace'::LineReader::ReadLine(
nglog::tools::_anonymous_namespace_::LineReader *this,
const char **a2,
const char **a3)
{
signed long long v4; // [rsp+8h] [rbp-48h]
long long v5; // [rsp+18h] [rbp-38h]
long long v6; // [rsp+20h] [rbp-30h]
signed long long v7; // [rsp+28h] [rbp-28h]
if ( (nglog::tools::`anonymous namespace'::LineReader::BufferIsEmpty(this) & 1) != 0 )
{
v7 = nglog::tools::ReadFromOffset(
(nglog::tools *)*(unsigned int *)this,
*((_QWORD *)this + 1),
*((char **)this + 2),
*((_QWORD *)this + 3));
if ( v7 <= 0 )
return 0;
*((_QWORD *)this + 3) += v7;
*((_QWORD *)this + 6) = v7 + *((_QWORD *)this + 1);
*((_QWORD *)this + 4) = *((_QWORD *)this + 1);
}
else
{
*((_QWORD *)this + 4) = *((_QWORD *)this + 5) + 1LL;
if ( *((_QWORD *)this + 4) > *((_QWORD *)this + 6) )
abort(this, a2);
if ( (nglog::tools::`anonymous namespace'::LineReader::HasCompleteLine(this) & 1) == 0 )
{
v6 = *((_QWORD *)this + 6) - *((_QWORD *)this + 4);
memmove(*((_QWORD *)this + 1), *((_QWORD *)this + 4), v6);
v5 = v6 + *((_QWORD *)this + 1);
v4 = nglog::tools::ReadFromOffset(
(nglog::tools *)*(unsigned int *)this,
v5,
(char *)(*((_QWORD *)this + 2) - v6),
*((_QWORD *)this + 3));
if ( v4 <= 0 )
return 0;
*((_QWORD *)this + 3) += v4;
*((_QWORD *)this + 6) = v4 + v5;
*((_QWORD *)this + 4) = *((_QWORD *)this + 1);
}
}
*((_QWORD *)this + 5) = nglog::tools::`anonymous namespace'::LineReader::FindLineFeed(this);
if ( !*((_QWORD *)this + 5) )
return 0;
**((_BYTE **)this + 5) = 0;
*a2 = (const char *)*((_QWORD *)this + 4);
*a3 = (const char *)*((_QWORD *)this + 5);
return 1;
}
| ReadLine:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RDI,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x50],RDI
CALL 0x0016a460
TEST AL,0x1
JNZ 0x0016a167
JMP 0x0016a1bb
LAB_0016a167:
MOV RAX,qword ptr [RBP + -0x50]
MOV EDI,dword ptr [RAX]
MOV RSI,qword ptr [RAX + 0x8]
MOV RDX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RAX + 0x18]
CALL 0x00169180
MOV qword ptr [RBP + -0x28],RAX
CMP qword ptr [RBP + -0x28],0x0
JG 0x0016a192
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0016a2bd
LAB_0016a192:
MOV RAX,qword ptr [RBP + -0x50]
MOV RCX,qword ptr [RBP + -0x28]
ADD RCX,qword ptr [RAX + 0x18]
MOV qword ptr [RAX + 0x18],RCX
MOV RCX,qword ptr [RAX + 0x8]
ADD RCX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0x30],RCX
MOV RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RAX + 0x20],RCX
JMP 0x0016a277
LAB_0016a1bb:
MOV RCX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RCX + 0x28]
ADD RAX,0x1
MOV qword ptr [RCX + 0x20],RAX
MOV RAX,qword ptr [RCX + 0x20]
CMP RAX,qword ptr [RCX + 0x30]
JA 0x0016a1d7
JMP 0x0016a1dc
LAB_0016a1d7:
CALL 0x0010a440
LAB_0016a1dc:
MOV RDI,qword ptr [RBP + -0x50]
CALL 0x0016a480
TEST AL,0x1
JNZ 0x0016a275
MOV RAX,qword ptr [RBP + -0x50]
MOV RCX,qword ptr [RAX + 0x30]
MOV RDX,qword ptr [RAX + 0x20]
SUB RCX,RDX
MOV qword ptr [RBP + -0x30],RCX
MOV RDI,qword ptr [RAX + 0x8]
MOV RSI,qword ptr [RAX + 0x20]
MOV RDX,qword ptr [RBP + -0x30]
CALL 0x0010ae40
MOV RAX,qword ptr [RBP + -0x50]
MOV RCX,qword ptr [RAX + 0x8]
ADD RCX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x38],RCX
MOV RCX,qword ptr [RAX + 0x10]
SUB RCX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x40],RCX
MOV EDI,dword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RAX + 0x18]
CALL 0x00169180
MOV qword ptr [RBP + -0x48],RAX
CMP qword ptr [RBP + -0x48],0x0
JG 0x0016a251
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0016a2bd
LAB_0016a251:
MOV RAX,qword ptr [RBP + -0x50]
MOV RCX,qword ptr [RBP + -0x48]
ADD RCX,qword ptr [RAX + 0x18]
MOV qword ptr [RAX + 0x18],RCX
MOV RCX,qword ptr [RBP + -0x38]
ADD RCX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX + 0x30],RCX
MOV RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RAX + 0x20],RCX
LAB_0016a275:
JMP 0x0016a277
LAB_0016a277:
MOV RDI,qword ptr [RBP + -0x50]
CALL 0x0016a4d0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RAX + 0x28],RCX
CMP qword ptr [RAX + 0x28],0x0
JNZ 0x0016a298
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0016a2bd
LAB_0016a298:
MOV RAX,qword ptr [RBP + -0x50]
MOV RCX,qword ptr [RAX + 0x28]
MOV byte ptr [RCX],0x0
MOV RDX,qword ptr [RAX + 0x20]
MOV RCX,qword ptr [RBP + -0x18]
MOV qword ptr [RCX],RDX
MOV RCX,qword ptr [RAX + 0x28]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
MOV byte ptr [RBP + -0x1],0x1
LAB_0016a2bd:
MOV AL,byte ptr [RBP + -0x1]
AND AL,0x1
ADD RSP,0x50
POP RBP
RET
|
/* nglog::tools::(anonymous namespace)::LineReader::ReadLine(char const**, char const**) */
bool __thiscall
nglog::tools::(anonymous_namespace)::LineReader::ReadLine
(LineReader *this,char **param_1,char **param_2)
{
ulong uVar1;
long lVar2;
long lVar3;
int8 uVar4;
size_t __n;
uVar1 = BufferIsEmpty(this);
if ((uVar1 & 1) == 0) {
*(long *)(this + 0x20) = *(long *)(this + 0x28) + 1;
if (*(ulong *)(this + 0x30) < *(ulong *)(this + 0x20)) {
/* WARNING: Subroutine does not return */
abort();
}
uVar1 = HasCompleteLine(this);
if ((uVar1 & 1) == 0) {
__n = *(long *)(this + 0x30) - *(long *)(this + 0x20);
memmove(*(void **)(this + 8),*(void **)(this + 0x20),__n);
lVar2 = *(long *)(this + 8);
lVar3 = ReadFromOffset(*(int *)this,(void *)(lVar2 + __n),*(long *)(this + 0x10) - __n,
*(ulong *)(this + 0x18));
if (lVar3 < 1) {
return false;
}
*(long *)(this + 0x18) = lVar3 + *(long *)(this + 0x18);
*(long *)(this + 0x30) = (long)(lVar2 + __n) + lVar3;
*(int8 *)(this + 0x20) = *(int8 *)(this + 8);
}
}
else {
lVar2 = ReadFromOffset(*(int *)this,*(void **)(this + 8),*(ulong *)(this + 0x10),
*(ulong *)(this + 0x18));
if (lVar2 < 1) {
return false;
}
*(long *)(this + 0x18) = lVar2 + *(long *)(this + 0x18);
*(long *)(this + 0x30) = *(long *)(this + 8) + lVar2;
*(int8 *)(this + 0x20) = *(int8 *)(this + 8);
}
uVar4 = FindLineFeed(this);
*(int8 *)(this + 0x28) = uVar4;
lVar2 = *(long *)(this + 0x28);
if (lVar2 != 0) {
**(int1 **)(this + 0x28) = 0;
*param_1 = *(char **)(this + 0x20);
*param_2 = *(char **)(this + 0x28);
}
return lVar2 != 0;
}
| |
43,569 | MNN::TfQuantizedConv2DT::TfQuantizedConv2DT() | mnn-tts/MNN/schema/current/TFQuantizeOp_generated.h | TfQuantizedConv2DT()
: biasflag(false),
activationType(FusedActivation_kTfLiteActNone),
multiplier(0),
outMax(0),
outMin(0),
shift(0),
depthMultiplier(0),
modelFormat(ModeFormat_TENSORFLOW) {
} | O0 | c | MNN::TfQuantizedConv2DT::TfQuantizedConv2DT():
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xb260
movq 0x8(%rsp), %rdi
movb $0x0, 0x18(%rdi)
addq $0x20, %rdi
callq 0x17a60
movq 0x8(%rsp), %rdi
addq $0x28, %rdi
callq 0xb290
movq 0x8(%rsp), %rdi
movl $0x0, 0x40(%rdi)
movl $0x0, 0x44(%rdi)
movl $0x0, 0x48(%rdi)
movl $0x0, 0x4c(%rdi)
movl $0x0, 0x50(%rdi)
addq $0x58, %rdi
callq 0x16640
movq 0x8(%rsp), %rdi
movl $0x0, 0x60(%rdi)
addq $0x68, %rdi
callq 0x16640
movq 0x8(%rsp), %rdi
addq $0x70, %rdi
callq 0x16640
movq 0x8(%rsp), %rdi
movl $0x0, 0x78(%rdi)
addq $0x80, %rdi
callq 0x16640
addq $0x18, %rsp
retq
nopl (%rax)
| _ZN3MNN18TfQuantizedConv2DTC2Ev:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov rdi, [rsp+18h+var_8]
mov [rsp+18h+var_10], rdi
call _ZNSt3__16vectorIiNS_9allocatorIiEEEC2B8nn200100Ev; std::vector<int>::vector(void)
mov rdi, [rsp+18h+var_10]
mov byte ptr [rdi+18h], 0
add rdi, 20h ; ' '
call _ZNSt3__110unique_ptrIN3MNN20Convolution2DCommonTENS_14default_deleteIS2_EEEC2B8nn200100ILb1EvEEv; std::unique_ptr<MNN::Convolution2DCommonT>::unique_ptr<true,void>(void)
mov rdi, [rsp+18h+var_10]
add rdi, 28h ; '('
call _ZNSt3__16vectorIhNS_9allocatorIhEEEC2B8nn200100Ev; std::vector<uchar>::vector(void)
mov rdi, [rsp+18h+var_10]
mov dword ptr [rdi+40h], 0
mov dword ptr [rdi+44h], 0
mov dword ptr [rdi+48h], 0
mov dword ptr [rdi+4Ch], 0
mov dword ptr [rdi+50h], 0
add rdi, 58h ; 'X'
call _ZNSt3__110unique_ptrIN3MNN15QuantizedParamTENS_14default_deleteIS2_EEEC2B8nn200100ILb1EvEEv; std::unique_ptr<MNN::QuantizedParamT>::unique_ptr<true,void>(void)
mov rdi, [rsp+18h+var_10]
mov dword ptr [rdi+60h], 0
add rdi, 68h ; 'h'
call _ZNSt3__110unique_ptrIN3MNN15QuantizedParamTENS_14default_deleteIS2_EEEC2B8nn200100ILb1EvEEv; std::unique_ptr<MNN::QuantizedParamT>::unique_ptr<true,void>(void)
mov rdi, [rsp+18h+var_10]
add rdi, 70h ; 'p'
call _ZNSt3__110unique_ptrIN3MNN15QuantizedParamTENS_14default_deleteIS2_EEEC2B8nn200100ILb1EvEEv; std::unique_ptr<MNN::QuantizedParamT>::unique_ptr<true,void>(void)
mov rdi, [rsp+18h+var_10]
mov dword ptr [rdi+78h], 0
add rdi, 80h
call _ZNSt3__110unique_ptrIN3MNN15QuantizedParamTENS_14default_deleteIS2_EEEC2B8nn200100ILb1EvEEv; std::unique_ptr<MNN::QuantizedParamT>::unique_ptr<true,void>(void)
add rsp, 18h
retn
| _QWORD * MNN::TfQuantizedConv2DT::TfQuantizedConv2DT(MNN::TfQuantizedConv2DT *this)
{
std::vector<int>::vector[abi:nn200100](this);
*((_BYTE *)this + 24) = 0;
std::unique_ptr<MNN::Convolution2DCommonT>::unique_ptr[abi:nn200100]<true,void>((_QWORD *)this + 4);
std::vector<unsigned char>::vector[abi:nn200100]((_QWORD *)this + 5);
*((_DWORD *)this + 16) = 0;
*((_DWORD *)this + 17) = 0;
*((_DWORD *)this + 18) = 0;
*((_DWORD *)this + 19) = 0;
*((_DWORD *)this + 20) = 0;
std::unique_ptr<MNN::QuantizedParamT>::unique_ptr[abi:nn200100]<true,void>((_QWORD *)this + 11);
*((_DWORD *)this + 24) = 0;
std::unique_ptr<MNN::QuantizedParamT>::unique_ptr[abi:nn200100]<true,void>((_QWORD *)this + 13);
std::unique_ptr<MNN::QuantizedParamT>::unique_ptr[abi:nn200100]<true,void>((_QWORD *)this + 14);
*((_DWORD *)this + 30) = 0;
return std::unique_ptr<MNN::QuantizedParamT>::unique_ptr[abi:nn200100]<true,void>((_QWORD *)this + 16);
}
| TfQuantizedConv2DT:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV RDI,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x8],RDI
CALL 0x0010b260
MOV RDI,qword ptr [RSP + 0x8]
MOV byte ptr [RDI + 0x18],0x0
ADD RDI,0x20
CALL 0x00117a60
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x28
CALL 0x0010b290
MOV RDI,qword ptr [RSP + 0x8]
MOV dword ptr [RDI + 0x40],0x0
MOV dword ptr [RDI + 0x44],0x0
MOV dword ptr [RDI + 0x48],0x0
MOV dword ptr [RDI + 0x4c],0x0
MOV dword ptr [RDI + 0x50],0x0
ADD RDI,0x58
CALL 0x00116640
MOV RDI,qword ptr [RSP + 0x8]
MOV dword ptr [RDI + 0x60],0x0
ADD RDI,0x68
CALL 0x00116640
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x70
CALL 0x00116640
MOV RDI,qword ptr [RSP + 0x8]
MOV dword ptr [RDI + 0x78],0x0
ADD RDI,0x80
CALL 0x00116640
ADD RSP,0x18
RET
|
/* MNN::TfQuantizedConv2DT::TfQuantizedConv2DT() */
void __thiscall MNN::TfQuantizedConv2DT::TfQuantizedConv2DT(TfQuantizedConv2DT *this)
{
std::vector<int,std::allocator<int>>::vector_abi_nn200100_
((vector<int,std::allocator<int>> *)this);
this[0x18] = (TfQuantizedConv2DT)0x0;
_ZNSt3__110unique_ptrIN3MNN20Convolution2DCommonTENS_14default_deleteIS2_EEEC2B8nn200100ILb1EvEEv
(this + 0x20);
std::vector<unsigned_char,std::allocator<unsigned_char>>::vector_abi_nn200100_
((vector<unsigned_char,std::allocator<unsigned_char>> *)(this + 0x28));
*(int4 *)(this + 0x40) = 0;
*(int4 *)(this + 0x44) = 0;
*(int4 *)(this + 0x48) = 0;
*(int4 *)(this + 0x4c) = 0;
*(int4 *)(this + 0x50) = 0;
_ZNSt3__110unique_ptrIN3MNN15QuantizedParamTENS_14default_deleteIS2_EEEC2B8nn200100ILb1EvEEv
(this + 0x58);
*(int4 *)(this + 0x60) = 0;
_ZNSt3__110unique_ptrIN3MNN15QuantizedParamTENS_14default_deleteIS2_EEEC2B8nn200100ILb1EvEEv
(this + 0x68);
_ZNSt3__110unique_ptrIN3MNN15QuantizedParamTENS_14default_deleteIS2_EEEC2B8nn200100ILb1EvEEv
(this + 0x70);
*(int4 *)(this + 0x78) = 0;
_ZNSt3__110unique_ptrIN3MNN15QuantizedParamTENS_14default_deleteIS2_EEEC2B8nn200100ILb1EvEEv
(this + 0x80);
return;
}
| |
43,570 | rlFrustum | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rlgl.h | void rlFrustum(double left, double right, double bottom, double top, double znear, double zfar)
{
Matrix matFrustum = { 0 };
float rl = (float)(right - left);
float tb = (float)(top - bottom);
float fn = (float)(zfar - znear);
matFrustum.m0 = ((float) znear*2.0f)/rl;
matFrustum.m1 = 0.0f;
matFrustum.m2 = 0.0f;
matFrustum.m3 = 0.0f;
matFrustum.m4 = 0.0f;
matFrustum.m5 = ((float) znear*2.0f)/tb;
matFrustum.m6 = 0.0f;
matFrustum.m7 = 0.0f;
matFrustum.m8 = ((float)right + (float)left)/rl;
matFrustum.m9 = ((float)top + (float)bottom)/tb;
matFrustum.m10 = -((float)zfar + (float)znear)/fn;
matFrustum.m11 = -1.0f;
matFrustum.m12 = 0.0f;
matFrustum.m13 = 0.0f;
matFrustum.m14 = -((float)zfar*(float)znear*2.0f)/fn;
matFrustum.m15 = 0.0f;
*RLGL.State.currentMatrix = rlMatrixMultiply(*RLGL.State.currentMatrix, matFrustum);
} | O0 | c | rlFrustum:
pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd %xmm3, -0x20(%rbp)
movsd %xmm4, -0x28(%rbp)
movsd %xmm5, -0x30(%rbp)
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0xa2d0
movsd -0x10(%rbp), %xmm0
subsd -0x8(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x74(%rbp)
movsd -0x20(%rbp), %xmm0
subsd -0x18(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x78(%rbp)
movsd -0x30(%rbp), %xmm0
subsd -0x28(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x7c(%rbp)
movsd -0x28(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movss 0xf7cd9(%rip), %xmm1 # 0x1a801c
mulss %xmm1, %xmm0
divss -0x74(%rbp), %xmm0
movss %xmm0, -0x70(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x60(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x50(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x40(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x6c(%rbp)
movsd -0x28(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movss 0xf7c9a(%rip), %xmm1 # 0x1a801c
mulss %xmm1, %xmm0
divss -0x78(%rbp), %xmm0
movss %xmm0, -0x5c(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x4c(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x3c(%rbp)
movsd -0x10(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movsd -0x8(%rbp), %xmm1
cvtsd2ss %xmm1, %xmm1
addss %xmm1, %xmm0
divss -0x74(%rbp), %xmm0
movss %xmm0, -0x68(%rbp)
movsd -0x20(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movsd -0x18(%rbp), %xmm1
cvtsd2ss %xmm1, %xmm1
addss %xmm1, %xmm0
divss -0x78(%rbp), %xmm0
movss %xmm0, -0x58(%rbp)
movsd -0x30(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movsd -0x28(%rbp), %xmm1
cvtsd2ss %xmm1, %xmm1
addss %xmm1, %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax # imm = 0x80000000
movd %eax, %xmm0
divss -0x7c(%rbp), %xmm0
movss %xmm0, -0x48(%rbp)
movss 0xf7b0f(%rip), %xmm0 # 0x1a7f24
movss %xmm0, -0x38(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x64(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x54(%rbp)
movsd -0x30(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movsd -0x28(%rbp), %xmm1
cvtsd2ss %xmm1, %xmm1
mulss %xmm1, %xmm0
movss 0xf7bd4(%rip), %xmm1 # 0x1a801c
mulss %xmm1, %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax # imm = 0x80000000
movd %eax, %xmm0
divss -0x7c(%rbp), %xmm0
movss %xmm0, -0x44(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x34(%rbp)
movq 0x169dae(%rip), %rax # 0x21a220
movq %rax, -0x108(%rbp)
movq 0x169da0(%rip), %rsi # 0x21a220
leaq -0x100(%rbp), %rdi
movl $0x40, %edx
callq 0xa400
movups -0x70(%rbp), %xmm0
movups -0x60(%rbp), %xmm1
movups -0x50(%rbp), %xmm2
movups -0x40(%rbp), %xmm3
movq %rsp, %rax
movups %xmm3, 0x70(%rax)
movups %xmm2, 0x60(%rax)
movups %xmm1, 0x50(%rax)
movups %xmm0, 0x40(%rax)
movups -0x100(%rbp), %xmm0
movups -0xf0(%rbp), %xmm1
movups -0xe0(%rbp), %xmm2
movups -0xd0(%rbp), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0xbc(%rbp), %rdi
callq 0xaf840
movq -0x108(%rbp), %rdi
leaq -0xbc(%rbp), %rsi
movl $0x40, %edx
callq 0xa400
addq $0x190, %rsp # imm = 0x190
popq %rbp
retq
nopl (%rax)
| rlFrustum:
push rbp
mov rbp, rsp
sub rsp, 190h
movsd [rbp+var_8], xmm0
movsd [rbp+var_10], xmm1
movsd [rbp+var_18], xmm2
movsd [rbp+var_20], xmm3
movsd [rbp+var_28], xmm4
movsd [rbp+var_30], xmm5
lea rdi, [rbp+var_70]
xor esi, esi
mov edx, 40h ; '@'
call _memset
movsd xmm0, [rbp+var_10]
subsd xmm0, [rbp+var_8]
cvtsd2ss xmm0, xmm0
movss [rbp+var_74], xmm0
movsd xmm0, [rbp+var_20]
subsd xmm0, [rbp+var_18]
cvtsd2ss xmm0, xmm0
movss [rbp+var_78], xmm0
movsd xmm0, [rbp+var_30]
subsd xmm0, [rbp+var_28]
cvtsd2ss xmm0, xmm0
movss [rbp+var_7C], xmm0
movsd xmm0, [rbp+var_28]
cvtsd2ss xmm0, xmm0
movss xmm1, cs:dword_1A801C
mulss xmm0, xmm1
divss xmm0, [rbp+var_74]
movss dword ptr [rbp+var_70], xmm0
xorps xmm0, xmm0
movss dword ptr [rbp+var_60], xmm0
xorps xmm0, xmm0
movss dword ptr [rbp+var_50], xmm0
xorps xmm0, xmm0
movss dword ptr [rbp+var_40], xmm0
xorps xmm0, xmm0
movss dword ptr [rbp+var_70+4], xmm0
movsd xmm0, [rbp+var_28]
cvtsd2ss xmm0, xmm0
movss xmm1, cs:dword_1A801C
mulss xmm0, xmm1
divss xmm0, [rbp+var_78]
movss dword ptr [rbp+var_60+4], xmm0
xorps xmm0, xmm0
movss dword ptr [rbp+var_50+4], xmm0
xorps xmm0, xmm0
movss dword ptr [rbp+var_40+4], xmm0
movsd xmm0, [rbp+var_10]
cvtsd2ss xmm0, xmm0
movsd xmm1, [rbp+var_8]
cvtsd2ss xmm1, xmm1
addss xmm0, xmm1
divss xmm0, [rbp+var_74]
movss dword ptr [rbp+var_70+8], xmm0
movsd xmm0, [rbp+var_20]
cvtsd2ss xmm0, xmm0
movsd xmm1, [rbp+var_18]
cvtsd2ss xmm1, xmm1
addss xmm0, xmm1
divss xmm0, [rbp+var_78]
movss dword ptr [rbp+var_60+8], xmm0
movsd xmm0, [rbp+var_30]
cvtsd2ss xmm0, xmm0
movsd xmm1, [rbp+var_28]
cvtsd2ss xmm1, xmm1
addss xmm0, xmm1
movd eax, xmm0
xor eax, 80000000h
movd xmm0, eax
divss xmm0, [rbp+var_7C]
movss dword ptr [rbp+var_50+8], xmm0
movss xmm0, cs:dword_1A7F24
movss dword ptr [rbp+var_40+8], xmm0
xorps xmm0, xmm0
movss dword ptr [rbp+var_70+0Ch], xmm0
xorps xmm0, xmm0
movss dword ptr [rbp+var_60+0Ch], xmm0
movsd xmm0, [rbp+var_30]
cvtsd2ss xmm0, xmm0
movsd xmm1, [rbp+var_28]
cvtsd2ss xmm1, xmm1
mulss xmm0, xmm1
movss xmm1, cs:dword_1A801C
mulss xmm0, xmm1
movd eax, xmm0
xor eax, 80000000h
movd xmm0, eax
divss xmm0, [rbp+var_7C]
movss dword ptr [rbp+var_50+0Ch], xmm0
xorps xmm0, xmm0
movss dword ptr [rbp+var_40+0Ch], xmm0
mov rax, cs:qword_21A220
mov [rbp+var_108], rax
mov rsi, cs:qword_21A220
lea rdi, [rbp+var_100]
mov edx, 40h ; '@'
call _memcpy
movups xmm0, [rbp+var_70]
movups xmm1, [rbp+var_60]
movups xmm2, [rbp+var_50]
movups xmm3, [rbp+var_40]
mov rax, rsp
movups xmmword ptr [rax+70h], xmm3
movups xmmword ptr [rax+60h], xmm2
movups xmmword ptr [rax+50h], xmm1
movups xmmword ptr [rax+40h], xmm0
movups xmm0, [rbp+var_100]
movups xmm1, [rbp+var_F0]
movups xmm2, [rbp+var_E0]
movups xmm3, [rbp+var_D0]
movups xmmword ptr [rax+30h], xmm3
movups xmmword ptr [rax+20h], xmm2
movups xmmword ptr [rax+10h], xmm1
movups xmmword ptr [rax], xmm0
lea rdi, [rbp+var_BC]
call rlMatrixMultiply
mov rdi, [rbp+var_108]
lea rsi, [rbp+var_BC]
mov edx, 40h ; '@'
call _memcpy
add rsp, 190h
pop rbp
retn
| long long rlFrustum(double a1, double a2, double a3, double a4, double a5, double a6, double a7, double a8)
{
float v8; // xmm0_4
float v9; // xmm0_4
float v10; // xmm0_4
float v11; // xmm0_4
float v12; // xmm0_4
float v13; // xmm0_4
float v14; // xmm1_4
float v15; // xmm0_4
float v16; // xmm1_4
__m128i v17; // xmm0
float v18; // xmm1_4
__m128i v19; // xmm0
float v20; // xmm1_4
int v21; // esi
int v22; // edx
int v23; // ecx
int v24; // r8d
int v25; // r9d
double v26; // xmm4_8
double v27; // xmm5_8
long long v29; // [rsp+88h] [rbp-108h]
double v30[2]; // [rsp+90h] [rbp-100h] BYREF
double v31; // [rsp+A0h] [rbp-F0h]
double v32; // [rsp+A8h] [rbp-E8h]
double v33; // [rsp+B0h] [rbp-E0h]
double v34; // [rsp+B8h] [rbp-D8h]
double v35; // [rsp+C0h] [rbp-D0h]
double v36; // [rsp+C8h] [rbp-C8h]
float v37[16]; // [rsp+D4h] [rbp-BCh] BYREF
float v38; // [rsp+114h] [rbp-7Ch]
float v39; // [rsp+118h] [rbp-78h]
float v40; // [rsp+11Ch] [rbp-74h]
long long v41; // [rsp+120h] [rbp-70h] BYREF
long long v42; // [rsp+128h] [rbp-68h]
long long v43; // [rsp+130h] [rbp-60h]
long long v44; // [rsp+138h] [rbp-58h]
long long v45; // [rsp+140h] [rbp-50h]
long long v46; // [rsp+148h] [rbp-48h]
long long v47; // [rsp+150h] [rbp-40h]
long long v48; // [rsp+158h] [rbp-38h]
double v49; // [rsp+160h] [rbp-30h]
double v50; // [rsp+168h] [rbp-28h]
double v51; // [rsp+170h] [rbp-20h]
double v52; // [rsp+178h] [rbp-18h]
double v53; // [rsp+180h] [rbp-10h]
double v54; // [rsp+188h] [rbp-8h]
v54 = a1;
v53 = a2;
v52 = a3;
v51 = a4;
v50 = a5;
v49 = a6;
memset(&v41, 0LL, 64LL);
v8 = v53 - v54;
v40 = v8;
v9 = v51 - v52;
v39 = v9;
v10 = v49 - v50;
v38 = v10;
v11 = v50;
*(float *)&v41 = (float)(v11 * 2.0) / v40;
LODWORD(v43) = 0;
v45 = 0LL;
v47 = 0LL;
HIDWORD(v41) = 0;
v12 = v50;
*((float *)&v43 + 1) = (float)(v12 * 2.0) / v39;
v13 = v53;
v14 = v54;
*(float *)&v42 = (float)(v13 + v14) / v40;
v15 = v51;
v16 = v52;
*(float *)&v44 = (float)(v15 + v16) / v39;
v17 = (__m128i)*(unsigned long long *)&v49;
*(float *)v17.m128i_i32 = v49;
v18 = v50;
*(float *)v17.m128i_i32 = *(float *)v17.m128i_i32 + v18;
*(float *)&v46 = COERCE_FLOAT(_mm_cvtsi128_si32(v17) ^ 0x80000000) / v38;
v48 = 3212836864LL;
HIDWORD(v42) = 0;
HIDWORD(v44) = 0;
v19 = (__m128i)*(unsigned long long *)&v49;
*(float *)v19.m128i_i32 = v49;
v20 = v50;
*(float *)v19.m128i_i32 = (float)(*(float *)v19.m128i_i32 * v20) * 2.0;
*((float *)&v46 + 1) = COERCE_FLOAT(_mm_cvtsi128_si32(v19) ^ 0x80000000) / v38;
v29 = qword_21A220;
v21 = qword_21A220;
memcpy(v30, qword_21A220, 64LL);
rlMatrixMultiply(
v37,
v21,
v22,
v23,
v24,
v25,
v30[0],
v31,
v33,
v35,
v26,
v27,
a7,
a8,
v30[0],
v30[1],
v31,
v32,
v33,
v34,
v35,
v36,
v41,
v42,
v43,
v44,
v45,
v46,
v47,
v48);
return memcpy(v29, v37, 64LL);
}
| rlFrustum:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x190
MOVSD qword ptr [RBP + -0x8],XMM0
MOVSD qword ptr [RBP + -0x10],XMM1
MOVSD qword ptr [RBP + -0x18],XMM2
MOVSD qword ptr [RBP + -0x20],XMM3
MOVSD qword ptr [RBP + -0x28],XMM4
MOVSD qword ptr [RBP + -0x30],XMM5
LEA RDI,[RBP + -0x70]
XOR ESI,ESI
MOV EDX,0x40
CALL 0x0010a2d0
MOVSD XMM0,qword ptr [RBP + -0x10]
SUBSD XMM0,qword ptr [RBP + -0x8]
CVTSD2SS XMM0,XMM0
MOVSS dword ptr [RBP + -0x74],XMM0
MOVSD XMM0,qword ptr [RBP + -0x20]
SUBSD XMM0,qword ptr [RBP + -0x18]
CVTSD2SS XMM0,XMM0
MOVSS dword ptr [RBP + -0x78],XMM0
MOVSD XMM0,qword ptr [RBP + -0x30]
SUBSD XMM0,qword ptr [RBP + -0x28]
CVTSD2SS XMM0,XMM0
MOVSS dword ptr [RBP + -0x7c],XMM0
MOVSD XMM0,qword ptr [RBP + -0x28]
CVTSD2SS XMM0,XMM0
MOVSS XMM1,dword ptr [0x002a801c]
MULSS XMM0,XMM1
DIVSS XMM0,dword ptr [RBP + -0x74]
MOVSS dword ptr [RBP + -0x70],XMM0
XORPS XMM0,XMM0
MOVSS dword ptr [RBP + -0x60],XMM0
XORPS XMM0,XMM0
MOVSS dword ptr [RBP + -0x50],XMM0
XORPS XMM0,XMM0
MOVSS dword ptr [RBP + -0x40],XMM0
XORPS XMM0,XMM0
MOVSS dword ptr [RBP + -0x6c],XMM0
MOVSD XMM0,qword ptr [RBP + -0x28]
CVTSD2SS XMM0,XMM0
MOVSS XMM1,dword ptr [0x002a801c]
MULSS XMM0,XMM1
DIVSS XMM0,dword ptr [RBP + -0x78]
MOVSS dword ptr [RBP + -0x5c],XMM0
XORPS XMM0,XMM0
MOVSS dword ptr [RBP + -0x4c],XMM0
XORPS XMM0,XMM0
MOVSS dword ptr [RBP + -0x3c],XMM0
MOVSD XMM0,qword ptr [RBP + -0x10]
CVTSD2SS XMM0,XMM0
MOVSD XMM1,qword ptr [RBP + -0x8]
CVTSD2SS XMM1,XMM1
ADDSS XMM0,XMM1
DIVSS XMM0,dword ptr [RBP + -0x74]
MOVSS dword ptr [RBP + -0x68],XMM0
MOVSD XMM0,qword ptr [RBP + -0x20]
CVTSD2SS XMM0,XMM0
MOVSD XMM1,qword ptr [RBP + -0x18]
CVTSD2SS XMM1,XMM1
ADDSS XMM0,XMM1
DIVSS XMM0,dword ptr [RBP + -0x78]
MOVSS dword ptr [RBP + -0x58],XMM0
MOVSD XMM0,qword ptr [RBP + -0x30]
CVTSD2SS XMM0,XMM0
MOVSD XMM1,qword ptr [RBP + -0x28]
CVTSD2SS XMM1,XMM1
ADDSS XMM0,XMM1
MOVD EAX,XMM0
XOR EAX,0x80000000
MOVD XMM0,EAX
DIVSS XMM0,dword ptr [RBP + -0x7c]
MOVSS dword ptr [RBP + -0x48],XMM0
MOVSS XMM0,dword ptr [0x002a7f24]
MOVSS dword ptr [RBP + -0x38],XMM0
XORPS XMM0,XMM0
MOVSS dword ptr [RBP + -0x64],XMM0
XORPS XMM0,XMM0
MOVSS dword ptr [RBP + -0x54],XMM0
MOVSD XMM0,qword ptr [RBP + -0x30]
CVTSD2SS XMM0,XMM0
MOVSD XMM1,qword ptr [RBP + -0x28]
CVTSD2SS XMM1,XMM1
MULSS XMM0,XMM1
MOVSS XMM1,dword ptr [0x002a801c]
MULSS XMM0,XMM1
MOVD EAX,XMM0
XOR EAX,0x80000000
MOVD XMM0,EAX
DIVSS XMM0,dword ptr [RBP + -0x7c]
MOVSS dword ptr [RBP + -0x44],XMM0
XORPS XMM0,XMM0
MOVSS dword ptr [RBP + -0x34],XMM0
MOV RAX,qword ptr [0x0031a220]
MOV qword ptr [RBP + -0x108],RAX
MOV RSI,qword ptr [0x0031a220]
LEA RDI,[RBP + -0x100]
MOV EDX,0x40
CALL 0x0010a400
MOVUPS XMM0,xmmword ptr [RBP + -0x70]
MOVUPS XMM1,xmmword ptr [RBP + -0x60]
MOVUPS XMM2,xmmword ptr [RBP + -0x50]
MOVUPS XMM3,xmmword ptr [RBP + -0x40]
MOV RAX,RSP
MOVUPS xmmword ptr [RAX + 0x70],XMM3
MOVUPS xmmword ptr [RAX + 0x60],XMM2
MOVUPS xmmword ptr [RAX + 0x50],XMM1
MOVUPS xmmword ptr [RAX + 0x40],XMM0
MOVUPS XMM0,xmmword ptr [RBP + -0x100]
MOVUPS XMM1,xmmword ptr [RBP + -0xf0]
MOVUPS XMM2,xmmword ptr [RBP + -0xe0]
MOVUPS XMM3,xmmword ptr [RBP + -0xd0]
MOVUPS xmmword ptr [RAX + 0x30],XMM3
MOVUPS xmmword ptr [RAX + 0x20],XMM2
MOVUPS xmmword ptr [RAX + 0x10],XMM1
MOVUPS xmmword ptr [RAX],XMM0
LEA RDI,[RBP + -0xbc]
CALL 0x001af840
MOV RDI,qword ptr [RBP + -0x108]
LEA RSI,[RBP + -0xbc]
MOV EDX,0x40
CALL 0x0010a400
ADD RSP,0x190
POP RBP
RET
|
void rlFrustum(double param_1,double param_2,double param_3,double param_4,double param_5,
double param_6)
{
void *__dest;
int1 local_108 [68];
int1 local_c4 [64];
float local_84;
float local_80;
float local_7c;
float local_78 [3];
int4 uStack_6c;
int4 local_68;
float fStack_64;
float fStack_60;
int4 uStack_5c;
int4 local_58;
int4 uStack_54;
float fStack_50;
float fStack_4c;
int4 local_48;
int4 uStack_44;
int4 uStack_40;
int4 uStack_3c;
double local_38;
double local_30;
double local_28;
double local_20;
double local_18;
double local_10;
local_38 = param_6;
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
memset(local_78,0,0x40);
__dest = DAT_0031a220;
local_7c = (float)(local_18 - local_10);
local_80 = (float)(local_28 - local_20);
local_84 = (float)(local_38 - local_30);
local_78[0] = ((float)local_30 * DAT_002a801c) / local_7c;
local_68 = 0;
local_58 = 0;
local_48 = 0;
local_78[1] = 0.0;
fStack_64 = ((float)local_30 * DAT_002a801c) / local_80;
uStack_54 = 0;
uStack_44 = 0;
local_78[2] = ((float)local_18 + (float)local_10) / local_7c;
fStack_60 = ((float)local_28 + (float)local_20) / local_80;
fStack_50 = -((float)local_38 + (float)local_30) / local_84;
uStack_40 = DAT_002a7f24;
uStack_6c = 0;
uStack_5c = 0;
fStack_4c = -((float)local_38 * (float)local_30 * DAT_002a801c) / local_84;
uStack_3c = 0;
memcpy(local_108,DAT_0031a220,0x40);
rlMatrixMultiply(local_c4);
memcpy(__dest,local_c4,0x40);
return;
}
| |
43,571 | rlFrustum | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rlgl.h | void rlFrustum(double left, double right, double bottom, double top, double znear, double zfar)
{
Matrix matFrustum = { 0 };
float rl = (float)(right - left);
float tb = (float)(top - bottom);
float fn = (float)(zfar - znear);
matFrustum.m0 = ((float) znear*2.0f)/rl;
matFrustum.m1 = 0.0f;
matFrustum.m2 = 0.0f;
matFrustum.m3 = 0.0f;
matFrustum.m4 = 0.0f;
matFrustum.m5 = ((float) znear*2.0f)/tb;
matFrustum.m6 = 0.0f;
matFrustum.m7 = 0.0f;
matFrustum.m8 = ((float)right + (float)left)/rl;
matFrustum.m9 = ((float)top + (float)bottom)/tb;
matFrustum.m10 = -((float)zfar + (float)znear)/fn;
matFrustum.m11 = -1.0f;
matFrustum.m12 = 0.0f;
matFrustum.m13 = 0.0f;
matFrustum.m14 = -((float)zfar*(float)znear*2.0f)/fn;
matFrustum.m15 = 0.0f;
*RLGL.State.currentMatrix = rlMatrixMultiply(*RLGL.State.currentMatrix, matFrustum);
} | O2 | c | rlFrustum:
pushq %r14
pushq %rbx
subq $0x148, %rsp # imm = 0x148
cvtsd2ss %xmm1, %xmm6
subsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm7
cvtsd2ss %xmm3, %xmm8
subsd %xmm2, %xmm3
cvtsd2ss %xmm3, %xmm9
cvtsd2ss %xmm4, %xmm1
movaps %xmm1, %xmm3
addss %xmm1, %xmm3
movaps %xmm3, %xmm10
divss %xmm7, %xmm10
movss %xmm10, 0x80(%rsp)
cvtsd2ss %xmm5, %xmm10
andl $0x0, 0x84(%rsp)
subsd %xmm4, %xmm5
andl $0x0, 0xa4(%rsp)
cvtsd2ss %xmm5, %xmm4
cvtsd2ss %xmm0, %xmm0
addss %xmm6, %xmm0
divss %xmm7, %xmm0
movss %xmm0, 0x88(%rsp)
cvtsd2ss %xmm2, %xmm0
addss %xmm8, %xmm0
unpcklps %xmm0, %xmm3 # xmm3 = xmm3[0],xmm0[0],xmm3[1],xmm0[1]
unpcklps %xmm9, %xmm9 # xmm9 = xmm9[0,0,1,1]
divps %xmm9, %xmm3
movaps %xmm1, %xmm0
addss %xmm10, %xmm0
xorps 0x641d6(%rip), %xmm0 # 0xb5140
xorps %xmm2, %xmm2
movlhps %xmm3, %xmm2 # xmm2 = xmm2[0],xmm3[0]
movups %xmm2, 0x8c(%rsp)
andq $0x0, 0x9c(%rsp)
mulss %xmm10, %xmm1
mulss 0x6884a(%rip), %xmm1 # 0xb97d8
unpcklps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
unpcklps %xmm4, %xmm4 # xmm4 = xmm4[0,0,1,1]
divps %xmm4, %xmm0
movlps %xmm0, 0xa8(%rsp)
movaps 0x725aa(%rip), %xmm0 # 0xc3550
movups %xmm0, 0xb0(%rsp)
movq 0xd61cb(%rip), %r14 # 0x127180
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups 0x30(%r14), %xmm3
movaps %xmm3, 0xf0(%rsp)
movaps %xmm2, 0xe0(%rsp)
movaps %xmm1, 0xd0(%rsp)
movaps %xmm0, 0xc0(%rsp)
movups 0x80(%rsp), %xmm0
movups 0x90(%rsp), %xmm1
movups 0xa0(%rsp), %xmm2
movups 0xb0(%rsp), %xmm3
movups %xmm3, 0x70(%rsp)
movups %xmm2, 0x60(%rsp)
movups %xmm1, 0x50(%rsp)
movups %xmm0, 0x40(%rsp)
movaps 0xc0(%rsp), %xmm0
movaps 0xd0(%rsp), %xmm1
movaps 0xe0(%rsp), %xmm2
movaps 0xf0(%rsp), %xmm3
movups %xmm3, 0x30(%rsp)
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x108(%rsp), %rbx
movq %rbx, %rdi
callq 0x50806
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x20(%rbx), %xmm2
movups 0x30(%rbx), %xmm3
movups %xmm3, 0x30(%r14)
movups %xmm2, 0x20(%r14)
movups %xmm1, 0x10(%r14)
movups %xmm0, (%r14)
addq $0x148, %rsp # imm = 0x148
popq %rbx
popq %r14
retq
| rlFrustum:
push r14
push rbx
sub rsp, 148h
cvtsd2ss xmm6, xmm1
subsd xmm1, xmm0
cvtsd2ss xmm7, xmm1
cvtsd2ss xmm8, xmm3
subsd xmm3, xmm2
cvtsd2ss xmm9, xmm3
cvtsd2ss xmm1, xmm4
movaps xmm3, xmm1
addss xmm3, xmm1
movaps xmm10, xmm3
divss xmm10, xmm7
movss dword ptr [rsp+158h+var_D8], xmm10
cvtsd2ss xmm10, xmm5
and dword ptr [rsp+158h+var_D8+4], 0
subsd xmm5, xmm4
and dword ptr [rsp+158h+var_BC+8], 0
cvtsd2ss xmm4, xmm5
cvtsd2ss xmm0, xmm0
addss xmm0, xmm6
divss xmm0, xmm7
movss dword ptr [rsp+158h+var_D8+8], xmm0
cvtsd2ss xmm0, xmm2
addss xmm0, xmm8
unpcklps xmm3, xmm0
unpcklps xmm9, xmm9
divps xmm3, xmm9
movaps xmm0, xmm1
addss xmm0, xmm10
xorps xmm0, cs:xmmword_B5140
xorps xmm2, xmm2
movlhps xmm2, xmm3
movups [rsp+158h+var_D8+0Ch], xmm2
and qword ptr [rsp+158h+var_BC], 0
mulss xmm1, xmm10
mulss xmm1, cs:dword_B97D8
unpcklps xmm0, xmm1
unpcklps xmm4, xmm4
divps xmm0, xmm4
movlps qword ptr [rsp+158h+var_BC+0Ch], xmm0
movaps xmm0, cs:xmmword_C3550
movups [rsp+158h+var_A8], xmm0
mov r14, cs:qword_127180
movups xmm0, xmmword ptr [r14]
movups xmm1, xmmword ptr [r14+10h]
movups xmm2, xmmword ptr [r14+20h]
movups xmm3, xmmword ptr [r14+30h]
movaps [rsp+158h+var_68], xmm3
movaps [rsp+158h+var_78], xmm2
movaps [rsp+158h+var_88], xmm1
movaps [rsp+158h+var_98], xmm0
movups xmm0, [rsp+158h+var_D8]
movups xmm1, xmmword ptr [rsp+90h]
movups xmm2, [rsp+158h+var_BC+4]
movups xmm3, [rsp+158h+var_A8]
movups [rsp+158h+var_E8], xmm3
movups [rsp+158h+var_F8], xmm2
movups [rsp+158h+var_108], xmm1
movups [rsp+158h+var_118], xmm0
movaps xmm0, [rsp+158h+var_98]
movaps xmm1, [rsp+158h+var_88]
movaps xmm2, [rsp+158h+var_78]
movaps xmm3, [rsp+158h+var_68]
movups [rsp+158h+var_128], xmm3
movups [rsp+158h+var_138], xmm2
movups [rsp+158h+var_148], xmm1
movups [rsp+158h+var_158], xmm0
lea rbx, [rsp+158h+var_50]
mov rdi, rbx
call rlMatrixMultiply
movups xmm0, xmmword ptr [rbx]
movups xmm1, xmmword ptr [rbx+10h]
movups xmm2, xmmword ptr [rbx+20h]
movups xmm3, xmmword ptr [rbx+30h]
movups xmmword ptr [r14+30h], xmm3
movups xmmword ptr [r14+20h], xmm2
movups xmmword ptr [r14+10h], xmm1
movups xmmword ptr [r14], xmm0
add rsp, 148h
pop rbx
pop r14
retn
| __m128 * rlFrustum(
double a1,
__m128 a2,
double a3,
double a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
long long a9,
long long a10,
long long a11,
long long a12,
long long a13,
long long a14)
{
float v14; // xmm10_4
__m128 v15; // xmm0
__m128 v16; // xmm4
long long v17; // r14
__m128 v18; // xmm0
__m128 v19; // xmm1
__m128 v20; // xmm2
__m128 *result; // rax
__m128 v22; // xmm0
__m128 v23; // xmm1
__m128 v24; // xmm2
_DWORD v25[21]; // [rsp+9Ch] [rbp-BCh] BYREF
__m128 v26; // [rsp+F0h] [rbp-68h]
__m128 v27[5]; // [rsp+108h] [rbp-50h] BYREF
a7.m128_f32[0] = *(double *)a2.m128_u64;
*(double *)a2.m128_u64 = *(double *)a2.m128_u64 - a1;
a8.m128_f32[0] = *(double *)a2.m128_u64;
a2.m128_f32[0] = *(double *)a5.m128_u64;
v14 = *(double *)a6.m128_u64;
*(double *)a6.m128_u64 = *(double *)a6.m128_u64 - *(double *)a5.m128_u64;
a5.m128_f32[0] = *(double *)a6.m128_u64;
v15 = a2;
v15.m128_f32[0] = a2.m128_f32[0] + v14;
a2.m128_f32[0] = (float)(a2.m128_f32[0] * v14) * -2.0;
v16 = _mm_unpacklo_ps(a5, a5);
_mm_storel_ps((double *)&v25[3], _mm_div_ps(_mm_unpacklo_ps(_mm_xor_ps(v15, (__m128)xmmword_B5140), a2), v16));
*(_OWORD *)&v25[5] = xmmword_C3550;
v17 = qword_127180;
v18 = *(__m128 *)qword_127180;
v19 = *(__m128 *)(qword_127180 + 16);
v20 = *(__m128 *)(qword_127180 + 32);
v26 = *(__m128 *)(qword_127180 + 48);
*(__m128 *)&v25[17] = v20;
*(__m128 *)&v25[13] = v19;
*(__m128 *)&v25[9] = v18;
result = rlMatrixMultiply(v27, a10, a11, a12, a13, a14, v18, v19, v20, v26, v16, a6, a7, a8);
v22 = v27[0];
v23 = v27[1];
v24 = v27[2];
*(__m128 *)(v17 + 48) = v27[3];
*(__m128 *)(v17 + 32) = v24;
*(__m128 *)(v17 + 16) = v23;
*(__m128 *)v17 = v22;
return result;
}
| rlFrustum:
PUSH R14
PUSH RBX
SUB RSP,0x148
CVTSD2SS XMM6,XMM1
SUBSD XMM1,XMM0
CVTSD2SS XMM7,XMM1
CVTSD2SS XMM8,XMM3
SUBSD XMM3,XMM2
CVTSD2SS XMM9,XMM3
CVTSD2SS XMM1,XMM4
MOVAPS XMM3,XMM1
ADDSS XMM3,XMM1
MOVAPS XMM10,XMM3
DIVSS XMM10,XMM7
MOVSS dword ptr [RSP + 0x80],XMM10
CVTSD2SS XMM10,XMM5
AND dword ptr [RSP + 0x84],0x0
SUBSD XMM5,XMM4
AND dword ptr [RSP + 0xa4],0x0
CVTSD2SS XMM4,XMM5
CVTSD2SS XMM0,XMM0
ADDSS XMM0,XMM6
DIVSS XMM0,XMM7
MOVSS dword ptr [RSP + 0x88],XMM0
CVTSD2SS XMM0,XMM2
ADDSS XMM0,XMM8
UNPCKLPS XMM3,XMM0
UNPCKLPS XMM9,XMM9
DIVPS XMM3,XMM9
MOVAPS XMM0,XMM1
ADDSS XMM0,XMM10
XORPS XMM0,xmmword ptr [0x001b5140]
XORPS XMM2,XMM2
MOVLHPS XMM2,XMM3
MOVUPS xmmword ptr [RSP + 0x8c],XMM2
AND qword ptr [RSP + 0x9c],0x0
MULSS XMM1,XMM10
MULSS XMM1,dword ptr [0x001b97d8]
UNPCKLPS XMM0,XMM1
UNPCKLPS XMM4,XMM4
DIVPS XMM0,XMM4
MOVLPS qword ptr [RSP + 0xa8],XMM0
MOVAPS XMM0,xmmword ptr [0x001c3550]
MOVUPS xmmword ptr [RSP + 0xb0],XMM0
MOV R14,qword ptr [0x00227180]
MOVUPS XMM0,xmmword ptr [R14]
MOVUPS XMM1,xmmword ptr [R14 + 0x10]
MOVUPS XMM2,xmmword ptr [R14 + 0x20]
MOVUPS XMM3,xmmword ptr [R14 + 0x30]
MOVAPS xmmword ptr [RSP + 0xf0],XMM3
MOVAPS xmmword ptr [RSP + 0xe0],XMM2
MOVAPS xmmword ptr [RSP + 0xd0],XMM1
MOVAPS xmmword ptr [RSP + 0xc0],XMM0
MOVUPS XMM0,xmmword ptr [RSP + 0x80]
MOVUPS XMM1,xmmword ptr [RSP + 0x90]
MOVUPS XMM2,xmmword ptr [RSP + 0xa0]
MOVUPS XMM3,xmmword ptr [RSP + 0xb0]
MOVUPS xmmword ptr [RSP + 0x70],XMM3
MOVUPS xmmword ptr [RSP + 0x60],XMM2
MOVUPS xmmword ptr [RSP + 0x50],XMM1
MOVUPS xmmword ptr [RSP + 0x40],XMM0
MOVAPS XMM0,xmmword ptr [RSP + 0xc0]
MOVAPS XMM1,xmmword ptr [RSP + 0xd0]
MOVAPS XMM2,xmmword ptr [RSP + 0xe0]
MOVAPS XMM3,xmmword ptr [RSP + 0xf0]
MOVUPS xmmword ptr [RSP + 0x30],XMM3
MOVUPS xmmword ptr [RSP + 0x20],XMM2
MOVUPS xmmword ptr [RSP + 0x10],XMM1
MOVUPS xmmword ptr [RSP],XMM0
LEA RBX,[RSP + 0x108]
MOV RDI,RBX
CALL 0x00150806
MOVUPS XMM0,xmmword ptr [RBX]
MOVUPS XMM1,xmmword ptr [RBX + 0x10]
MOVUPS XMM2,xmmword ptr [RBX + 0x20]
MOVUPS XMM3,xmmword ptr [RBX + 0x30]
MOVUPS xmmword ptr [R14 + 0x30],XMM3
MOVUPS xmmword ptr [R14 + 0x20],XMM2
MOVUPS xmmword ptr [R14 + 0x10],XMM1
MOVUPS xmmword ptr [R14],XMM0
ADD RSP,0x148
POP RBX
POP R14
RET
| ||
43,572 | my_strcasecmp_mb | eloqsql/strings/ctype-mb.c | int my_strcasecmp_mb(CHARSET_INFO * cs,const char *s, const char *t)
{
register uint32 l;
register const uchar *map=cs->to_upper;
while (*s && *t)
{
/* Pointing after the '\0' is safe here. */
if ((l=my_ismbchar(cs, s, s + cs->mbmaxlen)))
{
while (l--)
if (*s++ != *t++)
return 1;
}
else if (my_ci_charlen(cs, (const uchar *) t, (const uchar *) t + cs->mbmaxlen) > 1)
return 1;
else if (map[(uchar) *s++] != map[(uchar) *t++])
return 1;
}
/* At least one of '*s' and '*t' is zero here. */
return (*t != *s);
} | O3 | c | my_strcasecmp_mb:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movb (%rsi), %cl
testb %cl, %cl
je 0xb30a7
cmpb $0x0, (%rbx)
je 0xb30a9
movq %rsi, %r15
movq %rdi, %r14
movq 0x50(%rdi), %r12
movl 0x9c(%r14), %edx
addq %r15, %rdx
movq 0xb8(%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0xc0(%rax)
cmpl $0x2, %eax
jge 0xb306c
movl 0x9c(%r14), %edx
addq %rbx, %rdx
movq 0xb8(%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0xc0(%rax)
movl %eax, %ecx
movl $0x1, %eax
cmpl $0x1, %ecx
jg 0xb30b7
movzbl (%r15), %ecx
movb (%r12,%rcx), %cl
movzbl (%rbx), %edx
cmpb (%r12,%rdx), %cl
jne 0xb30b7
incq %r15
incq %rbx
jmp 0xb3095
movl %eax, %eax
leaq (%r15,%rax), %rcx
leaq (%rbx,%rax), %rdx
xorl %esi, %esi
cmpl %esi, %eax
je 0xb308f
movb (%r15,%rsi), %dil
leaq 0x1(%rsi), %r8
cmpb (%rbx,%rsi), %dil
movq %r8, %rsi
je 0xb3078
jmp 0xb30b2
movq %rcx, %r15
movq %rdx, %rbx
movb (%r15), %cl
testb %cl, %cl
je 0xb30a7
cmpb $0x0, (%rbx)
jne 0xb3008
jmp 0xb30a9
xorl %ecx, %ecx
xorl %eax, %eax
cmpb %cl, (%rbx)
setne %al
jmp 0xb30b7
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| my_strcasecmp_mb:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov rbx, rdx
mov cl, [rsi]
test cl, cl
jz loc_B30A7
cmp byte ptr [rbx], 0
jz loc_B30A9
mov r15, rsi
mov r14, rdi
mov r12, [rdi+50h]
loc_B3008:
mov edx, [r14+9Ch]
add rdx, r15
mov rax, [r14+0B8h]
mov rdi, r14
mov rsi, r15
call qword ptr [rax+0C0h]
cmp eax, 2
jge short loc_B306C
mov edx, [r14+9Ch]
add rdx, rbx
mov rax, [r14+0B8h]
mov rdi, r14
mov rsi, rbx
call qword ptr [rax+0C0h]
mov ecx, eax
mov eax, 1
cmp ecx, 1
jg short loc_B30B7
movzx ecx, byte ptr [r15]
mov cl, [r12+rcx]
movzx edx, byte ptr [rbx]
cmp cl, [r12+rdx]
jnz short loc_B30B7
inc r15
inc rbx
jmp short loc_B3095
loc_B306C:
mov eax, eax
lea rcx, [r15+rax]
lea rdx, [rbx+rax]
xor esi, esi
loc_B3078:
cmp eax, esi
jz short loc_B308F
mov dil, [r15+rsi]
lea r8, [rsi+1]
cmp dil, [rbx+rsi]
mov rsi, r8
jz short loc_B3078
jmp short loc_B30B2
loc_B308F:
mov r15, rcx
mov rbx, rdx
loc_B3095:
mov cl, [r15]
test cl, cl
jz short loc_B30A7
cmp byte ptr [rbx], 0
jnz loc_B3008
jmp short loc_B30A9
loc_B30A7:
xor ecx, ecx
loc_B30A9:
xor eax, eax
cmp [rbx], cl
setnz al
jmp short loc_B30B7
loc_B30B2:
mov eax, 1
loc_B30B7:
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| _BOOL8 my_strcasecmp_mb(long long a1, unsigned __int8 *a2, _BYTE *a3)
{
_BYTE *v3; // rbx
unsigned __int8 v4; // cl
unsigned __int8 *v5; // r15
long long v6; // r12
int v7; // eax
int v8; // ecx
_BOOL8 result; // rax
long long i; // rsi
v3 = a3;
v4 = *a2;
if ( *a2 )
{
if ( *a3 )
{
v5 = a2;
v6 = *(_QWORD *)(a1 + 80);
do
{
v7 = (*(long long ( **)(long long, unsigned __int8 *, unsigned __int8 *))(*(_QWORD *)(a1 + 184) + 192LL))(
a1,
v5,
&v5[*(unsigned int *)(a1 + 156)]);
if ( v7 >= 2 )
{
for ( i = 0LL; v7 != (_DWORD)i; ++i )
{
if ( v5[i] != v3[i] )
return 1LL;
}
v5 += (unsigned int)v7;
v3 += (unsigned int)v7;
}
else
{
v8 = (*(long long ( **)(long long, _BYTE *, _BYTE *))(*(_QWORD *)(a1 + 184) + 192LL))(
a1,
v3,
&v3[*(unsigned int *)(a1 + 156)]);
result = 1LL;
if ( v8 > 1 || *(_BYTE *)(v6 + *v5) != *(_BYTE *)(v6 + (unsigned __int8)*v3) )
return result;
++v5;
++v3;
}
v4 = *v5;
if ( !*v5 )
goto LABEL_16;
}
while ( *v3 );
}
}
else
{
LABEL_16:
v4 = 0;
}
return *v3 != v4;
}
| my_strcasecmp_mb:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RBX,RDX
MOV CL,byte ptr [RSI]
TEST CL,CL
JZ 0x001b30a7
CMP byte ptr [RBX],0x0
JZ 0x001b30a9
MOV R15,RSI
MOV R14,RDI
MOV R12,qword ptr [RDI + 0x50]
LAB_001b3008:
MOV EDX,dword ptr [R14 + 0x9c]
ADD RDX,R15
MOV RAX,qword ptr [R14 + 0xb8]
MOV RDI,R14
MOV RSI,R15
CALL qword ptr [RAX + 0xc0]
CMP EAX,0x2
JGE 0x001b306c
MOV EDX,dword ptr [R14 + 0x9c]
ADD RDX,RBX
MOV RAX,qword ptr [R14 + 0xb8]
MOV RDI,R14
MOV RSI,RBX
CALL qword ptr [RAX + 0xc0]
MOV ECX,EAX
MOV EAX,0x1
CMP ECX,0x1
JG 0x001b30b7
MOVZX ECX,byte ptr [R15]
MOV CL,byte ptr [R12 + RCX*0x1]
MOVZX EDX,byte ptr [RBX]
CMP CL,byte ptr [R12 + RDX*0x1]
JNZ 0x001b30b7
INC R15
INC RBX
JMP 0x001b3095
LAB_001b306c:
MOV EAX,EAX
LEA RCX,[R15 + RAX*0x1]
LEA RDX,[RBX + RAX*0x1]
XOR ESI,ESI
LAB_001b3078:
CMP EAX,ESI
JZ 0x001b308f
MOV DIL,byte ptr [R15 + RSI*0x1]
LEA R8,[RSI + 0x1]
CMP DIL,byte ptr [RBX + RSI*0x1]
MOV RSI,R8
JZ 0x001b3078
JMP 0x001b30b2
LAB_001b308f:
MOV R15,RCX
MOV RBX,RDX
LAB_001b3095:
MOV CL,byte ptr [R15]
TEST CL,CL
JZ 0x001b30a7
CMP byte ptr [RBX],0x0
JNZ 0x001b3008
JMP 0x001b30a9
LAB_001b30a7:
XOR ECX,ECX
LAB_001b30a9:
XOR EAX,EAX
CMP byte ptr [RBX],CL
SETNZ AL
JMP 0x001b30b7
LAB_001b30b2:
MOV EAX,0x1
LAB_001b30b7:
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
bool my_strcasecmp_mb(long param_1,byte *param_2,byte *param_3)
{
byte *pbVar1;
byte *pbVar2;
long lVar3;
uint uVar4;
int iVar5;
byte bVar6;
byte *pbVar7;
long lVar8;
byte *pbVar9;
bVar6 = *param_2;
if (bVar6 == 0) {
LAB_001b30a7:
bVar6 = 0;
}
else if (*param_3 != 0) {
lVar3 = *(long *)(param_1 + 0x50);
pbVar7 = param_3;
do {
uVar4 = (**(code **)(*(long *)(param_1 + 0xb8) + 0xc0))
(param_1,param_2,param_2 + *(uint *)(param_1 + 0x9c));
if ((int)uVar4 < 2) {
iVar5 = (**(code **)(*(long *)(param_1 + 0xb8) + 0xc0))
(param_1,pbVar7,pbVar7 + *(uint *)(param_1 + 0x9c));
if (1 < iVar5) {
return true;
}
if (*(char *)(lVar3 + (ulong)*param_2) != *(char *)(lVar3 + (ulong)*pbVar7)) {
return true;
}
pbVar9 = param_2 + 1;
param_3 = pbVar7 + 1;
}
else {
pbVar9 = param_2 + uVar4;
param_3 = pbVar7 + uVar4;
lVar8 = 0;
while (uVar4 != (uint)lVar8) {
pbVar1 = param_2 + lVar8;
pbVar2 = pbVar7 + lVar8;
lVar8 = lVar8 + 1;
if (*pbVar1 != *pbVar2) {
return true;
}
}
}
bVar6 = *pbVar9;
if (bVar6 == 0) goto LAB_001b30a7;
pbVar7 = param_3;
param_2 = pbVar9;
} while (*param_3 != 0);
}
return *param_3 != bVar6;
}
| |
43,573 | mysql_stmt_reset_start | eloqsql/libmariadb/libmariadb/mariadb_async.c | int STDCALL
mysql_stmt_reset_start(my_bool *ret, MYSQL_STMT *stmt)
{
MK_ASYNC_START_BODY(
mysql_stmt_reset,
stmt->mysql,
{
WIN_SET_NONBLOCKING(stmt->mysql)
parms.stmt= stmt;
},
TRUE,
r_my_bool,
/* If stmt->mysql==NULL then we will not block so can call directly. */
if (!stmt->mysql)
{
*ret= mysql_stmt_reset(stmt);
return 0;
})
} | O0 | c | mysql_stmt_reset_start:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x58188
movq -0x18(%rbp), %rdi
callq 0x46b80
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x58296
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movb $0x1, 0x14(%rax)
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
leaq 0xe2(%rip), %rsi # 0x582a0
leaq -0x30(%rbp), %rdx
callq 0x59b10
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
movb $0x0, 0x15(%rax)
movq -0x28(%rbp), %rax
movb $0x0, 0x14(%rax)
cmpl $0x0, -0x1c(%rbp)
jle 0x581f6
movq -0x28(%rbp), %rax
movb $0x1, 0x15(%rax)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x58296
cmpl $0x0, -0x1c(%rbp)
jge 0x58282
jmp 0x58202
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movl $0x7d8, 0x90(%rax) # imm = 0x7D8
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
addq $0x297, %rdi # imm = 0x297
leaq 0x28c76(%rip), %rax # 0x80ea0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x14220
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movb $0x0, 0x29c(%rax)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
addq $0x97, %rdi
leaq 0x28c54(%rip), %rax # 0x80eb0
movq 0x40(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x14220
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movb $0x0, 0x296(%rax)
movq -0x10(%rbp), %rax
movb $0x1, (%rax)
jmp 0x5828f
movq -0x28(%rbp), %rax
movb 0x8(%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
| mysql_stmt_reset_start:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_18]
cmp qword ptr [rax+38h], 0
jnz short loc_58188
mov rdi, [rbp+var_18]
call mysql_stmt_reset
mov cl, al
mov rax, [rbp+var_10]
mov [rax], cl
mov [rbp+var_4], 0
jmp loc_58296
loc_58188:
mov rax, [rbp+var_18]
mov rax, [rax+38h]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov [rbp+var_28], rax
mov rax, [rbp+var_18]
mov [rbp+var_30], rax
mov rax, [rbp+var_28]
mov byte ptr [rax+14h], 1
mov rdi, [rbp+var_28]
add rdi, 38h ; '8'
lea rsi, mysql_stmt_reset_start_internal
lea rdx, [rbp+var_30]
call my_context_spawn
mov [rbp+var_1C], eax
mov rax, [rbp+var_28]
mov byte ptr [rax+15h], 0
mov rax, [rbp+var_28]
mov byte ptr [rax+14h], 0
cmp [rbp+var_1C], 0
jle short loc_581F6
mov rax, [rbp+var_28]
mov byte ptr [rax+15h], 1
mov rax, [rbp+var_28]
mov eax, [rax]
mov [rbp+var_4], eax
jmp loc_58296
loc_581F6:
cmp [rbp+var_1C], 0
jge loc_58282
jmp short $+2
loc_58202:
mov rax, [rbp+var_18]
mov rax, [rax+38h]
mov dword ptr [rax+90h], 7D8h
mov rax, [rbp+var_18]
mov rdi, [rax+38h]
add rdi, 297h
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [rbp+var_18]
mov rax, [rax+38h]
mov byte ptr [rax+29Ch], 0
mov rax, [rbp+var_18]
mov rdi, [rax+38h]
add rdi, 97h
lea rax, client_errors
mov rsi, [rax+40h]
mov edx, 1FFh
call _strncpy
mov rax, [rbp+var_18]
mov rax, [rax+38h]
mov byte ptr [rax+296h], 0
mov rax, [rbp+var_10]
mov byte ptr [rax], 1
jmp short loc_5828F
loc_58282:
mov rax, [rbp+var_28]
mov cl, [rax+8]
mov rax, [rbp+var_10]
mov [rax], cl
loc_5828F:
mov [rbp+var_4], 0
loc_58296:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long mysql_stmt_reset_start(char *a1, long long a2)
{
long long v3; // [rsp+0h] [rbp-30h] BYREF
_BYTE *v4; // [rsp+8h] [rbp-28h]
int v5; // [rsp+14h] [rbp-1Ch]
long long v6; // [rsp+18h] [rbp-18h]
char *v7; // [rsp+20h] [rbp-10h]
v7 = a1;
v6 = a2;
if ( *(_QWORD *)(a2 + 56) )
{
v4 = *(_BYTE **)(*(_QWORD *)(*(_QWORD *)(v6 + 56) + 1152LL) + 40LL);
v3 = v6;
v4[20] = 1;
v5 = my_context_spawn(v4 + 56, mysql_stmt_reset_start_internal, &v3);
v4[21] = 0;
v4[20] = 0;
if ( v5 <= 0 )
{
if ( v5 >= 0 )
{
*v7 = v4[8];
}
else
{
*(_DWORD *)(*(_QWORD *)(v6 + 56) + 144LL) = 2008;
strncpy(*(_QWORD *)(v6 + 56) + 663LL, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(*(_QWORD *)(v6 + 56) + 668LL) = 0;
strncpy(*(_QWORD *)(v6 + 56) + 151LL, client_errors[8], 511LL);
*(_BYTE *)(*(_QWORD *)(v6 + 56) + 662LL) = 0;
*v7 = 1;
}
return 0;
}
else
{
v4[21] = 1;
return *(unsigned int *)v4;
}
}
else
{
*v7 = mysql_stmt_reset(v6);
return 0;
}
}
| mysql_stmt_reset_start:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x38],0x0
JNZ 0x00158188
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00146b80
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],CL
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00158296
LAB_00158188:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x14],0x1
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x38
LEA RSI,[0x1582a0]
LEA RDX,[RBP + -0x30]
CALL 0x00159b10
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x15],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x14],0x0
CMP dword ptr [RBP + -0x1c],0x0
JLE 0x001581f6
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x15],0x1
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00158296
LAB_001581f6:
CMP dword ptr [RBP + -0x1c],0x0
JGE 0x00158282
JMP 0x00158202
LAB_00158202:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
MOV dword ptr [RAX + 0x90],0x7d8
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x38]
ADD RDI,0x297
LEA RAX,[0x180ea0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00114220
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
MOV byte ptr [RAX + 0x29c],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x38]
ADD RDI,0x97
LEA RAX,[0x180eb0]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x1ff
CALL 0x00114220
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
MOV byte ptr [RAX + 0x296],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],0x1
JMP 0x0015828f
LAB_00158282:
MOV RAX,qword ptr [RBP + -0x28]
MOV CL,byte ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],CL
LAB_0015828f:
MOV dword ptr [RBP + -0x4],0x0
LAB_00158296:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 mysql_stmt_reset_start(int1 *param_1,long param_2)
{
int1 uVar1;
long local_38;
int4 *local_30;
int local_24;
long local_20;
int1 *local_18;
int4 local_c;
local_20 = param_2;
local_18 = param_1;
if (*(long *)(param_2 + 0x38) == 0) {
uVar1 = mysql_stmt_reset(param_2);
*local_18 = uVar1;
local_c = 0;
}
else {
local_30 = *(int4 **)(*(long *)(*(long *)(param_2 + 0x38) + 0x480) + 0x28);
*(int1 *)(local_30 + 5) = 1;
local_38 = param_2;
local_24 = my_context_spawn(local_30 + 0xe,mysql_stmt_reset_start_internal,&local_38);
*(int1 *)((long)local_30 + 0x15) = 0;
*(int1 *)(local_30 + 5) = 0;
if (local_24 < 1) {
if (local_24 < 0) {
*(int4 *)(*(long *)(local_20 + 0x38) + 0x90) = 0x7d8;
strncpy((char *)(*(long *)(local_20 + 0x38) + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(*(long *)(local_20 + 0x38) + 0x29c) = 0;
strncpy((char *)(*(long *)(local_20 + 0x38) + 0x97),PTR_s_Client_run_out_of_memory_00180ef0,
0x1ff);
*(int1 *)(*(long *)(local_20 + 0x38) + 0x296) = 0;
*local_18 = 1;
}
else {
*local_18 = *(int1 *)(local_30 + 2);
}
local_c = 0;
}
else {
*(int1 *)((long)local_30 + 0x15) = 1;
local_c = *local_30;
}
}
return local_c;
}
| |
43,574 | plutovg_surface_create_uninitialized | dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-surface.c | static plutovg_surface_t* plutovg_surface_create_uninitialized(int width, int height)
{
if(width > STBI_MAX_DIMENSIONS || height > STBI_MAX_DIMENSIONS)
return NULL;
const size_t size = width * height * 4;
plutovg_surface_t* surface = malloc(size + sizeof(plutovg_surface_t));
if(surface == NULL)
return NULL;
surface->ref_count = 1;
surface->width = width;
surface->height = height;
surface->stride = width * 4;
surface->data = (uint8_t*)(surface + 1);
return surface;
} | O0 | c | plutovg_surface_create_uninitialized:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
cmpl $0x1000000, -0xc(%rbp) # imm = 0x1000000
jg 0x14220
cmpl $0x1000000, -0x10(%rbp) # imm = 0x1000000
jle 0x1422a
movq $0x0, -0x8(%rbp)
jmp 0x1429f
movl -0xc(%rbp), %eax
imull -0x10(%rbp), %eax
shll $0x2, %eax
cltq
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0x31c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1425c
movq $0x0, -0x8(%rbp)
jmp 0x1429f
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0xc(%rbp), %ecx
shll $0x2, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x20(%rbp), %rcx
addq $0x18, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| plutovg_surface_create_uninitialized:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_C], edi
mov [rbp+var_10], esi
cmp [rbp+var_C], 1000000h
jg short loc_14220
cmp [rbp+var_10], 1000000h
jle short loc_1422A
loc_14220:
mov [rbp+var_8], 0
jmp short loc_1429F
loc_1422A:
mov eax, [rbp+var_C]
imul eax, [rbp+var_10]
shl eax, 2
cdqe
mov [rbp+var_18], rax
mov rdi, [rbp+var_18]
add rdi, 18h
call _malloc
mov [rbp+var_20], rax
cmp [rbp+var_20], 0
jnz short loc_1425C
mov [rbp+var_8], 0
jmp short loc_1429F
loc_1425C:
mov rax, [rbp+var_20]
mov dword ptr [rax], 1
mov ecx, [rbp+var_C]
mov rax, [rbp+var_20]
mov [rax+4], ecx
mov ecx, [rbp+var_10]
mov rax, [rbp+var_20]
mov [rax+8], ecx
mov ecx, [rbp+var_C]
shl ecx, 2
mov rax, [rbp+var_20]
mov [rax+0Ch], ecx
mov rcx, [rbp+var_20]
add rcx, 18h
mov rax, [rbp+var_20]
mov [rax+10h], rcx
mov rax, [rbp+var_20]
mov [rbp+var_8], rax
loc_1429F:
mov rax, [rbp+var_8]
add rsp, 20h
pop rbp
retn
| long long plutovg_surface_create_uninitialized(int a1, int a2)
{
long long v3; // [rsp+0h] [rbp-20h]
if ( a1 > 0x1000000 || a2 > 0x1000000 )
return 0LL;
v3 = malloc(4 * a2 * a1 + 24LL);
if ( !v3 )
return 0LL;
*(_DWORD *)v3 = 1;
*(_DWORD *)(v3 + 4) = a1;
*(_DWORD *)(v3 + 8) = a2;
*(_DWORD *)(v3 + 12) = 4 * a1;
*(_QWORD *)(v3 + 16) = v3 + 24;
return v3;
}
| plutovg_surface_create_uninitialized:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0xc],EDI
MOV dword ptr [RBP + -0x10],ESI
CMP dword ptr [RBP + -0xc],0x1000000
JG 0x00114220
CMP dword ptr [RBP + -0x10],0x1000000
JLE 0x0011422a
LAB_00114220:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0011429f
LAB_0011422a:
MOV EAX,dword ptr [RBP + -0xc]
IMUL EAX,dword ptr [RBP + -0x10]
SHL EAX,0x2
CDQE
MOV qword ptr [RBP + -0x18],RAX
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x18
CALL 0x001031c0
MOV qword ptr [RBP + -0x20],RAX
CMP qword ptr [RBP + -0x20],0x0
JNZ 0x0011425c
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0011429f
LAB_0011425c:
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],0x1
MOV ECX,dword ptr [RBP + -0xc]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x4],ECX
MOV ECX,dword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x8],ECX
MOV ECX,dword ptr [RBP + -0xc]
SHL ECX,0x2
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0xc],ECX
MOV RCX,qword ptr [RBP + -0x20]
ADD RCX,0x18
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x8],RAX
LAB_0011429f:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x20
POP RBP
RET
|
int4 * plutovg_surface_create_uninitialized(int param_1,int param_2)
{
int4 *local_10;
if ((param_1 < 0x1000001) && (param_2 < 0x1000001)) {
local_10 = (int4 *)malloc((long)(param_1 * param_2 * 4) + 0x18);
if (local_10 == (int4 *)0x0) {
local_10 = (int4 *)0x0;
}
else {
*local_10 = 1;
local_10[1] = param_1;
local_10[2] = param_2;
local_10[3] = param_1 << 2;
*(int4 **)(local_10 + 4) = local_10 + 6;
}
}
else {
local_10 = (int4 *)0x0;
}
return local_10;
}
| |
43,575 | plutovg_surface_create_uninitialized | dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-surface.c | static plutovg_surface_t* plutovg_surface_create_uninitialized(int width, int height)
{
if(width > STBI_MAX_DIMENSIONS || height > STBI_MAX_DIMENSIONS)
return NULL;
const size_t size = width * height * 4;
plutovg_surface_t* surface = malloc(size + sizeof(plutovg_surface_t));
if(surface == NULL)
return NULL;
surface->ref_count = 1;
surface->width = width;
surface->height = height;
surface->stride = width * 4;
surface->data = (uint8_t*)(surface + 1);
return surface;
} | O1 | c | plutovg_surface_create_uninitialized:
movl $0x1000001, %eax # imm = 0x1000001
cmpl %eax, %edi
setge %cl
cmpl %eax, %esi
setge %al
orb %cl, %al
je 0xd7c8
xorl %eax, %eax
retq
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movl %edi, %ebx
movl %edi, %eax
imull %esi, %eax
shll $0x2, %eax
movslq %eax, %rdi
addq $0x18, %rdi
callq 0x31b0
testq %rax, %rax
je 0xd807
movl $0x1, (%rax)
movl %ebx, 0x4(%rax)
movl %ebp, 0x8(%rax)
shll $0x2, %ebx
movl %ebx, 0xc(%rax)
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, 0x10(%rax)
jmp 0xd809
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| plutovg_surface_create_uninitialized:
mov eax, 1000001h
cmp edi, eax
setnl cl
cmp esi, eax
setnl al
or al, cl
jz short loc_D7C8
xor eax, eax
retn
loc_D7C8:
push rbp
push rbx
push rax
mov ebp, esi
mov ebx, edi
mov eax, edi
imul eax, esi
shl eax, 2
movsxd rdi, eax
add rdi, 18h
call _malloc
test rax, rax
jz short loc_D807
mov dword ptr [rax], 1
mov [rax+4], ebx
mov [rax+8], ebp
shl ebx, 2
mov [rax+0Ch], ebx
mov rcx, rax
add rcx, 18h
mov [rax+10h], rcx
jmp short loc_D809
loc_D807:
xor eax, eax
loc_D809:
add rsp, 8
pop rbx
pop rbp
retn
| long long plutovg_surface_create_uninitialized(int a1, int a2)
{
long long result; // rax
if ( a1 >= 16777217 || a2 >= 16777217 )
return 0LL;
result = malloc(4 * a2 * a1 + 24LL);
if ( !result )
return 0LL;
*(_DWORD *)result = 1;
*(_DWORD *)(result + 4) = a1;
*(_DWORD *)(result + 8) = a2;
*(_DWORD *)(result + 12) = 4 * a1;
*(_QWORD *)(result + 16) = result + 24;
return result;
}
| plutovg_surface_create_uninitialized:
MOV EAX,0x1000001
CMP EDI,EAX
SETGE CL
CMP ESI,EAX
SETGE AL
OR AL,CL
JZ 0x0010d7c8
XOR EAX,EAX
RET
LAB_0010d7c8:
PUSH RBP
PUSH RBX
PUSH RAX
MOV EBP,ESI
MOV EBX,EDI
MOV EAX,EDI
IMUL EAX,ESI
SHL EAX,0x2
MOVSXD RDI,EAX
ADD RDI,0x18
CALL 0x001031b0
TEST RAX,RAX
JZ 0x0010d807
MOV dword ptr [RAX],0x1
MOV dword ptr [RAX + 0x4],EBX
MOV dword ptr [RAX + 0x8],EBP
SHL EBX,0x2
MOV dword ptr [RAX + 0xc],EBX
MOV RCX,RAX
ADD RCX,0x18
MOV qword ptr [RAX + 0x10],RCX
JMP 0x0010d809
LAB_0010d807:
XOR EAX,EAX
LAB_0010d809:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
int4 * plutovg_surface_create_uninitialized(int param_1,int param_2)
{
int4 *puVar1;
if (0x1000000 < param_2 || 0x1000000 < param_1) {
return (int4 *)0x0;
}
puVar1 = (int4 *)malloc((long)(param_1 * param_2 * 4) + 0x18);
if (puVar1 == (int4 *)0x0) {
puVar1 = (int4 *)0x0;
}
else {
*puVar1 = 1;
puVar1[1] = param_1;
puVar1[2] = param_2;
puVar1[3] = param_1 << 2;
*(int4 **)(puVar1 + 4) = puVar1 + 6;
}
return puVar1;
}
| |
43,576 | mysql_set_character_set | eloqsql/libmariadb/libmariadb/mariadb_lib.c | int STDCALL mysql_set_character_set(MYSQL *mysql, const char *csname)
{
const MARIADB_CHARSET_INFO *cs;
if (!csname)
goto error;
if ((cs= mysql_find_charset_name(csname)))
{
char buff[64];
snprintf(buff, 63, "SET NAMES %s", cs->csname);
if (!mysql_real_query(mysql, buff, (unsigned long)strlen(buff)))
{
mysql->charset= cs;
return(0);
}
return(mysql->net.last_errno);
}
error:
my_set_error(mysql, CR_CANT_READ_CHARSET, SQLSTATE_UNKNOWN,
0, csname, "compiled_in");
return(mysql->net.last_errno);
} | O0 | c | mysql_set_character_set:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x60(%rbp)
movq %rsi, -0x68(%rbp)
cmpq $0x0, -0x68(%rbp)
jne 0x7860c
jmp 0x78695
movq -0x68(%rbp), %rdi
callq 0x9ec50
movq %rax, -0x70(%rbp)
cmpq $0x0, %rax
je 0x78693
leaq -0x50(%rbp), %rdi
movq -0x70(%rbp), %rax
movq 0x8(%rax), %rcx
movl $0x3f, %esi
leaq 0x9d03a(%rip), %rdx # 0x115671
movb $0x0, %al
callq 0x3b590
movq -0x60(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x50(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3b4b0
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq %rax, %rdx
callq 0x77d00
cmpl $0x0, %eax
jne 0x78684
movq -0x70(%rbp), %rcx
movq -0x60(%rbp), %rax
movq %rcx, 0x2f0(%rax)
movl $0x0, -0x54(%rbp)
jmp 0x786cb
movq -0x60(%rbp), %rax
movl 0x90(%rax), %eax
movl %eax, -0x54(%rbp)
jmp 0x786cb
jmp 0x78695
movq -0x60(%rbp), %rdi
leaq 0x213450(%rip), %rax # 0x28baf0
movq (%rax), %rdx
movq -0x68(%rbp), %r8
movl $0x7e3, %esi # imm = 0x7E3
xorl %eax, %eax
movl %eax, %ecx
leaq 0x9cefe(%rip), %r9 # 0x1155b5
movb $0x0, %al
callq 0x70ce0
movq -0x60(%rbp), %rax
movl 0x90(%rax), %eax
movl %eax, -0x54(%rbp)
movl -0x54(%rbp), %eax
movl %eax, -0x84(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x786f5
movl -0x84(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
callq 0x3b340
nopw (%rax,%rax)
| mysql_set_character_set:
push rbp
mov rbp, rsp
sub rsp, 90h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_60], rdi
mov [rbp+var_68], rsi
cmp [rbp+var_68], 0
jnz short loc_7860C
jmp loc_78695
loc_7860C:
mov rdi, [rbp+var_68]
call mysql_find_charset_name
mov [rbp+var_70], rax
cmp rax, 0
jz short loc_78693
lea rdi, [rbp+var_50]
mov rax, [rbp+var_70]
mov rcx, [rax+8]
mov esi, 3Fh ; '?'
lea rdx, aSetNamesS; "SET NAMES %s"
mov al, 0
call _snprintf
mov rax, [rbp+var_60]
mov [rbp+var_80], rax
lea rax, [rbp+var_50]
mov [rbp+var_78], rax
lea rdi, [rbp+var_50]
call _strlen
mov rdi, [rbp+var_80]
mov rsi, [rbp+var_78]
mov rdx, rax
call mysql_real_query
cmp eax, 0
jnz short loc_78684
mov rcx, [rbp+var_70]
mov rax, [rbp+var_60]
mov [rax+2F0h], rcx
mov [rbp+var_54], 0
jmp short loc_786CB
loc_78684:
mov rax, [rbp+var_60]
mov eax, [rax+90h]
mov [rbp+var_54], eax
jmp short loc_786CB
loc_78693:
jmp short $+2
loc_78695:
mov rdi, [rbp+var_60]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
mov r8, [rbp+var_68]
mov esi, 7E3h
xor eax, eax
mov ecx, eax
lea r9, aCompiledIn; "compiled_in"
mov al, 0
call my_set_error
mov rax, [rbp+var_60]
mov eax, [rax+90h]
mov [rbp+var_54], eax
loc_786CB:
mov eax, [rbp+var_54]
mov [rbp+var_84], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_786F5
mov eax, [rbp+var_84]
add rsp, 90h
pop rbp
retn
loc_786F5:
call ___stack_chk_fail
| long long mysql_set_character_set(long long a1, long long a2)
{
long long v2; // rax
long long charset_name; // [rsp+20h] [rbp-70h]
_BYTE v6[72]; // [rsp+40h] [rbp-50h] BYREF
unsigned long long v7; // [rsp+88h] [rbp-8h]
v7 = __readfsqword(0x28u);
if ( a2 && (charset_name = mysql_find_charset_name(a2)) != 0 )
{
snprintf(v6, 63LL, "SET NAMES %s", *(const char **)(charset_name + 8));
v2 = strlen(v6);
if ( (unsigned int)mysql_real_query(a1, (long long)v6, v2) )
{
return *(unsigned int *)(a1 + 144);
}
else
{
*(_QWORD *)(a1 + 752) = charset_name;
return 0;
}
}
else
{
my_set_error(a1, 0x7E3u, (long long)SQLSTATE_UNKNOWN, 0LL, a2, "compiled_in");
return *(unsigned int *)(a1 + 144);
}
}
| mysql_set_character_set:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x60],RDI
MOV qword ptr [RBP + -0x68],RSI
CMP qword ptr [RBP + -0x68],0x0
JNZ 0x0017860c
JMP 0x00178695
LAB_0017860c:
MOV RDI,qword ptr [RBP + -0x68]
CALL 0x0019ec50
MOV qword ptr [RBP + -0x70],RAX
CMP RAX,0x0
JZ 0x00178693
LEA RDI,[RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x70]
MOV RCX,qword ptr [RAX + 0x8]
MOV ESI,0x3f
LEA RDX,[0x215671]
MOV AL,0x0
CALL 0x0013b590
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x80],RAX
LEA RAX,[RBP + -0x50]
MOV qword ptr [RBP + -0x78],RAX
LEA RDI,[RBP + -0x50]
CALL 0x0013b4b0
MOV RDI,qword ptr [RBP + -0x80]
MOV RSI,qword ptr [RBP + -0x78]
MOV RDX,RAX
CALL 0x00177d00
CMP EAX,0x0
JNZ 0x00178684
MOV RCX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RAX + 0x2f0],RCX
MOV dword ptr [RBP + -0x54],0x0
JMP 0x001786cb
LAB_00178684:
MOV RAX,qword ptr [RBP + -0x60]
MOV EAX,dword ptr [RAX + 0x90]
MOV dword ptr [RBP + -0x54],EAX
JMP 0x001786cb
LAB_00178693:
JMP 0x00178695
LAB_00178695:
MOV RDI,qword ptr [RBP + -0x60]
LEA RAX,[0x38baf0]
MOV RDX,qword ptr [RAX]
MOV R8,qword ptr [RBP + -0x68]
MOV ESI,0x7e3
XOR EAX,EAX
MOV ECX,EAX
LEA R9,[0x2155b5]
MOV AL,0x0
CALL 0x00170ce0
MOV RAX,qword ptr [RBP + -0x60]
MOV EAX,dword ptr [RAX + 0x90]
MOV dword ptr [RBP + -0x54],EAX
LAB_001786cb:
MOV EAX,dword ptr [RBP + -0x54]
MOV dword ptr [RBP + -0x84],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001786f5
MOV EAX,dword ptr [RBP + -0x84]
ADD RSP,0x90
POP RBP
RET
LAB_001786f5:
CALL 0x0013b340
|
int4 mysql_set_character_set(long param_1,long param_2)
{
int iVar1;
long lVar2;
size_t sVar3;
long in_FS_OFFSET;
int4 local_5c;
char local_58 [72];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if ((param_2 == 0) || (lVar2 = mysql_find_charset_name(param_2), lVar2 == 0)) {
my_set_error(param_1,0x7e3,SQLSTATE_UNKNOWN,0,param_2,"compiled_in");
local_5c = *(int4 *)(param_1 + 0x90);
}
else {
snprintf(local_58,0x3f,"SET NAMES %s",*(int8 *)(lVar2 + 8));
sVar3 = strlen(local_58);
iVar1 = mysql_real_query(param_1,local_58,sVar3);
if (iVar1 == 0) {
*(long *)(param_1 + 0x2f0) = lVar2;
local_5c = 0;
}
else {
local_5c = *(int4 *)(param_1 + 0x90);
}
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_5c;
}
| |
43,577 | LefDefParser::lefwStartArrayDefaultCap(int) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefwWriter.cpp | int
lefwStartArrayDefaultCap(int size)
{
if (!lefwFile)
return LEFW_UNINITIALIZED;
if (lefwState != LEFW_ARRAY_START &&
lefwState != LEFW_ARRAY)
return LEFW_BAD_ORDER;
if (lefwIsArrayDef)
return LEFW_BAD_ORDER;
if (lefwWriteEncrypt)
encPrint(lefwFile, (char*) " DEFAULTCAP %d\n", size);
else
fprintf(lefwFile, " DEFAULTCAP %d\n", size);
lefwLines++;
lefwIsArrayDef = 1;
return LEFW_OK;
} | O0 | cpp | LefDefParser::lefwStartArrayDefaultCap(int):
pushq %rax
movl %edi, (%rsp)
leaq 0x154e5(%rip), %rax # 0x32e00
cmpq $0x0, (%rax)
jne 0x1d92e
movl $0x1, 0x4(%rsp)
jmp 0x1d9d4
leaq 0x1571b(%rip), %rax # 0x33050
cmpl $0x2, (%rax)
je 0x1d953
leaq 0x1570f(%rip), %rax # 0x33050
cmpl $0x13, (%rax)
je 0x1d953
movl $0x2, 0x4(%rsp)
jmp 0x1d9d4
leaq 0x15722(%rip), %rax # 0x3307c
cmpl $0x0, (%rax)
je 0x1d969
movl $0x2, 0x4(%rsp)
jmp 0x1d9d4
cmpl $0x0, 0x1577c(%rip) # 0x330ec
je 0x1d98f
leaq 0x15487(%rip), %rax # 0x32e00
movq (%rax), %rdi
movl (%rsp), %edx
leaq 0xdbea(%rip), %rsi # 0x2b570
movb $0x0, %al
callq 0x289b0
jmp 0x1d9aa
leaq 0x1546a(%rip), %rax # 0x32e00
movq (%rax), %rdi
movl (%rsp), %edx
leaq 0xdbcd(%rip), %rsi # 0x2b570
movb $0x0, %al
callq 0x1100
leaq 0x1569b(%rip), %rax # 0x3304c
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x1568f(%rip), %rax # 0x3304c
movl %ecx, (%rax)
leaq 0x156b6(%rip), %rax # 0x3307c
movl $0x1, (%rax)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
popq %rcx
retq
nopw (%rax,%rax)
| _ZN12LefDefParser24lefwStartArrayDefaultCapEi:
push rax
mov [rsp+8+var_8], edi
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
cmp qword ptr [rax], 0
jnz short loc_1D92E
mov [rsp+8+var_4], 1
jmp loc_1D9D4
loc_1D92E:
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
cmp dword ptr [rax], 2
jz short loc_1D953
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
cmp dword ptr [rax], 13h
jz short loc_1D953
mov [rsp+8+var_4], 2
jmp loc_1D9D4
loc_1D953:
lea rax, _ZN12LefDefParser14lefwIsArrayDefE; LefDefParser::lefwIsArrayDef
cmp dword ptr [rax], 0
jz short loc_1D969
mov [rsp+8+var_4], 2
jmp short loc_1D9D4
loc_1D969:
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 0; LefDefParser::lefwWriteEncrypt
jz short loc_1D98F
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
mov edx, [rsp+8+var_8]
lea rsi, aDefaultcapD; " DEFAULTCAP %d\n"
mov al, 0
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp short loc_1D9AA
loc_1D98F:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
mov edx, [rsp+8+var_8]
lea rsi, aDefaultcapD; " DEFAULTCAP %d\n"
mov al, 0
call _fprintf
loc_1D9AA:
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov ecx, [rax]
add ecx, 1
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov [rax], ecx
lea rax, _ZN12LefDefParser14lefwIsArrayDefE; LefDefParser::lefwIsArrayDef
mov dword ptr [rax], 1
mov [rsp+8+var_4], 0
loc_1D9D4:
mov eax, [rsp+8+var_4]
pop rcx
retn
| long long LefDefParser::lefwStartArrayDefaultCap(
LefDefParser *this,
int a2,
long long a3,
int a4,
int a5,
int a6)
{
if ( *(_QWORD *)&LefDefParser::lefwFile )
{
if ( LefDefParser::lefwState == 2 || LefDefParser::lefwState == 19 )
{
if ( LefDefParser::lefwIsArrayDef )
{
return 2;
}
else
{
if ( LefDefParser::lefwWriteEncrypt )
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)" DEFAULTCAP %d\n", (_DWORD)this, a4, a5, a6);
else
fprintf(*(_QWORD *)&LefDefParser::lefwFile, " DEFAULTCAP %d\n", (_DWORD)this);
++LefDefParser::lefwLines;
LefDefParser::lefwIsArrayDef = 1;
return 0;
}
}
else
{
return 2;
}
}
else
{
return 1;
}
}
| lefwStartArrayDefaultCap:
PUSH RAX
MOV dword ptr [RSP],EDI
LEA RAX,[0x132e00]
CMP qword ptr [RAX],0x0
JNZ 0x0011d92e
MOV dword ptr [RSP + 0x4],0x1
JMP 0x0011d9d4
LAB_0011d92e:
LEA RAX,[0x133050]
CMP dword ptr [RAX],0x2
JZ 0x0011d953
LEA RAX,[0x133050]
CMP dword ptr [RAX],0x13
JZ 0x0011d953
MOV dword ptr [RSP + 0x4],0x2
JMP 0x0011d9d4
LAB_0011d953:
LEA RAX,[0x13307c]
CMP dword ptr [RAX],0x0
JZ 0x0011d969
MOV dword ptr [RSP + 0x4],0x2
JMP 0x0011d9d4
LAB_0011d969:
CMP dword ptr [0x001330ec],0x0
JZ 0x0011d98f
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
MOV EDX,dword ptr [RSP]
LEA RSI,[0x12b570]
MOV AL,0x0
CALL 0x001289b0
JMP 0x0011d9aa
LAB_0011d98f:
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
MOV EDX,dword ptr [RSP]
LEA RSI,[0x12b570]
MOV AL,0x0
CALL 0x00101100
LAB_0011d9aa:
LEA RAX,[0x13304c]
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
LEA RAX,[0x13304c]
MOV dword ptr [RAX],ECX
LEA RAX,[0x13307c]
MOV dword ptr [RAX],0x1
MOV dword ptr [RSP + 0x4],0x0
LAB_0011d9d4:
MOV EAX,dword ptr [RSP + 0x4]
POP RCX
RET
|
/* LefDefParser::lefwStartArrayDefaultCap(int) */
int4 LefDefParser::lefwStartArrayDefaultCap(int param_1)
{
int4 local_4;
if (lefwFile == (_IO_FILE *)0x0) {
local_4 = 1;
}
else if ((lefwState == 2) || (lefwState == 0x13)) {
if (lefwIsArrayDef == 0) {
if (lefwWriteEncrypt == 0) {
fprintf(lefwFile," DEFAULTCAP %d\n",param_1);
}
else {
encPrint(lefwFile," DEFAULTCAP %d\n",param_1);
}
lefwLines = lefwLines + 1;
lefwIsArrayDef = 1;
local_4 = 0;
}
else {
local_4 = 2;
}
}
else {
local_4 = 2;
}
return local_4;
}
| |
43,578 | processSource(std::shared_ptr<flux::common::Source> const&, bool, bool) | kvthweatt[P]FluxLang/src/main.cpp | void processSource(const std::shared_ptr<flux::common::Source>& source, bool lexOnly, bool parseOnly) {
try {
if (lexOnly) {
processLexing(source);
} else if (parseOnly) {
processParsing(source);
} else {
// Default: execute the program (for now, just parse it)
processParsing(source);
// TODO: Add type checking and execution steps here
std::cout << "\nExecution is not yet implemented." << std::endl;
}
} catch (const flux::common::Error& e) {
// Report error
e.report();
}
} | O0 | cpp | processSource(std::shared_ptr<flux::common::Source> const&, bool, bool):
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
andb $0x1, %cl
movb %cl, -0x9(%rbp)
andb $0x1, %al
movb %al, -0xa(%rbp)
testb $0x1, -0x9(%rbp)
je 0x8408
movq -0x8(%rbp), %rdi
callq 0x7af0
jmp 0x83bd
jmp 0x8455
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x846c
movq -0x18(%rbp), %rdi
callq 0x7100
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x8df72(%rip), %rsi # 0x96368
callq 0xd770
jmp 0x83fd
callq 0x7540
addq $0x30, %rsp
popq %rbp
retq
testb $0x1, -0xa(%rbp)
je 0x841b
movq -0x8(%rbp), %rdi
callq 0x8140
jmp 0x8419
jmp 0x8453
movq -0x8(%rbp), %rdi
callq 0x8140
jmp 0x8426
movq 0x8db8b(%rip), %rdi # 0x95fb8
leaq 0x59dca(%rip), %rsi # 0x621fe
callq 0x7330
movq %rax, -0x30(%rbp)
jmp 0x843f
movq -0x30(%rbp), %rdi
movq 0x8db36(%rip), %rsi # 0x95f80
callq 0x7360
jmp 0x8451
jmp 0x8453
jmp 0x8455
jmp 0x8402
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x7540
jmp 0x846a
jmp 0x846c
movq -0x18(%rbp), %rdi
callq 0x75a0
movq %rax, %rdi
callq 0x9430
nopl (%rax)
| _Z13processSourceRKSt10shared_ptrIN4flux6common6SourceEEbb:
push rbp
mov rbp, rsp
sub rsp, 30h
mov al, dl
mov cl, sil
mov [rbp+var_8], rdi
and cl, 1
mov [rbp+var_9], cl
and al, 1
mov [rbp+var_A], al
test [rbp+var_9], 1
jz short loc_8408
mov rdi, [rbp+var_8]
call _Z13processLexingRKSt10shared_ptrIN4flux6common6SourceEE; processLexing(std::shared_ptr<flux::common::Source> const&)
jmp short $+2
loc_83BD:
jmp loc_8455
mov rcx, rax
mov eax, edx
mov [rbp+var_18], rcx
mov [rbp+var_1C], eax
mov eax, [rbp+var_1C]
mov ecx, 1
cmp eax, ecx
jnz loc_846C
mov rdi, [rbp+var_18]; void *
call ___cxa_begin_catch
mov [rbp+var_28], rax
mov rdi, [rbp+var_28]; this
lea rsi, _ZN4flux6output13defaultWriterE; flux::output::Writer *
call _ZNK4flux6common5Error6reportERNS_6output6WriterE; flux::common::Error::report(flux::output::Writer &)
jmp short $+2
loc_83FD:
call ___cxa_end_catch
loc_8402:
add rsp, 30h
pop rbp
retn
loc_8408:
test [rbp+var_A], 1
jz short loc_841B
mov rdi, [rbp+var_8]
call _Z14processParsingRKSt10shared_ptrIN4flux6common6SourceEE; processParsing(std::shared_ptr<flux::common::Source> const&)
jmp short $+2
loc_8419:
jmp short loc_8453
loc_841B:
mov rdi, [rbp+var_8]
call _Z14processParsingRKSt10shared_ptrIN4flux6common6SourceEE; processParsing(std::shared_ptr<flux::common::Source> const&)
jmp short $+2
loc_8426:
mov rdi, cs:_ZSt4cout_ptr
lea rsi, aExecutionIsNot; "\nExecution is not yet implemented."
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rbp+var_30], rax
jmp short $+2
loc_843F:
mov rdi, [rbp+var_30]
mov rsi, cs:_ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6__ptr
call __ZNSolsEPFRSoS_E; std::ostream::operator<<(std::ostream & (*)(std::ostream &))
jmp short $+2
loc_8451:
jmp short $+2
loc_8453:
jmp short $+2
loc_8455:
jmp short loc_8402
mov rcx, rax
mov eax, edx
mov [rbp+var_18], rcx
mov [rbp+var_1C], eax
call ___cxa_end_catch
jmp short $+2
loc_846A:
jmp short $+2
loc_846C:
mov rdi, [rbp+var_18]
call __Unwind_Resume
mov rdi, rax
call __clang_call_terminate
| void processSource(long long a1, char a2, char a3)
{
long long v3; // [rsp+0h] [rbp-30h]
char v4; // [rsp+26h] [rbp-Ah]
v4 = a3 & 1;
if ( (a2 & 1) != 0 )
{
processLexing(a1);
}
else
{
processParsing(a1);
if ( (v4 & 1) == 0 )
{
v3 = std::operator<<<std::char_traits<char>>(&std::cout, "\nExecution is not yet implemented.");
std::ostream::operator<<(v3, &std::endl<char,std::char_traits<char>>);
}
}
}
| processSource:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV AL,DL
MOV CL,SIL
MOV qword ptr [RBP + -0x8],RDI
AND CL,0x1
MOV byte ptr [RBP + -0x9],CL
AND AL,0x1
MOV byte ptr [RBP + -0xa],AL
TEST byte ptr [RBP + -0x9],0x1
JZ 0x00108408
MOV RDI,qword ptr [RBP + -0x8]
LAB_001083b6:
CALL 0x00107af0
LAB_001083bb:
JMP 0x001083bd
LAB_001083bd:
JMP 0x00108455
LAB_00108402:
ADD RSP,0x30
POP RBP
RET
LAB_00108408:
TEST byte ptr [RBP + -0xa],0x1
JZ 0x0010841b
MOV RDI,qword ptr [RBP + -0x8]
LAB_00108412:
CALL 0x00108140
JMP 0x00108419
LAB_00108419:
JMP 0x00108453
LAB_0010841b:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00108140
JMP 0x00108426
LAB_00108426:
MOV RDI,qword ptr [0x00195fb8]
LEA RSI,[0x1621fe]
CALL 0x00107330
MOV qword ptr [RBP + -0x30],RAX
JMP 0x0010843f
LAB_0010843f:
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [0x00195f80]
CALL 0x00107360
JMP 0x00108451
LAB_00108451:
JMP 0x00108453
LAB_00108453:
JMP 0x00108455
LAB_00108455:
JMP 0x00108402
|
/* processSource(std::shared_ptr<flux::common::Source> const&, bool, bool) */
void processSource(shared_ptr *param_1,bool param_2,bool param_3)
{
ostream *this;
if (param_2) {
/* try { // try from 001083b6 to 001083ba has its CatchHandler @ 001083c2 */
processLexing(param_1);
}
else if (param_3) {
/* try { // try from 00108412 to 0010844e has its CatchHandler @ 001083c2 */
processParsing(param_1);
}
else {
processParsing(param_1);
this = std::operator<<((ostream *)PTR_cout_00195fb8,"\nExecution is not yet implemented.");
std::ostream::operator<<
(this,(_func_ostream_ptr_ostream_ptr *)PTR_endl<char,std_char_traits<char>>_00195f80);
}
return;
}
| |
43,579 | PowerProfileManager::applyPowerProfile(QString const&) | midoBB[P]pwrctl/powerprofile.cpp | void PowerProfileManager::applyPowerProfile(const QString &profile) {
QProcess *process = new QProcess();
process->setProgram("powerprofilesctl");
process->setArguments(QStringList() << "set" << profile);
process->start();
process->waitForFinished();
} | O3 | cpp | PowerProfileManager::applyPowerProfile(QString const&):
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movl $0x10, %edi
callq 0x9750
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
callq 0x99e0
leaq 0x5ec0(%rip), %rdx # 0x21eae
leaq 0x40(%rsp), %r15
movl $0x10, %esi
movq %r15, %rdi
callq 0x95e0
movaps (%r15), %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsi)
movq %rbx, %rdi
callq 0x9690
movq (%rsp), %rax
testq %rax, %rax
je 0x1c03b
lock
decl (%rax)
jne 0x1c03b
movq (%rsp), %rdi
movl $0x2, %esi
movl $0x8, %edx
callq 0x9550
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
leaq 0x5e8e(%rip), %rdx # 0x21ee0
leaq 0x40(%rsp), %rdi
movl $0x3, %esi
callq 0x95e0
movaps 0x40(%rsp), %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rdx)
movq %rsp, %rdi
xorl %esi, %esi
callq 0x1c2b2
movq %rsp, %rdi
movq 0x10(%rdi), %rsi
movq %r14, %rdx
callq 0x1aa8c
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x9520
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x1c0be
lock
decl (%rax)
jne 0x1c0be
movq 0x20(%rsp), %rdi
movl $0x2, %esi
movl $0x8, %edx
callq 0x9550
movq %rsp, %rdi
callq 0x15f86
movq %rbx, %rdi
movl $0x3, %esi
callq 0x9cf0
movq %rbx, %rdi
movl $0x7530, %esi # imm = 0x7530
callq 0x90e0
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0x1c13d
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1c145
movq %rsp, %rsi
callq 0xa3f8
jmp 0x1c145
movq %rax, %r14
movl $0x10, %esi
movq %rbx, %rdi
callq 0x9100
jmp 0x1c145
movq %rax, %r14
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x1c13d
lock
decl (%rax)
jne 0x1c13d
movq 0x20(%rsp), %rdi
movl $0x2, %esi
movl $0x8, %edx
callq 0x9550
movq %rsp, %rdi
callq 0x15f86
movq %r14, %rdi
callq 0x93d0
nop
| _ZN19PowerProfileManager17applyPowerProfileERK7QString:
push r15
push r14
push rbx
sub rsp, 60h
mov r14, rsi
mov edi, 10h; unsigned __int64
call __Znwm; operator new(ulong)
mov rbx, rax
mov rdi, rax; this
xor esi, esi; QObject *
call __ZN8QProcessC1EP7QObject; QProcess::QProcess(QObject *)
lea rdx, aPowerprofilesc; "powerprofilesctl"
lea r15, [rsp+78h+var_38]
mov esi, 10h
mov rdi, r15
call __ZN7QString8fromUtf8E14QByteArrayView; QString::fromUtf8(QByteArrayView)
movaps xmm0, xmmword ptr [r15]
mov rsi, rsp; QString *
movaps xmmword ptr [rsi], xmm0
mov rax, [r15+10h]
mov [rsi+10h], rax
mov rdi, rbx; this
call __ZN8QProcess10setProgramERK7QString; QProcess::setProgram(QString const&)
mov rax, qword ptr [rsp+78h+var_78]
test rax, rax
jz short loc_1C03B
lock dec dword ptr [rax]
jnz short loc_1C03B
mov rdi, qword ptr [rsp+78h+var_78]
mov esi, 2
mov edx, 8
call __ZN10QArrayData10deallocateEPS_xx; QArrayData::deallocate(QArrayData*,long long,long long)
loc_1C03B:
xorps xmm0, xmm0
movaps [rsp+78h+var_78], xmm0
mov [rsp+78h+var_68], 0
lea rdx, aSet; "set"
lea rdi, [rsp+78h+var_38]
mov esi, 3
call __ZN7QString8fromUtf8E14QByteArrayView; QString::fromUtf8(QByteArrayView)
movaps xmm0, [rsp+78h+var_38]
lea rdx, [rsp+78h+var_58]
movaps xmmword ptr [rdx], xmm0
mov rax, [rsp+78h+var_28]
mov [rdx+10h], rax
mov rdi, rsp
xor esi, esi
call _ZN9QtPrivate16QMovableArrayOpsI7QStringE7emplaceIJS1_EEEvxDpOT_; QtPrivate::QMovableArrayOps<QString>::emplace<QString>(long long,QString &&)
mov rdi, rsp
mov rsi, [rdi+10h]
mov rdx, r14
call _ZN9QtPrivate16QMovableArrayOpsI7QStringE7emplaceIJRKS1_EEEvxDpOT_; QtPrivate::QMovableArrayOps<QString>::emplace<QString const&>(long long,QString const&)
mov rsi, rsp
mov rdi, rbx
call __ZN8QProcess12setArgumentsERK5QListI7QStringE; QProcess::setArguments(QList<QString> const&)
mov rax, [rsp+78h+var_58]
test rax, rax
jz short loc_1C0BE
lock dec dword ptr [rax]
jnz short loc_1C0BE
mov rdi, [rsp+78h+var_58]
mov esi, 2
mov edx, 8
call __ZN10QArrayData10deallocateEPS_xx; QArrayData::deallocate(QArrayData*,long long,long long)
loc_1C0BE:
mov rdi, rsp
call _ZN17QArrayDataPointerI7QStringED2Ev; QArrayDataPointer<QString>::~QArrayDataPointer()
mov rdi, rbx
mov esi, 3
call __ZN8QProcess5startE6QFlagsIN13QIODeviceBase12OpenModeFlagEE; QProcess::start(QFlags<QIODeviceBase::OpenModeFlag>)
mov rdi, rbx; this
mov esi, 7530h; int
call __ZN8QProcess15waitForFinishedEi; QProcess::waitForFinished(int)
add rsp, 60h
pop rbx
pop r14
pop r15
retn
mov r14, rax
jmp short loc_1C13D
mov r14, rax
mov rdi, [rsp+0]
test rdi, rdi
jz short loc_1C145
mov rsi, rsp
call _ZN19PowerProfileManager17applyPowerProfileERK7QString_cold_1; PowerProfileManager::applyPowerProfile(QString const&) [clone]
jmp short loc_1C145
mov r14, rax
mov esi, 10h; unsigned __int64
mov rdi, rbx; void *
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_1C145
mov r14, rax
mov rax, [rsp+arg_18]
test rax, rax
jz short loc_1C13D
lock dec dword ptr [rax]
jnz short loc_1C13D
mov rdi, [rsp+arg_18]
mov esi, 2
mov edx, 8
call __ZN10QArrayData10deallocateEPS_xx; QArrayData::deallocate(QArrayData*,long long,long long)
loc_1C13D:
mov rdi, rsp
call _ZN17QArrayDataPointerI7QStringED2Ev; QArrayDataPointer<QString>::~QArrayDataPointer()
loc_1C145:
mov rdi, r14
call __Unwind_Resume
| long long PowerProfileManager::applyPowerProfile(PowerProfileManager *this, volatile signed __int32 **a2)
{
QProcess *v2; // rbx
__int128 v4; // [rsp+0h] [rbp-78h] BYREF
volatile signed __int32 *v5; // [rsp+10h] [rbp-68h]
__int128 v6; // [rsp+20h] [rbp-58h]
volatile signed __int32 *v7; // [rsp+30h] [rbp-48h]
__int128 v8; // [rsp+40h] [rbp-38h] BYREF
volatile signed __int32 *v9; // [rsp+50h] [rbp-28h]
v2 = (QProcess *)operator new(0x10uLL);
QProcess::QProcess(v2, 0LL);
QString::fromUtf8(&v8, 16LL, "powerprofilesctl");
v4 = v8;
v5 = v9;
QProcess::setProgram(v2, (const QString *)&v4);
if ( (_QWORD)v4 && !_InterlockedDecrement((volatile signed __int32 *)v4) )
QArrayData::deallocate(v4, 2LL, 8LL);
v4 = 0LL;
v5 = 0LL;
QString::fromUtf8(&v8, 3LL, "set");
v6 = v8;
v7 = v9;
QtPrivate::QMovableArrayOps<QString>::emplace<QString>(&v4, 0LL);
QtPrivate::QMovableArrayOps<QString>::emplace<QString const&>(&v4, v5, a2);
QProcess::setArguments(v2, &v4);
if ( (_QWORD)v6 && !_InterlockedDecrement((volatile signed __int32 *)v6) )
QArrayData::deallocate(v6, 2LL, 8LL);
QArrayDataPointer<QString>::~QArrayDataPointer((volatile signed __int32 **)&v4);
QProcess::start(v2, 3LL);
return QProcess::waitForFinished(v2, 30000);
}
| applyPowerProfile:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x60
MOV R14,RSI
MOV EDI,0x10
CALL 0x00109750
MOV RBX,RAX
LAB_0011bfdd:
MOV RDI,RAX
XOR ESI,ESI
CALL 0x001099e0
LAB_0011bfe7:
LEA RDX,[0x121eae]
LEA R15,[RSP + 0x40]
MOV ESI,0x10
MOV RDI,R15
CALL 0x001095e0
MOVAPS XMM0,xmmword ptr [R15]
MOV RSI,RSP
MOVAPS xmmword ptr [RSI],XMM0
MOV RAX,qword ptr [R15 + 0x10]
MOV qword ptr [RSI + 0x10],RAX
LAB_0011c012:
MOV RDI,RBX
CALL 0x00109690
MOV RAX,qword ptr [RSP]
TEST RAX,RAX
JZ 0x0011c03b
DEC.LOCK dword ptr [RAX]
JNZ 0x0011c03b
MOV RDI,qword ptr [RSP]
MOV ESI,0x2
MOV EDX,0x8
CALL 0x00109550
LAB_0011c03b:
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP],XMM0
MOV qword ptr [RSP + 0x10],0x0
LAB_0011c04b:
LEA RDX,[0x121ee0]
LEA RDI,[RSP + 0x40]
MOV ESI,0x3
CALL 0x001095e0
MOVAPS XMM0,xmmword ptr [RSP + 0x40]
LEA RDX,[RSP + 0x20]
MOVAPS xmmword ptr [RDX],XMM0
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RDX + 0x10],RAX
LAB_0011c077:
MOV RDI,RSP
XOR ESI,ESI
CALL 0x0011c2b2
MOV RDI,RSP
MOV RSI,qword ptr [RDI + 0x10]
MOV RDX,R14
CALL 0x0011aa8c
MOV RSI,RSP
MOV RDI,RBX
CALL 0x00109520
LAB_0011c09b:
MOV RAX,qword ptr [RSP + 0x20]
TEST RAX,RAX
JZ 0x0011c0be
DEC.LOCK dword ptr [RAX]
JNZ 0x0011c0be
MOV RDI,qword ptr [RSP + 0x20]
MOV ESI,0x2
MOV EDX,0x8
CALL 0x00109550
LAB_0011c0be:
MOV RDI,RSP
CALL 0x00115f86
MOV RDI,RBX
MOV ESI,0x3
CALL 0x00109cf0
MOV RDI,RBX
MOV ESI,0x7530
CALL 0x001090e0
ADD RSP,0x60
POP RBX
POP R14
POP R15
RET
|
/* PowerProfileManager::applyPowerProfile(QString const&) */
void __thiscall PowerProfileManager::applyPowerProfile(PowerProfileManager *this,QString *param_1)
{
QProcess *this_00;
QArrayData *local_78;
int8 uStack_70;
longlong local_68;
QArrayData *local_58;
int8 uStack_50;
int8 local_48;
QArrayData *local_38;
int8 uStack_30;
int8 local_28;
this_00 = (QProcess *)operator_new(0x10);
/* try { // try from 0011bfdd to 0011bfe6 has its CatchHandler @ 0011c105 */
QProcess::QProcess(this_00,(QObject *)0x0);
QString::fromUtf8(&local_38,0x10,"powerprofilesctl");
local_78 = local_38;
uStack_70 = uStack_30;
local_68 = local_28;
/* try { // try from 0011c012 to 0011c019 has its CatchHandler @ 0011c0ef */
QProcess::setProgram((QString *)this_00);
if (local_78 != (QArrayData *)0x0) {
LOCK();
*(int *)local_78 = *(int *)local_78 + -1;
UNLOCK();
if (*(int *)local_78 == 0) {
QArrayData::deallocate(local_78,2,8);
}
}
local_78 = (QArrayData *)0x0;
uStack_70 = 0;
local_68 = 0;
/* try { // try from 0011c04b to 0011c060 has its CatchHandler @ 0011c0ea */
QString::fromUtf8(&local_38,3,&DAT_00121ee0);
local_58 = local_38;
uStack_50 = uStack_30;
local_48 = local_28;
/* try { // try from 0011c077 to 0011c09a has its CatchHandler @ 0011c117 */
QtPrivate::QMovableArrayOps<QString>::emplace<QString>
((QMovableArrayOps<QString> *)&local_78,0,(QString *)&local_58);
QtPrivate::QMovableArrayOps<QString>::emplace<QString_const&>
((QMovableArrayOps<QString> *)&local_78,local_68,param_1);
QProcess::setArguments((QList *)this_00);
if (local_58 != (QArrayData *)0x0) {
LOCK();
*(int *)local_58 = *(int *)local_58 + -1;
UNLOCK();
if (*(int *)local_58 == 0) {
QArrayData::deallocate(local_58,2,8);
}
}
QArrayDataPointer<QString>::~QArrayDataPointer((QArrayDataPointer<QString> *)&local_78);
QProcess::start(this_00,3);
QProcess::waitForFinished((int)this_00);
return;
}
| |
43,580 | maria_versioning | eloqsql/storage/maria/ma_state.c | void maria_versioning(MARIA_HA *info, my_bool versioning)
{
MARIA_SHARE *share= info->s;
DBUG_ENTER("maria_versioning");
/* For now, this is a hack */
if (share->have_versioning)
{
enum thr_lock_type save_lock_type;
share->lock_key_trees= versioning;
/* Set up info->lock.type temporary for _ma_block_get_status() */
save_lock_type= info->lock.type;
info->lock.type= versioning ? TL_WRITE_CONCURRENT_INSERT : TL_WRITE;
_ma_block_get_status((void*) info, versioning);
info->lock.type= save_lock_type;
if (versioning)
info->state= &share->state.common;
else
info->state= &share->state.state; /* Change global values by default */
info->state_start= info->state; /* Initial values */
}
DBUG_VOID_RETURN;
} | O0 | c | maria_versioning:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, 0x7e8(%rax)
je 0x4bce8
movb -0x9(%rbp), %cl
movq -0x18(%rbp), %rax
movb %cl, 0x7e3(%rax)
movq -0x8(%rbp), %rax
movl 0x6d0(%rax), %eax
movl %eax, -0x1c(%rbp)
movsbl -0x9(%rbp), %edx
movl $0xd, %ecx
movl $0x8, %eax
cmpl $0x0, %edx
cmovnel %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x6d0(%rax)
movq -0x8(%rbp), %rdi
movsbl -0x9(%rbp), %esi
callq 0x4ba20
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x6d0(%rax)
cmpb $0x0, -0x9(%rbp)
je 0x4bcc8
movq -0x18(%rbp), %rcx
addq $0x50, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x4bcd8
movq -0x18(%rbp), %rcx
addq $0x18, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x60(%rax)
jmp 0x4bcea
jmp 0x4bcec
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| maria_versioning:
push rbp
mov rbp, rsp
sub rsp, 20h
mov al, sil
mov [rbp+var_8], rdi
mov [rbp+var_9], al
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
cmp byte ptr [rax+7E8h], 0
jz loc_4BCE8
mov cl, [rbp+var_9]
mov rax, [rbp+var_18]
mov [rax+7E3h], cl
mov rax, [rbp+var_8]
mov eax, [rax+6D0h]
mov [rbp+var_1C], eax
movsx edx, [rbp+var_9]
mov ecx, 0Dh
mov eax, 8
cmp edx, 0
cmovnz ecx, eax
mov rax, [rbp+var_8]
mov [rax+6D0h], ecx
mov rdi, [rbp+var_8]
movsx esi, [rbp+var_9]
call _ma_block_get_status
mov ecx, [rbp+var_1C]
mov rax, [rbp+var_8]
mov [rax+6D0h], ecx
cmp [rbp+var_9], 0
jz short loc_4BCC8
mov rcx, [rbp+var_18]
add rcx, 50h ; 'P'
mov rax, [rbp+var_8]
mov [rax+20h], rcx
jmp short loc_4BCD8
loc_4BCC8:
mov rcx, [rbp+var_18]
add rcx, 18h
mov rax, [rbp+var_8]
mov [rax+20h], rcx
loc_4BCD8:
mov rax, [rbp+var_8]
mov rcx, [rax+20h]
mov rax, [rbp+var_8]
mov [rax+60h], rcx
loc_4BCE8:
jmp short $+2
loc_4BCEA:
jmp short $+2
loc_4BCEC:
add rsp, 20h
pop rbp
retn
| long long maria_versioning(long long a1, char a2)
{
long long result; // rax
int v3; // ecx
int v4; // [rsp+4h] [rbp-1Ch]
long long v5; // [rsp+8h] [rbp-18h]
v5 = *(_QWORD *)a1;
result = *(_QWORD *)a1;
if ( *(_BYTE *)(*(_QWORD *)a1 + 2024LL) )
{
*(_BYTE *)(v5 + 2019) = a2;
v4 = *(_DWORD *)(a1 + 1744);
v3 = 13;
if ( a2 )
v3 = 8;
*(_DWORD *)(a1 + 1744) = v3;
ma_block_get_status(a1, a2);
*(_DWORD *)(a1 + 1744) = v4;
if ( a2 )
*(_QWORD *)(a1 + 32) = v5 + 80;
else
*(_QWORD *)(a1 + 32) = v5 + 24;
result = a1;
*(_QWORD *)(a1 + 96) = *(_QWORD *)(a1 + 32);
}
return result;
}
| maria_versioning:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV AL,SIL
MOV qword ptr [RBP + -0x8],RDI
MOV byte ptr [RBP + -0x9],AL
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
CMP byte ptr [RAX + 0x7e8],0x0
JZ 0x0014bce8
MOV CL,byte ptr [RBP + -0x9]
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x7e3],CL
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x6d0]
MOV dword ptr [RBP + -0x1c],EAX
MOVSX EDX,byte ptr [RBP + -0x9]
MOV ECX,0xd
MOV EAX,0x8
CMP EDX,0x0
CMOVNZ ECX,EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x6d0],ECX
MOV RDI,qword ptr [RBP + -0x8]
MOVSX ESI,byte ptr [RBP + -0x9]
CALL 0x0014ba20
MOV ECX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x6d0],ECX
CMP byte ptr [RBP + -0x9],0x0
JZ 0x0014bcc8
MOV RCX,qword ptr [RBP + -0x18]
ADD RCX,0x50
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x20],RCX
JMP 0x0014bcd8
LAB_0014bcc8:
MOV RCX,qword ptr [RBP + -0x18]
ADD RCX,0x18
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x20],RCX
LAB_0014bcd8:
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x60],RCX
LAB_0014bce8:
JMP 0x0014bcea
LAB_0014bcea:
JMP 0x0014bcec
LAB_0014bcec:
ADD RSP,0x20
POP RBP
RET
|
void maria_versioning(long *param_1,char param_2)
{
long lVar1;
long lVar2;
int4 uVar3;
lVar1 = *param_1;
if (*(char *)(lVar1 + 0x7e8) != '\0') {
*(char *)(lVar1 + 0x7e3) = param_2;
lVar2 = param_1[0xda];
uVar3 = 0xd;
if (param_2 != '\0') {
uVar3 = 8;
}
*(int4 *)(param_1 + 0xda) = uVar3;
_ma_block_get_status(param_1,(int)param_2);
*(int *)(param_1 + 0xda) = (int)lVar2;
if (param_2 == '\0') {
param_1[4] = lVar1 + 0x18;
}
else {
param_1[4] = lVar1 + 0x50;
}
param_1[0xc] = param_1[4];
}
return;
}
| |
43,581 | show_usage | bluesky950520[P]quickjs/tests/test_conv.c | void show_usage(void) {
printf("usage: test_conv [options] [bases] [filters]\n"
" options:\n"
" -h --help output this help\n"
" -t --terse only output average stats\n"
" -v --verbose output stats for all tested bases\n"
" bases\n"
" bases can be specified individually, as ranges or enumerations\n"
" supported bases are 2-36\n"
" examples: 10 2,8,16 2-10,16\n"
" filters are words that must be contained in variant names\n"
" examples: naive pri len rev\n"
" variants:\n"
#ifdef TEST_SNPRINTF
" snprintf use snprintf for supported bases for reference\n"
#endif
#ifdef TEST_NAIVE
" naive naive digit loop and copy loops\n"
#endif
#ifdef TEST_BLOCKMOV
" blockmov same but move all digits together\n"
#endif
#ifdef TEST_REVERSE
" reverse naive digit loop and reverse digit string\n"
#endif
#ifdef TEST_LENGTH_LOOP
" length_loop compute length before digit loop using loop\n"
#endif
#ifdef TEST_LENGTH_EXPR
" length_expr compute length before digit loop using expression\n"
#endif
#ifdef TEST_SHIFTBUF
" shift generate up to 7 digit chunks in a register\n"
#endif
#ifdef TEST_DIGIT_PAIRS
" pair generate 2 decimal digits at a time\n"
#endif
#ifdef TEST_DIGIT_1PASS
" pair_1pass same but as a single left to right pass\n"
#endif
#ifdef TEST_DIV_TABLE
" div_table use multiplier table instead of radix divisions\n"
#endif
#ifdef TEST_DISPATCH
" dispatch use dispatch table to optimal 64-bit radix converters\n"
#endif
);
} | O0 | c | show_usage:
pushq %rax
leaq 0x77c4(%rip), %rdi # 0xd30c
movb $0x0, %al
callq 0x2060
popq %rax
retq
nopw %cs:(%rax,%rax)
| show_usage:
push rax
lea rdi, aUsageTestConvO; "usage: test_conv [options] [bases] [fil"...
mov al, 0
call _printf
pop rax
retn
| void __spoils<rdx,rcx,r8,r9,r10,r11,xmm4,xmm5> show_usage()
{
printf(
"usage: test_conv [options] [bases] [filters]\n"
" options:\n"
" -h --help output this help\n"
" -t --terse only output average stats\n"
" -v --verbose output stats for all tested bases\n"
" bases\n"
" bases can be specified individually, as ranges or enumerations\n"
" supported bases are 2-36\n"
" examples: 10 2,8,16 2-10,16\n"
" filters are words that must be contained in variant names\n"
" examples: naive pri len rev\n"
" variants:\n"
" snprintf use snprintf for supported bases for reference\n"
" naive naive digit loop and copy loops\n"
" blockmov same but move all digits together\n"
" reverse naive digit loop and reverse digit string\n"
" length_loop compute length before digit loop using loop\n"
" length_expr compute length before digit loop using expression\n"
" shift generate up to 7 digit chunks in a register\n"
" pair generate 2 decimal digits at a time\n"
" pair_1pass same but as a single left to right pass\n"
" div_table use multiplier table instead of radix divisions\n"
" dispatch use dispatch table to optimal 64-bit radix converters\n");
}
| show_usage:
PUSH RAX
LEA RDI,[0x10d30c]
MOV AL,0x0
CALL 0x00102060
POP RAX
RET
|
int8 show_usage(void)
{
int8 in_RAX;
printf(
"usage: test_conv [options] [bases] [filters]\n options:\n -h --help output this help\n -t --terse only output average stats\n -v --verbose output stats for all tested bases\n bases\n bases can be specified individually, as ranges or enumerations\n supported bases are 2-36\n examples: 10 2,8,16 2-10,16\n filters are words that must be contained in variant names\n examples: naive pri len rev\n variants:\n snprintf use snprintf for supported bases for reference\n naive naive digit loop and copy loops\n blockmov same but move all digits together\n reverse naive digit loop and reverse digit string\n length_loop compute length before digit loop using loop\n length_expr compute length before digit loop using expression\n shift generate up to 7 digit chunks in a register\n pair generate 2 decimal digits at a time\n pair_1pass same but as a single left to right pass\n div_table use multiplier table instead of radix divisions\n dispatch use dispatch table to optimal 64-bit radix converters\n"
);
return in_RAX;
}
| |
43,582 | show_usage | bluesky950520[P]quickjs/tests/test_conv.c | void show_usage(void) {
printf("usage: test_conv [options] [bases] [filters]\n"
" options:\n"
" -h --help output this help\n"
" -t --terse only output average stats\n"
" -v --verbose output stats for all tested bases\n"
" bases\n"
" bases can be specified individually, as ranges or enumerations\n"
" supported bases are 2-36\n"
" examples: 10 2,8,16 2-10,16\n"
" filters are words that must be contained in variant names\n"
" examples: naive pri len rev\n"
" variants:\n"
#ifdef TEST_SNPRINTF
" snprintf use snprintf for supported bases for reference\n"
#endif
#ifdef TEST_NAIVE
" naive naive digit loop and copy loops\n"
#endif
#ifdef TEST_BLOCKMOV
" blockmov same but move all digits together\n"
#endif
#ifdef TEST_REVERSE
" reverse naive digit loop and reverse digit string\n"
#endif
#ifdef TEST_LENGTH_LOOP
" length_loop compute length before digit loop using loop\n"
#endif
#ifdef TEST_LENGTH_EXPR
" length_expr compute length before digit loop using expression\n"
#endif
#ifdef TEST_SHIFTBUF
" shift generate up to 7 digit chunks in a register\n"
#endif
#ifdef TEST_DIGIT_PAIRS
" pair generate 2 decimal digits at a time\n"
#endif
#ifdef TEST_DIGIT_1PASS
" pair_1pass same but as a single left to right pass\n"
#endif
#ifdef TEST_DIV_TABLE
" div_table use multiplier table instead of radix divisions\n"
#endif
#ifdef TEST_DISPATCH
" dispatch use dispatch table to optimal 64-bit radix converters\n"
#endif
);
} | O1 | c | show_usage:
leaq 0x3aa4(%rip), %rdi # 0x7566
jmp 0x2050
| show_usage:
lea rdi, aUsageTestConvO; "usage: test_conv [options] [bases] [fil"...
jmp _puts
| long long show_usage()
{
return puts(
"usage: test_conv [options] [bases] [filters]\n"
" options:\n"
" -h --help output this help\n"
" -t --terse only output average stats\n"
" -v --verbose output stats for all tested bases\n"
" bases\n"
" bases can be specified individually, as ranges or enumerations\n"
" supported bases are 2-36\n"
" examples: 10 2,8,16 2-10,16\n"
" filters are words that must be contained in variant names\n"
" examples: naive pri len rev\n"
" variants:\n"
" snprintf use snprintf for supported bases for reference\n"
" naive naive digit loop and copy loops\n"
" blockmov same but move all digits together\n"
" reverse naive digit loop and reverse digit string\n"
" length_loop compute length before digit loop using loop\n"
" length_expr compute length before digit loop using expression\n"
" shift generate up to 7 digit chunks in a register\n"
" pair generate 2 decimal digits at a time\n"
" pair_1pass same but as a single left to right pass\n"
" div_table use multiplier table instead of radix divisions\n"
" dispatch use dispatch table to optimal 64-bit radix converters");
}
| show_usage:
LEA RDI,[0x107566]
JMP 0x00102050
|
void show_usage(void)
{
puts(
"usage: test_conv [options] [bases] [filters]\n options:\n -h --help output this help\n -t --terse only output average stats\n -v --verbose output stats for all tested bases\n bases\n bases can be specified individually, as ranges or enumerations\n supported bases are 2-36\n examples: 10 2,8,16 2-10,16\n filters are words that must be contained in variant names\n examples: naive pri len rev\n variants:\n snprintf use snprintf for supported bases for reference\n naive naive digit loop and copy loops\n blockmov same but move all digits together\n reverse naive digit loop and reverse digit string\n length_loop compute length before digit loop using loop\n length_expr compute length before digit loop using expression\n shift generate up to 7 digit chunks in a register\n pair generate 2 decimal digits at a time\n pair_1pass same but as a single left to right pass\n div_table use multiplier table instead of radix divisions\n dispatch use dispatch table to optimal 64-bit radix converters"
);
return;
}
| |
43,583 | CLI::detail::remove_quotes(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | MikePodsytnik[P]TCRtrie/build_O2/_deps/cli11-src/include/CLI/impl/StringTools_inl.hpp | CLI11_INLINE std::string &remove_quotes(std::string &str) {
if(str.length() > 1 && (str.front() == '"' || str.front() == '\'')) {
if(str.front() == str.back()) {
str.pop_back();
str.erase(str.begin(), str.begin() + 1);
}
}
return str;
} | O2 | cpp | CLI::detail::remove_quotes(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&):
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpq $0x2, %rax
jb 0x1ebe3
movq (%rbx), %rcx
movzbl (%rcx), %edx
cmpl $0x27, %edx
je 0x1ebc6
cmpl $0x22, %edx
jne 0x1ebe3
cmpb -0x1(%rcx,%rax), %dl
jne 0x1ebe3
movq %rbx, %rdi
callq 0x7530
movq (%rbx), %rsi
leaq 0x1(%rsi), %rdx
movq %rbx, %rdi
callq 0x70c0
movq %rbx, %rax
popq %rbx
retq
| _ZN3CLI6detail13remove_quotesERNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbx
mov rbx, rdi
mov rax, [rdi+8]
cmp rax, 2
jb short loc_1EBE3
mov rcx, [rbx]
movzx edx, byte ptr [rcx]
cmp edx, 27h ; '''
jz short loc_1EBC6
cmp edx, 22h ; '"'
jnz short loc_1EBE3
loc_1EBC6:
cmp dl, [rcx+rax-1]
jnz short loc_1EBE3
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE8pop_backEv; std::string::pop_back(void)
mov rsi, [rbx]
lea rdx, [rsi+1]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5eraseEN9__gnu_cxx17__normal_iteratorIPKcS4_EES9_; std::string::erase(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>)
loc_1EBE3:
mov rax, rbx
pop rbx
retn
| unsigned __int8 ** CLI::detail::remove_quotes(unsigned __int8 **a1)
{
unsigned long long v1; // rax
int v2; // edx
v1 = (unsigned long long)a1[1];
if ( v1 >= 2 )
{
v2 = **a1;
if ( (v2 == 39 || v2 == 34) && (_BYTE)v2 == (*a1)[v1 - 1] )
{
std::string::pop_back(a1);
std::string::erase(a1, *a1, *a1 + 1);
}
}
return a1;
}
| remove_quotes:
PUSH RBX
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x8]
CMP RAX,0x2
JC 0x0011ebe3
MOV RCX,qword ptr [RBX]
MOVZX EDX,byte ptr [RCX]
CMP EDX,0x27
JZ 0x0011ebc6
CMP EDX,0x22
JNZ 0x0011ebe3
LAB_0011ebc6:
CMP DL,byte ptr [RCX + RAX*0x1 + -0x1]
JNZ 0x0011ebe3
MOV RDI,RBX
CALL 0x00107530
MOV RSI,qword ptr [RBX]
LEA RDX,[RSI + 0x1]
MOV RDI,RBX
CALL 0x001070c0
LAB_0011ebe3:
MOV RAX,RBX
POP RBX
RET
|
/* CLI::detail::remove_quotes(std::__cxx11::string&) */
string * CLI::detail::remove_quotes(string *param_1)
{
char cVar1;
if (1 < *(ulong *)(param_1 + 8)) {
cVar1 = **(char **)param_1;
if (((cVar1 == '\'') || (cVar1 == '\"')) &&
(cVar1 == (*(char **)param_1)[*(ulong *)(param_1 + 8) - 1])) {
std::__cxx11::string::pop_back();
std::__cxx11::string::erase(param_1,*(long *)param_1,*(long *)param_1 + 1);
}
}
return param_1;
}
| |
43,584 | JS_NewAtomString | bluesky950520[P]quickjs/quickjs.c | JSValue JS_NewAtomString(JSContext *ctx, const char *str)
{
JSAtom atom = JS_NewAtom(ctx, str);
if (atom == JS_ATOM_NULL)
return JS_EXCEPTION;
JSValue val = JS_AtomToString(ctx, atom);
JS_FreeAtom(ctx, atom);
return val;
} | O0 | c | JS_NewAtomString:
subq $0x28, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x2e7b0
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x2fb0b
movl $0x0, 0x18(%rsp)
movq $0x6, 0x20(%rsp)
jmp 0x2fb31
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x2f2f0
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x2f330
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rdx
addq $0x28, %rsp
retq
| JS_NewAtomString:
sub rsp, 28h
mov [rsp+28h+var_18], rdi
mov [rsp+28h+var_20], rsi
mov rdi, [rsp+28h+var_18]
mov rsi, [rsp+28h+var_20]
call JS_NewAtom
mov [rsp+28h+var_24], eax
cmp [rsp+28h+var_24], 0
jnz short loc_2FB0B
mov dword ptr [rsp+28h+var_10], 0
mov [rsp+28h+var_8], 6
jmp short loc_2FB31
loc_2FB0B:
mov rdi, [rsp+28h+var_18]
mov esi, [rsp+28h+var_24]
call JS_AtomToString
mov [rsp+28h+var_10], rax
mov [rsp+28h+var_8], rdx
mov rdi, [rsp+28h+var_18]
mov esi, [rsp+28h+var_24]
call JS_FreeAtom
loc_2FB31:
mov rax, [rsp+28h+var_10]
mov rdx, [rsp+28h+var_8]
add rsp, 28h
retn
| long long JS_NewAtomString(long long a1, unsigned __int8 *a2)
{
unsigned int v3; // [rsp+4h] [rbp-24h]
long long v4; // [rsp+18h] [rbp-10h]
v3 = JS_NewAtom(a1, a2);
if ( v3 )
{
v4 = JS_AtomToString(a1, v3);
JS_FreeAtom(a1, v3);
}
else
{
LODWORD(v4) = 0;
}
return v4;
}
| JS_NewAtomString:
SUB RSP,0x28
MOV qword ptr [RSP + 0x10],RDI
MOV qword ptr [RSP + 0x8],RSI
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP + 0x8]
CALL 0x0012e7b0
MOV dword ptr [RSP + 0x4],EAX
CMP dword ptr [RSP + 0x4],0x0
JNZ 0x0012fb0b
MOV dword ptr [RSP + 0x18],0x0
MOV qword ptr [RSP + 0x20],0x6
JMP 0x0012fb31
LAB_0012fb0b:
MOV RDI,qword ptr [RSP + 0x10]
MOV ESI,dword ptr [RSP + 0x4]
CALL 0x0012f2f0
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x20],RDX
MOV RDI,qword ptr [RSP + 0x10]
MOV ESI,dword ptr [RSP + 0x4]
CALL 0x0012f330
LAB_0012fb31:
MOV RAX,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x20]
ADD RSP,0x28
RET
|
int1 [16] JS_NewAtomString(int8 param_1,int8 param_2)
{
int iVar1;
int1 auVar2 [16];
int4 local_10;
int4 uStack_c;
int8 local_8;
iVar1 = JS_NewAtom(param_1,param_2);
if (iVar1 == 0) {
local_10 = 0;
local_8 = 6;
}
else {
auVar2 = JS_AtomToString(param_1,iVar1);
local_8 = auVar2._8_8_;
local_10 = auVar2._0_4_;
uStack_c = auVar2._4_4_;
JS_FreeAtom(param_1,iVar1);
}
auVar2._4_4_ = uStack_c;
auVar2._0_4_ = local_10;
auVar2._8_8_ = local_8;
return auVar2;
}
| |
43,585 | mi_find_writepos | eloqsql/storage/myisam/mi_dynrec.c | static int _mi_find_writepos(MI_INFO *info,
ulong reclength, /* record length */
my_off_t *filepos, /* Return file pos */
ulong *length) /* length of block at filepos */
{
MI_BLOCK_INFO block_info;
ulong tmp;
DBUG_ENTER("_mi_find_writepos");
if (info->s->state.dellink != HA_OFFSET_ERROR &&
!info->append_insert_at_end)
{
/* Deleted blocks exists; Get last used block */
*filepos=info->s->state.dellink;
block_info.second_read=0;
info->rec_cache.seek_not_done=1;
if (!(_mi_get_block_info(&block_info,info->dfile,info->s->state.dellink) &
BLOCK_DELETED))
{
DBUG_PRINT("error",("Delete link crashed"));
my_errno=HA_ERR_WRONG_IN_RECORD;
DBUG_RETURN(-1);
}
info->s->state.dellink=block_info.next_filepos;
info->state->del--;
info->state->empty-= block_info.block_len;
*length= block_info.block_len;
}
else
{
/* No deleted blocks; Allocate a new block */
*filepos=info->state->data_file_length;
if ((tmp= reclength + 3 + MY_TEST(reclength >= (65520 - 3))) <
info->s->base.min_block_length)
tmp= info->s->base.min_block_length;
else
tmp= ((tmp+MI_DYN_ALIGN_SIZE-1) &
(~ (ulong) (MI_DYN_ALIGN_SIZE-1)));
if (info->state->data_file_length >
(info->s->base.max_data_file_length - tmp))
{
my_errno=HA_ERR_RECORD_FILE_FULL;
DBUG_RETURN(-1);
}
if (tmp > MI_MAX_BLOCK_LENGTH)
tmp=MI_MAX_BLOCK_LENGTH;
*length= tmp;
info->state->data_file_length+= tmp;
info->s->state.split++;
info->update|=HA_STATE_WRITE_AT_END;
}
DBUG_RETURN(0);
} | O0 | c | mi_find_writepos:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x70(%rbp)
movq %rsi, -0x78(%rbp)
movq %rdx, -0x80(%rbp)
movq %rcx, -0x88(%rbp)
movq -0x70(%rbp), %rax
movq (%rax), %rax
cmpq $-0x1, 0x58(%rax)
je 0xae353
movq -0x70(%rbp), %rax
cmpb $0x0, 0x33a(%rax)
jne 0xae353
movq -0x70(%rbp), %rax
movq (%rax), %rax
movq 0x58(%rax), %rcx
movq -0x80(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x10(%rbp)
movq -0x70(%rbp), %rax
movl $0x1, 0x300(%rax)
movq -0x70(%rbp), %rax
movl 0x1c0(%rax), %esi
movq -0x70(%rbp), %rax
movq (%rax), %rax
movq 0x58(%rax), %rdx
leaq -0x60(%rbp), %rdi
callq 0xab440
andl $0x4, %eax
cmpl $0x0, %eax
jne 0xae306
jmp 0xae2ed
jmp 0xae2ef
callq 0xf7a70
movl $0x7f, (%rax)
movl $0xffffffff, -0x64(%rbp) # imm = 0xFFFFFFFF
jmp 0xae47d
movq -0x20(%rbp), %rcx
movq -0x70(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x58(%rax)
movq -0x70(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rdx
movq -0x70(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rcx
movq -0x88(%rbp), %rax
movq %rcx, (%rax)
jmp 0xae474
movq -0x70(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rcx
movq -0x80(%rbp), %rax
movq %rcx, (%rax)
movq -0x78(%rbp), %rax
addq $0x3, %rax
movq -0x78(%rbp), %rsi
xorl %ecx, %ecx
movl $0x1, %edx
cmpq $0xffed, %rsi # imm = 0xFFED
cmovael %edx, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x90(%rbp)
movq -0x70(%rbp), %rcx
movq (%rcx), %rcx
cmpq 0x160(%rcx), %rax
jae 0xae3b7
movq -0x70(%rbp), %rax
movq (%rax), %rax
movq 0x160(%rax), %rax
movq %rax, -0x90(%rbp)
jmp 0xae3d1
movq -0x90(%rbp), %rax
addq $0x4, %rax
subq $0x1, %rax
andq $-0x4, %rax
movq %rax, -0x90(%rbp)
movq -0x70(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rax
movq -0x70(%rbp), %rcx
movq (%rcx), %rcx
movq 0x110(%rcx), %rcx
subq -0x90(%rbp), %rcx
cmpq %rcx, %rax
jbe 0xae40b
callq 0xf7a70
movl $0x87, (%rax)
movl $0xffffffff, -0x64(%rbp) # imm = 0xFFFFFFFF
jmp 0xae47d
cmpq $0xfffffc, -0x90(%rbp) # imm = 0xFFFFFC
jbe 0xae423
movq $0xfffffc, -0x90(%rbp) # imm = 0xFFFFFC
movq -0x90(%rbp), %rcx
movq -0x88(%rbp), %rax
movq %rcx, (%rax)
movq -0x90(%rbp), %rcx
movq -0x70(%rbp), %rax
movq 0x8(%rax), %rax
addq 0x28(%rax), %rcx
movq %rcx, 0x28(%rax)
movq -0x70(%rbp), %rax
movq (%rax), %rax
movq 0x50(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x50(%rax)
movq -0x70(%rbp), %rax
movl 0x1d0(%rax), %ecx
orl $0x100, %ecx # imm = 0x100
movl %ecx, 0x1d0(%rax)
jmp 0xae476
movl $0x0, -0x64(%rbp)
movl -0x64(%rbp), %eax
movl %eax, -0x94(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xae4a7
movl -0x94(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
callq 0x2a250
nopl (%rax)
| _mi_find_writepos:
push rbp
mov rbp, rsp
sub rsp, 0A0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_70], rdi
mov [rbp+var_78], rsi
mov [rbp+var_80], rdx
mov [rbp+var_88], rcx
mov rax, [rbp+var_70]
mov rax, [rax]
cmp qword ptr [rax+58h], 0FFFFFFFFFFFFFFFFh
jz loc_AE353
mov rax, [rbp+var_70]
cmp byte ptr [rax+33Ah], 0
jnz loc_AE353
mov rax, [rbp+var_70]
mov rax, [rax]
mov rcx, [rax+58h]
mov rax, [rbp+var_80]
mov [rax], rcx
mov [rbp+var_10], 0
mov rax, [rbp+var_70]
mov dword ptr [rax+300h], 1
mov rax, [rbp+var_70]
mov esi, [rax+1C0h]
mov rax, [rbp+var_70]
mov rax, [rax]
mov rdx, [rax+58h]
lea rdi, [rbp+var_60]
call _mi_get_block_info
and eax, 4
cmp eax, 0
jnz short loc_AE306
jmp short $+2
loc_AE2ED:
jmp short $+2
loc_AE2EF:
call _my_thread_var
mov dword ptr [rax], 7Fh
mov [rbp+var_64], 0FFFFFFFFh
jmp loc_AE47D
loc_AE306:
mov rcx, [rbp+var_20]
mov rax, [rbp+var_70]
mov rax, [rax]
mov [rax+58h], rcx
mov rax, [rbp+var_70]
mov rax, [rax+8]
mov rcx, [rax+8]
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rax+8], rcx
mov rdx, [rbp+var_38]
mov rax, [rbp+var_70]
mov rax, [rax+8]
mov rcx, [rax+10h]
sub rcx, rdx
mov [rax+10h], rcx
mov rcx, [rbp+var_38]
mov rax, [rbp+var_88]
mov [rax], rcx
jmp loc_AE474
loc_AE353:
mov rax, [rbp+var_70]
mov rax, [rax+8]
mov rcx, [rax+28h]
mov rax, [rbp+var_80]
mov [rax], rcx
mov rax, [rbp+var_78]
add rax, 3
mov rsi, [rbp+var_78]
xor ecx, ecx
mov edx, 1
cmp rsi, 0FFEDh
cmovnb ecx, edx
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_90], rax
mov rcx, [rbp+var_70]
mov rcx, [rcx]
cmp rax, [rcx+160h]
jnb short loc_AE3B7
mov rax, [rbp+var_70]
mov rax, [rax]
mov rax, [rax+160h]
mov [rbp+var_90], rax
jmp short loc_AE3D1
loc_AE3B7:
mov rax, [rbp+var_90]
add rax, 4
sub rax, 1
and rax, 0FFFFFFFFFFFFFFFCh
mov [rbp+var_90], rax
loc_AE3D1:
mov rax, [rbp+var_70]
mov rax, [rax+8]
mov rax, [rax+28h]
mov rcx, [rbp+var_70]
mov rcx, [rcx]
mov rcx, [rcx+110h]
sub rcx, [rbp+var_90]
cmp rax, rcx
jbe short loc_AE40B
call _my_thread_var
mov dword ptr [rax], 87h
mov [rbp+var_64], 0FFFFFFFFh
jmp short loc_AE47D
loc_AE40B:
cmp [rbp+var_90], 0FFFFFCh
jbe short loc_AE423
mov [rbp+var_90], 0FFFFFCh
loc_AE423:
mov rcx, [rbp+var_90]
mov rax, [rbp+var_88]
mov [rax], rcx
mov rcx, [rbp+var_90]
mov rax, [rbp+var_70]
mov rax, [rax+8]
add rcx, [rax+28h]
mov [rax+28h], rcx
mov rax, [rbp+var_70]
mov rax, [rax]
mov rcx, [rax+50h]
add rcx, 1
mov [rax+50h], rcx
mov rax, [rbp+var_70]
mov ecx, [rax+1D0h]
or ecx, 100h
mov [rax+1D0h], ecx
loc_AE474:
jmp short $+2
loc_AE476:
mov [rbp+var_64], 0
loc_AE47D:
mov eax, [rbp+var_64]
mov [rbp+var_94], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_AE4A7
mov eax, [rbp+var_94]
add rsp, 0A0h
pop rbp
retn
loc_AE4A7:
call ___stack_chk_fail
| long long mi_find_writepos(_QWORD *a1, const char *a2, _QWORD *a3, unsigned long long *a4)
{
const char *v4; // rsi
unsigned long long v6; // [rsp+10h] [rbp-90h]
unsigned long long v7; // [rsp+10h] [rbp-90h]
char v10[40]; // [rsp+40h] [rbp-60h] BYREF
unsigned long long v11; // [rsp+68h] [rbp-38h]
long long v12; // [rsp+80h] [rbp-20h]
int v13; // [rsp+90h] [rbp-10h]
unsigned long long v14; // [rsp+98h] [rbp-8h]
v14 = __readfsqword(0x28u);
if ( *(_QWORD *)(*a1 + 88LL) == -1LL || *((_BYTE *)a1 + 826) )
{
*a3 = *(_QWORD *)(a1[1] + 40LL);
v6 = (unsigned long long)&a2[((unsigned long long)a2 >= 0xFFED) + 3];
if ( v6 >= *(_QWORD *)(*a1 + 352LL) )
v7 = (v6 + 3) & 0xFFFFFFFFFFFFFFFCLL;
else
v7 = *(_QWORD *)(*a1 + 352LL);
if ( *(_QWORD *)(a1[1] + 40LL) > *(_QWORD *)(*a1 + 272LL) - v7 )
{
*(_DWORD *)my_thread_var(a1, a2) = 135;
return (unsigned int)-1;
}
if ( v7 > 0xFFFFFC )
v7 = 16777212LL;
*a4 = v7;
*(_QWORD *)(a1[1] + 40LL) += v7;
++*(_QWORD *)(*a1 + 80LL);
*((_DWORD *)a1 + 116) |= 0x100u;
return 0;
}
*a3 = *(_QWORD *)(*a1 + 88LL);
v13 = 0;
*((_DWORD *)a1 + 192) = 1;
v4 = (const char *)*((unsigned int *)a1 + 112);
if ( (mi_get_block_info(v10, v4, *(_QWORD *)(*a1 + 88LL)) & 4) != 0 )
{
*(_QWORD *)(*a1 + 88LL) = v12;
--*(_QWORD *)(a1[1] + 8LL);
*(_QWORD *)(a1[1] + 16LL) -= v11;
*a4 = v11;
return 0;
}
*(_DWORD *)my_thread_var(v10, v4) = 127;
return (unsigned int)-1;
}
| _mi_find_writepos:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xa0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x70],RDI
MOV qword ptr [RBP + -0x78],RSI
MOV qword ptr [RBP + -0x80],RDX
MOV qword ptr [RBP + -0x88],RCX
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX]
CMP qword ptr [RAX + 0x58],-0x1
JZ 0x001ae353
MOV RAX,qword ptr [RBP + -0x70]
CMP byte ptr [RAX + 0x33a],0x0
JNZ 0x001ae353
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RAX + 0x58]
MOV RAX,qword ptr [RBP + -0x80]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x10],0x0
MOV RAX,qword ptr [RBP + -0x70]
MOV dword ptr [RAX + 0x300],0x1
MOV RAX,qword ptr [RBP + -0x70]
MOV ESI,dword ptr [RAX + 0x1c0]
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x58]
LEA RDI,[RBP + -0x60]
CALL 0x001ab440
AND EAX,0x4
CMP EAX,0x0
JNZ 0x001ae306
JMP 0x001ae2ed
LAB_001ae2ed:
JMP 0x001ae2ef
LAB_001ae2ef:
CALL 0x001f7a70
MOV dword ptr [RAX],0x7f
MOV dword ptr [RBP + -0x64],0xffffffff
JMP 0x001ae47d
LAB_001ae306:
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX + 0x58],RCX
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RAX + 0x8]
ADD RCX,-0x1
MOV qword ptr [RAX + 0x8],RCX
MOV RDX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RAX + 0x10]
SUB RCX,RDX
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x88]
MOV qword ptr [RAX],RCX
JMP 0x001ae474
LAB_001ae353:
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RAX + 0x28]
MOV RAX,qword ptr [RBP + -0x80]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x78]
ADD RAX,0x3
MOV RSI,qword ptr [RBP + -0x78]
XOR ECX,ECX
MOV EDX,0x1
CMP RSI,0xffed
CMOVNC ECX,EDX
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x90],RAX
MOV RCX,qword ptr [RBP + -0x70]
MOV RCX,qword ptr [RCX]
CMP RAX,qword ptr [RCX + 0x160]
JNC 0x001ae3b7
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x160]
MOV qword ptr [RBP + -0x90],RAX
JMP 0x001ae3d1
LAB_001ae3b7:
MOV RAX,qword ptr [RBP + -0x90]
ADD RAX,0x4
SUB RAX,0x1
AND RAX,-0x4
MOV qword ptr [RBP + -0x90],RAX
LAB_001ae3d1:
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0x28]
MOV RCX,qword ptr [RBP + -0x70]
MOV RCX,qword ptr [RCX]
MOV RCX,qword ptr [RCX + 0x110]
SUB RCX,qword ptr [RBP + -0x90]
CMP RAX,RCX
JBE 0x001ae40b
CALL 0x001f7a70
MOV dword ptr [RAX],0x87
MOV dword ptr [RBP + -0x64],0xffffffff
JMP 0x001ae47d
LAB_001ae40b:
CMP qword ptr [RBP + -0x90],0xfffffc
JBE 0x001ae423
MOV qword ptr [RBP + -0x90],0xfffffc
LAB_001ae423:
MOV RCX,qword ptr [RBP + -0x90]
MOV RAX,qword ptr [RBP + -0x88]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x90]
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX + 0x8]
ADD RCX,qword ptr [RAX + 0x28]
MOV qword ptr [RAX + 0x28],RCX
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RAX + 0x50]
ADD RCX,0x1
MOV qword ptr [RAX + 0x50],RCX
MOV RAX,qword ptr [RBP + -0x70]
MOV ECX,dword ptr [RAX + 0x1d0]
OR ECX,0x100
MOV dword ptr [RAX + 0x1d0],ECX
LAB_001ae474:
JMP 0x001ae476
LAB_001ae476:
MOV dword ptr [RBP + -0x64],0x0
LAB_001ae47d:
MOV EAX,dword ptr [RBP + -0x64]
MOV dword ptr [RBP + -0x94],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001ae4a7
MOV EAX,dword ptr [RBP + -0x94]
ADD RSP,0xa0
POP RBP
RET
LAB_001ae4a7:
CALL 0x0012a250
|
int4 _mi_find_writepos(long *param_1,ulong param_2,int8 *param_3,ulong *param_4)
{
uint uVar1;
int4 *puVar2;
ulong uVar3;
long in_FS_OFFSET;
ulong local_98;
int4 local_6c;
int1 local_68 [40];
ulong local_40;
int8 local_28;
int4 local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if ((*(long *)(*param_1 + 0x58) == -1) || (*(char *)((long)param_1 + 0x33a) != '\0')) {
*param_3 = *(int8 *)(param_1[1] + 0x28);
uVar3 = param_2 + 3 + (long)(int)(uint)(0xffec < param_2);
if (uVar3 < *(ulong *)(*param_1 + 0x160)) {
local_98 = *(ulong *)(*param_1 + 0x160);
}
else {
local_98 = uVar3 + 3 & 0xfffffffffffffffc;
}
if (*(long *)(*param_1 + 0x110) - local_98 < *(ulong *)(param_1[1] + 0x28)) {
puVar2 = (int4 *)_my_thread_var();
*puVar2 = 0x87;
local_6c = 0xffffffff;
goto LAB_001ae47d;
}
if (0xfffffc < local_98) {
local_98 = 0xfffffc;
}
*param_4 = local_98;
*(ulong *)(param_1[1] + 0x28) = local_98 + *(long *)(param_1[1] + 0x28);
*(long *)(*param_1 + 0x50) = *(long *)(*param_1 + 0x50) + 1;
*(uint *)(param_1 + 0x3a) = *(uint *)(param_1 + 0x3a) | 0x100;
}
else {
*param_3 = *(int8 *)(*param_1 + 0x58);
local_18 = 0;
*(int4 *)(param_1 + 0x60) = 1;
uVar1 = _mi_get_block_info(local_68,(int)param_1[0x38],*(int8 *)(*param_1 + 0x58));
if ((uVar1 & 4) == 0) {
puVar2 = (int4 *)_my_thread_var();
*puVar2 = 0x7f;
local_6c = 0xffffffff;
goto LAB_001ae47d;
}
*(int8 *)(*param_1 + 0x58) = local_28;
*(long *)(param_1[1] + 8) = *(long *)(param_1[1] + 8) + -1;
*(ulong *)(param_1[1] + 0x10) = *(long *)(param_1[1] + 0x10) - local_40;
*param_4 = local_40;
}
local_6c = 0;
LAB_001ae47d:
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return local_6c;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
43,586 | change_partitioned_key_cache_param | eloqsql/mysys/mf_keycache.c | static
void change_partitioned_key_cache_param(PARTITIONED_KEY_CACHE_CB *keycache,
uint division_limit,
uint age_threshold)
{
uint i;
uint partitions= keycache->partitions;
DBUG_ENTER("partitioned_change_key_cache_param");
for (i= 0; i < partitions; i++)
{
change_simple_key_cache_param(keycache->partition_array[i], division_limit,
age_threshold);
}
DBUG_VOID_RETURN;
} | O3 | c | change_partitioned_key_cache_param:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x1c(%rdi), %r12d
testq %r12, %r12
je 0x9f8cb
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
xorl %r13d, %r13d
movq 0x8(%r15), %rax
movq (%rax,%r13,8), %rdi
movl %r14d, %esi
movl %ebx, %edx
callq 0x9e05a
incq %r13
cmpq %r13, %r12
jne 0x9f8b1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| change_partitioned_key_cache_param:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r12d, [rdi+1Ch]
test r12, r12
jz short loc_9F8CB
mov ebx, edx
mov r14d, esi
mov r15, rdi
xor r13d, r13d
loc_9F8B1:
mov rax, [r15+8]
mov rdi, [rax+r13*8]
mov esi, r14d
mov edx, ebx
call change_simple_key_cache_param
inc r13
cmp r12, r13
jnz short loc_9F8B1
loc_9F8CB:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long change_partitioned_key_cache_param(long long a1, int a2, int a3)
{
long long v3; // r12
long long v5; // r13
long long result; // rax
v3 = *(unsigned int *)(a1 + 28);
if ( *(_DWORD *)(a1 + 28) )
{
v5 = 0LL;
do
result = change_simple_key_cache_param(*(_QWORD *)(*(_QWORD *)(a1 + 8) + 8 * v5++), a2, a3);
while ( v3 != v5 );
}
return result;
}
| change_partitioned_key_cache_param:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R12D,dword ptr [RDI + 0x1c]
TEST R12,R12
JZ 0x0019f8cb
MOV EBX,EDX
MOV R14D,ESI
MOV R15,RDI
XOR R13D,R13D
LAB_0019f8b1:
MOV RAX,qword ptr [R15 + 0x8]
MOV RDI,qword ptr [RAX + R13*0x8]
MOV ESI,R14D
MOV EDX,EBX
CALL 0x0019e05a
INC R13
CMP R12,R13
JNZ 0x0019f8b1
LAB_0019f8cb:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void change_partitioned_key_cache_param(long param_1,int4 param_2,int4 param_3)
{
uint uVar1;
ulong uVar2;
uVar1 = *(uint *)(param_1 + 0x1c);
if ((ulong)uVar1 != 0) {
uVar2 = 0;
do {
change_simple_key_cache_param
(*(int8 *)(*(long *)(param_1 + 8) + uVar2 * 8),param_2,param_3);
uVar2 = uVar2 + 1;
} while (uVar1 != uVar2);
}
return;
}
| |
43,587 | mjv_applyPerturbForce | aimrt_mujoco_sim/_deps/mujoco-src/src/engine/engine_vis_interact.c | void mjv_applyPerturbForce(const mjModel* m, mjData* d, const mjvPerturb* pert) {
int sel = pert->select;
// exit if nothing to do
if (sel < 0 || sel >= m->nbody || !(pert->active | pert->active2)) {
return;
}
// pointers to body xfrc_applied, force and torque
mjtNum *force = d->xfrc_applied + 6*sel;
mjtNum *torque = d->xfrc_applied + 6*sel + 3;
// pointers to global selbody velocity, linear and rotational
mjtNum bvel[6];
mj_objectVelocity(m, d, mjOBJ_BODY, sel, bvel, 0);
mjtNum *body_linvel = bvel + 3;
mjtNum *body_rotvel = bvel;
// body rotational inertia
mjtNum invweight = m->body_invweight0[2*sel+1];
mjtNum inertia = invweight ? 1.0/mju_max(mjMINVAL, invweight) : 1;
if (((pert->active | pert->active2) & mjPERT_TRANSLATE)) {
// compute selection point in world coordinates
mjtNum selpos[3];
mju_rotVecMat(selpos, pert->localpos, d->xmat+9*sel);
mju_addTo3(selpos, d->xpos+3*sel);
// displacement of selection point from reference point
mjtNum diff[3];
mju_sub3(diff, selpos, pert->refselpos);
// spring perturbation force
mjtNum stiffness = m->vis.map.stiffness;
mju_copy3(force, diff);
mju_scl3(force, force, -stiffness*pert->localmass);
// moment arm w.r.t body com
mjtNum moment_arm[3];
mju_sub3(moment_arm, selpos, d->xipos+3*sel);
// translational velocity of selection point
mjtNum svel[3];
mju_cross(svel, body_rotvel, moment_arm);
mju_addTo3(svel, body_linvel);
// add critical damping force of selection point
mju_addToScl3(force, svel, -sqrtf(stiffness)*pert->localmass);
// torque on body com due to force
mju_cross(torque, moment_arm, force);
// add critically damped torsional torque along displacement axis
stiffness = m->vis.map.stiffnessrot;
mju_normalize3(diff);
mju_addToScl3(torque, diff, -sqrtf(stiffness)*inertia*mju_dot3(diff, body_rotvel));
}
if (((pert->active | pert->active2) & mjPERT_ROTATE)) {
// spring perturbation torque, with critical damping
mjtNum stiffness = m->vis.map.stiffnessrot;
mjtNum xiquat[4], difquat[4];
mju_mulQuat(xiquat, d->xquat+4*sel, m->body_iquat+4*sel);
mju_negQuat(xiquat, xiquat);
mju_mulQuat(difquat, pert->refquat, xiquat);
mju_quat2Vel(torque, difquat, 1.0/(stiffness*inertia));
mju_addToScl3(torque, body_rotvel, -sqrtf(stiffness)*inertia);
}
} | O0 | c | mjv_applyPerturbForce:
subq $0x198, %rsp # imm = 0x198
movq %rdi, 0x190(%rsp)
movq %rsi, 0x188(%rsp)
movq %rdx, 0x180(%rsp)
movq 0x180(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x17c(%rsp)
cmpl $0x0, 0x17c(%rsp)
jl 0x2ecd39
movl 0x17c(%rsp), %eax
movq 0x190(%rsp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x2ecd39
movq 0x180(%rsp), %rax
movl 0xc(%rax), %eax
movq 0x180(%rsp), %rcx
orl 0x10(%rcx), %eax
cmpl $0x0, %eax
jne 0x2ecd3e
jmp 0x2ed256
movq 0x188(%rsp), %rax
movq 0x277b0(%rax), %rax
imull $0x6, 0x17c(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x170(%rsp)
movq 0x188(%rsp), %rax
movq 0x277b0(%rax), %rax
imull $0x6, 0x17c(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
addq $0x18, %rax
movq %rax, 0x168(%rsp)
movq 0x190(%rsp), %rdi
movq 0x188(%rsp), %rsi
movl 0x17c(%rsp), %ecx
leaq 0x130(%rsp), %r8
movl $0x1, %edx
xorl %r9d, %r9d
callq 0x49a40
leaq 0x130(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x128(%rsp)
leaq 0x130(%rsp), %rax
movq %rax, 0x120(%rsp)
movq 0x190(%rsp), %rax
movq 0x5d0(%rax), %rax
movl 0x17c(%rsp), %ecx
shll %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
vmovsd (%rax,%rcx,8), %xmm0
vmovsd %xmm0, 0x118(%rsp)
vmovsd 0x118(%rsp), %xmm0
vxorps %xmm1, %xmm1, %xmm1
vucomisd %xmm1, %xmm0
jne 0x2ece27
jp 0x2ece27
jmp 0x2ece55
vmovsd 0x118(%rsp), %xmm1
vmovsd 0x22acf8(%rip), %xmm0 # 0x517b30
callq 0x494b0
vmovaps %xmm0, %xmm1
vmovsd 0x22ad0f(%rip), %xmm0 # 0x517b58
vdivsd %xmm1, %xmm0, %xmm0
vmovsd %xmm0, 0x38(%rsp)
jmp 0x2ece65
vmovsd 0x22acfb(%rip), %xmm0 # 0x517b58
vmovsd %xmm0, 0x38(%rsp)
jmp 0x2ece65
vmovsd 0x38(%rsp), %xmm0
vmovsd %xmm0, 0x110(%rsp)
movq 0x180(%rsp), %rax
movl 0xc(%rax), %eax
movq 0x180(%rsp), %rcx
orl 0x10(%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2ed11c
leaq 0xf0(%rsp), %rdi
movq 0x180(%rsp), %rsi
addq $0x68, %rsi
movq 0x188(%rsp), %rax
movq 0x27810(%rax), %rdx
imull $0x9, 0x17c(%rsp), %eax
cltq
shlq $0x3, %rax
addq %rax, %rdx
callq 0x49320
leaq 0xf0(%rsp), %rdi
movq 0x188(%rsp), %rax
movq 0x27800(%rax), %rsi
imull $0x3, 0x17c(%rsp), %eax
cltq
shlq $0x3, %rax
addq %rax, %rsi
callq 0x49380
leaq 0xd0(%rsp), %rdi
leaq 0xf0(%rsp), %rsi
movq 0x180(%rsp), %rdx
addq $0x50, %rdx
callq 0x492b0
movq 0x190(%rsp), %rax
vmovss 0x2d8(%rax), %xmm1
vcvtss2sd %xmm1, %xmm0, %xmm0
vmovsd %xmm0, 0xc8(%rsp)
movq 0x170(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0x49300
movq 0x170(%rsp), %rdi
movq 0x170(%rsp), %rsi
vmovsd 0xc8(%rsp), %xmm0
vmovq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
vmovq %rax, %xmm0
movq 0x180(%rsp), %rax
vmulsd 0x80(%rax), %xmm0, %xmm0
callq 0x49340
leaq 0xb0(%rsp), %rdi
leaq 0xf0(%rsp), %rsi
movq 0x188(%rsp), %rax
movq 0x27818(%rax), %rdx
imull $0x3, 0x17c(%rsp), %eax
cltq
shlq $0x3, %rax
addq %rax, %rdx
callq 0x492b0
leaq 0x90(%rsp), %rdi
movq 0x120(%rsp), %rsi
leaq 0xb0(%rsp), %rdx
callq 0x495e0
leaq 0x90(%rsp), %rdi
movq 0x128(%rsp), %rsi
callq 0x49380
movq 0x170(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x90(%rsp), %rax
movq %rax, 0x18(%rsp)
vmovsd 0xc8(%rsp), %xmm1
vcvtsd2ss %xmm1, %xmm0, %xmm0
callq 0x4aa40
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
vmovd %xmm0, %eax
xorl $0x80000000, %eax # imm = 0x80000000
vmovd %eax, %xmm1
vcvtss2sd %xmm1, %xmm0, %xmm0
movq 0x180(%rsp), %rax
vmulsd 0x80(%rax), %xmm0, %xmm0
callq 0x49310
movq 0x168(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
movq 0x170(%rsp), %rdx
callq 0x495e0
movq 0x190(%rsp), %rax
vmovss 0x2dc(%rax), %xmm1
vcvtss2sd %xmm1, %xmm0, %xmm0
vmovsd %xmm0, 0xc8(%rsp)
leaq 0xd0(%rsp), %rdi
callq 0x492e0
movq 0x168(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0xd0(%rsp), %rax
movq %rax, 0x28(%rsp)
vmovsd 0xc8(%rsp), %xmm1
vcvtsd2ss %xmm1, %xmm0, %xmm0
callq 0x4aa40
vmovd %xmm0, %eax
xorl $0x80000000, %eax # imm = 0x80000000
vmovd %eax, %xmm1
vcvtss2sd %xmm1, %xmm0, %xmm0
vmulsd 0x110(%rsp), %xmm0, %xmm0
vmovsd %xmm0, 0x30(%rsp)
leaq 0xd0(%rsp), %rdi
movq 0x120(%rsp), %rsi
callq 0x49360
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
vmovaps %xmm0, %xmm1
vmovsd 0x30(%rsp), %xmm0
vmulsd %xmm1, %xmm0, %xmm0
callq 0x49310
movq 0x180(%rsp), %rax
movl 0xc(%rax), %eax
movq 0x180(%rsp), %rcx
orl 0x10(%rcx), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x2ed256
movq 0x190(%rsp), %rax
vmovss 0x2dc(%rax), %xmm1
vcvtss2sd %xmm1, %xmm0, %xmm0
vmovsd %xmm0, 0x88(%rsp)
leaq 0x60(%rsp), %rdi
movq 0x188(%rsp), %rax
movq 0x27808(%rax), %rsi
movl 0x17c(%rsp), %eax
shll $0x2, %eax
cltq
shlq $0x3, %rax
addq %rax, %rsi
movq 0x190(%rsp), %rax
movq 0x5b0(%rax), %rdx
movl 0x17c(%rsp), %eax
shll $0x2, %eax
cltq
shlq $0x3, %rax
addq %rax, %rdx
callq 0x497e0
leaq 0x60(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x497f0
leaq 0x40(%rsp), %rdi
movq 0x180(%rsp), %rsi
addq $0x30, %rsi
leaq 0x60(%rsp), %rdx
callq 0x497e0
movq 0x168(%rsp), %rdi
leaq 0x40(%rsp), %rsi
vmovsd 0x88(%rsp), %xmm0
vmulsd 0x110(%rsp), %xmm0, %xmm1
vmovsd 0x22a95e(%rip), %xmm0 # 0x517b58
vdivsd %xmm1, %xmm0, %xmm0
callq 0x49830
movq 0x168(%rsp), %rax
movq %rax, (%rsp)
movq 0x120(%rsp), %rax
movq %rax, 0x8(%rsp)
vmovsd 0x88(%rsp), %xmm1
vcvtsd2ss %xmm1, %xmm0, %xmm0
callq 0x4aa40
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
vmovd %xmm0, %eax
xorl $0x80000000, %eax # imm = 0x80000000
vmovd %eax, %xmm1
vcvtss2sd %xmm1, %xmm0, %xmm0
vmulsd 0x110(%rsp), %xmm0, %xmm0
callq 0x49310
addq $0x198, %rsp # imm = 0x198
retq
nop
| mjv_applyPerturbForce:
sub rsp, 198h
mov [rsp+198h+var_8], rdi
mov [rsp+198h+var_10], rsi
mov [rsp+198h+var_18], rdx
mov rax, [rsp+198h+var_18]
mov eax, [rax]
mov [rsp+198h+var_1C], eax
cmp [rsp+198h+var_1C], 0
jl short loc_2ECD39
mov eax, [rsp+198h+var_1C]
mov rcx, [rsp+198h+var_8]
cmp eax, [rcx+10h]
jge short loc_2ECD39
mov rax, [rsp+198h+var_18]
mov eax, [rax+0Ch]
mov rcx, [rsp+198h+var_18]
or eax, [rcx+10h]
cmp eax, 0
jnz short loc_2ECD3E
loc_2ECD39:
jmp loc_2ED256
loc_2ECD3E:
mov rax, [rsp+198h+var_10]
mov rax, [rax+277B0h]
imul ecx, [rsp+198h+var_1C], 6
movsxd rcx, ecx
shl rcx, 3
add rax, rcx
mov [rsp+198h+var_28], rax
mov rax, [rsp+198h+var_10]
mov rax, [rax+277B0h]
imul ecx, [rsp+198h+var_1C], 6
movsxd rcx, ecx
shl rcx, 3
add rax, rcx
add rax, 18h
mov [rsp+198h+var_30], rax
mov rdi, [rsp+198h+var_8]
mov rsi, [rsp+198h+var_10]
mov ecx, [rsp+198h+var_1C]
lea r8, [rsp+198h+var_68]
mov edx, 1
xor r9d, r9d
call _mj_objectVelocity
lea rax, [rsp+198h+var_68]
add rax, 18h
mov [rsp+198h+var_70], rax
lea rax, [rsp+198h+var_68]
mov [rsp+198h+var_78], rax
mov rax, [rsp+198h+var_8]
mov rax, [rax+5D0h]
mov ecx, [rsp+198h+var_1C]
shl ecx, 1
add ecx, 1
movsxd rcx, ecx
vmovsd xmm0, qword ptr [rax+rcx*8]
vmovsd [rsp+198h+var_80], xmm0
vmovsd xmm0, [rsp+198h+var_80]
vxorps xmm1, xmm1, xmm1
vucomisd xmm0, xmm1
jnz short loc_2ECE27
jp short loc_2ECE27
jmp short loc_2ECE55
loc_2ECE27:
vmovsd xmm1, [rsp+198h+var_80]
vmovsd xmm0, cs:qword_517B30
call _mju_max
vmovaps xmm1, xmm0
vmovsd xmm0, cs:qword_517B58
vdivsd xmm0, xmm0, xmm1
vmovsd [rsp+198h+var_160], xmm0
jmp short loc_2ECE65
loc_2ECE55:
vmovsd xmm0, cs:qword_517B58
vmovsd [rsp+198h+var_160], xmm0
jmp short $+2
loc_2ECE65:
vmovsd xmm0, [rsp+198h+var_160]
vmovsd [rsp+198h+var_88], xmm0
mov rax, [rsp+198h+var_18]
mov eax, [rax+0Ch]
mov rcx, [rsp+198h+var_18]
or eax, [rcx+10h]
and eax, 1
cmp eax, 0
jz loc_2ED11C
lea rdi, [rsp+198h+var_A8]
mov rsi, [rsp+198h+var_18]
add rsi, 68h ; 'h'
mov rax, [rsp+198h+var_10]
mov rdx, [rax+27810h]
imul eax, [rsp+198h+var_1C], 9
cdqe
shl rax, 3
add rdx, rax
call _mju_rotVecMat
lea rdi, [rsp+198h+var_A8]
mov rax, [rsp+198h+var_10]
mov rsi, [rax+27800h]
imul eax, [rsp+198h+var_1C], 3
cdqe
shl rax, 3
add rsi, rax
call _mju_addTo3
lea rdi, [rsp+198h+var_C8]
lea rsi, [rsp+198h+var_A8]
mov rdx, [rsp+198h+var_18]
add rdx, 50h ; 'P'
call _mju_sub3
mov rax, [rsp+198h+var_8]
vmovss xmm1, dword ptr [rax+2D8h]
vcvtss2sd xmm0, xmm0, xmm1
vmovsd [rsp+198h+var_D0], xmm0
mov rdi, [rsp+198h+var_28]
lea rsi, [rsp+198h+var_C8]
call _mju_copy3
mov rdi, [rsp+198h+var_28]
mov rsi, [rsp+198h+var_28]
vmovsd xmm0, [rsp+198h+var_D0]
vmovq rax, xmm0
mov rcx, 8000000000000000h
xor rax, rcx
vmovq xmm0, rax
mov rax, [rsp+198h+var_18]
vmulsd xmm0, xmm0, qword ptr [rax+80h]
call _mju_scl3
lea rdi, [rsp+198h+var_E8]
lea rsi, [rsp+198h+var_A8]
mov rax, [rsp+198h+var_10]
mov rdx, [rax+27818h]
imul eax, [rsp+198h+var_1C], 3
cdqe
shl rax, 3
add rdx, rax
call _mju_sub3
lea rdi, [rsp+198h+var_108]
mov rsi, [rsp+198h+var_78]
lea rdx, [rsp+198h+var_E8]
call _mju_cross
lea rdi, [rsp+198h+var_108]
mov rsi, [rsp+198h+var_70]
call _mju_addTo3
mov rax, [rsp+198h+var_28]
mov [rsp+198h+var_188], rax
lea rax, [rsp+198h+var_108]
mov [rsp+198h+var_180], rax
vmovsd xmm1, [rsp+198h+var_D0]
vcvtsd2ss xmm0, xmm0, xmm1
call _sqrtf
mov rdi, [rsp+198h+var_188]
mov rsi, [rsp+198h+var_180]
vmovd eax, xmm0
xor eax, 80000000h
vmovd xmm1, eax
vcvtss2sd xmm0, xmm0, xmm1
mov rax, [rsp+198h+var_18]
vmulsd xmm0, xmm0, qword ptr [rax+80h]
call _mju_addToScl3
mov rdi, [rsp+198h+var_30]
lea rsi, [rsp+198h+var_E8]
mov rdx, [rsp+198h+var_28]
call _mju_cross
mov rax, [rsp+198h+var_8]
vmovss xmm1, dword ptr [rax+2DCh]
vcvtss2sd xmm0, xmm0, xmm1
vmovsd [rsp+198h+var_D0], xmm0
lea rdi, [rsp+198h+var_C8]
call _mju_normalize3
mov rax, [rsp+198h+var_30]
mov [rsp+198h+var_178], rax
lea rax, [rsp+198h+var_C8]
mov [rsp+198h+var_170], rax
vmovsd xmm1, [rsp+198h+var_D0]
vcvtsd2ss xmm0, xmm0, xmm1
call _sqrtf
vmovd eax, xmm0
xor eax, 80000000h
vmovd xmm1, eax
vcvtss2sd xmm0, xmm0, xmm1
vmulsd xmm0, xmm0, [rsp+198h+var_88]
vmovsd [rsp+198h+var_168], xmm0
lea rdi, [rsp+198h+var_C8]
mov rsi, [rsp+198h+var_78]
call _mju_dot3
mov rdi, [rsp+198h+var_178]
mov rsi, [rsp+198h+var_170]
vmovaps xmm1, xmm0
vmovsd xmm0, [rsp+198h+var_168]
vmulsd xmm0, xmm0, xmm1
call _mju_addToScl3
loc_2ED11C:
mov rax, [rsp+198h+var_18]
mov eax, [rax+0Ch]
mov rcx, [rsp+198h+var_18]
or eax, [rcx+10h]
and eax, 2
cmp eax, 0
jz loc_2ED256
mov rax, [rsp+198h+var_8]
vmovss xmm1, dword ptr [rax+2DCh]
vcvtss2sd xmm0, xmm0, xmm1
vmovsd [rsp+198h+var_110], xmm0
lea rdi, [rsp+198h+var_138]
mov rax, [rsp+198h+var_10]
mov rsi, [rax+27808h]
mov eax, [rsp+198h+var_1C]
shl eax, 2
cdqe
shl rax, 3
add rsi, rax
mov rax, [rsp+198h+var_8]
mov rdx, [rax+5B0h]
mov eax, [rsp+198h+var_1C]
shl eax, 2
cdqe
shl rax, 3
add rdx, rax
call _mju_mulQuat
lea rdi, [rsp+198h+var_138]
lea rsi, [rsp+198h+var_138]
call _mju_negQuat
lea rdi, [rsp+198h+var_158]
mov rsi, [rsp+198h+var_18]
add rsi, 30h ; '0'
lea rdx, [rsp+198h+var_138]
call _mju_mulQuat
mov rdi, [rsp+198h+var_30]
lea rsi, [rsp+198h+var_158]
vmovsd xmm0, [rsp+198h+var_110]
vmulsd xmm1, xmm0, [rsp+198h+var_88]
vmovsd xmm0, cs:qword_517B58
vdivsd xmm0, xmm0, xmm1
call _mju_quat2Vel
mov rax, [rsp+198h+var_30]
mov [rsp+198h+var_198], rax
mov rax, [rsp+198h+var_78]
mov [rsp+198h+var_190], rax
vmovsd xmm1, [rsp+198h+var_110]
vcvtsd2ss xmm0, xmm0, xmm1
call _sqrtf
mov rdi, [rsp+198h+var_198]
mov rsi, [rsp+198h+var_190]
vmovd eax, xmm0
xor eax, 80000000h
vmovd xmm1, eax
vcvtss2sd xmm0, xmm0, xmm1
vmulsd xmm0, xmm0, [rsp+198h+var_88]
call _mju_addToScl3
loc_2ED256:
add rsp, 198h
retn
| long long mjv_applyPerturbForce(long long a1, _QWORD *a2, int *a3, double a4, __m128 _XMM1)
{
long long result; // rax
long long v21; // rdx
long long v56; // [rsp+0h] [rbp-198h]
_BYTE *v57; // [rsp+8h] [rbp-190h]
long long v58; // [rsp+10h] [rbp-188h]
long long v59; // [rsp+20h] [rbp-178h]
_BYTE v62[32]; // [rsp+40h] [rbp-158h] BYREF
_BYTE v63[40]; // [rsp+60h] [rbp-138h] BYREF
_BYTE v65[32]; // [rsp+90h] [rbp-108h] BYREF
_BYTE v66[24]; // [rsp+B0h] [rbp-E8h] BYREF
_BYTE v68[32]; // [rsp+D0h] [rbp-C8h] BYREF
_BYTE v69[32]; // [rsp+F0h] [rbp-A8h] BYREF
_BYTE *v72; // [rsp+120h] [rbp-78h]
long long *v73; // [rsp+128h] [rbp-70h]
_BYTE v74[24]; // [rsp+130h] [rbp-68h] BYREF
long long v75; // [rsp+148h] [rbp-50h] BYREF
long long v76; // [rsp+168h] [rbp-30h]
long long v77; // [rsp+170h] [rbp-28h]
int v78; // [rsp+17Ch] [rbp-1Ch]
int *v79; // [rsp+180h] [rbp-18h]
_QWORD *v80; // [rsp+188h] [rbp-10h]
long long v81; // [rsp+190h] [rbp-8h]
v81 = a1;
v80 = a2;
v79 = a3;
result = (unsigned int)*a3;
v78 = *a3;
if ( v78 >= 0 )
{
result = (unsigned int)v78;
if ( v78 < *(_DWORD *)(v81 + 16) )
{
result = v79[4] | (unsigned int)v79[3];
if ( *(_QWORD *)(v79 + 3) )
{
v77 = 48LL * v78 + v80[20214];
v76 = 48LL * v78 + v80[20214] + 24;
mj_objectVelocity(v81, v80, 1LL, (unsigned int)v78, v74, 0LL);
v73 = &v75;
v72 = v74;
_RAX = *(_QWORD *)(v81 + 1488);
_RCX = 2 * v78 + 1;
__asm
{
vmovsd xmm0, qword ptr [rax+rcx*8]
vmovsd [rsp+198h+var_80], xmm0
vmovsd xmm0, [rsp+198h+var_80]
vxorps xmm1, xmm1, xmm1
vucomisd xmm0, xmm1
}
if ( 2 * v78 != -1 || __SETP__(2 * v78 + 1, 0) )
{
__asm
{
vmovsd xmm1, [rsp+198h+var_80]
vmovsd xmm0, cs:qword_517B30
}
*(double *)&_XMM0 = mju_max(*(double *)&_XMM0, *(double *)&_XMM1);
__asm
{
vmovaps xmm1, xmm0
vmovsd xmm0, cs:qword_517B58
vdivsd xmm0, xmm0, xmm1
vmovsd [rsp+198h+var_160], xmm0
}
}
else
{
__asm
{
vmovsd xmm0, cs:qword_517B58
vmovsd [rsp+198h+var_160], xmm0
}
}
__asm
{
vmovsd xmm0, [rsp+198h+var_160]
vmovsd [rsp+198h+var_88], xmm0
}
if ( ((v79[4] | v79[3]) & 1) != 0 )
{
mju_rotVecMat(v69, v79 + 26, 72LL * v78 + v80[20226]);
mju_addTo3(v69, 24LL * v78 + v80[20224]);
*(double *)&_XMM0 = mju_sub3(v68, v69, v79 + 20);
_RAX = v81;
__asm
{
vmovss xmm1, dword ptr [rax+2D8h]
vcvtss2sd xmm0, xmm0, xmm1
vmovsd [rsp+198h+var_D0], xmm0
}
mju_copy3(v77, v68, v21);
__asm
{
vmovsd xmm0, [rsp+198h+var_D0]
vmovq rax, xmm0
}
_RAX ^= 0x8000000000000000LL;
__asm
{
vmovq xmm0, rax
vmulsd xmm0, xmm0, qword ptr [rax+80h]
}
mju_scl3(v77, v77, *(double *)&_XMM0);
mju_sub3(v66, v69, 24LL * v78 + v80[20227]);
mju_cross(v65, v72, v66);
*(double *)&_XMM0 = mju_addTo3(v65, v73);
v58 = v77;
__asm
{
vmovsd xmm1, [rsp+198h+var_D0]
vcvtsd2ss xmm0, xmm0, xmm1
}
*(double *)&_XMM0 = sqrtf(*(double *)&_XMM0);
__asm { vmovd eax, xmm0 }
_EAX ^= 0x80000000;
__asm
{
vmovd xmm1, eax
vcvtss2sd xmm0, xmm0, xmm1
vmulsd xmm0, xmm0, qword ptr [rax+80h]
}
mju_addToScl3(v58, v65, *(double *)&_XMM0);
*(double *)&_XMM0 = mju_cross(v76, v66, v77);
_RAX = v81;
__asm
{
vmovss xmm1, dword ptr [rax+2DCh]
vcvtss2sd xmm0, xmm0, xmm1
vmovsd [rsp+198h+var_D0], xmm0
}
*(double *)&_XMM0 = mju_normalize3(v68);
v59 = v76;
__asm
{
vmovsd xmm1, [rsp+198h+var_D0]
vcvtsd2ss xmm0, xmm0, xmm1
}
*(double *)&_XMM0 = sqrtf(*(double *)&_XMM0);
__asm { vmovd eax, xmm0 }
_EAX ^= 0x80000000;
__asm
{
vmovd xmm1, eax
vcvtss2sd xmm0, xmm0, xmm1
vmulsd xmm0, xmm0, [rsp+198h+var_88]
vmovsd [rsp+198h+var_168], xmm0
}
*(double *)&_XMM0 = mju_dot3(v68, v72);
__asm
{
vmovaps xmm1, xmm0
vmovsd xmm0, [rsp+198h+var_168]
vmulsd xmm0, xmm0, xmm1
}
mju_addToScl3(v59, v68, *(double *)&_XMM0);
}
result = (v79[4] | v79[3]) & 2;
if ( (_DWORD)result )
{
_RAX = v81;
__asm
{
vmovss xmm1, dword ptr [rax+2DCh]
vcvtss2sd xmm0, xmm0, xmm1
vmovsd [rsp+198h+var_110], xmm0
}
mju_mulQuat(v63, 32LL * v78 + v80[20225], 32LL * v78 + *(_QWORD *)(v81 + 1456));
mju_negQuat(v63, v63);
mju_mulQuat(v62, v79 + 12, v63);
__asm
{
vmovsd xmm0, [rsp+198h+var_110]
vmulsd xmm1, xmm0, [rsp+198h+var_88]
vmovsd xmm0, cs:qword_517B58
vdivsd xmm0, xmm0, xmm1
}
*(double *)&_XMM0 = mju_quat2Vel(v76, v62, *(double *)&_XMM0);
v56 = v76;
v57 = v72;
__asm
{
vmovsd xmm1, [rsp+198h+var_110]
vcvtsd2ss xmm0, xmm0, xmm1
}
*(double *)&_XMM0 = sqrtf(*(double *)&_XMM0);
__asm { vmovd eax, xmm0 }
_EAX ^= 0x80000000;
__asm
{
vmovd xmm1, eax
vcvtss2sd xmm0, xmm0, xmm1
vmulsd xmm0, xmm0, [rsp+198h+var_88]
}
return mju_addToScl3(v56, v57, *(double *)&_XMM0);
}
}
}
}
return result;
}
| |||
43,588 | mjv_applyPerturbForce | aimrt_mujoco_sim/_deps/mujoco-src/src/engine/engine_vis_interact.c | void mjv_applyPerturbForce(const mjModel* m, mjData* d, const mjvPerturb* pert) {
int sel = pert->select;
// exit if nothing to do
if (sel < 0 || sel >= m->nbody || !(pert->active | pert->active2)) {
return;
}
// pointers to body xfrc_applied, force and torque
mjtNum *force = d->xfrc_applied + 6*sel;
mjtNum *torque = d->xfrc_applied + 6*sel + 3;
// pointers to global selbody velocity, linear and rotational
mjtNum bvel[6];
mj_objectVelocity(m, d, mjOBJ_BODY, sel, bvel, 0);
mjtNum *body_linvel = bvel + 3;
mjtNum *body_rotvel = bvel;
// body rotational inertia
mjtNum invweight = m->body_invweight0[2*sel+1];
mjtNum inertia = invweight ? 1.0/mju_max(mjMINVAL, invweight) : 1;
if (((pert->active | pert->active2) & mjPERT_TRANSLATE)) {
// compute selection point in world coordinates
mjtNum selpos[3];
mju_rotVecMat(selpos, pert->localpos, d->xmat+9*sel);
mju_addTo3(selpos, d->xpos+3*sel);
// displacement of selection point from reference point
mjtNum diff[3];
mju_sub3(diff, selpos, pert->refselpos);
// spring perturbation force
mjtNum stiffness = m->vis.map.stiffness;
mju_copy3(force, diff);
mju_scl3(force, force, -stiffness*pert->localmass);
// moment arm w.r.t body com
mjtNum moment_arm[3];
mju_sub3(moment_arm, selpos, d->xipos+3*sel);
// translational velocity of selection point
mjtNum svel[3];
mju_cross(svel, body_rotvel, moment_arm);
mju_addTo3(svel, body_linvel);
// add critical damping force of selection point
mju_addToScl3(force, svel, -sqrtf(stiffness)*pert->localmass);
// torque on body com due to force
mju_cross(torque, moment_arm, force);
// add critically damped torsional torque along displacement axis
stiffness = m->vis.map.stiffnessrot;
mju_normalize3(diff);
mju_addToScl3(torque, diff, -sqrtf(stiffness)*inertia*mju_dot3(diff, body_rotvel));
}
if (((pert->active | pert->active2) & mjPERT_ROTATE)) {
// spring perturbation torque, with critical damping
mjtNum stiffness = m->vis.map.stiffnessrot;
mjtNum xiquat[4], difquat[4];
mju_mulQuat(xiquat, d->xquat+4*sel, m->body_iquat+4*sel);
mju_negQuat(xiquat, xiquat);
mju_mulQuat(difquat, pert->refquat, xiquat);
mju_quat2Vel(torque, difquat, 1.0/(stiffness*inertia));
mju_addToScl3(torque, body_rotvel, -sqrtf(stiffness)*inertia);
}
} | O3 | c | mjv_applyPerturbForce:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl (%rdx), %r14d
testl %r14d, %r14d
js 0xa7fc8
movq %rdi, %r15
cmpl 0x10(%rdi), %r14d
jge 0xa7fc8
movq %rdx, %rbx
movl 0x10(%rdx), %eax
orl 0xc(%rdx), %eax
je 0xa7fc8
movq %rsi, %r12
movq 0x277b0(%rsi), %rbp
leaq (%r14,%r14,2), %r13
shlq $0x4, %r13
leaq 0x90(%rsp), %r8
movq %r15, %rdi
movl $0x1, %edx
movl %r14d, %ecx
xorl %r9d, %r9d
callq 0x2d860
movq 0x5d0(%r15), %rax
movq %r14, %rcx
shlq $0x4, %rcx
vmovsd 0x8(%rax,%rcx), %xmm1
vxorpd %xmm0, %xmm0, %xmm0
vucomisd %xmm0, %xmm1
jne 0xa7cf3
jnp 0xa7d0e
vmovsd 0x114ead(%rip), %xmm0 # 0x1bcba8
callq 0x2d2f0
vmovsd 0x114ec8(%rip), %xmm1 # 0x1bcbd0
vdivsd %xmm0, %xmm1, %xmm0
jmp 0xa7d16
vmovsd 0x114eba(%rip), %xmm0 # 0x1bcbd0
vmovsd %xmm0, 0x10(%rsp)
leaq 0x18(,%r13), %rax
addq %rbp, %rax
movq %rax, 0x18(%rsp)
movl 0x10(%rbx), %eax
orl 0xc(%rbx), %eax
testb $0x1, %al
je 0xa7eee
addq %r13, %rbp
leaq 0x68(%rbx), %rsi
leaq (%r14,%r14,8), %rdx
shlq $0x3, %rdx
addq 0x27810(%r12), %rdx
leaq 0x50(%rsp), %rdi
callq 0x2d170
leal (%r14,%r14,2), %r13d
shlq $0x3, %r13
movq 0x27800(%r12), %rsi
addq %r13, %rsi
leaq 0x50(%rsp), %rdi
callq 0x2d1c0
leaq 0x50(%rbx), %rdx
leaq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x2d100
vmovss 0x2d8(%r15), %xmm0
vmovss %xmm0, 0x8(%rsp)
vcvtss2sd %xmm0, %xmm0, %xmm0
vmovaps %xmm0, 0x20(%rsp)
movq %rbp, %rdi
leaq 0x30(%rsp), %rsi
callq 0x2d160
vmovddup 0x114de7(%rip), %xmm0 # xmm0 = mem[0,0]
vxorpd 0x20(%rsp), %xmm0, %xmm0
vmulsd 0x80(%rbx), %xmm0, %xmm0
movq %rbp, %rdi
movq %rbp, %rsi
callq 0x2d190
addq 0x27818(%r12), %r13
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
movq %r13, %rdx
callq 0x2d100
leaq 0xc0(%rsp), %r13
leaq 0x90(%rsp), %rsi
movq %r13, %rdi
leaq 0x70(%rsp), %rdx
callq 0x2d420
movq %r13, %rdi
leaq 0xa8(%rsp), %rsi
callq 0x2d1c0
vmovss 0x8(%rsp), %xmm0
vxorpd %xmm1, %xmm1, %xmm1
vucomiss %xmm1, %xmm0
jb 0xa7e2f
vsqrtss %xmm0, %xmm0, %xmm0
jmp 0xa7e34
callq 0x2e560
vbroadcastss 0x11581f(%rip), %xmm1 # 0x1bd65c
vxorps %xmm1, %xmm0, %xmm0
vcvtss2sd %xmm0, %xmm0, %xmm0
vmulsd 0x80(%rbx), %xmm0, %xmm0
leaq 0xc0(%rsp), %rsi
movq %rbp, %rdi
callq 0x2d140
leaq 0x70(%rsp), %rsi
movq 0x18(%rsp), %rdi
movq %rbp, %rdx
callq 0x2d420
vmovss 0x2dc(%r15), %xmm0
vmovss %xmm0, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x2d130
vmovss 0x8(%rsp), %xmm0
vucomiss 0x1157ca(%rip), %xmm0 # 0x1bd660
jb 0xa7e9e
vsqrtss %xmm0, %xmm0, %xmm0
jmp 0xa7ea3
callq 0x2e560
vbroadcastss 0x1157b0(%rip), %xmm1 # 0x1bd65c
vxorps %xmm1, %xmm0, %xmm0
vcvtss2sd %xmm0, %xmm0, %xmm0
vmulsd 0x10(%rsp), %xmm0, %xmm0
vmovsd %xmm0, 0x8(%rsp)
leaq 0x30(%rsp), %r13
leaq 0x90(%rsp), %rsi
movq %r13, %rdi
callq 0x2d1b0
vmulsd 0x8(%rsp), %xmm0, %xmm0
movq 0x18(%rsp), %rdi
movq %r13, %rsi
callq 0x2d140
movl 0x10(%rbx), %eax
orl 0xc(%rbx), %eax
testb $0x2, %al
je 0xa7fc8
vmovss 0x2dc(%r15), %xmm0
vmovss %xmm0, 0x8(%rsp)
vcvtss2sd %xmm0, %xmm0, %xmm0
vmovsd %xmm0, 0x20(%rsp)
shll $0x2, %r14d
shlq $0x3, %r14
movq 0x27808(%r12), %rsi
addq %r14, %rsi
addq 0x5b0(%r15), %r14
leaq 0x50(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x2d620
movq %r15, %rdi
movq %r15, %rsi
callq 0x2d630
addq $0x30, %rbx
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2d620
vmovsd 0x20(%rsp), %xmm0
vmulsd 0x10(%rsp), %xmm0, %xmm0
vmovsd 0x114c61(%rip), %xmm1 # 0x1bcbd0
vdivsd %xmm0, %xmm1, %xmm0
movq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x2d660
vxorpd %xmm0, %xmm0, %xmm0
vmovss 0x8(%rsp), %xmm1
vucomiss %xmm0, %xmm1
vmovaps %xmm1, %xmm0
jb 0xa7f9a
vsqrtss %xmm0, %xmm0, %xmm0
jmp 0xa7f9f
callq 0x2e560
vbroadcastss 0x1156b4(%rip), %xmm1 # 0x1bd65c
vxorps %xmm1, %xmm0, %xmm0
vcvtss2sd %xmm0, %xmm0, %xmm0
vmulsd 0x10(%rsp), %xmm0, %xmm0
leaq 0x90(%rsp), %rsi
movq 0x18(%rsp), %rdi
callq 0x2d140
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| mjv_applyPerturbForce:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0D8h
mov r14d, [rdx]
test r14d, r14d
js loc_A7FC8
mov r15, rdi
cmp r14d, [rdi+10h]
jge loc_A7FC8
mov rbx, rdx
mov eax, [rdx+10h]
or eax, [rdx+0Ch]
jz loc_A7FC8
mov r12, rsi
mov rbp, qword ptr ds:stru_277B0.r_offset[rsi]
lea r13, [r14+r14*2]
shl r13, 4
lea r8, [rsp+108h+var_78]
mov rdi, r15
mov edx, 1
mov ecx, r14d
xor r9d, r9d
call _mj_objectVelocity
mov rax, [r15+5D0h]
mov rcx, r14
shl rcx, 4
vmovsd xmm1, qword ptr [rax+rcx+8]
vxorpd xmm0, xmm0, xmm0
vucomisd xmm1, xmm0
jnz short loc_A7CF3
jnp short loc_A7D0E
loc_A7CF3:
vmovsd xmm0, cs:qword_1BCBA8
call _mju_max
vmovsd xmm1, cs:qword_1BCBD0
vdivsd xmm0, xmm1, xmm0
jmp short loc_A7D16
loc_A7D0E:
vmovsd xmm0, cs:qword_1BCBD0
loc_A7D16:
vmovsd [rsp+108h+var_F8], xmm0
lea rax, ds:18h[r13]
add rax, rbp
mov [rsp+108h+var_F0], rax
mov eax, [rbx+10h]
or eax, [rbx+0Ch]
test al, 1
jz loc_A7EEE
add rbp, r13
lea rsi, [rbx+68h]
lea rdx, [r14+r14*8]
shl rdx, 3
add rdx, qword ptr ds:stru_27810.r_offset[r12]
lea rdi, [rsp+108h+var_B8]
call _mju_rotVecMat
lea r13d, [r14+r14*2]
shl r13, 3
mov rsi, [r12+27800h]
add rsi, r13
lea rdi, [rsp+108h+var_B8]
call _mju_addTo3
lea rdx, [rbx+50h]
lea rdi, [rsp+108h+var_D8]
lea rsi, [rsp+108h+var_B8]
call _mju_sub3
vmovss xmm0, dword ptr [r15+2D8h]
vmovss dword ptr [rsp+108h+var_100], xmm0
vcvtss2sd xmm0, xmm0, xmm0
vmovaps [rsp+108h+var_E8], xmm0
mov rdi, rbp
lea rsi, [rsp+108h+var_D8]
call _mju_copy3
vmovddup xmm0, cs:qword_1BCBA0
vxorpd xmm0, xmm0, [rsp+108h+var_E8]
vmulsd xmm0, xmm0, qword ptr [rbx+80h]
mov rdi, rbp
mov rsi, rbp
call _mju_scl3
add r13, [r12+27818h]
lea rdi, [rsp+108h+var_98]
lea rsi, [rsp+108h+var_B8]
mov rdx, r13
call _mju_sub3
lea r13, [rsp+108h+var_48]
lea rsi, [rsp+108h+var_78]
mov rdi, r13
lea rdx, [rsp+108h+var_98]
call _mju_cross
mov rdi, r13
lea rsi, [rsp+108h+var_60]
call _mju_addTo3
vmovss xmm0, dword ptr [rsp+108h+var_100]
vxorpd xmm1, xmm1, xmm1
vucomiss xmm0, xmm1
jb short loc_A7E2F
vsqrtss xmm0, xmm0, xmm0
jmp short loc_A7E34
loc_A7E2F:
call _sqrtf
loc_A7E34:
vbroadcastss xmm1, cs:dword_1BD65C
vxorps xmm0, xmm0, xmm1
vcvtss2sd xmm0, xmm0, xmm0
vmulsd xmm0, xmm0, qword ptr [rbx+80h]
lea rsi, [rsp+108h+var_48]
mov rdi, rbp
call _mju_addToScl3
lea rsi, [rsp+108h+var_98]
mov rdi, [rsp+108h+var_F0]
mov rdx, rbp
call _mju_cross
vmovss xmm0, dword ptr [r15+2DCh]
vmovss dword ptr [rsp+108h+var_100], xmm0
lea rdi, [rsp+108h+var_D8]
call _mju_normalize3
vmovss xmm0, dword ptr [rsp+108h+var_100]
vucomiss xmm0, cs:dword_1BD660
jb short loc_A7E9E
vsqrtss xmm0, xmm0, xmm0
jmp short loc_A7EA3
loc_A7E9E:
call _sqrtf
loc_A7EA3:
vbroadcastss xmm1, cs:dword_1BD65C
vxorps xmm0, xmm0, xmm1
vcvtss2sd xmm0, xmm0, xmm0
vmulsd xmm0, xmm0, [rsp+108h+var_F8]
vmovsd [rsp+108h+var_100], xmm0
lea r13, [rsp+108h+var_D8]
lea rsi, [rsp+108h+var_78]
mov rdi, r13
call _mju_dot3
vmulsd xmm0, xmm0, [rsp+108h+var_100]
mov rdi, [rsp+108h+var_F0]
mov rsi, r13
call _mju_addToScl3
mov eax, [rbx+10h]
or eax, [rbx+0Ch]
loc_A7EEE:
test al, 2
jz loc_A7FC8
vmovss xmm0, dword ptr [r15+2DCh]
vmovss dword ptr [rsp+108h+var_100], xmm0
vcvtss2sd xmm0, xmm0, xmm0
vmovsd qword ptr [rsp+108h+var_E8], xmm0
shl r14d, 2
shl r14, 3
mov rsi, [r12+27808h]
add rsi, r14
add r14, [r15+5B0h]
lea r15, [rsp+108h+var_B8]
mov rdi, r15
mov rdx, r14
call _mju_mulQuat
mov rdi, r15
mov rsi, r15
call _mju_negQuat
add rbx, 30h ; '0'
lea r14, [rsp+108h+var_D8]
mov rdi, r14
mov rsi, rbx
mov rdx, r15
call _mju_mulQuat
vmovsd xmm0, qword ptr [rsp+108h+var_E8]
vmulsd xmm0, xmm0, [rsp+108h+var_F8]
vmovsd xmm1, cs:qword_1BCBD0
vdivsd xmm0, xmm1, xmm0
mov rdi, [rsp+108h+var_F0]
mov rsi, r14
call _mju_quat2Vel
vxorpd xmm0, xmm0, xmm0
vmovss xmm1, dword ptr [rsp+108h+var_100]
vucomiss xmm1, xmm0
vmovaps xmm0, xmm1
jb short loc_A7F9A
vsqrtss xmm0, xmm0, xmm0
jmp short loc_A7F9F
loc_A7F9A:
call _sqrtf
loc_A7F9F:
vbroadcastss xmm1, cs:dword_1BD65C
vxorps xmm0, xmm0, xmm1
vcvtss2sd xmm0, xmm0, xmm0
vmulsd xmm0, xmm0, [rsp+108h+var_F8]
lea rsi, [rsp+108h+var_78]
mov rdi, [rsp+108h+var_F0]
call _mju_addToScl3
loc_A7FC8:
add rsp, 0D8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| double mjv_applyPerturbForce(
long long a1,
_QWORD *a2,
unsigned int *a3,
__m128 _XMM0,
double a5,
double a6,
double a7)
{
long long v7; // r14
long long v10; // rbp
long long v11; // r13
int v17; // eax
long long v18; // rbp
long long v19; // r13
char v27; // cf
long long v44; // rdx
long long v45; // rcx
long long v46; // r8
long long v59; // [rsp+18h] [rbp-F0h]
_BYTE v62[32]; // [rsp+30h] [rbp-D8h] BYREF
_BYTE v63[32]; // [rsp+50h] [rbp-B8h] BYREF
_BYTE v64[32]; // [rsp+70h] [rbp-98h] BYREF
_BYTE v65[24]; // [rsp+90h] [rbp-78h] BYREF
_BYTE v66[24]; // [rsp+A8h] [rbp-60h] BYREF
_BYTE v67[72]; // [rsp+C0h] [rbp-48h] BYREF
v7 = *a3;
if ( (int)v7 >= 0 )
{
_R15 = a1;
if ( (int)v7 < *(_DWORD *)(a1 + 16) )
{
if ( *(_QWORD *)(a3 + 3) )
{
v10 = *(unsigned long long *)((char *)&stru_277B0.r_offset + (_QWORD)a2);
v11 = 48 * v7;
*(double *)_XMM0.m128_u64 = mj_objectVelocity(
a1,
a2,
1LL,
(unsigned int)v7,
v65,
0LL,
*(double *)_XMM0.m128_u64);
_RAX = *(_QWORD *)(a1 + 1488);
_RCX = 16 * v7;
__asm
{
vmovsd xmm1, qword ptr [rax+rcx+8]
vxorpd xmm0, xmm0, xmm0
vucomisd xmm1, xmm0
}
if ( 16 * v7 || __SETP__(16 * v7, 0LL) )
{
__asm { vmovsd xmm0, cs:qword_1BCBA8 }
mju_max(*(double *)&_XMM0, *(double *)&_XMM1);
__asm
{
vmovsd xmm1, cs:qword_1BCBD0
vdivsd xmm0, xmm1, xmm0
}
}
else
{
__asm { vmovsd xmm0, cs:qword_1BCBD0 }
}
__asm { vmovsd [rsp+108h+var_F8], xmm0 }
v59 = v10 + v11 + 24;
v17 = a3[3] | a3[4];
if ( ((*((_BYTE *)a3 + 12) | *((_BYTE *)a3 + 16)) & 1) != 0 )
{
v18 = v11 + v10;
mju_rotVecMat(
v63,
a3 + 26,
*(unsigned long long *)((char *)&stru_27810.r_offset + (_QWORD)a2) + 72 * v7,
*(double *)_XMM0.m128_u64);
v19 = 8LL * (unsigned int)(3 * v7);
mju_addTo3(v63, v19 + a2[20224], *(double *)_XMM0.m128_u64, *(double *)&_XMM1, a6, a7);
mju_sub3(v62, v63, a3 + 20);
__asm
{
vmovss xmm0, dword ptr [r15+2D8h]
vmovss dword ptr [rsp+108h+var_100], xmm0
vcvtss2sd xmm0, xmm0, xmm0
vmovaps [rsp+108h+var_E8], xmm0
}
mju_copy3(v18, v62);
__asm
{
vmovddup xmm0, cs:qword_1BCBA0
vxorpd xmm0, xmm0, [rsp+108h+var_E8]
vmulsd xmm0, xmm0, qword ptr [rbx+80h]
}
mju_scl3(v18, v18, *(double *)&_XMM0);
mju_sub3(v64, v63, a2[20227] + v19);
*(double *)&_XMM0 = mju_cross(v67, v65, v64);
mju_addTo3(v67, v66, *(double *)&_XMM0, *(double *)&_XMM1, a6, a7);
__asm
{
vmovss xmm0, dword ptr [rsp+108h+var_100]
vxorpd xmm1, xmm1, xmm1
vucomiss xmm0, xmm1
}
if ( v27 )
*(double *)&_XMM0 = ((double (*)(void))sqrtf)();
else
__asm { vsqrtss xmm0, xmm0, xmm0 }
__asm
{
vbroadcastss xmm1, cs:dword_1BD65C
vxorps xmm0, xmm0, xmm1
vcvtss2sd xmm0, xmm0, xmm0
vmulsd xmm0, xmm0, qword ptr [rbx+80h]
}
mju_addToScl3(v18, v67);
mju_cross(v59, v64, v18);
__asm
{
vmovss xmm0, dword ptr [r15+2DCh]
vmovss dword ptr [rsp+108h+var_100], xmm0
}
mju_normalize3(v62, *(double *)&_XMM0, *(double *)&_XMM1);
__asm
{
vmovss xmm0, dword ptr [rsp+108h+var_100]
vucomiss xmm0, cs:dword_1BD660
}
if ( v27 )
*(double *)&_XMM0 = ((double (*)(void))sqrtf)();
else
__asm { vsqrtss xmm0, xmm0, xmm0 }
__asm
{
vbroadcastss xmm1, cs:dword_1BD65C
vxorps xmm0, xmm0, xmm1
vcvtss2sd xmm0, xmm0, xmm0
vmulsd xmm0, xmm0, [rsp+108h+var_F8]
vmovsd [rsp+108h+var_100], xmm0
}
*(double *)&_XMM0 = mju_dot3(v62, v65);
__asm { vmulsd xmm0, xmm0, [rsp+108h+var_100] }
*(double *)_XMM0.m128_u64 = mju_addToScl3(v59, v62);
v17 = a3[3] | a3[4];
}
if ( (v17 & 2) != 0 )
{
__asm
{
vmovss xmm0, dword ptr [r15+2DCh]
vmovss dword ptr [rsp+108h+var_100], xmm0
vcvtss2sd xmm0, xmm0, xmm0
vmovsd qword ptr [rsp+108h+var_E8], xmm0
}
mju_mulQuat(
v63,
8LL * (unsigned int)(4 * v7) + a2[20225],
*(_QWORD *)(a1 + 1456) + 8LL * (unsigned int)(4 * v7),
*(double *)&_XMM0);
mju_negQuat(v63, v63);
mju_mulQuat(v62, a3 + 12, v63, *(double *)&_XMM0);
__asm
{
vmovsd xmm0, qword ptr [rsp+108h+var_E8]
vmulsd xmm0, xmm0, [rsp+108h+var_F8]
vmovsd xmm1, cs:qword_1BCBD0
vdivsd xmm0, xmm1, xmm0
}
*(double *)&_XMM0 = mju_quat2Vel(v59, v62, v44, v45, v46, *(double *)&_XMM0);
__asm
{
vxorpd xmm0, xmm0, xmm0
vmovss xmm1, dword ptr [rsp+108h+var_100]
vucomiss xmm1, xmm0
vmovaps xmm0, xmm1
}
if ( v27 )
*(double *)&_XMM0 = sqrtf(*(double *)&_XMM0);
else
__asm { vsqrtss xmm0, xmm0, xmm0 }
__asm
{
vbroadcastss xmm1, cs:dword_1BD65C
vxorps xmm0, xmm0, xmm1
vcvtss2sd xmm0, xmm0, xmm0
vmulsd xmm0, xmm0, [rsp+108h+var_F8]
}
*(double *)_XMM0.m128_u64 = mju_addToScl3(v59, v65);
}
}
}
}
return *(double *)_XMM0.m128_u64;
}
| mjv_applyPerturbForce:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xd8
MOV R14D,dword ptr [RDX]
TEST R14D,R14D
JS 0x001a7fc8
MOV R15,RDI
CMP R14D,dword ptr [RDI + 0x10]
JGE 0x001a7fc8
MOV RBX,RDX
MOV EAX,dword ptr [RDX + 0x10]
OR EAX,dword ptr [RDX + 0xc]
JZ 0x001a7fc8
MOV R12,RSI
MOV RBP,qword ptr [RSI + 0x277b0]
LEA R13,[R14 + R14*0x2]
SHL R13,0x4
LEA R8,[RSP + 0x90]
MOV RDI,R15
MOV EDX,0x1
MOV ECX,R14D
XOR R9D,R9D
CALL 0x0012d860
MOV RAX,qword ptr [R15 + 0x5d0]
MOV RCX,R14
SHL RCX,0x4
VMOVSD XMM1,qword ptr [RAX + RCX*0x1 + 0x8]
VXORPD XMM0,XMM0,XMM0
VUCOMISD XMM1,XMM0
JNZ 0x001a7cf3
JNP 0x001a7d0e
LAB_001a7cf3:
VMOVSD XMM0,qword ptr [0x002bcba8]
CALL 0x0012d2f0
VMOVSD XMM1,qword ptr [0x002bcbd0]
VDIVSD XMM0,XMM1,XMM0
JMP 0x001a7d16
LAB_001a7d0e:
VMOVSD XMM0,qword ptr [0x002bcbd0]
LAB_001a7d16:
VMOVSD qword ptr [RSP + 0x10],XMM0
LEA RAX,[0x18 + R13*0x1]
ADD RAX,RBP
MOV qword ptr [RSP + 0x18],RAX
MOV EAX,dword ptr [RBX + 0x10]
OR EAX,dword ptr [RBX + 0xc]
TEST AL,0x1
JZ 0x001a7eee
ADD RBP,R13
LEA RSI,[RBX + 0x68]
LEA RDX,[R14 + R14*0x8]
SHL RDX,0x3
ADD RDX,qword ptr [R12 + 0x27810]
LEA RDI,[RSP + 0x50]
CALL 0x0012d170
LEA R13D,[R14 + R14*0x2]
SHL R13,0x3
MOV RSI,qword ptr [R12 + 0x27800]
ADD RSI,R13
LEA RDI,[RSP + 0x50]
CALL 0x0012d1c0
LEA RDX,[RBX + 0x50]
LEA RDI,[RSP + 0x30]
LEA RSI,[RSP + 0x50]
CALL 0x0012d100
VMOVSS XMM0,dword ptr [R15 + 0x2d8]
VMOVSS dword ptr [RSP + 0x8],XMM0
VCVTSS2SD XMM0,XMM0,XMM0
VMOVAPS xmmword ptr [RSP + 0x20],XMM0
MOV RDI,RBP
LEA RSI,[RSP + 0x30]
CALL 0x0012d160
VMOVDDUP XMM0,qword ptr [0x002bcba0]
VXORPD XMM0,XMM0,xmmword ptr [RSP + 0x20]
VMULSD XMM0,XMM0,qword ptr [RBX + 0x80]
MOV RDI,RBP
MOV RSI,RBP
CALL 0x0012d190
ADD R13,qword ptr [R12 + 0x27818]
LEA RDI,[RSP + 0x70]
LEA RSI,[RSP + 0x50]
MOV RDX,R13
CALL 0x0012d100
LEA R13,[RSP + 0xc0]
LEA RSI,[RSP + 0x90]
MOV RDI,R13
LEA RDX,[RSP + 0x70]
CALL 0x0012d420
MOV RDI,R13
LEA RSI,[RSP + 0xa8]
CALL 0x0012d1c0
VMOVSS XMM0,dword ptr [RSP + 0x8]
VXORPD XMM1,XMM1,XMM1
VUCOMISS XMM0,XMM1
JC 0x001a7e2f
VSQRTSS XMM0,XMM0,XMM0
JMP 0x001a7e34
LAB_001a7e2f:
CALL 0x0012e560
LAB_001a7e34:
VBROADCASTSS XMM1,dword ptr [0x002bd65c]
VXORPS XMM0,XMM0,XMM1
VCVTSS2SD XMM0,XMM0,XMM0
VMULSD XMM0,XMM0,qword ptr [RBX + 0x80]
LEA RSI,[RSP + 0xc0]
MOV RDI,RBP
CALL 0x0012d140
LEA RSI,[RSP + 0x70]
MOV RDI,qword ptr [RSP + 0x18]
MOV RDX,RBP
CALL 0x0012d420
VMOVSS XMM0,dword ptr [R15 + 0x2dc]
VMOVSS dword ptr [RSP + 0x8],XMM0
LEA RDI,[RSP + 0x30]
CALL 0x0012d130
VMOVSS XMM0,dword ptr [RSP + 0x8]
VUCOMISS XMM0,dword ptr [0x002bd660]
JC 0x001a7e9e
VSQRTSS XMM0,XMM0,XMM0
JMP 0x001a7ea3
LAB_001a7e9e:
CALL 0x0012e560
LAB_001a7ea3:
VBROADCASTSS XMM1,dword ptr [0x002bd65c]
VXORPS XMM0,XMM0,XMM1
VCVTSS2SD XMM0,XMM0,XMM0
VMULSD XMM0,XMM0,qword ptr [RSP + 0x10]
VMOVSD qword ptr [RSP + 0x8],XMM0
LEA R13,[RSP + 0x30]
LEA RSI,[RSP + 0x90]
MOV RDI,R13
CALL 0x0012d1b0
VMULSD XMM0,XMM0,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,R13
CALL 0x0012d140
MOV EAX,dword ptr [RBX + 0x10]
OR EAX,dword ptr [RBX + 0xc]
LAB_001a7eee:
TEST AL,0x2
JZ 0x001a7fc8
VMOVSS XMM0,dword ptr [R15 + 0x2dc]
VMOVSS dword ptr [RSP + 0x8],XMM0
VCVTSS2SD XMM0,XMM0,XMM0
VMOVSD qword ptr [RSP + 0x20],XMM0
SHL R14D,0x2
SHL R14,0x3
MOV RSI,qword ptr [R12 + 0x27808]
ADD RSI,R14
ADD R14,qword ptr [R15 + 0x5b0]
LEA R15,[RSP + 0x50]
MOV RDI,R15
MOV RDX,R14
CALL 0x0012d620
MOV RDI,R15
MOV RSI,R15
CALL 0x0012d630
ADD RBX,0x30
LEA R14,[RSP + 0x30]
MOV RDI,R14
MOV RSI,RBX
MOV RDX,R15
CALL 0x0012d620
VMOVSD XMM0,qword ptr [RSP + 0x20]
VMULSD XMM0,XMM0,qword ptr [RSP + 0x10]
VMOVSD XMM1,qword ptr [0x002bcbd0]
VDIVSD XMM0,XMM1,XMM0
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,R14
CALL 0x0012d660
VXORPD XMM0,XMM0,XMM0
VMOVSS XMM1,dword ptr [RSP + 0x8]
VUCOMISS XMM1,XMM0
VMOVAPS XMM0,XMM1
JC 0x001a7f9a
VSQRTSS XMM0,XMM0,XMM0
JMP 0x001a7f9f
LAB_001a7f9a:
CALL 0x0012e560
LAB_001a7f9f:
VBROADCASTSS XMM1,dword ptr [0x002bd65c]
VXORPS XMM0,XMM0,XMM1
VCVTSS2SD XMM0,XMM0,XMM0
VMULSD XMM0,XMM0,qword ptr [RSP + 0x10]
LEA RSI,[RSP + 0x90]
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x0012d140
LAB_001a7fc8:
ADD RSP,0xd8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void mjv_applyPerturbForce(long param_1,long param_2,uint *param_3)
{
uint uVar1;
int1 auVar2 [16];
uint uVar3;
long lVar4;
long lVar5;
long lVar6;
ulong uVar7;
float fVar8;
double dVar9;
double dVar10;
int1 local_d8 [32];
int1 local_b8 [32];
int1 local_98 [32];
int1 local_78 [24];
int1 local_60 [24];
int1 local_48 [24];
uVar1 = *param_3;
uVar7 = (ulong)uVar1;
if (((-1 < (int)uVar1) && ((int)uVar1 < *(int *)(param_1 + 0x10))) &&
(param_3[4] != 0 || param_3[3] != 0)) {
lVar5 = *(long *)(param_2 + 0x277b0);
mj_objectVelocity(param_1,param_2,1,uVar1,local_78,0);
dVar9 = *(double *)(*(long *)(param_1 + 0x5d0) + 8 + uVar7 * 0x10);
if ((dVar9 != 0.0) || (dVar10 = DAT_002bcbd0, NAN(dVar9))) {
dVar9 = (double)mju_max(DAT_002bcba8);
dVar10 = DAT_002bcbd0 / dVar9;
}
lVar4 = uVar7 * 0x30 + 0x18 + lVar5;
uVar3 = param_3[4] | param_3[3];
if ((uVar3 & 1) != 0) {
lVar5 = lVar5 + uVar7 * 0x30;
mju_rotVecMat(local_b8,param_3 + 0x1a,uVar7 * 0x48 + *(long *)(param_2 + 0x27810));
lVar6 = (ulong)(uVar1 * 3) * 8;
mju_addTo3(local_b8,*(long *)(param_2 + 0x27800) + lVar6);
mju_sub3(local_d8,local_b8,param_3 + 0x14);
fVar8 = *(float *)(param_1 + 0x2d8);
mju_copy3(lVar5,local_d8);
mju_scl3((double)(DAT_002bcba0 ^ (ulong)(double)fVar8) * *(double *)(param_3 + 0x20),lVar5,
lVar5);
mju_sub3(local_98,local_b8,lVar6 + *(long *)(param_2 + 0x27818));
mju_cross(local_48,local_78,local_98);
mju_addTo3(local_48,local_60);
if (fVar8 < 0.0) {
fVar8 = sqrtf(fVar8);
}
else {
auVar2 = vsqrtss_avx(ZEXT416((uint)fVar8),ZEXT416((uint)fVar8));
fVar8 = auVar2._0_4_;
}
mju_addToScl3((double)(float)((uint)fVar8 ^ DAT_002bd65c) * *(double *)(param_3 + 0x20),lVar5,
local_48);
mju_cross(lVar4,local_98,lVar5);
fVar8 = *(float *)(param_1 + 0x2dc);
mju_normalize3(local_d8);
if (fVar8 < DAT_002bd660) {
fVar8 = sqrtf(fVar8);
}
else {
auVar2 = vsqrtss_avx(ZEXT416((uint)fVar8),ZEXT416((uint)fVar8));
fVar8 = auVar2._0_4_;
}
fVar8 = (float)((uint)fVar8 ^ DAT_002bd65c);
dVar9 = (double)mju_dot3(local_d8,local_78);
mju_addToScl3(dVar9 * (double)fVar8 * dVar10,lVar4,local_d8);
uVar3 = param_3[4] | param_3[3];
}
if ((uVar3 & 2) != 0) {
fVar8 = *(float *)(param_1 + 0x2dc);
lVar5 = (ulong)(uVar1 << 2) * 8;
mju_mulQuat(local_b8,*(long *)(param_2 + 0x27808) + lVar5,lVar5 + *(long *)(param_1 + 0x5b0));
mju_negQuat(local_b8,local_b8);
mju_mulQuat(local_d8,param_3 + 0xc,local_b8);
mju_quat2Vel(DAT_002bcbd0 / ((double)fVar8 * dVar10),lVar4,local_d8);
if (fVar8 < 0.0) {
fVar8 = sqrtf(fVar8);
}
else {
auVar2 = vsqrtss_avx(ZEXT416((uint)fVar8),ZEXT416((uint)fVar8));
fVar8 = auVar2._0_4_;
}
mju_addToScl3((double)(float)((uint)fVar8 ^ DAT_002bd65c) * dVar10,lVar4,local_78);
}
}
return;
}
| |
43,589 | build_repetition(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/json-schema-to-grammar.cpp | static std::string build_repetition(const std::string & item_rule, int min_items, int max_items, const std::string & separator_rule = "") {
auto has_max = max_items != std::numeric_limits<int>::max();
if (min_items == 0 && max_items == 1) {
return item_rule + "?";
}
if (separator_rule.empty()) {
if (min_items == 1 && !has_max) {
return item_rule + "+";
} else if (min_items == 0 && !has_max) {
return item_rule + "*";
} else {
return item_rule + "{" + std::to_string(min_items) + "," + (has_max ? std::to_string(max_items) : "") + "}";
}
}
auto result = item_rule + " " + build_repetition("(" + separator_rule + " " + item_rule + ")", min_items == 0 ? 0 : min_items - 1, has_max ? max_items - 1 : max_items);
if (min_items == 0) {
result = "(" + result + ")?";
}
return result;
} | O2 | cpp | build_repetition(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xf0, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movl %ecx, %eax
xorl $0x1, %eax
orl %edx, %eax
jne 0x8afcc
leaq 0x2c977(%rip), %rdx # 0xb7933
movq %rbx, %rdi
movq %r15, %rsi
callq 0x37f3f
jmp 0x8b275
movq %r8, %r12
movl %ecx, %ebp
movl %edx, %r14d
cmpq $0x0, 0x8(%r8)
je 0x8b151
leaq 0x27627(%rip), %rdx # 0xb260d
leaq 0x30(%rsp), %rdi
movq %r15, %rsi
callq 0x37f3f
leaq 0x2cb50(%rip), %rsi # 0xb7b4a
leaq 0x50(%rsp), %rdi
movq %r12, %rdx
callq 0x3917c
leaq 0x275ff(%rip), %rdx # 0xb260d
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x37f20
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
movq %r15, %rdx
callq 0x3a6f8
leaq 0x2c7ca(%rip), %rdx # 0xb7803
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x37f20
leaq 0x23b71(%rip), %rsi # 0xaebc6
leaq 0xd0(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x27370
xorl %eax, %eax
cmpl $0x7fffffff, %ebp # imm = 0x7FFFFFFF
setne %al
subl %eax, %ebp
xorl %eax, %eax
movl %r14d, %edx
subl $0x1, %edx
cmovbl %eax, %edx
leaq 0x10(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
leaq 0xd0(%rsp), %r8
movl %ebp, %ecx
callq 0x8af97
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x38faf
leaq 0x10(%rsp), %rdi
callq 0x241a8
leaq 0xd0(%rsp), %rdi
callq 0x241a8
leaq 0xb0(%rsp), %rdi
callq 0x241a8
leaq 0x90(%rsp), %rdi
callq 0x241a8
leaq 0x70(%rsp), %rdi
callq 0x241a8
leaq 0x50(%rsp), %rdi
callq 0x241a8
leaq 0x30(%rsp), %rdi
callq 0x241a8
testl %r14d, %r14d
jne 0x8b275
leaq 0x2ca3e(%rip), %rsi # 0xb7b4a
leaq 0x10(%rsp), %rdi
movq %rbx, %rdx
callq 0x3917c
leaq 0x2c9cc(%rip), %rdx # 0xb7aec
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x37f20
leaq 0x30(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x23ab0
movq %r14, %rdi
callq 0x241a8
leaq 0x10(%rsp), %rdi
jmp 0x8b270
movl %ebp, %eax
xorl $0x7fffffff, %eax # imm = 0x7FFFFFFF
movl %r14d, %ecx
xorl $0x1, %ecx
orl %eax, %ecx
je 0x8b1d4
orl %r14d, %eax
je 0x8b1e0
leaq 0x27c0f(%rip), %rdx # 0xb2d7d
leaq 0x90(%rsp), %rdi
movq %r15, %rsi
callq 0x37f3f
leaq 0x70(%rsp), %rdi
movl %r14d, %esi
callq 0x3d833
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0x38faf
leaq 0x280ca(%rip), %rdx # 0xb3276
leaq 0x10(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x37f20
cmpl $0x7fffffff, %ebp # imm = 0x7FFFFFFF
je 0x8b1ec
leaq 0x50(%rsp), %rdi
movl %ebp, %esi
callq 0x3d833
jmp 0x8b205
leaq 0x28982(%rip), %rdx # 0xb3b5d
jmp 0x8afbc
leaq 0x2e6e5(%rip), %rdx # 0xb98cc
jmp 0x8afbc
leaq 0x239d3(%rip), %rsi # 0xaebc6
leaq 0x50(%rsp), %rdi
leaq 0xd0(%rsp), %rdx
callq 0x27370
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x38faf
leaq 0x2c33f(%rip), %rdx # 0xb755f
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x37f20
leaq 0x30(%rsp), %rdi
callq 0x241a8
leaq 0x50(%rsp), %rdi
callq 0x241a8
cmpl $0x7fffffff, %ebp # imm = 0x7FFFFFFF
leaq 0x10(%rsp), %rdi
callq 0x241a8
leaq 0xb0(%rsp), %rdi
callq 0x241a8
leaq 0x70(%rsp), %rdi
callq 0x241a8
leaq 0x90(%rsp), %rdi
callq 0x241a8
movq %rbx, %rax
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8b28a
movq %rax, %r14
jmp 0x8b2b1
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x241a8
jmp 0x8b2a1
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0x241a8
cmpl $0x7fffffff, %ebp # imm = 0x7FFFFFFF
leaq 0x10(%rsp), %rdi
callq 0x241a8
jmp 0x8b2c0
movq %rax, %r14
leaq 0xb0(%rsp), %rdi
callq 0x241a8
jmp 0x8b2d2
movq %rax, %r14
leaq 0x70(%rsp), %rdi
callq 0x241a8
leaq 0x90(%rsp), %rdi
jmp 0x8b363
movq %rax, %r14
jmp 0x8b2dc
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x241a8
jmp 0x8b2fd
movq %rax, %r14
movq %rbx, %rdi
jmp 0x8b363
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x241a8
jmp 0x8b314
movq %rax, %r14
leaq 0xd0(%rsp), %rdi
callq 0x241a8
jmp 0x8b326
movq %rax, %r14
leaq 0xb0(%rsp), %rdi
callq 0x241a8
jmp 0x8b338
movq %rax, %r14
leaq 0x90(%rsp), %rdi
callq 0x241a8
jmp 0x8b34a
movq %rax, %r14
leaq 0x70(%rsp), %rdi
callq 0x241a8
leaq 0x50(%rsp), %rdi
callq 0x241a8
leaq 0x30(%rsp), %rdi
callq 0x241a8
movq %r14, %rdi
callq 0x23f70
movq %rax, %r14
jmp 0x8b354
movq %rax, %r14
jmp 0x8b35e
| _ZL16build_repetitionRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiiS6_:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 0F0h
mov r15, rsi
mov rbx, rdi
mov eax, ecx
xor eax, 1
or eax, edx
jnz short loc_8AFCC
lea rdx, asc_B7930+3; "?"
loc_8AFBC:
mov rdi, rbx
mov rsi, r15
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EERKS8_PKS5_; std::operator+<char>(std::string const&,char const*)
jmp loc_8B275
loc_8AFCC:
mov r12, r8
mov ebp, ecx
mov r14d, edx
cmp qword ptr [r8+8], 0
jz loc_8B151
lea rdx, aForMessageInMe+144h; " "
lea rdi, [rsp+118h+var_E8]
mov rsi, r15
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EERKS8_PKS5_; std::operator+<char>(std::string const&,char const*)
lea rsi, asc_B7B45+5; "("
lea rdi, [rsp+118h+var_C8]
mov rdx, r12
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
lea rdx, aForMessageInMe+144h; " "
lea rdi, [rsp+118h+var_A8]
lea rsi, [rsp+118h+var_C8]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
lea rdi, [rsp+118h+var_88]
lea rsi, [rsp+118h+var_A8]
mov rdx, r15
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_RKS8_; std::operator+<char>(std::string&&,std::string const&)
lea rdx, a09401910201912+51h; ")"
lea rdi, [rsp+118h+var_68]
lea rsi, [rsp+118h+var_88]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
lea rsi, aErrorWhileHand_0+34h; ""
lea rdi, [rsp+118h+var_48]
lea rdx, [rsp+118h+var_109]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
xor eax, eax
cmp ebp, 7FFFFFFFh
setnz al
sub ebp, eax
xor eax, eax
mov edx, r14d
sub edx, 1
cmovb edx, eax
lea rdi, [rsp+118h+var_108]
lea rsi, [rsp+118h+var_68]
lea r8, [rsp+118h+var_48]
mov ecx, ebp
call _ZL16build_repetitionRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiiS6_; build_repetition(std::string const&,int,int,std::string const&)
lea rsi, [rsp+118h+var_E8]
lea rdx, [rsp+118h+var_108]
mov rdi, rbx
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_S9_; std::operator+<char>(std::string&&,std::string&)
lea rdi, [rsp+118h+var_108]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+118h+var_48]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+118h+var_68]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+118h+var_88]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+118h+var_A8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+118h+var_C8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+118h+var_E8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test r14d, r14d
jnz loc_8B275
lea rsi, asc_B7B45+5; "("
lea rdi, [rsp+118h+var_108]
mov rdx, rbx
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
lea rdx, asc_B7AEB+1; ")?"
lea rdi, [rsp+118h+var_E8]
lea rsi, [rsp+118h+var_108]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
lea r14, [rsp+118h+var_E8]
mov rdi, rbx
mov rsi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, r14; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+118h+var_108]
jmp loc_8B270
loc_8B151:
mov eax, ebp
xor eax, 7FFFFFFFh
mov ecx, r14d
xor ecx, 1
or ecx, eax
jz short loc_8B1D4
or eax, r14d
jz short loc_8B1E0
lea rdx, asc_B2D7D; "{"
lea rdi, [rsp+118h+var_88]
mov rsi, r15
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EERKS8_PKS5_; std::operator+<char>(std::string const&,char const*)
lea rdi, [rsp+118h+var_A8]; this
mov esi, r14d; int
call _ZNSt7__cxx119to_stringEi; std::to_string(int)
lea rdi, [rsp+118h+var_68]
lea rsi, [rsp+118h+var_88]
lea rdx, [rsp+118h+var_A8]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_S9_; std::operator+<char>(std::string&&,std::string&)
lea rdx, asc_B3276; ","
lea rdi, [rsp+118h+var_108]
lea rsi, [rsp+118h+var_68]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
cmp ebp, 7FFFFFFFh
jz short loc_8B1EC
lea rdi, [rsp+118h+var_C8]; this
mov esi, ebp; int
call _ZNSt7__cxx119to_stringEi; std::to_string(int)
jmp short loc_8B205
loc_8B1D4:
lea rdx, aSRN_0+0Bh; "+"
jmp loc_8AFBC
loc_8B1E0:
lea rdx, asc_B98CB+1; "*"
jmp loc_8AFBC
loc_8B1EC:
lea rsi, aErrorWhileHand_0+34h; ""
lea rdi, [rsp+118h+var_C8]
lea rdx, [rsp+118h+var_48]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
loc_8B205:
lea rdi, [rsp+118h+var_E8]
lea rsi, [rsp+118h+var_108]
lea rdx, [rsp+118h+var_C8]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_S9_; std::operator+<char>(std::string&&,std::string&)
lea rdx, aNT020+17h; "}"
lea rsi, [rsp+118h+var_E8]
mov rdi, rbx
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
lea rdi, [rsp+118h+var_E8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+118h+var_C8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
cmp ebp, 7FFFFFFFh
lea rdi, [rsp+118h+var_108]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+118h+var_68]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+118h+var_A8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+118h+var_88]; void *
loc_8B270:
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_8B275:
mov rax, rbx
add rsp, 0F0h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
jmp short $+2
loc_8B28A:
mov r14, rax
jmp short loc_8B2B1
mov r14, rax
lea rdi, [rsp+arg_28]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_8B2A1
mov r14, rax
loc_8B2A1:
lea rdi, [rsp+arg_48]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
cmp ebp, 7FFFFFFFh
loc_8B2B1:
lea rdi, [rsp+arg_8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_8B2C0
mov r14, rax
loc_8B2C0:
lea rdi, [rsp+arg_A8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_8B2D2
mov r14, rax
loc_8B2D2:
lea rdi, [rsp+arg_68]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_8B2DC:
lea rdi, [rsp+arg_88]
jmp short loc_8B363
mov r14, rax
jmp short loc_8B2DC
mov r14, rax
lea rdi, [rsp+arg_8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_8B2FD
mov r14, rax
loc_8B2FD:
mov rdi, rbx
jmp short loc_8B363
mov r14, rax
lea rdi, [rsp+arg_8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_8B314
mov r14, rax
loc_8B314:
lea rdi, [rsp+arg_C8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_8B326
mov r14, rax
loc_8B326:
lea rdi, [rsp+arg_A8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_8B338
mov r14, rax
loc_8B338:
lea rdi, [rsp+arg_88]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_8B34A
mov r14, rax
loc_8B34A:
lea rdi, [rsp+arg_68]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_8B354:
lea rdi, [rsp+arg_48]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_8B35E:
lea rdi, [rsp+arg_28]; void *
loc_8B363:
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r14
call __Unwind_Resume
mov r14, rax
jmp short loc_8B354
mov r14, rax
jmp short loc_8B35E
| long long build_repetition(long long a1, long long a2, int a3, int a4, long long a5)
{
char *v6; // rdx
int v10; // r9d
int v11; // ebp
int v12; // edx
_QWORD *v13; // rdi
_QWORD v15[4]; // [rsp+10h] [rbp-108h] BYREF
_QWORD v16[4]; // [rsp+30h] [rbp-E8h] BYREF
_QWORD v17[4]; // [rsp+50h] [rbp-C8h] BYREF
_QWORD v18[4]; // [rsp+70h] [rbp-A8h] BYREF
_QWORD v19[4]; // [rsp+90h] [rbp-88h] BYREF
_BYTE v20[32]; // [rsp+B0h] [rbp-68h] BYREF
_QWORD v21[9]; // [rsp+D0h] [rbp-48h] BYREF
if ( !(a3 | a4 ^ 1) )
{
v6 = "?";
LABEL_3:
std::operator+<char>(a1, a2, (long long)v6);
return a1;
}
if ( !*(_QWORD *)(a5 + 8) )
{
if ( !(a4 ^ 0x7FFFFFFF | a3 ^ 1) )
{
v6 = "+";
goto LABEL_3;
}
if ( !(a3 | a4 ^ 0x7FFFFFFF) )
{
v6 = "*";
goto LABEL_3;
}
std::operator+<char>((long long)v19, a2, (long long)"{");
std::to_string((std::__cxx11 *)v18, a3);
std::operator+<char>((long long)v20, v19, v18);
std::operator+<char>((long long)v15, (long long)v20, (long long)",");
if ( a4 == 0x7FFFFFFF )
std::string::basic_string<std::allocator<char>>(v17, (long long)"");
else
std::to_string((std::__cxx11 *)v17, a4);
std::operator+<char>((long long)v16, v15, v17);
std::operator+<char>(a1, (long long)v16, (long long)"}");
std::string::~string(v16);
std::string::~string(v17);
std::string::~string(v15);
std::string::~string(v20);
std::string::~string(v18);
v13 = v19;
LABEL_17:
std::string::~string(v13);
return a1;
}
std::operator+<char>((long long)v16, a2, (long long)" ");
std::operator+<char>((long long)v17, (long long)"(", a5);
std::operator+<char>((long long)v18, (long long)v17, (long long)" ");
std::operator+<char>((long long)v19, (long long)v18, a2);
std::operator+<char>((long long)v20, (long long)v19, (long long)")");
std::string::basic_string<std::allocator<char>>(v21, (long long)"");
v11 = a4 - (a4 != 0x7FFFFFFF);
v12 = a3 - 1;
if ( !a3 )
v12 = 0;
build_repetition((unsigned int)v15, (unsigned int)v20, v12, v11, (unsigned int)v21, v10);
std::operator+<char>(a1, v16, v15);
std::string::~string(v15);
std::string::~string(v21);
std::string::~string(v20);
std::string::~string(v19);
std::string::~string(v18);
std::string::~string(v17);
std::string::~string(v16);
if ( !a3 )
{
std::operator+<char>((long long)v15, (long long)"(", a1);
std::operator+<char>((long long)v16, (long long)v15, (long long)")?");
std::string::operator=(a1, v16);
std::string::~string(v16);
v13 = v15;
goto LABEL_17;
}
return a1;
}
| build_repetition:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0xf0
MOV R15,RSI
MOV RBX,RDI
MOV EAX,ECX
XOR EAX,0x1
OR EAX,EDX
JNZ 0x0018afcc
LEA RDX,[0x1b7933]
LAB_0018afbc:
MOV RDI,RBX
MOV RSI,R15
CALL 0x00137f3f
JMP 0x0018b275
LAB_0018afcc:
MOV R12,R8
MOV EBP,ECX
MOV R14D,EDX
CMP qword ptr [R8 + 0x8],0x0
JZ 0x0018b151
LEA RDX,[0x1b260d]
LEA RDI,[RSP + 0x30]
MOV RSI,R15
CALL 0x00137f3f
LAB_0018aff3:
LEA RSI,[0x1b7b4a]
LEA RDI,[RSP + 0x50]
MOV RDX,R12
CALL 0x0013917c
LAB_0018b007:
LEA RDX,[0x1b260d]
LEA RDI,[RSP + 0x70]
LEA RSI,[RSP + 0x50]
CALL 0x00137f20
LAB_0018b01d:
LEA RDI,[RSP + 0x90]
LEA RSI,[RSP + 0x70]
MOV RDX,R15
CALL 0x0013a6f8
LAB_0018b032:
LEA RDX,[0x1b7803]
LEA RDI,[RSP + 0xb0]
LEA RSI,[RSP + 0x90]
CALL 0x00137f20
LAB_0018b04e:
LEA RSI,[0x1aebc6]
LEA RDI,[RSP + 0xd0]
LEA RDX,[RSP + 0xf]
CALL 0x00127370
XOR EAX,EAX
CMP EBP,0x7fffffff
SETNZ AL
SUB EBP,EAX
XOR EAX,EAX
MOV EDX,R14D
SUB EDX,0x1
CMOVC EDX,EAX
LAB_0018b07f:
LEA RDI,[RSP + 0x10]
LEA RSI,[RSP + 0xb0]
LEA R8,[RSP + 0xd0]
MOV ECX,EBP
CALL 0x0018af97
LAB_0018b09b:
LEA RSI,[RSP + 0x30]
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
CALL 0x00138faf
LEA RDI,[RSP + 0x10]
CALL 0x001241a8
LEA RDI,[RSP + 0xd0]
CALL 0x001241a8
LEA RDI,[RSP + 0xb0]
CALL 0x001241a8
LEA RDI,[RSP + 0x90]
CALL 0x001241a8
LEA RDI,[RSP + 0x70]
CALL 0x001241a8
LEA RDI,[RSP + 0x50]
CALL 0x001241a8
LEA RDI,[RSP + 0x30]
CALL 0x001241a8
TEST R14D,R14D
JNZ 0x0018b275
LAB_0018b105:
LEA RSI,[0x1b7b4a]
LEA RDI,[RSP + 0x10]
MOV RDX,RBX
CALL 0x0013917c
LAB_0018b119:
LEA RDX,[0x1b7aec]
LEA RDI,[RSP + 0x30]
LEA RSI,[RSP + 0x10]
CALL 0x00137f20
LAB_0018b12f:
LEA R14,[RSP + 0x30]
MOV RDI,RBX
MOV RSI,R14
CALL 0x00123ab0
MOV RDI,R14
CALL 0x001241a8
LEA RDI,[RSP + 0x10]
JMP 0x0018b270
LAB_0018b151:
MOV EAX,EBP
XOR EAX,0x7fffffff
MOV ECX,R14D
XOR ECX,0x1
OR ECX,EAX
JZ 0x0018b1d4
OR EAX,R14D
JZ 0x0018b1e0
LEA RDX,[0x1b2d7d]
LEA RDI,[RSP + 0x90]
MOV RSI,R15
CALL 0x00137f3f
LAB_0018b17e:
LEA RDI,[RSP + 0x70]
MOV ESI,R14D
CALL 0x0013d833
LAB_0018b18b:
LEA RDI,[RSP + 0xb0]
LEA RSI,[RSP + 0x90]
LEA RDX,[RSP + 0x70]
CALL 0x00138faf
LAB_0018b1a5:
LEA RDX,[0x1b3276]
LEA RDI,[RSP + 0x10]
LEA RSI,[RSP + 0xb0]
CALL 0x00137f20
CMP EBP,0x7fffffff
JZ 0x0018b1ec
LAB_0018b1c6:
LEA RDI,[RSP + 0x50]
MOV ESI,EBP
CALL 0x0013d833
JMP 0x0018b205
LAB_0018b1d4:
LEA RDX,[0x1b3b5d]
JMP 0x0018afbc
LAB_0018b1e0:
LEA RDX,[0x1b98cc]
JMP 0x0018afbc
LAB_0018b1ec:
LEA RSI,[0x1aebc6]
LEA RDI,[RSP + 0x50]
LEA RDX,[RSP + 0xd0]
CALL 0x00127370
LAB_0018b205:
LEA RDI,[RSP + 0x30]
LEA RSI,[RSP + 0x10]
LEA RDX,[RSP + 0x50]
CALL 0x00138faf
LAB_0018b219:
LEA RDX,[0x1b755f]
LEA RSI,[RSP + 0x30]
MOV RDI,RBX
CALL 0x00137f20
LAB_0018b22d:
LEA RDI,[RSP + 0x30]
CALL 0x001241a8
LEA RDI,[RSP + 0x50]
CALL 0x001241a8
CMP EBP,0x7fffffff
LEA RDI,[RSP + 0x10]
CALL 0x001241a8
LEA RDI,[RSP + 0xb0]
CALL 0x001241a8
LEA RDI,[RSP + 0x70]
CALL 0x001241a8
LEA RDI,[RSP + 0x90]
LAB_0018b270:
CALL 0x001241a8
LAB_0018b275:
MOV RAX,RBX
ADD RSP,0xf0
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
/* build_repetition(std::__cxx11::string const&, int, int, std::__cxx11::string const&) */
string * build_repetition(string *param_1,int param_2,int param_3,string *param_4)
{
uint uVar1;
int iVar2;
int4 in_register_00000034;
char *pcVar3;
string *this;
long in_R8;
allocator local_109;
string local_108 [32];
string local_e8 [32];
string local_c8 [32];
string local_a8 [32];
string local_88 [32];
string local_68 [32];
string local_48 [32];
pcVar3 = (char *)CONCAT44(in_register_00000034,param_2);
uVar1 = (uint)param_4;
if (uVar1 == 1 && param_3 == 0) {
LAB_0018afbc:
std::operator+(param_1,pcVar3);
}
else {
if (*(long *)(in_R8 + 8) == 0) {
if ((param_3 == 1 && (uVar1 ^ 0x7fffffff) == 0) || ((uVar1 ^ 0x7fffffff) == 0 && param_3 == 0)
) goto LAB_0018afbc;
std::operator+(local_88,pcVar3);
/* try { // try from 0018b17e to 0018b18a has its CatchHandler @ 0018b2e6 */
std::__cxx11::to_string((__cxx11 *)local_a8,param_3);
/* try { // try from 0018b18b to 0018b1a4 has its CatchHandler @ 0018b2cf */
std::operator+(local_68,local_88);
/* try { // try from 0018b1a5 to 0018b1bd has its CatchHandler @ 0018b2bd */
std::operator+(local_108,(char *)local_68);
if (uVar1 == 0x7fffffff) {
/* try { // try from 0018b1ec to 0018b204 has its CatchHandler @ 0018b288 */
std::__cxx11::string::string<std::allocator<char>>(local_c8,"",(allocator *)local_48);
}
else {
/* try { // try from 0018b1c6 to 0018b1d1 has its CatchHandler @ 0018b28a */
std::__cxx11::to_string((__cxx11 *)local_c8,uVar1);
}
/* try { // try from 0018b205 to 0018b218 has its CatchHandler @ 0018b29e */
std::operator+(local_e8,local_108);
/* try { // try from 0018b219 to 0018b22c has its CatchHandler @ 0018b28f */
std::operator+(param_1,(char *)local_e8);
std::__cxx11::string::~string(local_e8);
std::__cxx11::string::~string(local_c8);
std::__cxx11::string::~string(local_108);
std::__cxx11::string::~string(local_68);
std::__cxx11::string::~string(local_a8);
this = local_88;
}
else {
std::operator+(local_e8,pcVar3);
/* try { // try from 0018aff3 to 0018b006 has its CatchHandler @ 0018b375 */
std::operator+((char *)local_c8,(string *)&DAT_001b7b4a);
/* try { // try from 0018b007 to 0018b01c has its CatchHandler @ 0018b370 */
std::operator+(local_a8,(char *)local_c8);
/* try { // try from 0018b01d to 0018b031 has its CatchHandler @ 0018b347 */
std::operator+(local_88,local_a8);
/* try { // try from 0018b032 to 0018b04d has its CatchHandler @ 0018b335 */
std::operator+(local_68,(char *)local_88);
/* try { // try from 0018b04e to 0018b066 has its CatchHandler @ 0018b323 */
std::__cxx11::string::string<std::allocator<char>>(local_48,"",&local_109);
iVar2 = param_3 + -1;
if (param_3 == 0) {
iVar2 = 0;
}
/* try { // try from 0018b07f to 0018b09a has its CatchHandler @ 0018b311 */
build_repetition(local_108,(int)local_68,iVar2,
(string *)(ulong)(uVar1 - (uVar1 != 0x7fffffff)));
/* try { // try from 0018b09b to 0018b0ac has its CatchHandler @ 0018b302 */
std::operator+(param_1,local_e8);
std::__cxx11::string::~string(local_108);
std::__cxx11::string::~string(local_48);
std::__cxx11::string::~string(local_68);
std::__cxx11::string::~string(local_88);
std::__cxx11::string::~string(local_a8);
std::__cxx11::string::~string(local_c8);
std::__cxx11::string::~string(local_e8);
if (param_3 != 0) {
return param_1;
}
/* try { // try from 0018b105 to 0018b118 has its CatchHandler @ 0018b2fa */
std::operator+((char *)local_108,(string *)&DAT_001b7b4a);
/* try { // try from 0018b119 to 0018b12e has its CatchHandler @ 0018b2eb */
std::operator+(local_e8,(char *)local_108);
std::__cxx11::string::operator=(param_1,local_e8);
std::__cxx11::string::~string(local_e8);
this = local_108;
}
std::__cxx11::string::~string(this);
}
return param_1;
}
| |
43,590 | ma_dynstr_append_mem | eloqsql/libmariadb/libmariadb/ma_string.c | my_bool ma_dynstr_append_mem(DYNAMIC_STRING *str, const char *append,
size_t length)
{
char *new_ptr;
if (str->length+length >= str->max_length)
{
size_t new_length=(str->length+length+str->alloc_increment)/
str->alloc_increment;
new_length*=str->alloc_increment;
if (!(new_ptr=(char*) realloc(str->str,new_length)))
return TRUE;
str->str=new_ptr;
str->max_length=new_length;
}
memcpy(str->str + str->length,append,length);
str->length+=length;
str->str[str->length]=0; /* Safety for C programs */
return FALSE;
} | O0 | c | ma_dynstr_append_mem:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
addq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x56f84
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
addq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
addq 0x18(%rcx), %rax
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divq 0x18(%rcx)
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
imulq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x360c0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x56f6d
movb $0x1, -0x1(%rbp)
jmp 0x56fc7
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
addq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x360b0
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
| ma_dynstr_append_mem:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_10]
mov rax, [rax+8]
add rax, [rbp+var_20]
mov rcx, [rbp+var_10]
cmp rax, [rcx+10h]
jb short loc_56F84
mov rax, [rbp+var_10]
mov rax, [rax+8]
add rax, [rbp+var_20]
mov rcx, [rbp+var_10]
add rax, [rcx+18h]
mov rcx, [rbp+var_10]
xor edx, edx
div qword ptr [rcx+18h]
mov [rbp+var_30], rax
mov rax, [rbp+var_10]
mov rax, [rax+18h]
imul rax, [rbp+var_30]
mov [rbp+var_30], rax
mov rax, [rbp+var_10]
mov rdi, [rax]
mov rsi, [rbp+var_30]
call _realloc
mov [rbp+var_28], rax
cmp rax, 0
jnz short loc_56F6D
mov [rbp+var_1], 1
jmp short loc_56FC7
loc_56F6D:
mov rcx, [rbp+var_28]
mov rax, [rbp+var_10]
mov [rax], rcx
mov rcx, [rbp+var_30]
mov rax, [rbp+var_10]
mov [rax+10h], rcx
loc_56F84:
mov rax, [rbp+var_10]
mov rdi, [rax]
mov rax, [rbp+var_10]
add rdi, [rax+8]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
call _memcpy
mov rcx, [rbp+var_20]
mov rax, [rbp+var_10]
add rcx, [rax+8]
mov [rax+8], rcx
mov rax, [rbp+var_10]
mov rax, [rax]
mov rcx, [rbp+var_10]
mov rcx, [rcx+8]
mov byte ptr [rax+rcx], 0
mov [rbp+var_1], 0
loc_56FC7:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
| char ma_dynstr_append_mem(long long *a1, long long a2, long long a3)
{
unsigned long long v4; // [rsp+0h] [rbp-30h]
long long v5; // [rsp+8h] [rbp-28h]
if ( a3 + a1[1] < (unsigned long long)a1[2] )
goto LABEL_5;
v4 = (a1[3] + a3 + a1[1]) / (unsigned long long)a1[3] * a1[3];
v5 = realloc(*a1, v4);
if ( v5 )
{
*a1 = v5;
a1[2] = v4;
LABEL_5:
memcpy(a1[1] + *a1, a2, a3);
a1[1] += a3;
*(_BYTE *)(*a1 + a1[1]) = 0;
return 0;
}
return 1;
}
| ma_dynstr_append_mem:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
ADD RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x10]
JC 0x00156f84
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
ADD RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RCX + 0x18]
MOV RCX,qword ptr [RBP + -0x10]
XOR EDX,EDX
DIV qword ptr [RCX + 0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x18]
IMUL RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x30]
CALL 0x001360c0
MOV qword ptr [RBP + -0x28],RAX
CMP RAX,0x0
JNZ 0x00156f6d
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00156fc7
LAB_00156f6d:
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x10],RCX
LAB_00156f84:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
ADD RDI,qword ptr [RAX + 0x8]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x001360b0
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
ADD RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x8]
MOV byte ptr [RAX + RCX*0x1],0x0
MOV byte ptr [RBP + -0x1],0x0
LAB_00156fc7:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int1 ma_dynstr_append_mem(long *param_1,void *param_2,size_t param_3)
{
size_t __size;
void *pvVar1;
if ((ulong)param_1[2] <= param_1[1] + param_3) {
__size = param_1[3] * ((param_1[1] + param_3 + param_1[3]) / (ulong)param_1[3]);
pvVar1 = realloc((void *)*param_1,__size);
if (pvVar1 == (void *)0x0) {
return 1;
}
*param_1 = (long)pvVar1;
param_1[2] = __size;
}
memcpy((void *)(*param_1 + param_1[1]),param_2,param_3);
param_1[1] = param_3 + param_1[1];
*(int1 *)(*param_1 + param_1[1]) = 0;
return 0;
}
| |
43,591 | maria_extra_keyflag | eloqsql/storage/maria/ma_extra.c | static void maria_extra_keyflag(MARIA_HA *info,
enum ha_extra_function function)
{
uint idx;
for (idx= 0; idx< info->s->base.keys; idx++)
{
switch (function) {
case HA_EXTRA_CHANGE_KEY_TO_UNIQUE:
info->s->keyinfo[idx].flag|= HA_NOSAME;
break;
case HA_EXTRA_CHANGE_KEY_TO_DUP:
info->s->keyinfo[idx].flag&= ~(HA_NOSAME);
break;
default:
break;
}
}
} | O0 | c | maria_extra_keyflag:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0x3e8(%rcx), %eax
jae 0x6f8fd
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
subl $0x1e, %eax
je 0x6f88f
jmp 0x6f885
movl -0x14(%rbp), %eax
subl $0x1f, %eax
je 0x6f8bd
jmp 0x6f8eb
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x570(%rax), %rax
movl -0x10(%rbp), %ecx
imulq $0x118, %rcx, %rcx # imm = 0x118
addq %rcx, %rax
movzwl 0xa2(%rax), %ecx
orl $0x1, %ecx
movw %cx, 0xa2(%rax)
jmp 0x6f8ed
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x570(%rax), %rax
movl -0x10(%rbp), %ecx
imulq $0x118, %rcx, %rcx # imm = 0x118
addq %rcx, %rax
movzwl 0xa2(%rax), %ecx
andl $-0x2, %ecx
movw %cx, 0xa2(%rax)
jmp 0x6f8ed
jmp 0x6f8ed
jmp 0x6f8ef
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x6f862
popq %rbp
retq
nop
| maria_extra_keyflag:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_10], 0
loc_6F862:
mov eax, [rbp+var_10]
mov rcx, [rbp+var_8]
mov rcx, [rcx]
cmp eax, [rcx+3E8h]
jnb loc_6F8FD
mov eax, [rbp+var_C]
mov [rbp+var_14], eax
sub eax, 1Eh
jz short loc_6F88F
jmp short $+2
loc_6F885:
mov eax, [rbp+var_14]
sub eax, 1Fh
jz short loc_6F8BD
jmp short loc_6F8EB
loc_6F88F:
mov rax, [rbp+var_8]
mov rax, [rax]
mov rax, [rax+570h]
mov ecx, [rbp+var_10]
imul rcx, 118h
add rax, rcx
movzx ecx, word ptr [rax+0A2h]
or ecx, 1
mov [rax+0A2h], cx
jmp short loc_6F8ED
loc_6F8BD:
mov rax, [rbp+var_8]
mov rax, [rax]
mov rax, [rax+570h]
mov ecx, [rbp+var_10]
imul rcx, 118h
add rax, rcx
movzx ecx, word ptr [rax+0A2h]
and ecx, 0FFFFFFFEh
mov [rax+0A2h], cx
jmp short loc_6F8ED
loc_6F8EB:
jmp short $+2
loc_6F8ED:
jmp short $+2
loc_6F8EF:
mov eax, [rbp+var_10]
add eax, 1
mov [rbp+var_10], eax
jmp loc_6F862
loc_6F8FD:
pop rbp
retn
| long long maria_extra_keyflag(long long a1, int a2)
{
long long result; // rax
long long v3; // rax
long long v4; // rax
unsigned int i; // [rsp+4h] [rbp-10h]
for ( i = 0; ; ++i )
{
result = i;
if ( i >= *(_DWORD *)(*(_QWORD *)a1 + 1000LL) )
break;
if ( a2 == 30 )
{
v3 = 280LL * i + *(_QWORD *)(*(_QWORD *)a1 + 1392LL);
*(_WORD *)(v3 + 162) |= 1u;
}
else if ( a2 == 31 )
{
v4 = 280LL * i + *(_QWORD *)(*(_QWORD *)a1 + 1392LL);
*(_WORD *)(v4 + 162) &= ~1u;
}
}
return result;
}
| maria_extra_keyflag:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV dword ptr [RBP + -0x10],0x0
LAB_0016f862:
MOV EAX,dword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RCX]
CMP EAX,dword ptr [RCX + 0x3e8]
JNC 0x0016f8fd
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x14],EAX
SUB EAX,0x1e
JZ 0x0016f88f
JMP 0x0016f885
LAB_0016f885:
MOV EAX,dword ptr [RBP + -0x14]
SUB EAX,0x1f
JZ 0x0016f8bd
JMP 0x0016f8eb
LAB_0016f88f:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x570]
MOV ECX,dword ptr [RBP + -0x10]
IMUL RCX,RCX,0x118
ADD RAX,RCX
MOVZX ECX,word ptr [RAX + 0xa2]
OR ECX,0x1
MOV word ptr [RAX + 0xa2],CX
JMP 0x0016f8ed
LAB_0016f8bd:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x570]
MOV ECX,dword ptr [RBP + -0x10]
IMUL RCX,RCX,0x118
ADD RAX,RCX
MOVZX ECX,word ptr [RAX + 0xa2]
AND ECX,0xfffffffe
MOV word ptr [RAX + 0xa2],CX
JMP 0x0016f8ed
LAB_0016f8eb:
JMP 0x0016f8ed
LAB_0016f8ed:
JMP 0x0016f8ef
LAB_0016f8ef:
MOV EAX,dword ptr [RBP + -0x10]
ADD EAX,0x1
MOV dword ptr [RBP + -0x10],EAX
JMP 0x0016f862
LAB_0016f8fd:
POP RBP
RET
|
void maria_extra_keyflag(long *param_1,int param_2)
{
long lVar1;
int4 local_18;
for (local_18 = 0; local_18 < *(uint *)(*param_1 + 1000); local_18 = local_18 + 1) {
if (param_2 == 0x1e) {
lVar1 = *(long *)(*param_1 + 0x570) + (ulong)local_18 * 0x118;
*(ushort *)(lVar1 + 0xa2) = *(ushort *)(lVar1 + 0xa2) | 1;
}
else if (param_2 == 0x1f) {
lVar1 = *(long *)(*param_1 + 0x570) + (ulong)local_18 * 0x118;
*(ushort *)(lVar1 + 0xa2) = *(ushort *)(lVar1 + 0xa2) & 0xfffe;
}
}
return;
}
| |
43,592 | count_square | eloqsql/storage/myisam/rt_split.c | static double count_square(const double *a, int n_dim)
{
const double *end = a + n_dim * 2;
double square = 1.0;
do
{
square *= a[1] - a[0];
a += 2;
}while (a != end);
return square;
} | O0 | c | count_square:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
shll %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movsd 0x8310e(%rip), %xmm0 # 0x158c58
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
subsd (%rax), %xmm0
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0xd5b4f
movsd -0x20(%rbp), %xmm0
popq %rbp
retq
nopw (%rax,%rax)
| count_square_0:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov rax, [rbp+var_8]
mov ecx, [rbp+var_C]
shl ecx, 1
movsxd rcx, ecx
shl rcx, 3
add rax, rcx
mov [rbp+var_18], rax
movsd xmm0, cs:qword_158C58
movsd [rbp+var_20], xmm0
loc_D5B4F:
mov rax, [rbp+var_8]
movsd xmm0, qword ptr [rax+8]
mov rax, [rbp+var_8]
subsd xmm0, qword ptr [rax]
mulsd xmm0, [rbp+var_20]
movsd [rbp+var_20], xmm0
mov rax, [rbp+var_8]
add rax, 10h
mov [rbp+var_8], rax
mov rax, [rbp+var_8]
cmp rax, [rbp+var_18]
jnz short loc_D5B4F
movsd xmm0, [rbp+var_20]
pop rbp
retn
| double count_square_0(double *a1, int a2)
{
double v3; // [rsp+0h] [rbp-20h]
double *v4; // [rsp+18h] [rbp-8h]
v4 = a1;
v3 = 1.0;
do
{
v3 = (v4[1] - *v4) * v3;
v4 += 2;
}
while ( v4 != &a1[2 * a2] );
return v3;
}
| count_square:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RBP + -0xc]
SHL ECX,0x1
MOVSXD RCX,ECX
SHL RCX,0x3
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
MOVSD XMM0,qword ptr [0x00258c58]
MOVSD qword ptr [RBP + -0x20],XMM0
LAB_001d5b4f:
MOV RAX,qword ptr [RBP + -0x8]
MOVSD XMM0,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x8]
SUBSD XMM0,qword ptr [RAX]
MULSD XMM0,qword ptr [RBP + -0x20]
MOVSD qword ptr [RBP + -0x20],XMM0
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x10
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RBP + -0x18]
JNZ 0x001d5b4f
MOVSD XMM0,qword ptr [RBP + -0x20]
POP RBP
RET
|
double count_square(double *param_1,int param_2)
{
double local_28;
double *local_10;
local_28 = DAT_00258c58;
local_10 = param_1;
do {
local_28 = (local_10[1] - *local_10) * local_28;
local_10 = local_10 + 2;
} while (local_10 != param_1 + (param_2 << 1));
return local_28;
}
| |
43,593 | ggml_backend_cpu_buffer_type_alloc_buffer(ggml_backend_buffer_type*, unsigned long) | monkey531[P]llama/ggml/src/ggml-backend.cpp | static ggml_backend_buffer_t ggml_backend_cpu_buffer_type_alloc_buffer(ggml_backend_buffer_type_t buft, size_t size) {
void * data = ggml_aligned_malloc(size);
if (data == NULL) {
GGML_LOG_ERROR("%s: failed to allocate buffer of size %zu\n", __func__, size);
return NULL;
}
return ggml_backend_buffer_init(buft, ggml_backend_cpu_buffer_i, data, size);
} | O1 | cpp | ggml_backend_cpu_buffer_type_alloc_buffer(ggml_backend_buffer_type*, unsigned long):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq %rsi, %rdi
callq 0x16860
testq %rax, %rax
je 0x28610
movq %rax, %r12
movl $0x68, %edi
callq 0x17030
movq %rax, %r14
leaq 0x41680(%rip), %rsi # 0x69c70
movl $0x9, %ecx
movq %rax, %rdi
rep movsq (%rsi), %es:(%rdi)
movq %r15, 0x48(%rax)
movq %r12, 0x50(%rax)
movq %rbx, 0x58(%rax)
movl $0x0, 0x60(%rax)
jmp 0x28630
leaq 0x255a9(%rip), %rsi # 0x4dbc0
leaq 0x255cd(%rip), %rdx # 0x4dbeb
xorl %r14d, %r14d
movl $0x4, %edi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x167f0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| _ZL41ggml_backend_cpu_buffer_type_alloc_bufferP24ggml_backend_buffer_typem:
push r15
push r14
push r12
push rbx
push rax
mov rbx, rsi
mov r15, rdi
mov rdi, rsi
call _ggml_aligned_malloc
test rax, rax
jz short loc_28610
mov r12, rax
mov edi, 68h ; 'h'; unsigned __int64
call __Znwm; operator new(ulong)
mov r14, rax
lea rsi, _ZL25ggml_backend_cpu_buffer_i; ggml_backend_cpu_buffer_i
mov ecx, 9
mov rdi, rax
rep movsq
mov [rax+48h], r15
mov [rax+50h], r12
mov [rax+58h], rbx
mov dword ptr [rax+60h], 0
jmp short loc_28630
loc_28610:
lea rsi, aSFailedToAlloc_4; "%s: failed to allocate buffer of size %"...
lea rdx, aGgmlBackendCpu_1; "ggml_backend_cpu_buffer_type_alloc_buff"...
xor r14d, r14d
mov edi, 4
mov rcx, rbx
xor eax, eax
call _ggml_log_internal
loc_28630:
mov rax, r14
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| long long ggml_backend_cpu_buffer_type_alloc_buffer(
long long a1,
unsigned long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
long long v14; // rax
long long v15; // r8
long long v16; // r9
__m128 v17; // xmm4
__m128 v18; // xmm5
long long v19; // r12
long long v20; // r14
v14 = ggml_aligned_malloc(a2, a7, a8, a9, a10, a11, a12, a13, a14, a2, a3, a4, a5, a6);
if ( v14 )
{
v19 = v14;
v20 = operator new(0x68uLL);
qmemcpy((void *)v20, ggml_backend_cpu_buffer_i, 0x48uLL);
*(_QWORD *)(v20 + 72) = a1;
*(_QWORD *)(v20 + 80) = v19;
*(_QWORD *)(v20 + 88) = a2;
*(_DWORD *)(v20 + 96) = 0;
}
else
{
v20 = 0LL;
ggml_log_internal(
4u,
(long long)"%s: failed to allocate buffer of size %zu\n",
(long long)"ggml_backend_cpu_buffer_type_alloc_buffer",
a2,
v15,
v16,
a7,
a8,
a9,
a10,
v17,
v18,
a13,
a14);
}
return v20;
}
| ggml_backend_cpu_buffer_type_alloc_buffer:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R15,RDI
MOV RDI,RSI
CALL 0x00116860
TEST RAX,RAX
JZ 0x00128610
MOV R12,RAX
MOV EDI,0x68
CALL 0x00117030
MOV R14,RAX
LEA RSI,[0x169c70]
MOV ECX,0x9
MOV RDI,RAX
MOVSQ.REP RDI,RSI
MOV qword ptr [RAX + 0x48],R15
MOV qword ptr [RAX + 0x50],R12
MOV qword ptr [RAX + 0x58],RBX
MOV dword ptr [RAX + 0x60],0x0
JMP 0x00128630
LAB_00128610:
LEA RSI,[0x14dbc0]
LEA RDX,[0x14dbeb]
XOR R14D,R14D
MOV EDI,0x4
MOV RCX,RBX
XOR EAX,EAX
CALL 0x001167f0
LAB_00128630:
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* ggml_backend_cpu_buffer_type_alloc_buffer(ggml_backend_buffer_type*, unsigned long) */
int8 *
ggml_backend_cpu_buffer_type_alloc_buffer(ggml_backend_buffer_type *param_1,ulong param_2)
{
long lVar1;
int8 *puVar2;
long lVar3;
int **ppuVar4;
int8 *puVar5;
byte bVar6;
bVar6 = 0;
lVar1 = ggml_aligned_malloc(param_2);
if (lVar1 == 0) {
puVar2 = (int8 *)0x0;
ggml_log_internal(4,"%s: failed to allocate buffer of size %zu\n",
"ggml_backend_cpu_buffer_type_alloc_buffer",param_2);
}
else {
puVar2 = (int8 *)operator_new(0x68);
ppuVar4 = &ggml_backend_cpu_buffer_i;
puVar5 = puVar2;
for (lVar3 = 9; lVar3 != 0; lVar3 = lVar3 + -1) {
*puVar5 = *ppuVar4;
ppuVar4 = ppuVar4 + (ulong)bVar6 * -2 + 1;
puVar5 = puVar5 + (ulong)bVar6 * -2 + 1;
}
puVar2[9] = param_1;
puVar2[10] = lVar1;
puVar2[0xb] = param_2;
*(int4 *)(puVar2 + 0xc) = 0;
}
return puVar2;
}
| |
43,594 | my_mutex_end | eloqsql/mysys/thr_mutex.c | void my_mutex_end()
{
#ifdef PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
pthread_mutexattr_destroy(&my_fast_mutexattr);
#endif
#ifdef PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP
pthread_mutexattr_destroy(&my_errorcheck_mutexattr);
#endif
} | O3 | c | my_mutex_end:
pushq %rbp
movq %rsp, %rbp
leaq 0x379f69(%rip), %rdi # 0x428340
callq 0x39230
leaq 0x379f61(%rip), %rdi # 0x428344
popq %rbp
jmp 0x39230
nopl (%rax)
| my_mutex_end:
push rbp
mov rbp, rsp
lea rdi, my_fast_mutexattr
call _pthread_mutexattr_destroy
lea rdi, my_errorcheck_mutexattr
pop rbp
jmp _pthread_mutexattr_destroy
| long long my_mutex_end()
{
pthread_mutexattr_destroy(&my_fast_mutexattr);
return pthread_mutexattr_destroy(&my_errorcheck_mutexattr);
}
| my_mutex_end:
PUSH RBP
MOV RBP,RSP
LEA RDI,[0x528340]
CALL 0x00139230
LEA RDI,[0x528344]
POP RBP
JMP 0x00139230
|
void my_mutex_end(void)
{
pthread_mutexattr_destroy((pthread_mutexattr_t *)&my_fast_mutexattr);
pthread_mutexattr_destroy((pthread_mutexattr_t *)&my_errorcheck_mutexattr);
return;
}
| |
43,595 | OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::~FVarLevel() | NVIDIA-RTX[P]OSD-Lite/opensubdiv/vtr/fvarLevel.cpp | FVarLevel::~FVarLevel() {
} | O1 | cpp | OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::~FVarLevel():
pushq %rbx
movq %rdi, %rbx
movq 0xc0(%rdi), %rdi
testq %rdi, %rdi
je 0x3d64f
movq 0xd0(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2d0
movq 0xa8(%rbx), %rdi
testq %rdi, %rdi
je 0x3d66a
movq 0xb8(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2d0
movq 0x90(%rbx), %rdi
testq %rdi, %rdi
je 0x3d685
movq 0xa0(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2d0
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x3d69d
movq 0x88(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2d0
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x3d6b2
movq 0x70(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2d0
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x3d6c7
movq 0x58(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2d0
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x3d6dc
movq 0x40(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2d0
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x3d6f2
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
jmp 0x3a2d0
popq %rbx
retq
| _ZN10OpenSubdiv6v3_6_03Vtr8internal9FVarLevelD2Ev:
push rbx; Alternative name is 'OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::~FVarLevel()'
mov rbx, rdi
mov rdi, [rdi+0C0h]; void *
test rdi, rdi
jz short loc_3D64F
mov rsi, [rbx+0D0h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3D64F:
mov rdi, [rbx+0A8h]; void *
test rdi, rdi
jz short loc_3D66A
mov rsi, [rbx+0B8h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3D66A:
mov rdi, [rbx+90h]; void *
test rdi, rdi
jz short loc_3D685
mov rsi, [rbx+0A0h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3D685:
mov rdi, [rbx+78h]; void *
test rdi, rdi
jz short loc_3D69D
mov rsi, [rbx+88h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3D69D:
mov rdi, [rbx+60h]; void *
test rdi, rdi
jz short loc_3D6B2
mov rsi, [rbx+70h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3D6B2:
mov rdi, [rbx+48h]; void *
test rdi, rdi
jz short loc_3D6C7
mov rsi, [rbx+58h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3D6C7:
mov rdi, [rbx+30h]; void *
test rdi, rdi
jz short loc_3D6DC
mov rsi, [rbx+40h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3D6DC:
mov rdi, [rbx+18h]; void *
test rdi, rdi
jz short loc_3D6F2
mov rsi, [rbx+28h]
sub rsi, rdi; unsigned __int64
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
loc_3D6F2:
pop rbx
retn
| void OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::~FVarLevel(
OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel *this)
{
void *v2; // rdi
void *v3; // rdi
void *v4; // rdi
void *v5; // rdi
void *v6; // rdi
void *v7; // rdi
void *v8; // rdi
void *v9; // rdi
v2 = (void *)*((_QWORD *)this + 24);
if ( v2 )
operator delete(v2, *((_QWORD *)this + 26) - (_QWORD)v2);
v3 = (void *)*((_QWORD *)this + 21);
if ( v3 )
operator delete(v3, *((_QWORD *)this + 23) - (_QWORD)v3);
v4 = (void *)*((_QWORD *)this + 18);
if ( v4 )
operator delete(v4, *((_QWORD *)this + 20) - (_QWORD)v4);
v5 = (void *)*((_QWORD *)this + 15);
if ( v5 )
operator delete(v5, *((_QWORD *)this + 17) - (_QWORD)v5);
v6 = (void *)*((_QWORD *)this + 12);
if ( v6 )
operator delete(v6, *((_QWORD *)this + 14) - (_QWORD)v6);
v7 = (void *)*((_QWORD *)this + 9);
if ( v7 )
operator delete(v7, *((_QWORD *)this + 11) - (_QWORD)v7);
v8 = (void *)*((_QWORD *)this + 6);
if ( v8 )
operator delete(v8, *((_QWORD *)this + 8) - (_QWORD)v8);
v9 = (void *)*((_QWORD *)this + 3);
if ( v9 )
operator delete(v9, *((_QWORD *)this + 5) - (_QWORD)v9);
}
| ~FVarLevel:
PUSH RBX
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0xc0]
TEST RDI,RDI
JZ 0x0013d64f
MOV RSI,qword ptr [RBX + 0xd0]
SUB RSI,RDI
CALL 0x0013a2d0
LAB_0013d64f:
MOV RDI,qword ptr [RBX + 0xa8]
TEST RDI,RDI
JZ 0x0013d66a
MOV RSI,qword ptr [RBX + 0xb8]
SUB RSI,RDI
CALL 0x0013a2d0
LAB_0013d66a:
MOV RDI,qword ptr [RBX + 0x90]
TEST RDI,RDI
JZ 0x0013d685
MOV RSI,qword ptr [RBX + 0xa0]
SUB RSI,RDI
CALL 0x0013a2d0
LAB_0013d685:
MOV RDI,qword ptr [RBX + 0x78]
TEST RDI,RDI
JZ 0x0013d69d
MOV RSI,qword ptr [RBX + 0x88]
SUB RSI,RDI
CALL 0x0013a2d0
LAB_0013d69d:
MOV RDI,qword ptr [RBX + 0x60]
TEST RDI,RDI
JZ 0x0013d6b2
MOV RSI,qword ptr [RBX + 0x70]
SUB RSI,RDI
CALL 0x0013a2d0
LAB_0013d6b2:
MOV RDI,qword ptr [RBX + 0x48]
TEST RDI,RDI
JZ 0x0013d6c7
MOV RSI,qword ptr [RBX + 0x58]
SUB RSI,RDI
CALL 0x0013a2d0
LAB_0013d6c7:
MOV RDI,qword ptr [RBX + 0x30]
TEST RDI,RDI
JZ 0x0013d6dc
MOV RSI,qword ptr [RBX + 0x40]
SUB RSI,RDI
CALL 0x0013a2d0
LAB_0013d6dc:
MOV RDI,qword ptr [RBX + 0x18]
TEST RDI,RDI
JZ 0x0013d6f2
MOV RSI,qword ptr [RBX + 0x28]
SUB RSI,RDI
POP RBX
JMP 0x0013a2d0
LAB_0013d6f2:
POP RBX
RET
|
/* OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::~FVarLevel() */
void __thiscall OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::~FVarLevel(FVarLevel *this)
{
void *pvVar1;
pvVar1 = *(void **)(this + 0xc0);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0xd0) - (long)pvVar1);
}
pvVar1 = *(void **)(this + 0xa8);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0xb8) - (long)pvVar1);
}
pvVar1 = *(void **)(this + 0x90);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0xa0) - (long)pvVar1);
}
pvVar1 = *(void **)(this + 0x78);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0x88) - (long)pvVar1);
}
pvVar1 = *(void **)(this + 0x60);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0x70) - (long)pvVar1);
}
pvVar1 = *(void **)(this + 0x48);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0x58) - (long)pvVar1);
}
pvVar1 = *(void **)(this + 0x30);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0x40) - (long)pvVar1);
}
pvVar1 = *(void **)(this + 0x18);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0x28) - (long)pvVar1);
return;
}
return;
}
| |
43,596 | OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::~FVarLevel() | NVIDIA-RTX[P]OSD-Lite/opensubdiv/vtr/fvarLevel.cpp | FVarLevel::~FVarLevel() {
} | O3 | cpp | OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::~FVarLevel():
pushq %rbx
movq %rdi, %rbx
movq 0xc0(%rdi), %rdi
testq %rdi, %rdi
je 0x3d5cb
movq 0xd0(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2b0
movq 0xa8(%rbx), %rdi
testq %rdi, %rdi
je 0x3d5e6
movq 0xb8(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2b0
movq 0x90(%rbx), %rdi
testq %rdi, %rdi
je 0x3d601
movq 0xa0(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2b0
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x3d619
movq 0x88(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2b0
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x3d62e
movq 0x70(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2b0
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x3d643
movq 0x58(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2b0
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x3d658
movq 0x40(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2b0
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x3d66e
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
jmp 0x3a2b0
popq %rbx
retq
| _ZN10OpenSubdiv6v3_6_03Vtr8internal9FVarLevelD2Ev:
push rbx; Alternative name is 'OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::~FVarLevel()'
mov rbx, rdi
mov rdi, [rdi+0C0h]; void *
test rdi, rdi
jz short loc_3D5CB
mov rsi, [rbx+0D0h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3D5CB:
mov rdi, [rbx+0A8h]; void *
test rdi, rdi
jz short loc_3D5E6
mov rsi, [rbx+0B8h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3D5E6:
mov rdi, [rbx+90h]; void *
test rdi, rdi
jz short loc_3D601
mov rsi, [rbx+0A0h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3D601:
mov rdi, [rbx+78h]; void *
test rdi, rdi
jz short loc_3D619
mov rsi, [rbx+88h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3D619:
mov rdi, [rbx+60h]; void *
test rdi, rdi
jz short loc_3D62E
mov rsi, [rbx+70h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3D62E:
mov rdi, [rbx+48h]; void *
test rdi, rdi
jz short loc_3D643
mov rsi, [rbx+58h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3D643:
mov rdi, [rbx+30h]; void *
test rdi, rdi
jz short loc_3D658
mov rsi, [rbx+40h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3D658:
mov rdi, [rbx+18h]; void *
test rdi, rdi
jz short loc_3D66E
mov rsi, [rbx+28h]
sub rsi, rdi; unsigned __int64
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
loc_3D66E:
pop rbx
retn
| void OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::~FVarLevel(
OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel *this)
{
void *v2; // rdi
void *v3; // rdi
void *v4; // rdi
void *v5; // rdi
void *v6; // rdi
void *v7; // rdi
void *v8; // rdi
void *v9; // rdi
v2 = (void *)*((_QWORD *)this + 24);
if ( v2 )
operator delete(v2, *((_QWORD *)this + 26) - (_QWORD)v2);
v3 = (void *)*((_QWORD *)this + 21);
if ( v3 )
operator delete(v3, *((_QWORD *)this + 23) - (_QWORD)v3);
v4 = (void *)*((_QWORD *)this + 18);
if ( v4 )
operator delete(v4, *((_QWORD *)this + 20) - (_QWORD)v4);
v5 = (void *)*((_QWORD *)this + 15);
if ( v5 )
operator delete(v5, *((_QWORD *)this + 17) - (_QWORD)v5);
v6 = (void *)*((_QWORD *)this + 12);
if ( v6 )
operator delete(v6, *((_QWORD *)this + 14) - (_QWORD)v6);
v7 = (void *)*((_QWORD *)this + 9);
if ( v7 )
operator delete(v7, *((_QWORD *)this + 11) - (_QWORD)v7);
v8 = (void *)*((_QWORD *)this + 6);
if ( v8 )
operator delete(v8, *((_QWORD *)this + 8) - (_QWORD)v8);
v9 = (void *)*((_QWORD *)this + 3);
if ( v9 )
operator delete(v9, *((_QWORD *)this + 5) - (_QWORD)v9);
}
| ~FVarLevel:
PUSH RBX
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0xc0]
TEST RDI,RDI
JZ 0x0013d5cb
MOV RSI,qword ptr [RBX + 0xd0]
SUB RSI,RDI
CALL 0x0013a2b0
LAB_0013d5cb:
MOV RDI,qword ptr [RBX + 0xa8]
TEST RDI,RDI
JZ 0x0013d5e6
MOV RSI,qword ptr [RBX + 0xb8]
SUB RSI,RDI
CALL 0x0013a2b0
LAB_0013d5e6:
MOV RDI,qword ptr [RBX + 0x90]
TEST RDI,RDI
JZ 0x0013d601
MOV RSI,qword ptr [RBX + 0xa0]
SUB RSI,RDI
CALL 0x0013a2b0
LAB_0013d601:
MOV RDI,qword ptr [RBX + 0x78]
TEST RDI,RDI
JZ 0x0013d619
MOV RSI,qword ptr [RBX + 0x88]
SUB RSI,RDI
CALL 0x0013a2b0
LAB_0013d619:
MOV RDI,qword ptr [RBX + 0x60]
TEST RDI,RDI
JZ 0x0013d62e
MOV RSI,qword ptr [RBX + 0x70]
SUB RSI,RDI
CALL 0x0013a2b0
LAB_0013d62e:
MOV RDI,qword ptr [RBX + 0x48]
TEST RDI,RDI
JZ 0x0013d643
MOV RSI,qword ptr [RBX + 0x58]
SUB RSI,RDI
CALL 0x0013a2b0
LAB_0013d643:
MOV RDI,qword ptr [RBX + 0x30]
TEST RDI,RDI
JZ 0x0013d658
MOV RSI,qword ptr [RBX + 0x40]
SUB RSI,RDI
CALL 0x0013a2b0
LAB_0013d658:
MOV RDI,qword ptr [RBX + 0x18]
TEST RDI,RDI
JZ 0x0013d66e
MOV RSI,qword ptr [RBX + 0x28]
SUB RSI,RDI
POP RBX
JMP 0x0013a2b0
LAB_0013d66e:
POP RBX
RET
|
/* OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::~FVarLevel() */
void __thiscall OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::~FVarLevel(FVarLevel *this)
{
void *pvVar1;
pvVar1 = *(void **)(this + 0xc0);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0xd0) - (long)pvVar1);
}
pvVar1 = *(void **)(this + 0xa8);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0xb8) - (long)pvVar1);
}
pvVar1 = *(void **)(this + 0x90);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0xa0) - (long)pvVar1);
}
pvVar1 = *(void **)(this + 0x78);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0x88) - (long)pvVar1);
}
pvVar1 = *(void **)(this + 0x60);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0x70) - (long)pvVar1);
}
pvVar1 = *(void **)(this + 0x48);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0x58) - (long)pvVar1);
}
pvVar1 = *(void **)(this + 0x30);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0x40) - (long)pvVar1);
}
pvVar1 = *(void **)(this + 0x18);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0x28) - (long)pvVar1);
return;
}
return;
}
| |
43,597 | 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& 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>::operator[]<char const>(char const*) const | monkey531[P]llama/common/json.hpp | const_reference operator[](T* key) const
{
return operator[](typename object_t::key_type(key));
} | 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> const& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator[]<char const>(char const*) const:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x25866
movq %rbx, %rdi
movq %r14, %rsi
callq 0xcee2a
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc8cd5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1dc50
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc8cfe
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1dc50
movq %rbx, %rdi
callq 0x1e660
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixIKcEERKSD_PT_:
push r14
push rbx
sub rsp, 28h
mov rbx, rdi
lea r14, [rsp+38h+var_30]
lea rdx, [rsp+38h+var_31]
mov rdi, r14
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
mov rdi, rbx
mov rsi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixERKS9_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator[](std::string const&)
mov rbx, rax
lea rax, [rsp+38h+var_20]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_C8CD5
mov rsi, [rsp+38h+var_20]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C8CD5:
mov rax, rbx
add rsp, 28h
pop rbx
pop r14
retn
mov rbx, rax
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_C8CFE
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C8CFE:
mov rdi, rbx
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>::operator[]<char const>(
long long a1,
long long a2)
{
long long v2; // rbx
void *v4[2]; // [rsp+8h] [rbp-30h] BYREF
long long v5; // [rsp+18h] [rbp-20h] BYREF
std::string::basic_string<std::allocator<char>>(v4, a2);
v2 = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator[](
a1,
v4);
if ( v4[0] != &v5 )
operator delete(v4[0], v5 + 1);
return v2;
}
| operator[]<char_const>:
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
LEA R14,[RSP + 0x8]
LEA RDX,[RSP + 0x7]
MOV RDI,R14
CALL 0x00125866
LAB_001c8cac:
MOV RDI,RBX
MOV RSI,R14
CALL 0x001cee2a
LAB_001c8cb7:
MOV RBX,RAX
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001c8cd5
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011dc50
LAB_001c8cd5:
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R14
RET
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const&
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>::operator[]<char const>(char const*) const */
basic_json * __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator[]<char_const>
(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,char *param_1)
{
basic_json *pbVar1;
allocator local_31;
long *local_30 [2];
long local_20 [2];
std::__cxx11::string::string<std::allocator<char>>((string *)local_30,param_1,&local_31);
/* try { // try from 001c8cac to 001c8cb6 has its CatchHandler @ 001c8ce0 */
pbVar1 = (basic_json *)operator[](this,(string *)local_30);
if (local_30[0] != local_20) {
operator_delete(local_30[0],local_20[0] + 1);
}
return pbVar1;
}
| |
43,598 | my_free_open_file_info | eloqsql/mysys/my_file.c | void my_free_open_file_info()
{
DBUG_ENTER("my_free_file_info");
if (my_file_info != my_file_info_default)
{
/* Copy data back for my_print_open_files */
memcpy((char*) my_file_info_default, my_file_info,
sizeof(*my_file_info_default)* MY_NFILE);
my_free(my_file_info);
my_file_info= my_file_info_default;
my_file_limit= MY_NFILE;
}
DBUG_VOID_RETURN;
} | O3 | c | my_free_open_file_info:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x2ee9fd(%rip), %r15 # 0x36fad8
movq (%r15), %rbx
cmpq 0x2eaef3(%rip), %rbx # 0x36bfd8
je 0x81116
leaq 0x36ff22(%rip), %r14 # 0x3f1010
movl $0x400, %edx # imm = 0x400
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3a0c0
movq %rbx, %rdi
callq 0x84732
movq %r14, (%r15)
leaq 0x2ee9c0(%rip), %rax # 0x36fad0
movl $0x40, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
| my_free_open_file_info:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
lea r15, my_file_info
mov rbx, [r15]
cmp rbx, cs:my_file_info_default_ptr
jz short loc_81116
lea r14, my_file_info_default
mov edx, 400h
mov rdi, r14
mov rsi, rbx
call _memcpy
mov rdi, rbx
call my_free
mov [r15], r14
lea rax, my_file_limit
mov dword ptr [rax], 40h ; '@'
loc_81116:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| _DWORD * my_free_open_file_info(long long a1, long long a2, long long a3, long long a4, long long a5, long long a6)
{
void *v6; // rbx
_DWORD *result; // rax
v6 = my_file_info;
if ( my_file_info != &my_file_info_default )
{
memcpy(&my_file_info_default, my_file_info, 1024LL, a4, a5, a6);
my_free(v6);
my_file_info = &my_file_info_default;
result = my_file_limit;
my_file_limit[0] = 64;
}
return result;
}
| my_free_open_file_info:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
LEA R15,[0x46fad8]
MOV RBX,qword ptr [R15]
CMP RBX,qword ptr [0x0046bfd8]
JZ 0x00181116
LEA R14,[0x4f1010]
MOV EDX,0x400
MOV RDI,R14
MOV RSI,RBX
CALL 0x0013a0c0
MOV RDI,RBX
CALL 0x00184732
MOV qword ptr [R15],R14
LEA RAX,[0x46fad0]
MOV dword ptr [RAX],0x40
LAB_00181116:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
void my_free_open_file_info(void)
{
int *puVar1;
puVar1 = my_file_info;
if (my_file_info != PTR_my_file_info_default_0046bfd8) {
memcpy(my_file_info_default,my_file_info,0x400);
my_free(puVar1);
my_file_info = my_file_info_default;
my_file_limit = 0x40;
}
return;
}
| |
43,599 | lunasvg::SVGSVGElement::localTransform() const | dmazzella[P]pylunasvg/lunasvg/source/svgelement.cpp | Transform SVGSVGElement::localTransform() const
{
LengthContext lengthContext(this);
const Rect viewportRect = {
lengthContext.valueForLength(m_x),
lengthContext.valueForLength(m_y),
lengthContext.valueForLength(m_width),
lengthContext.valueForLength(m_height)
};
if(isRootElement())
return viewBoxToViewTransform(viewportRect.size());
return SVGGraphicsElement::localTransform() * Transform::translated(viewportRect.x, viewportRect.y) * viewBoxToViewTransform(viewportRect.size());
} | O1 | cpp | lunasvg::SVGSVGElement::localTransform() const:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x50(%rsp), %r15
movq %rsi, (%r15)
movb $0x0, 0x8(%r15)
addq $0xdc, %rsi
movzbl 0xd9(%r14), %edx
movq %r15, %rdi
callq 0x1f7ea
movss %xmm0, 0x10(%rsp)
leaq 0xf4(%r14), %rsi
movzbl 0xf1(%r14), %edx
movq %r15, %rdi
callq 0x1f7ea
movss %xmm0, 0xc(%rsp)
leaq 0x10c(%r14), %rsi
movzbl 0x109(%r14), %edx
movq %r15, %rdi
callq 0x1f7ea
movaps %xmm0, 0x20(%rsp)
leaq 0x124(%r14), %rsi
movzbl 0x121(%r14), %edx
movq %r15, %rdi
callq 0x1f7ea
movaps %xmm0, %xmm1
cmpq $0x0, 0x10(%r14)
je 0x108d7
movq 0x8c(%r14), %rax
leaq 0x60(%rsp), %r15
movq %rax, 0x10(%r15)
movups 0x7c(%r14), %xmm0
movaps %xmm0, (%r15)
leaq 0x98(%rsp), %r12
movq %r12, %rdi
movss 0x10(%rsp), %xmm0
movaps %xmm1, 0x10(%rsp)
movss 0xc(%rsp), %xmm1
callq 0xc9dc
leaq 0x38(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xc91a
addq $0x98, %r14
movaps 0x20(%rsp), %xmm0
unpcklps 0x10(%rsp), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
leaq 0x30(%rsp), %rdx
movlps %xmm0, (%rdx)
leaq 0x80(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x10122
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0xc91a
jmp 0x108f9
addq $0x98, %r14
movaps 0x20(%rsp), %xmm0
unpcklps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
leaq 0x38(%rsp), %rdx
movlps %xmm0, (%rdx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10122
movq %rbx, %rax
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
| _ZNK7lunasvg13SVGSVGElement14localTransformEv:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0B0h
mov r14, rsi
mov rbx, rdi
lea r15, [rsp+0D8h+var_88]
mov [r15], rsi
mov byte ptr [r15+8], 0
add rsi, 0DCh
movzx edx, byte ptr [r14+0D9h]
mov rdi, r15
call _ZNK7lunasvg13LengthContext14valueForLengthERKNS_6LengthENS_15LengthDirectionE; lunasvg::LengthContext::valueForLength(lunasvg::Length const&,lunasvg::LengthDirection)
movss [rsp+0D8h+var_C8], xmm0
lea rsi, [r14+0F4h]
movzx edx, byte ptr [r14+0F1h]
mov rdi, r15
call _ZNK7lunasvg13LengthContext14valueForLengthERKNS_6LengthENS_15LengthDirectionE; lunasvg::LengthContext::valueForLength(lunasvg::Length const&,lunasvg::LengthDirection)
movss [rsp+0D8h+var_CC], xmm0
lea rsi, [r14+10Ch]
movzx edx, byte ptr [r14+109h]
mov rdi, r15
call _ZNK7lunasvg13LengthContext14valueForLengthERKNS_6LengthENS_15LengthDirectionE; lunasvg::LengthContext::valueForLength(lunasvg::Length const&,lunasvg::LengthDirection)
movaps [rsp+0D8h+var_B8], xmm0
lea rsi, [r14+124h]
movzx edx, byte ptr [r14+121h]
mov rdi, r15
call _ZNK7lunasvg13LengthContext14valueForLengthERKNS_6LengthENS_15LengthDirectionE; lunasvg::LengthContext::valueForLength(lunasvg::Length const&,lunasvg::LengthDirection)
movaps xmm1, xmm0
cmp qword ptr [r14+10h], 0
jz loc_108D7
mov rax, [r14+8Ch]
lea r15, [rsp+0D8h+var_78]
mov [r15+10h], rax
movups xmm0, xmmword ptr [r14+7Ch]
movaps xmmword ptr [r15], xmm0
lea r12, [rsp+0D8h+var_40]
mov rdi, r12; this
movss xmm0, [rsp+0D8h+var_C8]; float
movaps xmmword ptr [rsp+0D8h+var_C8], xmm1
movss xmm1, [rsp+0D8h+var_CC]; float
call _ZN7lunasvg9Transform10translatedEff; lunasvg::Transform::translated(float,float)
lea r13, [rsp+0D8h+var_A0]
mov rdi, r13
mov rsi, r15
mov rdx, r12
call _ZNK7lunasvg9TransformmlERKS0_; lunasvg::Transform::operator*(lunasvg::Transform const&)
add r14, 98h
movaps xmm0, [rsp+0D8h+var_B8]
unpcklps xmm0, xmmword ptr [rsp+0D8h+var_C8]
lea rdx, [rsp+0D8h+var_A8]
movlps qword ptr [rdx], xmm0
lea r15, [rsp+0D8h+var_58]
mov rdi, r15; this
mov rsi, r14
call _ZNK7lunasvg15SVGFitToViewBox22viewBoxToViewTransformERKNS_4SizeE; lunasvg::SVGFitToViewBox::viewBoxToViewTransform(lunasvg::Size const&)
mov rdi, rbx
mov rsi, r13
mov rdx, r15
call _ZNK7lunasvg9TransformmlERKS0_; lunasvg::Transform::operator*(lunasvg::Transform const&)
jmp short loc_108F9
loc_108D7:
add r14, 98h
movaps xmm0, [rsp+0D8h+var_B8]
unpcklps xmm0, xmm1
lea rdx, [rsp+0D8h+var_A0]
movlps qword ptr [rdx], xmm0
mov rdi, rbx; this
mov rsi, r14
call _ZNK7lunasvg15SVGFitToViewBox22viewBoxToViewTransformERKNS_4SizeE; lunasvg::SVGFitToViewBox::viewBoxToViewTransform(lunasvg::Size const&)
loc_108F9:
mov rax, rbx
add rsp, 0B0h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
| lunasvg::SVGSVGElement * lunasvg::SVGSVGElement::localTransform(
lunasvg::SVGSVGElement *this,
long long a2,
__m128 a3)
{
float v5; // [rsp+Ch] [rbp-CCh]
float v6; // [rsp+10h] [rbp-C8h]
__m128 v7; // [rsp+20h] [rbp-B8h]
double v8; // [rsp+30h] [rbp-A8h] BYREF
double v9[3]; // [rsp+38h] [rbp-A0h] BYREF
long long v10; // [rsp+50h] [rbp-88h] BYREF
char v11; // [rsp+58h] [rbp-80h]
__int128 v12; // [rsp+60h] [rbp-78h] BYREF
long long v13; // [rsp+70h] [rbp-68h]
_BYTE v14[24]; // [rsp+80h] [rbp-58h] BYREF
_BYTE v15[64]; // [rsp+98h] [rbp-40h] BYREF
v10 = a2;
v11 = 0;
*(double *)a3.m128_u64 = lunasvg::LengthContext::valueForLength(&v10, a2 + 220, *(unsigned __int8 *)(a2 + 217));
v6 = a3.m128_f32[0];
*(double *)a3.m128_u64 = lunasvg::LengthContext::valueForLength(&v10, a2 + 244, *(unsigned __int8 *)(a2 + 241));
v5 = a3.m128_f32[0];
*(double *)a3.m128_u64 = lunasvg::LengthContext::valueForLength(&v10, a2 + 268, *(unsigned __int8 *)(a2 + 265));
v7 = a3;
*(double *)a3.m128_u64 = lunasvg::LengthContext::valueForLength(&v10, a2 + 292, *(unsigned __int8 *)(a2 + 289));
if ( *(_QWORD *)(a2 + 16) )
{
v13 = *(_QWORD *)(a2 + 140);
v12 = *(_OWORD *)(a2 + 124);
lunasvg::Transform::translated((lunasvg::Transform *)v15, v6, v5);
lunasvg::Transform::operator*((long long)v9, (long long)&v12, (long long)v15);
_mm_storel_ps(&v8, _mm_unpacklo_ps(v7, a3));
lunasvg::SVGFitToViewBox::viewBoxToViewTransform((lunasvg::Transform *)v14, a2 + 152, (float *)&v8);
lunasvg::Transform::operator*((long long)this, (long long)v9, (long long)v14);
}
else
{
_mm_storel_ps(v9, _mm_unpacklo_ps(v7, a3));
lunasvg::SVGFitToViewBox::viewBoxToViewTransform(this, a2 + 152, (float *)v9);
}
return this;
}
| localTransform:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xb0
MOV R14,RSI
MOV RBX,RDI
LEA R15,[RSP + 0x50]
MOV qword ptr [R15],RSI
MOV byte ptr [R15 + 0x8],0x0
ADD RSI,0xdc
MOVZX EDX,byte ptr [R14 + 0xd9]
MOV RDI,R15
CALL 0x0011f7ea
MOVSS dword ptr [RSP + 0x10],XMM0
LEA RSI,[R14 + 0xf4]
MOVZX EDX,byte ptr [R14 + 0xf1]
MOV RDI,R15
CALL 0x0011f7ea
MOVSS dword ptr [RSP + 0xc],XMM0
LEA RSI,[R14 + 0x10c]
MOVZX EDX,byte ptr [R14 + 0x109]
MOV RDI,R15
CALL 0x0011f7ea
MOVAPS xmmword ptr [RSP + 0x20],XMM0
LEA RSI,[R14 + 0x124]
MOVZX EDX,byte ptr [R14 + 0x121]
MOV RDI,R15
CALL 0x0011f7ea
MOVAPS XMM1,XMM0
CMP qword ptr [R14 + 0x10],0x0
JZ 0x001108d7
MOV RAX,qword ptr [R14 + 0x8c]
LEA R15,[RSP + 0x60]
MOV qword ptr [R15 + 0x10],RAX
MOVUPS XMM0,xmmword ptr [R14 + 0x7c]
MOVAPS xmmword ptr [R15],XMM0
LEA R12,[RSP + 0x98]
MOV RDI,R12
MOVSS XMM0,dword ptr [RSP + 0x10]
MOVAPS xmmword ptr [RSP + 0x10],XMM1
MOVSS XMM1,dword ptr [RSP + 0xc]
CALL 0x0010c9dc
LEA R13,[RSP + 0x38]
MOV RDI,R13
MOV RSI,R15
MOV RDX,R12
CALL 0x0010c91a
ADD R14,0x98
MOVAPS XMM0,xmmword ptr [RSP + 0x20]
UNPCKLPS XMM0,xmmword ptr [RSP + 0x10]
LEA RDX,[RSP + 0x30]
MOVLPS qword ptr [RDX],XMM0
LEA R15,[RSP + 0x80]
MOV RDI,R15
MOV RSI,R14
CALL 0x00110122
MOV RDI,RBX
MOV RSI,R13
MOV RDX,R15
CALL 0x0010c91a
JMP 0x001108f9
LAB_001108d7:
ADD R14,0x98
MOVAPS XMM0,xmmword ptr [RSP + 0x20]
UNPCKLPS XMM0,XMM1
LEA RDX,[RSP + 0x38]
MOVLPS qword ptr [RDX],XMM0
MOV RDI,RBX
MOV RSI,R14
CALL 0x00110122
LAB_001108f9:
MOV RAX,RBX
ADD RSP,0xb0
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* lunasvg::SVGSVGElement::localTransform() const */
void lunasvg::SVGSVGElement::localTransform(void)
{
long in_RSI;
Transform *in_RDI;
float fVar1;
float fVar2;
int4 uVar3;
int4 uVar4;
int8 local_a0 [3];
LengthContext local_88 [8];
int1 local_80;
int8 local_78;
int8 uStack_70;
int8 local_68;
Size local_58 [48];
local_80 = 0;
fVar1 = (float)LengthContext::valueForLength
(local_88,in_RSI + 0xdc,*(int1 *)(in_RSI + 0xd9));
fVar2 = (float)LengthContext::valueForLength
(local_88,in_RSI + 0xf4,*(int1 *)(in_RSI + 0xf1));
uVar3 = LengthContext::valueForLength(local_88,in_RSI + 0x10c,*(int1 *)(in_RSI + 0x109));
uVar4 = LengthContext::valueForLength(local_88,in_RSI + 0x124,*(int1 *)(in_RSI + 0x121));
if (*(long *)(in_RSI + 0x10) == 0) {
local_a0[0] = CONCAT44(uVar4,uVar3);
SVGFitToViewBox::viewBoxToViewTransform((Size *)in_RDI);
}
else {
local_68 = *(int8 *)(in_RSI + 0x8c);
local_78 = *(int8 *)(in_RSI + 0x7c);
uStack_70 = *(int8 *)(in_RSI + 0x84);
Transform::translated(fVar1,fVar2);
Transform::operator*((Transform *)local_a0,(Transform *)&local_78);
SVGFitToViewBox::viewBoxToViewTransform(local_58);
Transform::operator*(in_RDI,(Transform *)local_a0);
}
return;
}
|
Subsets and Splits
C++ Functions With Standard Library Dependencies
Identifies C++ functions that depend on standard library components, revealing patterns in how developers utilize STL libraries and potentially highlighting common coding practices or dependencies in the dataset.
C++ Standard Library Function Analysis
Filters C++ code examples that use standard library containers and types, providing useful insights into common programming patterns and data structures in the dataset.
Random Training Function Samples
Performs basic filtering and random sampling of assembly code data without revealing meaningful patterns or relationships.
Random Training Function Samples
Retrieves a random sample of 1000 records from the training dataset, providing basic data exploration but offering limited analytical value beyond seeing raw entries.