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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
48,300 | my_hash_first_from_hash_value | eloqsql/mysys/hash.c | uchar* my_hash_first_from_hash_value(const HASH *hash,
my_hash_value_type hash_value,
const uchar *key,
size_t length,
HASH_SEARCH_STATE *current_record)
{
HASH_LINK *pos;
DBUG_ENTER("my_hash_first_from_hash_value");
if (hash->records)
{
uint flag= 1;
uint idx= my_hash_mask(hash_value,
hash->blength, hash->records);
do
{
pos= dynamic_element(&hash->array,idx,HASH_LINK*);
if (!hashcmp(hash,pos,key,length))
{
DBUG_PRINT("exit",("found key at %d",idx));
*current_record= idx;
DBUG_RETURN (pos->data);
}
if (flag)
{
flag=0; /* Reset flag */
if (my_hash_rec_mask(pos, hash->blength, hash->records) != idx)
break; /* Wrong link */
}
}
while ((idx=pos->next) != NO_RECORD);
}
*current_record= NO_RECORD;
DBUG_RETURN(0);
} | O3 | c | my_hash_first_from_hash_value:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x4fa22
movq %rdx, %r15
movq %rdi, %r12
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
movq 0x10(%rdi), %rbx
addl %ebx, %ecx
andl %esi, %ecx
shrq %rbx
decl %ebx
andl %esi, %ebx
cmpq %rax, %rcx
cmovbl %ecx, %ebx
xorl %r14d, %r14d
movq 0x28(%r12), %rax
movl %ebx, %ecx
shlq $0x4, %rcx
leaq (%rax,%rcx), %r13
movq 0x8(%rax,%rcx), %rsi
movq %r12, %rdi
movq %r15, %rdx
movq -0x38(%rbp), %rcx
callq 0x4fa49
testl %eax, %eax
je 0x4fa30
testb $0x1, %r14b
jne 0x4fa16
movq 0x10(%r12), %rax
movl 0x4(%r13), %ecx
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
addl %eax, %edx
andl %ecx, %edx
shrq %rax
decl %eax
andl %ecx, %eax
cmpq 0x18(%r12), %rdx
cmovbl %edx, %eax
cmpl %ebx, %eax
jne 0x4fa22
movl (%r13), %ebx
movb $0x1, %r14b
cmpl $-0x1, %ebx
jne 0x4f9c4
movq -0x30(%rbp), %rax
movl $0xffffffff, (%rax) # imm = 0xFFFFFFFF
xorl %eax, %eax
jmp 0x4fa3a
movq -0x30(%rbp), %rax
movl %ebx, (%rax)
movq 0x8(%r13), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_hash_first_from_hash_value:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov [rbp+var_30], r8
mov [rbp+var_38], rcx
mov rax, [rdi+18h]
test rax, rax
jz loc_4FA22
mov r15, rdx
mov r12, rdi
mov ecx, 0FFFFFFFFh
mov rbx, [rdi+10h]
add ecx, ebx
and ecx, esi
shr rbx, 1
dec ebx
and ebx, esi
cmp rcx, rax
cmovb ebx, ecx
xor r14d, r14d
loc_4F9C4:
mov rax, [r12+28h]
mov ecx, ebx
shl rcx, 4
lea r13, [rax+rcx]
mov rsi, [rax+rcx+8]
mov rdi, r12
mov rdx, r15
mov rcx, [rbp+var_38]
call hashcmp
test eax, eax
jz short loc_4FA30
test r14b, 1
jnz short loc_4FA16
mov rax, [r12+10h]
mov ecx, [r13+4]
mov edx, 0FFFFFFFFh
add edx, eax
and edx, ecx
shr rax, 1
dec eax
and eax, ecx
cmp rdx, [r12+18h]
cmovb eax, edx
cmp eax, ebx
jnz short loc_4FA22
loc_4FA16:
mov ebx, [r13+0]
mov r14b, 1
cmp ebx, 0FFFFFFFFh
jnz short loc_4F9C4
loc_4FA22:
mov rax, [rbp+var_30]
mov dword ptr [rax], 0FFFFFFFFh
xor eax, eax
jmp short loc_4FA3A
loc_4FA30:
mov rax, [rbp+var_30]
mov [rax], ebx
mov rax, [r13+8]
loc_4FA3A:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_hash_first_from_hash_value(_QWORD *a1, int a2, long long a3, long long a4, unsigned int *a5)
{
unsigned long long v5; // rax
unsigned long long v7; // rbx
unsigned long long v8; // rcx
unsigned int v9; // ebx
char v10; // r14
long long v11; // r13
unsigned long long v12; // rax
int v13; // ecx
unsigned long long v14; // rdx
int v15; // eax
v5 = a1[3];
if ( v5 )
{
v7 = a1[2];
v8 = a2 & (unsigned int)(v7 - 1);
v9 = a2 & ((v7 >> 1) - 1);
if ( v8 < v5 )
v9 = v8;
v10 = 0;
while ( 1 )
{
v11 = a1[5] + 16LL * v9;
if ( !(unsigned int)hashcmp(a1, *(_QWORD *)(v11 + 8), a3, a4) )
break;
if ( (v10 & 1) != 0 )
goto LABEL_15;
v12 = a1[2];
v13 = *(_DWORD *)(v11 + 4);
v14 = v13 & (unsigned int)(v12 - 1);
v15 = v13 & ((v12 >> 1) - 1);
if ( v14 < a1[3] )
v15 = v14;
if ( v15 == v9 )
{
LABEL_15:
v9 = *(_DWORD *)v11;
v10 = 1;
if ( *(_DWORD *)v11 != -1 )
continue;
}
goto LABEL_11;
}
*a5 = v9;
return *(_QWORD *)(v11 + 8);
}
else
{
LABEL_11:
*a5 = -1;
return 0LL;
}
}
| my_hash_first_from_hash_value:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RBP + -0x30],R8
MOV qword ptr [RBP + -0x38],RCX
MOV RAX,qword ptr [RDI + 0x18]
TEST RAX,RAX
JZ 0x0014fa22
MOV R15,RDX
MOV R12,RDI
MOV ECX,0xffffffff
MOV RBX,qword ptr [RDI + 0x10]
ADD ECX,EBX
AND ECX,ESI
SHR RBX,0x1
DEC EBX
AND EBX,ESI
CMP RCX,RAX
CMOVC EBX,ECX
XOR R14D,R14D
LAB_0014f9c4:
MOV RAX,qword ptr [R12 + 0x28]
MOV ECX,EBX
SHL RCX,0x4
LEA R13,[RAX + RCX*0x1]
MOV RSI,qword ptr [RAX + RCX*0x1 + 0x8]
MOV RDI,R12
MOV RDX,R15
MOV RCX,qword ptr [RBP + -0x38]
CALL 0x0014fa49
TEST EAX,EAX
JZ 0x0014fa30
TEST R14B,0x1
JNZ 0x0014fa16
MOV RAX,qword ptr [R12 + 0x10]
MOV ECX,dword ptr [R13 + 0x4]
MOV EDX,0xffffffff
ADD EDX,EAX
AND EDX,ECX
SHR RAX,0x1
DEC EAX
AND EAX,ECX
CMP RDX,qword ptr [R12 + 0x18]
CMOVC EAX,EDX
CMP EAX,EBX
JNZ 0x0014fa22
LAB_0014fa16:
MOV EBX,dword ptr [R13]
MOV R14B,0x1
CMP EBX,-0x1
JNZ 0x0014f9c4
LAB_0014fa22:
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],0xffffffff
XOR EAX,EAX
JMP 0x0014fa3a
LAB_0014fa30:
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],EBX
MOV RAX,qword ptr [R13 + 0x8]
LAB_0014fa3a:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8
my_hash_first_from_hash_value
(long param_1,uint param_2,int8 param_3,int8 param_4,uint *param_5)
{
uint *puVar1;
uint uVar2;
int iVar3;
uint uVar4;
uint uVar5;
bool bVar6;
if (*(ulong *)(param_1 + 0x18) != 0) {
uVar4 = (int)*(ulong *)(param_1 + 0x10) - 1U & param_2;
uVar2 = (int)(*(ulong *)(param_1 + 0x10) >> 1) - 1U & param_2;
if ((ulong)uVar4 < *(ulong *)(param_1 + 0x18)) {
uVar2 = uVar4;
}
bVar6 = false;
do {
puVar1 = (uint *)(*(long *)(param_1 + 0x28) + (ulong)uVar2 * 0x10);
iVar3 = hashcmp(param_1,*(int8 *)(*(long *)(param_1 + 0x28) + 8 + (ulong)uVar2 * 0x10),
param_3,param_4);
if (iVar3 == 0) {
*param_5 = uVar2;
return *(int8 *)(puVar1 + 2);
}
if (!bVar6) {
uVar5 = (int)*(ulong *)(param_1 + 0x10) - 1U & puVar1[1];
uVar4 = (int)(*(ulong *)(param_1 + 0x10) >> 1) - 1U & puVar1[1];
if ((ulong)uVar5 < *(ulong *)(param_1 + 0x18)) {
uVar4 = uVar5;
}
if (uVar4 != uVar2) break;
}
uVar2 = *puVar1;
bVar6 = true;
} while (uVar2 != 0xffffffff);
}
*param_5 = 0xffffffff;
return 0;
}
| |
48,301 | pvio_socket_has_data | eloqsql/libmariadb/plugins/pvio/pvio_socket.c | my_bool pvio_socket_has_data(MARIADB_PVIO *pvio, ssize_t *data_len)
{
struct st_pvio_socket *csock= NULL;
char tmp_buf;
ssize_t len;
my_bool mode;
if (!pvio || !pvio->data)
return 0;
csock= (struct st_pvio_socket *)pvio->data;
/* MSG_PEEK: Peeks at the incoming data. The data is copied into the buffer,
but is not removed from the input queue.
*/
pvio_socket_blocking(pvio, 0, &mode);
len= recv(csock->socket, &tmp_buf, sizeof(tmp_buf), MSG_PEEK);
pvio_socket_blocking(pvio, mode, 0);
if (len < 0)
return 1;
*data_len= len;
return 0;
} | O0 | c | pvio_socket_has_data:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5cbf9
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x5cbff
movb $0x0, -0x1(%rbp)
jmp 0x5cc63
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
leaq -0x31(%rbp), %rdx
callq 0x5bba0
movq -0x20(%rbp), %rax
movl (%rax), %edi
leaq -0x21(%rbp), %rsi
movl $0x1, %edx
movl $0x2, %ecx
callq 0x14160
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movsbl -0x31(%rbp), %esi
callq 0x5bba0
cmpq $0x0, -0x30(%rbp)
jge 0x5cc54
movb $0x1, -0x1(%rbp)
jmp 0x5cc63
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
| pvio_socket_has_data:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], 0
cmp [rbp+var_10], 0
jz short loc_5CBF9
mov rax, [rbp+var_10]
cmp qword ptr [rax], 0
jnz short loc_5CBFF
loc_5CBF9:
mov [rbp+var_1], 0
jmp short loc_5CC63
loc_5CBFF:
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_20], rax
mov rdi, [rbp+var_10]
xor esi, esi
lea rdx, [rbp+var_31]
call pvio_socket_blocking
mov rax, [rbp+var_20]
mov edi, [rax]
lea rsi, [rbp+var_21]
mov edx, 1
mov ecx, 2
call _recv
mov [rbp+var_30], rax
mov rdi, [rbp+var_10]
xor eax, eax
mov edx, eax
movsx esi, [rbp+var_31]
call pvio_socket_blocking
cmp [rbp+var_30], 0
jge short loc_5CC54
mov [rbp+var_1], 1
jmp short loc_5CC63
loc_5CC54:
mov rcx, [rbp+var_30]
mov rax, [rbp+var_18]
mov [rax], rcx
mov [rbp+var_1], 0
loc_5CC63:
mov al, [rbp+var_1]
add rsp, 40h
pop rbp
retn
| char pvio_socket_has_data(unsigned int **a1, long long *a2)
{
char v3; // [rsp+Fh] [rbp-31h] BYREF
long long v4; // [rsp+10h] [rbp-30h]
char v5; // [rsp+1Fh] [rbp-21h] BYREF
unsigned int *v6; // [rsp+20h] [rbp-20h]
long long *v7; // [rsp+28h] [rbp-18h]
unsigned int **v8; // [rsp+30h] [rbp-10h]
v8 = a1;
v7 = a2;
v6 = 0LL;
if ( !a1 || !*v8 )
return 0;
v6 = *v8;
pvio_socket_blocking(v8, 0, &v3);
v4 = recv(*v6, &v5, 1LL, 2LL);
pvio_socket_blocking(v8, v3, 0LL);
if ( v4 < 0 )
return 1;
*v7 = v4;
return 0;
}
| pvio_socket_has_data:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],0x0
CMP qword ptr [RBP + -0x10],0x0
JZ 0x0015cbf9
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX],0x0
JNZ 0x0015cbff
LAB_0015cbf9:
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0015cc63
LAB_0015cbff:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x10]
XOR ESI,ESI
LEA RDX,[RBP + -0x31]
CALL 0x0015bba0
MOV RAX,qword ptr [RBP + -0x20]
MOV EDI,dword ptr [RAX]
LEA RSI,[RBP + -0x21]
MOV EDX,0x1
MOV ECX,0x2
CALL 0x00114160
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x10]
XOR EAX,EAX
MOV EDX,EAX
MOVSX ESI,byte ptr [RBP + -0x31]
CALL 0x0015bba0
CMP qword ptr [RBP + -0x30],0x0
JGE 0x0015cc54
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0015cc63
LAB_0015cc54:
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV byte ptr [RBP + -0x1],0x0
LAB_0015cc63:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x40
POP RBP
RET
|
int1 pvio_socket_has_data(long *param_1,long *param_2)
{
char local_39;
long local_38;
int1 local_29;
int *local_28;
long *local_20;
long *local_18;
int1 local_9;
if ((param_1 == (long *)0x0) || (*param_1 == 0)) {
local_9 = 0;
}
else {
local_28 = (int *)*param_1;
local_20 = param_2;
local_18 = param_1;
pvio_socket_blocking(param_1,0,&local_39);
local_38 = recv(*local_28,&local_29,1,2);
pvio_socket_blocking(local_18,(int)local_39,0);
if (local_38 < 0) {
local_9 = 1;
}
else {
*local_20 = local_38;
local_9 = 0;
}
}
return local_9;
}
| |
48,302 | ma_readinfo | eloqsql/storage/maria/ma_locking.c | int _ma_readinfo(register MARIA_HA *info __attribute__ ((unused)),
int lock_type __attribute__ ((unused)),
int check_keybuffer __attribute__ ((unused)))
{
#ifdef MARIA_EXTERNAL_LOCKING
DBUG_ENTER("_ma_readinfo");
if (info->lock_type == F_UNLCK)
{
MARIA_SHARE *share= info->s;
if (!share->tot_locks)
{
/* should not be done for transactional tables */
if (_ma_state_info_read_dsk(share->kfile.file, &share->state))
{
if (!my_errno)
my_errno= HA_ERR_FILE_TOO_SHORT;
DBUG_RETURN(1);
}
}
if (check_keybuffer)
VOID(_ma_test_if_changed(info));
info->invalidator=share->invalidator;
}
else if (lock_type == F_WRLCK && info->lock_type == F_RDLCK)
{
my_errno=EACCES; /* Not allowed to change */
DBUG_RETURN(-1); /* when have read_lock() */
}
DBUG_RETURN(0);
#else
return 0;
#endif /* defined(MARIA_EXTERNAL_LOCKING) */
} | O3 | c | ma_readinfo:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
popq %rbp
retq
| _ma_readinfo:
push rbp
mov rbp, rsp
xor eax, eax
pop rbp
retn
| long long ma_readinfo()
{
return 0LL;
}
| _ma_readinfo:
PUSH RBP
MOV RBP,RSP
XOR EAX,EAX
POP RBP
RET
|
int8 _ma_readinfo(void)
{
return 0;
}
| |
48,303 | Geometry::Class_info::Class_info(char const*, char const*, int, Geometry* (*)(char*)) | eloqsql/sql/spatial.cc | Geometry::Class_info::Class_info(const char *name, const char *geojson_name,
int type_id, create_geom_t create_func):
m_type_id(type_id), m_create_func(create_func)
{
m_name.str= (char *) name;
m_name.length= strlen(name);
m_geojson_name.str= (char *) geojson_name;
m_geojson_name.length= strlen(geojson_name);
ci_collection[type_id]= this;
} | O0 | cpp | Geometry::Class_info::Class_info(char const*, char const*, int, Geometry* (*)(char*)):
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x20(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x433950
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rdi
callq 0x433950
movq -0x30(%rbp), %rdx
movq %rax, 0x18(%rdx)
movslq -0x1c(%rbp), %rcx
leaq 0xb85410(%rip), %rax # 0x15f3d50
movq %rdx, (%rax,%rcx,8)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| _ZN8Geometry10Class_infoC2EPKcS2_iPFPS_PcE:
push rbp; Alternative name is 'Geometry::Class_info::Class_info(char const*, char const*, int, Geometry* (*)(char *))'
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
mov [rbp+var_28], r8
mov rax, [rbp+var_8]
mov [rbp+var_30], rax
mov ecx, [rbp+var_1C]
mov [rax+20h], ecx
mov rcx, [rbp+var_28]
mov [rax+28h], rcx
mov rcx, [rbp+var_10]
mov [rax], rcx
mov rdi, [rbp+var_10]
call _strlen
mov rcx, rax
mov rax, [rbp+var_30]
mov [rax+8], rcx
mov rcx, [rbp+var_18]
mov [rax+10h], rcx
mov rdi, [rbp+var_18]
call _strlen
mov rdx, [rbp+var_30]
mov [rdx+18h], rax
movsxd rcx, [rbp+var_1C]
lea rax, _ZN8Geometry13ci_collectionE; Geometry::ci_collection
mov [rax+rcx*8], rdx
add rsp, 30h
pop rbp
retn
| _QWORD * Geometry::Class_info::Class_info(
Geometry::Class_info *this,
const char *a2,
const char *a3,
int a4,
Geometry *(*a5)(char *))
{
_QWORD *result; // rax
*((_DWORD *)this + 8) = a4;
*((_QWORD *)this + 5) = a5;
*(_QWORD *)this = a2;
*((_QWORD *)this + 1) = strlen(a2);
*((_QWORD *)this + 2) = a3;
*((_QWORD *)this + 3) = strlen(a3);
result = Geometry::ci_collection;
Geometry::ci_collection[a4] = this;
return result;
}
| val_str:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x58],RDI
MOV qword ptr [RBP + -0x60],RSI
MOV RSI,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x88],RSI
MOV RDX,RSI
ADD RDX,0xa8
LEA RDI,[RBP + -0x50]
MOV qword ptr [RBP + -0x80],RDI
CALL 0x00a762a0
MOV RAX,qword ptr [RBP + -0x88]
MOV RDI,qword ptr [RBP + -0x80]
MOV RSI,qword ptr [RBP + -0x60]
MOVZX EDX,word ptr [RAX + 0xc]
LAB_00a6e925:
CALL 0x008cb070
LAB_00a6e92a:
MOV qword ptr [RBP + -0x78],RAX
JMP 0x00a6e930
LAB_00a6e930:
LEA RDI,[RBP + -0x50]
CALL 0x00a76330
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00a6e996
MOV RAX,qword ptr [RBP + -0x78]
ADD RSP,0x90
POP RBP
RET
LAB_00a6e996:
CALL 0x00533650
|
/* Item_func_udf_decimal::val_str(String*) */
int8 __thiscall Item_func_udf_decimal::val_str(Item_func_udf_decimal *this,String *param_1)
{
int8 uVar1;
long in_FS_OFFSET;
VDec_udf local_58 [72];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
Item_udf_func::VDec_udf::VDec_udf(local_58,(Item_udf_func *)this,(udf_handler *)(this + 0xa8));
/* try { // try from 00a6e925 to 00a6e929 has its CatchHandler @ 00a6e958 */
uVar1 = Dec_ptr_and_buffer::to_string_round
((Dec_ptr_and_buffer *)local_58,param_1,*(ushort *)(this + 0xc));
Item_udf_func::VDec_udf::~VDec_udf(local_58);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return uVar1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
48,304 | spdlog::pattern_formatter::~pattern_formatter() | AlayaLite/build_O3/_deps/spdlog-src/include/spdlog/pattern_formatter.h | class SPDLOG_API pattern_formatter final : public formatter {
public:
using custom_flags = std::unordered_map<char, std::unique_ptr<custom_flag_formatter>>;
explicit pattern_formatter(std::string pattern,
pattern_time_type time_type = pattern_time_type::local,
std::string eol = spdlog::details::os::default_eol,
custom_flags custom_user_flags = custom_flags());
// use default pattern is not given
explicit pattern_formatter(pattern_time_type time_type = pattern_time_type::local,
std::string eol = spdlog::details::os::default_eol);
pattern_formatter(const pattern_formatter &other) = delete;
pattern_formatter &operator=(const pattern_formatter &other) = delete;
std::unique_ptr<formatter> clone() const override;
void format(const details::log_msg &msg, memory_buf_t &dest) override;
template <typename T, typename... Args>
pattern_formatter &add_flag(char flag, Args &&...args) {
custom_handlers_[flag] = details::make_unique<T>(std::forward<Args>(args)...);
return *this;
}
void set_pattern(std::string pattern);
void need_localtime(bool need = true);
private:
std::string pattern_;
std::string eol_;
pattern_time_type pattern_time_type_;
bool need_localtime_;
std::tm cached_tm_;
std::chrono::seconds last_log_secs_;
std::vector<std::unique_ptr<details::flag_formatter>> formatters_;
custom_flags custom_handlers_;
std::tm get_time_(const details::log_msg &msg);
template <typename Padder>
void handle_flag_(char flag, details::padding_info padding);
// Extract given pad spec (e.g. %8X)
// Advance the given it pass the end of the padding spec found (if any)
// Return padding.
static details::padding_info handle_padspec_(std::string::const_iterator &it,
std::string::const_iterator end);
void compile_pattern_(const std::string &pattern);
} | O3 | c | spdlog::pattern_formatter::~pattern_formatter():
pushq %rbx
movq %rdi, %rbx
addq $0xa8, %rdi
callq 0x32e88
leaq 0x90(%rbx), %rdi
callq 0x300b2
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x32610
movq (%rax), %rsi
incq %rsi
callq 0x11120
movq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x32628
movq (%rax), %rsi
incq %rsi
callq 0x11120
movl $0xe0, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x11120
| _ZN6spdlog17pattern_formatterD0Ev:
push rbx
mov rbx, rdi
add rdi, 0A8h
call _ZNSt10_HashtableIcSt4pairIKcSt10unique_ptrIN6spdlog21custom_flag_formatterESt14default_deleteIS4_EEESaIS8_ENSt8__detail10_Select1stESt8equal_toIcESt4hashIcENSA_18_Mod_range_hashingENSA_20_Default_ranged_hashENSA_20_Prime_rehash_policyENSA_17_Hashtable_traitsILb0ELb0ELb1EEEED2Ev; std::_Hashtable<char,std::pair<char const,std::unique_ptr<spdlog::custom_flag_formatter>>,std::allocator<std::pair<char const,std::unique_ptr<spdlog::custom_flag_formatter>>>,std::__detail::_Select1st,std::equal_to<char>,std::hash<char>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::~_Hashtable()
lea rdi, [rbx+90h]
call _ZNSt6vectorISt10unique_ptrIN6spdlog7details14flag_formatterESt14default_deleteIS3_EESaIS6_EED2Ev; std::vector<std::unique_ptr<spdlog::details::flag_formatter>>::~vector()
mov rdi, [rbx+28h]; void *
lea rax, [rbx+38h]
cmp rdi, rax
jz short loc_32610
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_32610:
mov rdi, [rbx+8]; void *
lea rax, [rbx+18h]
cmp rdi, rax
jz short loc_32628
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_32628:
mov esi, 0E0h; unsigned __int64
mov rdi, rbx; void *
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
| void spdlog::pattern_formatter::~pattern_formatter(spdlog::pattern_formatter *this)
{
char *v2; // rdi
char *v3; // rdi
std::_Hashtable<char,std::pair<char const,std::unique_ptr<spdlog::custom_flag_formatter>>,std::allocator<std::pair<char const,std::unique_ptr<spdlog::custom_flag_formatter>>>,std::__detail::_Select1st,std::equal_to<char>,std::hash<char>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::~_Hashtable((char *)this + 168);
std::vector<std::unique_ptr<spdlog::details::flag_formatter>>::~vector((long long)this + 144);
v2 = (char *)*((_QWORD *)this + 5);
if ( v2 != (char *)this + 56 )
operator delete(v2, *((_QWORD *)this + 7) + 1LL);
v3 = (char *)*((_QWORD *)this + 1);
if ( v3 != (char *)this + 24 )
operator delete(v3, *((_QWORD *)this + 3) + 1LL);
operator delete(this, 0xE0uLL);
}
| ~pattern_formatter:
PUSH RBX
MOV RBX,RDI
ADD RDI,0xa8
CALL 0x00132e88
LEA RDI,[RBX + 0x90]
CALL 0x001300b2
MOV RDI,qword ptr [RBX + 0x28]
LEA RAX,[RBX + 0x38]
CMP RDI,RAX
JZ 0x00132610
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x00111120
LAB_00132610:
MOV RDI,qword ptr [RBX + 0x8]
LEA RAX,[RBX + 0x18]
CMP RDI,RAX
JZ 0x00132628
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x00111120
LAB_00132628:
MOV ESI,0xe0
MOV RDI,RBX
POP RBX
JMP 0x00111120
|
/* spdlog::pattern_formatter::~pattern_formatter() */
void __thiscall spdlog::pattern_formatter::~pattern_formatter(pattern_formatter *this)
{
std::
_Hashtable<char,std::pair<char_const,std::unique_ptr<spdlog::custom_flag_formatter,std::default_delete<spdlog::custom_flag_formatter>>>,std::allocator<std::pair<char_const,std::unique_ptr<spdlog::custom_flag_formatter,std::default_delete<spdlog::custom_flag_formatter>>>>,std::__detail::_Select1st,std::equal_to<char>,std::hash<char>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
::~_Hashtable((_Hashtable<char,std::pair<char_const,std::unique_ptr<spdlog::custom_flag_formatter,std::default_delete<spdlog::custom_flag_formatter>>>,std::allocator<std::pair<char_const,std::unique_ptr<spdlog::custom_flag_formatter,std::default_delete<spdlog::custom_flag_formatter>>>>,std::__detail::_Select1st,std::equal_to<char>,std::hash<char>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
*)(this + 0xa8));
std::
vector<std::unique_ptr<spdlog::details::flag_formatter,std::default_delete<spdlog::details::flag_formatter>>,std::allocator<std::unique_ptr<spdlog::details::flag_formatter,std::default_delete<spdlog::details::flag_formatter>>>>
::~vector((vector<std::unique_ptr<spdlog::details::flag_formatter,std::default_delete<spdlog::details::flag_formatter>>,std::allocator<std::unique_ptr<spdlog::details::flag_formatter,std::default_delete<spdlog::details::flag_formatter>>>>
*)(this + 0x90));
if (*(pattern_formatter **)(this + 0x28) != this + 0x38) {
operator_delete(*(pattern_formatter **)(this + 0x28),*(long *)(this + 0x38) + 1);
}
if (*(pattern_formatter **)(this + 8) != this + 0x18) {
operator_delete(*(pattern_formatter **)(this + 8),*(long *)(this + 0x18) + 1);
}
operator_delete(this,0xe0);
return;
}
| |
48,305 | js_regexp_constructor_internal | bluesky950520[P]quickjs/quickjs.c | static JSValue js_regexp_constructor_internal(JSContext *ctx, JSValue ctor,
JSValue pattern, JSValue bc)
{
JSValue obj;
JSObject *p;
JSRegExp *re;
/* sanity check */
if (JS_VALUE_GET_TAG(bc) != JS_TAG_STRING ||
JS_VALUE_GET_TAG(pattern) != JS_TAG_STRING) {
JS_ThrowTypeError(ctx, "string expected");
fail:
JS_FreeValue(ctx, bc);
JS_FreeValue(ctx, pattern);
return JS_EXCEPTION;
}
obj = js_create_from_ctor(ctx, ctor, JS_CLASS_REGEXP);
if (JS_IsException(obj))
goto fail;
p = JS_VALUE_GET_OBJ(obj);
re = &p->u.regexp;
re->pattern = JS_VALUE_GET_STRING(pattern);
re->bytecode = JS_VALUE_GET_STRING(bc);
JS_DefinePropertyValue(ctx, obj, JS_ATOM_lastIndex, js_int32(0),
JS_PROP_WRITABLE);
return obj;
} | O1 | c | js_regexp_constructor_internal:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %rbx
leaq 0x50(%rsp), %rbp
movq %rcx, 0x10(%rsp)
movq 0x8(%rbp), %r12
movl %r12d, %eax
movl $0xfffffff9, %ecx # imm = 0xFFFFFFF9
xorq %rcx, %rax
movl %r14d, %edi
xorq %rcx, %rdi
orq %rax, %rdi
je 0x3f768
leaq 0x5fd0a(%rip), %rsi # 0x9f466
movq %rbx, %rdi
xorl %eax, %eax
callq 0x22567
jmp 0x3f783
movq %rbx, %rdi
movl $0x12, %ecx
callq 0x36d56
movq %rdx, %r13
movq %rax, 0x8(%rsp)
cmpl $0x6, %r13d
jne 0x3f7ad
movq (%rbp), %rsi
movq 0x18(%rbx), %rdi
movq %r12, %rdx
callq 0x1d8c6
movq 0x18(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1d8c6
movl $0x6, %r13d
xorl %r14d, %r14d
jmp 0x3f7e8
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x30(%rax)
movq (%rbp), %rcx
movq %rcx, 0x38(%rax)
movq 0x8(%rsp), %r14
movl $0x2, (%rsp)
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
movl $0x56, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x26abb
movq %r14, %rax
movq %r13, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| js_regexp_constructor_internal:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r14, r8
mov r15, rcx
mov rbx, rdi
lea rbp, [rsp+48h+arg_0]
mov [rsp+48h+var_38], rcx
mov r12, [rbp+8]
mov eax, r12d
mov ecx, 0FFFFFFF9h
xor rax, rcx
mov edi, r14d
xor rdi, rcx
or rdi, rax
jz short loc_3F768
lea rsi, aStringExpected; "string expected"
mov rdi, rbx
xor eax, eax
call JS_ThrowTypeError
jmp short loc_3F783
loc_3F768:
mov rdi, rbx
mov ecx, 12h
call js_create_from_ctor
mov r13, rdx
mov [rsp+48h+var_40], rax
cmp r13d, 6
jnz short loc_3F7AD
loc_3F783:
mov rsi, [rbp+0]
mov rdi, [rbx+18h]
mov rdx, r12
call JS_FreeValueRT
mov rdi, [rbx+18h]
mov rsi, r15
mov rdx, r14
call JS_FreeValueRT
mov r13d, 6
xor r14d, r14d
jmp short loc_3F7E8
loc_3F7AD:
mov rax, [rsp+48h+var_40]
mov rcx, [rsp+48h+var_38]
mov [rax+30h], rcx
mov rcx, [rbp+0]
mov [rax+38h], rcx
mov r14, [rsp+48h+var_40]
mov [rsp+48h+var_48], 2
mov rdi, rbx
mov rsi, r14
mov rdx, r13
mov ecx, 56h ; 'V'
xor r8d, r8d
xor r9d, r9d
call JS_DefinePropertyValue
loc_3F7E8:
mov rax, r14
mov rdx, r13
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| unsigned long long js_regexp_constructor_internal(
long long a1,
long long a2,
long long a3,
_DWORD *a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
_DWORD *a15,
long long a16)
{
unsigned long long v18; // rax
long long v19; // rdx
__m128 v20; // xmm4
__m128 v21; // xmm5
unsigned long long v22; // r14
char v24; // [rsp+0h] [rbp-48h]
if ( (unsigned int)a16 ^ 0xFFFFFFF9LL | (unsigned int)a5 ^ 0xFFFFFFF9LL )
{
JS_ThrowTypeError(
a1,
(long long)"string expected",
a3,
4294967289LL,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v24);
}
else
{
v18 = js_create_from_ctor(a1, a2, a3, 18);
if ( (_DWORD)v19 != 6 )
{
*(_QWORD *)(v18 + 48) = a4;
*(_QWORD *)(v18 + 56) = a15;
v22 = v18;
JS_DefinePropertyValue(a1, v18, v19, 86LL, 0LL, 0LL, *(double *)a7.m128_u64, a8, a9, a10, v20, v21, a13, a14, 2);
return v22;
}
}
JS_FreeValueRT(*(_QWORD *)(a1 + 24), a15, a16);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), a4, a5);
return 0LL;
}
| |||
48,306 | js_regexp_constructor_internal | bluesky950520[P]quickjs/quickjs.c | static JSValue js_regexp_constructor_internal(JSContext *ctx, JSValue ctor,
JSValue pattern, JSValue bc)
{
JSValue obj;
JSObject *p;
JSRegExp *re;
/* sanity check */
if (JS_VALUE_GET_TAG(bc) != JS_TAG_STRING ||
JS_VALUE_GET_TAG(pattern) != JS_TAG_STRING) {
JS_ThrowTypeError(ctx, "string expected");
fail:
JS_FreeValue(ctx, bc);
JS_FreeValue(ctx, pattern);
return JS_EXCEPTION;
}
obj = js_create_from_ctor(ctx, ctor, JS_CLASS_REGEXP);
if (JS_IsException(obj))
goto fail;
p = JS_VALUE_GET_OBJ(obj);
re = &p->u.regexp;
re->pattern = JS_VALUE_GET_STRING(pattern);
re->bytecode = JS_VALUE_GET_STRING(bc);
JS_DefinePropertyValue(ctx, obj, JS_ATOM_lastIndex, js_int32(0),
JS_PROP_WRITABLE);
return obj;
} | O2 | c | js_regexp_constructor_internal:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rcx, %r14
movq %rdi, %rbx
leaq 0x40(%rsp), %rax
movq 0x8(%rax), %r12
movl %r12d, %eax
movl $0xfffffff9, %ecx # imm = 0xFFFFFFF9
xorq %rcx, %rax
movl %r15d, %edi
xorq %rcx, %rdi
orq %rax, %rdi
je 0x37a41
leaq 0x4e981(%rip), %rsi # 0x863b6
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1c64d
jmp 0x37a55
pushq $0x12
popq %rcx
movq %rbx, %rdi
callq 0x3045a
movq %rdx, %r13
cmpl $0x6, %r13d
jne 0x37a7e
leaq 0x40(%rsp), %rax
movq (%rax), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x1801e
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1801e
pushq $0x6
popq %r13
xorl %ebp, %ebp
jmp 0x37aaf
movq %rax, %rbp
movq %r14, 0x30(%rax)
leaq 0x40(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x38(%rbp)
movl $0x2, (%rsp)
pushq $0x56
popq %rcx
movq %rbx, %rdi
movq %rbp, %rsi
movq %r13, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x20872
movq %rbp, %rax
movq %r13, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| js_regexp_constructor_internal:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15, r8
mov r14, rcx
mov rbx, rdi
lea rax, [rsp+38h+arg_0]
mov r12, [rax+8]
mov eax, r12d
mov ecx, 0FFFFFFF9h
xor rax, rcx
mov edi, r15d
xor rdi, rcx
or rdi, rax
jz short loc_37A41
lea rsi, aStringExpected; "string expected"
mov rdi, rbx
xor eax, eax
call JS_ThrowTypeError
jmp short loc_37A55
loc_37A41:
push 12h
pop rcx
mov rdi, rbx
call js_create_from_ctor
mov r13, rdx
cmp r13d, 6
jnz short loc_37A7E
loc_37A55:
lea rax, [rsp+38h+arg_0]
mov rsi, [rax]
mov rdi, rbx
mov rdx, r12
call JS_FreeValue
mov rdi, rbx
mov rsi, r14
mov rdx, r15
call JS_FreeValue
push 6
pop r13
xor ebp, ebp
jmp short loc_37AAF
loc_37A7E:
mov rbp, rax
mov [rax+30h], r14
lea rax, [rsp+38h+arg_0]
mov rax, [rax]
mov [rbp+38h], rax
mov [rsp+38h+var_38], 2
push 56h ; 'V'
pop rcx
mov rdi, rbx
mov rsi, rbp
mov rdx, r13
xor r8d, r8d
xor r9d, r9d
call JS_DefinePropertyValue
loc_37AAF:
mov rax, rbp
mov rdx, r13
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| unsigned long long js_regexp_constructor_internal(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
long long a15,
long long a16)
{
char v16; // al
unsigned long long v19; // rax
long long v20; // rdx
__m128 v21; // xmm4
__m128 v22; // xmm5
unsigned long long v23; // rbp
if ( (unsigned int)a16 ^ 0xFFFFFFF9LL | (unsigned int)a5 ^ 0xFFFFFFF9LL )
{
JS_ThrowTypeError(
a1,
(long long)"string expected",
a3,
4294967289LL,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v16);
}
else
{
v19 = js_create_from_ctor(a1, a2, a3, 18);
if ( (_DWORD)v20 != 6 )
{
v23 = v19;
*(_QWORD *)(v19 + 48) = a4;
*(_QWORD *)(v19 + 56) = a15;
JS_DefinePropertyValue(a1, v19, v20, 86LL, 0LL, 0LL, *(double *)a7.m128_u64, a8, a9, a10, v21, v22, a13, a14, 2);
return v23;
}
}
JS_FreeValue(a1, a15, a16);
JS_FreeValue(a1, a4, a5);
return 0LL;
}
| js_regexp_constructor_internal:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,R8
MOV R14,RCX
MOV RBX,RDI
LEA RAX,[RSP + 0x40]
MOV R12,qword ptr [RAX + 0x8]
MOV EAX,R12D
MOV ECX,0xfffffff9
XOR RAX,RCX
MOV EDI,R15D
XOR RDI,RCX
OR RDI,RAX
JZ 0x00137a41
LEA RSI,[0x1863b6]
MOV RDI,RBX
XOR EAX,EAX
CALL 0x0011c64d
JMP 0x00137a55
LAB_00137a41:
PUSH 0x12
POP RCX
MOV RDI,RBX
CALL 0x0013045a
MOV R13,RDX
CMP R13D,0x6
JNZ 0x00137a7e
LAB_00137a55:
LEA RAX,[RSP + 0x40]
MOV RSI,qword ptr [RAX]
MOV RDI,RBX
MOV RDX,R12
CALL 0x0011801e
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R15
CALL 0x0011801e
PUSH 0x6
POP R13
XOR EBP,EBP
JMP 0x00137aaf
LAB_00137a7e:
MOV RBP,RAX
MOV qword ptr [RAX + 0x30],R14
LEA RAX,[RSP + 0x40]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + 0x38],RAX
MOV dword ptr [RSP],0x2
PUSH 0x56
POP RCX
MOV RDI,RBX
MOV RSI,RBP
MOV RDX,R13
XOR R8D,R8D
XOR R9D,R9D
CALL 0x00120872
LAB_00137aaf:
MOV RAX,RBP
MOV RDX,R13
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int1 [16]
js_regexp_constructor_internal
(int8 param_1,int8 param_2,int8 param_3,int8 param_4,ulong param_5
,int8 param_6,int8 param_7,ulong param_8)
{
int8 in_RAX;
int4 uVar2;
long lVar1;
int1 auVar3 [16];
uVar2 = (int4)((ulong)in_RAX >> 0x20);
if ((param_5 & 0xffffffff) == 0xfffffff9 && (param_8 & 0xffffffff) == 0xfffffff9) {
auVar3 = js_create_from_ctor(param_1,param_2,param_3,0x12);
lVar1 = auVar3._0_8_;
if (auVar3._8_4_ != 6) {
*(int8 *)(lVar1 + 0x30) = param_4;
*(int8 *)(lVar1 + 0x38) = param_7;
JS_DefinePropertyValue(param_1,lVar1,auVar3._8_8_,0x56,0,0,CONCAT44(uVar2,2));
return auVar3;
}
}
else {
JS_ThrowTypeError(param_1,"string expected");
}
JS_FreeValue(param_1,param_7,param_8);
JS_FreeValue(param_1,param_4,param_5);
return ZEXT816(6) << 0x40;
}
| |
48,307 | escape_quotes_for_mysql | eloqsql/mysys/charset.c | size_t escape_quotes_for_mysql(CHARSET_INFO *charset_info,
char *to, size_t to_length,
const char *from, size_t length,
my_bool *overflow)
{
const char *to_start= to;
const char *end, *to_end=to_start + (to_length ? to_length-1 : 2*length);
#ifdef USE_MB
my_bool use_mb_flag= my_ci_use_mb(charset_info);
#endif
*overflow= FALSE;
for (end= from + length; from < end; from++)
{
#ifdef USE_MB
int tmp_length;
if (use_mb_flag && (tmp_length= my_ismbchar(charset_info, from, end)))
{
if (to + tmp_length > to_end)
{
*overflow= TRUE;
break;
}
while (tmp_length--)
*to++= *from++;
from--;
continue;
}
/*
We don't have the same issue here with a non-multi-byte character being
turned into a multi-byte character by the addition of an escaping
character, because we are only escaping the ' character with itself.
*/
#endif
if (*from == '\'')
{
if (to + 2 > to_end)
{
*overflow= TRUE;
break;
}
*to++= '\'';
*to++= '\'';
}
else
{
if (to + 1 > to_end)
{
*overflow= TRUE;
break;
}
*to++= *from;
}
}
*to= 0;
return (size_t) (to - to_start);
} | O3 | c | escape_quotes_for_mysql:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
leaq (%r8,%r8), %rax
subq $0x1, %r12
cmovbq %rax, %r12
movq %rdi, -0x40(%rbp)
movl 0x9c(%rdi), %r13d
movq %r9, -0x38(%rbp)
movb $0x0, (%r9)
movq %rsi, -0x30(%rbp)
movq %rsi, %rax
testq %r8, %r8
jle 0x29017
movq %r8, %r15
movq %rcx, %r14
movq -0x30(%rbp), %rbx
addq %rbx, %r12
addq %rcx, %r15
cmpl $0x2, %r13d
jb 0x28fb2
movq -0x40(%rbp), %rdi
movq 0xb8(%rdi), %rax
movq %r14, %rsi
movq %r15, %rdx
callq *0xc0(%rax)
cmpl $0x2, %eax
jge 0x28fd7
movb (%r14), %cl
cmpb $0x27, %cl
jne 0x28fca
leaq 0x2(%rbx), %rax
cmpq %r12, %rax
ja 0x2900d
movw $0x2727, (%rbx) # imm = 0x2727
jmp 0x29000
leaq 0x1(%rbx), %rax
cmpq %r12, %rax
ja 0x2900d
movb %cl, (%rbx)
jmp 0x29000
movl %eax, %ecx
movl %eax, %eax
addq %rbx, %rax
cmpq %r12, %rax
ja 0x2900d
decq %r14
movq %r14, %rdx
leaq 0x1(%rdx), %r14
leaq 0x1(%rbx), %rax
movb 0x1(%rdx), %dl
movb %dl, (%rbx)
movq %r14, %rdx
movq %rax, %rbx
decl %ecx
jne 0x28fe9
incq %r14
movq %rax, %rbx
cmpq %r15, %r14
jb 0x28f90
jmp 0x29017
movq -0x38(%rbp), %rax
movb $0x1, (%rax)
movq %rbx, %rax
movb $0x0, (%rax)
subq -0x30(%rbp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| escape_quotes_for_mysql:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r12, rdx
lea rax, [r8+r8]
sub r12, 1
cmovb r12, rax
mov [rbp+var_40], rdi
mov r13d, [rdi+9Ch]
mov [rbp+var_38], r9
mov byte ptr [r9], 0
mov [rbp+var_30], rsi
mov rax, rsi
test r8, r8
jle loc_29017
mov r15, r8
mov r14, rcx
mov rbx, [rbp+var_30]
add r12, rbx
add r15, rcx
loc_28F90:
cmp r13d, 2
jb short loc_28FB2
mov rdi, [rbp+var_40]
mov rax, [rdi+0B8h]
mov rsi, r14
mov rdx, r15
call qword ptr [rax+0C0h]
cmp eax, 2
jge short loc_28FD7
loc_28FB2:
mov cl, [r14]
cmp cl, 27h ; '''
jnz short loc_28FCA
lea rax, [rbx+2]
cmp rax, r12
ja short loc_2900D
mov word ptr [rbx], 2727h
jmp short loc_29000
loc_28FCA:
lea rax, [rbx+1]
cmp rax, r12
ja short loc_2900D
mov [rbx], cl
jmp short loc_29000
loc_28FD7:
mov ecx, eax
mov eax, eax
add rax, rbx
cmp rax, r12
ja short loc_2900D
dec r14
mov rdx, r14
loc_28FE9:
lea r14, [rdx+1]
lea rax, [rbx+1]
mov dl, [rdx+1]
mov [rbx], dl
mov rdx, r14
mov rbx, rax
dec ecx
jnz short loc_28FE9
loc_29000:
inc r14
mov rbx, rax
cmp r14, r15
jb short loc_28F90
jmp short loc_29017
loc_2900D:
mov rax, [rbp+var_38]
mov byte ptr [rax], 1
mov rax, rbx
loc_29017:
mov byte ptr [rax], 0
sub rax, [rbp+var_30]
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| _BYTE * escape_quotes_for_mysql(long long a1, _BYTE *a2, long long a3, _BYTE *a4, long long a5, _BYTE *a6)
{
long long v6; // r12
unsigned int v7; // r13d
_BYTE *v8; // rax
_BYTE *v9; // r14
_WORD *v10; // rbx
unsigned long long v11; // r12
unsigned long long v12; // r15
int v13; // eax
int v14; // ecx
_BYTE *v15; // rdx
v6 = a3 - 1;
if ( !a3 )
v6 = 2 * a5;
v7 = *(_DWORD *)(a1 + 156);
*a6 = 0;
v8 = a2;
if ( a5 > 0 )
{
v9 = a4;
v10 = a2;
v11 = (unsigned long long)&a2[v6];
v12 = (unsigned long long)&a4[a5];
do
{
if ( v7 >= 2
&& (v13 = (*(long long ( **)(long long, _BYTE *, unsigned long long))(*(_QWORD *)(a1 + 184) + 192LL))(
a1,
v9,
v12),
v13 >= 2) )
{
v14 = v13;
if ( (unsigned long long)v10 + (unsigned int)v13 > v11 )
{
LABEL_17:
*a6 = 1;
v8 = v10;
break;
}
v15 = v9 - 1;
do
{
v9 = v15 + 1;
v8 = (char *)v10 + 1;
*(_BYTE *)v10 = *++v15;
v10 = (_WORD *)((char *)v10 + 1);
--v14;
}
while ( v14 );
}
else if ( *v9 == 39 )
{
v8 = v10 + 1;
if ( (unsigned long long)(v10 + 1) > v11 )
goto LABEL_17;
*v10 = 10023;
}
else
{
v8 = (char *)v10 + 1;
if ( (unsigned long long)v10 + 1 > v11 )
goto LABEL_17;
*(_BYTE *)v10 = *v9;
}
++v9;
v10 = v8;
}
while ( (unsigned long long)v9 < v12 );
}
*v8 = 0;
return (_BYTE *)(v8 - a2);
}
| escape_quotes_for_mysql:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R12,RDX
LEA RAX,[R8 + R8*0x1]
SUB R12,0x1
CMOVC R12,RAX
MOV qword ptr [RBP + -0x40],RDI
MOV R13D,dword ptr [RDI + 0x9c]
MOV qword ptr [RBP + -0x38],R9
MOV byte ptr [R9],0x0
MOV qword ptr [RBP + -0x30],RSI
MOV RAX,RSI
TEST R8,R8
JLE 0x00129017
MOV R15,R8
MOV R14,RCX
MOV RBX,qword ptr [RBP + -0x30]
ADD R12,RBX
ADD R15,RCX
LAB_00128f90:
CMP R13D,0x2
JC 0x00128fb2
MOV RDI,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RDI + 0xb8]
MOV RSI,R14
MOV RDX,R15
CALL qword ptr [RAX + 0xc0]
CMP EAX,0x2
JGE 0x00128fd7
LAB_00128fb2:
MOV CL,byte ptr [R14]
CMP CL,0x27
JNZ 0x00128fca
LEA RAX,[RBX + 0x2]
CMP RAX,R12
JA 0x0012900d
MOV word ptr [RBX],0x2727
JMP 0x00129000
LAB_00128fca:
LEA RAX,[RBX + 0x1]
CMP RAX,R12
JA 0x0012900d
MOV byte ptr [RBX],CL
JMP 0x00129000
LAB_00128fd7:
MOV ECX,EAX
MOV EAX,EAX
ADD RAX,RBX
CMP RAX,R12
JA 0x0012900d
DEC R14
MOV RDX,R14
LAB_00128fe9:
LEA R14,[RDX + 0x1]
LEA RAX,[RBX + 0x1]
MOV DL,byte ptr [RDX + 0x1]
MOV byte ptr [RBX],DL
MOV RDX,R14
MOV RBX,RAX
DEC ECX
JNZ 0x00128fe9
LAB_00129000:
INC R14
MOV RBX,RAX
CMP R14,R15
JC 0x00128f90
JMP 0x00129017
LAB_0012900d:
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX],0x1
MOV RAX,RBX
LAB_00129017:
MOV byte ptr [RAX],0x0
SUB RAX,qword ptr [RBP + -0x30]
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long escape_quotes_for_mysql
(long param_1,char *param_2,long param_3,char *param_4,long param_5,
int1 *param_6)
{
uint uVar1;
uint uVar2;
char *pcVar3;
char *pcVar4;
char *pcVar5;
long lVar6;
char *pcVar7;
char *pcVar8;
lVar6 = param_3 + -1;
if (param_3 == 0) {
lVar6 = param_5 * 2;
}
uVar1 = *(uint *)(param_1 + 0x9c);
*param_6 = 0;
pcVar3 = param_2;
if (0 < param_5) {
pcVar7 = param_2 + lVar6;
pcVar8 = param_4 + param_5;
pcVar5 = param_2;
do {
if ((uVar1 < 2) ||
(uVar2 = (**(code **)(*(long *)(param_1 + 0xb8) + 0xc0))(param_1,param_4,pcVar8),
(int)uVar2 < 2)) {
if (*param_4 == '\'') {
pcVar3 = pcVar5 + 2;
if (pcVar7 < pcVar3) {
LAB_0012900d:
*param_6 = 1;
pcVar3 = pcVar5;
break;
}
pcVar5[0] = '\'';
pcVar5[1] = '\'';
}
else {
pcVar3 = pcVar5 + 1;
if (pcVar7 < pcVar3) goto LAB_0012900d;
*pcVar5 = *param_4;
}
}
else {
if (pcVar7 < pcVar5 + uVar2) goto LAB_0012900d;
pcVar4 = param_4 + -1;
do {
param_4 = pcVar4 + 1;
pcVar3 = pcVar5 + 1;
*pcVar5 = pcVar4[1];
uVar2 = uVar2 - 1;
pcVar4 = param_4;
pcVar5 = pcVar3;
} while (uVar2 != 0);
}
param_4 = param_4 + 1;
pcVar5 = pcVar3;
} while (param_4 < pcVar8);
}
*pcVar3 = '\0';
return (long)pcVar3 - (long)param_2;
}
| |
48,308 | maria_rtree_find_next | eloqsql/storage/maria/ma_rt_index.c | int maria_rtree_find_next(MARIA_HA *info, uint keynr, uint32 search_flag)
{
my_off_t root;
uint32 nod_cmp_flag;
MARIA_KEYDEF *keyinfo= info->s->keyinfo + keynr;
DBUG_ASSERT(info->last_key.keyinfo == keyinfo);
/*
At the moment index can only properly handle the
MBR_INTERSECT, so we use it for all sorts of queries.
TODO: better searsh for CONTAINS/WITHIN.
*/
search_flag= nod_cmp_flag= MBR_INTERSECT;
if (info->update & HA_STATE_DELETED)
return maria_rtree_find_first(info, &info->last_key, search_flag);
if (!info->keyread_buff_used)
{
uchar *key= info->int_keypos;
while (key < info->int_maxpos)
{
if (!maria_rtree_key_cmp(keyinfo->seg,
info->first_mbr_key, key,
info->last_rkey_length, search_flag))
{
uchar *after_key= key + keyinfo->keylength;
MARIA_KEY tmp_key;
/*
We don't need to set all MARIA_KEY elements here as
_ma_row_pos_from_key only uses a few of them.
*/
tmp_key.keyinfo= keyinfo;
tmp_key.data= key;
tmp_key.data_length= keyinfo->keylength - info->s->base.rec_reflength;
info->cur_row.lastpos= _ma_row_pos_from_key(&tmp_key);
memcpy(info->last_key.data, key, info->last_key.data_length);
if (after_key < info->int_maxpos)
info->int_keypos= after_key;
else
info->keyread_buff_used= 1;
return 0;
}
key+= keyinfo->keylength;
}
}
if ((root= info->s->state.key_root[keynr]) == HA_OFFSET_ERROR)
{
my_errno= HA_ERR_END_OF_FILE;
return -1;
}
/*
TODO better search for CONTAINS/WITHIN.
nod_cmp_flag= (((search_flag & (MBR_EQUAL | MBR_WITHIN)) ?
MBR_WITHIN : MBR_INTERSECT));
*/
return maria_rtree_find_req(info, keyinfo, search_flag, nod_cmp_flag, root,
0);
} | O0 | c | maria_rtree_find_next:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x570(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0x118, %rcx, %rcx # imm = 0x118
addq %rcx, %rax
movq %rax, -0x30(%rbp)
jmp 0x8d063
movl $0x400, -0x24(%rbp) # imm = 0x400
movl $0x400, -0x18(%rbp) # imm = 0x400
movq -0x10(%rbp), %rax
movl 0x624(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x8d0a2
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x200, %rsi # imm = 0x200
movl -0x18(%rbp), %edx
callq 0x8c9c0
movl %eax, -0x4(%rbp)
jmp 0x8d22e
movq -0x10(%rbp), %rax
cmpb $0x0, 0x685(%rax)
jne 0x8d1de
movq -0x10(%rbp), %rax
movq 0x3b0(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x3b8(%rcx), %rax
jae 0x8d1dc
movq -0x30(%rbp), %rax
movq 0xc0(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x398(%rax), %rsi
movq -0x38(%rbp), %rdx
movq -0x10(%rbp), %rax
movl 0x630(%rax), %ecx
movl -0x18(%rbp), %r8d
callq 0x8feb0
cmpl $0x0, %eax
jne 0x8d1be
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movzwl 0xaa(%rcx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x30(%rbp), %rax
movzwl 0xaa(%rax), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
subl 0x3e0(%rcx), %eax
movl %eax, -0x50(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x6a620
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x98(%rax)
movq -0x10(%rbp), %rax
movq 0x200(%rax), %rdi
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x210(%rax), %eax
movl %eax, %edx
callq 0x2a0a0
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x3b8(%rcx), %rax
jae 0x8d1aa
movq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x3b0(%rax)
jmp 0x8d1b5
movq -0x10(%rbp), %rax
movb $0x1, 0x685(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x8d22e
movq -0x30(%rbp), %rax
movzwl 0xaa(%rax), %ecx
movq -0x38(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
jmp 0x8d0c2
jmp 0x8d1de
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x118(%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $-0x1, %rax
jne 0x8d211
callq 0xf55f0
movl $0x89, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8d22e
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x18(%rbp), %edx
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %r8
xorl %r9d, %r9d
callq 0x8cab0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| maria_rtree_find_next:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+570h]
mov ecx, [rbp+var_14]
imul rcx, 118h
add rax, rcx
mov [rbp+var_30], rax
jmp short $+2
loc_8D063:
mov [rbp+var_24], 400h
mov [rbp+var_18], 400h
mov rax, [rbp+var_10]
mov eax, [rax+624h]
and eax, 8
cmp eax, 0
jz short loc_8D0A2
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_10]
add rsi, 200h
mov edx, [rbp+var_18]
call maria_rtree_find_first
mov [rbp+var_4], eax
jmp loc_8D22E
loc_8D0A2:
mov rax, [rbp+var_10]
cmp byte ptr [rax+685h], 0
jnz loc_8D1DE
mov rax, [rbp+var_10]
mov rax, [rax+3B0h]
mov [rbp+var_38], rax
loc_8D0C2:
mov rax, [rbp+var_38]
mov rcx, [rbp+var_10]
cmp rax, [rcx+3B8h]
jnb loc_8D1DC
mov rax, [rbp+var_30]
mov rdi, [rax+0C0h]
mov rax, [rbp+var_10]
mov rsi, [rax+398h]
mov rdx, [rbp+var_38]
mov rax, [rbp+var_10]
mov ecx, [rax+630h]
mov r8d, [rbp+var_18]
call maria_rtree_key_cmp
cmp eax, 0
jnz loc_8D1BE
mov rax, [rbp+var_38]
mov rcx, [rbp+var_30]
movzx ecx, word ptr [rcx+0AAh]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_40], rax
mov rax, [rbp+var_30]
mov [rbp+var_58], rax
mov rax, [rbp+var_38]
mov [rbp+var_60], rax
mov rax, [rbp+var_30]
movzx eax, word ptr [rax+0AAh]
mov rcx, [rbp+var_10]
mov rcx, [rcx]
sub eax, [rcx+3E0h]
mov [rbp+var_50], eax
lea rdi, [rbp+var_60]
call _ma_row_pos_from_key
mov rcx, rax
mov rax, [rbp+var_10]
mov [rax+98h], rcx
mov rax, [rbp+var_10]
mov rdi, [rax+200h]
mov rsi, [rbp+var_38]
mov rax, [rbp+var_10]
mov eax, [rax+210h]
mov edx, eax
call _memcpy
mov rax, [rbp+var_40]
mov rcx, [rbp+var_10]
cmp rax, [rcx+3B8h]
jnb short loc_8D1AA
mov rcx, [rbp+var_40]
mov rax, [rbp+var_10]
mov [rax+3B0h], rcx
jmp short loc_8D1B5
loc_8D1AA:
mov rax, [rbp+var_10]
mov byte ptr [rax+685h], 1
loc_8D1B5:
mov [rbp+var_4], 0
jmp short loc_8D22E
loc_8D1BE:
mov rax, [rbp+var_30]
movzx ecx, word ptr [rax+0AAh]
mov rax, [rbp+var_38]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_38], rax
jmp loc_8D0C2
loc_8D1DC:
jmp short $+2
loc_8D1DE:
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+118h]
mov ecx, [rbp+var_14]
mov rax, [rax+rcx*8]
mov [rbp+var_20], rax
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_8D211
call _my_thread_var
mov dword ptr [rax], 89h
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_8D22E
loc_8D211:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_30]
mov edx, [rbp+var_18]
mov ecx, [rbp+var_24]
mov r8, [rbp+var_20]
xor r9d, r9d
call maria_rtree_find_req
mov [rbp+var_4], eax
loc_8D22E:
mov eax, [rbp+var_4]
add rsp, 60h
pop rbp
retn
| long long maria_rtree_find_next(_DWORD *a1, unsigned int a2, unsigned int a3, double a4)
{
long long v4; // rax
_QWORD v6[2]; // [rsp+0h] [rbp-60h] BYREF
int v7; // [rsp+10h] [rbp-50h]
unsigned long long v8; // [rsp+20h] [rbp-40h]
unsigned long long i; // [rsp+28h] [rbp-38h]
long long v10; // [rsp+30h] [rbp-30h]
unsigned int v11; // [rsp+3Ch] [rbp-24h]
unsigned long long v12; // [rsp+40h] [rbp-20h]
unsigned int v13; // [rsp+48h] [rbp-18h]
unsigned int v14; // [rsp+4Ch] [rbp-14h]
_DWORD *v15; // [rsp+50h] [rbp-10h]
v15 = a1;
v14 = a2;
v13 = a3;
v10 = 280LL * a2 + *(_QWORD *)(*(_QWORD *)a1 + 1392LL);
v11 = 1024;
v13 = 1024;
if ( (a1[393] & 8) != 0 )
{
return (unsigned int)maria_rtree_find_first((long long)v15, (long long)(v15 + 128), a4);
}
else
{
if ( !*((_BYTE *)v15 + 1669) )
{
for ( i = *((_QWORD *)v15 + 118); i < *((_QWORD *)v15 + 119); i += *(unsigned __int16 *)(v10 + 170) )
{
if ( !(unsigned int)maria_rtree_key_cmp(
*(_QWORD *)(v10 + 192),
*((_QWORD *)v15 + 115),
i,
(unsigned int)v15[396],
v13) )
{
v8 = *(unsigned __int16 *)(v10 + 170) + i;
v6[1] = v10;
v6[0] = i;
v7 = *(unsigned __int16 *)(v10 + 170) - *(_DWORD *)(*(_QWORD *)v15 + 992LL);
v4 = ma_row_pos_from_key((long long)v6);
*((_QWORD *)v15 + 19) = v4;
memcpy(*((_QWORD *)v15 + 64), i, (unsigned int)v15[132]);
if ( v8 >= *((_QWORD *)v15 + 119) )
*((_BYTE *)v15 + 1669) = 1;
else
*((_QWORD *)v15 + 118) = v8;
return 0;
}
}
}
v12 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)v15 + 280LL) + 8LL * v14);
if ( v12 == -1LL )
{
*(_DWORD *)my_thread_var(a4) = 137;
return (unsigned int)-1;
}
else
{
return (unsigned int)maria_rtree_find_req((long long)v15, v10, v13, v11, v12, 0, a4);
}
}
}
| maria_rtree_find_next:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x570]
MOV ECX,dword ptr [RBP + -0x14]
IMUL RCX,RCX,0x118
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
JMP 0x0018d063
LAB_0018d063:
MOV dword ptr [RBP + -0x24],0x400
MOV dword ptr [RBP + -0x18],0x400
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x624]
AND EAX,0x8
CMP EAX,0x0
JZ 0x0018d0a2
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x200
MOV EDX,dword ptr [RBP + -0x18]
CALL 0x0018c9c0
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0018d22e
LAB_0018d0a2:
MOV RAX,qword ptr [RBP + -0x10]
CMP byte ptr [RAX + 0x685],0x0
JNZ 0x0018d1de
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x3b0]
MOV qword ptr [RBP + -0x38],RAX
LAB_0018d0c2:
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x3b8]
JNC 0x0018d1dc
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,qword ptr [RAX + 0xc0]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x398]
MOV RDX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x630]
MOV R8D,dword ptr [RBP + -0x18]
CALL 0x0018feb0
CMP EAX,0x0
JNZ 0x0018d1be
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x30]
MOVZX ECX,word ptr [RCX + 0xaa]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,word ptr [RAX + 0xaa]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX]
SUB EAX,dword ptr [RCX + 0x3e0]
MOV dword ptr [RBP + -0x50],EAX
LEA RDI,[RBP + -0x60]
CALL 0x0016a620
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x98],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x200]
MOV RSI,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x210]
MOV EDX,EAX
CALL 0x0012a0a0
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x3b8]
JNC 0x0018d1aa
MOV RCX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x3b0],RCX
JMP 0x0018d1b5
LAB_0018d1aa:
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x685],0x1
LAB_0018d1b5:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0018d22e
LAB_0018d1be:
MOV RAX,qword ptr [RBP + -0x30]
MOVZX ECX,word ptr [RAX + 0xaa]
MOV RAX,qword ptr [RBP + -0x38]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x38],RAX
JMP 0x0018d0c2
LAB_0018d1dc:
JMP 0x0018d1de
LAB_0018d1de:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x118]
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,-0x1
JNZ 0x0018d211
CALL 0x001f55f0
MOV dword ptr [RAX],0x89
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x0018d22e
LAB_0018d211:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x30]
MOV EDX,dword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x24]
MOV R8,qword ptr [RBP + -0x20]
XOR R9D,R9D
CALL 0x0018cab0
MOV dword ptr [RBP + -0x4],EAX
LAB_0018d22e:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x60
POP RBP
RET
|
int4 maria_rtree_find_next(long *param_1,uint param_2)
{
int iVar1;
long lVar2;
int4 *puVar3;
void *local_68;
long local_60;
int local_58;
ulong local_48;
void *local_40;
long local_38;
int4 local_2c;
long local_28;
int4 local_20;
uint local_1c;
long *local_18;
int4 local_c;
local_38 = *(long *)(*param_1 + 0x570) + (ulong)param_2 * 0x118;
local_2c = 0x400;
local_20 = 0x400;
local_1c = param_2;
local_18 = param_1;
if ((*(uint *)((long)param_1 + 0x624) & 8) == 0) {
if (*(char *)((long)param_1 + 0x685) == '\0') {
for (local_40 = (void *)param_1[0x76]; local_40 < (void *)local_18[0x77];
local_40 = (void *)((long)local_40 + (long)(int)(uint)*(ushort *)(local_38 + 0xaa))) {
iVar1 = maria_rtree_key_cmp(*(int8 *)(local_38 + 0xc0),local_18[0x73],local_40,
(int)local_18[0xc6],local_20);
if (iVar1 == 0) {
local_48 = (long)local_40 + (long)(int)(uint)*(ushort *)(local_38 + 0xaa);
local_60 = local_38;
local_68 = local_40;
local_58 = (uint)*(ushort *)(local_38 + 0xaa) - *(int *)(*local_18 + 0x3e0);
lVar2 = _ma_row_pos_from_key(&local_68);
local_18[0x13] = lVar2;
memcpy((void *)local_18[0x40],local_40,(ulong)*(uint *)(local_18 + 0x42));
if (local_48 < (ulong)local_18[0x77]) {
local_18[0x76] = local_48;
}
else {
*(int1 *)((long)local_18 + 0x685) = 1;
}
return 0;
}
}
}
local_28 = *(long *)(*(long *)(*local_18 + 0x118) + (ulong)local_1c * 8);
if (local_28 == -1) {
puVar3 = (int4 *)_my_thread_var();
*puVar3 = 0x89;
local_c = 0xffffffff;
}
else {
local_c = maria_rtree_find_req(local_18,local_38,local_20,local_2c,local_28,0);
}
}
else {
local_c = maria_rtree_find_first(param_1,param_1 + 0x40,0x400);
}
return local_c;
}
| |
48,309 | check_variable | eloqsql/libmariadb/unittest/libmariadb/my_test.h | int check_variable(MYSQL *mysql, const char *variable, const char *value)
{
char query[MAX_TEST_QUERY_LENGTH];
MYSQL_RES *result;
MYSQL_ROW row;
sprintf(query, "SELECT %s", variable);
result= mysql_store_result(mysql);
if (!result)
return FAIL;
if ((row = mysql_fetch_row(result)))
if (strcmp(row[0], value) == 0) {
mysql_free_result(result);
return OK;
}
mysql_free_result(result);
return FAIL;
} | O0 | c | check_variable:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x150(%rbp)
movq %rsi, -0x158(%rbp)
movq %rdx, -0x160(%rbp)
leaq -0x140(%rbp), %rdi
movq -0x158(%rbp), %rdx
leaq 0x3a10b(%rip), %rsi # 0x4e28d
movb $0x0, %al
callq 0x130f0
movq -0x150(%rbp), %rdi
callq 0x24570
movq %rax, -0x168(%rbp)
cmpq $0x0, -0x168(%rbp)
jne 0x141b2
movl $0x1, -0x144(%rbp)
jmp 0x14216
movq -0x168(%rbp), %rdi
callq 0x248b0
movq %rax, -0x170(%rbp)
cmpq $0x0, %rax
je 0x14200
movq -0x170(%rbp), %rax
movq (%rax), %rdi
movq -0x160(%rbp), %rsi
callq 0x135f0
cmpl $0x0, %eax
jne 0x141fe
movq -0x168(%rbp), %rdi
callq 0x1bdb0
movl $0x0, -0x144(%rbp)
jmp 0x14216
jmp 0x14200
movq -0x168(%rbp), %rdi
callq 0x1bdb0
movl $0x1, -0x144(%rbp)
movl -0x144(%rbp), %eax
movl %eax, -0x174(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x14243
movl -0x174(%rbp), %eax
addq $0x180, %rsp # imm = 0x180
popq %rbp
retq
callq 0x134b0
nopl (%rax,%rax)
| check_variable:
push rbp
mov rbp, rsp
sub rsp, 180h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_150], rdi
mov [rbp+var_158], rsi
mov [rbp+var_160], rdx
lea rdi, [rbp+var_140]
mov rdx, [rbp+var_158]
lea rsi, aSelectS; "SELECT %s"
mov al, 0
call _sprintf
mov rdi, [rbp+var_150]
call mysql_store_result
mov [rbp+var_168], rax
cmp [rbp+var_168], 0
jnz short loc_141B2
mov [rbp+var_144], 1
jmp short loc_14216
loc_141B2:
mov rdi, [rbp+var_168]
call mysql_fetch_row
mov [rbp+var_170], rax
cmp rax, 0
jz short loc_14200
mov rax, [rbp+var_170]
mov rdi, [rax]
mov rsi, [rbp+var_160]
call _strcmp
cmp eax, 0
jnz short loc_141FE
mov rdi, [rbp+var_168]
call mysql_free_result
mov [rbp+var_144], 0
jmp short loc_14216
loc_141FE:
jmp short $+2
loc_14200:
mov rdi, [rbp+var_168]
call mysql_free_result
mov [rbp+var_144], 1
loc_14216:
mov eax, [rbp+var_144]
mov [rbp+var_174], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_14243
mov eax, [rbp+var_174]
add rsp, 180h
pop rbp
retn
loc_14243:
call ___stack_chk_fail
| long long check_variable(long long a1, const char *a2, long long a3)
{
_QWORD *row; // [rsp+10h] [rbp-170h]
long long v5; // [rsp+18h] [rbp-168h]
_BYTE v8[312]; // [rsp+40h] [rbp-140h] BYREF
unsigned long long v9; // [rsp+178h] [rbp-8h]
v9 = __readfsqword(0x28u);
sprintf(v8, "SELECT %s", a2);
v5 = mysql_store_result(a1);
if ( v5 )
{
row = (_QWORD *)mysql_fetch_row(v5);
if ( row && !(unsigned int)strcmp(*row, a3) )
{
mysql_free_result(v5);
return 0;
}
else
{
mysql_free_result(v5);
return 1;
}
}
else
{
return 1;
}
}
| check_variable:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x180
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x150],RDI
MOV qword ptr [RBP + -0x158],RSI
MOV qword ptr [RBP + -0x160],RDX
LEA RDI,[RBP + -0x140]
MOV RDX,qword ptr [RBP + -0x158]
LEA RSI,[0x14e28d]
MOV AL,0x0
CALL 0x001130f0
MOV RDI,qword ptr [RBP + -0x150]
CALL 0x00124570
MOV qword ptr [RBP + -0x168],RAX
CMP qword ptr [RBP + -0x168],0x0
JNZ 0x001141b2
MOV dword ptr [RBP + -0x144],0x1
JMP 0x00114216
LAB_001141b2:
MOV RDI,qword ptr [RBP + -0x168]
CALL 0x001248b0
MOV qword ptr [RBP + -0x170],RAX
CMP RAX,0x0
JZ 0x00114200
MOV RAX,qword ptr [RBP + -0x170]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x160]
CALL 0x001135f0
CMP EAX,0x0
JNZ 0x001141fe
MOV RDI,qword ptr [RBP + -0x168]
CALL 0x0011bdb0
MOV dword ptr [RBP + -0x144],0x0
JMP 0x00114216
LAB_001141fe:
JMP 0x00114200
LAB_00114200:
MOV RDI,qword ptr [RBP + -0x168]
CALL 0x0011bdb0
MOV dword ptr [RBP + -0x144],0x1
LAB_00114216:
MOV EAX,dword ptr [RBP + -0x144]
MOV dword ptr [RBP + -0x174],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00114243
MOV EAX,dword ptr [RBP + -0x174]
ADD RSP,0x180
POP RBP
RET
LAB_00114243:
CALL 0x001134b0
|
int4 check_variable(int8 param_1,int8 param_2,char *param_3)
{
int iVar1;
long lVar2;
int8 *puVar3;
long in_FS_OFFSET;
int4 local_14c;
char local_148 [312];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
sprintf(local_148,"SELECT %s",param_2);
lVar2 = mysql_store_result(param_1);
if (lVar2 == 0) {
local_14c = 1;
}
else {
puVar3 = (int8 *)mysql_fetch_row(lVar2);
if ((puVar3 == (int8 *)0x0) || (iVar1 = strcmp((char *)*puVar3,param_3), iVar1 != 0)) {
mysql_free_result(lVar2);
local_14c = 1;
}
else {
mysql_free_result(lVar2);
local_14c = 0;
}
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_14c;
}
| |
48,310 | stop_waiting_locked | eloqsql/mysys/waiting_threads.c | static int stop_waiting_locked(WT_THD *thd)
{
int ret;
WT_RESOURCE *rc= thd->waiting_for;
DBUG_ENTER("stop_waiting_locked");
DBUG_ASSERT(rc->waiter_count);
DBUG_ASSERT(rc->state == ACTIVE);
rc->waiter_count--;
thd->waiting_for= 0;
ret= unlock_lock_and_free_resource(thd, rc);
DBUG_RETURN((thd->killed || ret) ? WT_DEADLOCK : WT_OK);
} | O3 | c | stop_waiting_locked:
pushq %rbp
movq %rsp, %rbp
movq 0x28(%rdi), %rsi
decl 0x10(%rsi)
movq $0x0, 0x28(%rdi)
popq %rbp
jmp 0xa725d
| stop_waiting_locked:
push rbp
mov rbp, rsp
mov rsi, [rdi+28h]
dec dword ptr [rsi+10h]
mov qword ptr [rdi+28h], 0
pop rbp
jmp unlock_lock_and_free_resource
| long long stop_waiting_locked(long long a1)
{
--*(_DWORD *)(*(_QWORD *)(a1 + 40) + 16LL);
*(_QWORD *)(a1 + 40) = 0LL;
return unlock_lock_and_free_resource(a1);
}
| stop_waiting_locked:
PUSH RBP
MOV RBP,RSP
MOV RSI,qword ptr [RDI + 0x28]
DEC dword ptr [RSI + 0x10]
MOV qword ptr [RDI + 0x28],0x0
POP RBP
JMP 0x001a725d
|
void stop_waiting_locked(long param_1)
{
int *piVar1;
piVar1 = (int *)(*(long *)(param_1 + 0x28) + 0x10);
*piVar1 = *piVar1 + -1;
*(int8 *)(param_1 + 0x28) = 0;
unlock_lock_and_free_resource();
return;
}
| |
48,311 | ftxui::(anonymous namespace)::InputBase::HandleCharacter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Andrewchistyakov[P]flashcards_lyc/build_O1/_deps/ftxui-src/src/ftxui/component/input.cpp | bool HandleCharacter(const std::string& character) {
content->insert(cursor_position(), character);
cursor_position() += character.size();
on_change();
return true;
} | O1 | cpp | ftxui::(anonymous namespace)::InputBase::HandleCharacter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r12
addq $0x28, %rdi
callq 0x2c944
movq %rax, %r14
leaq 0xf8(%r12), %r15
movq %r15, %rdi
callq 0x2cdc2
movslq (%rax), %rsi
movq (%rbx), %rcx
movq 0x8(%rbx), %r8
movq %r14, %rdi
xorl %edx, %edx
callq 0xb470
movl 0x8(%rbx), %ebx
movq %r15, %rdi
callq 0x2cdc2
addl %ebx, (%rax)
cmpq $0x0, 0xc8(%r12)
je 0x2bf94
movq %r12, %rax
leaq 0xb8(%r12), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *0xd0(%rax)
callq 0xb140
nop
| _ZN5ftxui12_GLOBAL__N_19InputBase15HandleCharacterERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r15
push r14
push r12
push rbx
push rax
mov rbx, rsi
mov r12, rdi
add rdi, 28h ; '('
call _ZN5ftxui3RefINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE7AddressEv; ftxui::Ref<std::string>::Address(void)
mov r14, rax
lea r15, [r12+0F8h]
mov rdi, r15
call _ZN5ftxui3RefIiE7AddressEv; ftxui::Ref<int>::Address(void)
movsxd rsi, dword ptr [rax]
mov rcx, [rbx]
mov r8, [rbx+8]
mov rdi, r14
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7replaceEmmPKcm; std::string::replace(ulong,ulong,char const*,ulong)
mov ebx, [rbx+8]
mov rdi, r15
call _ZN5ftxui3RefIiE7AddressEv; ftxui::Ref<int>::Address(void)
add [rax], ebx
cmp qword ptr [r12+0C8h], 0
jz short loc_2BF94
mov rax, r12
lea rdi, [r12+0B8h]
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
jmp qword ptr [rax+0D0h]
loc_2BF94:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
| long long ftxui::`anonymous namespace'::InputBase::HandleCharacter(long long a1, long long a2)
{
long long v2; // r14
int *v3; // rax
int v4; // ebx
_DWORD *v5; // rax
v2 = ftxui::Ref<std::string>::Address(a1 + 40);
v3 = (int *)ftxui::Ref<int>::Address(a1 + 248);
std::string::replace(v2, *v3, 0LL);
v4 = *(_DWORD *)(a2 + 8);
v5 = (_DWORD *)ftxui::Ref<int>::Address(a1 + 248);
*v5 += v4;
if ( !*(_QWORD *)(a1 + 200) )
std::__throw_bad_function_call();
return (*(long long ( **)(long long))(a1 + 208))(a1 + 184);
}
| HandleCharacter:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R12,RDI
ADD RDI,0x28
CALL 0x0012c944
MOV R14,RAX
LEA R15,[R12 + 0xf8]
MOV RDI,R15
CALL 0x0012cdc2
MOVSXD RSI,dword ptr [RAX]
MOV RCX,qword ptr [RBX]
MOV R8,qword ptr [RBX + 0x8]
MOV RDI,R14
XOR EDX,EDX
CALL 0x0010b470
MOV EBX,dword ptr [RBX + 0x8]
MOV RDI,R15
CALL 0x0012cdc2
ADD dword ptr [RAX],EBX
CMP qword ptr [R12 + 0xc8],0x0
JZ 0x0012bf94
MOV RAX,R12
LEA RDI,[R12 + 0xb8]
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
JMP qword ptr [RAX + 0xd0]
LAB_0012bf94:
CALL 0x0010b140
|
/* ftxui::(anonymous namespace)::InputBase::HandleCharacter(std::__cxx11::string const&) */
void __thiscall
ftxui::(anonymous_namespace)::InputBase::HandleCharacter(InputBase *this,string *param_1)
{
int iVar1;
ulong uVar2;
int *piVar3;
uVar2 = Ref<std::__cxx11::string>::Address((Ref<std::__cxx11::string> *)(this + 0x28));
piVar3 = (int *)Ref<int>::Address((Ref<int> *)(this + 0xf8));
std::__cxx11::string::replace(uVar2,(long)*piVar3,(char *)0x0,*(ulong *)param_1);
iVar1 = *(int *)(param_1 + 8);
piVar3 = (int *)Ref<int>::Address((Ref<int> *)(this + 0xf8));
*piVar3 = *piVar3 + iVar1;
if (*(long *)(this + 200) != 0) {
/* WARNING: Could not recover jumptable at 0x0012bf8e. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(this + 0xd0))(this + 0xb8);
return;
}
/* WARNING: Subroutine does not return */
std::__throw_bad_function_call();
}
| |
48,312 | nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::unget() | monkey531[P]llama/common/json.hpp | void unget()
{
next_unget = true;
--position.chars_read_total;
// in case we "unget" a newline, we have to also decrement the lines_read
if (position.chars_read_current_line == 0)
{
if (position.lines_read > 0)
{
--position.lines_read;
}
}
else
{
--position.chars_read_current_line;
}
if (JSON_HEDLEY_LIKELY(current != char_traits<char_type>::eof()))
{
JSON_ASSERT(!token_string.empty());
token_string.pop_back();
}
} | O0 | cpp | nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::unget():
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movb $0x1, 0x18(%rax)
movq 0x20(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x20(%rax)
cmpq $0x0, 0x28(%rax)
jne 0xa4729
movq 0x8(%rsp), %rax
cmpq $0x0, 0x30(%rax)
jbe 0xa4727
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x30(%rax)
jmp 0xa473a
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x28(%rax)
movq 0x8(%rsp), %rax
movl 0x14(%rax), %eax
movl %eax, 0x4(%rsp)
callq 0x9e7d0
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xa4760
jmp 0xa47a3
movq 0x8(%rsp), %rdi
addq $0x38, %rdi
callq 0xa5220
testb $0x1, %al
jne 0xa4774
jmp 0xa4795
leaq 0x168e63(%rip), %rdi # 0x20d5de
movl $0x2240, %esi # imm = 0x2240
leaq 0x162a52(%rip), %rdx # 0x2071d9
leaq 0x169024(%rip), %rcx # 0x20d7b2
movb $0x0, %al
callq 0x5aef0
movq 0x8(%rsp), %rdi
addq $0x38, %rdi
callq 0xa5270
addq $0x18, %rsp
retq
nopl (%rax,%rax)
| _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE5ungetEv:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov rax, [rsp+18h+var_8]
mov [rsp+18h+var_10], rax
mov byte ptr [rax+18h], 1
mov rcx, [rax+20h]
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rax+20h], rcx
cmp qword ptr [rax+28h], 0
jnz short loc_A4729
mov rax, [rsp+18h+var_10]
cmp qword ptr [rax+30h], 0
jbe short loc_A4727
mov rax, [rsp+18h+var_10]
mov rcx, [rax+30h]
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rax+30h], rcx
loc_A4727:
jmp short loc_A473A
loc_A4729:
mov rax, [rsp+18h+var_10]
mov rcx, [rax+28h]
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rax+28h], rcx
loc_A473A:
mov rax, [rsp+18h+var_10]
mov eax, [rax+14h]
mov [rsp+18h+var_14], eax
call _ZNSt11char_traitsIcE3eofEv; std::char_traits<char>::eof(void)
mov ecx, eax
mov eax, [rsp+18h+var_14]
cmp eax, ecx
setnz al
xor al, 0FFh
xor al, 0FFh
test al, 1
jnz short loc_A4760
jmp short loc_A47A3
loc_A4760:
mov rdi, [rsp+18h+var_10]
add rdi, 38h ; '8'
call _ZNKSt6vectorIcSaIcEE5emptyEv; std::vector<char>::empty(void)
test al, 1
jnz short loc_A4774
jmp short loc_A4795
loc_A4774:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
mov esi, 2240h
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aTokenStringEmp; "!token_string.empty()"
mov al, 0
call _ggml_abort
loc_A4795:
mov rdi, [rsp+18h+var_10]
add rdi, 38h ; '8'
call _ZNSt6vectorIcSaIcEE8pop_backEv; std::vector<char>::pop_back(void)
loc_A47A3:
add rsp, 18h
retn
| char nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::unget(
long long a1)
{
int v1; // ecx
char result; // al
int v3; // [rsp+4h] [rbp-14h]
*(_BYTE *)(a1 + 24) = 1;
--*(_QWORD *)(a1 + 32);
if ( *(_QWORD *)(a1 + 40) )
{
--*(_QWORD *)(a1 + 40);
}
else if ( *(_QWORD *)(a1 + 48) )
{
--*(_QWORD *)(a1 + 48);
}
v3 = *(_DWORD *)(a1 + 20);
v1 = std::char_traits<char>::eof();
result = v3 != v1;
if ( v3 != v1 )
{
if ( (std::vector<char>::empty(a1 + 56) & 1) != 0 )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
8768LL,
"GGML_ASSERT(%s) failed",
"!token_string.empty()");
return std::vector<char>::pop_back(a1 + 56);
}
return result;
}
| unget:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x8],RAX
MOV byte ptr [RAX + 0x18],0x1
MOV RCX,qword ptr [RAX + 0x20]
ADD RCX,-0x1
MOV qword ptr [RAX + 0x20],RCX
CMP qword ptr [RAX + 0x28],0x0
JNZ 0x001a4729
MOV RAX,qword ptr [RSP + 0x8]
CMP qword ptr [RAX + 0x30],0x0
JBE 0x001a4727
MOV RAX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RAX + 0x30]
ADD RCX,-0x1
MOV qword ptr [RAX + 0x30],RCX
LAB_001a4727:
JMP 0x001a473a
LAB_001a4729:
MOV RAX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RAX + 0x28]
ADD RCX,-0x1
MOV qword ptr [RAX + 0x28],RCX
LAB_001a473a:
MOV RAX,qword ptr [RSP + 0x8]
MOV EAX,dword ptr [RAX + 0x14]
MOV dword ptr [RSP + 0x4],EAX
CALL 0x0019e7d0
MOV ECX,EAX
MOV EAX,dword ptr [RSP + 0x4]
CMP EAX,ECX
SETNZ AL
XOR AL,0xff
XOR AL,0xff
TEST AL,0x1
JNZ 0x001a4760
JMP 0x001a47a3
LAB_001a4760:
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x38
CALL 0x001a5220
TEST AL,0x1
JNZ 0x001a4774
JMP 0x001a4795
LAB_001a4774:
LEA RDI,[0x30d5de]
MOV ESI,0x2240
LEA RDX,[0x3071d9]
LEA RCX,[0x30d7b2]
MOV AL,0x0
CALL 0x0015aef0
LAB_001a4795:
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x38
CALL 0x001a5270
LAB_001a47a3:
ADD RSP,0x18
RET
|
/* nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>,
nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > > >::unget() */
void __thiscall
nlohmann::json_abi_v3_11_3::detail::
lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
::unget(lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*this)
{
int iVar1;
int iVar2;
ulong uVar3;
this[0x18] = (lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
)0x1;
*(long *)(this + 0x20) = *(long *)(this + 0x20) + -1;
if (*(long *)(this + 0x28) == 0) {
if (*(long *)(this + 0x30) != 0) {
*(long *)(this + 0x30) = *(long *)(this + 0x30) + -1;
}
}
else {
*(long *)(this + 0x28) = *(long *)(this + 0x28) + -1;
}
iVar1 = *(int *)(this + 0x14);
iVar2 = std::char_traits<char>::eof();
if (iVar1 != iVar2) {
uVar3 = std::vector<char,std::allocator<char>>::empty
((vector<char,std::allocator<char>> *)(this + 0x38));
if ((uVar3 & 1) != 0) {
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",0x2240,
"GGML_ASSERT(%s) failed","!token_string.empty()");
}
std::vector<char,std::allocator<char>>::pop_back
((vector<char,std::allocator<char>> *)(this + 0x38));
}
return;
}
| |
48,313 | nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::unget() | monkey531[P]llama/common/json.hpp | void unget()
{
next_unget = true;
--position.chars_read_total;
// in case we "unget" a newline, we have to also decrement the lines_read
if (position.chars_read_current_line == 0)
{
if (position.lines_read > 0)
{
--position.lines_read;
}
}
else
{
--position.chars_read_current_line;
}
if (JSON_HEDLEY_LIKELY(current != char_traits<char_type>::eof()))
{
JSON_ASSERT(!token_string.empty());
token_string.pop_back();
}
} | O2 | cpp | nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::unget():
movb $0x1, 0x18(%rdi)
decq 0x20(%rdi)
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x3ec31
leaq 0x28(%rdi), %rcx
jmp 0x3ec3e
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x3ec44
leaq 0x30(%rdi), %rcx
decq %rax
movq %rax, (%rcx)
cmpl $-0x1, 0x14(%rdi)
je 0x3ec5b
movq 0x40(%rdi), %rax
cmpq %rax, 0x38(%rdi)
je 0x3ec5c
decq %rax
movq %rax, 0x40(%rdi)
retq
pushq %rax
leaq 0x713e2(%rip), %rdi # 0xb0046
leaq 0x6b636(%rip), %rdx # 0xaa2a1
leaq 0x7159c(%rip), %rcx # 0xb020e
movl $0x2240, %esi # imm = 0x2240
xorl %eax, %eax
callq 0x23ef0
| _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE5ungetEv:
mov byte ptr [rdi+18h], 1
dec qword ptr [rdi+20h]
mov rax, [rdi+28h]
test rax, rax
jz short loc_3EC31
lea rcx, [rdi+28h]
jmp short loc_3EC3E
loc_3EC31:
mov rax, [rdi+30h]
test rax, rax
jz short loc_3EC44
lea rcx, [rdi+30h]
loc_3EC3E:
dec rax
mov [rcx], rax
loc_3EC44:
cmp dword ptr [rdi+14h], 0FFFFFFFFh
jz short locret_3EC5B
mov rax, [rdi+40h]
cmp [rdi+38h], rax
jz short loc_3EC5C
dec rax
mov [rdi+40h], rax
locret_3EC5B:
retn
loc_3EC5C:
push rax
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aTokenStringEmp; "!token_string.empty()"
mov esi, 2240h
xor eax, eax
call _ggml_abort
| long long nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::unget(
long long a1)
{
long long result; // rax
_QWORD *v2; // rcx
long long v3; // rax
*(_BYTE *)(a1 + 24) = 1;
--*(_QWORD *)(a1 + 32);
result = *(_QWORD *)(a1 + 40);
if ( result )
{
v2 = (_QWORD *)(a1 + 40);
}
else
{
result = *(_QWORD *)(a1 + 48);
if ( !result )
goto LABEL_6;
v2 = (_QWORD *)(a1 + 48);
}
*v2 = --result;
LABEL_6:
if ( *(_DWORD *)(a1 + 20) != -1 )
{
v3 = *(_QWORD *)(a1 + 64);
if ( *(_QWORD *)(a1 + 56) == v3 )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
8768LL,
"GGML_ASSERT(%s) failed",
"!token_string.empty()");
return std::vector<char>::emplace_back<char>("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp");
}
else
{
result = v3 - 1;
*(_QWORD *)(a1 + 64) = result;
}
}
return result;
}
| unget:
MOV byte ptr [RDI + 0x18],0x1
DEC qword ptr [RDI + 0x20]
MOV RAX,qword ptr [RDI + 0x28]
TEST RAX,RAX
JZ 0x0013ec31
LEA RCX,[RDI + 0x28]
JMP 0x0013ec3e
LAB_0013ec31:
MOV RAX,qword ptr [RDI + 0x30]
TEST RAX,RAX
JZ 0x0013ec44
LEA RCX,[RDI + 0x30]
LAB_0013ec3e:
DEC RAX
MOV qword ptr [RCX],RAX
LAB_0013ec44:
CMP dword ptr [RDI + 0x14],-0x1
JZ 0x0013ec5b
MOV RAX,qword ptr [RDI + 0x40]
CMP qword ptr [RDI + 0x38],RAX
JZ 0x0013ec5c
DEC RAX
MOV qword ptr [RDI + 0x40],RAX
LAB_0013ec5b:
RET
LAB_0013ec5c:
PUSH RAX
LEA RDI,[0x1b0046]
LEA RDX,[0x1aa2a1]
LEA RCX,[0x1b020e]
MOV ESI,0x2240
XOR EAX,EAX
CALL 0x00123ef0
|
/* nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>,
nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > > >::unget() */
void __thiscall
nlohmann::json_abi_v3_11_3::detail::
lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
::unget(lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*this)
{
long lVar1;
lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*plVar2;
int8 in_R8;
int8 in_R9;
this[0x18] = (lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
)0x1;
*(long *)(this + 0x20) = *(long *)(this + 0x20) + -1;
lVar1 = *(long *)(this + 0x28);
if (lVar1 == 0) {
lVar1 = *(long *)(this + 0x30);
if (lVar1 == 0) goto LAB_0013ec44;
plVar2 = this + 0x30;
}
else {
plVar2 = this + 0x28;
}
*(long *)plVar2 = lVar1 + -1;
LAB_0013ec44:
if (*(int *)(this + 0x14) != -1) {
lVar1 = *(long *)(this + 0x40);
if (*(long *)(this + 0x38) == lVar1) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",0x2240,
"GGML_ASSERT(%s) failed","!token_string.empty()",in_R8,in_R9,lVar1);
}
*(long *)(this + 0x40) = lVar1 + -1;
}
return;
}
| |
48,314 | LefDefParser::defrDisableParserMsgs(int, int*) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defrReader.cpp | void
defrDisableParserMsgs(int nMsg,
int *msgs)
{
DEF_INIT;
int i, j;
int *tmp;
if (defContext.settings->nDDMsgs == 0) {
defContext.settings->nDDMsgs = nMsg;
defContext.settings->disableDMsgs = (int*) malloc(sizeof(int) * nMsg);
for (i = 0; i < nMsg; i++)
defContext.settings->disableDMsgs[i] = msgs[i];
} else { // add the list to the existing list
// 1st check if the msgId is already on the list before adding it on
tmp = (int*) malloc(sizeof(int) * (nMsg + defContext.settings->nDDMsgs));
for (i = 0; i < defContext.settings->nDDMsgs; i++) // copy the existing to the new list
tmp[i] = defContext.settings->disableDMsgs[i];
free((int*) (defContext.settings->disableDMsgs));
defContext.settings->disableDMsgs = tmp; // set disableDMsgs to the new list
for (i = 0; i < nMsg; i++) { // merge the new list with the existing
for (j = 0; j < defContext.settings->nDDMsgs; j++) {
if (defContext.settings->disableDMsgs[j] == msgs[i])
break; // msgId already on the list
}
if (j == defContext.settings->nDDMsgs) // msgId not on the list, add it on
defContext.settings->disableDMsgs[defContext.settings->nDDMsgs++] = msgs[i];
}
}
return;
} | O0 | cpp | LefDefParser::defrDisableParserMsgs(int, int*):
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
leaq 0x517ec(%rip), %rdi # 0x70970
callq 0x1b270
leaq 0x71150(%rip), %rax # 0x902e0
movq (%rax), %rax
cmpl $0x0, 0x90(%rax)
jne 0x1f220
movl 0x24(%rsp), %ecx
leaq 0x71135(%rip), %rax # 0x902e0
movq (%rax), %rax
movl %ecx, 0x90(%rax)
movslq 0x24(%rsp), %rdi
shlq $0x2, %rdi
callq 0x72d0
movq %rax, %rcx
leaq 0x71114(%rip), %rax # 0x902e0
movq (%rax), %rax
movq %rcx, 0x98(%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x1f21b
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
movl (%rax,%rcx,4), %edx
leaq 0x710e4(%rip), %rax # 0x902e0
movq (%rax), %rax
movq 0x98(%rax), %rax
movslq 0x14(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x1f1de
jmp 0x1f398
movl 0x24(%rsp), %eax
leaq 0x710b5(%rip), %rcx # 0x902e0
movq (%rcx), %rcx
addl 0x90(%rcx), %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x72d0
movq %rax, 0x8(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
leaq 0x71088(%rip), %rcx # 0x902e0
movq (%rcx), %rcx
cmpl 0x90(%rcx), %eax
jge 0x1f296
leaq 0x71076(%rip), %rax # 0x902e0
movq (%rax), %rax
movq 0x98(%rax), %rax
movslq 0x14(%rsp), %rcx
movl (%rax,%rcx,4), %edx
movq 0x8(%rsp), %rax
movslq 0x14(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x1f24d
leaq 0x71043(%rip), %rax # 0x902e0
movq (%rax), %rax
movq 0x98(%rax), %rdi
callq 0x72a0
movq 0x8(%rsp), %rcx
leaq 0x71028(%rip), %rax # 0x902e0
movq (%rax), %rax
movq %rcx, 0x98(%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x1f396
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
leaq 0x70ff5(%rip), %rcx # 0x902e0
movq (%rcx), %rcx
cmpl 0x90(%rcx), %eax
jge 0x1f32f
leaq 0x70fe3(%rip), %rax # 0x902e0
movq (%rax), %rax
movq 0x98(%rax), %rax
movslq 0x10(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq 0x18(%rsp), %rcx
movslq 0x14(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jne 0x1f320
jmp 0x1f32f
jmp 0x1f322
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x1f2e0
movl 0x10(%rsp), %eax
leaq 0x70fa6(%rip), %rcx # 0x902e0
movq (%rcx), %rcx
cmpl 0x90(%rcx), %eax
jne 0x1f384
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
movl (%rax,%rcx,4), %edx
leaq 0x70f87(%rip), %rax # 0x902e0
movq (%rax), %rax
movq 0x98(%rax), %rax
leaq 0x70f76(%rip), %rcx # 0x902e0
movq (%rcx), %rsi
movl 0x90(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x90(%rsi)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x1f386
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x1f2ca
jmp 0x1f398
addq $0x28, %rsp
retq
nopl (%rax)
| _ZN12LefDefParser21defrDisableParserMsgsEiPi:
sub rsp, 28h
mov [rsp+28h+var_4], edi
mov [rsp+28h+var_10], rsi
lea rdi, aDefrdisablepar; "defrDisableParserMsgs"
call _ZN12LefDefParser8def_initEPKc; LefDefParser::def_init(char const*)
lea rax, _ZN12LefDefParser10defContextE; LefDefParser::defContext
mov rax, [rax]
cmp dword ptr [rax+90h], 0
jnz loc_1F220
mov ecx, [rsp+28h+var_4]
lea rax, _ZN12LefDefParser10defContextE; LefDefParser::defContext
mov rax, [rax]
mov [rax+90h], ecx
movsxd rdi, [rsp+28h+var_4]
shl rdi, 2
call _malloc
mov rcx, rax
lea rax, _ZN12LefDefParser10defContextE; LefDefParser::defContext
mov rax, [rax]
mov [rax+98h], rcx
mov [rsp+28h+var_14], 0
loc_1F1DE:
mov eax, [rsp+28h+var_14]
cmp eax, [rsp+28h+var_4]
jge short loc_1F21B
mov rax, [rsp+28h+var_10]
movsxd rcx, [rsp+28h+var_14]
mov edx, [rax+rcx*4]
lea rax, _ZN12LefDefParser10defContextE; LefDefParser::defContext
mov rax, [rax]
mov rax, [rax+98h]
movsxd rcx, [rsp+28h+var_14]
mov [rax+rcx*4], edx
mov eax, [rsp+28h+var_14]
add eax, 1
mov [rsp+28h+var_14], eax
jmp short loc_1F1DE
loc_1F21B:
jmp loc_1F398
loc_1F220:
mov eax, [rsp+28h+var_4]
lea rcx, _ZN12LefDefParser10defContextE; LefDefParser::defContext
mov rcx, [rcx]
add eax, [rcx+90h]
movsxd rdi, eax
shl rdi, 2
call _malloc
mov [rsp+28h+var_20], rax
mov [rsp+28h+var_14], 0
loc_1F24D:
mov eax, [rsp+28h+var_14]
lea rcx, _ZN12LefDefParser10defContextE; LefDefParser::defContext
mov rcx, [rcx]
cmp eax, [rcx+90h]
jge short loc_1F296
lea rax, _ZN12LefDefParser10defContextE; LefDefParser::defContext
mov rax, [rax]
mov rax, [rax+98h]
movsxd rcx, [rsp+28h+var_14]
mov edx, [rax+rcx*4]
mov rax, [rsp+28h+var_20]
movsxd rcx, [rsp+28h+var_14]
mov [rax+rcx*4], edx
mov eax, [rsp+28h+var_14]
add eax, 1
mov [rsp+28h+var_14], eax
jmp short loc_1F24D
loc_1F296:
lea rax, _ZN12LefDefParser10defContextE; LefDefParser::defContext
mov rax, [rax]
mov rdi, [rax+98h]
call _free
mov rcx, [rsp+28h+var_20]
lea rax, _ZN12LefDefParser10defContextE; LefDefParser::defContext
mov rax, [rax]
mov [rax+98h], rcx
mov [rsp+28h+var_14], 0
loc_1F2CA:
mov eax, [rsp+28h+var_14]
cmp eax, [rsp+28h+var_4]
jge loc_1F396
mov [rsp+28h+var_18], 0
loc_1F2E0:
mov eax, [rsp+28h+var_18]
lea rcx, _ZN12LefDefParser10defContextE; LefDefParser::defContext
mov rcx, [rcx]
cmp eax, [rcx+90h]
jge short loc_1F32F
lea rax, _ZN12LefDefParser10defContextE; LefDefParser::defContext
mov rax, [rax]
mov rax, [rax+98h]
movsxd rcx, [rsp+28h+var_18]
mov eax, [rax+rcx*4]
mov rcx, [rsp+28h+var_10]
movsxd rdx, [rsp+28h+var_14]
cmp eax, [rcx+rdx*4]
jnz short loc_1F320
jmp short loc_1F32F
loc_1F320:
jmp short $+2
loc_1F322:
mov eax, [rsp+28h+var_18]
add eax, 1
mov [rsp+28h+var_18], eax
jmp short loc_1F2E0
loc_1F32F:
mov eax, [rsp+28h+var_18]
lea rcx, _ZN12LefDefParser10defContextE; LefDefParser::defContext
mov rcx, [rcx]
cmp eax, [rcx+90h]
jnz short loc_1F384
mov rax, [rsp+28h+var_10]
movsxd rcx, [rsp+28h+var_14]
mov edx, [rax+rcx*4]
lea rax, _ZN12LefDefParser10defContextE; LefDefParser::defContext
mov rax, [rax]
mov rax, [rax+98h]
lea rcx, _ZN12LefDefParser10defContextE; LefDefParser::defContext
mov rsi, [rcx]
mov ecx, [rsi+90h]
mov edi, ecx
add edi, 1
mov [rsi+90h], edi
movsxd rcx, ecx
mov [rax+rcx*4], edx
loc_1F384:
jmp short $+2
loc_1F386:
mov eax, [rsp+28h+var_14]
add eax, 1
mov [rsp+28h+var_14], eax
jmp loc_1F2CA
loc_1F396:
jmp short $+2
loc_1F398:
add rsp, 28h
retn
| long long LefDefParser::defrDisableParserMsgs(LefDefParser *this, const char *a2, int *a3)
{
long long result; // rax
int v4; // edx
long long v5; // rax
int v6; // ecx
long long v7; // [rsp+8h] [rbp-20h]
int k; // [rsp+10h] [rbp-18h]
int m; // [rsp+14h] [rbp-14h]
int i; // [rsp+14h] [rbp-14h]
int j; // [rsp+14h] [rbp-14h]
LefDefParser::def_init((LefDefParser *)"defrDisableParserMsgs", a2);
if ( *(_DWORD *)(LefDefParser::defContext[0] + 144LL) )
{
v7 = malloc(4LL * (*(_DWORD *)(LefDefParser::defContext[0] + 144LL) + (int)this));
for ( i = 0; i < *(_DWORD *)(LefDefParser::defContext[0] + 144LL); ++i )
*(_DWORD *)(v7 + 4LL * i) = *(_DWORD *)(*(_QWORD *)(LefDefParser::defContext[0] + 152LL) + 4LL * i);
free(*(_QWORD *)(LefDefParser::defContext[0] + 152LL));
*(_QWORD *)(LefDefParser::defContext[0] + 152LL) = v7;
for ( j = 0; ; ++j )
{
result = (unsigned int)j;
if ( j >= (int)this )
break;
for ( k = 0;
k < *(_DWORD *)(LefDefParser::defContext[0] + 144LL)
&& *(_DWORD *)(*(_QWORD *)(LefDefParser::defContext[0] + 152LL) + 4LL * k) != *(_DWORD *)&a2[4 * j];
++k )
{
;
}
if ( k == *(_DWORD *)(LefDefParser::defContext[0] + 144LL) )
{
v4 = *(_DWORD *)&a2[4 * j];
v5 = *(_QWORD *)(LefDefParser::defContext[0] + 152LL);
v6 = *(_DWORD *)(LefDefParser::defContext[0] + 144LL);
*(_DWORD *)(LefDefParser::defContext[0] + 144LL) = v6 + 1;
*(_DWORD *)(v5 + 4LL * v6) = v4;
}
}
}
else
{
*(_DWORD *)(LefDefParser::defContext[0] + 144LL) = (_DWORD)this;
*(_QWORD *)(LefDefParser::defContext[0] + 152LL) = malloc(4LL * (int)this);
for ( m = 0; ; ++m )
{
result = (unsigned int)m;
if ( m >= (int)this )
break;
*(_DWORD *)(*(_QWORD *)(LefDefParser::defContext[0] + 152LL) + 4LL * m) = *(_DWORD *)&a2[4 * m];
}
}
return result;
}
| defrDisableParserMsgs:
SUB RSP,0x28
MOV dword ptr [RSP + 0x24],EDI
MOV qword ptr [RSP + 0x18],RSI
LEA RDI,[0x170970]
CALL 0x0011b270
LEA RAX,[0x1902e0]
MOV RAX,qword ptr [RAX]
CMP dword ptr [RAX + 0x90],0x0
JNZ 0x0011f220
MOV ECX,dword ptr [RSP + 0x24]
LEA RAX,[0x1902e0]
MOV RAX,qword ptr [RAX]
MOV dword ptr [RAX + 0x90],ECX
MOVSXD RDI,dword ptr [RSP + 0x24]
SHL RDI,0x2
CALL 0x001072d0
MOV RCX,RAX
LEA RAX,[0x1902e0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX + 0x98],RCX
MOV dword ptr [RSP + 0x14],0x0
LAB_0011f1de:
MOV EAX,dword ptr [RSP + 0x14]
CMP EAX,dword ptr [RSP + 0x24]
JGE 0x0011f21b
MOV RAX,qword ptr [RSP + 0x18]
MOVSXD RCX,dword ptr [RSP + 0x14]
MOV EDX,dword ptr [RAX + RCX*0x4]
LEA RAX,[0x1902e0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x98]
MOVSXD RCX,dword ptr [RSP + 0x14]
MOV dword ptr [RAX + RCX*0x4],EDX
MOV EAX,dword ptr [RSP + 0x14]
ADD EAX,0x1
MOV dword ptr [RSP + 0x14],EAX
JMP 0x0011f1de
LAB_0011f21b:
JMP 0x0011f398
LAB_0011f220:
MOV EAX,dword ptr [RSP + 0x24]
LEA RCX,[0x1902e0]
MOV RCX,qword ptr [RCX]
ADD EAX,dword ptr [RCX + 0x90]
MOVSXD RDI,EAX
SHL RDI,0x2
CALL 0x001072d0
MOV qword ptr [RSP + 0x8],RAX
MOV dword ptr [RSP + 0x14],0x0
LAB_0011f24d:
MOV EAX,dword ptr [RSP + 0x14]
LEA RCX,[0x1902e0]
MOV RCX,qword ptr [RCX]
CMP EAX,dword ptr [RCX + 0x90]
JGE 0x0011f296
LEA RAX,[0x1902e0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x98]
MOVSXD RCX,dword ptr [RSP + 0x14]
MOV EDX,dword ptr [RAX + RCX*0x4]
MOV RAX,qword ptr [RSP + 0x8]
MOVSXD RCX,dword ptr [RSP + 0x14]
MOV dword ptr [RAX + RCX*0x4],EDX
MOV EAX,dword ptr [RSP + 0x14]
ADD EAX,0x1
MOV dword ptr [RSP + 0x14],EAX
JMP 0x0011f24d
LAB_0011f296:
LEA RAX,[0x1902e0]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX + 0x98]
CALL 0x001072a0
MOV RCX,qword ptr [RSP + 0x8]
LEA RAX,[0x1902e0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX + 0x98],RCX
MOV dword ptr [RSP + 0x14],0x0
LAB_0011f2ca:
MOV EAX,dword ptr [RSP + 0x14]
CMP EAX,dword ptr [RSP + 0x24]
JGE 0x0011f396
MOV dword ptr [RSP + 0x10],0x0
LAB_0011f2e0:
MOV EAX,dword ptr [RSP + 0x10]
LEA RCX,[0x1902e0]
MOV RCX,qword ptr [RCX]
CMP EAX,dword ptr [RCX + 0x90]
JGE 0x0011f32f
LEA RAX,[0x1902e0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x98]
MOVSXD RCX,dword ptr [RSP + 0x10]
MOV EAX,dword ptr [RAX + RCX*0x4]
MOV RCX,qword ptr [RSP + 0x18]
MOVSXD RDX,dword ptr [RSP + 0x14]
CMP EAX,dword ptr [RCX + RDX*0x4]
JNZ 0x0011f320
JMP 0x0011f32f
LAB_0011f320:
JMP 0x0011f322
LAB_0011f322:
MOV EAX,dword ptr [RSP + 0x10]
ADD EAX,0x1
MOV dword ptr [RSP + 0x10],EAX
JMP 0x0011f2e0
LAB_0011f32f:
MOV EAX,dword ptr [RSP + 0x10]
LEA RCX,[0x1902e0]
MOV RCX,qword ptr [RCX]
CMP EAX,dword ptr [RCX + 0x90]
JNZ 0x0011f384
MOV RAX,qword ptr [RSP + 0x18]
MOVSXD RCX,dword ptr [RSP + 0x14]
MOV EDX,dword ptr [RAX + RCX*0x4]
LEA RAX,[0x1902e0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x98]
LEA RCX,[0x1902e0]
MOV RSI,qword ptr [RCX]
MOV ECX,dword ptr [RSI + 0x90]
MOV EDI,ECX
ADD EDI,0x1
MOV dword ptr [RSI + 0x90],EDI
MOVSXD RCX,ECX
MOV dword ptr [RAX + RCX*0x4],EDX
LAB_0011f384:
JMP 0x0011f386
LAB_0011f386:
MOV EAX,dword ptr [RSP + 0x14]
ADD EAX,0x1
MOV dword ptr [RSP + 0x14],EAX
JMP 0x0011f2ca
LAB_0011f396:
JMP 0x0011f398
LAB_0011f398:
ADD RSP,0x28
RET
|
/* LefDefParser::defrDisableParserMsgs(int, int*) */
void LefDefParser::defrDisableParserMsgs(int param_1,int *param_2)
{
long *plVar1;
int iVar2;
int iVar3;
void *pvVar4;
int local_18;
int local_14;
def_init("defrDisableParserMsgs");
if (*(int *)(defContext + 0x90) == 0) {
*(int *)(defContext + 0x90) = param_1;
pvVar4 = malloc((long)param_1 << 2);
*(void **)(defContext + 0x98) = pvVar4;
for (local_14 = 0; local_14 < param_1; local_14 = local_14 + 1) {
*(int *)(*(long *)(defContext + 0x98) + (long)local_14 * 4) = param_2[local_14];
}
}
else {
pvVar4 = malloc((long)(param_1 + *(int *)(defContext + 0x90)) << 2);
for (local_14 = 0; local_14 < *(int *)(defContext + 0x90); local_14 = local_14 + 1) {
*(int4 *)((long)pvVar4 + (long)local_14 * 4) =
*(int4 *)(*(long *)(defContext + 0x98) + (long)local_14 * 4);
}
free(*(void **)(defContext + 0x98));
*(void **)(defContext + 0x98) = pvVar4;
for (local_14 = 0; local_14 < param_1; local_14 = local_14 + 1) {
local_18 = 0;
while ((local_18 < *(int *)(defContext + 0x90) &&
(*(int *)(*(long *)(defContext + 0x98) + (long)local_18 * 4) != param_2[local_14]))) {
local_18 = local_18 + 1;
}
if (local_18 == *(int *)(defContext + 0x90)) {
iVar2 = param_2[local_14];
plVar1 = (long *)(defContext + 0x98);
iVar3 = *(int *)(defContext + 0x90);
*(int *)(defContext + 0x90) = iVar3 + 1;
*(int *)(*plVar1 + (long)iVar3 * 4) = iVar2;
}
}
}
return;
}
| |
48,315 | ma_zlib_decompress | eloqsql/libmariadb/plugins/compress/c_zlib.c | my_bool ma_zlib_decompress(ma_compress_ctx *ctx, void *dst, size_t *dst_len,
void *source, size_t *source_len)
{
int rc;
if (!ctx)
return 1;
rc= uncompress((Bytef*) dst, (uLongf *)dst_len, (Bytef*) source, (uLongf)*source_len);
if (rc != Z_OK)
return 1;
return 0;
} | O0 | c | ma_zlib_decompress:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5b619
movb $0x1, -0x1(%rbp)
jmp 0x5b644
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rax
movq (%rax), %rcx
callq 0x14190
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x5b640
movb $0x1, -0x1(%rbp)
jmp 0x5b644
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
| ma_zlib_decompress:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
cmp [rbp+var_10], 0
jnz short loc_5B619
mov [rbp+var_1], 1
jmp short loc_5B644
loc_5B619:
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_28]
mov rax, [rbp+var_30]
mov rcx, [rax]
call _uncompress
mov [rbp+var_34], eax
cmp [rbp+var_34], 0
jz short loc_5B640
mov [rbp+var_1], 1
jmp short loc_5B644
loc_5B640:
mov [rbp+var_1], 0
loc_5B644:
mov al, [rbp+var_1]
add rsp, 40h
pop rbp
retn
| bool ma_zlib_decompress(long long a1, long long a2, long long a3, long long a4, _QWORD *a5)
{
return !a1 || (unsigned int)uncompress(a2, a3, a4, *a5) != 0;
}
| ma_zlib_decompress:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
CMP qword ptr [RBP + -0x10],0x0
JNZ 0x0015b619
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0015b644
LAB_0015b619:
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RAX]
CALL 0x00114190
MOV dword ptr [RBP + -0x34],EAX
CMP dword ptr [RBP + -0x34],0x0
JZ 0x0015b640
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0015b644
LAB_0015b640:
MOV byte ptr [RBP + -0x1],0x0
LAB_0015b644:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x40
POP RBP
RET
|
int1
ma_zlib_decompress(long param_1,int8 param_2,int8 param_3,int8 param_4,
int8 *param_5)
{
int iVar1;
int1 local_9;
if (param_1 == 0) {
local_9 = 1;
}
else {
iVar1 = uncompress(param_2,param_3,param_4,*param_5);
if (iVar1 == 0) {
local_9 = 0;
}
else {
local_9 = 1;
}
}
return local_9;
}
| |
48,316 | ggml_vec_dot_q6_K_q8_K | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-quants.c | void ggml_vec_dot_q6_K_q8_K(int n, float * restrict s, size_t bs, const void * restrict vx, size_t bx, const void * restrict vy, size_t by, int nrc) {
assert(n % QK_K == 0);
assert(nrc == 1);
UNUSED(nrc);
UNUSED(bx);
UNUSED(by);
UNUSED(bs);
const block_q6_K * restrict x = vx;
const block_q8_K * restrict y = vy;
const int nb = n / QK_K;
#ifdef __ARM_NEON
float sum = 0;
const uint8x16_t m4b = vdupq_n_u8(0xF);
const int32x4_t vzero = vdupq_n_s32(0);
//const int8x16_t m32s = vdupq_n_s8(32);
const uint8x16_t mone = vdupq_n_u8(3);
ggml_int8x16x4_t q6bytes;
ggml_uint8x16x4_t q6h;
for (int i = 0; i < nb; ++i) {
const float d_all = GGML_FP16_TO_FP32(x[i].d);
const uint8_t * restrict q6 = x[i].ql;
const uint8_t * restrict qh = x[i].qh;
const int8_t * restrict q8 = y[i].qs;
const int8_t * restrict scale = x[i].scales;
const ggml_int16x8x2_t q8sums = ggml_vld1q_s16_x2(y[i].bsums);
const int8x16_t scales = vld1q_s8(scale);
const ggml_int16x8x2_t q6scales = {{vmovl_s8(vget_low_s8(scales)), vmovl_s8(vget_high_s8(scales))}};
const int32x4_t prod = vaddq_s32(vaddq_s32(vmull_s16(vget_low_s16 (q8sums.val[0]), vget_low_s16 (q6scales.val[0])),
vmull_s16(vget_high_s16(q8sums.val[0]), vget_high_s16(q6scales.val[0]))),
vaddq_s32(vmull_s16(vget_low_s16 (q8sums.val[1]), vget_low_s16 (q6scales.val[1])),
vmull_s16(vget_high_s16(q8sums.val[1]), vget_high_s16(q6scales.val[1]))));
int32_t isum_mins = vaddvq_s32(prod);
int32_t isum = 0;
for (int j = 0; j < QK_K/128; ++j) {
ggml_uint8x16x2_t qhbits = ggml_vld1q_u8_x2(qh); qh += 32;
ggml_uint8x16x4_t q6bits = ggml_vld1q_u8_x4(q6); q6 += 64;
ggml_int8x16x4_t q8bytes = ggml_vld1q_s8_x4(q8); q8 += 64;
q6h.val[0] = vshlq_n_u8(vandq_u8(mone, qhbits.val[0]), 4);
q6h.val[1] = vshlq_n_u8(vandq_u8(mone, qhbits.val[1]), 4);
uint8x16_t shifted = vshrq_n_u8(qhbits.val[0], 2);
q6h.val[2] = vshlq_n_u8(vandq_u8(mone, shifted), 4);
shifted = vshrq_n_u8(qhbits.val[1], 2);
q6h.val[3] = vshlq_n_u8(vandq_u8(mone, shifted), 4);
//q6bytes.val[0] = vsubq_s8(vreinterpretq_s8_u8(vorrq_u8(vandq_u8(q6bits.val[0], m4b), q6h.val[0])), m32s);
//q6bytes.val[1] = vsubq_s8(vreinterpretq_s8_u8(vorrq_u8(vandq_u8(q6bits.val[1], m4b), q6h.val[1])), m32s);
//q6bytes.val[2] = vsubq_s8(vreinterpretq_s8_u8(vorrq_u8(vandq_u8(q6bits.val[2], m4b), q6h.val[2])), m32s);
//q6bytes.val[3] = vsubq_s8(vreinterpretq_s8_u8(vorrq_u8(vandq_u8(q6bits.val[3], m4b), q6h.val[3])), m32s);
q6bytes.val[0] = vreinterpretq_s8_u8(vorrq_u8(vandq_u8(q6bits.val[0], m4b), q6h.val[0]));
q6bytes.val[1] = vreinterpretq_s8_u8(vorrq_u8(vandq_u8(q6bits.val[1], m4b), q6h.val[1]));
q6bytes.val[2] = vreinterpretq_s8_u8(vorrq_u8(vandq_u8(q6bits.val[2], m4b), q6h.val[2]));
q6bytes.val[3] = vreinterpretq_s8_u8(vorrq_u8(vandq_u8(q6bits.val[3], m4b), q6h.val[3]));
isum += vaddvq_s32(ggml_vdotq_s32(vzero, q6bytes.val[0], q8bytes.val[0])) * scale[0] +
vaddvq_s32(ggml_vdotq_s32(vzero, q6bytes.val[1], q8bytes.val[1])) * scale[1] +
vaddvq_s32(ggml_vdotq_s32(vzero, q6bytes.val[2], q8bytes.val[2])) * scale[2] +
vaddvq_s32(ggml_vdotq_s32(vzero, q6bytes.val[3], q8bytes.val[3])) * scale[3];
scale += 4;
q8bytes = ggml_vld1q_s8_x4(q8); q8 += 64;
shifted = vshrq_n_u8(qhbits.val[0], 4);
q6h.val[0] = vshlq_n_u8(vandq_u8(mone, shifted), 4);
shifted = vshrq_n_u8(qhbits.val[1], 4);
q6h.val[1] = vshlq_n_u8(vandq_u8(mone, shifted), 4);
shifted = vshrq_n_u8(qhbits.val[0], 6);
q6h.val[2] = vshlq_n_u8(vandq_u8(mone, shifted), 4);
shifted = vshrq_n_u8(qhbits.val[1], 6);
q6h.val[3] = vshlq_n_u8(vandq_u8(mone, shifted), 4);
//q6bytes.val[0] = vsubq_s8(vreinterpretq_s8_u8(vorrq_u8(vshrq_n_u8(q6bits.val[0], 4), q6h.val[0])), m32s);
//q6bytes.val[1] = vsubq_s8(vreinterpretq_s8_u8(vorrq_u8(vshrq_n_u8(q6bits.val[1], 4), q6h.val[1])), m32s);
//q6bytes.val[2] = vsubq_s8(vreinterpretq_s8_u8(vorrq_u8(vshrq_n_u8(q6bits.val[2], 4), q6h.val[2])), m32s);
//q6bytes.val[3] = vsubq_s8(vreinterpretq_s8_u8(vorrq_u8(vshrq_n_u8(q6bits.val[3], 4), q6h.val[3])), m32s);
q6bytes.val[0] = vreinterpretq_s8_u8(vorrq_u8(vshrq_n_u8(q6bits.val[0], 4), q6h.val[0]));
q6bytes.val[1] = vreinterpretq_s8_u8(vorrq_u8(vshrq_n_u8(q6bits.val[1], 4), q6h.val[1]));
q6bytes.val[2] = vreinterpretq_s8_u8(vorrq_u8(vshrq_n_u8(q6bits.val[2], 4), q6h.val[2]));
q6bytes.val[3] = vreinterpretq_s8_u8(vorrq_u8(vshrq_n_u8(q6bits.val[3], 4), q6h.val[3]));
isum += vaddvq_s32(ggml_vdotq_s32(vzero, q6bytes.val[0], q8bytes.val[0])) * scale[0] +
vaddvq_s32(ggml_vdotq_s32(vzero, q6bytes.val[1], q8bytes.val[1])) * scale[1] +
vaddvq_s32(ggml_vdotq_s32(vzero, q6bytes.val[2], q8bytes.val[2])) * scale[2] +
vaddvq_s32(ggml_vdotq_s32(vzero, q6bytes.val[3], q8bytes.val[3])) * scale[3];
scale += 4;
}
//sum += isum * d_all * y[i].d;
sum += d_all * y[i].d * (isum - 32 * isum_mins);
}
*s = sum;
#elif defined __AVX2__
const __m256i m4 = _mm256_set1_epi8(0xF);
const __m256i m2 = _mm256_set1_epi8(3);
const __m256i m32s = _mm256_set1_epi8(32);
__m256 acc = _mm256_setzero_ps();
for (int i = 0; i < nb; ++i) {
const float d = y[i].d * GGML_FP16_TO_FP32(x[i].d);
const uint8_t * restrict q4 = x[i].ql;
const uint8_t * restrict qh = x[i].qh;
const int8_t * restrict q8 = y[i].qs;
const __m128i scales = _mm_loadu_si128((const __m128i*)x[i].scales);
__m256i sumi = _mm256_setzero_si256();
int is = 0;
for (int j = 0; j < QK_K/128; ++j) {
const __m128i scale_0 = _mm_shuffle_epi8(scales, get_scale_shuffle(is + 0));
const __m128i scale_1 = _mm_shuffle_epi8(scales, get_scale_shuffle(is + 1));
const __m128i scale_2 = _mm_shuffle_epi8(scales, get_scale_shuffle(is + 2));
const __m128i scale_3 = _mm_shuffle_epi8(scales, get_scale_shuffle(is + 3));
is += 4;
const __m256i q4bits1 = _mm256_loadu_si256((const __m256i*)q4); q4 += 32;
const __m256i q4bits2 = _mm256_loadu_si256((const __m256i*)q4); q4 += 32;
const __m256i q4bitsH = _mm256_loadu_si256((const __m256i*)qh); qh += 32;
const __m256i q4h_0 = _mm256_slli_epi16(_mm256_and_si256(q4bitsH, m2), 4);
const __m256i q4h_1 = _mm256_slli_epi16(_mm256_and_si256(_mm256_srli_epi16(q4bitsH, 2), m2), 4);
const __m256i q4h_2 = _mm256_slli_epi16(_mm256_and_si256(_mm256_srli_epi16(q4bitsH, 4), m2), 4);
const __m256i q4h_3 = _mm256_slli_epi16(_mm256_and_si256(_mm256_srli_epi16(q4bitsH, 6), m2), 4);
const __m256i q4_0 = _mm256_or_si256(_mm256_and_si256(q4bits1, m4), q4h_0);
const __m256i q4_1 = _mm256_or_si256(_mm256_and_si256(q4bits2, m4), q4h_1);
const __m256i q4_2 = _mm256_or_si256(_mm256_and_si256(_mm256_srli_epi16(q4bits1, 4), m4), q4h_2);
const __m256i q4_3 = _mm256_or_si256(_mm256_and_si256(_mm256_srli_epi16(q4bits2, 4), m4), q4h_3);
const __m256i q8_0 = _mm256_loadu_si256((const __m256i*)q8); q8 += 32;
const __m256i q8_1 = _mm256_loadu_si256((const __m256i*)q8); q8 += 32;
const __m256i q8_2 = _mm256_loadu_si256((const __m256i*)q8); q8 += 32;
const __m256i q8_3 = _mm256_loadu_si256((const __m256i*)q8); q8 += 32;
__m256i q8s_0 = _mm256_maddubs_epi16(m32s, q8_0);
__m256i q8s_1 = _mm256_maddubs_epi16(m32s, q8_1);
__m256i q8s_2 = _mm256_maddubs_epi16(m32s, q8_2);
__m256i q8s_3 = _mm256_maddubs_epi16(m32s, q8_3);
__m256i p16_0 = _mm256_maddubs_epi16(q4_0, q8_0);
__m256i p16_1 = _mm256_maddubs_epi16(q4_1, q8_1);
__m256i p16_2 = _mm256_maddubs_epi16(q4_2, q8_2);
__m256i p16_3 = _mm256_maddubs_epi16(q4_3, q8_3);
p16_0 = _mm256_sub_epi16(p16_0, q8s_0);
p16_1 = _mm256_sub_epi16(p16_1, q8s_1);
p16_2 = _mm256_sub_epi16(p16_2, q8s_2);
p16_3 = _mm256_sub_epi16(p16_3, q8s_3);
p16_0 = _mm256_madd_epi16(_mm256_cvtepi8_epi16(scale_0), p16_0);
p16_1 = _mm256_madd_epi16(_mm256_cvtepi8_epi16(scale_1), p16_1);
p16_2 = _mm256_madd_epi16(_mm256_cvtepi8_epi16(scale_2), p16_2);
p16_3 = _mm256_madd_epi16(_mm256_cvtepi8_epi16(scale_3), p16_3);
sumi = _mm256_add_epi32(sumi, _mm256_add_epi32(p16_0, p16_1));
sumi = _mm256_add_epi32(sumi, _mm256_add_epi32(p16_2, p16_3));
}
acc = _mm256_fmadd_ps(_mm256_broadcast_ss(&d), _mm256_cvtepi32_ps(sumi), acc);
}
*s = hsum_float_8(acc);
#elif defined __AVX__
const __m128i m3 = _mm_set1_epi8(3);
const __m128i m15 = _mm_set1_epi8(15);
__m256 acc = _mm256_setzero_ps();
for (int i = 0; i < nb; ++i) {
const float d = y[i].d * GGML_FP16_TO_FP32(x[i].d);
const uint8_t * restrict q4 = x[i].ql;
const uint8_t * restrict qh = x[i].qh;
const int8_t * restrict q8 = y[i].qs;
// handle the q6_k -32 offset separately using bsums
const __m128i q8sums_0 = _mm_loadu_si128((const __m128i*)y[i].bsums);
const __m128i q8sums_1 = _mm_loadu_si128((const __m128i*)y[i].bsums + 1);
const __m128i scales = _mm_loadu_si128((const __m128i*)x[i].scales);
const __m128i scales_16_0 = _mm_cvtepi8_epi16(scales);
const __m128i scales_16_1 = _mm_cvtepi8_epi16(_mm_bsrli_si128(scales, 8));
const __m128i q8sclsub_0 = _mm_slli_epi32(_mm_madd_epi16(q8sums_0, scales_16_0), 5);
const __m128i q8sclsub_1 = _mm_slli_epi32(_mm_madd_epi16(q8sums_1, scales_16_1), 5);
__m128i sumi_0 = _mm_setzero_si128();
__m128i sumi_1 = _mm_setzero_si128();
int is = 0;
for (int j = 0; j < QK_K/128; ++j) {
const __m128i q4bitsH_0 = _mm_loadu_si128((const __m128i*)qh); qh += 16;
const __m128i q4bitsH_1 = _mm_loadu_si128((const __m128i*)qh); qh += 16;
const __m128i q4h_0 = _mm_slli_epi16(_mm_and_si128(q4bitsH_0, m3), 4);
const __m128i q4h_1 = _mm_slli_epi16(_mm_and_si128(q4bitsH_1, m3), 4);
const __m128i q4h_2 = _mm_slli_epi16(_mm_and_si128(q4bitsH_0, _mm_set1_epi8(12)), 2);
const __m128i q4h_3 = _mm_slli_epi16(_mm_and_si128(q4bitsH_1, _mm_set1_epi8(12)), 2);
const __m128i q4h_4 = _mm_and_si128(q4bitsH_0, _mm_set1_epi8(48));
const __m128i q4h_5 = _mm_and_si128(q4bitsH_1, _mm_set1_epi8(48));
const __m128i q4h_6 = _mm_srli_epi16(_mm_and_si128(q4bitsH_0, _mm_set1_epi8(-64)), 2);
const __m128i q4h_7 = _mm_srli_epi16(_mm_and_si128(q4bitsH_1, _mm_set1_epi8(-64)), 2);
const __m128i q4bits1_0 = _mm_loadu_si128((const __m128i*)q4); q4 += 16;
const __m128i q4bits1_1 = _mm_loadu_si128((const __m128i*)q4); q4 += 16;
const __m128i q4bits2_0 = _mm_loadu_si128((const __m128i*)q4); q4 += 16;
const __m128i q4bits2_1 = _mm_loadu_si128((const __m128i*)q4); q4 += 16;
const __m128i q4_0 = _mm_or_si128(_mm_and_si128(q4bits1_0, m15), q4h_0);
const __m128i q4_1 = _mm_or_si128(_mm_and_si128(q4bits1_1, m15), q4h_1);
const __m128i q4_2 = _mm_or_si128(_mm_and_si128(q4bits2_0, m15), q4h_2);
const __m128i q4_3 = _mm_or_si128(_mm_and_si128(q4bits2_1, m15), q4h_3);
const __m128i q4_4 = _mm_or_si128(_mm_and_si128(_mm_srli_epi16(q4bits1_0, 4), m15), q4h_4);
const __m128i q4_5 = _mm_or_si128(_mm_and_si128(_mm_srli_epi16(q4bits1_1, 4), m15), q4h_5);
const __m128i q4_6 = _mm_or_si128(_mm_and_si128(_mm_srli_epi16(q4bits2_0, 4), m15), q4h_6);
const __m128i q4_7 = _mm_or_si128(_mm_and_si128(_mm_srli_epi16(q4bits2_1, 4), m15), q4h_7);
const __m128i q8_0 = _mm_loadu_si128((const __m128i*)q8); q8 += 16;
const __m128i q8_1 = _mm_loadu_si128((const __m128i*)q8); q8 += 16;
const __m128i q8_2 = _mm_loadu_si128((const __m128i*)q8); q8 += 16;
const __m128i q8_3 = _mm_loadu_si128((const __m128i*)q8); q8 += 16;
const __m128i q8_4 = _mm_loadu_si128((const __m128i*)q8); q8 += 16;
const __m128i q8_5 = _mm_loadu_si128((const __m128i*)q8); q8 += 16;
const __m128i q8_6 = _mm_loadu_si128((const __m128i*)q8); q8 += 16;
const __m128i q8_7 = _mm_loadu_si128((const __m128i*)q8); q8 += 16;
__m128i p16_0 = _mm_maddubs_epi16(q4_0, q8_0);
__m128i p16_1 = _mm_maddubs_epi16(q4_1, q8_1);
__m128i p16_2 = _mm_maddubs_epi16(q4_2, q8_2);
__m128i p16_3 = _mm_maddubs_epi16(q4_3, q8_3);
__m128i p16_4 = _mm_maddubs_epi16(q4_4, q8_4);
__m128i p16_5 = _mm_maddubs_epi16(q4_5, q8_5);
__m128i p16_6 = _mm_maddubs_epi16(q4_6, q8_6);
__m128i p16_7 = _mm_maddubs_epi16(q4_7, q8_7);
const __m128i scale_0 = _mm_shuffle_epi8(scales, get_scale_shuffle(is + 0));
const __m128i scale_1 = _mm_shuffle_epi8(scales, get_scale_shuffle(is + 1));
const __m128i scale_2 = _mm_shuffle_epi8(scales, get_scale_shuffle(is + 2));
const __m128i scale_3 = _mm_shuffle_epi8(scales, get_scale_shuffle(is + 3));
is += 4;
p16_0 = _mm_madd_epi16(_mm_cvtepi8_epi16(scale_0), p16_0);
p16_1 = _mm_madd_epi16(_mm_cvtepi8_epi16(_mm_bsrli_si128(scale_0, 8)), p16_1);
p16_2 = _mm_madd_epi16(_mm_cvtepi8_epi16(scale_1), p16_2);
p16_3 = _mm_madd_epi16(_mm_cvtepi8_epi16(_mm_bsrli_si128(scale_1, 8)), p16_3);
p16_4 = _mm_madd_epi16(_mm_cvtepi8_epi16(scale_2), p16_4);
p16_5 = _mm_madd_epi16(_mm_cvtepi8_epi16(_mm_bsrli_si128(scale_2, 8)), p16_5);
p16_6 = _mm_madd_epi16(_mm_cvtepi8_epi16(scale_3), p16_6);
p16_7 = _mm_madd_epi16(_mm_cvtepi8_epi16(_mm_bsrli_si128(scale_3, 8)), p16_7);
sumi_0 = _mm_add_epi32(sumi_0, _mm_add_epi32(p16_0, p16_2));
sumi_1 = _mm_add_epi32(sumi_1, _mm_add_epi32(p16_1, p16_3));
sumi_0 = _mm_add_epi32(sumi_0, _mm_add_epi32(p16_4, p16_6));
sumi_1 = _mm_add_epi32(sumi_1, _mm_add_epi32(p16_5, p16_7));
}
sumi_0 = _mm_sub_epi32(sumi_0, q8sclsub_0);
sumi_1 = _mm_sub_epi32(sumi_1, q8sclsub_1);
const __m256i sumi = MM256_SET_M128I(sumi_1, sumi_0);
acc = _mm256_add_ps(_mm256_mul_ps(_mm256_set1_ps(d), _mm256_cvtepi32_ps(sumi)), acc);
}
*s = hsum_float_8(acc);
#elif defined __riscv_v_intrinsic
float sumf = 0;
for (int i = 0; i < nb; ++i) {
const float d = GGML_FP16_TO_FP32(x[i].d) * y[i].d;
const uint8_t * restrict q6 = x[i].ql;
const uint8_t * restrict qh = x[i].qh;
const int8_t * restrict q8 = y[i].qs;
const int8_t * restrict scale = x[i].scales;
size_t vl;
vint32m1_t vzero = __riscv_vmv_v_x_i32m1(0, 1);
int sum_t = 0;
int is = 0;
for (int j = 0; j < QK_K/128; ++j) {
vl = 32;
// load qh
vuint8m1_t qh_x = __riscv_vle8_v_u8m1(qh, vl);
// load Q6
vuint8m1_t q6_0 = __riscv_vle8_v_u8m1(q6, vl);
vuint8m1_t q6_1 = __riscv_vle8_v_u8m1(q6+32, vl);
vuint8m1_t q6a_0 = __riscv_vand_vx_u8m1(q6_0, 0x0F, vl);
vuint8m1_t q6a_1 = __riscv_vand_vx_u8m1(q6_1, 0x0F, vl);
vuint8m1_t q6s_0 = __riscv_vsrl_vx_u8m1(q6_0, 0x04, vl);
vuint8m1_t q6s_1 = __riscv_vsrl_vx_u8m1(q6_1, 0x04, vl);
vuint8m1_t qh_0 = __riscv_vand_vx_u8m1(qh_x, 0x03, vl);
vuint8m1_t qh_1 = __riscv_vand_vx_u8m1(__riscv_vsrl_vx_u8m1(qh_x, 0x2, vl), 0x03 , vl);
vuint8m1_t qh_2 = __riscv_vand_vx_u8m1(__riscv_vsrl_vx_u8m1(qh_x, 0x4, vl), 0x03 , vl);
vuint8m1_t qh_3 = __riscv_vand_vx_u8m1(__riscv_vsrl_vx_u8m1(qh_x, 0x6, vl), 0x03 , vl);
vuint8m1_t qhi_0 = __riscv_vor_vv_u8m1(q6a_0, __riscv_vsll_vx_u8m1(qh_0, 0x04, vl), vl);
vuint8m1_t qhi_1 = __riscv_vor_vv_u8m1(q6a_1, __riscv_vsll_vx_u8m1(qh_1, 0x04, vl), vl);
vuint8m1_t qhi_2 = __riscv_vor_vv_u8m1(q6s_0, __riscv_vsll_vx_u8m1(qh_2, 0x04, vl), vl);
vuint8m1_t qhi_3 = __riscv_vor_vv_u8m1(q6s_1, __riscv_vsll_vx_u8m1(qh_3, 0x04, vl), vl);
vint8m1_t a_0 = __riscv_vsub_vx_i8m1(__riscv_vreinterpret_v_u8m1_i8m1(qhi_0), 32, vl);
vint8m1_t a_1 = __riscv_vsub_vx_i8m1(__riscv_vreinterpret_v_u8m1_i8m1(qhi_1), 32, vl);
vint8m1_t a_2 = __riscv_vsub_vx_i8m1(__riscv_vreinterpret_v_u8m1_i8m1(qhi_2), 32, vl);
vint8m1_t a_3 = __riscv_vsub_vx_i8m1(__riscv_vreinterpret_v_u8m1_i8m1(qhi_3), 32, vl);
// load Q8 and take product
vint16m2_t va_q_0 = __riscv_vwmul_vv_i16m2(a_0, __riscv_vle8_v_i8m1(q8, vl), vl);
vint16m2_t va_q_1 = __riscv_vwmul_vv_i16m2(a_1, __riscv_vle8_v_i8m1(q8+32, vl), vl);
vint16m2_t va_q_2 = __riscv_vwmul_vv_i16m2(a_2, __riscv_vle8_v_i8m1(q8+64, vl), vl);
vint16m2_t va_q_3 = __riscv_vwmul_vv_i16m2(a_3, __riscv_vle8_v_i8m1(q8+96, vl), vl);
vl = 16;
vint32m2_t vaux_0 = __riscv_vwmul_vx_i32m2(__riscv_vget_v_i16m2_i16m1(va_q_0, 0), scale[is+0], vl);
vint32m2_t vaux_1 = __riscv_vwmul_vx_i32m2(__riscv_vget_v_i16m2_i16m1(va_q_0, 1), scale[is+1], vl);
vint32m2_t vaux_2 = __riscv_vwmul_vx_i32m2(__riscv_vget_v_i16m2_i16m1(va_q_1, 0), scale[is+2], vl);
vint32m2_t vaux_3 = __riscv_vwmul_vx_i32m2(__riscv_vget_v_i16m2_i16m1(va_q_1, 1), scale[is+3], vl);
vint32m2_t vaux_4 = __riscv_vwmul_vx_i32m2(__riscv_vget_v_i16m2_i16m1(va_q_2, 0), scale[is+4], vl);
vint32m2_t vaux_5 = __riscv_vwmul_vx_i32m2(__riscv_vget_v_i16m2_i16m1(va_q_2, 1), scale[is+5], vl);
vint32m2_t vaux_6 = __riscv_vwmul_vx_i32m2(__riscv_vget_v_i16m2_i16m1(va_q_3, 0), scale[is+6], vl);
vint32m2_t vaux_7 = __riscv_vwmul_vx_i32m2(__riscv_vget_v_i16m2_i16m1(va_q_3, 1), scale[is+7], vl);
vint32m1_t isum0 = __riscv_vredsum_vs_i32m2_i32m1(__riscv_vadd_vv_i32m2(vaux_0, vaux_1, vl), vzero, vl);
vint32m1_t isum1 = __riscv_vredsum_vs_i32m2_i32m1(__riscv_vadd_vv_i32m2(vaux_2, vaux_3, vl), isum0, vl);
vint32m1_t isum2 = __riscv_vredsum_vs_i32m2_i32m1(__riscv_vadd_vv_i32m2(vaux_4, vaux_5, vl), isum1, vl);
vint32m1_t isum3 = __riscv_vredsum_vs_i32m2_i32m1(__riscv_vadd_vv_i32m2(vaux_6, vaux_7, vl), isum2, vl);
sum_t += __riscv_vmv_x_s_i32m1_i32(isum3);
q6 += 64; qh += 32; q8 += 128; is=8;
}
sumf += d * sum_t;
}
*s = sumf;
#elif defined(__POWER9_VECTOR__)
const vector signed char lowMask = vec_splats((signed char)0xF);
const vector int v0 = vec_splats((int32_t)0);
const vector unsigned char v2 = vec_splats((unsigned char)0x2);
const vector unsigned char v3 = vec_splats((unsigned char)0x3);
const vector unsigned char v4 = vec_splats((unsigned char)0x4);
const vector unsigned char v6 = vec_splats((unsigned char)0x6);
const vector signed char off = vec_splats((signed char)0x20);
vector float vsumf0 = vec_splats(0.0f);
vector float vsumf1 = vec_splats(0.0f);
vector float vsumf2 = vec_splats(0.0f);
vector float vsumf3 = vec_splats(0.0f);
for (int i = 0; i < nb; ++i) {
vector float vxd = vec_splats(GGML_FP16_TO_FP32(x[i].d));
vector float vyd = vec_splats(y[i].d);
vector float vd = vec_mul(vxd, vyd);
vector signed int vsumi0 = v0;
vector signed int vsumi1 = v0;
vector signed int vsumi2 = v0;
vector signed int vsumi3 = v0;
vector signed int vsumi4 = v0;
vector signed int vsumi5 = v0;
vector signed int vsumi6 = v0;
vector signed int vsumi7 = v0;
const uint8_t * restrict q6 = x[i].ql;
const uint8_t * restrict qh = x[i].qh;
const int8_t * restrict qs = x[i].scales;
const int8_t * restrict q8 = y[i].qs;
for (int j = 0; j < QK_K/128; ++j) {
__builtin_prefetch(q6, 0, 0);
__builtin_prefetch(qh, 0, 0);
__builtin_prefetch(q8, 0, 0);
vector signed char qxs0 = (vector signed char)vec_xl( 0, q6);
vector signed char qxs1 = (vector signed char)vec_xl(16, q6);
vector signed char qxs2 = (vector signed char)vec_xl(32, q6);
vector signed char qxs3 = (vector signed char)vec_xl(48, q6);
q6 += 64;
vector signed char qxs00 = vec_and(qxs0, lowMask);
vector signed char qxs01 = vec_sr(qxs0, v4);
vector signed char qxs10 = vec_and(qxs1, lowMask);
vector signed char qxs11 = vec_sr(qxs1, v4);
vector signed char qxs20 = vec_and(qxs2, lowMask);
vector signed char qxs21 = vec_sr(qxs2, v4);
vector signed char qxs30 = vec_and(qxs3, lowMask);
vector signed char qxs31 = vec_sr(qxs3, v4);
vector signed char qxhs0 = (vector signed char)vec_xl( 0, qh);
vector signed char qxhs1 = (vector signed char)vec_xl(16, qh);
qh += 32;
vector signed char qxh00 = vec_sl(vec_and((vector signed char)v3, qxhs0), v4);
vector signed char qxh01 = vec_sl(vec_and((vector signed char)v3, vec_sr(qxhs0, v4)), v4);
vector signed char qxh10 = vec_sl(vec_and((vector signed char)v3, qxhs1), v4);
vector signed char qxh11 = vec_sl(vec_and((vector signed char)v3, vec_sr(qxhs1, v4)), v4);
vector signed char qxh20 = vec_sl(vec_and((vector signed char)v3, vec_sr(qxhs0, v2)), v4);
vector signed char qxh21 = vec_sl(vec_and((vector signed char)v3, vec_sr(qxhs0, v6)), v4);
vector signed char qxh30 = vec_sl(vec_and((vector signed char)v3, vec_sr(qxhs1, v2)), v4);
vector signed char qxh31 = vec_sl(vec_and((vector signed char)v3, vec_sr(qxhs1, v6)), v4);
vector signed char q6x00 = vec_sub(vec_or(qxh00, qxs00), off);
vector signed char q6x01 = vec_sub(vec_or(qxh01, qxs01), off);
vector signed char q6x10 = vec_sub(vec_or(qxh10, qxs10), off);
vector signed char q6x11 = vec_sub(vec_or(qxh11, qxs11), off);
vector signed char q6x20 = vec_sub(vec_or(qxh20, qxs20), off);
vector signed char q6x21 = vec_sub(vec_or(qxh21, qxs21), off);
vector signed char q6x30 = vec_sub(vec_or(qxh30, qxs30), off);
vector signed char q6x31 = vec_sub(vec_or(qxh31, qxs31), off);
vector signed char q8y00 = vec_xl( 0, q8);
vector signed char q8y10 = vec_xl( 16, q8);
vector signed char q8y20 = vec_xl( 32, q8);
vector signed char q8y30 = vec_xl( 48, q8);
vector signed char q8y01 = vec_xl( 64, q8);
vector signed char q8y11 = vec_xl( 80, q8);
vector signed char q8y21 = vec_xl( 96, q8);
vector signed char q8y31 = vec_xl(112, q8);
q8 += 128;
vector signed short qv00 = vec_add(vec_mule(q6x00, q8y00), vec_mulo(q6x00, q8y00));
vector signed short qv10 = vec_add(vec_mule(q6x10, q8y10), vec_mulo(q6x10, q8y10));
vector signed short qv20 = vec_add(vec_mule(q6x20, q8y20), vec_mulo(q6x20, q8y20));
vector signed short qv30 = vec_add(vec_mule(q6x30, q8y30), vec_mulo(q6x30, q8y30));
vector signed short qv01 = vec_add(vec_mule(q6x01, q8y01), vec_mulo(q6x01, q8y01));
vector signed short qv11 = vec_add(vec_mule(q6x11, q8y11), vec_mulo(q6x11, q8y11));
vector signed short qv21 = vec_add(vec_mule(q6x21, q8y21), vec_mulo(q6x21, q8y21));
vector signed short qv31 = vec_add(vec_mule(q6x31, q8y31), vec_mulo(q6x31, q8y31));
vector signed short vscales = vec_unpackh(vec_xl_len(qs, 8));
qs += 8;
vector signed short vs0 = vec_splat(vscales, 0);
vector signed short vs1 = vec_splat(vscales, 1);
vector signed short vs2 = vec_splat(vscales, 2);
vector signed short vs3 = vec_splat(vscales, 3);
vector signed short vs4 = vec_splat(vscales, 4);
vector signed short vs5 = vec_splat(vscales, 5);
vector signed short vs6 = vec_splat(vscales, 6);
vector signed short vs7 = vec_splat(vscales, 7);
vsumi0 = vec_msum(qv00, vs0, vsumi0);
vsumi1 = vec_msum(qv01, vs4, vsumi1);
vsumi2 = vec_msum(qv10, vs1, vsumi2);
vsumi3 = vec_msum(qv11, vs5, vsumi3);
vsumi4 = vec_msum(qv20, vs2, vsumi4);
vsumi5 = vec_msum(qv21, vs6, vsumi5);
vsumi6 = vec_msum(qv30, vs3, vsumi6);
vsumi7 = vec_msum(qv31, vs7, vsumi7);
}
vsumi0 = vec_add(vsumi0, vsumi4);
vsumi1 = vec_add(vsumi1, vsumi5);
vsumi2 = vec_add(vsumi2, vsumi6);
vsumi3 = vec_add(vsumi3, vsumi7);
vsumf0 = vec_madd(vec_ctf(vsumi0, 0), vd, vsumf0);
vsumf1 = vec_madd(vec_ctf(vsumi1, 0), vd, vsumf1);
vsumf2 = vec_madd(vec_ctf(vsumi2, 0), vd, vsumf2);
vsumf3 = vec_madd(vec_ctf(vsumi3, 0), vd, vsumf3);
}
vsumf0 = vec_add(vsumf0, vsumf2);
vsumf1 = vec_add(vsumf1, vsumf3);
vsumf0 = vec_add(vsumf0, vsumf1);
vsumf0 = vec_add(vsumf0, vec_sld(vsumf0, vsumf0, 4));
vsumf0 = vec_add(vsumf0, vec_sld(vsumf0, vsumf0, 8));
*s = vec_extract(vsumf0, 0);
#elif defined __loongarch_asx
const __m256i m4 = __lasx_xvreplgr2vr_b(0xF);
const __m256i m2 = __lasx_xvreplgr2vr_b(3);
const __m256i m32s = __lasx_xvreplgr2vr_b(32);
__m256 acc = (__m256)__lasx_xvldi(0);
for (int i = 0; i < nb; ++i) {
const float d = y[i].d * GGML_FP16_TO_FP32(x[i].d);
const uint8_t * restrict q4 = x[i].ql;
const uint8_t * restrict qh = x[i].qh;
const int8_t * restrict q8 = y[i].qs;
const __m128i scales = __lsx_vld((const __m128i*)x[i].scales, 0);
__m256i sumi = __lasx_xvldi(0);
int is = 0;
for (int j = 0; j < QK_K/128; ++j) {
const __m128i scale_0 = lsx_shuffle_b(scales, get_scale_shuffle(is + 0));
const __m128i scale_1 = lsx_shuffle_b(scales, get_scale_shuffle(is + 1));
const __m128i scale_2 = lsx_shuffle_b(scales, get_scale_shuffle(is + 2));
const __m128i scale_3 = lsx_shuffle_b(scales, get_scale_shuffle(is + 3));
is += 4;
const __m256i q4bits1 = __lasx_xvld((const __m256i*)q4, 0); q4 += 32;
const __m256i q4bits2 = __lasx_xvld((const __m256i*)q4, 0); q4 += 32;
const __m256i q4bitsH = __lasx_xvld((const __m256i*)qh, 0); qh += 32;
const __m256i q4h_0 = __lasx_xvslli_h(__lasx_xvand_v(q4bitsH, m2), 4);
const __m256i q4h_1 = __lasx_xvslli_h(__lasx_xvand_v(__lasx_xvsrli_h(q4bitsH, 2), m2), 4);
const __m256i q4h_2 = __lasx_xvslli_h(__lasx_xvand_v(__lasx_xvsrli_h(q4bitsH, 4), m2), 4);
const __m256i q4h_3 = __lasx_xvslli_h(__lasx_xvand_v(__lasx_xvsrli_h(q4bitsH, 6), m2), 4);
const __m256i q4_0 = __lasx_xvor_v(__lasx_xvand_v(q4bits1, m4), q4h_0);
const __m256i q4_1 = __lasx_xvor_v(__lasx_xvand_v(q4bits2, m4), q4h_1);
const __m256i q4_2 = __lasx_xvor_v(__lasx_xvand_v(__lasx_xvsrli_h(q4bits1, 4), m4), q4h_2);
const __m256i q4_3 = __lasx_xvor_v(__lasx_xvand_v(__lasx_xvsrli_h(q4bits2, 4), m4), q4h_3);
const __m256i q8_0 = __lasx_xvld((const __m256i*)q8, 0); q8 += 32;
const __m256i q8_1 = __lasx_xvld((const __m256i*)q8, 0); q8 += 32;
const __m256i q8_2 = __lasx_xvld((const __m256i*)q8, 0); q8 += 32;
const __m256i q8_3 = __lasx_xvld((const __m256i*)q8, 0); q8 += 32;
__m256i q8s_0 = lasx_maddubs_h(m32s, q8_0);
__m256i q8s_1 = lasx_maddubs_h(m32s, q8_1);
__m256i q8s_2 = lasx_maddubs_h(m32s, q8_2);
__m256i q8s_3 = lasx_maddubs_h(m32s, q8_3);
__m256i p16_0 = lasx_maddubs_h(q4_0, q8_0);
__m256i p16_1 = lasx_maddubs_h(q4_1, q8_1);
__m256i p16_2 = lasx_maddubs_h(q4_2, q8_2);
__m256i p16_3 = lasx_maddubs_h(q4_3, q8_3);
p16_0 = __lasx_xvsub_h(p16_0, q8s_0);
p16_1 = __lasx_xvsub_h(p16_1, q8s_1);
p16_2 = __lasx_xvsub_h(p16_2, q8s_2);
p16_3 = __lasx_xvsub_h(p16_3, q8s_3);
p16_0 = lasx_madd_h(lasx_ext8_16(scale_0), p16_0);
p16_1 = lasx_madd_h(lasx_ext8_16(scale_1), p16_1);
p16_2 = lasx_madd_h(lasx_ext8_16(scale_2), p16_2);
p16_3 = lasx_madd_h(lasx_ext8_16(scale_3), p16_3);
sumi = __lasx_xvadd_w(sumi, __lasx_xvadd_w(p16_0, p16_1));
sumi = __lasx_xvadd_w(sumi, __lasx_xvadd_w(p16_2, p16_3));
}
acc = __lasx_xvfmadd_s((__m256)__lasx_xvreplfr2vr_s(d), __lasx_xvffint_s_w(sumi), acc);
}
*s = hsum_float_8(acc);
#else
int8_t aux8[QK_K];
int16_t aux16[8];
float sums [8];
int32_t aux32[8];
memset(sums, 0, 8*sizeof(float));
float sumf = 0;
for (int i = 0; i < nb; ++i) {
const uint8_t * restrict q4 = x[i].ql;
const uint8_t * restrict qh = x[i].qh;
const int8_t * restrict q8 = y[i].qs;
memset(aux32, 0, 8*sizeof(int32_t));
int8_t * restrict a = aux8;
for (int j = 0; j < QK_K; j += 128) {
for (int l = 0; l < 32; ++l) {
a[l + 0] = (int8_t)((q4[l + 0] & 0xF) | (((qh[l] >> 0) & 3) << 4)) - 32;
a[l + 32] = (int8_t)((q4[l + 32] & 0xF) | (((qh[l] >> 2) & 3) << 4)) - 32;
a[l + 64] = (int8_t)((q4[l + 0] >> 4) | (((qh[l] >> 4) & 3) << 4)) - 32;
a[l + 96] = (int8_t)((q4[l + 32] >> 4) | (((qh[l] >> 6) & 3) << 4)) - 32;
}
a += 128;
q4 += 64;
qh += 32;
}
a = aux8;
int is = 0;
for (int j = 0; j < QK_K/16; ++j) {
int scale = x[i].scales[is++];
for (int l = 0; l < 8; ++l) aux16[l] = q8[l] * a[l];
for (int l = 0; l < 8; ++l) aux32[l] += scale * aux16[l];
q8 += 8; a += 8;
for (int l = 0; l < 8; ++l) aux16[l] = q8[l] * a[l];
for (int l = 0; l < 8; ++l) aux32[l] += scale * aux16[l];
q8 += 8; a += 8;
}
const float d = GGML_FP16_TO_FP32(x[i].d) * y[i].d;
for (int l = 0; l < 8; ++l) sums[l] += d * aux32[l];
}
for (int l = 0; l < 8; ++l) sumf += sums[l];
*s = sumf;
#endif
} | O1 | c | ggml_vec_dot_q6_K_q8_K:
pushq %r14
pushq %rbx
pushq %rax
testb %dil, %dil
jne 0x3323b
cmpl $0x1, 0x28(%rsp)
jne 0x3325a
sarl $0x8, %edi
testl %edi, %edi
jle 0x33211
movl %edi, %eax
leaq 0x4(%r9), %rdx
vxorps %xmm3, %xmm3, %xmm3
xorl %edi, %edi
movq 0x15f0c(%rip), %r8 # 0x48f68
leaq 0xfccd(%rip), %r10 # 0x42d30
vpbroadcastq 0x7364(%rip), %ymm0 # 0x3a3d0
vpbroadcastq 0x734b(%rip), %ymm1 # 0x3a3c0
vpbroadcastb 0x7395(%rip), %ymm2 # 0x3a413
movq %rcx, %r11
imulq $0x124, %rdi, %rbx # imm = 0x124
vmovss (%r9,%rbx), %xmm4
imulq $0xd2, %rdi, %rbx
movzwl 0xd0(%rcx,%rbx), %r14d
vmovss (%r8,%r14,4), %xmm5
vmovdqu 0xc0(%rcx,%rbx), %xmm6
xorl %ebx, %ebx
vpxor %xmm7, %xmm7, %xmm7
vpshufb (%r10,%rbx,2), %xmm6, %xmm8
vpshufb 0x10(%r10,%rbx,2), %xmm6, %xmm9
vpshufb 0x20(%r10,%rbx,2), %xmm6, %xmm10
vpshufb 0x30(%r10,%rbx,2), %xmm6, %xmm11
vmovdqu (%r11,%rbx,2), %ymm12
vmovdqu 0x20(%r11,%rbx,2), %ymm13
vmovdqu 0x80(%r11,%rbx), %ymm14
vpsllw $0x4, %ymm14, %ymm15
vpand %ymm0, %ymm15, %ymm15
vpsllw $0x2, %ymm14, %ymm16
vpandq %ymm0, %ymm16, %ymm16
vpsrlw $0x2, %ymm14, %ymm17
vpandq %ymm0, %ymm17, %ymm17
vpternlogq $0xf8, %ymm1, %ymm12, %ymm15
vpternlogq $0xf8, %ymm1, %ymm13, %ymm16
vpsrlw $0x4, %ymm12, %ymm12
vpand %ymm1, %ymm12, %ymm12
vpternlogq $0xf8, %ymm0, %ymm14, %ymm12
vpsrlw $0x4, %ymm13, %ymm13
vpternlogq $0xec, %ymm1, %ymm17, %ymm13
vmovdqu (%rdx,%rbx,4), %ymm14
vmovdqu64 0x20(%rdx,%rbx,4), %ymm17
vmovdqu64 0x40(%rdx,%rbx,4), %ymm18
vmovdqu64 0x60(%rdx,%rbx,4), %ymm19
vpmaddubsw %ymm14, %ymm2, %ymm20
vpmaddubsw %ymm17, %ymm2, %ymm21
vpmaddubsw %ymm18, %ymm2, %ymm22
vpmaddubsw %ymm19, %ymm2, %ymm23
vpmaddubsw %ymm14, %ymm15, %ymm14
vpsubw %ymm20, %ymm14, %ymm14
vpmaddubsw %ymm17, %ymm16, %ymm15
vpsubw %ymm21, %ymm15, %ymm15
vpmaddubsw %ymm18, %ymm12, %ymm12
vpsubw %ymm22, %ymm12, %ymm12
vpmaddubsw %ymm19, %ymm13, %ymm13
vpsubw %ymm23, %ymm13, %ymm13
vpmovsxbw %xmm8, %ymm8
vpmaddwd %ymm14, %ymm8, %ymm8
vpaddd %ymm7, %ymm8, %ymm7
vpmovsxbw %xmm9, %ymm8
vpmaddwd %ymm15, %ymm8, %ymm8
vpmovsxbw %xmm10, %ymm9
vpmaddwd %ymm12, %ymm9, %ymm9
vpaddd %ymm9, %ymm8, %ymm8
vpaddd %ymm7, %ymm8, %ymm7
vpmovsxbw %xmm11, %ymm8
vpmaddwd %ymm13, %ymm8, %ymm8
vpaddd %ymm7, %ymm8, %ymm7
addq $0x20, %rbx
cmpl $0x20, %ebx
je 0x330b3
vmulss %xmm5, %xmm4, %xmm4
vbroadcastss %xmm4, %ymm5
vcvtdq2ps %ymm7, %ymm4
vfmadd213ps %ymm3, %ymm5, %ymm4 # ymm4 = (ymm5 * ymm4) + ymm3
incq %rdi
addq $0xd2, %r11
addq $0x124, %rdx # imm = 0x124
vmovaps %ymm4, %ymm3
cmpq %rax, %rdi
jne 0x33081
jmp 0x33215
vxorps %xmm4, %xmm4, %xmm4
vextractf128 $0x1, %ymm4, %xmm0
vaddps %xmm4, %xmm0, %xmm0
vshufpd $0x1, %xmm0, %xmm0, %xmm1 # xmm1 = xmm0[1,0]
vaddps %xmm1, %xmm0, %xmm0
vhaddps %xmm0, %xmm0, %xmm0
vmovss %xmm0, (%rsi)
addq $0x8, %rsp
popq %rbx
popq %r14
vzeroupper
retq
leaq 0x101fe(%rip), %rdi # 0x43440
leaq 0xfba7(%rip), %rsi # 0x42df0
leaq 0x1036f(%rip), %rcx # 0x435bf
movl $0x1a6b, %edx # imm = 0x1A6B
callq 0x83b0
leaq 0x382d(%rip), %rdi # 0x36a8e
leaq 0xfb88(%rip), %rsi # 0x42df0
leaq 0x10350(%rip), %rcx # 0x435bf
movl $0x1a6c, %edx # imm = 0x1A6C
callq 0x83b0
| ggml_vec_dot_q6_K_q8_K:
push r14
push rbx
push rax
test dil, dil
jnz loc_3323B
cmp [rsp+18h+arg_8], 1
jnz loc_3325A
sar edi, 8
test edi, edi
jle loc_33211
mov eax, edi
lea rdx, [r9+4]
vxorps xmm3, xmm3, xmm3
xor edi, edi
mov r8, cs:ggml_table_f32_f16_ptr
lea r10, get_scale_shuffle_k_shuffle
vpbroadcastq ymm0, cs:qword_3A3D0
vpbroadcastq ymm1, cs:qword_3A3C0
vpbroadcastb ymm2, cs:byte_3A413
mov r11, rcx
loc_33081:
imul rbx, rdi, 124h
vmovss xmm4, dword ptr [r9+rbx]
imul rbx, rdi, 0D2h
movzx r14d, word ptr [rcx+rbx+0D0h]
vmovss xmm5, dword ptr [r8+r14*4]
vmovdqu xmm6, xmmword ptr [rcx+rbx+0C0h]
xor ebx, ebx
vpxor xmm7, xmm7, xmm7
loc_330B3:
vpshufb xmm8, xmm6, xmmword ptr [r10+rbx*2]
vpshufb xmm9, xmm6, xmmword ptr [r10+rbx*2+10h]
vpshufb xmm10, xmm6, xmmword ptr [r10+rbx*2+20h]
vpshufb xmm11, xmm6, xmmword ptr [r10+rbx*2+30h]
vmovdqu ymm12, ymmword ptr [r11+rbx*2]
vmovdqu ymm13, ymmword ptr [r11+rbx*2+20h]
vmovdqu ymm14, ymmword ptr [r11+rbx+80h]
vpsllw ymm15, ymm14, 4
vpand ymm15, ymm15, ymm0
vpsllw ymm16, ymm14, 2
vpandq ymm16, ymm16, ymm0
vpsrlw ymm17, ymm14, 2
vpandq ymm17, ymm17, ymm0
vpternlogq ymm15, ymm12, ymm1, 0F8h
vpternlogq ymm16, ymm13, ymm1, 0F8h
vpsrlw ymm12, ymm12, 4
vpand ymm12, ymm12, ymm1
vpternlogq ymm12, ymm14, ymm0, 0F8h
vpsrlw ymm13, ymm13, 4
vpternlogq ymm13, ymm17, ymm1, 0ECh
vmovdqu ymm14, ymmword ptr [rdx+rbx*4]
vmovdqu64 ymm17, ymmword ptr [rdx+rbx*4+20h]
vmovdqu64 ymm18, ymmword ptr [rdx+rbx*4+40h]
vmovdqu64 ymm19, ymmword ptr [rdx+rbx*4+60h]
vpmaddubsw ymm20, ymm2, ymm14
vpmaddubsw ymm21, ymm2, ymm17
vpmaddubsw ymm22, ymm2, ymm18
vpmaddubsw ymm23, ymm2, ymm19
vpmaddubsw ymm14, ymm15, ymm14
vpsubw ymm14, ymm14, ymm20
vpmaddubsw ymm15, ymm16, ymm17
vpsubw ymm15, ymm15, ymm21
vpmaddubsw ymm12, ymm12, ymm18
vpsubw ymm12, ymm12, ymm22
vpmaddubsw ymm13, ymm13, ymm19
vpsubw ymm13, ymm13, ymm23
vpmovsxbw ymm8, xmm8
vpmaddwd ymm8, ymm8, ymm14
vpaddd ymm7, ymm8, ymm7
vpmovsxbw ymm8, xmm9
vpmaddwd ymm8, ymm8, ymm15
vpmovsxbw ymm9, xmm10
vpmaddwd ymm9, ymm9, ymm12
vpaddd ymm8, ymm8, ymm9
vpaddd ymm7, ymm8, ymm7
vpmovsxbw ymm8, xmm11
vpmaddwd ymm8, ymm8, ymm13
vpaddd ymm7, ymm8, ymm7
add rbx, 20h ; ' '
cmp ebx, 20h ; ' '
jz loc_330B3
vmulss xmm4, xmm4, xmm5
vbroadcastss ymm5, xmm4
vcvtdq2ps ymm4, ymm7
vfmadd213ps ymm4, ymm5, ymm3
inc rdi
add r11, 0D2h
add rdx, 124h
vmovaps ymm3, ymm4
cmp rdi, rax
jnz loc_33081
jmp short loc_33215
loc_33211:
vxorps xmm4, xmm4, xmm4
loc_33215:
vextractf128 xmm0, ymm4, 1
vaddps xmm0, xmm0, xmm4
vshufpd xmm1, xmm0, xmm0, 1
vaddps xmm0, xmm0, xmm1
vhaddps xmm0, xmm0, xmm0
vmovss dword ptr [rsi], xmm0
add rsp, 8
pop rbx
pop r14
vzeroupper
retn
loc_3323B:
lea rdi, aNQkK0; "n % QK_K == 0"
lea rsi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidGgmlVecDot_13; "void ggml_vec_dot_q6_K_q8_K(int, float "...
mov edx, 1A6Bh
call ___assert_fail
loc_3325A:
lea rdi, aNrc1; "nrc == 1"
lea rsi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidGgmlVecDot_13; "void ggml_vec_dot_q6_K_q8_K(int, float "...
mov edx, 1A6Ch
call ___assert_fail
| long long ggml_vec_dot_q6_K_q8_K(
int a1,
long long _RSI,
double a3,
double a4,
double a5,
__m128 _XMM3,
__m128 _XMM4,
double a8,
double a9,
__m128 _XMM7,
long long a11,
long long _RCX,
long long a13,
long long _R9,
int a15,
int a16)
{
long long result; // rax
int v18; // edi
long long v21; // rdi
if ( (_BYTE)a1 )
__assert_fail(
"n % QK_K == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-quants.c",
6763LL,
"void ggml_vec_dot_q6_K_q8_K(int, float *restrict, size_t, const void *restrict, size_t, const void *restrict, size_t, int)");
if ( a16 != 1 )
__assert_fail(
"nrc == 1",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-quants.c",
6764LL,
"void ggml_vec_dot_q6_K_q8_K(int, float *restrict, size_t, const void *restrict, size_t, const void *restrict, size_t, int)");
v18 = a1 >> 8;
if ( v18 <= 0 )
{
__asm { vxorps xmm4, xmm4, xmm4 }
}
else
{
result = (unsigned int)v18;
_RDX = _R9 + 4;
__asm { vxorps xmm3, xmm3, xmm3 }
v21 = 0LL;
_R8 = &ggml_table_f32_f16;
__asm
{
vpbroadcastq ymm0, cs:qword_3A3D0
vpbroadcastq ymm1, cs:qword_3A3C0
vpbroadcastb ymm2, cs:byte_3A413
}
_R11 = _RCX;
do
{
_RBX = 292 * v21;
__asm { vmovss xmm4, dword ptr [r9+rbx] }
_RBX = 210 * v21;
_R14 = *(unsigned __int16 *)(_RCX + 210 * v21 + 208);
__asm
{
vmovss xmm5, dword ptr [r8+r14*4]
vmovdqu xmm6, xmmword ptr [rcx+rbx+0C0h]
}
_RBX = 0LL;
__asm { vpxor xmm7, xmm7, xmm7 }
do
{
__asm
{
vpshufb xmm8, xmm6, xmmword ptr [r10+rbx*2]
vpshufb xmm9, xmm6, xmmword ptr [r10+rbx*2+10h]
vpshufb xmm10, xmm6, xmmword ptr [r10+rbx*2+20h]
vpshufb xmm11, xmm6, xmmword ptr [r10+rbx*2+30h]
vmovdqu ymm12, ymmword ptr [r11+rbx*2]
vmovdqu ymm13, ymmword ptr [r11+rbx*2+20h]
vmovdqu ymm14, ymmword ptr [r11+rbx+80h]
vpsllw ymm15, ymm14, 4
vpand ymm15, ymm15, ymm0
vpsllw ymm16, ymm14, 2
vpandq ymm16, ymm16, ymm0
vpsrlw ymm17, ymm14, 2
vpandq ymm17, ymm17, ymm0
vpternlogq ymm15, ymm12, ymm1, 0F8h
vpternlogq ymm16, ymm13, ymm1, 0F8h
vpsrlw ymm12, ymm12, 4
vpand ymm12, ymm12, ymm1
vpternlogq ymm12, ymm14, ymm0, 0F8h
vpsrlw ymm13, ymm13, 4
vpternlogq ymm13, ymm17, ymm1, 0ECh
vmovdqu ymm14, ymmword ptr [rdx+rbx*4]
vmovdqu64 ymm17, ymmword ptr [rdx+rbx*4+20h]
vmovdqu64 ymm18, ymmword ptr [rdx+rbx*4+40h]
vmovdqu64 ymm19, ymmword ptr [rdx+rbx*4+60h]
vpmaddubsw ymm20, ymm2, ymm14
vpmaddubsw ymm21, ymm2, ymm17
vpmaddubsw ymm22, ymm2, ymm18
vpmaddubsw ymm23, ymm2, ymm19
vpmaddubsw ymm14, ymm15, ymm14
vpsubw ymm14, ymm14, ymm20
vpmaddubsw ymm15, ymm16, ymm17
vpsubw ymm15, ymm15, ymm21
vpmaddubsw ymm12, ymm12, ymm18
vpsubw ymm12, ymm12, ymm22
vpmaddubsw ymm13, ymm13, ymm19
vpsubw ymm13, ymm13, ymm23
vpmovsxbw ymm8, xmm8
vpmaddwd ymm8, ymm8, ymm14
vpaddd ymm7, ymm8, ymm7
vpmovsxbw ymm8, xmm9
vpmaddwd ymm8, ymm8, ymm15
vpmovsxbw ymm9, xmm10
vpmaddwd ymm9, ymm9, ymm12
vpaddd ymm8, ymm8, ymm9
vpaddd ymm7, ymm8, ymm7
vpmovsxbw ymm8, xmm11
vpmaddwd ymm8, ymm8, ymm13
vpaddd ymm7, ymm8, ymm7
}
_RBX += 32LL;
}
while ( (_DWORD)_RBX == 32 );
__asm
{
vmulss xmm4, xmm4, xmm5
vbroadcastss ymm5, xmm4
vcvtdq2ps ymm4, ymm7
vfmadd213ps ymm4, ymm5, ymm3
}
++v21;
_R11 += 210LL;
_RDX += 292LL;
__asm { vmovaps ymm3, ymm4 }
}
while ( v21 != result );
}
__asm
{
vextractf128 xmm0, ymm4, 1
vaddps xmm0, xmm0, xmm4
vshufpd xmm1, xmm0, xmm0, 1
vaddps xmm0, xmm0, xmm1
vhaddps xmm0, xmm0, xmm0
vmovss dword ptr [rsi], xmm0
vzeroupper
}
return result;
}
| ggml_vec_dot_q6_K_q8_K:
PUSH R14
PUSH RBX
PUSH RAX
TEST DIL,DIL
JNZ 0x0013323b
CMP dword ptr [RSP + 0x28],0x1
JNZ 0x0013325a
SAR EDI,0x8
TEST EDI,EDI
JLE 0x00133211
MOV EAX,EDI
LEA RDX,[R9 + 0x4]
VXORPS XMM3,XMM3,XMM3
XOR EDI,EDI
MOV R8,qword ptr [0x00148f68]
LEA R10,[0x142d30]
VPBROADCASTQ YMM0,qword ptr [0x0013a3d0]
VPBROADCASTQ YMM1,qword ptr [0x0013a3c0]
VPBROADCASTB YMM2,byte ptr [0x0013a413]
MOV R11,RCX
LAB_00133081:
IMUL RBX,RDI,0x124
VMOVSS XMM4,dword ptr [R9 + RBX*0x1]
IMUL RBX,RDI,0xd2
MOVZX R14D,word ptr [RCX + RBX*0x1 + 0xd0]
VMOVSS XMM5,dword ptr [R8 + R14*0x4]
VMOVDQU XMM6,xmmword ptr [RCX + RBX*0x1 + 0xc0]
XOR EBX,EBX
VPXOR XMM7,XMM7,XMM7
LAB_001330b3:
VPSHUFB XMM8,XMM6,xmmword ptr [R10 + RBX*0x2]
VPSHUFB XMM9,XMM6,xmmword ptr [R10 + RBX*0x2 + 0x10]
VPSHUFB XMM10,XMM6,xmmword ptr [R10 + RBX*0x2 + 0x20]
VPSHUFB XMM11,XMM6,xmmword ptr [R10 + RBX*0x2 + 0x30]
VMOVDQU YMM12,ymmword ptr [R11 + RBX*0x2]
VMOVDQU YMM13,ymmword ptr [R11 + RBX*0x2 + 0x20]
VMOVDQU YMM14,ymmword ptr [R11 + RBX*0x1 + 0x80]
VPSLLW YMM15,YMM14,0x4
VPAND YMM15,YMM15,YMM0
VPSLLW YMM0,YMM14,0x2
VPANDQ YMM0,YMM0,YMM0
VPSRLW YMM1,YMM14,0x2
VPANDQ YMM1,YMM1,YMM0
VPTERNLOGQ YMM15,YMM12,YMM1,0xf8
VPTERNLOGQ YMM0,YMM13,YMM1,0xf8
VPSRLW YMM12,YMM12,0x4
VPAND YMM12,YMM12,YMM1
VPTERNLOGQ YMM12,YMM14,YMM0,0xf8
VPSRLW YMM13,YMM13,0x4
VPTERNLOGQ YMM13,YMM1,YMM1,0xec
VMOVDQU YMM14,ymmword ptr [RDX + RBX*0x4]
VMOVDQU64 YMM1,ymmword ptr [RDX + RBX*0x4 + 0x20]
VMOVDQU64 YMM2,ymmword ptr [RDX + RBX*0x4 + 0x40]
VMOVDQU64 YMM3,ymmword ptr [RDX + RBX*0x4 + 0x60]
VPMADDUBSW YMM4,YMM2,YMM14
VPMADDUBSW YMM5,YMM2,YMM1
VPMADDUBSW YMM6,YMM2,YMM2
VPMADDUBSW YMM7,YMM2,YMM3
VPMADDUBSW YMM14,YMM15,YMM14
VPSUBW YMM14,YMM14,YMM4
VPMADDUBSW YMM15,YMM0,YMM1
VPSUBW YMM15,YMM15,YMM5
VPMADDUBSW YMM12,YMM12,YMM2
VPSUBW YMM12,YMM12,YMM6
VPMADDUBSW YMM13,YMM13,YMM3
VPSUBW YMM13,YMM13,YMM7
VPMOVSXBW YMM8,XMM8
VPMADDWD YMM8,YMM8,YMM14
VPADDD YMM7,YMM8,YMM7
VPMOVSXBW YMM8,XMM9
VPMADDWD YMM8,YMM8,YMM15
VPMOVSXBW YMM9,XMM10
VPMADDWD YMM9,YMM9,YMM12
VPADDD YMM8,YMM8,YMM9
VPADDD YMM7,YMM8,YMM7
VPMOVSXBW YMM8,XMM11
VPMADDWD YMM8,YMM8,YMM13
VPADDD YMM7,YMM8,YMM7
ADD RBX,0x20
CMP EBX,0x20
JZ 0x001330b3
VMULSS XMM4,XMM4,XMM5
VBROADCASTSS YMM5,XMM4
VCVTDQ2PS YMM4,YMM7
VFMADD213PS YMM4,YMM5,YMM3
INC RDI
ADD R11,0xd2
ADD RDX,0x124
VMOVAPS YMM3,YMM4
CMP RDI,RAX
JNZ 0x00133081
JMP 0x00133215
LAB_00133211:
VXORPS XMM4,XMM4,XMM4
LAB_00133215:
VEXTRACTF128 XMM0,YMM4,0x1
VADDPS XMM0,XMM0,XMM4
VSHUFPD XMM1,XMM0,XMM0,0x1
VADDPS XMM0,XMM0,XMM1
VHADDPS XMM0,XMM0,XMM0
VMOVSS dword ptr [RSI],XMM0
ADD RSP,0x8
POP RBX
POP R14
VZEROUPPER
RET
LAB_0013323b:
LEA RDI,[0x143440]
LEA RSI,[0x142df0]
LEA RCX,[0x1435bf]
MOV EDX,0x1a6b
CALL 0x001083b0
LAB_0013325a:
LEA RDI,[0x136a8e]
LEA RSI,[0x142df0]
LEA RCX,[0x1435bf]
MOV EDX,0x1a6c
CALL 0x001083b0
|
void ggml_vec_dot_q6_K_q8_K
(int param_1,int4 *param_2,int8 param_3,long param_4,int8 param_5,
long param_6,int8 param_7,int param_8)
{
float fVar1;
long lVar2;
ulong uVar3;
long lVar4;
int1 auVar5 [32];
int1 auVar6 [32];
int1 auVar7 [32];
int1 auVar8 [32];
int1 auVar9 [32];
int1 auVar10 [32];
int1 auVar11 [32];
int1 auVar12 [32];
int1 auVar13 [32];
int1 auVar14 [32];
int1 auVar15 [16];
int1 auVar16 [16];
int1 auVar17 [64];
int1 auVar18 [16];
int1 auVar19 [16];
int1 auVar20 [64];
int1 auVar21 [32];
int1 auVar22 [32];
if ((char)param_1 != '\0') {
/* WARNING: Subroutine does not return */
__assert_fail("n % QK_K == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-quants.c"
,0x1a6b,
"void ggml_vec_dot_q6_K_q8_K(int, float *restrict, size_t, const void *restrict, size_t, const void *restrict, size_t, int)"
);
}
if (param_8 == 1) {
if (param_1 >> 8 < 1) {
auVar18 = ZEXT816(0) << 0x40;
}
else {
param_6 = param_6 + 4;
uVar3 = 0;
auVar17 = ZEXT3264(CONCAT824(DAT_0013a3d0,
CONCAT816(DAT_0013a3d0,CONCAT88(DAT_0013a3d0,DAT_0013a3d0))));
lVar4 = param_4;
do {
auVar20 = ZEXT1664(*(int1 (*) [16])(param_4 + 0xc0 + uVar3 * 0xd2));
lVar2 = 0;
do {
auVar19 = auVar20._0_16_;
auVar18 = vpshufb_avx(auVar19,*(int1 (*) [16])
(get_scale_shuffle_k_shuffle + lVar2 * 2));
auVar15 = vpshufb_avx(auVar19,*(int1 (*) [16])
(get_scale_shuffle_k_shuffle + lVar2 * 2 + 0x10));
auVar16 = vpshufb_avx(auVar19,*(int1 (*) [16])
(get_scale_shuffle_k_shuffle + lVar2 * 2 + 0x20));
auVar19 = vpshufb_avx(auVar19,*(int1 (*) [16])
(get_scale_shuffle_k_shuffle + lVar2 * 2 + 0x30));
auVar21 = *(int1 (*) [32])(lVar4 + lVar2 * 2);
auVar8 = *(int1 (*) [32])(lVar4 + 0x20 + lVar2 * 2);
auVar7 = *(int1 (*) [32])(lVar4 + 0x80 + lVar2);
auVar22 = vpsllw_avx2(auVar7,4);
auVar22 = vpand_avx2(auVar22,auVar17._0_32_);
auVar5 = vpsllw_avx512vl(auVar7,2);
auVar5 = vpandq_avx512vl(auVar5,auVar5);
auVar6 = vpsrlw_avx512vl(auVar7,2);
auVar6 = vpandq_avx512vl(auVar6,auVar5);
auVar22 = vpternlogq_avx512vl(auVar22,auVar21,auVar6,0xf8);
auVar5 = vpternlogq_avx512vl(auVar5,auVar8,auVar6,0xf8);
auVar17 = ZEXT3264(auVar5);
auVar21 = vpsrlw_avx2(auVar21,4);
auVar21 = vpand_avx2(auVar21,auVar6);
auVar7 = vpternlogq_avx512vl(auVar21,auVar7,auVar5,0xf8);
auVar21 = vpsrlw_avx2(auVar8,4);
auVar8 = vpternlogq_avx512vl(auVar21,auVar6,auVar6,0xec);
auVar21 = *(int1 (*) [32])(param_6 + lVar2 * 4);
auVar6 = vmovdqu64_avx512vl(*(int1 (*) [32])(param_6 + 0x20 + lVar2 * 4));
auVar9 = vmovdqu64_avx512vl(*(int1 (*) [32])(param_6 + 0x40 + lVar2 * 4));
auVar10 = vmovdqu64_avx512vl(*(int1 (*) [32])(param_6 + 0x60 + lVar2 * 4));
auVar11 = vpmaddubsw_avx512vl(auVar9,auVar21);
auVar12 = vpmaddubsw_avx512vl(auVar9,auVar6);
auVar13 = vpmaddubsw_avx512vl(auVar9,auVar9);
auVar20 = ZEXT3264(auVar13);
auVar14 = vpmaddubsw_avx512vl(auVar9,auVar10);
auVar21 = vpmaddubsw_avx2(auVar22,auVar21);
auVar22 = vpsubw_avx512vl(auVar21,auVar11);
auVar21 = vpmaddubsw_avx512vl(auVar5,auVar6);
auVar5 = vpsubw_avx512vl(auVar21,auVar12);
auVar21 = vpmaddubsw_avx512vl(auVar7,auVar9);
auVar6 = vpsubw_avx512vl(auVar21,auVar13);
auVar21 = vpmaddubsw_avx512vl(auVar8,auVar10);
auVar9 = vpsubw_avx512vl(auVar21,auVar14);
auVar21 = vpmovsxbw_avx2(auVar18);
auVar21 = vpmaddwd_avx2(auVar21,auVar22);
auVar21 = vpaddd_avx2(auVar21,auVar14);
auVar8 = vpmovsxbw_avx2(auVar15);
auVar8 = vpmaddwd_avx2(auVar8,auVar5);
auVar7 = vpmovsxbw_avx2(auVar16);
auVar7 = vpmaddwd_avx2(auVar7,auVar6);
auVar8 = vpaddd_avx2(auVar8,auVar7);
auVar21 = vpaddd_avx2(auVar8,auVar21);
auVar8 = vpmovsxbw_avx2(auVar19);
auVar8 = vpmaddwd_avx2(auVar8,auVar9);
auVar21 = vpaddd_avx2(auVar8,auVar21);
lVar2 = lVar2 + 0x20;
} while ((int)lVar2 == 0x20);
fVar1 = auVar11._0_4_ * auVar12._0_4_;
auVar8._4_4_ = fVar1;
auVar8._0_4_ = fVar1;
auVar8._8_4_ = fVar1;
auVar8._12_4_ = fVar1;
auVar8._16_4_ = fVar1;
auVar8._20_4_ = fVar1;
auVar8._24_4_ = fVar1;
auVar8._28_4_ = fVar1;
auVar21 = vcvtdq2ps_avx(auVar21);
auVar18 = vfmadd213ps_fma(auVar21,auVar8,auVar10);
uVar3 = uVar3 + 1;
lVar4 = lVar4 + 0xd2;
param_6 = param_6 + 0x124;
} while (uVar3 != (uint)(param_1 >> 8));
}
auVar15._0_4_ = auVar18._0_4_ + 0.0;
auVar15._4_4_ = auVar18._4_4_ + 0.0;
auVar15._8_4_ = auVar18._8_4_ + 0.0;
auVar15._12_4_ = auVar18._12_4_ + 0.0;
auVar18 = vshufpd_avx(auVar15,auVar15,1);
auVar16._0_4_ = auVar15._0_4_ + auVar18._0_4_;
auVar16._4_4_ = auVar15._4_4_ + auVar18._4_4_;
auVar16._8_4_ = auVar15._8_4_ + auVar18._8_4_;
auVar16._12_4_ = auVar15._12_4_ + auVar18._12_4_;
auVar18 = vhaddps_avx(auVar16,auVar16);
*param_2 = auVar18._0_4_;
return;
}
/* WARNING: Subroutine does not return */
__assert_fail("nrc == 1",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-quants.c"
,0x1a6c,
"void ggml_vec_dot_q6_K_q8_K(int, float *restrict, size_t, const void *restrict, size_t, const void *restrict, size_t, int)"
);
}
| |
48,317 | inheritance_source_by_id | eloqsql/mysys/charset.c | static CHARSET_INFO *inheritance_source_by_id(CHARSET_INFO *cs, uint refid)
{
CHARSET_INFO *refcs;
return refid && refid != cs->number &&
(refcs= all_charsets[refid]) &&
(refcs->state & MY_CS_AVAILABLE) ? refcs : NULL;
} | O0 | c | inheritance_source_by_id:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x2b5d1
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
je 0x2b5d1
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x358e78(%rip), %rax # 0x384420
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x2b5d1
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x200, %eax # imm = 0x200
cmpl $0x0, %eax
je 0x2b5d1
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x2b5d9
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x2b5d9
movq -0x20(%rbp), %rax
popq %rbp
retq
nop
| inheritance_source_by_id:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
cmp [rbp+var_C], 0
jz short loc_2B5D1
mov eax, [rbp+var_C]
mov rcx, [rbp+var_8]
cmp eax, [rcx]
jz short loc_2B5D1
mov eax, [rbp+var_C]
mov ecx, eax
lea rax, all_charsets
mov rax, [rax+rcx*8]
mov [rbp+var_18], rax
cmp rax, 0
jz short loc_2B5D1
mov rax, [rbp+var_18]
mov eax, [rax+0Ch]
and eax, 200h
cmp eax, 0
jz short loc_2B5D1
mov rax, [rbp+var_18]
mov [rbp+var_20], rax
jmp short loc_2B5D9
loc_2B5D1:
xor eax, eax
mov [rbp+var_20], rax
jmp short $+2
loc_2B5D9:
mov rax, [rbp+var_20]
pop rbp
retn
| long long inheritance_source_by_id(_DWORD *a1, int a2)
{
long long v4; // [rsp+8h] [rbp-18h]
if ( a2 && a2 != *a1 && (v4 = all_charsets[a2]) != 0 && (*(_DWORD *)(v4 + 12) & 0x200) != 0 )
return all_charsets[a2];
else
return 0LL;
}
| inheritance_source_by_id:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
CMP dword ptr [RBP + -0xc],0x0
JZ 0x0012b5d1
MOV EAX,dword ptr [RBP + -0xc]
MOV RCX,qword ptr [RBP + -0x8]
CMP EAX,dword ptr [RCX]
JZ 0x0012b5d1
MOV EAX,dword ptr [RBP + -0xc]
MOV ECX,EAX
LEA RAX,[0x484420]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JZ 0x0012b5d1
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0xc]
AND EAX,0x200
CMP EAX,0x0
JZ 0x0012b5d1
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0012b5d9
LAB_0012b5d1:
XOR EAX,EAX
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0012b5d9
LAB_0012b5d9:
MOV RAX,qword ptr [RBP + -0x20]
POP RBP
RET
|
long inheritance_source_by_id(uint *param_1,uint param_2)
{
long local_28;
if ((((param_2 == 0) || (param_2 == *param_1)) ||
(local_28 = (&all_charsets)[param_2], local_28 == 0)) ||
((*(uint *)(local_28 + 0xc) & 0x200) == 0)) {
local_28 = 0;
}
return local_28;
}
| |
48,318 | get_date | eloqsql/mysys/mf_getdate.c | void get_date(register char * to, int flag, time_t date)
{
reg2 struct tm *start_time;
time_t skr;
#if defined(HAVE_LOCALTIME_R) && defined(_REENTRANT)
struct tm tm_tmp;
#endif
skr=date ? date : (time_t) my_time(0);
#if defined(HAVE_LOCALTIME_R) && defined(_REENTRANT)
if (flag & GETDATE_GMT)
gmtime_r(&skr,&tm_tmp);
else
localtime_r(&skr,&tm_tmp);
start_time= &tm_tmp;
#else
if (flag & GETDATE_GMT)
start_time= gmtime(&skr);
else
start_time= localtime(&skr);
#endif
if (flag & GETDATE_SHORT_DATE)
sprintf(to,"%02d%02d%02d",
start_time->tm_year % 100,
start_time->tm_mon+1,
start_time->tm_mday);
else
sprintf(to, ((flag & GETDATE_FIXEDLENGTH) ?
"%4d-%02d-%02d" : "%d-%02d-%02d"),
start_time->tm_year+1900,
start_time->tm_mon+1,
start_time->tm_mday);
if (flag & GETDATE_DATE_TIME)
sprintf(strend(to),
((flag & GETDATE_FIXEDLENGTH) ?
" %02d:%02d:%02d" : " %2d:%02d:%02d"),
start_time->tm_hour,
start_time->tm_min,
start_time->tm_sec);
else if (flag & GETDATE_HHMMSSTIME)
sprintf(strend(to),"%02d%02d%02d",
start_time->tm_hour,
start_time->tm_min,
start_time->tm_sec);
} | O0 | c | get_date:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x32564
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
jmp 0x3257f
callq 0x35ea0
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movl $0xf4240, %ecx # imm = 0xF4240
xorl %edx, %edx
divq %rcx
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x325a1
leaq -0x28(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x24660
jmp 0x325ae
leaq -0x28(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x24180
leaq -0x60(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x325f6
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x14(%rax), %eax
movl $0x64, %ecx
cltd
idivl %ecx
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movq -0x20(%rbp), %rax
movl 0xc(%rax), %r8d
leaq 0x4add6(%rip), %rsi # 0x7d3c3
movb $0x0, %al
callq 0x240a0
jmp 0x3263b
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %ecx
andl $0x10, %ecx
leaq 0x4add7(%rip), %rsi # 0x7d3de
leaq 0x4adc2(%rip), %rax # 0x7d3d0
cmpl $0x0, %ecx
cmovneq %rax, %rsi
movq -0x20(%rbp), %rax
movl 0x14(%rax), %edx
addl $0x76c, %edx # imm = 0x76C
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movq -0x20(%rbp), %rax
movl 0xc(%rax), %r8d
movb $0x0, %al
callq 0x240a0
movl -0xc(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x3268b
movq -0x8(%rbp), %rdi
callq 0x79c40
movq %rax, %rdi
movl -0xc(%rbp), %ecx
andl $0x10, %ecx
leaq 0x4ad9c(%rip), %rsi # 0x7d3fb
leaq 0x4ad85(%rip), %rax # 0x7d3eb
cmpl $0x0, %ecx
cmovneq %rax, %rsi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x20(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
movl (%rax), %r8d
movb $0x0, %al
callq 0x240a0
jmp 0x326c7
movl -0xc(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x326c5
movq -0x8(%rbp), %rdi
callq 0x79c40
movq %rax, %rdi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x20(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
movl (%rax), %r8d
leaq 0x4ad05(%rip), %rsi # 0x7d3c3
movb $0x0, %al
callq 0x240a0
jmp 0x326c7
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
| get_date:
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
cmp [rbp+var_18], 0
jz short loc_32564
mov rax, [rbp+var_18]
mov [rbp+var_70], rax
jmp short loc_3257F
loc_32564:
call my_hrtime
mov [rbp+var_68], rax
mov rax, [rbp+var_68]
mov ecx, offset unk_F4240
xor edx, edx
div rcx
mov [rbp+var_70], rax
loc_3257F:
mov rax, [rbp+var_70]
mov [rbp+var_28], rax
mov eax, [rbp+var_C]
and eax, 8
cmp eax, 0
jz short loc_325A1
lea rdi, [rbp+var_28]
lea rsi, [rbp+var_60]
call _gmtime_r
jmp short loc_325AE
loc_325A1:
lea rdi, [rbp+var_28]
lea rsi, [rbp+var_60]
call _localtime_r
loc_325AE:
lea rax, [rbp+var_60]
mov [rbp+var_20], rax
mov eax, [rbp+var_C]
and eax, 2
cmp eax, 0
jz short loc_325F6
mov rdi, [rbp+var_8]
mov rax, [rbp+var_20]
mov eax, [rax+14h]
mov ecx, 64h ; 'd'
cdq
idiv ecx
mov rax, [rbp+var_20]
mov ecx, [rax+10h]
add ecx, 1
mov rax, [rbp+var_20]
mov r8d, [rax+0Ch]
lea rsi, a02d02d02d; "%02d%02d%02d"
mov al, 0
call _sprintf
jmp short loc_3263B
loc_325F6:
mov rdi, [rbp+var_8]
mov ecx, [rbp+var_C]
and ecx, 10h
lea rsi, aD02d02d; "%d-%02d-%02d"
lea rax, a4d02d02d; "%4d-%02d-%02d"
cmp ecx, 0
cmovnz rsi, rax
mov rax, [rbp+var_20]
mov edx, [rax+14h]
add edx, 76Ch
mov rax, [rbp+var_20]
mov ecx, [rax+10h]
add ecx, 1
mov rax, [rbp+var_20]
mov r8d, [rax+0Ch]
mov al, 0
call _sprintf
loc_3263B:
mov eax, [rbp+var_C]
and eax, 1
cmp eax, 0
jz short loc_3268B
mov rdi, [rbp+var_8]
call strend
mov rdi, rax
mov ecx, [rbp+var_C]
and ecx, 10h
lea rsi, a2d02d02d; " %2d:%02d:%02d"
lea rax, a02d02d02d_0; " %02d:%02d:%02d"
cmp ecx, 0
cmovnz rsi, rax
mov rax, [rbp+var_20]
mov edx, [rax+8]
mov rax, [rbp+var_20]
mov ecx, [rax+4]
mov rax, [rbp+var_20]
mov r8d, [rax]
mov al, 0
call _sprintf
jmp short loc_326C7
loc_3268B:
mov eax, [rbp+var_C]
and eax, 4
cmp eax, 0
jz short loc_326C5
mov rdi, [rbp+var_8]
call strend
mov rdi, rax
mov rax, [rbp+var_20]
mov edx, [rax+8]
mov rax, [rbp+var_20]
mov ecx, [rax+4]
mov rax, [rbp+var_20]
mov r8d, [rax]
lea rsi, a02d02d02d; "%02d%02d%02d"
mov al, 0
call _sprintf
loc_326C5:
jmp short $+2
loc_326C7:
add rsp, 70h
pop rbp
retn
| long long get_date(long long a1, int a2, unsigned long long a3)
{
const char *v3; // rsi
long long v4; // rdi
long long v5; // r9
const char *v6; // rsi
long long result; // rax
long long v8; // rax
unsigned long long v9; // [rsp+0h] [rbp-70h]
unsigned long long v10; // [rsp+8h] [rbp-68h]
_BYTE v11[56]; // [rsp+10h] [rbp-60h] BYREF
unsigned long long v12; // [rsp+48h] [rbp-28h] BYREF
unsigned int *v13; // [rsp+50h] [rbp-20h]
unsigned long long v14; // [rsp+58h] [rbp-18h]
int v15; // [rsp+64h] [rbp-Ch]
long long v16; // [rsp+68h] [rbp-8h]
v16 = a1;
v15 = a2;
v14 = a3;
if ( a3 )
{
v9 = v14;
}
else
{
v10 = my_hrtime();
a3 = v10 % (unsigned long long)&unk_F4240;
v9 = v10 / (unsigned long long)&unk_F4240;
}
v12 = v9;
if ( (v15 & 8) != 0 )
gmtime_r(&v12, v11, a3);
else
localtime_r(&v12, v11, a3);
v13 = (unsigned int *)v11;
if ( (v15 & 2) != 0 )
{
sprintf(v16, "%02d%02d%02d", (int)v13[5] % 100, v13[4] + 1, v13[3]);
}
else
{
v3 = "%d-%02d-%02d";
if ( (v15 & 0x10) != 0 )
v3 = "%4d-%02d-%02d";
sprintf(v16, v3, v13[5] + 1900, v13[4] + 1, v13[3]);
}
if ( (v15 & 1) != 0 )
{
v4 = strend(v16);
v6 = " %2d:%02d:%02d";
if ( (v15 & 0x10) != 0 )
v6 = " %02d:%02d:%02d";
return sprintf(v4, v6, v13[2], v13[1], *v13, v5, v9, v10);
}
else
{
result = v15 & 4;
if ( (v15 & 4) != 0 )
{
v8 = strend(v16);
return sprintf(v8, "%02d%02d%02d", v13[2], v13[1], *v13);
}
}
return result;
}
| get_date:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
CMP qword ptr [RBP + -0x18],0x0
JZ 0x00132564
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x70],RAX
JMP 0x0013257f
LAB_00132564:
CALL 0x00135ea0
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x68]
MOV ECX,0xf4240
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x70],RAX
LAB_0013257f:
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RBP + -0x28],RAX
MOV EAX,dword ptr [RBP + -0xc]
AND EAX,0x8
CMP EAX,0x0
JZ 0x001325a1
LEA RDI,[RBP + -0x28]
LEA RSI,[RBP + -0x60]
CALL 0x00124660
JMP 0x001325ae
LAB_001325a1:
LEA RDI,[RBP + -0x28]
LEA RSI,[RBP + -0x60]
CALL 0x00124180
LAB_001325ae:
LEA RAX,[RBP + -0x60]
MOV qword ptr [RBP + -0x20],RAX
MOV EAX,dword ptr [RBP + -0xc]
AND EAX,0x2
CMP EAX,0x0
JZ 0x001325f6
MOV RDI,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0x14]
MOV ECX,0x64
CDQ
IDIV ECX
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x10]
ADD ECX,0x1
MOV RAX,qword ptr [RBP + -0x20]
MOV R8D,dword ptr [RAX + 0xc]
LEA RSI,[0x17d3c3]
MOV AL,0x0
CALL 0x001240a0
JMP 0x0013263b
LAB_001325f6:
MOV RDI,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RBP + -0xc]
AND ECX,0x10
LEA RSI,[0x17d3de]
LEA RAX,[0x17d3d0]
CMP ECX,0x0
CMOVNZ RSI,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RAX + 0x14]
ADD EDX,0x76c
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x10]
ADD ECX,0x1
MOV RAX,qword ptr [RBP + -0x20]
MOV R8D,dword ptr [RAX + 0xc]
MOV AL,0x0
CALL 0x001240a0
LAB_0013263b:
MOV EAX,dword ptr [RBP + -0xc]
AND EAX,0x1
CMP EAX,0x0
JZ 0x0013268b
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00179c40
MOV RDI,RAX
MOV ECX,dword ptr [RBP + -0xc]
AND ECX,0x10
LEA RSI,[0x17d3fb]
LEA RAX,[0x17d3eb]
CMP ECX,0x0
CMOVNZ RSI,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x4]
MOV RAX,qword ptr [RBP + -0x20]
MOV R8D,dword ptr [RAX]
MOV AL,0x0
CALL 0x001240a0
JMP 0x001326c7
LAB_0013268b:
MOV EAX,dword ptr [RBP + -0xc]
AND EAX,0x4
CMP EAX,0x0
JZ 0x001326c5
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00179c40
MOV RDI,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x4]
MOV RAX,qword ptr [RBP + -0x20]
MOV R8D,dword ptr [RAX]
LEA RSI,[0x17d3c3]
MOV AL,0x0
CALL 0x001240a0
LAB_001326c5:
JMP 0x001326c7
LAB_001326c7:
ADD RSP,0x70
POP RBP
RET
|
void get_date(char *param_1,uint param_2,ulong param_3)
{
char *pcVar1;
char *__format;
ulong local_78;
tm local_68;
ulong local_30;
tm *local_28;
ulong local_20;
uint local_14;
char *local_10;
local_78 = param_3;
local_20 = param_3;
local_14 = param_2;
local_10 = param_1;
if (param_3 == 0) {
local_78 = my_hrtime();
local_78 = local_78 / 1000000;
}
local_30 = local_78;
if ((local_14 & 8) == 0) {
localtime_r((time_t *)&local_30,&local_68);
}
else {
gmtime_r((time_t *)&local_30,&local_68);
}
local_28 = &local_68;
if ((local_14 & 2) == 0) {
pcVar1 = "%d-%02d-%02d";
if ((local_14 & 0x10) != 0) {
pcVar1 = "%4d-%02d-%02d";
}
sprintf(local_10,pcVar1,(ulong)(local_68.tm_year + 0x76c),(ulong)(local_68.tm_mon + 1),
(ulong)(uint)local_68.tm_mday);
}
else {
sprintf(local_10,"%02d%02d%02d",(long)local_68.tm_year % 100 & 0xffffffff,
(ulong)(local_68.tm_mon + 1),(ulong)(uint)local_68.tm_mday);
}
if ((local_14 & 1) == 0) {
if ((local_14 & 4) != 0) {
pcVar1 = (char *)strend(local_10);
sprintf(pcVar1,"%02d%02d%02d",(ulong)(uint)local_28->tm_hour,(ulong)(uint)local_28->tm_min,
(ulong)(uint)local_28->tm_sec);
}
}
else {
pcVar1 = (char *)strend(local_10);
__format = " %2d:%02d:%02d";
if ((local_14 & 0x10) != 0) {
__format = " %02d:%02d:%02d";
}
sprintf(pcVar1,__format,(ulong)(uint)local_28->tm_hour,(ulong)(uint)local_28->tm_min,
(ulong)(uint)local_28->tm_sec);
}
return;
}
| |
48,319 | inline_mysql_file_create_with_symlink | eloqsql/include/mysql/psi/mysql_file.h | static inline File
inline_mysql_file_create_with_symlink(
#ifdef HAVE_PSI_FILE_INTERFACE
PSI_file_key key, const char *src_file, uint src_line,
#endif
const char *linkname, const char *filename, int create_flags,
int access_flags, myf flags)
{
File file;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_name_locker)(&state, key, PSI_FILE_CREATE, filename,
&locker);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_open_wait)(locker, src_file, src_line);
file= my_create_with_symlink(linkname, filename, create_flags, access_flags,
flags);
PSI_FILE_CALL(end_file_open_wait_and_bind_to_descriptor)(locker, file);
return file;
}
#endif
file= my_create_with_symlink(linkname, filename, create_flags, access_flags,
flags);
return file;
} | O0 | c | inline_mysql_file_create_with_symlink:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
leaq 0x259ef1(%rip), %rax # 0x2cb450
movq (%rax), %rax
movq 0x148(%rax), %rax
movl -0x8(%rbp), %esi
movq -0x28(%rbp), %rcx
leaq -0x80(%rbp), %rdi
xorl %edx, %edx
leaq -0x38(%rbp), %r8
callq *%rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x715fa
leaq 0x259ea9(%rip), %rax # 0x2cb450
movq (%rax), %rax
movq 0x1f0(%rax), %rax
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq *%rax
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %edx
movl 0x10(%rbp), %ecx
movq 0x18(%rbp), %r8
callq 0xfbd30
movl %eax, -0x30(%rbp)
leaq 0x259e71(%rip), %rax # 0x2cb450
movq (%rax), %rax
movq 0x200(%rax), %rax
movq -0x38(%rbp), %rdi
movl -0x30(%rbp), %esi
callq *%rax
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7161a
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %edx
movl 0x10(%rbp), %ecx
movq 0x18(%rbp), %r8
callq 0xfbd30
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| inline_mysql_file_create_with_symlink:
push rbp
mov rbp, rsp
sub rsp, 80h
mov rax, [rbp+arg_8]
mov eax, [rbp+arg_0]
mov [rbp+var_8], edi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_2C], r9d
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+148h]
mov esi, [rbp+var_8]
mov rcx, [rbp+var_28]
lea rdi, [rbp+var_80]
xor edx, edx
lea r8, [rbp+var_38]
call rax
mov [rbp+var_38], rax
cmp [rbp+var_38], 0
setnz al
and al, 1
movzx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_715FA
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1F0h]
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_10]
mov edx, [rbp+var_14]
call rax
mov rdi, [rbp+var_20]
mov rsi, [rbp+var_28]
mov edx, [rbp+var_2C]
mov ecx, [rbp+arg_0]
mov r8, [rbp+arg_8]
call my_create_with_symlink
mov [rbp+var_30], eax
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+200h]
mov rdi, [rbp+var_38]
mov esi, [rbp+var_30]
call rax
mov eax, [rbp+var_30]
mov [rbp+var_4], eax
jmp short loc_7161A
loc_715FA:
mov rdi, [rbp+var_20]
mov rsi, [rbp+var_28]
mov edx, [rbp+var_2C]
mov ecx, [rbp+arg_0]
mov r8, [rbp+arg_8]
call my_create_with_symlink
mov [rbp+var_30], eax
mov eax, [rbp+var_30]
mov [rbp+var_4], eax
loc_7161A:
mov eax, [rbp+var_4]
add rsp, 80h
pop rbp
retn
| long long inline_mysql_file_create_with_symlink(
unsigned int a1,
long long a2,
unsigned int a3,
long long a4,
long long a5,
unsigned int a6,
unsigned int a7,
long long a8)
{
_BYTE v9[72]; // [rsp+0h] [rbp-80h] BYREF
long long v10; // [rsp+48h] [rbp-38h] BYREF
unsigned int v11; // [rsp+50h] [rbp-30h]
unsigned int v12; // [rsp+54h] [rbp-2Ch]
long long v13; // [rsp+58h] [rbp-28h]
long long v14; // [rsp+60h] [rbp-20h]
unsigned int v15; // [rsp+6Ch] [rbp-14h]
long long v16; // [rsp+70h] [rbp-10h]
unsigned int v17; // [rsp+78h] [rbp-8h]
v17 = a1;
v16 = a2;
v15 = a3;
v14 = a4;
v13 = a5;
v12 = a6;
v10 = ((long long ( *)(_BYTE *, _QWORD, _QWORD, long long, long long *))PSI_server[41])(v9, a1, 0LL, a5, &v10);
if ( v10 )
{
((void ( *)(long long, long long, _QWORD))PSI_server[62])(v10, v16, v15);
v11 = my_create_with_symlink(v14, v13, v12, a7, a8);
((void ( *)(long long, _QWORD))PSI_server[64])(v10, v11);
}
else
{
return (unsigned int)my_create_with_symlink(v14, v13, v12, a7, a8);
}
return v11;
}
| inline_mysql_file_create_with_symlink:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV RAX,qword ptr [RBP + 0x18]
MOV EAX,dword ptr [RBP + 0x10]
MOV dword ptr [RBP + -0x8],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV dword ptr [RBP + -0x2c],R9D
LEA RAX,[0x3cb450]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x148]
MOV ESI,dword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x28]
LEA RDI,[RBP + -0x80]
XOR EDX,EDX
LEA R8,[RBP + -0x38]
CALL RAX
MOV qword ptr [RBP + -0x38],RAX
CMP qword ptr [RBP + -0x38],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x001715fa
LEA RAX,[0x3cb450]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1f0]
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x14]
CALL RAX
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x28]
MOV EDX,dword ptr [RBP + -0x2c]
MOV ECX,dword ptr [RBP + 0x10]
MOV R8,qword ptr [RBP + 0x18]
CALL 0x001fbd30
MOV dword ptr [RBP + -0x30],EAX
LEA RAX,[0x3cb450]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x200]
MOV RDI,qword ptr [RBP + -0x38]
MOV ESI,dword ptr [RBP + -0x30]
CALL RAX
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0017161a
LAB_001715fa:
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x28]
MOV EDX,dword ptr [RBP + -0x2c]
MOV ECX,dword ptr [RBP + 0x10]
MOV R8,qword ptr [RBP + 0x18]
CALL 0x001fbd30
MOV dword ptr [RBP + -0x30],EAX
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x4],EAX
LAB_0017161a:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x80
POP RBP
RET
|
int4
inline_mysql_file_create_with_symlink
(int4 param_1,int8 param_2,int4 param_3,int8 param_4,
int8 param_5,int4 param_6,int4 param_7,int8 param_8)
{
int1 local_88 [72];
long local_40;
int4 local_38;
int4 local_34;
int8 local_30;
int8 local_28;
int4 local_1c;
int8 local_18;
int4 local_10;
int4 local_c;
local_34 = param_6;
local_30 = param_5;
local_28 = param_4;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
local_40 = (**(code **)(PSI_server + 0x148))(local_88,param_1,0,param_5,&local_40);
if (local_40 == 0) {
local_c = my_create_with_symlink(local_28,local_30,local_34,param_7,param_8);
}
else {
(**(code **)(PSI_server + 0x1f0))(local_40,local_18,local_1c);
local_38 = my_create_with_symlink(local_28,local_30,local_34,param_7,param_8);
(**(code **)(PSI_server + 0x200))(local_40,local_38);
local_c = local_38;
}
return local_c;
}
| |
48,320 | HMAC_init | corpus-core[P]colibri-stateless/build_O0/_deps/blst-src/src/keygen.c | static void HMAC_init(HMAC_SHA256_CTX *ctx, const void *K, size_t K_len)
{
size_t i;
if (K == NULL) { /* reuse h_ipad and h_opad */
sha256_hcopy(ctx->ctx.h, ctx->h_ipad);
ctx->ctx.N = 64;
vec_zero(ctx->ctx.buf, sizeof(ctx->ctx.buf));
ctx->ctx.off = 0;
return;
}
vec_zero(ctx->tail.c, sizeof(ctx->tail));
if (K_len > 64) {
sha256_init(&ctx->ctx);
sha256_update(&ctx->ctx, K, K_len);
sha256_final(ctx->tail.c, &ctx->ctx);
} else {
sha256_bcopy(ctx->tail.c, K, K_len);
}
for (i = 0; i < 64/sizeof(limb_t); i++)
ctx->tail.l[i] ^= (limb_t)0x3636363636363636;
sha256_init(&ctx->ctx);
sha256_update(&ctx->ctx, ctx->tail.c, 64);
sha256_hcopy(ctx->h_ipad, ctx->ctx.h);
for (i = 0; i < 64/sizeof(limb_t); i++)
ctx->tail.l[i] ^= (limb_t)(0x3636363636363636 ^ 0x5c5c5c5c5c5c5c5c);
sha256_init_h(ctx->h_opad);
sha256_block_data_order(ctx->h_opad, ctx->tail.c, 1);
vec_zero(ctx->tail.c, sizeof(ctx->tail));
ctx->tail.c[32] = 0x80;
ctx->tail.c[62] = 3; /* (64+32)*8 in big endian */
ctx->tail.c[63] = 0;
} | O0 | c | HMAC_init:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xb7f8b
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x70, %rsi
callq 0xc3890
movq -0x8(%rbp), %rax
movq $0x40, 0x20(%rax)
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl $0x40, %esi
callq 0xa87c0
movq -0x8(%rbp), %rax
movq $0x0, 0x68(%rax)
jmp 0xb8106
movq -0x8(%rbp), %rdi
addq $0xb0, %rdi
movl $0x40, %esi
callq 0xa87c0
cmpq $0x40, -0x18(%rbp)
jbe 0xb7fd7
movq -0x8(%rbp), %rdi
callq 0xb7140
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xb7190
movq -0x8(%rbp), %rdi
addq $0xb0, %rdi
movq -0x8(%rbp), %rsi
callq 0xb7320
jmp 0xb7fef
movq -0x8(%rbp), %rdi
addq $0xb0, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xc3870
movq $0x0, -0x20(%rbp)
cmpq $0x8, -0x20(%rbp)
jae 0xb802e
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movabsq $0x3636363636363636, %rdx # imm = 0x3636363636363636
xorq 0xb0(%rax,%rcx,8), %rdx
movq %rdx, 0xb0(%rax,%rcx,8)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xb7ff7
movq -0x8(%rbp), %rdi
callq 0xb7140
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0xb0, %rsi
movl $0x40, %edx
callq 0xb7190
movq -0x8(%rbp), %rdi
addq $0x70, %rdi
movq -0x8(%rbp), %rsi
callq 0xc3890
movq $0x0, -0x20(%rbp)
cmpq $0x8, -0x20(%rbp)
jae 0xb80a0
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movabsq $0x6a6a6a6a6a6a6a6a, %rdx # imm = 0x6A6A6A6A6A6A6A6A
xorq 0xb0(%rax,%rcx,8), %rdx
movq %rdx, 0xb0(%rax,%rcx,8)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xb8069
movq -0x8(%rbp), %rdi
addq $0x90, %rdi
callq 0xb81b0
movq -0x8(%rbp), %rdi
addq $0x90, %rdi
movq -0x8(%rbp), %rsi
addq $0xb0, %rsi
movl $0x1, %edx
callq 0xc14c0
movq -0x8(%rbp), %rdi
addq $0xb0, %rdi
movl $0x40, %esi
callq 0xa87c0
movq -0x8(%rbp), %rax
movb $-0x80, 0xd0(%rax)
movq -0x8(%rbp), %rax
movb $0x3, 0xee(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0xef(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| HMAC_init:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
cmp [rbp+var_10], 0
jnz short loc_B7F8B
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_8]
add rsi, 70h ; 'p'
call blst_sha256_hcopy
mov rax, [rbp+var_8]
mov qword ptr [rax+20h], 40h ; '@'
mov rdi, [rbp+var_8]
add rdi, 28h ; '('
mov esi, 40h ; '@'
call vec_zero
mov rax, [rbp+var_8]
mov qword ptr [rax+68h], 0
jmp loc_B8106
loc_B7F8B:
mov rdi, [rbp+var_8]
add rdi, 0B0h
mov esi, 40h ; '@'
call vec_zero
cmp [rbp+var_18], 40h ; '@'
jbe short loc_B7FD7
mov rdi, [rbp+var_8]
call sha256_init
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
call sha256_update
mov rdi, [rbp+var_8]
add rdi, 0B0h
mov rsi, [rbp+var_8]
call sha256_final
jmp short loc_B7FEF
loc_B7FD7:
mov rdi, [rbp+var_8]
add rdi, 0B0h
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
call blst_sha256_bcopy
loc_B7FEF:
mov [rbp+var_20], 0
loc_B7FF7:
cmp [rbp+var_20], 8
jnb short loc_B802E
mov rax, [rbp+var_8]
mov rcx, [rbp+var_20]
mov rdx, 3636363636363636h
xor rdx, [rax+rcx*8+0B0h]
mov [rax+rcx*8+0B0h], rdx
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_20], rax
jmp short loc_B7FF7
loc_B802E:
mov rdi, [rbp+var_8]
call sha256_init
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_8]
add rsi, 0B0h
mov edx, 40h ; '@'
call sha256_update
mov rdi, [rbp+var_8]
add rdi, 70h ; 'p'
mov rsi, [rbp+var_8]
call blst_sha256_hcopy
mov [rbp+var_20], 0
loc_B8069:
cmp [rbp+var_20], 8
jnb short loc_B80A0
mov rax, [rbp+var_8]
mov rcx, [rbp+var_20]
mov rdx, 6A6A6A6A6A6A6A6Ah
xor rdx, [rax+rcx*8+0B0h]
mov [rax+rcx*8+0B0h], rdx
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_20], rax
jmp short loc_B8069
loc_B80A0:
mov rdi, [rbp+var_8]
add rdi, 90h
call sha256_init_h
mov rdi, [rbp+var_8]
add rdi, 90h
mov rsi, [rbp+var_8]
add rsi, 0B0h
mov edx, 1
call blst_sha256_block_data_order
mov rdi, [rbp+var_8]
add rdi, 0B0h
mov esi, 40h ; '@'
call vec_zero
mov rax, [rbp+var_8]
mov byte ptr [rax+0D0h], 80h
mov rax, [rbp+var_8]
mov byte ptr [rax+0EEh], 3
mov rax, [rbp+var_8]
mov byte ptr [rax+0EFh], 0
loc_B8106:
add rsp, 20h
pop rbp
retn
| HMAC_init:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
CMP qword ptr [RBP + -0x10],0x0
JNZ 0x001b7f8b
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x8]
ADD RSI,0x70
CALL 0x001c3890
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x20],0x40
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x28
MOV ESI,0x40
CALL 0x001a87c0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x68],0x0
JMP 0x001b8106
LAB_001b7f8b:
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xb0
MOV ESI,0x40
CALL 0x001a87c0
CMP qword ptr [RBP + -0x18],0x40
JBE 0x001b7fd7
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001b7140
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x001b7190
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xb0
MOV RSI,qword ptr [RBP + -0x8]
CALL 0x001b7320
JMP 0x001b7fef
LAB_001b7fd7:
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xb0
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x001c3870
LAB_001b7fef:
MOV qword ptr [RBP + -0x20],0x0
LAB_001b7ff7:
CMP qword ptr [RBP + -0x20],0x8
JNC 0x001b802e
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x20]
MOV RDX,0x3636363636363636
XOR RDX,qword ptr [RAX + RCX*0x8 + 0xb0]
MOV qword ptr [RAX + RCX*0x8 + 0xb0],RDX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001b7ff7
LAB_001b802e:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001b7140
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x8]
ADD RSI,0xb0
MOV EDX,0x40
CALL 0x001b7190
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x70
MOV RSI,qword ptr [RBP + -0x8]
CALL 0x001c3890
MOV qword ptr [RBP + -0x20],0x0
LAB_001b8069:
CMP qword ptr [RBP + -0x20],0x8
JNC 0x001b80a0
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x20]
MOV RDX,0x6a6a6a6a6a6a6a6a
XOR RDX,qword ptr [RAX + RCX*0x8 + 0xb0]
MOV qword ptr [RAX + RCX*0x8 + 0xb0],RDX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001b8069
LAB_001b80a0:
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x90
CALL 0x001b81b0
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x90
MOV RSI,qword ptr [RBP + -0x8]
ADD RSI,0xb0
MOV EDX,0x1
CALL 0x001c14c0
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xb0
MOV ESI,0x40
CALL 0x001a87c0
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0xd0],0x80
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0xee],0x3
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0xef],0x0
LAB_001b8106:
ADD RSP,0x20
POP RBP
RET
|
void HMAC_init(long param_1,long param_2,ulong param_3)
{
int8 local_28;
if (param_2 == 0) {
blst_sha256_hcopy(param_1,param_1 + 0x70);
*(int8 *)(param_1 + 0x20) = 0x40;
vec_zero(param_1 + 0x28,0x40);
*(int8 *)(param_1 + 0x68) = 0;
}
else {
vec_zero(param_1 + 0xb0,0x40);
if (param_3 < 0x41) {
blst_sha256_bcopy(param_1 + 0xb0,param_2,param_3);
}
else {
sha256_init(param_1);
sha256_update(param_1,param_2,param_3);
sha256_final(param_1 + 0xb0,param_1);
}
for (local_28 = 0; local_28 < 8; local_28 = local_28 + 1) {
*(ulong *)(param_1 + 0xb0 + local_28 * 8) =
*(ulong *)(param_1 + 0xb0 + local_28 * 8) ^ 0x3636363636363636;
}
sha256_init(param_1);
sha256_update(param_1,param_1 + 0xb0,0x40);
blst_sha256_hcopy(param_1 + 0x70,param_1);
for (local_28 = 0; local_28 < 8; local_28 = local_28 + 1) {
*(ulong *)(param_1 + 0xb0 + local_28 * 8) =
*(ulong *)(param_1 + 0xb0 + local_28 * 8) ^ 0x6a6a6a6a6a6a6a6a;
}
sha256_init_h(param_1 + 0x90);
blst_sha256_block_data_order(param_1 + 0x90,param_1 + 0xb0,1);
vec_zero(param_1 + 0xb0,0x40);
*(int1 *)(param_1 + 0xd0) = 0x80;
*(int1 *)(param_1 + 0xee) = 3;
*(int1 *)(param_1 + 0xef) = 0;
}
return;
}
| ||
48,321 | Engine::extendedSearch(int, int, int) | Razamindset[P]pawnstar-chess-engine/src/engine/search.cpp | int Engine::extendedSearch(int alpha, int beta, int ply) {
positionsSearched++;
ply++;
int evaluation = evaluatePosition(board, ply);
// Alpha-beta pruning: If the evaluation is greater than or equal to beta,
// the minimizing player has found a move that the maximizing player would
// never allow. So, we prune this branch.
if (evaluation >= beta) return beta;
// Update alpha to track the best score found so far for the maximizing
// player.
alpha = std::max(evaluation, alpha);
Movelist moves;
movegen::legalmoves(moves, board);
if (moves.empty()) {
if (board.inCheck()) {
return -MATE_SCORE + ply;
} else {
return 0;
}
}
for (const auto& move : moves) {
board.makeMove(move);
bool inCheck = board.inCheck();
board.unmakeMove(move);
if (!board.isCapture(move) || !inCheck)
continue; // Only consider captures in quiescence search.
// The following line is really necessary. I donot know if it is the best
// thing but it works. What we do is only consider capturing moves of
// higher value with lower value pieces. This brings down our search time
// from 30s to 6-7s
Piece attacker = board.at(move.from());
Piece victim = board.at(move.to());
// Allow equal captures (like queen takes queen)
if (getPieceValue(attacker) > getPieceValue(victim) + 50) continue;
// Consider promoted pawns specially
if (move.typeOf() == Move::PROMOTION) {
// Always consider pawn captures that lead to promotion
if (attacker.type() == PAWN) goto makeMove;
}
makeMove:
board.makeMove(move);
// Negamax with alpha-beta pruning: The roles of alpha and beta are
// swapped because each layer alternates between maximizing and
// minimizing.
int score = -extendedSearch(-beta, -alpha, ply);
board.unmakeMove(move);
// Beta cutoff: If we find a move better than beta for the maximizing
// player, the minimizing player will never allow this position, so we
// prune the search.
if (score >= beta) {
return beta;
}
// Update alpha to the best score found so far.
alpha = std::max(alpha, score);
}
return alpha;
} | O0 | cpp | Engine::extendedSearch(int, int, int):
pushq %rbp
movq %rsp, %rbp
subq $0x490, %rsp # imm = 0x490
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x480(%rbp)
movl 0x114(%rsi), %eax
addl $0x1, %eax
movl %eax, 0x114(%rsi)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edx
movq %rsi, %rdi
callq 0x1fa60
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x18(%rbp), %eax
jl 0x1b7dc
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1baca
leaq -0x20(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x12720
movl (%rax), %eax
movl %eax, -0x14(%rbp)
leaq -0x424(%rbp), %rdi
callq 0x12f00
movq -0x480(%rbp), %rsi
leaq -0x424(%rbp), %rdi
movl $0x3f, %edx
callq 0x12f20
leaq -0x424(%rbp), %rdi
callq 0x12f90
testb $0x1, %al
jne 0x1b824
jmp 0x1b852
movq -0x480(%rbp), %rdi
callq 0x12fb0
testb $0x1, %al
jne 0x1b836
jmp 0x1b846
movl -0x1c(%rbp), %eax
addl $0xfffe7960, %eax # imm = 0xFFFE7960
movl %eax, -0x4(%rbp)
jmp 0x1baca
movl $0x0, -0x4(%rbp)
jmp 0x1baca
leaq -0x424(%rbp), %rax
movq %rax, -0x430(%rbp)
movq -0x430(%rbp), %rdi
callq 0x1a030
movq %rax, -0x438(%rbp)
movq -0x430(%rbp), %rdi
callq 0x1a050
movq %rax, -0x440(%rbp)
movq -0x438(%rbp), %rax
cmpq -0x440(%rbp), %rax
je 0x1bac4
movq -0x480(%rbp), %rdi
movq -0x438(%rbp), %rax
movq %rax, -0x448(%rbp)
movq -0x448(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x44c(%rbp)
movl -0x44c(%rbp), %esi
callq 0xf860
movq -0x480(%rbp), %rdi
callq 0x12fb0
movq -0x480(%rbp), %rdi
andb $0x1, %al
movb %al, -0x44d(%rbp)
movq -0x448(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x452(%rbp)
movl -0x452(%rbp), %esi
callq 0x1d4a0
movq -0x480(%rbp), %rdi
movq -0x448(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x456(%rbp)
movl -0x456(%rbp), %esi
callq 0x1d210
testb $0x1, %al
jne 0x1b925
jmp 0x1b92e
testb $0x1, -0x44d(%rbp)
jne 0x1b933
jmp 0x1baad
movq -0x448(%rbp), %rdi
callq 0x197a0
movq -0x480(%rbp), %rdi
movl %eax, -0x45c(%rbp)
movl -0x45c(%rbp), %esi
callq 0xa5b0
movb %al, -0x457(%rbp)
movq -0x448(%rbp), %rdi
callq 0x197e0
movq -0x480(%rbp), %rdi
movl %eax, -0x464(%rbp)
movl -0x464(%rbp), %esi
callq 0xa5b0
movq -0x480(%rbp), %rdi
movb %al, -0x45d(%rbp)
movb -0x457(%rbp), %al
movb %al, -0x465(%rbp)
movzbl -0x465(%rbp), %esi
callq 0xf440
movq -0x480(%rbp), %rdi
movl %eax, -0x484(%rbp)
movb -0x45d(%rbp), %al
movb %al, -0x466(%rbp)
movzbl -0x466(%rbp), %esi
callq 0xf440
movl %eax, %ecx
movl -0x484(%rbp), %eax
addl $0x32, %ecx
cmpl %ecx, %eax
jle 0x1b9df
jmp 0x1baad
movq -0x448(%rbp), %rdi
callq 0x19820
movzwl %ax, %eax
cmpl $0x4000, %eax # imm = 0x4000
jne 0x1ba1c
leaq -0x457(%rbp), %rdi
callq 0x9fb0
movb %al, -0x467(%rbp)
leaq -0x467(%rbp), %rdi
callq 0xa120
cmpl $0x1, %eax
jne 0x1ba1a
jmp 0x1ba1e
jmp 0x1ba1c
jmp 0x1ba1e
movq -0x480(%rbp), %rdi
movq -0x448(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x46c(%rbp)
movl -0x46c(%rbp), %esi
callq 0xf860
movq -0x480(%rbp), %rdi
xorl %esi, %esi
subl -0x18(%rbp), %esi
xorl %edx, %edx
subl -0x14(%rbp), %edx
movl -0x1c(%rbp), %ecx
callq 0x1b780
movq -0x480(%rbp), %rdi
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x470(%rbp)
movq -0x448(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x474(%rbp)
movl -0x474(%rbp), %esi
callq 0x1d4a0
movl -0x470(%rbp), %eax
cmpl -0x18(%rbp), %eax
jl 0x1ba98
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1baca
leaq -0x14(%rbp), %rdi
leaq -0x470(%rbp), %rsi
callq 0x12720
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x438(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x438(%rbp)
jmp 0x1b886
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x490, %rsp # imm = 0x490
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZN6Engine14extendedSearchEiii:
push rbp
mov rbp, rsp
sub rsp, 490h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov [rbp+var_1C], ecx
mov rsi, [rbp+var_10]; chess::Board *
mov [rbp+var_480], rsi
mov eax, [rsi+114h]
add eax, 1
mov [rsi+114h], eax
mov eax, [rbp+var_1C]
add eax, 1
mov [rbp+var_1C], eax
mov edx, [rbp+var_1C]; int
mov rdi, rsi; this
call _ZN6Engine16evaluatePositionERKN5chess5BoardEi; Engine::evaluatePosition(chess::Board const&,int)
mov [rbp+var_20], eax
mov eax, [rbp+var_20]
cmp eax, [rbp+var_18]
jl short loc_1B7DC
mov eax, [rbp+var_18]
mov [rbp+var_4], eax
jmp loc_1BACA
loc_1B7DC:
lea rdi, [rbp+var_20]
lea rsi, [rbp+var_14]
call _ZSt3maxIiERKT_S2_S2_; std::max<int>(int const&,int const&)
mov eax, [rax]
mov [rbp+var_14], eax
lea rdi, [rbp+var_424]; this
call _ZN5chess8MovelistC2Ev; chess::Movelist::Movelist(void)
mov rsi, [rbp+var_480]
lea rdi, [rbp+var_424]
mov edx, 3Fh ; '?'
call _ZN5chess7movegen10legalmovesILNS0_11MoveGenTypeE0EEEvRNS_8MovelistERKNS_5BoardEi; chess::movegen::legalmoves<(chess::movegen::MoveGenType)0>(chess::Movelist &,chess::Board const&,int)
lea rdi, [rbp+var_424]; this
call _ZNK5chess8Movelist5emptyEv; chess::Movelist::empty(void)
test al, 1
jnz short loc_1B824
jmp short loc_1B852
loc_1B824:
mov rdi, [rbp+var_480]; this
call _ZNK5chess5Board7inCheckEv; chess::Board::inCheck(void)
test al, 1
jnz short loc_1B836
jmp short loc_1B846
loc_1B836:
mov eax, [rbp+var_1C]
add eax, 0FFFE7960h
mov [rbp+var_4], eax
jmp loc_1BACA
loc_1B846:
mov [rbp+var_4], 0
jmp loc_1BACA
loc_1B852:
lea rax, [rbp+var_424]
mov [rbp+var_430], rax
mov rdi, [rbp+var_430]; this
call _ZN5chess8Movelist5beginEv; chess::Movelist::begin(void)
mov [rbp+var_438], rax
mov rdi, [rbp+var_430]; this
call _ZN5chess8Movelist3endEv; chess::Movelist::end(void)
mov [rbp+var_440], rax
loc_1B886:
mov rax, [rbp+var_438]
cmp rax, [rbp+var_440]
jz loc_1BAC4
mov rdi, [rbp+var_480]
mov rax, [rbp+var_438]
mov [rbp+var_448], rax
mov rax, [rbp+var_448]
mov eax, [rax]
mov [rbp+var_44C], eax
mov esi, [rbp+var_44C]
call _ZN5chess5Board8makeMoveILb0EEEvNS_4MoveE; chess::Board::makeMove<false>(chess::Move)
mov rdi, [rbp+var_480]; this
call _ZNK5chess5Board7inCheckEv; chess::Board::inCheck(void)
mov rdi, [rbp+var_480]
and al, 1
mov [rbp+var_44D], al
mov rax, [rbp+var_448]
mov eax, [rax]
mov [rbp+var_452], eax
mov esi, [rbp+var_452]
call _ZN5chess5Board10unmakeMoveENS_4MoveE; chess::Board::unmakeMove(chess::Move)
mov rdi, [rbp+var_480]
mov rax, [rbp+var_448]
mov eax, [rax]
mov [rbp+var_456], eax
mov esi, [rbp+var_456]
call _ZNK5chess5Board9isCaptureENS_4MoveE; chess::Board::isCapture(chess::Move)
test al, 1
jnz short loc_1B925
jmp short loc_1B92E
loc_1B925:
test [rbp+var_44D], 1
jnz short loc_1B933
loc_1B92E:
jmp loc_1BAAD
loc_1B933:
mov rdi, [rbp+var_448]; this
call _ZNK5chess4Move4fromEv; chess::Move::from(void)
mov rdi, [rbp+var_480]
mov [rbp+var_45C], eax
mov esi, [rbp+var_45C]
call _ZNK5chess5Board2atINS_5PieceEEET_NS_6SquareE; chess::Board::at<chess::Piece>(chess::Square)
mov [rbp+var_457], al
mov rdi, [rbp+var_448]; this
call _ZNK5chess4Move2toEv; chess::Move::to(void)
mov rdi, [rbp+var_480]
mov [rbp+var_464], eax
mov esi, [rbp+var_464]
call _ZNK5chess5Board2atINS_5PieceEEET_NS_6SquareE; chess::Board::at<chess::Piece>(chess::Square)
mov rdi, [rbp+var_480]
mov [rbp+var_45D], al
mov al, [rbp+var_457]
mov [rbp+var_465], al
movzx esi, [rbp+var_465]
call _ZN6Engine13getPieceValueEN5chess5PieceE; Engine::getPieceValue(chess::Piece)
mov rdi, [rbp+var_480]
mov [rbp+var_484], eax
mov al, [rbp+var_45D]
mov [rbp+var_466], al
movzx esi, [rbp+var_466]
call _ZN6Engine13getPieceValueEN5chess5PieceE; Engine::getPieceValue(chess::Piece)
mov ecx, eax
mov eax, [rbp+var_484]
add ecx, 32h ; '2'
cmp eax, ecx
jle short loc_1B9DF
jmp loc_1BAAD
loc_1B9DF:
mov rdi, [rbp+var_448]; this
call _ZNK5chess4Move6typeOfEv; chess::Move::typeOf(void)
movzx eax, ax
cmp eax, 4000h
jnz short loc_1BA1C
lea rdi, [rbp+var_457]; this
call _ZNK5chess5Piece4typeEv; chess::Piece::type(void)
mov [rbp+var_467], al
lea rdi, [rbp+var_467]
call _ZNK5chess9PieceTypecviEv; chess::PieceType::operator int(void)
cmp eax, 1
jnz short loc_1BA1A
jmp short loc_1BA1E
loc_1BA1A:
jmp short $+2
loc_1BA1C:
jmp short $+2
loc_1BA1E:
mov rdi, [rbp+var_480]
mov rax, [rbp+var_448]
mov eax, [rax]
mov [rbp+var_46C], eax
mov esi, [rbp+var_46C]
call _ZN5chess5Board8makeMoveILb0EEEvNS_4MoveE; chess::Board::makeMove<false>(chess::Move)
mov rdi, [rbp+var_480]; this
xor esi, esi
sub esi, [rbp+var_18]; int
xor edx, edx
sub edx, [rbp+var_14]; int
mov ecx, [rbp+var_1C]; int
call _ZN6Engine14extendedSearchEiii; Engine::extendedSearch(int,int,int)
mov rdi, [rbp+var_480]
mov ecx, eax
xor eax, eax
sub eax, ecx
mov [rbp+var_470], eax
mov rax, [rbp+var_448]
mov eax, [rax]
mov [rbp+var_474], eax
mov esi, [rbp+var_474]
call _ZN5chess5Board10unmakeMoveENS_4MoveE; chess::Board::unmakeMove(chess::Move)
mov eax, [rbp+var_470]
cmp eax, [rbp+var_18]
jl short loc_1BA98
mov eax, [rbp+var_18]
mov [rbp+var_4], eax
jmp short loc_1BACA
loc_1BA98:
lea rdi, [rbp+var_14]
lea rsi, [rbp+var_470]
call _ZSt3maxIiERKT_S2_S2_; std::max<int>(int const&,int const&)
mov eax, [rax]
mov [rbp+var_14], eax
loc_1BAAD:
mov rax, [rbp+var_438]
add rax, 4
mov [rbp+var_438], rax
jmp loc_1B886
loc_1BAC4:
mov eax, [rbp+var_14]
mov [rbp+var_4], eax
loc_1BACA:
mov eax, [rbp+var_4]
add rsp, 490h
pop rbp
retn
| long long Engine::extendedSearch(Engine *this, unsigned int a2, int a3, int a4)
{
signed int PieceValue; // [rsp+Ch] [rbp-484h]
int v6; // [rsp+20h] [rbp-470h] BYREF
int v7; // [rsp+24h] [rbp-46Ch]
unsigned __int8 v8[3]; // [rsp+29h] [rbp-467h] BYREF
int v9; // [rsp+2Ch] [rbp-464h]
char v10; // [rsp+33h] [rbp-45Dh]
int v11; // [rsp+34h] [rbp-45Ch]
char v12; // [rsp+39h] [rbp-457h] BYREF
unsigned int v13; // [rsp+3Ah] [rbp-456h]
unsigned int v14; // [rsp+3Eh] [rbp-452h]
char v15; // [rsp+43h] [rbp-44Dh]
int v16; // [rsp+44h] [rbp-44Ch]
chess::Move *v17; // [rsp+48h] [rbp-448h]
long long v18; // [rsp+50h] [rbp-440h]
chess::Move *v19; // [rsp+58h] [rbp-438h]
chess::Movelist *v20; // [rsp+60h] [rbp-430h]
_BYTE v21[1028]; // [rsp+6Ch] [rbp-424h] BYREF
int v22; // [rsp+470h] [rbp-20h] BYREF
int v23; // [rsp+474h] [rbp-1Ch]
int v24; // [rsp+478h] [rbp-18h]
unsigned int v25; // [rsp+47Ch] [rbp-14h] BYREF
Engine *v26; // [rsp+480h] [rbp-10h]
v26 = this;
v25 = a2;
v24 = a3;
v23 = a4;
++*((_DWORD *)this + 69);
v22 = Engine::evaluatePosition(this, this, ++v23);
if ( v22 < v24 )
{
v25 = *std::max<int>(&v22, &v25);
chess::Movelist::Movelist((chess::Movelist *)v21);
chess::movegen::legalmoves<(chess::movegen::MoveGenType)0>((chess::Movelist *)v21, this, 0x3Fu);
if ( chess::Movelist::empty((chess::Movelist *)v21) )
{
if ( (chess::Board::inCheck(this) & 1) != 0 )
return (unsigned int)(v23 - 100000);
else
return 0;
}
else
{
v20 = (chess::Movelist *)v21;
v19 = (chess::Move *)chess::Movelist::begin((chess::Movelist *)v21);
v18 = chess::Movelist::end((chess::Movelist *)v21);
while ( v19 != (chess::Move *)v18 )
{
v17 = v19;
v16 = *(_DWORD *)v19;
chess::Board::makeMove<false>((long long)this, v16);
v15 = chess::Board::inCheck(this) & 1;
v14 = *(_DWORD *)v17;
chess::Board::unmakeMove(this, v14);
v13 = *(_DWORD *)v17;
if ( (chess::Board::isCapture(this, v13) & 1) != 0 && (v15 & 1) != 0 )
{
v11 = chess::Move::from(v17);
v12 = chess::Board::at<chess::Piece>((long long)this, v11);
v9 = chess::Move::to(v17);
v10 = chess::Board::at<chess::Piece>((long long)this, v9);
v8[2] = v12;
PieceValue = Engine::getPieceValue((long long)this, v12);
v8[1] = v10;
if ( PieceValue <= (int)(Engine::getPieceValue((long long)this, v10) + 50) )
{
if ( (unsigned __int16)chess::Move::typeOf(v17) == 0x4000 )
{
v8[0] = chess::Piece::type((chess::Piece *)&v12);
chess::PieceType::operator int(v8);
}
v7 = *(_DWORD *)v17;
chess::Board::makeMove<false>((long long)this, v7);
v6 = -(int)Engine::extendedSearch(this, -v24, -v25, v23);
chess::Board::unmakeMove(this, *(unsigned int *)v17);
if ( v6 >= v24 )
return (unsigned int)v24;
v25 = *std::max<int>(&v25, &v6);
}
}
v19 = (chess::Move *)((char *)v19 + 4);
}
return v25;
}
}
else
{
return (unsigned int)v24;
}
}
| extendedSearch:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x490
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV dword ptr [RBP + -0x1c],ECX
MOV RSI,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x480],RSI
MOV EAX,dword ptr [RSI + 0x114]
ADD EAX,0x1
MOV dword ptr [RSI + 0x114],EAX
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x1c],EAX
MOV EDX,dword ptr [RBP + -0x1c]
MOV RDI,RSI
CALL 0x0011fa60
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x18]
JL 0x0011b7dc
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0011baca
LAB_0011b7dc:
LEA RDI,[RBP + -0x20]
LEA RSI,[RBP + -0x14]
CALL 0x00112720
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x14],EAX
LEA RDI,[RBP + -0x424]
CALL 0x00112f00
MOV RSI,qword ptr [RBP + -0x480]
LEA RDI,[RBP + -0x424]
MOV EDX,0x3f
CALL 0x00112f20
LEA RDI,[RBP + -0x424]
CALL 0x00112f90
TEST AL,0x1
JNZ 0x0011b824
JMP 0x0011b852
LAB_0011b824:
MOV RDI,qword ptr [RBP + -0x480]
CALL 0x00112fb0
TEST AL,0x1
JNZ 0x0011b836
JMP 0x0011b846
LAB_0011b836:
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,0xfffe7960
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0011baca
LAB_0011b846:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0011baca
LAB_0011b852:
LEA RAX,[RBP + -0x424]
MOV qword ptr [RBP + -0x430],RAX
MOV RDI,qword ptr [RBP + -0x430]
CALL 0x0011a030
MOV qword ptr [RBP + -0x438],RAX
MOV RDI,qword ptr [RBP + -0x430]
CALL 0x0011a050
MOV qword ptr [RBP + -0x440],RAX
LAB_0011b886:
MOV RAX,qword ptr [RBP + -0x438]
CMP RAX,qword ptr [RBP + -0x440]
JZ 0x0011bac4
MOV RDI,qword ptr [RBP + -0x480]
MOV RAX,qword ptr [RBP + -0x438]
MOV qword ptr [RBP + -0x448],RAX
MOV RAX,qword ptr [RBP + -0x448]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x44c],EAX
MOV ESI,dword ptr [RBP + -0x44c]
CALL 0x0010f860
MOV RDI,qword ptr [RBP + -0x480]
CALL 0x00112fb0
MOV RDI,qword ptr [RBP + -0x480]
AND AL,0x1
MOV byte ptr [RBP + -0x44d],AL
MOV RAX,qword ptr [RBP + -0x448]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x452],EAX
MOV ESI,dword ptr [RBP + -0x452]
CALL 0x0011d4a0
MOV RDI,qword ptr [RBP + -0x480]
MOV RAX,qword ptr [RBP + -0x448]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x456],EAX
MOV ESI,dword ptr [RBP + -0x456]
CALL 0x0011d210
TEST AL,0x1
JNZ 0x0011b925
JMP 0x0011b92e
LAB_0011b925:
TEST byte ptr [RBP + -0x44d],0x1
JNZ 0x0011b933
LAB_0011b92e:
JMP 0x0011baad
LAB_0011b933:
MOV RDI,qword ptr [RBP + -0x448]
CALL 0x001197a0
MOV RDI,qword ptr [RBP + -0x480]
MOV dword ptr [RBP + -0x45c],EAX
MOV ESI,dword ptr [RBP + -0x45c]
CALL 0x0010a5b0
MOV byte ptr [RBP + -0x457],AL
MOV RDI,qword ptr [RBP + -0x448]
CALL 0x001197e0
MOV RDI,qword ptr [RBP + -0x480]
MOV dword ptr [RBP + -0x464],EAX
MOV ESI,dword ptr [RBP + -0x464]
CALL 0x0010a5b0
MOV RDI,qword ptr [RBP + -0x480]
MOV byte ptr [RBP + -0x45d],AL
MOV AL,byte ptr [RBP + -0x457]
MOV byte ptr [RBP + -0x465],AL
MOVZX ESI,byte ptr [RBP + -0x465]
CALL 0x0010f440
MOV RDI,qword ptr [RBP + -0x480]
MOV dword ptr [RBP + -0x484],EAX
MOV AL,byte ptr [RBP + -0x45d]
MOV byte ptr [RBP + -0x466],AL
MOVZX ESI,byte ptr [RBP + -0x466]
CALL 0x0010f440
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x484]
ADD ECX,0x32
CMP EAX,ECX
JLE 0x0011b9df
JMP 0x0011baad
LAB_0011b9df:
MOV RDI,qword ptr [RBP + -0x448]
CALL 0x00119820
MOVZX EAX,AX
CMP EAX,0x4000
JNZ 0x0011ba1c
LEA RDI,[RBP + -0x457]
CALL 0x00109fb0
MOV byte ptr [RBP + -0x467],AL
LEA RDI,[RBP + -0x467]
CALL 0x0010a120
CMP EAX,0x1
JNZ 0x0011ba1a
JMP 0x0011ba1e
LAB_0011ba1a:
JMP 0x0011ba1c
LAB_0011ba1c:
JMP 0x0011ba1e
LAB_0011ba1e:
MOV RDI,qword ptr [RBP + -0x480]
MOV RAX,qword ptr [RBP + -0x448]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x46c],EAX
MOV ESI,dword ptr [RBP + -0x46c]
CALL 0x0010f860
MOV RDI,qword ptr [RBP + -0x480]
XOR ESI,ESI
SUB ESI,dword ptr [RBP + -0x18]
XOR EDX,EDX
SUB EDX,dword ptr [RBP + -0x14]
MOV ECX,dword ptr [RBP + -0x1c]
CALL 0x0011b780
MOV RDI,qword ptr [RBP + -0x480]
MOV ECX,EAX
XOR EAX,EAX
SUB EAX,ECX
MOV dword ptr [RBP + -0x470],EAX
MOV RAX,qword ptr [RBP + -0x448]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x474],EAX
MOV ESI,dword ptr [RBP + -0x474]
CALL 0x0011d4a0
MOV EAX,dword ptr [RBP + -0x470]
CMP EAX,dword ptr [RBP + -0x18]
JL 0x0011ba98
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0011baca
LAB_0011ba98:
LEA RDI,[RBP + -0x14]
LEA RSI,[RBP + -0x470]
CALL 0x00112720
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x14],EAX
LAB_0011baad:
MOV RAX,qword ptr [RBP + -0x438]
ADD RAX,0x4
MOV qword ptr [RBP + -0x438],RAX
JMP 0x0011b886
LAB_0011bac4:
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x4],EAX
LAB_0011baca:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x490
POP RBP
RET
|
/* Engine::extendedSearch(int, int, int) */
int __thiscall Engine::extendedSearch(Engine *this,int param_1,int param_2,int param_3)
{
short sVar1;
int iVar2;
int iVar3;
int *piVar4;
ulong uVar5;
int local_478;
int4 local_474;
PieceType local_46f;
int1 local_46e;
Piece local_46d;
int4 local_46c;
int1 local_465;
int4 local_464;
Piece local_45f;
int4 local_45e;
int4 local_45a;
byte local_455;
int4 local_454;
Move *local_450;
Move *local_448;
Move *local_440;
Movelist *local_438;
Movelist local_42c [1028];
int local_28;
int local_24;
int local_20;
int local_1c;
Engine *local_18;
int local_c;
*(int *)(this + 0x114) = *(int *)(this + 0x114) + 1;
local_24 = param_3 + 1;
local_20 = param_2;
local_1c = param_1;
local_18 = this;
local_28 = evaluatePosition(this,(Board *)this,local_24);
if (local_28 < local_20) {
piVar4 = std::max<int>(&local_28,&local_1c);
local_1c = *piVar4;
chess::Movelist::Movelist(local_42c);
chess::movegen::legalmoves<(chess::movegen::MoveGenType)0>(local_42c,(Board *)this,0x3f);
uVar5 = chess::Movelist::empty(local_42c);
if ((uVar5 & 1) == 0) {
local_438 = local_42c;
local_440 = (Move *)chess::Movelist::begin(local_438);
local_448 = (Move *)chess::Movelist::end(local_438);
for (; local_440 != local_448; local_440 = local_440 + 4) {
local_450 = local_440;
local_454 = *(int4 *)local_440;
chess::Board::makeMove<false>((Board *)this,local_454);
local_455 = chess::Board::inCheck((Board *)this);
local_455 = local_455 & 1;
local_45a = *(int4 *)local_450;
chess::Board::unmakeMove((Board *)this,local_45a);
local_45e = *(int4 *)local_450;
uVar5 = chess::Board::isCapture((Board *)this,local_45e);
if (((uVar5 & 1) != 0) && ((local_455 & 1) != 0)) {
local_464 = chess::Move::from(local_450);
local_45f = (Piece)chess::Board::at<chess::Piece>((Board *)this,local_464);
local_46c = chess::Move::to(local_450);
local_465 = chess::Board::at<chess::Piece>((Board *)this,local_46c);
local_46d = local_45f;
iVar2 = getPieceValue(this,local_45f);
local_46e = local_465;
iVar3 = getPieceValue(this,local_465);
if (iVar2 <= iVar3 + 0x32) {
sVar1 = chess::Move::typeOf(local_450);
if (sVar1 == 0x4000) {
local_46f = (PieceType)chess::Piece::type(&local_45f);
chess::PieceType::operator_cast_to_int(&local_46f);
}
local_474 = *(int4 *)local_450;
chess::Board::makeMove<false>((Board *)this);
local_478 = extendedSearch(this,-local_20,-local_1c,local_24);
local_478 = -local_478;
chess::Board::unmakeMove((Board *)this,*(int4 *)local_450);
if (local_20 <= local_478) {
return local_20;
}
piVar4 = std::max<int>(&local_1c,&local_478);
local_1c = *piVar4;
}
}
}
local_c = local_1c;
}
else {
uVar5 = chess::Board::inCheck((Board *)this);
if ((uVar5 & 1) == 0) {
local_c = 0;
}
else {
local_c = local_24 + -100000;
}
}
}
else {
local_c = local_20;
}
return local_c;
}
| |
48,322 | Engine::extendedSearch(int, int, int) | Razamindset[P]pawnstar-chess-engine/src/engine/search.cpp | int Engine::extendedSearch(int alpha, int beta, int ply) {
positionsSearched++;
ply++;
int evaluation = evaluatePosition(board, ply);
// Alpha-beta pruning: If the evaluation is greater than or equal to beta,
// the minimizing player has found a move that the maximizing player would
// never allow. So, we prune this branch.
if (evaluation >= beta) return beta;
// Update alpha to track the best score found so far for the maximizing
// player.
alpha = std::max(evaluation, alpha);
Movelist moves;
movegen::legalmoves(moves, board);
if (moves.empty()) {
if (board.inCheck()) {
return -MATE_SCORE + ply;
} else {
return 0;
}
}
for (const auto& move : moves) {
board.makeMove(move);
bool inCheck = board.inCheck();
board.unmakeMove(move);
if (!board.isCapture(move) || !inCheck)
continue; // Only consider captures in quiescence search.
// The following line is really necessary. I donot know if it is the best
// thing but it works. What we do is only consider capturing moves of
// higher value with lower value pieces. This brings down our search time
// from 30s to 6-7s
Piece attacker = board.at(move.from());
Piece victim = board.at(move.to());
// Allow equal captures (like queen takes queen)
if (getPieceValue(attacker) > getPieceValue(victim) + 50) continue;
// Consider promoted pawns specially
if (move.typeOf() == Move::PROMOTION) {
// Always consider pawn captures that lead to promotion
if (attacker.type() == PAWN) goto makeMove;
}
makeMove:
board.makeMove(move);
// Negamax with alpha-beta pruning: The roles of alpha and beta are
// swapped because each layer alternates between maximizing and
// minimizing.
int score = -extendedSearch(-beta, -alpha, ply);
board.unmakeMove(move);
// Beta cutoff: If we find a move better than beta for the maximizing
// player, the minimizing player will never allow this position, so we
// prune the search.
if (score >= beta) {
return beta;
}
// Update alpha to the best score found so far.
alpha = std::max(alpha, score);
}
return alpha;
} | O1 | cpp | Engine::extendedSearch(int, int, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x428, %rsp # imm = 0x428
movl %ecx, %r12d
movl %edx, %ebp
movl %esi, %ebx
movq %rdi, %r14
incl 0x114(%rdi)
leal 0x1(%r12), %edx
movq %rdi, %rsi
movl %edx, 0x14(%rsp)
callq 0xc9d8
cmpl %ebp, %eax
jge 0xb2b2
cmpl %ebx, %eax
cmovgl %eax, %ebx
movl $0x0, 0x424(%rsp)
cmpb $0x0, 0xae(%r14)
je 0xb142
leaq 0x24(%rsp), %rdi
movq %r14, %rsi
movl $0x3f, %edx
callq 0x8b88
jmp 0xb154
leaq 0x24(%rsp), %rdi
movq %r14, %rsi
movl $0x3f, %edx
callq 0x8522
movslq 0x424(%rsp), %rax
testq %rax, %rax
je 0xb293
movl %ebp, 0x10(%rsp)
negl %ebp
movl %ebp, 0xc(%rsp)
shlq $0x2, %rax
xorl %ebp, %ebp
movq %rax, %r12
movq %rax, 0x18(%rsp)
movl 0x24(%rsp,%rbp), %esi
movq %r14, %rdi
callq 0x6f7e
movq %r14, %rdi
callq 0x84bc
movl %eax, %r13d
movl 0x24(%rsp,%rbp), %esi
movq %r14, %rdi
callq 0xbafe
movl 0x24(%rsp,%rbp), %eax
movzwl %ax, %ecx
cmpl $0xbfff, %ecx # imm = 0xBFFF
ja 0xb1c0
movl %eax, %ecx
andl $0x3f, %ecx
cmpb $0xc, 0x60(%r14,%rcx)
je 0xb1c0
xorl %eax, %eax
jmp 0xb1cb
andl $0xc000, %eax # imm = 0xC000
negw %ax
setno %al
movl $0x3, %r15d
testb %al, %al
jne 0xb279
xorb $0x1, %r13b
jne 0xb279
movzwl 0x24(%rsp,%rbp), %eax
movl %eax, %ecx
shrl $0x6, %ecx
andl $0x3f, %ecx
andl $0x3f, %eax
movzbl 0x60(%r14,%rcx), %esi
movzbl 0x60(%r14,%rax), %r13d
movq %r14, %rdi
callq 0x6c2a
movl %eax, %r12d
movq %r14, %rdi
movl %r13d, %esi
callq 0x6c2a
addl $0x32, %eax
cmpl %eax, %r12d
jg 0xb274
movl 0x24(%rsp,%rbp), %esi
movq %r14, %rdi
callq 0x6f7e
movl %ebx, %edx
negl %edx
movq %r14, %rdi
movl 0xc(%rsp), %esi
movl 0x14(%rsp), %ecx
callq 0xb0da
movl %eax, %r12d
negl %r12d
movl 0x24(%rsp,%rbp), %esi
movq %r14, %rdi
callq 0xbafe
cmpl %r12d, %ebx
movl %r12d, %eax
cmovgl %ebx, %eax
xorl %r15d, %r15d
movl 0x10(%rsp), %ecx
cmpl %ecx, %r12d
setge %r15b
cmovll %eax, %ebx
movl 0x8(%rsp), %eax
cmovgel %ecx, %eax
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %r12
cmpl $0x3, %r15d
je 0xb284
testl %r15d, %r15d
jne 0xb2ac
addq $0x4, %rbp
cmpq %rbp, %r12
jne 0xb17d
jmp 0xb2b0
movq %r14, %rdi
callq 0x84bc
addl $0xfffe7961, %r12d # imm = 0xFFFE7961
xorl %ebx, %ebx
testb %al, %al
cmovnel %r12d, %ebx
jmp 0xb2b0
movl 0x8(%rsp), %ebx
movl %ebx, %ebp
movl %ebp, %eax
addq $0x428, %rsp # imm = 0x428
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZN6Engine14extendedSearchEiii:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 428h
mov r12d, ecx
mov ebp, edx
mov ebx, esi
mov r14, rdi
inc dword ptr [rdi+114h]
lea edx, [r12+1]; int
mov rsi, rdi; chess::Board *
mov [rsp+458h+var_444], edx
call _ZN6Engine16evaluatePositionERKN5chess5BoardEi; Engine::evaluatePosition(chess::Board const&,int)
cmp eax, ebp
jge loc_B2B2
cmp eax, ebx
cmovg ebx, eax
mov [rsp+458h+var_34], 0
cmp byte ptr [r14+0AEh], 0
jz short loc_B142
lea rdi, [rsp+458h+var_434]
mov rsi, r14
mov edx, 3Fh ; '?'
call _ZN5chess7movegen10legalmovesILNS_5Color10underlyingE1ELNS0_11MoveGenTypeE0EEEvRNS_8MovelistERKNS_5BoardEi; chess::movegen::legalmoves<(chess::Color::underlying)1,(chess::movegen::MoveGenType)0>(chess::Movelist &,chess::Board const&,int)
jmp short loc_B154
loc_B142:
lea rdi, [rsp+458h+var_434]
mov rsi, r14
mov edx, 3Fh ; '?'
call _ZN5chess7movegen10legalmovesILNS_5Color10underlyingE0ELNS0_11MoveGenTypeE0EEEvRNS_8MovelistERKNS_5BoardEi; chess::movegen::legalmoves<(chess::Color::underlying)0,(chess::movegen::MoveGenType)0>(chess::Movelist &,chess::Board const&,int)
loc_B154:
movsxd rax, [rsp+458h+var_34]
test rax, rax
jz loc_B293
mov [rsp+458h+var_448], ebp
neg ebp
mov [rsp+458h+var_44C], ebp
shl rax, 2
xor ebp, ebp
mov r12, rax
mov [rsp+458h+var_440], rax
loc_B17D:
mov esi, [rsp+rbp+458h+var_434]
mov rdi, r14
call _ZN5chess5Board8makeMoveILb0EEEvNS_4MoveE; chess::Board::makeMove<false>(chess::Move)
mov rdi, r14; this
call _ZNK5chess5Board7inCheckEv; chess::Board::inCheck(void)
mov r13d, eax
mov esi, [rsp+rbp+458h+var_434]
mov rdi, r14
call _ZN5chess5Board10unmakeMoveENS_4MoveE; chess::Board::unmakeMove(chess::Move)
mov eax, [rsp+rbp+458h+var_434]
movzx ecx, ax
cmp ecx, 0BFFFh
ja short loc_B1C0
mov ecx, eax
and ecx, 3Fh
cmp byte ptr [r14+rcx+60h], 0Ch
jz short loc_B1C0
xor eax, eax
jmp short loc_B1CB
loc_B1C0:
and eax, 0C000h
neg ax
setno al
loc_B1CB:
mov r15d, 3
test al, al
jnz loc_B279
xor r13b, 1
jnz loc_B279
movzx eax, word ptr [rsp+rbp+458h+var_434]
mov ecx, eax
shr ecx, 6
and ecx, 3Fh
and eax, 3Fh
movzx esi, byte ptr [r14+rcx+60h]
movzx r13d, byte ptr [r14+rax+60h]
mov rdi, r14
call _ZN6Engine13getPieceValueEN5chess5PieceE; Engine::getPieceValue(chess::Piece)
mov r12d, eax
mov rdi, r14
mov esi, r13d
call _ZN6Engine13getPieceValueEN5chess5PieceE; Engine::getPieceValue(chess::Piece)
add eax, 32h ; '2'
cmp r12d, eax
jg short loc_B274
mov esi, [rsp+rbp+458h+var_434]
mov rdi, r14
call _ZN5chess5Board8makeMoveILb0EEEvNS_4MoveE; chess::Board::makeMove<false>(chess::Move)
mov edx, ebx
neg edx; int
mov rdi, r14; this
mov esi, [rsp+458h+var_44C]; int
mov ecx, [rsp+458h+var_444]; int
call _ZN6Engine14extendedSearchEiii; Engine::extendedSearch(int,int,int)
mov r12d, eax
neg r12d
mov esi, [rsp+rbp+458h+var_434]
mov rdi, r14
call _ZN5chess5Board10unmakeMoveENS_4MoveE; chess::Board::unmakeMove(chess::Move)
cmp ebx, r12d
mov eax, r12d
cmovg eax, ebx
xor r15d, r15d
mov ecx, [rsp+458h+var_448]
cmp r12d, ecx
setnl r15b
cmovl ebx, eax
mov eax, [rsp+458h+var_450]
cmovge eax, ecx
mov [rsp+458h+var_450], eax
loc_B274:
mov r12, [rsp+458h+var_440]
loc_B279:
cmp r15d, 3
jz short loc_B284
test r15d, r15d
jnz short loc_B2AC
loc_B284:
add rbp, 4
cmp r12, rbp
jnz loc_B17D
jmp short loc_B2B0
loc_B293:
mov rdi, r14; this
call _ZNK5chess5Board7inCheckEv; chess::Board::inCheck(void)
add r12d, 0FFFE7961h
xor ebx, ebx
test al, al
cmovnz ebx, r12d
jmp short loc_B2B0
loc_B2AC:
mov ebx, [rsp+458h+var_450]
loc_B2B0:
mov ebp, ebx
loc_B2B2:
mov eax, ebp
add rsp, 428h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long Engine::extendedSearch(Engine *this, signed int a2, int a3, int a4)
{
unsigned int v6; // ebx
signed int v7; // eax
unsigned long long v8; // rbp
long long v9; // r12
char v10; // r13
int v11; // eax
bool v12; // al
int v13; // r15d
char v14; // r13
signed int PieceValue; // r12d
int v16; // r12d
int v17; // eax
int v18; // eax
unsigned int v19; // r12d
unsigned int v21; // [rsp+8h] [rbp-450h]
int v22; // [rsp+Ch] [rbp-44Ch]
int v23; // [rsp+10h] [rbp-448h]
int v24; // [rsp+14h] [rbp-444h]
long long v25; // [rsp+18h] [rbp-440h]
_DWORD v26[256]; // [rsp+24h] [rbp-434h] BYREF
int v27; // [rsp+424h] [rbp-34h]
v6 = a2;
++*((_DWORD *)this + 69);
v24 = a4 + 1;
v7 = Engine::evaluatePosition(this, this, a4 + 1);
if ( v7 < a3 )
{
if ( v7 > a2 )
v6 = v7;
v27 = 0;
if ( *((_BYTE *)this + 174) )
chess::movegen::legalmoves<(chess::Color::underlying)1,(chess::movegen::MoveGenType)0>((long long)v26, this, 63);
else
chess::movegen::legalmoves<(chess::Color::underlying)0,(chess::movegen::MoveGenType)0>(
(long long)v26,
(long long)this,
63);
if ( v27 )
{
v23 = a3;
v22 = -a3;
v8 = 0LL;
v9 = 4LL * v27;
v25 = v9;
while ( 1 )
{
chess::Board::makeMove<false>((long long *)this, v26[v8 / 4]);
v10 = chess::Board::inCheck(this);
chess::Board::unmakeMove(this, (unsigned int)v26[v8 / 4]);
v11 = v26[v8 / 4];
v12 = ((unsigned __int16)v11 > 0xBFFFu || *((_BYTE *)this + (v11 & 0x3F) + 96) == 12)
&& !__OFSUB__(-(v11 & 0xC000), 1);
v13 = 3;
if ( !v12 && v10 == 1 )
{
v14 = *((_BYTE *)this + (v26[v8 / 4] & 0x3F) + 96);
PieceValue = Engine::getPieceValue((long long)this, *((_BYTE *)this + ((LOWORD(v26[v8 / 4]) >> 6) & 0x3F) + 96));
if ( PieceValue <= (int)(Engine::getPieceValue((long long)this, v14) + 50) )
{
chess::Board::makeMove<false>((long long *)this, v26[v8 / 4]);
v16 = -(int)Engine::extendedSearch(this, v22, -v6, v24);
chess::Board::unmakeMove(this, (unsigned int)v26[v8 / 4]);
v17 = v16;
if ( (int)v6 > v16 )
v17 = v6;
v13 = v16 >= v23;
if ( v16 < v23 )
v6 = v17;
v18 = v21;
if ( v16 >= v23 )
v18 = v23;
v21 = v18;
}
v9 = v25;
}
if ( v13 != 3 && v13 )
break;
v8 += 4LL;
if ( v9 == v8 )
return v6;
}
return v21;
}
else
{
v19 = a4 - 99999;
v6 = 0;
if ( (unsigned __int8)chess::Board::inCheck(this) )
return v19;
}
return v6;
}
return (unsigned int)a3;
}
| extendedSearch:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x428
MOV R12D,ECX
MOV EBP,EDX
MOV EBX,ESI
MOV R14,RDI
INC dword ptr [RDI + 0x114]
LEA EDX,[R12 + 0x1]
MOV RSI,RDI
MOV dword ptr [RSP + 0x14],EDX
CALL 0x0010c9d8
CMP EAX,EBP
JGE 0x0010b2b2
CMP EAX,EBX
CMOVG EBX,EAX
MOV dword ptr [RSP + 0x424],0x0
CMP byte ptr [R14 + 0xae],0x0
JZ 0x0010b142
LEA RDI,[RSP + 0x24]
MOV RSI,R14
MOV EDX,0x3f
CALL 0x00108b88
JMP 0x0010b154
LAB_0010b142:
LEA RDI,[RSP + 0x24]
MOV RSI,R14
MOV EDX,0x3f
CALL 0x00108522
LAB_0010b154:
MOVSXD RAX,dword ptr [RSP + 0x424]
TEST RAX,RAX
JZ 0x0010b293
MOV dword ptr [RSP + 0x10],EBP
NEG EBP
MOV dword ptr [RSP + 0xc],EBP
SHL RAX,0x2
XOR EBP,EBP
MOV R12,RAX
MOV qword ptr [RSP + 0x18],RAX
LAB_0010b17d:
MOV ESI,dword ptr [RSP + RBP*0x1 + 0x24]
MOV RDI,R14
CALL 0x00106f7e
MOV RDI,R14
CALL 0x001084bc
MOV R13D,EAX
MOV ESI,dword ptr [RSP + RBP*0x1 + 0x24]
MOV RDI,R14
CALL 0x0010bafe
MOV EAX,dword ptr [RSP + RBP*0x1 + 0x24]
MOVZX ECX,AX
CMP ECX,0xbfff
JA 0x0010b1c0
MOV ECX,EAX
AND ECX,0x3f
CMP byte ptr [R14 + RCX*0x1 + 0x60],0xc
JZ 0x0010b1c0
XOR EAX,EAX
JMP 0x0010b1cb
LAB_0010b1c0:
AND EAX,0xc000
NEG AX
SETNO AL
LAB_0010b1cb:
MOV R15D,0x3
TEST AL,AL
JNZ 0x0010b279
XOR R13B,0x1
JNZ 0x0010b279
MOVZX EAX,word ptr [RSP + RBP*0x1 + 0x24]
MOV ECX,EAX
SHR ECX,0x6
AND ECX,0x3f
AND EAX,0x3f
MOVZX ESI,byte ptr [R14 + RCX*0x1 + 0x60]
MOVZX R13D,byte ptr [R14 + RAX*0x1 + 0x60]
MOV RDI,R14
CALL 0x00106c2a
MOV R12D,EAX
MOV RDI,R14
MOV ESI,R13D
CALL 0x00106c2a
ADD EAX,0x32
CMP R12D,EAX
JG 0x0010b274
MOV ESI,dword ptr [RSP + RBP*0x1 + 0x24]
MOV RDI,R14
CALL 0x00106f7e
MOV EDX,EBX
NEG EDX
MOV RDI,R14
MOV ESI,dword ptr [RSP + 0xc]
MOV ECX,dword ptr [RSP + 0x14]
CALL 0x0010b0da
MOV R12D,EAX
NEG R12D
MOV ESI,dword ptr [RSP + RBP*0x1 + 0x24]
MOV RDI,R14
CALL 0x0010bafe
CMP EBX,R12D
MOV EAX,R12D
CMOVG EAX,EBX
XOR R15D,R15D
MOV ECX,dword ptr [RSP + 0x10]
CMP R12D,ECX
SETGE R15B
CMOVL EBX,EAX
MOV EAX,dword ptr [RSP + 0x8]
CMOVGE EAX,ECX
MOV dword ptr [RSP + 0x8],EAX
LAB_0010b274:
MOV R12,qword ptr [RSP + 0x18]
LAB_0010b279:
CMP R15D,0x3
JZ 0x0010b284
TEST R15D,R15D
JNZ 0x0010b2ac
LAB_0010b284:
ADD RBP,0x4
CMP R12,RBP
JNZ 0x0010b17d
JMP 0x0010b2b0
LAB_0010b293:
MOV RDI,R14
CALL 0x001084bc
ADD R12D,0xfffe7961
XOR EBX,EBX
TEST AL,AL
CMOVNZ EBX,R12D
JMP 0x0010b2b0
LAB_0010b2ac:
MOV EBX,dword ptr [RSP + 0x8]
LAB_0010b2b0:
MOV EBP,EBX
LAB_0010b2b2:
MOV EAX,EBP
ADD RSP,0x428
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* Engine::extendedSearch(int, int, int) */
int __thiscall Engine::extendedSearch(Engine *this,int param_1,int param_2,int param_3)
{
Engine EVar1;
bool bVar2;
char cVar3;
int iVar4;
int iVar5;
long lVar6;
int iVar7;
long lVar8;
char cVar9;
int local_450;
Movelist local_434 [1024];
int local_34;
*(int *)(this + 0x114) = *(int *)(this + 0x114) + 1;
iVar4 = evaluatePosition(this,(Board *)this,param_3 + 1);
iVar7 = param_2;
if (iVar4 < param_2) {
if (param_1 < iVar4) {
param_1 = iVar4;
}
local_34 = 0;
if (this[0xae] == (Engine)0x0) {
chess::movegen::legalmoves<(chess::Color::underlying)0,(chess::movegen::MoveGenType)0>
(local_434,(Board *)this,0x3f);
}
else {
chess::movegen::legalmoves<(chess::Color::underlying)1,(chess::movegen::MoveGenType)0>
(local_434,(Board *)this,0x3f);
}
lVar6 = (long)local_34;
if (lVar6 == 0) {
cVar3 = chess::Board::inCheck((Board *)this);
iVar7 = 0;
if (cVar3 != '\0') {
iVar7 = param_3 + -99999;
}
}
else {
lVar8 = 0;
do {
chess::Board::makeMove<false>((Board *)this,*(int4 *)(local_434 + lVar8));
cVar3 = chess::Board::inCheck((Board *)this);
chess::Board::unmakeMove((Board *)this,*(int4 *)(local_434 + lVar8));
if (((*(uint *)(local_434 + lVar8) & 0xffff) < 0xc000) &&
(this[(ulong)(*(uint *)(local_434 + lVar8) & 0x3f) + 0x60] != (Engine)0xc)) {
bVar2 = false;
}
else {
bVar2 = true;
}
iVar7 = param_1;
cVar9 = '\x03';
if ((!bVar2) && (cVar3 == '\x01')) {
EVar1 = this[(ulong)(*(ushort *)(local_434 + lVar8) & 0x3f) + 0x60];
iVar4 = getPieceValue(this,this[(ulong)(*(ushort *)(local_434 + lVar8) >> 6 & 0x3f) + 0x60
]);
iVar5 = getPieceValue(this,EVar1);
cVar9 = '\x03';
if (iVar4 <= iVar5 + 0x32) {
chess::Board::makeMove<false>((Board *)this,*(int4 *)(local_434 + lVar8));
iVar4 = extendedSearch(this,-param_2,-param_1,param_3 + 1);
iVar5 = -iVar4;
chess::Board::unmakeMove((Board *)this,*(int4 *)(local_434 + lVar8));
iVar7 = iVar5;
if (param_1 != iVar5 && SBORROW4(param_1,iVar5) == param_1 + iVar4 < 0) {
iVar7 = param_1;
}
cVar9 = param_2 <= iVar5;
if (param_2 <= iVar5) {
local_450 = param_2;
iVar7 = param_1;
}
}
}
param_1 = iVar7;
} while (((cVar9 == '\x03') || (iVar7 = local_450, cVar9 == '\0')) &&
(lVar8 = lVar8 + 4, iVar7 = param_1, lVar6 << 2 != lVar8));
}
}
return iVar7;
}
| |
48,323 | Engine::extendedSearch(int, int, int) | Razamindset[P]pawnstar-chess-engine/src/engine/search.cpp | int Engine::extendedSearch(int alpha, int beta, int ply) {
positionsSearched++;
ply++;
int evaluation = evaluatePosition(board, ply);
// Alpha-beta pruning: If the evaluation is greater than or equal to beta,
// the minimizing player has found a move that the maximizing player would
// never allow. So, we prune this branch.
if (evaluation >= beta) return beta;
// Update alpha to track the best score found so far for the maximizing
// player.
alpha = std::max(evaluation, alpha);
Movelist moves;
movegen::legalmoves(moves, board);
if (moves.empty()) {
if (board.inCheck()) {
return -MATE_SCORE + ply;
} else {
return 0;
}
}
for (const auto& move : moves) {
board.makeMove(move);
bool inCheck = board.inCheck();
board.unmakeMove(move);
if (!board.isCapture(move) || !inCheck)
continue; // Only consider captures in quiescence search.
// The following line is really necessary. I donot know if it is the best
// thing but it works. What we do is only consider capturing moves of
// higher value with lower value pieces. This brings down our search time
// from 30s to 6-7s
Piece attacker = board.at(move.from());
Piece victim = board.at(move.to());
// Allow equal captures (like queen takes queen)
if (getPieceValue(attacker) > getPieceValue(victim) + 50) continue;
// Consider promoted pawns specially
if (move.typeOf() == Move::PROMOTION) {
// Always consider pawn captures that lead to promotion
if (attacker.type() == PAWN) goto makeMove;
}
makeMove:
board.makeMove(move);
// Negamax with alpha-beta pruning: The roles of alpha and beta are
// swapped because each layer alternates between maximizing and
// minimizing.
int score = -extendedSearch(-beta, -alpha, ply);
board.unmakeMove(move);
// Beta cutoff: If we find a move better than beta for the maximizing
// player, the minimizing player will never allow this position, so we
// prune the search.
if (score >= beta) {
return beta;
}
// Update alpha to the best score found so far.
alpha = std::max(alpha, score);
}
return alpha;
} | O3 | cpp | Engine::extendedSearch(int, int, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x418, %rsp # imm = 0x418
movl %ecx, %r12d
movl %edx, %ebp
movl %esi, %ebx
movq %rdi, %r14
incl 0x114(%rdi)
leal 0x1(%r12), %edx
movq %rdi, %rsi
movl %edx, 0x10(%rsp)
callq 0xb692
cmpl %ebp, %eax
jge 0xa062
cmpl %ebx, %eax
cmovgl %eax, %ebx
movl $0x0, 0x414(%rsp)
cmpb $0x0, 0xae(%r14)
je 0x9f2e
leaq 0x14(%rsp), %rdi
movq %r14, %rsi
movl $0x3f, %edx
callq 0x7a5c
jmp 0x9f40
leaq 0x14(%rsp), %rdi
movq %r14, %rsi
movl $0x3f, %edx
callq 0x73b0
movslq 0x414(%rsp), %r15
testq %r15, %r15
je 0xa043
movl %ebp, 0x8(%rsp)
negl %ebp
movl %ebp, 0xc(%rsp)
shlq $0x2, %r15
xorl %ebp, %ebp
movl 0x14(%rsp,%rbp), %esi
movq %r14, %rdi
callq 0x5df6
movq %r14, %rdi
callq 0x734a
movl %eax, %r13d
movl 0x14(%rsp,%rbp), %esi
movq %r14, %rdi
callq 0xa8d6
movl 0x14(%rsp,%rbp), %eax
movzwl %ax, %ecx
cmpl $0xbfff, %ecx # imm = 0xBFFF
ja 0x9fa4
movl %eax, %ecx
andl $0x3f, %ecx
cmpb $0xc, 0x60(%r14,%rcx)
je 0x9fa4
xorl %ecx, %ecx
jmp 0x9fb2
movl %eax, %ecx
andl $0xc000, %ecx # imm = 0xC000
negw %cx
setno %cl
testb %cl, %cl
jne 0xa034
xorb $0x1, %r13b
jne 0xa034
movl %eax, %ecx
shrl $0x6, %ecx
andl $0x3f, %ecx
movzwl %ax, %eax
andl $0x3f, %eax
movzbl 0x60(%r14,%rcx), %esi
movzbl 0x60(%r14,%rax), %r13d
movq %r14, %rdi
callq 0x5aa2
movl %eax, %r12d
movq %r14, %rdi
movl %r13d, %esi
callq 0x5aa2
addl $0x32, %eax
cmpl %eax, %r12d
jg 0xa034
movl 0x14(%rsp,%rbp), %esi
movq %r14, %rdi
callq 0x5df6
movl %ebx, %edx
negl %edx
movq %r14, %rdi
movl 0xc(%rsp), %esi
movl 0x10(%rsp), %ecx
callq 0x9ec6
movl %eax, %r13d
negl %r13d
movl 0x14(%rsp,%rbp), %esi
movq %r14, %rdi
callq 0xa8d6
cmpl 0x8(%rsp), %r13d
jge 0xa05c
cmpl %r13d, %ebx
cmovlel %r13d, %ebx
addq $0x4, %rbp
cmpq %rbp, %r15
jne 0x9f61
jmp 0xa060
movq %r14, %rdi
callq 0x734a
addl $0xfffe7961, %r12d # imm = 0xFFFE7961
xorl %ebx, %ebx
testb %al, %al
cmovnel %r12d, %ebx
jmp 0xa060
movl 0x8(%rsp), %ebx
movl %ebx, %ebp
movl %ebp, %eax
addq $0x418, %rsp # imm = 0x418
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZN6Engine14extendedSearchEiii:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 418h
mov r12d, ecx
mov ebp, edx
mov ebx, esi
mov r14, rdi
inc dword ptr [rdi+114h]
lea edx, [r12+1]; int
mov rsi, rdi; chess::Board *
mov [rsp+448h+var_438], edx
call _ZN6Engine16evaluatePositionERKN5chess5BoardEi; Engine::evaluatePosition(chess::Board const&,int)
cmp eax, ebp
jge loc_A062
cmp eax, ebx
cmovg ebx, eax
mov [rsp+448h+var_34], 0
cmp byte ptr [r14+0AEh], 0
jz short loc_9F2E
lea rdi, [rsp+448h+var_434]
mov rsi, r14
mov edx, 3Fh ; '?'
call _ZN5chess7movegen10legalmovesILNS_5Color10underlyingE1ELNS0_11MoveGenTypeE0EEEvRNS_8MovelistERKNS_5BoardEi; chess::movegen::legalmoves<(chess::Color::underlying)1,(chess::movegen::MoveGenType)0>(chess::Movelist &,chess::Board const&,int)
jmp short loc_9F40
loc_9F2E:
lea rdi, [rsp+448h+var_434]
mov rsi, r14
mov edx, 3Fh ; '?'
call _ZN5chess7movegen10legalmovesILNS_5Color10underlyingE0ELNS0_11MoveGenTypeE0EEEvRNS_8MovelistERKNS_5BoardEi; chess::movegen::legalmoves<(chess::Color::underlying)0,(chess::movegen::MoveGenType)0>(chess::Movelist &,chess::Board const&,int)
loc_9F40:
movsxd r15, [rsp+448h+var_34]
test r15, r15
jz loc_A043
mov [rsp+448h+var_440], ebp
neg ebp
mov [rsp+448h+var_43C], ebp
shl r15, 2
xor ebp, ebp
loc_9F61:
mov esi, [rsp+rbp+448h+var_434]
mov rdi, r14
call _ZN5chess5Board8makeMoveILb0EEEvNS_4MoveE; chess::Board::makeMove<false>(chess::Move)
mov rdi, r14; this
call _ZNK5chess5Board7inCheckEv; chess::Board::inCheck(void)
mov r13d, eax
mov esi, [rsp+rbp+448h+var_434]
mov rdi, r14
call _ZN5chess5Board10unmakeMoveENS_4MoveE; chess::Board::unmakeMove(chess::Move)
mov eax, [rsp+rbp+448h+var_434]
movzx ecx, ax
cmp ecx, 0BFFFh
ja short loc_9FA4
mov ecx, eax
and ecx, 3Fh
cmp byte ptr [r14+rcx+60h], 0Ch
jz short loc_9FA4
xor ecx, ecx
jmp short loc_9FB2
loc_9FA4:
mov ecx, eax
and ecx, 0C000h
neg cx
setno cl
loc_9FB2:
test cl, cl
jnz short loc_A034
xor r13b, 1
jnz short loc_A034
mov ecx, eax
shr ecx, 6
and ecx, 3Fh
movzx eax, ax
and eax, 3Fh
movzx esi, byte ptr [r14+rcx+60h]
movzx r13d, byte ptr [r14+rax+60h]
mov rdi, r14
call _ZN6Engine13getPieceValueEN5chess5PieceE; Engine::getPieceValue(chess::Piece)
mov r12d, eax
mov rdi, r14
mov esi, r13d
call _ZN6Engine13getPieceValueEN5chess5PieceE; Engine::getPieceValue(chess::Piece)
add eax, 32h ; '2'
cmp r12d, eax
jg short loc_A034
mov esi, [rsp+rbp+448h+var_434]
mov rdi, r14
call _ZN5chess5Board8makeMoveILb0EEEvNS_4MoveE; chess::Board::makeMove<false>(chess::Move)
mov edx, ebx
neg edx; int
mov rdi, r14; this
mov esi, [rsp+448h+var_43C]; int
mov ecx, [rsp+448h+var_438]; int
call _ZN6Engine14extendedSearchEiii; Engine::extendedSearch(int,int,int)
mov r13d, eax
neg r13d
mov esi, [rsp+rbp+448h+var_434]
mov rdi, r14
call _ZN5chess5Board10unmakeMoveENS_4MoveE; chess::Board::unmakeMove(chess::Move)
cmp r13d, [rsp+448h+var_440]
jge short loc_A05C
cmp ebx, r13d
cmovle ebx, r13d
loc_A034:
add rbp, 4
cmp r15, rbp
jnz loc_9F61
jmp short loc_A060
loc_A043:
mov rdi, r14; this
call _ZNK5chess5Board7inCheckEv; chess::Board::inCheck(void)
add r12d, 0FFFE7961h
xor ebx, ebx
test al, al
cmovnz ebx, r12d
jmp short loc_A060
loc_A05C:
mov ebx, [rsp+448h+var_440]
loc_A060:
mov ebp, ebx
loc_A062:
mov eax, ebp
add rsp, 418h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long Engine::extendedSearch(Engine *this, signed int a2, int a3, int a4)
{
unsigned int v6; // ebx
signed int v7; // eax
long long v8; // r15
unsigned long long v9; // rbp
char v10; // r13
unsigned int v11; // eax
char v13; // r13
signed int PieceValue; // r12d
int v15; // r13d
unsigned int v16; // r12d
int v18; // [rsp+8h] [rbp-440h]
int v19; // [rsp+Ch] [rbp-43Ch]
int v20; // [rsp+10h] [rbp-438h]
_DWORD v21[256]; // [rsp+14h] [rbp-434h] BYREF
int v22; // [rsp+414h] [rbp-34h]
v6 = a2;
++*((_DWORD *)this + 69);
v20 = a4 + 1;
v7 = Engine::evaluatePosition(this, this, a4 + 1);
if ( v7 < a3 )
{
if ( v7 > a2 )
v6 = v7;
v22 = 0;
if ( *((_BYTE *)this + 174) )
chess::movegen::legalmoves<(chess::Color::underlying)1,(chess::movegen::MoveGenType)0>((long long)v21, this, 63);
else
chess::movegen::legalmoves<(chess::Color::underlying)0,(chess::movegen::MoveGenType)0>((long long)v21, this, 63);
if ( v22 )
{
v18 = a3;
v19 = -a3;
v8 = 4LL * v22;
v9 = 0LL;
while ( 1 )
{
chess::Board::makeMove<false>((long long)this, v21[v9 / 4]);
v10 = chess::Board::inCheck(this);
chess::Board::unmakeMove(this, (unsigned int)v21[v9 / 4]);
v11 = v21[v9 / 4];
if ( ((unsigned __int16)v11 <= 0xBFFFu && *((_BYTE *)this + (v11 & 0x3F) + 96) != 12
|| __OFSUB__(-(v11 & 0xC000), 1))
&& v10 == 1 )
{
v13 = *((_BYTE *)this + (v11 & 0x3F) + 96);
PieceValue = Engine::getPieceValue((long long)this, *((_BYTE *)this + ((v11 >> 6) & 0x3F) + 96));
if ( PieceValue <= (int)(Engine::getPieceValue((long long)this, v13) + 50) )
{
chess::Board::makeMove<false>((long long)this, v21[v9 / 4]);
v15 = -(int)Engine::extendedSearch(this, v19, -v6, v20);
chess::Board::unmakeMove(this, (unsigned int)v21[v9 / 4]);
if ( v15 >= v18 )
return (unsigned int)v18;
if ( (int)v6 <= v15 )
v6 = v15;
}
}
v9 += 4LL;
if ( v8 == v9 )
return v6;
}
}
v16 = a4 - 99999;
v6 = 0;
if ( (unsigned __int8)chess::Board::inCheck(this) )
return v16;
return v6;
}
return (unsigned int)a3;
}
| extendedSearch:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x418
MOV R12D,ECX
MOV EBP,EDX
MOV EBX,ESI
MOV R14,RDI
INC dword ptr [RDI + 0x114]
LEA EDX,[R12 + 0x1]
MOV RSI,RDI
MOV dword ptr [RSP + 0x10],EDX
CALL 0x0010b692
CMP EAX,EBP
JGE 0x0010a062
CMP EAX,EBX
CMOVG EBX,EAX
MOV dword ptr [RSP + 0x414],0x0
CMP byte ptr [R14 + 0xae],0x0
JZ 0x00109f2e
LEA RDI,[RSP + 0x14]
MOV RSI,R14
MOV EDX,0x3f
CALL 0x00107a5c
JMP 0x00109f40
LAB_00109f2e:
LEA RDI,[RSP + 0x14]
MOV RSI,R14
MOV EDX,0x3f
CALL 0x001073b0
LAB_00109f40:
MOVSXD R15,dword ptr [RSP + 0x414]
TEST R15,R15
JZ 0x0010a043
MOV dword ptr [RSP + 0x8],EBP
NEG EBP
MOV dword ptr [RSP + 0xc],EBP
SHL R15,0x2
XOR EBP,EBP
LAB_00109f61:
MOV ESI,dword ptr [RSP + RBP*0x1 + 0x14]
MOV RDI,R14
CALL 0x00105df6
MOV RDI,R14
CALL 0x0010734a
MOV R13D,EAX
MOV ESI,dword ptr [RSP + RBP*0x1 + 0x14]
MOV RDI,R14
CALL 0x0010a8d6
MOV EAX,dword ptr [RSP + RBP*0x1 + 0x14]
MOVZX ECX,AX
CMP ECX,0xbfff
JA 0x00109fa4
MOV ECX,EAX
AND ECX,0x3f
CMP byte ptr [R14 + RCX*0x1 + 0x60],0xc
JZ 0x00109fa4
XOR ECX,ECX
JMP 0x00109fb2
LAB_00109fa4:
MOV ECX,EAX
AND ECX,0xc000
NEG CX
SETNO CL
LAB_00109fb2:
TEST CL,CL
JNZ 0x0010a034
XOR R13B,0x1
JNZ 0x0010a034
MOV ECX,EAX
SHR ECX,0x6
AND ECX,0x3f
MOVZX EAX,AX
AND EAX,0x3f
MOVZX ESI,byte ptr [R14 + RCX*0x1 + 0x60]
MOVZX R13D,byte ptr [R14 + RAX*0x1 + 0x60]
MOV RDI,R14
CALL 0x00105aa2
MOV R12D,EAX
MOV RDI,R14
MOV ESI,R13D
CALL 0x00105aa2
ADD EAX,0x32
CMP R12D,EAX
JG 0x0010a034
MOV ESI,dword ptr [RSP + RBP*0x1 + 0x14]
MOV RDI,R14
CALL 0x00105df6
MOV EDX,EBX
NEG EDX
MOV RDI,R14
MOV ESI,dword ptr [RSP + 0xc]
MOV ECX,dword ptr [RSP + 0x10]
CALL 0x00109ec6
MOV R13D,EAX
NEG R13D
MOV ESI,dword ptr [RSP + RBP*0x1 + 0x14]
MOV RDI,R14
CALL 0x0010a8d6
CMP R13D,dword ptr [RSP + 0x8]
JGE 0x0010a05c
CMP EBX,R13D
CMOVLE EBX,R13D
LAB_0010a034:
ADD RBP,0x4
CMP R15,RBP
JNZ 0x00109f61
JMP 0x0010a060
LAB_0010a043:
MOV RDI,R14
CALL 0x0010734a
ADD R12D,0xfffe7961
XOR EBX,EBX
TEST AL,AL
CMOVNZ EBX,R12D
JMP 0x0010a060
LAB_0010a05c:
MOV EBX,dword ptr [RSP + 0x8]
LAB_0010a060:
MOV EBP,EBX
LAB_0010a062:
MOV EAX,EBP
ADD RSP,0x418
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* Engine::extendedSearch(int, int, int) */
int __thiscall Engine::extendedSearch(Engine *this,int param_1,int param_2,int param_3)
{
Engine EVar1;
uint uVar2;
bool bVar3;
char cVar4;
int iVar5;
int iVar6;
int iVar7;
long lVar8;
long lVar9;
Movelist local_434 [1024];
int local_34;
*(int *)(this + 0x114) = *(int *)(this + 0x114) + 1;
iVar5 = evaluatePosition(this,(Board *)this,param_3 + 1);
iVar7 = param_2;
if (iVar5 < param_2) {
iVar7 = param_1;
if (param_1 < iVar5) {
iVar7 = iVar5;
}
local_34 = 0;
if (this[0xae] == (Engine)0x0) {
chess::movegen::legalmoves<(chess::Color::underlying)0,(chess::movegen::MoveGenType)0>
(local_434,(Board *)this,0x3f);
}
else {
chess::movegen::legalmoves<(chess::Color::underlying)1,(chess::movegen::MoveGenType)0>
(local_434,(Board *)this,0x3f);
}
lVar9 = (long)local_34;
if (lVar9 == 0) {
cVar4 = chess::Board::inCheck((Board *)this);
iVar7 = 0;
if (cVar4 != '\0') {
iVar7 = param_3 + -99999;
}
}
else {
lVar8 = 0;
do {
chess::Board::makeMove<false>((Board *)this,*(int4 *)(local_434 + lVar8));
cVar4 = chess::Board::inCheck((Board *)this);
chess::Board::unmakeMove((Board *)this,*(int4 *)(local_434 + lVar8));
uVar2 = *(uint *)(local_434 + lVar8);
if (((uVar2 & 0xffff) < 0xc000) && (this[(ulong)(uVar2 & 0x3f) + 0x60] != (Engine)0xc)) {
bVar3 = false;
}
else {
bVar3 = true;
}
if ((!bVar3) && (cVar4 == '\x01')) {
EVar1 = this[(ulong)(uVar2 & 0x3f) + 0x60];
iVar5 = getPieceValue(this,this[(ulong)(uVar2 >> 6 & 0x3f) + 0x60]);
iVar6 = getPieceValue(this,EVar1);
if (iVar5 <= iVar6 + 0x32) {
chess::Board::makeMove<false>((Board *)this,*(int4 *)(local_434 + lVar8));
iVar5 = extendedSearch(this,-param_2,-iVar7,param_3 + 1);
iVar6 = -iVar5;
chess::Board::unmakeMove((Board *)this,*(int4 *)(local_434 + lVar8));
if (param_2 <= iVar6) {
return param_2;
}
if (iVar7 == iVar6 || SBORROW4(iVar7,iVar6) != iVar7 + iVar5 < 0) {
iVar7 = iVar6;
}
}
}
lVar8 = lVar8 + 4;
} while (lVar9 * 4 != lVar8);
}
}
return iVar7;
}
| |
48,324 | retrieve_auto_increment | eloqsql/storage/myisam/mi_key.c | ulonglong retrieve_auto_increment(MI_INFO *info,const uchar *record)
{
ulonglong value= 0; /* Store unsigned values here */
longlong s_value= 0; /* Store signed values here */
HA_KEYSEG *keyseg= info->s->keyinfo[info->s->base.auto_key-1].seg;
const uchar *key= (uchar*) record + keyseg->start;
switch (keyseg->type) {
case HA_KEYTYPE_INT8:
s_value= (longlong) *(const signed char*) key;
break;
case HA_KEYTYPE_BINARY:
value=(ulonglong) *(uchar*) key;
break;
case HA_KEYTYPE_SHORT_INT:
s_value= (longlong) sint2korr(key);
break;
case HA_KEYTYPE_USHORT_INT:
value=(ulonglong) uint2korr(key);
break;
case HA_KEYTYPE_LONG_INT:
s_value= (longlong) sint4korr(key);
break;
case HA_KEYTYPE_ULONG_INT:
value=(ulonglong) uint4korr(key);
break;
case HA_KEYTYPE_INT24:
s_value= (longlong) sint3korr(key);
break;
case HA_KEYTYPE_UINT24:
value=(ulonglong) uint3korr(key);
break;
case HA_KEYTYPE_FLOAT: /* This shouldn't be used */
{
float f_1;
float4get(f_1,key);
/* Ignore negative values */
value = (f_1 < (float) 0.0) ? 0 : (ulonglong) f_1;
break;
}
case HA_KEYTYPE_DOUBLE: /* This shouldn't be used */
{
double f_1;
float8get(f_1,key);
/* Ignore negative values */
value = (f_1 < 0.0) ? 0 : (ulonglong) f_1;
break;
}
case HA_KEYTYPE_LONGLONG:
s_value= sint8korr(key);
break;
case HA_KEYTYPE_ULONGLONG:
value= uint8korr(key);
break;
default:
DBUG_ASSERT(0);
value=0; /* Error */
break;
}
/*
The following code works because if s_value < 0 then value is 0
and if s_value == 0 then value will contain either s_value or the
correct value.
*/
return (s_value > 0) ? (ulonglong) s_value : value;
} | O3 | c | retrieve_auto_increment:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movq 0x218(%rax), %rcx
movl 0x184(%rax), %eax
decl %eax
imulq $0x70, %rax, %rax
movq 0x28(%rcx,%rax), %rcx
movzbl 0x18(%rcx), %edx
xorl %eax, %eax
addl $-0x2, %edx
cmpl $0xc, %edx
ja 0x96ca6
movl 0x8(%rcx), %ecx
leaq 0x6f12c(%rip), %rdi # 0x105cd4
movslq (%rdi,%rdx,4), %rdx
addq %rdi, %rdx
jmpq *%rdx
movzbl (%rsi,%rcx), %eax
jmp 0x96ca6
movzwl (%rsi,%rcx), %edx
movzbl 0x2(%rsi,%rcx), %eax
shll $0x10, %eax
orq %rdx, %rax
jmp 0x96ca6
movslq (%rsi,%rcx), %rcx
jmp 0x96c9d
movzwl (%rsi,%rcx), %eax
jmp 0x96ca6
movsbq (%rsi,%rcx), %rcx
jmp 0x96c9d
movswq (%rsi,%rcx), %rcx
jmp 0x96c9d
movl (%rsi,%rcx), %eax
jmp 0x96ca6
movq (%rsi,%rcx), %rcx
jmp 0x96c9d
movss (%rsi,%rcx), %xmm0
xorps %xmm1, %xmm1
movaps %xmm0, %xmm2
cmpless %xmm1, %xmm2
andnps %xmm0, %xmm2
cvttss2si %xmm2, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subss 0x613d8(%rip), %xmm2 # 0xf8004
cvttss2si %xmm2, %rax
jmp 0x96c62
movsd (%rsi,%rcx), %xmm0
xorpd %xmm1, %xmm1
movapd %xmm0, %xmm2
cmplesd %xmm1, %xmm2
andnpd %xmm0, %xmm2
cvttsd2si %xmm2, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0x6e3b3(%rip), %xmm2 # 0x105010
cvttsd2si %xmm2, %rax
andq %rdx, %rax
orq %rcx, %rax
jmp 0x96ca6
movzbl 0x2(%rsi,%rcx), %edi
movl %edi, %eax
shll $0x10, %eax
movzbl 0x1(%rsi,%rcx), %edx
shll $0x8, %edx
movzbl (%rsi,%rcx), %ecx
testb %dil, %dil
js 0x96c91
orl %ecx, %eax
orl %edx, %eax
jmp 0x96c9a
movq (%rsi,%rcx), %rax
jmp 0x96ca6
orl %ecx, %edx
addl %edx, %eax
addl $0xff000000, %eax # imm = 0xFF000000
movslq %eax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
cmovgq %rcx, %rax
popq %rbp
retq
| retrieve_auto_increment:
push rbp
mov rbp, rsp
mov rax, [rdi]
mov rcx, [rax+218h]
mov eax, [rax+184h]
dec eax
imul rax, 70h ; 'p'
mov rcx, [rcx+rax+28h]
movzx edx, byte ptr [rcx+18h]
xor eax, eax
add edx, 0FFFFFFFEh; switch 13 cases
cmp edx, 0Ch
ja def_96BAF; jumptable 0000000000096BAF default case, case 7
mov ecx, [rcx+8]
lea rdi, jpt_96BAF
movsxd rdx, ds:(jpt_96BAF - 105CD4h)[rdi+rdx*4]
add rdx, rdi
jmp rdx; switch jump
loc_96BB1:
movzx eax, byte ptr [rsi+rcx]; jumptable 0000000000096BAF case 2
jmp def_96BAF; jumptable 0000000000096BAF default case, case 7
loc_96BBA:
movzx edx, word ptr [rsi+rcx]; jumptable 0000000000096BAF case 13
movzx eax, byte ptr [rsi+rcx+2]
shl eax, 10h
or rax, rdx
jmp def_96BAF; jumptable 0000000000096BAF default case, case 7
loc_96BCE:
movsxd rcx, dword ptr [rsi+rcx]; jumptable 0000000000096BAF case 4
jmp loc_96C9D
loc_96BD7:
movzx eax, word ptr [rsi+rcx]; jumptable 0000000000096BAF case 8
jmp def_96BAF; jumptable 0000000000096BAF default case, case 7
loc_96BE0:
movsx rcx, byte ptr [rsi+rcx]; jumptable 0000000000096BAF case 14
jmp loc_96C9D
loc_96BEA:
movsx rcx, word ptr [rsi+rcx]; jumptable 0000000000096BAF case 3
jmp loc_96C9D
loc_96BF4:
mov eax, [rsi+rcx]; jumptable 0000000000096BAF case 9
jmp def_96BAF; jumptable 0000000000096BAF default case, case 7
loc_96BFC:
mov rcx, [rsi+rcx]; jumptable 0000000000096BAF case 10
jmp loc_96C9D
loc_96C05:
movss xmm0, dword ptr [rsi+rcx]; jumptable 0000000000096BAF case 5
xorps xmm1, xmm1
movaps xmm2, xmm0
cmpless xmm2, xmm1
andnps xmm2, xmm0
cvttss2si rcx, xmm2
mov rdx, rcx
sar rdx, 3Fh
subss xmm2, cs:dword_F8004
cvttss2si rax, xmm2
jmp short loc_96C62
loc_96C33:
movsd xmm0, qword ptr [rsi+rcx]; jumptable 0000000000096BAF case 6
xorpd xmm1, xmm1
movapd xmm2, xmm0
cmplesd xmm2, xmm1
andnpd xmm2, xmm0
cvttsd2si rcx, xmm2
mov rdx, rcx
sar rdx, 3Fh
subsd xmm2, cs:qword_105010
cvttsd2si rax, xmm2
loc_96C62:
and rax, rdx
or rax, rcx
jmp short def_96BAF; jumptable 0000000000096BAF default case, case 7
loc_96C6A:
movzx edi, byte ptr [rsi+rcx+2]; jumptable 0000000000096BAF case 12
mov eax, edi
shl eax, 10h
movzx edx, byte ptr [rsi+rcx+1]
shl edx, 8
movzx ecx, byte ptr [rsi+rcx]
test dil, dil
js short loc_96C91
or eax, ecx
or eax, edx
jmp short loc_96C9A
loc_96C8B:
mov rax, [rsi+rcx]; jumptable 0000000000096BAF case 11
jmp short def_96BAF; jumptable 0000000000096BAF default case, case 7
loc_96C91:
or edx, ecx
add eax, edx
add eax, 0FF000000h
loc_96C9A:
movsxd rcx, eax
loc_96C9D:
xor eax, eax
test rcx, rcx
cmovg rax, rcx
def_96BAF:
pop rbp; jumptable 0000000000096BAF default case, case 7
retn
| unsigned long long retrieve_auto_increment(long long a1, long long a2)
{
long long v2; // rcx
int v3; // edx
unsigned long long result; // rax
long long v5; // rcx
long long v6; // rcx
char v8; // di
int v9; // eax
int v10; // edx
int v11; // ecx
int v12; // eax
v2 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)a1 + 536LL)
+ 112LL * (unsigned int)(*(_DWORD *)(*(_QWORD *)a1 + 388LL) - 1)
+ 40);
v3 = *(unsigned __int8 *)(v2 + 24);
result = 0LL;
v5 = *(unsigned int *)(v2 + 8);
switch ( v3 )
{
case 2:
return *(unsigned __int8 *)(a2 + v5);
case 3:
v6 = *(__int16 *)(a2 + v5);
goto LABEL_18;
case 4:
v6 = *(int *)(a2 + v5);
goto LABEL_18;
case 5:
return (unsigned int)(int)_mm_andnot_ps(
_mm_cmple_ss((__m128)*(unsigned int *)(a2 + v5), (__m128)0LL),
(__m128)*(unsigned int *)(a2 + v5)).m128_f32[0];
case 6:
return (unsigned int)(int)COERCE_DOUBLE(~(unsigned long long)*(_OWORD *)&_mm_cmple_sd(
(__m128d)*(unsigned long long *)(a2 + v5),
(__m128d)0LL) & *(_QWORD *)(a2 + v5));
case 8:
return *(unsigned __int16 *)(a2 + v5);
case 9:
return *(unsigned int *)(a2 + v5);
case 10:
v6 = *(_QWORD *)(a2 + v5);
goto LABEL_18;
case 11:
return *(_QWORD *)(a2 + v5);
case 12:
v8 = *(_BYTE *)(a2 + v5 + 2);
v9 = (unsigned __int8)v8 << 16;
v10 = *(unsigned __int8 *)(a2 + v5 + 1) << 8;
v11 = *(unsigned __int8 *)(a2 + v5);
if ( v8 < 0 )
v12 = (v11 | v10) + v9 - 0x1000000;
else
v12 = v10 | v11 | v9;
v6 = v12;
goto LABEL_18;
case 13:
return *(unsigned __int16 *)(a2 + v5) | (unsigned long long)(*(unsigned __int8 *)(a2 + v5 + 2) << 16);
case 14:
v6 = *(char *)(a2 + v5);
LABEL_18:
result = 0LL;
if ( v6 > 0 )
result = v6;
break;
default:
return result;
}
return result;
}
| retrieve_auto_increment:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RDI]
MOV RCX,qword ptr [RAX + 0x218]
MOV EAX,dword ptr [RAX + 0x184]
DEC EAX
IMUL RAX,RAX,0x70
MOV RCX,qword ptr [RCX + RAX*0x1 + 0x28]
MOVZX EDX,byte ptr [RCX + 0x18]
XOR EAX,EAX
ADD EDX,-0x2
CMP EDX,0xc
JA 0x00196ca6
MOV ECX,dword ptr [RCX + 0x8]
LEA RDI,[0x205cd4]
MOVSXD RDX,dword ptr [RDI + RDX*0x4]
ADD RDX,RDI
switchD:
JMP RDX
caseD_2:
MOVZX EAX,byte ptr [RSI + RCX*0x1]
JMP 0x00196ca6
caseD_d:
MOVZX EDX,word ptr [RSI + RCX*0x1]
MOVZX EAX,byte ptr [RSI + RCX*0x1 + 0x2]
SHL EAX,0x10
OR RAX,RDX
JMP 0x00196ca6
caseD_4:
MOVSXD RCX,dword ptr [RSI + RCX*0x1]
JMP 0x00196c9d
caseD_8:
MOVZX EAX,word ptr [RSI + RCX*0x1]
JMP 0x00196ca6
caseD_e:
MOVSX RCX,byte ptr [RSI + RCX*0x1]
JMP 0x00196c9d
caseD_3:
MOVSX RCX,word ptr [RSI + RCX*0x1]
JMP 0x00196c9d
caseD_9:
MOV EAX,dword ptr [RSI + RCX*0x1]
JMP 0x00196ca6
caseD_a:
MOV RCX,qword ptr [RSI + RCX*0x1]
JMP 0x00196c9d
caseD_5:
MOVSS XMM0,dword ptr [RSI + RCX*0x1]
XORPS XMM1,XMM1
MOVAPS XMM2,XMM0
CMPLESS XMM2,XMM1
ANDNPS XMM2,XMM0
CVTTSS2SI RCX,XMM2
MOV RDX,RCX
SAR RDX,0x3f
SUBSS XMM2,dword ptr [0x001f8004]
CVTTSS2SI RAX,XMM2
JMP 0x00196c62
caseD_6:
MOVSD XMM0,qword ptr [RSI + RCX*0x1]
XORPD XMM1,XMM1
MOVAPD XMM2,XMM0
CMPLESD XMM2,XMM1
ANDNPD XMM2,XMM0
CVTTSD2SI RCX,XMM2
MOV RDX,RCX
SAR RDX,0x3f
SUBSD XMM2,qword ptr [0x00205010]
CVTTSD2SI RAX,XMM2
LAB_00196c62:
AND RAX,RDX
OR RAX,RCX
JMP 0x00196ca6
caseD_c:
MOVZX EDI,byte ptr [RSI + RCX*0x1 + 0x2]
MOV EAX,EDI
SHL EAX,0x10
MOVZX EDX,byte ptr [RSI + RCX*0x1 + 0x1]
SHL EDX,0x8
MOVZX ECX,byte ptr [RSI + RCX*0x1]
TEST DIL,DIL
JS 0x00196c91
OR EAX,ECX
OR EAX,EDX
JMP 0x00196c9a
caseD_b:
MOV RAX,qword ptr [RSI + RCX*0x1]
JMP 0x00196ca6
LAB_00196c91:
OR EDX,ECX
ADD EAX,EDX
ADD EAX,0xff000000
LAB_00196c9a:
MOVSXD RCX,EAX
LAB_00196c9d:
XOR EAX,EAX
TEST RCX,RCX
CMOVG RAX,RCX
caseD_7:
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
ulong retrieve_auto_increment(long *param_1,long param_2)
{
byte bVar1;
byte bVar2;
long lVar3;
uint uVar4;
ulong uVar5;
ulong uVar6;
float fVar7;
double dVar8;
lVar3 = *(long *)(*(long *)(*param_1 + 0x218) + 0x28 +
(ulong)(*(int *)(*param_1 + 0x184) - 1) * 0x70);
uVar4 = (uint)*(byte *)(lVar3 + 0x18);
if (0xc < uVar4 - 2) {
return 0;
}
uVar6 = (ulong)*(uint *)(lVar3 + 8);
uVar5 = 0;
switch(uVar4) {
case 2:
uVar5 = (ulong)*(byte *)(param_2 + uVar6);
break;
case 3:
uVar6 = (ulong)*(short *)(param_2 + uVar6);
goto LAB_00196c9d;
case 4:
uVar6 = (ulong)*(int *)(param_2 + uVar6);
goto LAB_00196c9d;
case 5:
fVar7 = (float)(~-(uint)(*(float *)(param_2 + uVar6) <= 0.0) & (uint)*(float *)(param_2 + uVar6)
);
uVar5 = (ulong)fVar7;
uVar6 = (ulong)(fVar7 - _DAT_001f8004);
goto LAB_00196c62;
case 6:
dVar8 = (double)(~-(ulong)(*(double *)(param_2 + uVar6) <= 0.0) &
(ulong)*(double *)(param_2 + uVar6));
uVar5 = (ulong)dVar8;
uVar6 = (ulong)(dVar8 - _DAT_00205010);
LAB_00196c62:
uVar5 = uVar6 & (long)uVar5 >> 0x3f | uVar5;
break;
case 8:
uVar5 = (ulong)*(ushort *)(param_2 + uVar6);
break;
case 9:
uVar5 = (ulong)*(uint *)(param_2 + uVar6);
break;
case 10:
uVar6 = *(ulong *)(param_2 + uVar6);
goto LAB_00196c9d;
case 0xb:
uVar5 = *(ulong *)(param_2 + uVar6);
break;
case 0xc:
bVar1 = *(byte *)(param_2 + 2 + uVar6);
uVar4 = (uint)bVar1 * 0x10000;
bVar2 = *(byte *)(param_2 + 1 + uVar6);
if ((char)bVar1 < '\0') {
uVar4 = (uVar4 + CONCAT11(bVar2,*(byte *)(param_2 + uVar6))) - 0x1000000;
}
else {
uVar4 = uVar4 | *(byte *)(param_2 + uVar6) | (uint)bVar2 << 8;
}
uVar6 = (ulong)(int)uVar4;
goto LAB_00196c9d;
case 0xd:
uVar5 = (ulong)CONCAT12(*(int1 *)(param_2 + 2 + uVar6),*(int2 *)(param_2 + uVar6));
break;
case 0xe:
uVar6 = (ulong)*(char *)(param_2 + uVar6);
LAB_00196c9d:
uVar5 = 0;
if (0 < (long)uVar6) {
uVar5 = uVar6;
}
}
return uVar5;
}
| |
48,325 | httplib::detail::encode_url(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | hkr04[P]cpp-mcp/common/httplib.h | inline std::string encode_url(const std::string &s) {
std::string result;
result.reserve(s.size());
for (size_t i = 0; s[i]; i++) {
switch (s[i]) {
case ' ': result += "%20"; break;
case '+': result += "%2B"; break;
case '\r': result += "%0D"; break;
case '\n': result += "%0A"; break;
case '\'': result += "%27"; break;
case ',': result += "%2C"; break;
// case ':': result += "%3A"; break; // ok? probably...
case ';': result += "%3B"; break;
default:
auto c = static_cast<uint8_t>(s[i]);
if (c >= 0x80) {
result += '%';
char hex[4];
auto len = snprintf(hex, sizeof(hex) - 1, "%02X", c);
assert(len == 2);
result.append(hex, static_cast<size_t>(len));
} else {
result += s[i];
}
break;
}
}
return result;
} | O1 | c | httplib::detail::encode_url(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 $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x8(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
callq 0x8820
leaq 0x26cdc(%rip), %r13 # 0x448a8
leaq 0x26ce1(%rip), %r12 # 0x448b4
xorl %r15d, %r15d
movq (%r14), %rax
movzbl (%rax,%r15), %ebp
cmpl $0x26, %ebp
jle 0x1dbf7
cmpl $0x2b, %ebp
jg 0x1dc0f
cmpl $0x27, %ebp
je 0x1dc39
movq %r13, %rsi
cmpl $0x2b, %ebp
je 0x1dc45
jmp 0x1dc56
cmpl $0xc, %ebp
jle 0x1dc22
cmpl $0xd, %ebp
je 0x1dc30
cmpl $0x20, %ebp
jne 0x1dc56
leaq 0x26c97(%rip), %rsi # 0x448a4
jmp 0x1dc45
cmpl $0x2c, %ebp
je 0x1dc3e
cmpl $0x3b, %ebp
jne 0x1dc56
leaq 0x26c9c(%rip), %rsi # 0x448bc
jmp 0x1dc45
cmpl $0xa, %ebp
jne 0x1dc52
leaq 0x26c82(%rip), %rsi # 0x448b0
jmp 0x1dc45
leaq 0x26c75(%rip), %rsi # 0x448ac
jmp 0x1dc45
movq %r12, %rsi
jmp 0x1dc45
leaq 0x26c73(%rip), %rsi # 0x448b8
movq %rbx, %rdi
callq 0x8a20
incq %r15
jmp 0x1dbd6
testl %ebp, %ebp
je 0x1dcb0
testb %bpl, %bpl
js 0x1dc69
movsbl %bpl, %esi
movq %rbx, %rdi
callq 0x84b0
jmp 0x1dc4d
movq %rbx, %rdi
movl $0x25, %esi
callq 0x84b0
movq %r12, %r13
movl $0x3, %esi
leaq 0x14(%rsp), %r12
movq %r12, %rdi
leaq 0x26c33(%rip), %rdx # 0x448c0
movl %ebp, %ecx
xorl %eax, %eax
callq 0x8840
movslq %eax, %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8090
movq %r13, %r12
leaq 0x26bfa(%rip), %r13 # 0x448a8
jmp 0x1dc4d
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1dcc8
jmp 0x1dcc8
jmp 0x1dcc8
movq %rax, %r14
movq (%rbx), %rdi
movq 0x8(%rsp), %rax
cmpq %rax, %rdi
je 0x1dce3
movq (%rax), %rsi
incq %rsi
callq 0x8580
movq %r14, %rdi
callq 0x8960
| _ZN7httplib6detail10encode_urlERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r14, rsi
mov rbx, rdi
lea rax, [rdi+10h]
mov [rsp+48h+var_40], rax
mov [rdi], rax
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
mov rsi, [rsi+8]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
lea r13, a2b; "%2B"
lea r12, a27; "%27"
xor r15d, r15d
loc_1DBD6:
mov rax, [r14]
movzx ebp, byte ptr [rax+r15]
cmp ebp, 26h ; '&'
jle short loc_1DBF7
cmp ebp, 2Bh ; '+'
jg short loc_1DC0F
cmp ebp, 27h ; '''
jz short loc_1DC39
mov rsi, r13
cmp ebp, 2Bh ; '+'
jz short loc_1DC45
jmp short loc_1DC56
loc_1DBF7:
cmp ebp, 0Ch
jle short loc_1DC22
cmp ebp, 0Dh
jz short loc_1DC30
cmp ebp, 20h ; ' '
jnz short loc_1DC56
lea rsi, a20_0; "%20"
jmp short loc_1DC45
loc_1DC0F:
cmp ebp, 2Ch ; ','
jz short loc_1DC3E
cmp ebp, 3Bh ; ';'
jnz short loc_1DC56
lea rsi, a3b; "%3B"
jmp short loc_1DC45
loc_1DC22:
cmp ebp, 0Ah
jnz short loc_1DC52
lea rsi, a0a; "%0A"
jmp short loc_1DC45
loc_1DC30:
lea rsi, a0d; "%0D"
jmp short loc_1DC45
loc_1DC39:
mov rsi, r12
jmp short loc_1DC45
loc_1DC3E:
lea rsi, a2c; "%2C"
loc_1DC45:
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
loc_1DC4D:
inc r15
jmp short loc_1DBD6
loc_1DC52:
test ebp, ebp
jz short loc_1DCB0
loc_1DC56:
test bpl, bpl
js short loc_1DC69
movsx esi, bpl
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
jmp short loc_1DC4D
loc_1DC69:
mov rdi, rbx
mov esi, 25h ; '%'
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
mov r13, r12
mov esi, 3
lea r12, [rsp+48h+var_34]
mov rdi, r12
lea rdx, a02x; "%02X"
mov ecx, ebp
xor eax, eax
call _snprintf
movsxd rdx, eax
mov rdi, rbx
mov rsi, r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKcm; std::string::append(char const*,ulong)
mov r12, r13
lea r13, a2b; "%2B"
jmp short loc_1DC4D
loc_1DCB0:
mov rax, rbx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_1DCC8
jmp short loc_1DCC8
jmp short $+2
loc_1DCC8:
mov r14, rax
mov rdi, [rbx]; void *
mov rax, [rsp+arg_0]
cmp rdi, rax
jz short loc_1DCE3
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1DCE3:
mov rdi, r14
call __Unwind_Resume
| long long httplib::detail::encode_url(long long a1, _QWORD *a2)
{
long long i; // r15
unsigned int v4; // ebp
const char *v5; // rsi
_BYTE v7[52]; // [rsp+14h] [rbp-34h] BYREF
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
std::string::reserve(a1, a2[1]);
for ( i = 0LL; ; ++i )
{
v4 = *(unsigned __int8 *)(*a2 + i);
if ( v4 <= 0x26 )
break;
if ( *(unsigned __int8 *)(*a2 + i) > 0x2Bu )
{
if ( v4 == 44 )
{
v5 = "%2C";
}
else
{
if ( v4 != 59 )
goto LABEL_22;
v5 = "%3B";
}
LABEL_19:
std::string::append(a1, v5);
continue;
}
if ( v4 == 39 )
{
v5 = "%27";
goto LABEL_19;
}
v5 = "%2B";
if ( v4 == 43 )
goto LABEL_19;
LABEL_22:
if ( (v4 & 0x80u) != 0 )
{
std::string::push_back(a1, 37LL);
snprintf(v7, 3LL, "%02X", v4);
std::string::append(a1);
}
else
{
std::string::push_back(a1, (unsigned int)(char)v4);
}
}
if ( *(unsigned __int8 *)(*a2 + i) > 0xCu )
{
if ( v4 == 13 )
{
v5 = "%0D";
}
else
{
if ( v4 != 32 )
goto LABEL_22;
v5 = "%20";
}
goto LABEL_19;
}
if ( v4 == 10 )
{
v5 = "%0A";
goto LABEL_19;
}
if ( *(_BYTE *)(*a2 + i) )
goto LABEL_22;
return a1;
}
| encode_url:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R14,RSI
MOV RBX,RDI
LEA RAX,[RDI + 0x10]
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RDI],RAX
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
MOV RSI,qword ptr [RSI + 0x8]
LAB_0011dbc0:
CALL 0x00108820
LEA R13,[0x1448a8]
LEA R12,[0x1448b4]
XOR R15D,R15D
LAB_0011dbd6:
MOV RAX,qword ptr [R14]
MOVZX EBP,byte ptr [RAX + R15*0x1]
CMP EBP,0x26
JLE 0x0011dbf7
CMP EBP,0x2b
JG 0x0011dc0f
CMP EBP,0x27
JZ 0x0011dc39
MOV RSI,R13
CMP EBP,0x2b
JZ 0x0011dc45
JMP 0x0011dc56
LAB_0011dbf7:
CMP EBP,0xc
JLE 0x0011dc22
CMP EBP,0xd
JZ 0x0011dc30
CMP EBP,0x20
JNZ 0x0011dc56
LEA RSI,[0x1448a4]
JMP 0x0011dc45
LAB_0011dc0f:
CMP EBP,0x2c
JZ 0x0011dc3e
CMP EBP,0x3b
JNZ 0x0011dc56
LEA RSI,[0x1448bc]
JMP 0x0011dc45
LAB_0011dc22:
CMP EBP,0xa
JNZ 0x0011dc52
LEA RSI,[0x1448b0]
JMP 0x0011dc45
LAB_0011dc30:
LEA RSI,[0x1448ac]
JMP 0x0011dc45
LAB_0011dc39:
MOV RSI,R12
JMP 0x0011dc45
LAB_0011dc3e:
LEA RSI,[0x1448b8]
LAB_0011dc45:
MOV RDI,RBX
CALL 0x00108a20
LAB_0011dc4d:
INC R15
JMP 0x0011dbd6
LAB_0011dc52:
TEST EBP,EBP
JZ 0x0011dcb0
LAB_0011dc56:
TEST BPL,BPL
JS 0x0011dc69
LAB_0011dc5b:
MOVSX ESI,BPL
MOV RDI,RBX
CALL 0x001084b0
JMP 0x0011dc4d
LAB_0011dc69:
MOV RDI,RBX
MOV ESI,0x25
CALL 0x001084b0
MOV R13,R12
MOV ESI,0x3
LEA R12,[RSP + 0x14]
MOV RDI,R12
LEA RDX,[0x1448c0]
MOV ECX,EBP
XOR EAX,EAX
CALL 0x00108840
MOVSXD RDX,EAX
LAB_0011dc99:
MOV RDI,RBX
MOV RSI,R12
CALL 0x00108090
LAB_0011dca4:
MOV R12,R13
LEA R13,[0x1448a8]
JMP 0x0011dc4d
LAB_0011dcb0:
MOV RAX,RBX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* httplib::detail::encode_url(std::__cxx11::string const&) */
detail * __thiscall httplib::detail::encode_url(detail *this,string *param_1)
{
byte bVar1;
uint uVar2;
long lVar3;
char local_34 [4];
*(detail **)this = this + 0x10;
*(int8 *)(this + 8) = 0;
this[0x10] = (detail)0x0;
/* try { // try from 0011dbc0 to 0011dbc4 has its CatchHandler @ 0011dcc2 */
std::__cxx11::string::reserve((ulong)this);
lVar3 = 0;
do {
bVar1 = *(byte *)(*(long *)param_1 + lVar3);
uVar2 = (uint)bVar1;
if (bVar1 < 0x27) {
if (bVar1 < 0xd) {
if (uVar2 != 10) {
if (uVar2 == 0) {
return this;
}
goto LAB_0011dc56;
}
}
else if ((bVar1 != 0xd) && (bVar1 != 0x20)) goto LAB_0011dc56;
LAB_0011dc45:
/* try { // try from 0011dc45 to 0011dc4c has its CatchHandler @ 0011dcc8 */
std::__cxx11::string::append((char *)this);
}
else {
if (0x2b < bVar1) {
if ((uVar2 != 0x2c) && (uVar2 != 0x3b)) goto LAB_0011dc56;
goto LAB_0011dc45;
}
if ((uVar2 == 0x27) || (uVar2 == 0x2b)) goto LAB_0011dc45;
LAB_0011dc56:
if ((char)bVar1 < '\0') {
std::__cxx11::string::push_back((char)this);
snprintf(local_34,3,"%02X",(ulong)uVar2);
/* try { // try from 0011dc99 to 0011dca3 has its CatchHandler @ 0011dcc4 */
std::__cxx11::string::append((char *)this,(ulong)local_34);
}
else {
/* try { // try from 0011dc5b to 0011dc75 has its CatchHandler @ 0011dcc6 */
std::__cxx11::string::push_back((char)this);
}
}
lVar3 = lVar3 + 1;
} while( true );
}
| |
48,326 | httplib::detail::encode_url(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | hkr04[P]cpp-mcp/common/httplib.h | inline std::string encode_url(const std::string &s) {
std::string result;
result.reserve(s.size());
for (size_t i = 0; s[i]; i++) {
switch (s[i]) {
case ' ': result += "%20"; break;
case '+': result += "%2B"; break;
case '\r': result += "%0D"; break;
case '\n': result += "%0A"; break;
case '\'': result += "%27"; break;
case ',': result += "%2C"; break;
// case ':': result += "%3A"; break; // ok? probably...
case ';': result += "%3B"; break;
default:
auto c = static_cast<uint8_t>(s[i]);
if (c >= 0x80) {
result += '%';
char hex[4];
auto len = snprintf(hex, sizeof(hex) - 1, "%02X", c);
assert(len == 2);
result.append(hex, static_cast<size_t>(len));
} else {
result += s[i];
}
break;
}
}
return result;
} | O2 | c | httplib::detail::encode_url(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
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
callq 0x8880
leaq 0x21e5f(%rip), %r15 # 0x3a860
leaq 0x21e6c(%rip), %r12 # 0x3a874
xorl %r13d, %r13d
movq (%r14), %rax
movzbl (%rax,%r13), %ebp
cmpl $0xa, %ebp
je 0x18a66
cmpl $0xd, %ebp
je 0x18a7d
cmpl $0x20, %ebp
je 0x18a74
cmpl $0x27, %ebp
je 0x18a54
movq %r15, %rsi
cmpl $0x2b, %ebp
je 0x18a84
cmpl $0x2c, %ebp
je 0x18a5d
cmpl $0x3b, %ebp
je 0x18a6f
testl %ebp, %ebp
je 0x18ad7
testb %bpl, %bpl
js 0x18a94
movsbl %bpl, %esi
movq %rbx, %rdi
callq 0x8510
jmp 0x18a8c
leaq 0x21e11(%rip), %rsi # 0x3a86c
jmp 0x18a84
leaq 0x21e0c(%rip), %rsi # 0x3a870
jmp 0x18a84
leaq 0x21dfb(%rip), %rsi # 0x3a868
jmp 0x18a84
movq %r12, %rsi
jmp 0x18a84
leaq 0x21de1(%rip), %rsi # 0x3a85c
jmp 0x18a84
leaq 0x21de0(%rip), %rsi # 0x3a864
movq %rbx, %rdi
callq 0x8a60
incq %r13
jmp 0x18a0b
movq %rbx, %rdi
pushq $0x25
popq %rsi
callq 0x8510
movq %r12, %r15
leaq 0x4(%rsp), %r12
movq %r12, %rdi
pushq $0x3
popq %rsi
leaq 0x21dc4(%rip), %rdx # 0x3a878
movl %ebp, %ecx
xorl %eax, %eax
callq 0x88b0
movslq %eax, %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8090
movq %r15, %r12
leaq 0x21d8b(%rip), %r15 # 0x3a860
jmp 0x18a8c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x18aef
jmp 0x18aef
jmp 0x18aef
movq %rax, %r14
movq %rbx, %rdi
callq 0x8b18
movq %r14, %rdi
callq 0x89c0
| _ZN7httplib6detail10encode_urlERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
lea rax, [rdi+10h]
mov [rdi], rax
and qword ptr [rdi+8], 0
mov r14, rsi
mov byte ptr [rdi+10h], 0
mov rsi, [rsi+8]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
lea r15, a2b; "%2B"
lea r12, a3b; "%3B"
xor r13d, r13d
loc_18A0B:
mov rax, [r14]
movzx ebp, byte ptr [rax+r13]
cmp ebp, 0Ah
jz short loc_18A66
cmp ebp, 0Dh
jz short loc_18A7D
cmp ebp, 20h ; ' '
jz short loc_18A74
cmp ebp, 27h ; '''
jz short loc_18A54
mov rsi, r15
cmp ebp, 2Bh ; '+'
jz short loc_18A84
cmp ebp, 2Ch ; ','
jz short loc_18A5D
cmp ebp, 3Bh ; ';'
jz short loc_18A6F
test ebp, ebp
jz loc_18AD7
test bpl, bpl
js short loc_18A94
movsx esi, bpl
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
jmp short loc_18A8C
loc_18A54:
lea rsi, a27; "%27"
jmp short loc_18A84
loc_18A5D:
lea rsi, a2c; "%2C"
jmp short loc_18A84
loc_18A66:
lea rsi, a0a; "%0A"
jmp short loc_18A84
loc_18A6F:
mov rsi, r12
jmp short loc_18A84
loc_18A74:
lea rsi, a20_0; "%20"
jmp short loc_18A84
loc_18A7D:
lea rsi, a0d; "%0D"
loc_18A84:
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
loc_18A8C:
inc r13
jmp loc_18A0B
loc_18A94:
mov rdi, rbx
push 25h ; '%'
pop rsi
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
mov r15, r12
lea r12, [rsp+38h+var_34]
mov rdi, r12
push 3
pop rsi
lea rdx, a02x; "%02X"
mov ecx, ebp
xor eax, eax
call _snprintf
movsxd rdx, eax
mov rdi, rbx
mov rsi, r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKcm; std::string::append(char const*,ulong)
mov r12, r15
lea r15, a2b; "%2B"
jmp short loc_18A8C
loc_18AD7:
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_18AEF
jmp short loc_18AEF
jmp short $+2
loc_18AEF:
mov r14, rax
mov rdi, rbx; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r14
call __Unwind_Resume
| long long httplib::detail::encode_url(long long a1, _QWORD *a2)
{
long long v2; // rax
long long i; // r13
int v5; // ebp
const char *v6; // rsi
_DWORD v8[13]; // [rsp+0h] [rbp-34h] BYREF
v8[0] = HIDWORD(v2);
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
std::string::reserve(a1, a2[1]);
for ( i = 0LL; ; ++i )
{
v5 = *(unsigned __int8 *)(*a2 + i);
switch ( v5 )
{
case 10:
v6 = "%0A";
goto LABEL_18;
case 13:
v6 = "%0D";
goto LABEL_18;
case 32:
v6 = "%20";
goto LABEL_18;
case 39:
v6 = "%27";
LABEL_18:
std::string::append(a1, v6);
continue;
}
v6 = "%2B";
switch ( v5 )
{
case '+':
goto LABEL_18;
case ',':
v6 = "%2C";
goto LABEL_18;
case ';':
v6 = "%3B";
goto LABEL_18;
}
if ( !*(_BYTE *)(*a2 + i) )
break;
if ( (v5 & 0x80u) != 0 )
{
std::string::push_back(a1, 37LL);
snprintf(v8, 3LL, "%02X", v5);
std::string::append(a1);
}
else
{
std::string::push_back(a1, (unsigned int)(char)v5);
}
}
return a1;
}
| encode_url:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI],RAX
AND qword ptr [RDI + 0x8],0x0
MOV R14,RSI
MOV byte ptr [RDI + 0x10],0x0
MOV RSI,qword ptr [RSI + 0x8]
LAB_001189f5:
CALL 0x00108880
LEA R15,[0x13a860]
LEA R12,[0x13a874]
XOR R13D,R13D
LAB_00118a0b:
MOV RAX,qword ptr [R14]
MOVZX EBP,byte ptr [RAX + R13*0x1]
CMP EBP,0xa
JZ 0x00118a66
CMP EBP,0xd
JZ 0x00118a7d
CMP EBP,0x20
JZ 0x00118a74
CMP EBP,0x27
JZ 0x00118a54
MOV RSI,R15
CMP EBP,0x2b
JZ 0x00118a84
CMP EBP,0x2c
JZ 0x00118a5d
CMP EBP,0x3b
JZ 0x00118a6f
TEST EBP,EBP
JZ 0x00118ad7
TEST BPL,BPL
JS 0x00118a94
LAB_00118a46:
MOVSX ESI,BPL
MOV RDI,RBX
CALL 0x00108510
JMP 0x00118a8c
LAB_00118a54:
LEA RSI,[0x13a86c]
JMP 0x00118a84
LAB_00118a5d:
LEA RSI,[0x13a870]
JMP 0x00118a84
LAB_00118a66:
LEA RSI,[0x13a868]
JMP 0x00118a84
LAB_00118a6f:
MOV RSI,R12
JMP 0x00118a84
LAB_00118a74:
LEA RSI,[0x13a85c]
JMP 0x00118a84
LAB_00118a7d:
LEA RSI,[0x13a864]
LAB_00118a84:
MOV RDI,RBX
CALL 0x00108a60
LAB_00118a8c:
INC R13
JMP 0x00118a0b
LAB_00118a94:
MOV RDI,RBX
PUSH 0x25
POP RSI
CALL 0x00108510
MOV R15,R12
LEA R12,[RSP + 0x4]
MOV RDI,R12
PUSH 0x3
POP RSI
LEA RDX,[0x13a878]
MOV ECX,EBP
XOR EAX,EAX
CALL 0x001088b0
MOVSXD RDX,EAX
LAB_00118ac0:
MOV RDI,RBX
MOV RSI,R12
CALL 0x00108090
LAB_00118acb:
MOV R12,R15
LEA R15,[0x13a860]
JMP 0x00118a8c
LAB_00118ad7:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* httplib::detail::encode_url(std::__cxx11::string const&) */
detail * __thiscall httplib::detail::encode_url(detail *this,string *param_1)
{
byte bVar1;
uint uVar2;
long lVar3;
char local_34 [4];
*(detail **)this = this + 0x10;
*(int8 *)(this + 8) = 0;
this[0x10] = (detail)0x0;
/* try { // try from 001189f5 to 001189f9 has its CatchHandler @ 00118ae9 */
std::__cxx11::string::reserve((ulong)this);
lVar3 = 0;
do {
bVar1 = *(byte *)(*(long *)param_1 + lVar3);
if ((((bVar1 == 10) || (bVar1 == 0xd)) || (bVar1 == 0x20)) ||
(((bVar1 == 0x27 || (bVar1 == 0x2b)) ||
((bVar1 == 0x2c || (uVar2 = (uint)bVar1, uVar2 == 0x3b)))))) {
/* try { // try from 00118a84 to 00118a8b has its CatchHandler @ 00118aef */
std::__cxx11::string::append((char *)this);
}
else {
if (uVar2 == 0) {
return this;
}
if ((char)bVar1 < '\0') {
/* try { // try from 00118a94 to 00118a9e has its CatchHandler @ 00118aed */
std::__cxx11::string::push_back((char)this);
snprintf(local_34,3,"%02X",(ulong)uVar2);
/* try { // try from 00118ac0 to 00118aca has its CatchHandler @ 00118aeb */
std::__cxx11::string::append((char *)this,(ulong)local_34);
}
else {
/* try { // try from 00118a46 to 00118a51 has its CatchHandler @ 00118aed */
std::__cxx11::string::push_back((char)this);
}
}
lVar3 = lVar3 + 1;
} while( true );
}
| |
48,327 | uf_space_endspace | eloqsql/storage/myisam/mi_packrec.c | static void uf_space_endspace(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff, uchar *to,
uchar *end)
{
uint spaces;
if (get_bit(bit_buff))
bfill((uchar*) to,(end-to),' ');
else
{
if ((spaces=get_bits(bit_buff,rec->space_length_bits))+to > end)
{
bit_buff->error=1;
return;
}
if (to+spaces != end)
decode_bytes(rec,bit_buff,to,end-spaces);
bfill((uchar*) end-spaces,spaces,' ');
}
} | O3 | c | uf_space_endspace:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
movl 0x4(%rsi), %eax
testl %eax, %eax
je 0x8300a
movl (%r15), %r12d
decl %eax
movl %eax, 0x4(%r15)
btl %eax, %r12d
jae 0x83027
subq %r14, %rbx
movq %r14, %rdi
movl $0x20, %esi
movq %rbx, %rdx
jmp 0x830d7
movq %r15, %rdi
callq 0x82339
movl $0x1f, 0x4(%r15)
movl (%r15), %r12d
movl $0x1f, %eax
testl %r12d, %r12d
js 0x82ff7
movq %r13, %rdx
movl 0x1c(%r13), %r13d
movl %eax, %ecx
subl %r13d, %ecx
movq %rdx, -0x30(%rbp)
jae 0x83073
subl %eax, %r13d
movl %eax, %eax
leaq 0x5e88b(%rip), %rcx # 0xe18d0
andl (%rcx,%rax,4), %r12d
movl %r13d, %ecx
shll %cl, %r12d
movq %r15, %rdi
callq 0x82339
movl $0x20, %eax
subl %r13d, %eax
movl %eax, 0x4(%r15)
movl (%r15), %eax
negl %r13d
movl %r13d, %ecx
shrl %cl, %eax
addl %eax, %r12d
jmp 0x83088
movl %ecx, 0x4(%r15)
shrl %cl, %r12d
movl 0x1c(%rdx), %eax
leaq 0x5e84c(%rip), %rcx # 0xe18d0
andl (%rcx,%rax,4), %r12d
movl %r12d, %r13d
leaq (%r14,%r13), %rax
cmpq %rbx, %rax
jbe 0x830ab
movl $0x1, 0x28(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %r12
negq %r12
cmpq %rbx, %rax
je 0x830c9
leaq (%rbx,%r12), %rcx
movq -0x30(%rbp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x82c2a
addq %r12, %rbx
movq %rbx, %rdi
movl $0x20, %esi
movq %r13, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x292a0
| uf_space_endspace_0:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rcx
mov r14, rdx
mov r15, rsi
mov r13, rdi
mov eax, [rsi+4]
test eax, eax
jz short loc_8300A
mov r12d, [r15]
dec eax
mov [r15+4], eax
bt r12d, eax
jnb short loc_83027
loc_82FF7:
sub rbx, r14
mov rdi, r14
mov esi, 20h ; ' '
mov rdx, rbx
jmp loc_830D7
loc_8300A:
mov rdi, r15
call fill_buffer_0
mov dword ptr [r15+4], 1Fh
mov r12d, [r15]
mov eax, 1Fh
test r12d, r12d
js short loc_82FF7
loc_83027:
mov rdx, r13
mov r13d, [r13+1Ch]
mov ecx, eax
sub ecx, r13d
mov [rbp+var_30], rdx
jnb short loc_83073
sub r13d, eax
mov eax, eax
lea rcx, mask_0
and r12d, [rcx+rax*4]
mov ecx, r13d
shl r12d, cl
mov rdi, r15
call fill_buffer_0
mov eax, 20h ; ' '
sub eax, r13d
mov [r15+4], eax
mov eax, [r15]
neg r13d
mov ecx, r13d
shr eax, cl
add r12d, eax
jmp short loc_83088
loc_83073:
mov [r15+4], ecx
shr r12d, cl
mov eax, [rdx+1Ch]
lea rcx, mask_0
and r12d, [rcx+rax*4]
loc_83088:
mov r13d, r12d
lea rax, [r14+r13]
cmp rax, rbx
jbe short loc_830AB
mov dword ptr [r15+28h], 1
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_830AB:
mov r12, r13
neg r12
cmp rax, rbx
jz short loc_830C9
lea rcx, [rbx+r12]
mov rdi, [rbp+var_30]
mov rsi, r15
mov rdx, r14
call decode_bytes_0
loc_830C9:
add rbx, r12
mov rdi, rbx
mov esi, 20h ; ' '
mov rdx, r13
loc_830D7:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _memset
| unsigned long long uf_space_endspace_0(long long a1, unsigned int *a2, _BYTE *a3, unsigned long long a4)
{
unsigned int v6; // eax
unsigned int v7; // r12d
unsigned int v8; // eax
unsigned long long result; // rax
unsigned int v10; // r13d
unsigned int v11; // ecx
int v12; // r13d
int v13; // r12d
unsigned int v14; // r12d
v6 = a2[1];
if ( v6 )
{
v7 = *a2;
v8 = v6 - 1;
a2[1] = v8;
if ( _bittest((const int *)&v7, v8) )
return memset(a3, 32LL, a4 - (_QWORD)a3);
}
else
{
fill_buffer_0((long long)a2);
a2[1] = 31;
v7 = *a2;
v8 = 31;
if ( (*a2 & 0x80000000) != 0 )
return memset(a3, 32LL, a4 - (_QWORD)a3);
}
v10 = *(_DWORD *)(a1 + 28);
v11 = v8 - v10;
if ( v8 >= v10 )
{
a2[1] = v11;
v14 = mask_0[*(unsigned int *)(a1 + 28)] & (v7 >> v11);
}
else
{
v12 = v10 - v8;
v13 = (mask_0[v8] & v7) << v12;
fill_buffer_0((long long)a2);
a2[1] = 32 - v12;
v14 = (*a2 >> -(char)v12) + v13;
}
result = (unsigned long long)&a3[v14];
if ( result <= a4 )
{
if ( result != a4 )
decode_bytes_0(a1, (long long)a2, a3, (_BYTE *)(a4 - v14));
return memset(a4 - v14, 32LL, v14);
}
else
{
a2[10] = 1;
}
return result;
}
| uf_space_endspace:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RCX
MOV R14,RDX
MOV R15,RSI
MOV R13,RDI
MOV EAX,dword ptr [RSI + 0x4]
TEST EAX,EAX
JZ 0x0018300a
MOV R12D,dword ptr [R15]
DEC EAX
MOV dword ptr [R15 + 0x4],EAX
BT R12D,EAX
JNC 0x00183027
LAB_00182ff7:
SUB RBX,R14
MOV RDI,R14
MOV ESI,0x20
MOV RDX,RBX
JMP 0x001830d7
LAB_0018300a:
MOV RDI,R15
CALL 0x00182339
MOV dword ptr [R15 + 0x4],0x1f
MOV R12D,dword ptr [R15]
MOV EAX,0x1f
TEST R12D,R12D
JS 0x00182ff7
LAB_00183027:
MOV RDX,R13
MOV R13D,dword ptr [R13 + 0x1c]
MOV ECX,EAX
SUB ECX,R13D
MOV qword ptr [RBP + -0x30],RDX
JNC 0x00183073
SUB R13D,EAX
MOV EAX,EAX
LEA RCX,[0x1e18d0]
AND R12D,dword ptr [RCX + RAX*0x4]
MOV ECX,R13D
SHL R12D,CL
MOV RDI,R15
CALL 0x00182339
MOV EAX,0x20
SUB EAX,R13D
MOV dword ptr [R15 + 0x4],EAX
MOV EAX,dword ptr [R15]
NEG R13D
MOV ECX,R13D
SHR EAX,CL
ADD R12D,EAX
JMP 0x00183088
LAB_00183073:
MOV dword ptr [R15 + 0x4],ECX
SHR R12D,CL
MOV EAX,dword ptr [RDX + 0x1c]
LEA RCX,[0x1e18d0]
AND R12D,dword ptr [RCX + RAX*0x4]
LAB_00183088:
MOV R13D,R12D
LEA RAX,[R14 + R13*0x1]
CMP RAX,RBX
JBE 0x001830ab
MOV dword ptr [R15 + 0x28],0x1
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001830ab:
MOV R12,R13
NEG R12
CMP RAX,RBX
JZ 0x001830c9
LEA RCX,[RBX + R12*0x1]
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,R15
MOV RDX,R14
CALL 0x00182c2a
LAB_001830c9:
ADD RBX,R12
MOV RDI,RBX
MOV ESI,0x20
MOV RDX,R13
LAB_001830d7:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x001292a0
|
void uf_space_endspace(long param_1,uint *param_2,void *param_3,ulong param_4)
{
uint uVar1;
uint uVar2;
uint uVar3;
byte bVar4;
size_t __n;
uint uVar5;
if (param_2[1] == 0) {
fill_buffer(param_2);
param_2[1] = 0x1f;
uVar5 = *param_2;
uVar3 = 0x1f;
if (-1 < (int)uVar5) goto LAB_00183027;
}
else {
uVar5 = *param_2;
uVar3 = param_2[1] - 1;
param_2[1] = uVar3;
if ((uVar5 >> (uVar3 & 0x1f) & 1) == 0) {
LAB_00183027:
uVar1 = *(uint *)(param_1 + 0x1c);
if (uVar3 < uVar1) {
uVar2 = (&mask)[uVar3];
bVar4 = (byte)(uVar1 - uVar3);
fill_buffer(param_2);
param_2[1] = 0x20 - (uVar1 - uVar3);
uVar5 = ((uVar5 & uVar2) << (bVar4 & 0x1f)) + (*param_2 >> (-bVar4 & 0x1f));
}
else {
param_2[1] = uVar3 - uVar1;
uVar5 = uVar5 >> ((byte)(uVar3 - uVar1) & 0x1f) & (&mask)[*(uint *)(param_1 + 0x1c)];
}
__n = (size_t)uVar5;
if (param_4 < (long)param_3 + __n) {
param_2[10] = 1;
return;
}
if ((long)param_3 + __n != param_4) {
decode_bytes(param_1,param_2,param_3,param_4 + -__n);
}
param_3 = (void *)(param_4 + -__n);
goto LAB_001830d7;
}
}
__n = param_4 - (long)param_3;
LAB_001830d7:
memset(param_3,0x20,__n);
return;
}
| |
48,328 | my_caseup_str_8bit | eloqsql/strings/ctype-simple.c | size_t my_caseup_str_8bit(CHARSET_INFO * cs,char *str)
{
register const uchar *map= cs->to_upper;
char *str_orig= str;
while ((*str= (char) map[(uchar) *str]) != 0)
str++;
return (size_t) (str - str_orig);
} | O0 | c | my_caseup_str_8bit:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
movb (%rax,%rcx), %al
movq -0x10(%rbp), %rcx
movb %al, (%rcx)
movsbl %al, %eax
cmpl $0x0, %eax
je 0x52cca
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x52ca0
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
popq %rbp
retq
nopw (%rax,%rax)
| my_caseup_str_8bit:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov rax, [rax+50h]
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
mov [rbp+var_20], rax
loc_52CA0:
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
movzx ecx, byte ptr [rcx]
mov al, [rax+rcx]
mov rcx, [rbp+var_10]
mov [rcx], al
movsx eax, al
cmp eax, 0
jz short loc_52CCA
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp short loc_52CA0
loc_52CCA:
mov rax, [rbp+var_10]
mov rcx, [rbp+var_20]
sub rax, rcx
pop rbp
retn
| _BYTE * my_caseup_str_8bit(long long a1, _BYTE *a2)
{
char v2; // al
long long v4; // [rsp+8h] [rbp-18h]
_BYTE *v5; // [rsp+10h] [rbp-10h]
v5 = a2;
v4 = *(_QWORD *)(a1 + 80);
while ( 1 )
{
v2 = *(_BYTE *)(v4 + (unsigned __int8)*v5);
*v5 = v2;
if ( !v2 )
break;
++v5;
}
return (_BYTE *)(v5 - a2);
}
| my_caseup_str_8bit:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x50]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x20],RAX
LAB_00152ca0:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RCX]
MOV AL,byte ptr [RAX + RCX*0x1]
MOV RCX,qword ptr [RBP + -0x10]
MOV byte ptr [RCX],AL
MOVSX EAX,AL
CMP EAX,0x0
JZ 0x00152cca
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x00152ca0
LAB_00152cca:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x20]
SUB RAX,RCX
POP RBP
RET
|
long my_caseup_str_8bit(long param_1,byte *param_2)
{
byte bVar1;
long lVar2;
byte *local_18;
lVar2 = *(long *)(param_1 + 0x50);
local_18 = param_2;
while (bVar1 = *(byte *)(lVar2 + (ulong)*local_18), *local_18 = bVar1, bVar1 != 0) {
local_18 = local_18 + 1;
}
return (long)local_18 - (long)param_2;
}
| |
48,329 | free_timer | bluesky950520[P]quickjs/quickjs-libc.c | static void free_timer(JSRuntime *rt, JSOSTimer *th)
{
list_del(&th->link);
JS_FreeValueRT(rt, th->func);
js_free_rt(rt, th);
} | O1 | c | free_timer:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
movq 0x30(%rsi), %rsi
movq 0x38(%rbx), %rdx
callq 0x21922
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20ae0
| free_timer:
push r14
push rbx
push rax
mov rbx, rsi
mov r14, rdi
mov rax, [rsi]
mov rcx, [rsi+8]
mov [rax+8], rcx
mov [rcx], rax
xorps xmm0, xmm0
movups xmmword ptr [rsi], xmm0
mov rsi, [rsi+30h]
mov rdx, [rbx+38h]
call JS_FreeValueRT
mov rdi, r14
mov rsi, rbx
add rsp, 8
pop rbx
pop r14
jmp js_free_rt
| long long free_timer(long long a1, long long *a2)
{
long long v2; // rax
_QWORD *v3; // rcx
v2 = *a2;
v3 = (_QWORD *)a2[1];
*(_QWORD *)(v2 + 8) = v3;
*v3 = v2;
*(_OWORD *)a2 = 0LL;
JS_FreeValueRT(a1, a2[6]);
return js_free_rt(a1, a2);
}
| free_timer:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
MOV RAX,qword ptr [RSI]
MOV RCX,qword ptr [RSI + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV qword ptr [RCX],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSI],XMM0
MOV RSI,qword ptr [RSI + 0x30]
MOV RDX,qword ptr [RBX + 0x38]
CALL 0x00121922
MOV RDI,R14
MOV RSI,RBX
ADD RSP,0x8
POP RBX
POP R14
JMP 0x00120ae0
|
void free_timer(int8 param_1,long *param_2)
{
long lVar1;
long *plVar2;
lVar1 = *param_2;
plVar2 = (long *)param_2[1];
*(long **)(lVar1 + 8) = plVar2;
*plVar2 = lVar1;
*param_2 = 0;
param_2[1] = 0;
JS_FreeValueRT(param_1,param_2[6],param_2[7]);
js_free_rt(param_1,param_2);
return;
}
| |
48,330 | lunasvg::SVGGeometryElement::layoutElement(lunasvg::SVGLayoutState const&) | dmazzella[P]pylunasvg/lunasvg/source/svggeometryelement.cpp | void SVGGeometryElement::layoutElement(const SVGLayoutState& state)
{
m_fill_rule = state.fill_rule();
m_clip_rule = state.clip_rule();
m_fill = getPaintServer(state.fill(), state.fill_opacity());
m_stroke = getPaintServer(state.stroke(), state.stroke_opacity());
m_strokeData = getStrokeData(state);
SVGGraphicsElement::layoutElement(state);
m_path.reset();
m_markerPositions.clear();
m_fillBoundingBox = updateShape(m_path);
updateMarkerPositions(m_markerPositions, state);
} | O0 | cpp | lunasvg::SVGGeometryElement::layoutElement(lunasvg::SVGLayoutState const&):
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2ee00
movb %al, %cl
movq -0x70(%rbp), %rax
movb %cl, 0x110(%rax)
movq -0x10(%rbp), %rdi
callq 0x2ee20
movb %al, %cl
movq -0x70(%rbp), %rax
movb %cl, 0x111(%rax)
movq -0x10(%rbp), %rdi
callq 0x2ee40
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2ee60
movq -0x90(%rbp), %rsi
movq -0x70(%rbp), %rdi
callq 0x1a540
movq %rax, %rcx
movq -0x70(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movups -0x20(%rbp), %xmm0
movups %xmm0, 0xd8(%rax)
movq -0x10(%rbp), %rdi
callq 0x2ee80
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2eea0
movq -0x88(%rbp), %rsi
movq -0x70(%rbp), %rdi
callq 0x1a540
movq -0x70(%rbp), %rsi
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movups -0x30(%rbp), %xmm0
movups %xmm0, 0xe8(%rsi)
movq -0x10(%rbp), %rdx
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x1a610
movq -0x80(%rbp), %rsi
movq -0x70(%rbp), %rdi
addq $0xb0, %rdi
callq 0x2eec0
movq -0x80(%rbp), %rdi
callq 0x20ce0
movq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x19e30
movq -0x70(%rbp), %rdi
addq $0x98, %rdi
movq %rdi, -0x78(%rbp)
callq 0x12610
movq -0x70(%rbp), %rdi
addq $0xf8, %rdi
callq 0x2ef10
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdi
movq (%rdi), %rax
movq 0x90(%rax), %rax
callq *%rax
movq -0x70(%rbp), %rdi
movlpd %xmm0, -0x68(%rbp)
movlpd %xmm1, -0x60(%rbp)
movq -0x68(%rbp), %rax
movq %rax, 0xa0(%rdi)
movq -0x60(%rbp), %rax
movq %rax, 0xa8(%rdi)
movq %rdi, %rsi
addq $0xf8, %rsi
movq -0x10(%rbp), %rdx
callq 0x2d400
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| _ZN7lunasvg18SVGGeometryElement13layoutElementERKNS_14SVGLayoutStateE:
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov [rbp+var_70], rax
mov rdi, [rbp+var_10]; this
call _ZNK7lunasvg14SVGLayoutState9fill_ruleEv; lunasvg::SVGLayoutState::fill_rule(void)
mov cl, al
mov rax, [rbp+var_70]
mov [rax+110h], cl
mov rdi, [rbp+var_10]; this
call _ZNK7lunasvg14SVGLayoutState9clip_ruleEv; lunasvg::SVGLayoutState::clip_rule(void)
mov cl, al
mov rax, [rbp+var_70]
mov [rax+111h], cl
mov rdi, [rbp+var_10]; this
call _ZNK7lunasvg14SVGLayoutState4fillEv; lunasvg::SVGLayoutState::fill(void)
mov [rbp+var_90], rax
mov rdi, [rbp+var_10]; this
call _ZNK7lunasvg14SVGLayoutState12fill_opacityEv; lunasvg::SVGLayoutState::fill_opacity(void)
mov rsi, [rbp+var_90]; lunasvg::Paint *
mov rdi, [rbp+var_70]; this
call _ZNK7lunasvg18SVGGraphicsElement14getPaintServerERKNS_5PaintEf; lunasvg::SVGGraphicsElement::getPaintServer(lunasvg::Paint const&,float)
mov rcx, rax
mov rax, [rbp+var_70]
mov qword ptr [rbp+var_20], rcx
mov qword ptr [rbp+var_20+8], rdx
movups xmm0, [rbp+var_20]
movups xmmword ptr [rax+0D8h], xmm0
mov rdi, [rbp+var_10]; this
call _ZNK7lunasvg14SVGLayoutState6strokeEv; lunasvg::SVGLayoutState::stroke(void)
mov [rbp+var_88], rax
mov rdi, [rbp+var_10]; this
call _ZNK7lunasvg14SVGLayoutState14stroke_opacityEv; lunasvg::SVGLayoutState::stroke_opacity(void)
mov rsi, [rbp+var_88]; lunasvg::Paint *
mov rdi, [rbp+var_70]; this
call _ZNK7lunasvg18SVGGraphicsElement14getPaintServerERKNS_5PaintEf; lunasvg::SVGGraphicsElement::getPaintServer(lunasvg::Paint const&,float)
mov rsi, [rbp+var_70]; lunasvg::SVGLayoutState *
mov qword ptr [rbp+var_30], rax
mov qword ptr [rbp+var_30+8], rdx
movups xmm0, [rbp+var_30]
movups xmmword ptr [rsi+0E8h], xmm0
mov rdx, [rbp+var_10]
lea rdi, [rbp+var_58]; this
mov [rbp+var_80], rdi
call _ZNK7lunasvg18SVGGraphicsElement13getStrokeDataERKNS_14SVGLayoutStateE; lunasvg::SVGGraphicsElement::getStrokeData(lunasvg::SVGLayoutState const&)
mov rsi, [rbp+var_80]
mov rdi, [rbp+var_70]
add rdi, 0B0h
call _ZN7lunasvg10StrokeDataaSEOS0_; lunasvg::StrokeData::operator=(lunasvg::StrokeData&&)
mov rdi, [rbp+var_80]; this
call _ZN7lunasvg10StrokeDataD2Ev; lunasvg::StrokeData::~StrokeData()
mov rdi, [rbp+var_70]; this
mov rsi, [rbp+var_10]; lunasvg::SVGLayoutState *
call _ZN7lunasvg10SVGElement13layoutElementERKNS_14SVGLayoutStateE; lunasvg::SVGElement::layoutElement(lunasvg::SVGLayoutState const&)
mov rdi, [rbp+var_70]
add rdi, 98h; this
mov [rbp+var_78], rdi
call _ZN7lunasvg4Path5resetEv; lunasvg::Path::reset(void)
mov rdi, [rbp+var_70]
add rdi, 0F8h
call _ZNSt6vectorIN7lunasvg17SVGMarkerPositionESaIS1_EE5clearEv; std::vector<lunasvg::SVGMarkerPosition>::clear(void)
mov rsi, [rbp+var_78]
mov rdi, [rbp+var_70]
mov rax, [rdi]
mov rax, [rax+90h]
call rax
mov rdi, [rbp+var_70]
movlpd [rbp+var_68], xmm0
movlpd [rbp+var_60], xmm1
mov rax, [rbp+var_68]
mov [rdi+0A0h], rax
mov rax, [rbp+var_60]
mov [rdi+0A8h], rax
mov rsi, rdi
add rsi, 0F8h
mov rdx, [rbp+var_10]
call _ZN7lunasvg18SVGGeometryElement21updateMarkerPositionsERSt6vectorINS_17SVGMarkerPositionESaIS2_EERKNS_14SVGLayoutStateE; lunasvg::SVGGeometryElement::updateMarkerPositions(std::vector<lunasvg::SVGMarkerPosition> &,lunasvg::SVGLayoutState const&)
add rsp, 90h
pop rbp
retn
| long long lunasvg::SVGGeometryElement::layoutElement(
lunasvg::SVGGeometryElement *this,
const lunasvg::SVGLayoutState *a2,
float a3,
double a4)
{
__int128 v4; // rax
float v5; // xmm0_4
__int128 v6; // rax
float v7; // xmm0_4
lunasvg::Paint *v9; // [rsp+0h] [rbp-90h]
lunasvg::Paint *v10; // [rsp+8h] [rbp-88h]
_BYTE v11[40]; // [rsp+38h] [rbp-58h] BYREF
__int128 v12; // [rsp+60h] [rbp-30h]
__int128 v13; // [rsp+70h] [rbp-20h]
lunasvg::SVGLayoutState *v14; // [rsp+80h] [rbp-10h]
lunasvg::SVGGeometryElement *v15; // [rsp+88h] [rbp-8h]
v15 = this;
v14 = a2;
*((_BYTE *)this + 272) = lunasvg::SVGLayoutState::fill_rule(a2);
*((_BYTE *)this + 273) = lunasvg::SVGLayoutState::clip_rule(v14);
v9 = (lunasvg::Paint *)lunasvg::SVGLayoutState::fill(v14);
lunasvg::SVGLayoutState::fill_opacity(v14);
*(_QWORD *)&v4 = lunasvg::SVGGraphicsElement::getPaintServer((lunasvg::Document **)this, v9, a3);
v13 = v4;
v5 = *(float *)&v4;
*(_OWORD *)((char *)this + 216) = v4;
v10 = (lunasvg::Paint *)lunasvg::SVGLayoutState::stroke(v14);
lunasvg::SVGLayoutState::stroke_opacity(v14);
*(_QWORD *)&v6 = lunasvg::SVGGraphicsElement::getPaintServer((lunasvg::Document **)this, v10, v5);
v12 = v6;
v7 = *(float *)&v6;
*(_OWORD *)((char *)this + 232) = v6;
lunasvg::SVGGraphicsElement::getStrokeData((lunasvg::SVGGraphicsElement *)v11, this, v14);
lunasvg::StrokeData::operator=((char *)this + 176, v11);
lunasvg::StrokeData::~StrokeData((lunasvg::StrokeData *)v11);
lunasvg::SVGElement::layoutElement(this, v14, v7);
lunasvg::Path::reset((lunasvg::SVGGeometryElement *)((char *)this + 152));
std::vector<lunasvg::SVGMarkerPosition>::clear((char *)this + 248);
*((double *)this + 20) = (*(double ( **)(lunasvg::SVGGeometryElement *, char *))(*(_QWORD *)this + 144LL))(
this,
(char *)this + 152);
*((double *)this + 21) = a4;
return lunasvg::SVGGeometryElement::updateMarkerPositions(this, (char *)this + 248, v14);
}
| layoutElement:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x70],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0012ee00
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x70]
MOV byte ptr [RAX + 0x110],CL
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0012ee20
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x70]
MOV byte ptr [RAX + 0x111],CL
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0012ee40
MOV qword ptr [RBP + -0x90],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0012ee60
MOV RSI,qword ptr [RBP + -0x90]
MOV RDI,qword ptr [RBP + -0x70]
CALL 0x0011a540
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x18],RDX
MOVUPS XMM0,xmmword ptr [RBP + -0x20]
MOVUPS xmmword ptr [RAX + 0xd8],XMM0
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0012ee80
MOV qword ptr [RBP + -0x88],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0012eea0
MOV RSI,qword ptr [RBP + -0x88]
MOV RDI,qword ptr [RBP + -0x70]
CALL 0x0011a540
MOV RSI,qword ptr [RBP + -0x70]
MOV qword ptr [RBP + -0x30],RAX
MOV qword ptr [RBP + -0x28],RDX
MOVUPS XMM0,xmmword ptr [RBP + -0x30]
MOVUPS xmmword ptr [RSI + 0xe8],XMM0
MOV RDX,qword ptr [RBP + -0x10]
LEA RDI,[RBP + -0x58]
MOV qword ptr [RBP + -0x80],RDI
CALL 0x0011a610
MOV RSI,qword ptr [RBP + -0x80]
MOV RDI,qword ptr [RBP + -0x70]
ADD RDI,0xb0
CALL 0x0012eec0
MOV RDI,qword ptr [RBP + -0x80]
CALL 0x00120ce0
MOV RDI,qword ptr [RBP + -0x70]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x00119e30
MOV RDI,qword ptr [RBP + -0x70]
ADD RDI,0x98
MOV qword ptr [RBP + -0x78],RDI
CALL 0x00112610
MOV RDI,qword ptr [RBP + -0x70]
ADD RDI,0xf8
CALL 0x0012ef10
MOV RSI,qword ptr [RBP + -0x78]
MOV RDI,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x90]
CALL RAX
MOV RDI,qword ptr [RBP + -0x70]
MOVLPD qword ptr [RBP + -0x68],XMM0
MOVLPD qword ptr [RBP + -0x60],XMM1
MOV RAX,qword ptr [RBP + -0x68]
MOV qword ptr [RDI + 0xa0],RAX
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RDI + 0xa8],RAX
MOV RSI,RDI
ADD RSI,0xf8
MOV RDX,qword ptr [RBP + -0x10]
CALL 0x0012d400
ADD RSP,0x90
POP RBP
RET
|
/* lunasvg::SVGGeometryElement::layoutElement(lunasvg::SVGLayoutState const&) */
void lunasvg::SVGGeometryElement::layoutElement(SVGLayoutState *param_1)
{
int8 uVar1;
SVGLayoutState SVar2;
Paint *pPVar3;
SVGLayoutState *in_RSI;
float fVar4;
int8 in_XMM1_Qa;
SVGLayoutState local_60 [40];
int1 local_38 [16];
int1 local_28 [16];
SVGLayoutState *local_18;
SVGLayoutState *local_10;
local_18 = in_RSI;
local_10 = param_1;
SVar2 = (SVGLayoutState)SVGLayoutState::fill_rule(in_RSI);
param_1[0x110] = SVar2;
SVar2 = (SVGLayoutState)SVGLayoutState::clip_rule(local_18);
param_1[0x111] = SVar2;
pPVar3 = (Paint *)SVGLayoutState::fill(local_18);
fVar4 = (float)SVGLayoutState::fill_opacity(local_18);
local_28 = SVGGraphicsElement::getPaintServer((SVGGraphicsElement *)param_1,pPVar3,fVar4);
*(int1 (*) [16])(param_1 + 0xd8) = local_28;
pPVar3 = (Paint *)SVGLayoutState::stroke(local_18);
fVar4 = (float)SVGLayoutState::stroke_opacity(local_18);
local_38 = SVGGraphicsElement::getPaintServer((SVGGraphicsElement *)param_1,pPVar3,fVar4);
*(int1 (*) [16])(param_1 + 0xe8) = local_38;
SVGGraphicsElement::getStrokeData(local_60);
StrokeData::operator=((StrokeData *)(param_1 + 0xb0),(StrokeData *)local_60);
StrokeData::~StrokeData((StrokeData *)local_60);
SVGElement::layoutElement((SVGElement *)param_1,local_18);
Path::reset((Path *)(param_1 + 0x98));
std::vector<lunasvg::SVGMarkerPosition,std::allocator<lunasvg::SVGMarkerPosition>>::clear
((vector<lunasvg::SVGMarkerPosition,std::allocator<lunasvg::SVGMarkerPosition>> *)
(param_1 + 0xf8));
uVar1 = (**(code **)(*(long *)param_1 + 0x90))(param_1,(Path *)(param_1 + 0x98));
*(int8 *)(param_1 + 0xa0) = uVar1;
*(int8 *)(param_1 + 0xa8) = in_XMM1_Qa;
updateMarkerPositions((SVGGeometryElement *)param_1,(vector *)(param_1 + 0xf8),local_18);
return;
}
| |
48,331 | lunasvg::SVGGeometryElement::layoutElement(lunasvg::SVGLayoutState const&) | dmazzella[P]pylunasvg/lunasvg/source/svggeometryelement.cpp | void SVGGeometryElement::layoutElement(const SVGLayoutState& state)
{
m_fill_rule = state.fill_rule();
m_clip_rule = state.clip_rule();
m_fill = getPaintServer(state.fill(), state.fill_opacity());
m_stroke = getPaintServer(state.stroke(), state.stroke_opacity());
m_strokeData = getStrokeData(state);
SVGGraphicsElement::layoutElement(state);
m_path.reset();
m_markerPositions.clear();
m_fillBoundingBox = updateShape(m_path);
updateMarkerPositions(m_markerPositions, state);
} | O1 | cpp | lunasvg::SVGGeometryElement::layoutElement(lunasvg::SVGLayoutState const&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movb 0xba(%rsi), %al
movb %al, 0x110(%rdi)
movb 0xbb(%rsi), %al
movb %al, 0x111(%rdi)
addq $0x10, %rsi
movss 0x6c(%rbx), %xmm0
callq 0x103c8
movq %rax, 0xd8(%r14)
movq %rdx, 0xe0(%r14)
leaq 0x38(%rbx), %rsi
movss 0x70(%rbx), %xmm0
movq %r14, %rdi
callq 0x103c8
movq %rax, 0xe8(%r14)
movq %rdx, 0xf0(%r14)
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x10426
movq (%r15), %rax
movq 0x6(%r15), %rcx
movq %rcx, 0xb6(%r14)
movq %rax, 0xb0(%r14)
leaq 0xc0(%r14), %rdi
leaq 0x10(%rsp), %r15
movq %r15, %rsi
callq 0x13214
movq (%r15), %rdi
testq %rdi, %rdi
je 0x13a99
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0xa320
movq %r14, %rdi
movq %rbx, %rsi
callq 0xfe66
leaq 0x98(%r14), %r12
movq %r12, %rdi
callq 0xd282
leaq 0xf8(%r14), %r15
movq 0xf8(%r14), %rax
cmpq %rax, 0x100(%r14)
je 0x13ad1
movq %rax, 0x100(%r14)
movq (%r14), %rax
movq %r14, %rdi
movq %r12, %rsi
callq *0x90(%rax)
movlhps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, 0xa0(%r14)
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x13b06
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| _ZN7lunasvg18SVGGeometryElement13layoutElementERKNS_14SVGLayoutStateE:
push r15
push r14
push r12
push rbx
sub rsp, 28h
mov rbx, rsi
mov r14, rdi
mov al, [rsi+0BAh]
mov [rdi+110h], al
mov al, [rsi+0BBh]
mov [rdi+111h], al
add rsi, 10h
movss xmm0, dword ptr [rbx+6Ch]
call _ZNK7lunasvg18SVGGraphicsElement14getPaintServerERKNS_5PaintEf; lunasvg::SVGGraphicsElement::getPaintServer(lunasvg::Paint const&,float)
mov [r14+0D8h], rax
mov [r14+0E0h], rdx
lea rsi, [rbx+38h]
movss xmm0, dword ptr [rbx+70h]
mov rdi, r14
call _ZNK7lunasvg18SVGGraphicsElement14getPaintServerERKNS_5PaintEf; lunasvg::SVGGraphicsElement::getPaintServer(lunasvg::Paint const&,float)
mov [r14+0E8h], rax
mov [r14+0F0h], rdx
mov r15, rsp
mov rdi, r15; this
mov rsi, r14; lunasvg::SVGLayoutState *
mov rdx, rbx
call _ZNK7lunasvg18SVGGraphicsElement13getStrokeDataERKNS_14SVGLayoutStateE; lunasvg::SVGGraphicsElement::getStrokeData(lunasvg::SVGLayoutState const&)
mov rax, [r15]
mov rcx, [r15+6]
mov [r14+0B6h], rcx
mov [r14+0B0h], rax
lea rdi, [r14+0C0h]
lea r15, [rsp+48h+var_38]
mov rsi, r15
call _ZNSt6vectorIfSaIfEE14_M_move_assignEOS1_St17integral_constantIbLb1EE; std::vector<float>::_M_move_assign(std::vector<float>&&,std::integral_constant<bool,true>)
mov rdi, [r15]; void *
test rdi, rdi
jz short loc_13A99
mov rsi, [rsp+48h+var_28]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_13A99:
mov rdi, r14; this
mov rsi, rbx; lunasvg::SVGLayoutState *
call _ZN7lunasvg10SVGElement13layoutElementERKNS_14SVGLayoutStateE; lunasvg::SVGElement::layoutElement(lunasvg::SVGLayoutState const&)
lea r12, [r14+98h]
mov rdi, r12; this
call _ZN7lunasvg4Path5resetEv; lunasvg::Path::reset(void)
lea r15, [r14+0F8h]
mov rax, [r14+0F8h]
cmp [r14+100h], rax
jz short loc_13AD1
mov [r14+100h], rax
loc_13AD1:
mov rax, [r14]
mov rdi, r14
mov rsi, r12
call qword ptr [rax+90h]
movlhps xmm0, xmm1
movups xmmword ptr [r14+0A0h], xmm0
mov rdi, r14
mov rsi, r15
mov rdx, rbx
call _ZN7lunasvg18SVGGeometryElement21updateMarkerPositionsERSt6vectorINS_17SVGMarkerPositionESaIS2_EERKNS_14SVGLayoutStateE; lunasvg::SVGGeometryElement::updateMarkerPositions(std::vector<lunasvg::SVGMarkerPosition> &,lunasvg::SVGLayoutState const&)
add rsp, 28h
pop rbx
pop r12
pop r14
pop r15
retn
| long long lunasvg::SVGGeometryElement::layoutElement(
lunasvg::SVGGeometryElement *this,
const lunasvg::SVGLayoutState *a2,
double a3,
__m128 a4)
{
long long v4; // rdx
__m128 v5; // xmm0
long long v6; // rdx
long long v7; // rax
long long v8; // rax
_QWORD v10[2]; // [rsp+0h] [rbp-48h] BYREF
void *v11[7]; // [rsp+10h] [rbp-38h] BYREF
*((_BYTE *)this + 272) = *((_BYTE *)a2 + 186);
*((_BYTE *)this + 273) = *((_BYTE *)a2 + 187);
*((_QWORD *)this + 27) = lunasvg::SVGGraphicsElement::getPaintServer((long long)this, (long long)a2 + 16);
*((_QWORD *)this + 28) = v4;
v5 = (__m128)*((unsigned int *)a2 + 28);
*((_QWORD *)this + 29) = lunasvg::SVGGraphicsElement::getPaintServer((long long)this, (long long)a2 + 56);
*((_QWORD *)this + 30) = v6;
lunasvg::SVGGraphicsElement::getStrokeData((lunasvg::SVGGraphicsElement *)v10, this, (long long)a2);
v7 = v10[0];
*(_QWORD *)((char *)this + 182) = *(_QWORD *)((char *)v10 + 6);
*((_QWORD *)this + 22) = v7;
std::vector<float>::_M_move_assign((long long)this + 192, v11);
if ( v11[0] )
operator delete(v11[0], (char *)v11[2] - (char *)v11[0]);
lunasvg::SVGElement::layoutElement(this, a2);
lunasvg::Path::reset((lunasvg::SVGGeometryElement *)((char *)this + 152));
v8 = *((_QWORD *)this + 31);
if ( *((_QWORD *)this + 32) != v8 )
*((_QWORD *)this + 32) = v8;
*(double *)v5.m128_u64 = (*(double ( **)(lunasvg::SVGGeometryElement *, char *, double))(*(_QWORD *)this + 144LL))(
this,
(char *)this + 152,
*(double *)v5.m128_u64);
*((__m128 *)this + 10) = _mm_movelh_ps(v5, a4);
return lunasvg::SVGGeometryElement::updateMarkerPositions(this, (char *)this + 248, a2);
}
| layoutElement:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RBX,RSI
MOV R14,RDI
MOV AL,byte ptr [RSI + 0xba]
MOV byte ptr [RDI + 0x110],AL
MOV AL,byte ptr [RSI + 0xbb]
MOV byte ptr [RDI + 0x111],AL
ADD RSI,0x10
MOVSS XMM0,dword ptr [RBX + 0x6c]
CALL 0x001103c8
MOV qword ptr [R14 + 0xd8],RAX
MOV qword ptr [R14 + 0xe0],RDX
LEA RSI,[RBX + 0x38]
MOVSS XMM0,dword ptr [RBX + 0x70]
MOV RDI,R14
CALL 0x001103c8
MOV qword ptr [R14 + 0xe8],RAX
MOV qword ptr [R14 + 0xf0],RDX
MOV R15,RSP
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL 0x00110426
MOV RAX,qword ptr [R15]
MOV RCX,qword ptr [R15 + 0x6]
MOV qword ptr [R14 + 0xb6],RCX
MOV qword ptr [R14 + 0xb0],RAX
LEA RDI,[R14 + 0xc0]
LEA R15,[RSP + 0x10]
MOV RSI,R15
CALL 0x00113214
MOV RDI,qword ptr [R15]
TEST RDI,RDI
JZ 0x00113a99
MOV RSI,qword ptr [RSP + 0x20]
SUB RSI,RDI
CALL 0x0010a320
LAB_00113a99:
MOV RDI,R14
MOV RSI,RBX
CALL 0x0010fe66
LEA R12,[R14 + 0x98]
MOV RDI,R12
CALL 0x0010d282
LEA R15,[R14 + 0xf8]
MOV RAX,qword ptr [R14 + 0xf8]
CMP qword ptr [R14 + 0x100],RAX
JZ 0x00113ad1
MOV qword ptr [R14 + 0x100],RAX
LAB_00113ad1:
MOV RAX,qword ptr [R14]
MOV RDI,R14
MOV RSI,R12
CALL qword ptr [RAX + 0x90]
MOVLHPS XMM0,XMM1
MOVUPS xmmword ptr [R14 + 0xa0],XMM0
MOV RDI,R14
MOV RSI,R15
MOV RDX,RBX
CALL 0x00113b06
ADD RSP,0x28
POP RBX
POP R12
POP R14
POP R15
RET
|
/* lunasvg::SVGGeometryElement::layoutElement(lunasvg::SVGLayoutState const&) */
void lunasvg::SVGGeometryElement::layoutElement(SVGLayoutState *param_1)
{
SVGLayoutState *in_RSI;
int8 uVar1;
int8 in_XMM1_Qa;
int1 auVar2 [16];
int6 local_48;
int2 uStack_42;
int6 uStack_40;
void *local_38 [2];
long local_28;
param_1[0x110] = in_RSI[0xba];
param_1[0x111] = in_RSI[0xbb];
auVar2 = SVGGraphicsElement::getPaintServer
((SVGGraphicsElement *)param_1,(Paint *)(in_RSI + 0x10),
*(float *)(in_RSI + 0x6c));
*(int1 (*) [16])(param_1 + 0xd8) = auVar2;
auVar2 = SVGGraphicsElement::getPaintServer
((SVGGraphicsElement *)param_1,(Paint *)(in_RSI + 0x38),
*(float *)(in_RSI + 0x70));
*(int1 (*) [16])(param_1 + 0xe8) = auVar2;
SVGGraphicsElement::getStrokeData((SVGLayoutState *)&local_48);
*(ulong *)(param_1 + 0xb6) = CONCAT62(uStack_40,uStack_42);
*(ulong *)(param_1 + 0xb0) = CONCAT26(uStack_42,local_48);
std::vector<float,std::allocator<float>>::_M_move_assign(param_1 + 0xc0,local_38);
if (local_38[0] != (void *)0x0) {
operator_delete(local_38[0],local_28 - (long)local_38[0]);
}
SVGElement::layoutElement((SVGElement *)param_1,in_RSI);
Path::reset((Path *)(param_1 + 0x98));
if (*(long *)(param_1 + 0x100) != *(long *)(param_1 + 0xf8)) {
*(long *)(param_1 + 0x100) = *(long *)(param_1 + 0xf8);
}
uVar1 = (**(code **)(*(long *)param_1 + 0x90))(param_1,(Path *)(param_1 + 0x98));
*(int8 *)(param_1 + 0xa0) = uVar1;
*(int *)(param_1 + 0xa8) = (int)in_XMM1_Qa;
*(int *)(param_1 + 0xac) = (int)((ulong)in_XMM1_Qa >> 0x20);
updateMarkerPositions((SVGGeometryElement *)param_1,(vector *)(param_1 + 0xf8),in_RSI);
return;
}
| |
48,332 | string_split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/common.cpp | std::vector<std::string> string_split(const std::string & str, const std::string & delimiter) {
std::vector<std::string> parts;
size_t start = 0;
size_t end = str.find(delimiter);
while (end != std::string::npos) {
parts.push_back(str.substr(start, end - start));
start = end + delimiter.length();
end = str.find(delimiter, start);
}
parts.push_back(str.substr(start));
return parts;
} | O1 | cpp | string_split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rdx), %rsi
movq 0x8(%rdx), %rcx
xorl %ebp, %ebp
movq %r14, %rdi
xorl %edx, %edx
callq 0x1bfd0
cmpq $-0x1, %rax
je 0x7fbaa
movq %rax, %r12
xorl %ebp, %ebp
leaq 0x8(%rsp), %r13
movq %r12, %rcx
subq %rbp, %rcx
movq %r13, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x1b940
movq %rbx, %rdi
movq %r13, %rsi
callq 0x62f6a
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x7fb89
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b8f0
movq (%r15), %rsi
movq 0x8(%r15), %rcx
movq %r12, %rbp
addq %rcx, %rbp
movq %r14, %rdi
movq %rbp, %rdx
callq 0x1bfd0
movq %rax, %r12
cmpq $-0x1, %rax
jne 0x7fb4e
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbp, %rdx
movq $-0x1, %rcx
callq 0x1b940
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x62f6a
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7fbe9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b8f0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
jmp 0x7fc1d
jmp 0x7fc0b
movq %rax, %r14
jmp 0x7fc2f
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x7fc2f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b8f0
movq %rbx, %rdi
callq 0x2d182
movq %r14, %rdi
callq 0x1c020
| _Z12string_splitRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r15, rdx
mov r14, rsi
mov rbx, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
mov rsi, [rdx]
mov rcx, [rdx+8]
xor ebp, ebp
mov rdi, r14
xor edx, edx
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEPKcmm; std::string::find(char const*,ulong,ulong)
cmp rax, 0FFFFFFFFFFFFFFFFh
jz short loc_7FBAA
mov r12, rax
xor ebp, ebp
lea r13, [rsp+58h+var_50]
loc_7FB4E:
mov rcx, r12
sub rcx, rbp
mov rdi, r13
mov rsi, r14
mov rdx, rbp
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
mov rdi, rbx
mov rsi, r13
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE12emplace_backIJS5_EEERS5_DpOT_; std::vector<std::string>::emplace_back<std::string>(std::string &&)
mov rdi, [rsp+58h+var_50]; void *
lea rax, [rsp+58h+var_40]
cmp rdi, rax
jz short loc_7FB89
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7FB89:
mov rsi, [r15]
mov rcx, [r15+8]
mov rbp, r12
add rbp, rcx
mov rdi, r14
mov rdx, rbp
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEPKcmm; std::string::find(char const*,ulong,ulong)
mov r12, rax
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_7FB4E
loc_7FBAA:
lea rdi, [rsp+58h+var_50]
mov rsi, r14
mov rdx, rbp
mov rcx, 0FFFFFFFFFFFFFFFFh
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
lea rsi, [rsp+58h+var_50]
mov rdi, rbx
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE12emplace_backIJS5_EEERS5_DpOT_; std::vector<std::string>::emplace_back<std::string>(std::string &&)
lea rax, [rsp+58h+var_40]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_7FBE9
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7FBE9:
mov rax, rbx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov r14, rax
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]
jmp short loc_7FC1D
jmp short $+2
loc_7FC0B:
mov r14, rax
jmp short loc_7FC2F
mov r14, rax
mov rdi, [rsp+arg_0]; void *
lea rax, [rsp+arg_10]
loc_7FC1D:
cmp rdi, rax
jz short loc_7FC2F
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7FC2F:
mov rdi, rbx
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rdi, r14
call __Unwind_Resume
| long long string_split(long long a1, long long a2, _QWORD *a3)
{
long long v4; // rbp
long long v5; // rax
long long v6; // r12
long long v7; // rcx
void *v9[2]; // [rsp+8h] [rbp-50h] BYREF
_QWORD v10[8]; // [rsp+18h] [rbp-40h] BYREF
*(_OWORD *)a1 = 0LL;
*(_QWORD *)(a1 + 16) = 0LL;
v4 = 0LL;
v5 = std::string::find(a2, *a3, 0LL, a3[1]);
if ( v5 != -1 )
{
v6 = v5;
v4 = 0LL;
do
{
std::string::substr(v9, a2, v4, v6 - v4);
std::vector<std::string>::emplace_back<std::string>(a1, (long long)v9);
if ( v9[0] != v10 )
operator delete(v9[0], v10[0] + 1LL);
v7 = a3[1];
v4 = v7 + v6;
v6 = std::string::find(a2, *a3, v7 + v6, v7);
}
while ( v6 != -1 );
}
std::string::substr(v9, a2, v4, -1LL);
std::vector<std::string>::emplace_back<std::string>(a1, (long long)v9);
if ( v9[0] != v10 )
operator delete(v9[0], v10[0] + 1LL);
return a1;
}
| string_split:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R15,RDX
MOV R14,RSI
MOV RBX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
MOV RSI,qword ptr [RDX]
MOV RCX,qword ptr [RDX + 0x8]
XOR EBP,EBP
MOV RDI,R14
XOR EDX,EDX
CALL 0x0011bfd0
CMP RAX,-0x1
JZ 0x0017fbaa
MOV R12,RAX
XOR EBP,EBP
LEA R13,[RSP + 0x8]
LAB_0017fb4e:
MOV RCX,R12
SUB RCX,RBP
LAB_0017fb54:
MOV RDI,R13
MOV RSI,R14
MOV RDX,RBP
CALL 0x0011b940
LAB_0017fb62:
MOV RDI,RBX
MOV RSI,R13
CALL 0x00162f6a
MOV RDI,qword ptr [RSP + 0x8]
LEA RAX,[RSP + 0x18]
CMP RDI,RAX
JZ 0x0017fb89
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011b8f0
LAB_0017fb89:
MOV RSI,qword ptr [R15]
MOV RCX,qword ptr [R15 + 0x8]
MOV RBP,R12
ADD RBP,RCX
MOV RDI,R14
MOV RDX,RBP
CALL 0x0011bfd0
MOV R12,RAX
CMP RAX,-0x1
JNZ 0x0017fb4e
LAB_0017fbaa:
LEA RDI,[RSP + 0x8]
MOV RSI,R14
MOV RDX,RBP
MOV RCX,-0x1
CALL 0x0011b940
LAB_0017fbc1:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x00162f6a
LAB_0017fbce:
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0017fbe9
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011b8f0
LAB_0017fbe9:
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* string_split(std::__cxx11::string const&, std::__cxx11::string const&) */
string * string_split(string *param_1,string *param_2)
{
long lVar1;
ulong *in_RDX;
long *local_50 [2];
long local_40 [2];
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
lVar1 = std::__cxx11::string::find((char *)param_2,*in_RDX,0);
if (lVar1 != -1) {
do {
/* try { // try from 0017fb54 to 0017fb61 has its CatchHandler @ 0017fc0b */
std::__cxx11::string::substr((ulong)local_50,(ulong)param_2);
/* try { // try from 0017fb62 to 0017fb6c has its CatchHandler @ 0017fc10 */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::
emplace_back<std::__cxx11::string>
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)param_1,
(string *)local_50);
if (local_50[0] != local_40) {
operator_delete(local_50[0],local_40[0] + 1);
}
lVar1 = std::__cxx11::string::find((char *)param_2,*in_RDX,lVar1 + in_RDX[1]);
} while (lVar1 != -1);
}
/* try { // try from 0017fbaa to 0017fbc0 has its CatchHandler @ 0017fc09 */
std::__cxx11::string::substr((ulong)local_50,(ulong)param_2);
/* try { // try from 0017fbc1 to 0017fbcd has its CatchHandler @ 0017fbfb */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::
emplace_back<std::__cxx11::string>
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)param_1,
(string *)local_50);
if (local_50[0] != local_40) {
operator_delete(local_50[0],local_40[0] + 1);
}
return param_1;
}
| |
48,333 | string_split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/common.cpp | std::vector<std::string> string_split(const std::string & str, const std::string & delimiter) {
std::vector<std::string> parts;
size_t start = 0;
size_t end = str.find(delimiter);
while (end != std::string::npos) {
parts.push_back(str.substr(start, end - start));
start = end + delimiter.length();
end = str.find(delimiter, start);
}
parts.push_back(str.substr(start));
return parts;
} | O2 | cpp | string_split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
xorl %ebp, %ebp
movq %rsi, %rdi
movq %rdx, %rsi
xorl %edx, %edx
callq 0x25250
movq %rax, %r12
leaq 0x8(%rsp), %r13
cmpq $-0x1, %r12
je 0x5fb0d
movq %r12, %rcx
subq %rbp, %rcx
movq %r13, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x24950
movq %rbx, %rdi
movq %r13, %rsi
callq 0x46980
movq %r13, %rdi
callq 0x25298
addq 0x8(%r15), %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x25250
movq %r12, %rbp
movq %rax, %r12
jmp 0x5fac6
leaq 0x8(%rsp), %rdi
pushq $-0x1
popq %rcx
movq %r14, %rsi
movq %rbp, %rdx
callq 0x24950
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x46980
leaq 0x8(%rsp), %rdi
callq 0x25298
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5fb52
jmp 0x5fb4d
movq %rax, %r14
jmp 0x5fb5f
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x25298
movq %rbx, %rdi
callq 0x30b26
movq %r14, %rdi
callq 0x25010
| _Z12string_splitRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r15, rdx
mov r14, rsi
mov rbx, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
and qword ptr [rdi+10h], 0
xor ebp, ebp
mov rdi, rsi
mov rsi, rdx
xor edx, edx
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findERKS4_m; std::string::find(std::string const&,ulong)
mov r12, rax
lea r13, [rsp+58h+var_50]
loc_5FAC6:
cmp r12, 0FFFFFFFFFFFFFFFFh
jz short loc_5FB0D
mov rcx, r12
sub rcx, rbp
mov rdi, r13
mov rsi, r14
mov rdx, rbp
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
mov rdi, rbx
mov rsi, r13
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE12emplace_backIJS5_EEERS5_DpOT_; std::vector<std::string>::emplace_back<std::string>(std::string &&)
mov rdi, r13; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
add r12, [r15+8]
mov rdi, r14
mov rsi, r15
mov rdx, r12
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findERKS4_m; std::string::find(std::string const&,ulong)
mov rbp, r12
mov r12, rax
jmp short loc_5FAC6
loc_5FB0D:
lea rdi, [rsp+58h+var_50]
push 0FFFFFFFFFFFFFFFFh
pop rcx
mov rsi, r14
mov rdx, rbp
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
lea rsi, [rsp+58h+var_50]
mov rdi, rbx
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE12emplace_backIJS5_EEERS5_DpOT_; std::vector<std::string>::emplace_back<std::string>(std::string &&)
lea rdi, [rsp+58h+var_50]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rax, rbx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_5FB52
jmp short $+2
loc_5FB4D:
mov r14, rax
jmp short loc_5FB5F
loc_5FB52:
mov r14, rax
lea rdi, [rsp+arg_0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_5FB5F:
mov rdi, rbx
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rdi, r14
call __Unwind_Resume
| long long string_split(long long a1, long long a2, long long a3)
{
long long v4; // rbp
long long i; // r12
_BYTE v7[80]; // [rsp+8h] [rbp-50h] BYREF
*(_OWORD *)a1 = 0LL;
*(_QWORD *)(a1 + 16) = 0LL;
v4 = 0LL;
for ( i = std::string::find(a2, a3, 0LL); i != -1; i = std::string::find(a2, a3, v4) )
{
std::string::substr(v7, a2, v4, i - v4);
std::vector<std::string>::emplace_back<std::string>(a1, (long long)v7);
std::string::~string(v7);
v4 = *(_QWORD *)(a3 + 8) + i;
}
std::string::substr(v7, a2, v4, -1LL);
std::vector<std::string>::emplace_back<std::string>(a1, (long long)v7);
std::string::~string(v7);
return a1;
}
| string_split:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R15,RDX
MOV R14,RSI
MOV RBX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
AND qword ptr [RDI + 0x10],0x0
XOR EBP,EBP
MOV RDI,RSI
MOV RSI,RDX
XOR EDX,EDX
CALL 0x00125250
MOV R12,RAX
LEA R13,[RSP + 0x8]
LAB_0015fac6:
CMP R12,-0x1
JZ 0x0015fb0d
MOV RCX,R12
SUB RCX,RBP
LAB_0015fad2:
MOV RDI,R13
MOV RSI,R14
MOV RDX,RBP
CALL 0x00124950
LAB_0015fae0:
MOV RDI,RBX
MOV RSI,R13
CALL 0x00146980
MOV RDI,R13
CALL 0x00125298
ADD R12,qword ptr [R15 + 0x8]
MOV RDI,R14
MOV RSI,R15
MOV RDX,R12
CALL 0x00125250
MOV RBP,R12
MOV R12,RAX
JMP 0x0015fac6
LAB_0015fb0d:
LEA RDI,[RSP + 0x8]
PUSH -0x1
POP RCX
MOV RSI,R14
MOV RDX,RBP
CALL 0x00124950
LAB_0015fb20:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x00146980
LAB_0015fb2d:
LEA RDI,[RSP + 0x8]
CALL 0x00125298
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* string_split(std::__cxx11::string const&, std::__cxx11::string const&) */
string * string_split(string *param_1,string *param_2)
{
long lVar1;
ulong in_RDX;
string local_50 [32];
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
lVar1 = std::__cxx11::string::find(param_2,in_RDX);
while (lVar1 != -1) {
/* try { // try from 0015fad2 to 0015fadf has its CatchHandler @ 0015fb4d */
std::__cxx11::string::substr((ulong)local_50,(ulong)param_2);
/* try { // try from 0015fae0 to 0015faea has its CatchHandler @ 0015fb52 */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::
emplace_back<std::__cxx11::string>
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)param_1,local_50
);
std::__cxx11::string::~string(local_50);
lVar1 = std::__cxx11::string::find(param_2,in_RDX);
}
/* try { // try from 0015fb0d to 0015fb1f has its CatchHandler @ 0015fb4b */
std::__cxx11::string::substr((ulong)local_50,(ulong)param_2);
/* try { // try from 0015fb20 to 0015fb2c has its CatchHandler @ 0015fb49 */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::
emplace_back<std::__cxx11::string>
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)param_1,local_50);
std::__cxx11::string::~string(local_50);
return param_1;
}
| |
48,334 | my_caseup_str_utf8mb4 | eloqsql/strings/ctype-utf8.c | static size_t
my_caseup_str_utf8mb4(CHARSET_INFO *cs, char *src)
{
my_wc_t wc;
int srcres, dstres;
char *dst= src, *dst0= src;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
DBUG_ASSERT(cs->caseup_multiply == 1);
while (*src &&
(srcres= my_mb_wc_utf8mb4_no_range(cs, &wc, (uchar *) src)) > 0)
{
my_toupper_utf8mb4(uni_plane, &wc);
if ((dstres= my_wc_mb_utf8mb4_no_range(cs, wc, (uchar*) dst)) <= 0)
break;
src+= srcres;
dst+= dstres;
}
*dst= '\0';
return (size_t) (dst - dst0);
} | O0 | c | my_caseup_str_utf8mb4:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0xb51ee
jmp 0xb51f0
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x39(%rbp)
je 0xb521e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq -0x18(%rbp), %rsi
callq 0xb9080
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
setg %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0xb5227
jmp 0xb5276
movq -0x38(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xb92c0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0xb9330
movl %eax, -0x20(%rbp)
cmpl $0x0, %eax
jg 0xb524f
jmp 0xb5276
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x20(%rbp), %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0xb51f0
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
addq $0x40, %rsp
popq %rbp
retq
nop
| my_caseup_str_utf8mb4:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
mov [rbp+var_28], rax
mov rax, [rbp+var_10]
mov [rbp+var_30], rax
mov rax, [rbp+var_8]
mov rax, [rax+78h]
mov [rbp+var_38], rax
jmp short $+2
loc_B51EE:
jmp short $+2
loc_B51F0:
mov rax, [rbp+var_10]
movsx ecx, byte ptr [rax]
xor eax, eax
cmp ecx, 0
mov [rbp+var_39], al
jz short loc_B521E
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_10]
lea rsi, [rbp+var_18]
call my_mb_wc_utf8mb4_no_range
mov [rbp+var_1C], eax
cmp eax, 0
setnle al
mov [rbp+var_39], al
loc_B521E:
mov al, [rbp+var_39]
test al, 1
jnz short loc_B5227
jmp short loc_B5276
loc_B5227:
mov rdi, [rbp+var_38]
lea rsi, [rbp+var_18]
call my_toupper_utf8mb4
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_28]
call my_wc_mb_utf8mb4_no_range
mov [rbp+var_20], eax
cmp eax, 0
jg short loc_B524F
jmp short loc_B5276
loc_B524F:
mov ecx, [rbp+var_1C]
mov rax, [rbp+var_10]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_10], rax
mov ecx, [rbp+var_20]
mov rax, [rbp+var_28]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_28], rax
jmp loc_B51F0
loc_B5276:
mov rax, [rbp+var_28]
mov byte ptr [rax], 0
mov rax, [rbp+var_28]
mov rcx, [rbp+var_30]
sub rax, rcx
add rsp, 40h
pop rbp
retn
| _BYTE * my_caseup_str_utf8mb4(long long a1, _BYTE *a2)
{
bool v3; // [rsp+7h] [rbp-39h]
long long v4; // [rsp+8h] [rbp-38h]
_BYTE *v5; // [rsp+18h] [rbp-28h]
int v6; // [rsp+20h] [rbp-20h]
int v7; // [rsp+24h] [rbp-1Ch]
long long v8; // [rsp+28h] [rbp-18h] BYREF
_BYTE *v9; // [rsp+30h] [rbp-10h]
long long v10; // [rsp+38h] [rbp-8h]
v10 = a1;
v9 = a2;
v5 = a2;
v4 = *(_QWORD *)(a1 + 120);
while ( 1 )
{
v3 = 0;
if ( *v9 )
{
v7 = my_mb_wc_utf8mb4_no_range(v10, &v8, v9);
v3 = v7 > 0;
}
if ( !v3 )
break;
my_toupper_utf8mb4(v4, &v8);
v6 = my_wc_mb_utf8mb4_no_range(v10, v8, v5);
if ( v6 <= 0 )
break;
v9 += v7;
v5 += v6;
}
*v5 = 0;
return (_BYTE *)(v5 - a2);
}
| my_caseup_str_utf8mb4:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x78]
MOV qword ptr [RBP + -0x38],RAX
JMP 0x001b51ee
LAB_001b51ee:
JMP 0x001b51f0
LAB_001b51f0:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX ECX,byte ptr [RAX]
XOR EAX,EAX
CMP ECX,0x0
MOV byte ptr [RBP + -0x39],AL
JZ 0x001b521e
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x10]
LEA RSI,[RBP + -0x18]
CALL 0x001b9080
MOV dword ptr [RBP + -0x1c],EAX
CMP EAX,0x0
SETG AL
MOV byte ptr [RBP + -0x39],AL
LAB_001b521e:
MOV AL,byte ptr [RBP + -0x39]
TEST AL,0x1
JNZ 0x001b5227
JMP 0x001b5276
LAB_001b5227:
MOV RDI,qword ptr [RBP + -0x38]
LEA RSI,[RBP + -0x18]
CALL 0x001b92c0
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x28]
CALL 0x001b9330
MOV dword ptr [RBP + -0x20],EAX
CMP EAX,0x0
JG 0x001b524f
JMP 0x001b5276
LAB_001b524f:
MOV ECX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
MOV ECX,dword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x28]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
JMP 0x001b51f0
LAB_001b5276:
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
SUB RAX,RCX
ADD RSP,0x40
POP RBP
RET
|
long my_caseup_str_utf8mb4(long param_1,char *param_2)
{
int8 uVar1;
bool bVar2;
int iVar3;
char *local_30;
int local_24;
int8 local_20;
char *local_18;
long local_10;
uVar1 = *(int8 *)(param_1 + 0x78);
local_30 = param_2;
local_18 = param_2;
local_10 = param_1;
while( true ) {
bVar2 = false;
if (*local_18 != '\0') {
local_24 = my_mb_wc_utf8mb4_no_range(local_10,&local_20,local_18);
bVar2 = 0 < local_24;
}
if (!bVar2) break;
my_toupper_utf8mb4(uVar1,&local_20);
iVar3 = my_wc_mb_utf8mb4_no_range(local_10,local_20,local_30);
if (iVar3 < 1) break;
local_18 = local_18 + local_24;
local_30 = local_30 + iVar3;
}
*local_30 = '\0';
return (long)local_30 - (long)param_2;
}
| |
48,335 | my_readlink | eloqsql/mysys/my_symlink.c | int my_readlink(char *to, const char *filename, myf MyFlags)
{
#ifndef HAVE_READLINK
strmov(to,filename);
return 1;
#else
int result=0;
int length;
DBUG_ENTER("my_readlink");
if ((length=readlink(filename, to, FN_REFLEN-1)) < 0)
{
/* Don't give an error if this wasn't a symlink */
if ((my_errno=errno) == EINVAL)
{
result= 1;
strmov(to,filename);
}
else
{
if (MyFlags & MY_WME)
my_error(EE_CANT_READLINK, MYF(0), filename, errno);
result= -1;
}
}
else
to[length]=0;
DBUG_PRINT("exit" ,("result: %d", result));
DBUG_RETURN(result);
#endif /* HAVE_READLINK */
} | O0 | c | my_readlink:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x2a260
movl %eax, -0x20(%rbp)
cmpl $0x0, %eax
jge 0xf4ef1
callq 0x2a760
movl (%rax), %eax
movl %eax, -0x24(%rbp)
callq 0xf6090
movq %rax, %rcx
movl -0x24(%rbp), %eax
movl %eax, (%rcx)
cmpl $0x16, %eax
jne 0xf4eb7
movl $0x1, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2a730
jmp 0xf4eef
movq -0x18(%rbp), %rax
andq $0x10, %rax
cmpq $0x0, %rax
je 0xf4ee8
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x2a760
movq -0x30(%rbp), %rdx
movl (%rax), %ecx
movl $0x18, %edi
xorl %eax, %eax
movl %eax, %esi
movb $0x0, %al
callq 0xefb40
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
jmp 0xf4efd
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0xf4eff
jmp 0xf4f01
jmp 0xf4f03
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_readlink:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], 0
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_8]
mov edx, 1FFh
call _readlink
mov [rbp+var_20], eax
cmp eax, 0
jge short loc_F4EF1
call ___errno_location
mov eax, [rax]
mov [rbp+var_24], eax
call _my_thread_var
mov rcx, rax
mov eax, [rbp+var_24]
mov [rcx], eax
cmp eax, 16h
jnz short loc_F4EB7
mov [rbp+var_1C], 1
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
call _stpcpy
jmp short loc_F4EEF
loc_F4EB7:
mov rax, [rbp+var_18]
and rax, 10h
cmp rax, 0
jz short loc_F4EE8
mov rax, [rbp+var_10]
mov [rbp+var_30], rax
call ___errno_location
mov rdx, [rbp+var_30]
mov ecx, [rax]
mov edi, 18h
xor eax, eax
mov esi, eax
mov al, 0
call my_error
loc_F4EE8:
mov [rbp+var_1C], 0FFFFFFFFh
loc_F4EEF:
jmp short loc_F4EFD
loc_F4EF1:
mov rax, [rbp+var_8]
movsxd rcx, [rbp+var_20]
mov byte ptr [rax+rcx], 0
loc_F4EFD:
jmp short $+2
loc_F4EFF:
jmp short $+2
loc_F4F01:
jmp short $+2
loc_F4F03:
mov eax, [rbp+var_1C]
mov [rbp+var_34], eax
mov eax, [rbp+var_34]
add rsp, 40h
pop rbp
retn
| long long my_readlink(const char *a1, long long a2, char a3)
{
unsigned int *v3; // rax
int v5; // [rsp+1Ch] [rbp-24h]
int v6; // [rsp+20h] [rbp-20h]
unsigned int v7; // [rsp+24h] [rbp-1Ch]
v7 = 0;
v6 = readlink(a2, a1, 511LL);
if ( v6 >= 0 )
{
a1[v6] = 0;
}
else
{
v5 = *(_DWORD *)__errno_location();
*(_DWORD *)my_thread_var(a2, a1) = v5;
if ( v5 == 22 )
{
v7 = 1;
stpcpy(a1, a2);
}
else
{
if ( (a3 & 0x10) != 0 )
{
v3 = (unsigned int *)__errno_location();
my_error(0x18u, 0LL, a2, *v3);
}
return (unsigned int)-1;
}
}
return v7;
}
| my_readlink:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],0x0
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x8]
MOV EDX,0x1ff
CALL 0x0012a260
MOV dword ptr [RBP + -0x20],EAX
CMP EAX,0x0
JGE 0x001f4ef1
CALL 0x0012a760
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x24],EAX
CALL 0x001f6090
MOV RCX,RAX
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RCX],EAX
CMP EAX,0x16
JNZ 0x001f4eb7
MOV dword ptr [RBP + -0x1c],0x1
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x0012a730
JMP 0x001f4eef
LAB_001f4eb7:
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x10
CMP RAX,0x0
JZ 0x001f4ee8
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x30],RAX
CALL 0x0012a760
MOV RDX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RAX]
MOV EDI,0x18
XOR EAX,EAX
MOV ESI,EAX
MOV AL,0x0
CALL 0x001efb40
LAB_001f4ee8:
MOV dword ptr [RBP + -0x1c],0xffffffff
LAB_001f4eef:
JMP 0x001f4efd
LAB_001f4ef1:
MOV RAX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RBP + -0x20]
MOV byte ptr [RAX + RCX*0x1],0x0
LAB_001f4efd:
JMP 0x001f4eff
LAB_001f4eff:
JMP 0x001f4f01
LAB_001f4f01:
JMP 0x001f4f03
LAB_001f4f03:
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x34],EAX
MOV EAX,dword ptr [RBP + -0x34]
ADD RSP,0x40
POP RBP
RET
|
int4 my_readlink(char *param_1,char *param_2,ulong param_3)
{
int iVar1;
ssize_t sVar2;
int *piVar3;
int4 local_24;
local_24 = 0;
sVar2 = readlink(param_2,param_1,0x1ff);
if ((int)sVar2 < 0) {
piVar3 = __errno_location();
iVar1 = *piVar3;
piVar3 = (int *)_my_thread_var();
*piVar3 = iVar1;
if (iVar1 == 0x16) {
local_24 = 1;
stpcpy(param_1,param_2);
}
else {
if ((param_3 & 0x10) != 0) {
piVar3 = __errno_location();
my_error(0x18,0,param_2,*piVar3);
}
local_24 = 0xffffffff;
}
}
else {
param_1[(int)sVar2] = '\0';
}
return local_24;
}
| |
48,336 | rak_value_print | fabiosvm[P]rak/src/value.c | void rak_value_print(RakValue val)
{
switch (val.type)
{
case RAK_TYPE_NIL:
printf("nil");
break;
case RAK_TYPE_BOOL:
printf("%s", rak_as_bool(val) ? "true" : "false");
break;
case RAK_TYPE_NUMBER:
printf("%g", rak_as_number(val));
break;
case RAK_TYPE_STRING:
rak_string_print(rak_as_string(val));
break;
case RAK_TYPE_ARRAY:
rak_array_print(rak_as_array(val));
break;
case RAK_TYPE_RANGE:
rak_range_print(rak_as_range(val));
break;
case RAK_TYPE_RECORD:
rak_record_print(rak_as_record(val));
break;
case RAK_TYPE_CLOSURE:
printf("<%s %p>",rak_type_to_cstr(val.type), (void *) val.opaque.ptr);
break;
}
} | O0 | c | rak_value_print:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x7, %rax
ja 0xb43e
movq -0x18(%rbp), %rax
leaq 0x35a0(%rip), %rcx # 0xe93c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2e77(%rip), %rdi # 0xe223
movb $0x0, %al
callq 0x2080
jmp 0xb43e
movb -0x8(%rbp), %cl
leaq 0x33f1(%rip), %rsi # 0xe7b3
leaq 0x33f7(%rip), %rax # 0xe7c0
testb $0x1, %cl
cmovneq %rax, %rsi
leaq 0x370d(%rip), %rdi # 0xeae4
movb $0x0, %al
callq 0x2080
jmp 0xb43e
movsd -0x8(%rbp), %xmm0
leaq 0x35cb(%rip), %rdi # 0xe9b7
movb $0x1, %al
callq 0x2080
jmp 0xb43e
movq -0x8(%rbp), %rdi
callq 0xaec0
jmp 0xb43e
movq -0x8(%rbp), %rdi
callq 0x2e60
jmp 0xb43e
movq -0x8(%rbp), %rdi
callq 0x9b50
jmp 0xb43e
movq -0x8(%rbp), %rdi
callq 0xa590
jmp 0xb43e
movl -0x10(%rbp), %edi
callq 0xaef0
movq %rax, %rsi
movq -0x8(%rbp), %rdx
leaq 0x3583(%rip), %rdi # 0xe9ba
movb $0x0, %al
callq 0x2080
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| rak_value_print:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_8], rsi
mov eax, dword ptr [rbp+var_10]
mov [rbp+var_18], rax
sub rax, 7; switch 8 cases
ja def_B3A3; jumptable 000000000000B3A3 default case
mov rax, [rbp+var_18]
lea rcx, jpt_B3A3
movsxd rax, ds:(jpt_B3A3 - 0E93Ch)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_B3A5:
lea rdi, aIsNil+3; jumptable 000000000000B3A3 case 0
mov al, 0
call _printf
jmp def_B3A3; jumptable 000000000000B3A3 default case
loc_B3B8:
mov cl, byte ptr [rbp+var_8]; jumptable 000000000000B3A3 case 1
lea rsi, aFalse; "false"
lea rax, aTrue; "true"
test cl, 1
cmovnz rsi, rax
lea rdi, aCannotAddStrin+16h; "%s"
mov al, 0
call _printf
jmp short def_B3A3; jumptable 000000000000B3A3 default case
loc_B3E0:
movsd xmm0, [rbp+var_8]; jumptable 000000000000B3A3 case 2
lea rdi, aG; "%g"
mov al, 1
call _printf
jmp short def_B3A3; jumptable 000000000000B3A3 default case
loc_B3F5:
mov rdi, [rbp+var_8]; jumptable 000000000000B3A3 case 3
call rak_string_print
jmp short def_B3A3; jumptable 000000000000B3A3 default case
loc_B400:
mov rdi, [rbp+var_8]; jumptable 000000000000B3A3 case 4
call rak_array_print
jmp short def_B3A3; jumptable 000000000000B3A3 default case
loc_B40B:
mov rdi, [rbp+var_8]; jumptable 000000000000B3A3 case 5
call rak_range_print
jmp short def_B3A3; jumptable 000000000000B3A3 default case
loc_B416:
mov rdi, [rbp+var_8]; jumptable 000000000000B3A3 case 6
call rak_record_print
jmp short def_B3A3; jumptable 000000000000B3A3 default case
loc_B421:
mov edi, dword ptr [rbp+var_10]; jumptable 000000000000B3A3 case 7
call rak_type_to_cstr
mov rsi, rax
mov rdx, [rbp+var_8]
lea rdi, aSP; "<%s %p>"
mov al, 0
call _printf
def_B3A3:
add rsp, 20h; jumptable 000000000000B3A3 default case
pop rbp
retn
| long long rak_value_print(unsigned int a1, const void *a2)
{
long long result; // rax
const char *v3; // rsi
char *v4; // rax
char v5; // [rsp+18h] [rbp-8h]
v5 = (char)a2;
result = a1;
switch ( a1 )
{
case 0u:
result = printf("nil");
break;
case 1u:
v3 = "false";
if ( (v5 & 1) != 0 )
v3 = "true";
result = printf("%s", v3);
break;
case 2u:
result = printf("%g", *(double *)&a2);
break;
case 3u:
result = rak_string_print((long long)a2);
break;
case 4u:
result = rak_array_print((long long)a2);
break;
case 5u:
result = rak_range_print((long long)a2);
break;
case 6u:
result = rak_record_print((long long)a2);
break;
case 7u:
v4 = rak_type_to_cstr(a1);
result = printf("<%s %p>", v4, a2);
break;
default:
return result;
}
return result;
}
| rak_value_print:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x8],RSI
MOV EAX,dword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x18],RAX
SUB RAX,0x7
JA 0x0010b43e
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[0x10e93c]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_0:
LEA RDI,[0x10e223]
MOV AL,0x0
CALL 0x00102080
JMP 0x0010b43e
caseD_1:
MOV CL,byte ptr [RBP + -0x8]
LEA RSI,[0x10e7b3]
LEA RAX,[0x10e7c0]
TEST CL,0x1
CMOVNZ RSI,RAX
LEA RDI,[0x10eae4]
MOV AL,0x0
CALL 0x00102080
JMP 0x0010b43e
caseD_2:
MOVSD XMM0,qword ptr [RBP + -0x8]
LEA RDI,[0x10e9b7]
MOV AL,0x1
CALL 0x00102080
JMP 0x0010b43e
caseD_3:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0010aec0
JMP 0x0010b43e
caseD_4:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00102e60
JMP 0x0010b43e
caseD_5:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00109b50
JMP 0x0010b43e
caseD_6:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0010a590
JMP 0x0010b43e
caseD_7:
MOV EDI,dword ptr [RBP + -0x10]
CALL 0x0010aef0
MOV RSI,RAX
MOV RDX,qword ptr [RBP + -0x8]
LEA RDI,[0x10e9ba]
MOV AL,0x0
CALL 0x00102080
default:
ADD RSP,0x20
POP RBP
RET
|
void rak_value_print(int4 param_1,ulong param_2)
{
int8 uVar1;
char *pcVar2;
switch(param_1) {
case 0:
printf("nil");
break;
case 1:
pcVar2 = "false";
if ((param_2 & 1) != 0) {
pcVar2 = "true";
}
printf("%s",pcVar2);
break;
case 2:
printf("%g",param_2);
break;
case 3:
rak_string_print(param_2);
break;
case 4:
rak_array_print(param_2);
break;
case 5:
rak_range_print(param_2);
break;
case 6:
rak_record_print(param_2);
break;
case 7:
uVar1 = rak_type_to_cstr(param_1);
printf("<%s %p>",uVar1,param_2);
}
return;
}
| |
48,337 | rak_value_print | fabiosvm[P]rak/src/value.c | void rak_value_print(RakValue val)
{
switch (val.type)
{
case RAK_TYPE_NIL:
printf("nil");
break;
case RAK_TYPE_BOOL:
printf("%s", rak_as_bool(val) ? "true" : "false");
break;
case RAK_TYPE_NUMBER:
printf("%g", rak_as_number(val));
break;
case RAK_TYPE_STRING:
rak_string_print(rak_as_string(val));
break;
case RAK_TYPE_ARRAY:
rak_array_print(rak_as_array(val));
break;
case RAK_TYPE_RANGE:
rak_range_print(rak_as_range(val));
break;
case RAK_TYPE_RECORD:
rak_record_print(rak_as_record(val));
break;
case RAK_TYPE_CLOSURE:
printf("<%s %p>",rak_type_to_cstr(val.type), (void *) val.opaque.ptr);
break;
}
} | O2 | c | rak_value_print:
cmpl $0x7, %edi
ja 0x6d37
movq %rsi, %rdx
movl %edi, %eax
leaq 0x2ccb(%rip), %rcx # 0x9980
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x256e(%rip), %rdi # 0x9233
xorl %eax, %eax
jmp 0x2090
movq %rdx, %rdi
jmp 0x2883
movq %rdx, %xmm0
leaq 0x2d27(%rip), %rdi # 0x9a07
movb $0x1, %al
jmp 0x2090
movq %rdx, %rdi
jmp 0x6a2d
leaq 0x2d14(%rip), %rdi # 0x9a0a
leaq 0x2580(%rip), %rsi # 0x927d
xorl %eax, %eax
jmp 0x2090
leaq 0x2a76(%rip), %rax # 0x9781
leaq 0x2a62(%rip), %rsi # 0x9774
testb $0x1, %dl
cmovneq %rax, %rsi
leaq 0x2e14(%rip), %rdi # 0x9b34
xorl %eax, %eax
jmp 0x2090
movq %rdx, %rdi
jmp 0x6058
movq %rdx, %rdi
jmp 0x6583
retq
| rak_value_print:
cmp edi, 7; switch 8 cases
ja def_6CBC; jumptable 0000000000006CBC default case
mov rdx, rsi
mov eax, edi
lea rcx, jpt_6CBC
movsxd rax, ds:(jpt_6CBC - 9980h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_6CBE:
lea rdi, aIsNil+3; jumptable 0000000000006CBC case 0
xor eax, eax
jmp _printf
loc_6CCC:
mov rdi, rdx; jumptable 0000000000006CBC case 4
jmp rak_array_print
loc_6CD4:
movq xmm0, rdx; jumptable 0000000000006CBC case 2
lea rdi, aG; "%g"
mov al, 1
jmp _printf
loc_6CE7:
mov rdi, rdx; jumptable 0000000000006CBC case 3
jmp rak_string_print
loc_6CEF:
lea rdi, aSP; jumptable 0000000000006CBC case 7
lea rsi, aIsClosure+3; "closure"
xor eax, eax
jmp _printf
loc_6D04:
lea rax, aTrue; jumptable 0000000000006CBC case 1
lea rsi, aFalse; "false"
test dl, 1
cmovnz rsi, rax
lea rdi, aCannotAddStrin+16h; "%s"
xor eax, eax
jmp _printf
loc_6D27:
mov rdi, rdx; jumptable 0000000000006CBC case 5
jmp rak_range_print
loc_6D2F:
mov rdi, rdx; jumptable 0000000000006CBC case 6
jmp rak_record_print
def_6CBC:
retn; jumptable 0000000000006CBC default case
| long long rak_value_print(unsigned int a1, const void *a2)
{
char v2; // dl
long long result; // rax
const char *v4; // rsi
v2 = (char)a2;
result = a1;
switch ( a1 )
{
case 0u:
result = printf("nil");
break;
case 1u:
v4 = "false";
if ( (v2 & 1) != 0 )
v4 = "true";
result = printf("%s", v4);
break;
case 2u:
result = printf("%g", *(double *)&a2);
break;
case 3u:
result = rak_string_print((long long)a2);
break;
case 4u:
result = rak_array_print((long long)a2);
break;
case 5u:
result = rak_range_print((long long)a2);
break;
case 6u:
result = rak_record_print((long long)a2);
break;
case 7u:
result = printf("<%s %p>", "closure", a2);
break;
default:
return result;
}
return result;
}
| rak_value_print:
CMP EDI,0x7
JA 0x00106d37
MOV RDX,RSI
MOV EAX,EDI
LEA RCX,[0x109980]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_0:
LEA RDI,[0x109233]
XOR EAX,EAX
JMP 0x00102090
caseD_4:
MOV RDI,RDX
JMP 0x00102883
caseD_2:
MOVQ XMM0,RDX
LEA RDI,[0x109a07]
MOV AL,0x1
JMP 0x00102090
caseD_3:
MOV RDI,RDX
JMP 0x00106a2d
caseD_7:
LEA RDI,[0x109a0a]
LEA RSI,[0x10927d]
XOR EAX,EAX
JMP 0x00102090
caseD_1:
LEA RAX,[0x109781]
LEA RSI,[0x109774]
TEST DL,0x1
CMOVNZ RSI,RAX
LEA RDI,[0x109b34]
XOR EAX,EAX
JMP 0x00102090
caseD_5:
MOV RDI,RDX
JMP 0x00106058
caseD_6:
MOV RDI,RDX
JMP 0x00106583
default:
RET
|
void rak_value_print(int4 param_1,ulong param_2)
{
char *pcVar1;
switch(param_1) {
case 0:
printf("nil");
return;
case 1:
break;
case 2:
printf("%g",param_2);
return;
case 3:
rak_string_print(param_2);
return;
case 4:
rak_array_print(param_2);
return;
case 5:
rak_range_print(param_2);
return;
case 6:
rak_record_print(param_2);
return;
case 7:
printf("<%s %p>","closure");
return;
default:
return;
}
pcVar1 = "false";
if ((param_2 & 1) != 0) {
pcVar1 = "true";
}
printf("%s",pcVar1);
return;
}
| |
48,338 | my_mb_wc_sjis | eloqsql/strings/ctype-sjis.c | static int
my_mb_wc_sjis(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t *pwc, const uchar *s, const uchar *e){
int hi;
if (s >= e)
return MY_CS_TOOSMALL;
if ((hi= s[0]) < 0x80) /* ASCII: [00..7F] -> [U+0000..U+007F] */
{
*pwc= hi;
return 1;
}
/* JIS-X-0201 Half width Katakana: [A1..DF] -> [U+FF61..U+FF9F] */
if (hi >= 0xA1 && hi <= 0xDF)
{
*pwc= sjis_to_unicode[hi];
return 1;
}
if (s + 2 > e)
return MY_CS_TOOSMALL2;
/* JIS-X-0208 [81..9F,E0..FC][40..7E,80..FC] */
if (!(pwc[0]= sjis_to_unicode[(hi << 8) + s[1]]))
return (issjishead(hi) && issjistail(s[1])) ? -2 : MY_CS_ILSEQ;
return 2;
} | O3 | c | my_mb_wc_sjis:
pushq %rbp
movq %rsp, %rbp
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0x7000f
movzbl (%rdx), %edi
testb %dil, %dil
js 0x6fff5
movq %rdi, (%rsi)
jmp 0x7000a
leal 0x5f(%rdi), %eax
cmpb $0x3e, %al
ja 0x70011
leaq 0x16d3bd(%rip), %rax # 0x1dd3c0
movzwl (%rax,%rdi,2), %eax
movq %rax, (%rsi)
movl $0x1, %eax
popq %rbp
retq
leaq 0x2(%rdx), %r8
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %r8
ja 0x7000f
movzbl 0x1(%rdx), %eax
movl %edi, %ecx
shll $0x9, %ecx
leal (%rcx,%rax,2), %eax
leaq 0x16d38e(%rip), %rcx # 0x1dd3c0
movzwl (%rax,%rcx), %ecx
movq %rcx, (%rsi)
movl $0x2, %eax
testq %rcx, %rcx
jne 0x7000f
cmpb $-0x80, %dil
setne %al
cmpb $-0x60, %dil
setb %cl
andb %al, %cl
addb $0x20, %dil
cmpb $0x1d, %dil
setb %sil
orb %cl, %sil
xorl %eax, %eax
cmpb $0x1, %sil
jne 0x7000f
movb 0x1(%rdx), %cl
leal -0x40(%rcx), %edx
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
cmpb $0x3f, %dl
jb 0x7000f
movl $0x0, %eax
testb %cl, %cl
jns 0x7000f
xorl %eax, %eax
cmpb $-0x3, %cl
setae %al
leal -0x2(,%rax,2), %eax
jmp 0x7000f
| my_mb_wc_sjis:
push rbp
mov rbp, rsp
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short loc_7000F
movzx edi, byte ptr [rdx]
test dil, dil
js short loc_6FFF5
mov [rsi], rdi
jmp short loc_7000A
loc_6FFF5:
lea eax, [rdi+5Fh]
cmp al, 3Eh ; '>'
ja short loc_70011
lea rax, sjis_to_unicode
movzx eax, word ptr [rax+rdi*2]
mov [rsi], rax
loc_7000A:
mov eax, 1
loc_7000F:
pop rbp
retn
loc_70011:
lea r8, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp r8, rcx
ja short loc_7000F
movzx eax, byte ptr [rdx+1]
mov ecx, edi
shl ecx, 9
lea eax, [rcx+rax*2]
lea rcx, sjis_to_unicode
movzx ecx, word ptr [rax+rcx]
mov [rsi], rcx
mov eax, 2
test rcx, rcx
jnz short loc_7000F
cmp dil, 80h
setnz al
cmp dil, 0A0h
setb cl
and cl, al
add dil, 20h ; ' '
cmp dil, 1Dh
setb sil
or sil, cl
xor eax, eax
cmp sil, 1
jnz short loc_7000F
mov cl, [rdx+1]
lea edx, [rcx-40h]
mov eax, 0FFFFFFFEh
cmp dl, 3Fh ; '?'
jb short loc_7000F
mov eax, 0
test cl, cl
jns short loc_7000F
xor eax, eax
cmp cl, 0FDh
setnb al
lea eax, ds:0FFFFFFFFFFFFFFFEh[rax*2]
jmp loc_7000F
| long long my_mb_wc_sjis(long long a1, _QWORD *a2, unsigned __int8 *a3, unsigned long long a4)
{
long long result; // rax
long long v5; // rdi
long long v6; // rcx
char v7; // cl
result = 4294967195LL;
if ( (unsigned long long)a3 < a4 )
{
v5 = *a3;
if ( (v5 & 0x80u) == 0LL )
{
*a2 = v5;
return 1LL;
}
if ( (unsigned __int8)(v5 + 95) <= 0x3Eu )
{
*a2 = sjis_to_unicode[v5];
return 1LL;
}
result = 4294967194LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
v6 = sjis_to_unicode[256 * (_DWORD)v5 + a3[1]];
*a2 = v6;
result = 2LL;
if ( !v6 )
{
result = 0LL;
if ( (_BYTE)v5 != 0x80 && (unsigned __int8)v5 < 0xA0u || (unsigned __int8)(v5 + 32) < 0x1Du )
{
v7 = a3[1];
result = 4294967294LL;
if ( (unsigned __int8)(v7 - 64) >= 0x3Fu )
{
result = 0LL;
if ( v7 < 0 )
return 2 * (unsigned int)((unsigned __int8)v7 >= 0xFDu) - 2;
}
}
}
}
}
return result;
}
| my_mb_wc_sjis:
PUSH RBP
MOV RBP,RSP
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x0017000f
MOVZX EDI,byte ptr [RDX]
TEST DIL,DIL
JS 0x0016fff5
MOV qword ptr [RSI],RDI
JMP 0x0017000a
LAB_0016fff5:
LEA EAX,[RDI + 0x5f]
CMP AL,0x3e
JA 0x00170011
LEA RAX,[0x2dd3c0]
MOVZX EAX,word ptr [RAX + RDI*0x2]
MOV qword ptr [RSI],RAX
LAB_0017000a:
MOV EAX,0x1
LAB_0017000f:
POP RBP
RET
LAB_00170011:
LEA R8,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP R8,RCX
JA 0x0017000f
MOVZX EAX,byte ptr [RDX + 0x1]
MOV ECX,EDI
SHL ECX,0x9
LEA EAX,[RCX + RAX*0x2]
LEA RCX,[0x2dd3c0]
MOVZX ECX,word ptr [RAX + RCX*0x1]
MOV qword ptr [RSI],RCX
MOV EAX,0x2
TEST RCX,RCX
JNZ 0x0017000f
CMP DIL,0x80
SETNZ AL
CMP DIL,0xa0
SETC CL
AND CL,AL
ADD DIL,0x20
CMP DIL,0x1d
SETC SIL
OR SIL,CL
XOR EAX,EAX
CMP SIL,0x1
JNZ 0x0017000f
MOV CL,byte ptr [RDX + 0x1]
LEA EDX,[RCX + -0x40]
MOV EAX,0xfffffffe
CMP DL,0x3f
JC 0x0017000f
MOV EAX,0x0
TEST CL,CL
JNS 0x0017000f
XOR EAX,EAX
CMP CL,0xfd
SETNC AL
LEA EAX,[-0x2 + RAX*0x2]
JMP 0x0017000f
|
int my_mb_wc_sjis(int8 param_1,ulong *param_2,byte *param_3,byte *param_4)
{
byte bVar1;
ushort uVar2;
int iVar3;
iVar3 = -0x65;
if (param_3 < param_4) {
bVar1 = *param_3;
if ((char)bVar1 < '\0') {
if (0x3e < (byte)(bVar1 + 0x5f)) {
if (param_4 < param_3 + 2) {
return -0x66;
}
uVar2 = *(ushort *)(sjis_to_unicode + ((uint)bVar1 * 0x200 + (uint)param_3[1] * 2));
*param_2 = (ulong)uVar2;
if ((ulong)uVar2 != 0) {
return 2;
}
if (0x1c < (byte)(bVar1 + 0x20) && (0x9f < bVar1 || bVar1 == 0x80)) {
return 0;
}
bVar1 = param_3[1];
if ((byte)(bVar1 - 0x40) < 0x3f) {
return -2;
}
if (-1 < (char)bVar1) {
return 0;
}
return (uint)(0xfc < bVar1) * 2 + -2;
}
*param_2 = (ulong)*(ushort *)(sjis_to_unicode + (ulong)bVar1 * 2);
}
else {
*param_2 = (ulong)bVar1;
}
iVar3 = 1;
}
return iVar3;
}
| |
48,339 | my_strnncoll_tis620 | eloqsql/strings/ctype-tis620.c | static
int my_strnncoll_tis620(CHARSET_INFO *cs __attribute__((unused)),
const uchar *s1, size_t len1,
const uchar *s2, size_t len2,
my_bool s2_is_prefix)
{
uchar buf[80] ;
uchar *tc1, *tc2;
int i;
if (s2_is_prefix && len1 > len2)
len1= len2;
tc1= buf;
if ((len1 + len2 +2) > (int) sizeof(buf))
tc1= (uchar*) my_malloc(PSI_INSTRUMENT_ME, len1+len2+2, MYF(MY_FAE));
tc2= tc1 + len1+1;
memcpy((char*) tc1, (char*) s1, len1);
tc1[len1]= 0; /* if length(s1)> len1, need to put 'end of string' */
memcpy((char *)tc2, (char *)s2, len2);
tc2[len2]= 0; /* put end of string */
thai2sortable(tc1, len1);
thai2sortable(tc2, len2);
i= strcmp((char*)tc1, (char*)tc2);
if (tc1 != buf)
my_free(tc1);
return i;
} | O0 | c | my_strnncoll_tis620:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movb %r9b, %al
movq %fs:0x28, %r9
movq %r9, -0x8(%rbp)
movq %rdi, -0x68(%rbp)
movq %rsi, -0x70(%rbp)
movq %rdx, -0x78(%rbp)
movq %rcx, -0x80(%rbp)
movq %r8, -0x88(%rbp)
movb %al, -0x89(%rbp)
movsbl -0x89(%rbp), %eax
cmpl $0x0, %eax
je 0xfc36c
movq -0x78(%rbp), %rax
cmpq -0x88(%rbp), %rax
jbe 0xfc36c
movq -0x88(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x60(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x78(%rbp), %rax
addq -0x88(%rbp), %rax
addq $0x2, %rax
cmpq $0x50, %rax
jbe 0xfc3ae
movq -0x78(%rbp), %rsi
addq -0x88(%rbp), %rsi
addq $0x2, %rsi
xorl %edi, %edi
movl $0x8, %edx
callq 0xe1160
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rax
addq -0x78(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xa0(%rbp)
movq -0x98(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq -0x78(%rbp), %rdx
callq 0x3a0b0
movq -0x98(%rbp), %rax
movq -0x78(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0xa0(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x88(%rbp), %rdx
callq 0x3a0b0
movq -0xa0(%rbp), %rax
movq -0x88(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x98(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0xfc890
movq -0xa0(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0xfc890
movq -0x98(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x3a880
movl %eax, -0xa4(%rbp)
movq -0x98(%rbp), %rax
leaq -0x60(%rbp), %rcx
cmpq %rcx, %rax
je 0xfc468
movq -0x98(%rbp), %rdi
callq 0xe14e0
movl -0xa4(%rbp), %eax
movl %eax, -0xa8(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xfc495
movl -0xa8(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
callq 0x3a2a0
nopw (%rax,%rax)
| my_strnncoll_tis620:
push rbp
mov rbp, rsp
sub rsp, 0B0h
mov al, r9b
mov r9, fs:28h
mov [rbp+var_8], r9
mov [rbp+var_68], rdi
mov [rbp+var_70], rsi
mov [rbp+var_78], rdx
mov [rbp+var_80], rcx
mov [rbp+var_88], r8
mov [rbp+var_89], al
movsx eax, [rbp+var_89]
cmp eax, 0
jz short loc_FC36C
mov rax, [rbp+var_78]
cmp rax, [rbp+var_88]
jbe short loc_FC36C
mov rax, [rbp+var_88]
mov [rbp+var_78], rax
loc_FC36C:
lea rax, [rbp+var_60]
mov [rbp+var_98], rax
mov rax, [rbp+var_78]
add rax, [rbp+var_88]
add rax, 2
cmp rax, 50h ; 'P'
jbe short loc_FC3AE
mov rsi, [rbp+var_78]
add rsi, [rbp+var_88]
add rsi, 2
xor edi, edi
mov edx, 8
call my_malloc
mov [rbp+var_98], rax
loc_FC3AE:
mov rax, [rbp+var_98]
add rax, [rbp+var_78]
add rax, 1
mov [rbp+var_A0], rax
mov rdi, [rbp+var_98]
mov rsi, [rbp+var_70]
mov rdx, [rbp+var_78]
call _memcpy
mov rax, [rbp+var_98]
mov rcx, [rbp+var_78]
mov byte ptr [rax+rcx], 0
mov rdi, [rbp+var_A0]
mov rsi, [rbp+var_80]
mov rdx, [rbp+var_88]
call _memcpy
mov rax, [rbp+var_A0]
mov rcx, [rbp+var_88]
mov byte ptr [rax+rcx], 0
mov rdi, [rbp+var_98]
mov rsi, [rbp+var_78]
call thai2sortable
mov rdi, [rbp+var_A0]
mov rsi, [rbp+var_88]
call thai2sortable
mov rdi, [rbp+var_98]
mov rsi, [rbp+var_A0]
call _strcmp
mov [rbp+var_A4], eax
mov rax, [rbp+var_98]
lea rcx, [rbp+var_60]
cmp rax, rcx
jz short loc_FC468
mov rdi, [rbp+var_98]
call my_free
loc_FC468:
mov eax, [rbp+var_A4]
mov [rbp+var_A8], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_FC495
mov eax, [rbp+var_A8]
add rsp, 0B0h
pop rbp
retn
loc_FC495:
call ___stack_chk_fail
| long long my_strnncoll_tis620(
long long a1,
long long a2,
unsigned long long a3,
long long a4,
unsigned long long a5,
char a6)
{
unsigned int v7; // [rsp+Ch] [rbp-A4h]
long long v8; // [rsp+10h] [rbp-A0h]
_BYTE *v9; // [rsp+18h] [rbp-98h]
unsigned long long v12; // [rsp+38h] [rbp-78h]
_BYTE v13[88]; // [rsp+50h] [rbp-60h] BYREF
unsigned long long v14; // [rsp+A8h] [rbp-8h]
v14 = __readfsqword(0x28u);
v12 = a3;
if ( a6 && a3 > a5 )
v12 = a5;
v9 = v13;
if ( a5 + v12 + 2 > 0x50 )
v9 = (_BYTE *)my_malloc(0, a5 + v12 + 2, 8);
v8 = (long long)&v9[v12 + 1];
memcpy(v9, a2, v12);
v9[v12] = 0;
memcpy(v8, a4, a5);
*(_BYTE *)(v8 + a5) = 0;
thai2sortable(v9, v12);
thai2sortable(v8, a5);
v7 = strcmp(v9, v8);
if ( v9 != v13 )
my_free((long long)v9);
return v7;
}
| my_strnncoll_tis620:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xb0
MOV AL,R9B
MOV R9,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],R9
MOV qword ptr [RBP + -0x68],RDI
MOV qword ptr [RBP + -0x70],RSI
MOV qword ptr [RBP + -0x78],RDX
MOV qword ptr [RBP + -0x80],RCX
MOV qword ptr [RBP + -0x88],R8
MOV byte ptr [RBP + -0x89],AL
MOVSX EAX,byte ptr [RBP + -0x89]
CMP EAX,0x0
JZ 0x001fc36c
MOV RAX,qword ptr [RBP + -0x78]
CMP RAX,qword ptr [RBP + -0x88]
JBE 0x001fc36c
MOV RAX,qword ptr [RBP + -0x88]
MOV qword ptr [RBP + -0x78],RAX
LAB_001fc36c:
LEA RAX,[RBP + -0x60]
MOV qword ptr [RBP + -0x98],RAX
MOV RAX,qword ptr [RBP + -0x78]
ADD RAX,qword ptr [RBP + -0x88]
ADD RAX,0x2
CMP RAX,0x50
JBE 0x001fc3ae
MOV RSI,qword ptr [RBP + -0x78]
ADD RSI,qword ptr [RBP + -0x88]
ADD RSI,0x2
XOR EDI,EDI
MOV EDX,0x8
CALL 0x001e1160
MOV qword ptr [RBP + -0x98],RAX
LAB_001fc3ae:
MOV RAX,qword ptr [RBP + -0x98]
ADD RAX,qword ptr [RBP + -0x78]
ADD RAX,0x1
MOV qword ptr [RBP + -0xa0],RAX
MOV RDI,qword ptr [RBP + -0x98]
MOV RSI,qword ptr [RBP + -0x70]
MOV RDX,qword ptr [RBP + -0x78]
CALL 0x0013a0b0
MOV RAX,qword ptr [RBP + -0x98]
MOV RCX,qword ptr [RBP + -0x78]
MOV byte ptr [RAX + RCX*0x1],0x0
MOV RDI,qword ptr [RBP + -0xa0]
MOV RSI,qword ptr [RBP + -0x80]
MOV RDX,qword ptr [RBP + -0x88]
CALL 0x0013a0b0
MOV RAX,qword ptr [RBP + -0xa0]
MOV RCX,qword ptr [RBP + -0x88]
MOV byte ptr [RAX + RCX*0x1],0x0
MOV RDI,qword ptr [RBP + -0x98]
MOV RSI,qword ptr [RBP + -0x78]
CALL 0x001fc890
MOV RDI,qword ptr [RBP + -0xa0]
MOV RSI,qword ptr [RBP + -0x88]
CALL 0x001fc890
MOV RDI,qword ptr [RBP + -0x98]
MOV RSI,qword ptr [RBP + -0xa0]
CALL 0x0013a880
MOV dword ptr [RBP + -0xa4],EAX
MOV RAX,qword ptr [RBP + -0x98]
LEA RCX,[RBP + -0x60]
CMP RAX,RCX
JZ 0x001fc468
MOV RDI,qword ptr [RBP + -0x98]
CALL 0x001e14e0
LAB_001fc468:
MOV EAX,dword ptr [RBP + -0xa4]
MOV dword ptr [RBP + -0xa8],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001fc495
MOV EAX,dword ptr [RBP + -0xa8]
ADD RSP,0xb0
POP RBP
RET
LAB_001fc495:
CALL 0x0013a2a0
|
int my_strnncoll_tis620(int8 param_1,void *param_2,ulong param_3,void *param_4,ulong param_5,
char param_6)
{
int iVar1;
char *__s2;
long in_FS_OFFSET;
char *local_a0;
size_t local_80;
char local_68 [88];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_80 = param_3;
if ((param_6 != '\0') && (param_5 < param_3)) {
local_80 = param_5;
}
local_a0 = local_68;
if (0x50 < local_80 + param_5 + 2) {
local_a0 = (char *)my_malloc(0,local_80 + param_5 + 2,8);
}
__s2 = local_a0 + local_80 + 1;
memcpy(local_a0,param_2,local_80);
local_a0[local_80] = '\0';
memcpy(__s2,param_4,param_5);
__s2[param_5] = '\0';
thai2sortable(local_a0,local_80);
thai2sortable(__s2,param_5);
iVar1 = strcmp(local_a0,__s2);
if (local_a0 != local_68) {
my_free(local_a0);
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return iVar1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
48,340 | my_strnncoll_tis620 | eloqsql/strings/ctype-tis620.c | static
int my_strnncoll_tis620(CHARSET_INFO *cs __attribute__((unused)),
const uchar *s1, size_t len1,
const uchar *s2, size_t len2,
my_bool s2_is_prefix)
{
uchar buf[80] ;
uchar *tc1, *tc2;
int i;
if (s2_is_prefix && len1 > len2)
len1= len2;
tc1= buf;
if ((len1 + len2 +2) > (int) sizeof(buf))
tc1= (uchar*) my_malloc(PSI_INSTRUMENT_ME, len1+len2+2, MYF(MY_FAE));
tc2= tc1 + len1+1;
memcpy((char*) tc1, (char*) s1, len1);
tc1[len1]= 0; /* if length(s1)> len1, need to put 'end of string' */
memcpy((char *)tc2, (char *)s2, len2);
tc2[len2]= 0; /* put end of string */
thai2sortable(tc1, len1);
thai2sortable(tc2, len2);
i= strcmp((char*)tc1, (char*)tc2);
if (tc1 != buf)
my_free(tc1);
return i;
} | O3 | c | my_strnncoll_tis620:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %rbx
movq %rcx, -0x88(%rbp)
movq %rsi, %rcx
movq %fs:0x28, %rax
cmpq %r8, %rdx
movq %r8, %r15
cmovbq %rdx, %r15
movq %rax, -0x30(%rbp)
testb %r9b, %r9b
cmoveq %rdx, %r15
leaq (%r8,%r15), %rsi
addq $0x2, %rsi
leaq -0x80(%rbp), %r14
cmpq $0x51, %rsi
jb 0xbda8a
movl $0x8, %edx
xorl %edi, %edi
movq %rcx, %r14
callq 0xaca09
movq %r14, %rcx
movq %rax, %r14
leaq (%r14,%r15), %r13
leaq (%r14,%r15), %r12
incq %r12
movq %r14, %rdi
movq %rcx, %rsi
movq %r15, %rdx
callq 0x390a0
xorl %eax, %eax
movb %al, -0x1(%r12)
movq %r12, %rdi
movq -0x88(%rbp), %rsi
movq %rbx, %rdx
callq 0x390a0
xorl %eax, %eax
movb %al, 0x1(%rbx,%r13)
movq %r14, %rdi
movq %r15, %rsi
callq 0xbdd17
movq %r12, %rdi
movq %rbx, %rsi
callq 0xbdd17
movq %r14, %rdi
movq %r12, %rsi
callq 0x39890
movl %eax, %ebx
leaq -0x80(%rbp), %rax
cmpq %rax, %r14
je 0xbdaf7
movq %r14, %rdi
callq 0xacc36
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0xbdb17
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x39290
| my_strnncoll_tis620:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov rbx, r8
mov [rbp+var_88], rcx
mov rcx, rsi
mov rax, fs:28h
cmp rdx, r8
mov r15, r8
cmovb r15, rdx
mov [rbp+var_30], rax
test r9b, r9b
cmovz r15, rdx
lea rsi, [r8+r15]
add rsi, 2
lea r14, [rbp+var_80]
cmp rsi, 51h ; 'Q'
jb short loc_BDA8A
mov edx, 8
xor edi, edi
mov r14, rcx
call my_malloc
mov rcx, r14
mov r14, rax
loc_BDA8A:
lea r13, [r14+r15]
lea r12, [r14+r15]
inc r12
mov rdi, r14
mov rsi, rcx
mov rdx, r15
call _memcpy
xor eax, eax
mov [r12-1], al
mov rdi, r12
mov rsi, [rbp+var_88]
mov rdx, rbx
call _memcpy
xor eax, eax
mov [rbx+r13+1], al
mov rdi, r14
mov rsi, r15
call thai2sortable
mov rdi, r12
mov rsi, rbx
call thai2sortable
mov rdi, r14
mov rsi, r12
call _strcmp
mov ebx, eax
lea rax, [rbp+var_80]
cmp r14, rax
jz short loc_BDAF7
mov rdi, r14
call my_free
loc_BDAF7:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_BDB17
mov eax, ebx
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_BDB17:
call ___stack_chk_fail
| long long my_strnncoll_tis620(
long long a1,
long long a2,
unsigned long long a3,
long long a4,
unsigned long long a5,
char a6)
{
unsigned long long v8; // rax
unsigned long long v9; // r15
unsigned long long v10; // rsi
_BYTE *v11; // r14
long long v12; // r14
long long v13; // rax
unsigned int v14; // ebx
_BYTE v17[80]; // [rsp+10h] [rbp-80h] BYREF
unsigned long long v18; // [rsp+60h] [rbp-30h]
v8 = __readfsqword(0x28u);
v9 = a5;
if ( a3 < a5 )
v9 = a3;
v18 = v8;
if ( !a6 )
v9 = a3;
v10 = a5 + v9 + 2;
v11 = v17;
if ( v10 >= 0x51 )
{
v12 = a2;
v13 = my_malloc(0, v10, 8);
a2 = v12;
v11 = (_BYTE *)v13;
}
memcpy(v11, a2, v9);
v11[v9] = 0;
memcpy(&v11[v9 + 1], a4, a5);
v11[v9 + 1 + a5] = 0;
thai2sortable(v11, v9);
thai2sortable(&v11[v9 + 1], a5);
v14 = strcmp(v11, &v11[v9 + 1]);
if ( v11 != v17 )
my_free((long long)v11);
return v14;
}
| my_strnncoll_tis620:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV RBX,R8
MOV qword ptr [RBP + -0x88],RCX
MOV RCX,RSI
MOV RAX,qword ptr FS:[0x28]
CMP RDX,R8
MOV R15,R8
CMOVC R15,RDX
MOV qword ptr [RBP + -0x30],RAX
TEST R9B,R9B
CMOVZ R15,RDX
LEA RSI,[R8 + R15*0x1]
ADD RSI,0x2
LEA R14,[RBP + -0x80]
CMP RSI,0x51
JC 0x001bda8a
MOV EDX,0x8
XOR EDI,EDI
MOV R14,RCX
CALL 0x001aca09
MOV RCX,R14
MOV R14,RAX
LAB_001bda8a:
LEA R13,[R14 + R15*0x1]
LEA R12,[R14 + R15*0x1]
INC R12
MOV RDI,R14
MOV RSI,RCX
MOV RDX,R15
CALL 0x001390a0
XOR EAX,EAX
MOV byte ptr [R12 + -0x1],AL
MOV RDI,R12
MOV RSI,qword ptr [RBP + -0x88]
MOV RDX,RBX
CALL 0x001390a0
XOR EAX,EAX
MOV byte ptr [RBX + R13*0x1 + 0x1],AL
MOV RDI,R14
MOV RSI,R15
CALL 0x001bdd17
MOV RDI,R12
MOV RSI,RBX
CALL 0x001bdd17
MOV RDI,R14
MOV RSI,R12
CALL 0x00139890
MOV EBX,EAX
LEA RAX,[RBP + -0x80]
CMP R14,RAX
JZ 0x001bdaf7
MOV RDI,R14
CALL 0x001acc36
LAB_001bdaf7:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001bdb17
MOV EAX,EBX
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001bdb17:
CALL 0x00139290
|
int my_strnncoll_tis620(int8 param_1,void *param_2,ulong param_3,void *param_4,ulong param_5,
char param_6)
{
int iVar1;
char *__s1;
ulong uVar2;
char *__s2;
ulong __n;
long in_FS_OFFSET;
char local_88 [80];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
__n = param_5;
if (param_3 < param_5) {
__n = param_3;
}
if (param_6 == '\0') {
__n = param_3;
}
uVar2 = param_5 + __n + 2;
__s1 = local_88;
if (0x50 < uVar2) {
__s1 = (char *)my_malloc(0,uVar2,8);
}
__s2 = __s1 + __n + 1;
memcpy(__s1,param_2,__n);
__s1[__n] = '\0';
memcpy(__s2,param_4,param_5);
__s1[param_5 + 1 + __n] = '\0';
thai2sortable(__s1,__n);
thai2sortable(__s2,param_5);
iVar1 = strcmp(__s1,__s2);
if (__s1 != local_88) {
my_free(__s1);
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return iVar1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
48,341 | worker_func | bluesky950520[P]quickjs/quickjs-libc.c | static void *worker_func(void *opaque)
{
WorkerFuncArgs *args = opaque;
JSRuntime *rt;
JSThreadState *ts;
JSContext *ctx;
JSValue val;
rt = JS_NewRuntime();
if (rt == NULL) {
fprintf(stderr, "JS_NewRuntime failure");
exit(1);
}
js_std_init_handlers(rt);
JS_SetModuleLoaderFunc(rt, NULL, js_module_loader, NULL);
/* set the pipe to communicate with the parent */
ts = js_get_thread_state(rt);
ts->recv_pipe = args->recv_pipe;
ts->send_pipe = args->send_pipe;
/* function pointer to avoid linking the whole JS_NewContext() if
not needed */
ctx = js_worker_new_context_func(rt);
if (ctx == NULL) {
fprintf(stderr, "JS_NewContext failure");
}
JS_SetCanBlock(rt, TRUE);
js_std_add_helpers(ctx, -1, NULL);
val = JS_LoadModule(ctx, args->basename, args->filename);
free(args->filename);
free(args->basename);
free(args);
val = js_std_await(ctx, val);
if (JS_IsException(val))
js_std_dump_error(ctx);
JS_FreeValue(ctx, val);
JS_FreeValue(ctx, js_std_loop(ctx));
JS_FreeContext(ctx);
js_std_free_handlers(rt);
JS_FreeRuntime(rt);
return NULL;
} | O0 | c | worker_func:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x68(%rsp)
callq 0x29ab0
movq %rax, 0x60(%rsp)
cmpq $0x0, 0x60(%rsp)
jne 0x1dc17
movq 0x11f3fc(%rip), %rax # 0x13cff8
movq (%rax), %rdi
leaq 0xf162b(%rip), %rsi # 0x10f231
movb $0x0, %al
callq 0xe5a0
movl $0x1, %edi
callq 0xe920
movq 0x60(%rsp), %rdi
callq 0x174c0
movq 0x60(%rsp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x7531(%rip), %rdx # 0x16700
movq %rcx, %rsi
callq 0x4fdf0
movq 0x60(%rsp), %rdi
callq 0x178c0
movq %rax, 0x58(%rsp)
movq 0x68(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x58(%rsp), %rax
movq %rcx, 0x68(%rax)
movq 0x68(%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x58(%rsp), %rax
movq %rcx, 0x70(%rax)
movq 0x11ff55(%rip), %rax # 0x13dbc8
movq 0x60(%rsp), %rdi
callq *%rax
movq %rax, 0x50(%rsp)
cmpq $0x0, 0x50(%rsp)
jne 0x1dc9f
movq 0x11f36a(%rip), %rax # 0x13cff8
movq (%rax), %rdi
leaq 0xf15af(%rip), %rsi # 0x10f247
movb $0x0, %al
callq 0xe5a0
movq 0x60(%rsp), %rdi
movl $0x1, %esi
callq 0x29bb0
movq 0x50(%rsp), %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x17010
movq 0x50(%rsp), %rdi
movq 0x68(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x68(%rsp), %rax
movq (%rax), %rdx
callq 0x506b0
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x68(%rsp), %rax
movq (%rax), %rdi
callq 0xe060
movq 0x68(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xe060
movq 0x68(%rsp), %rdi
callq 0xe060
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x18570
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x16680
cmpl $0x0, %eax
je 0x1dd6f
movq 0x50(%rsp), %rdi
callq 0x17c40
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x29f80
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rdi
callq 0x17d00
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x29f80
movq 0x50(%rsp), %rdi
callq 0x2de40
movq 0x60(%rsp), %rdi
callq 0x17760
movq 0x60(%rsp), %rdi
callq 0x29720
xorl %eax, %eax
addq $0x78, %rsp
retq
nopw (%rax,%rax)
| worker_func:
sub rsp, 78h
mov [rsp+78h+var_8], rdi
mov rax, [rsp+78h+var_8]
mov [rsp+78h+var_10], rax
call JS_NewRuntime
mov [rsp+78h+var_18], rax
cmp [rsp+78h+var_18], 0
jnz short loc_1DC17
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aJsNewruntimeFa; "JS_NewRuntime failure"
mov al, 0
call _fprintf
mov edi, 1
call _exit
loc_1DC17:
mov rdi, [rsp+78h+var_18]
call js_std_init_handlers
mov rdi, [rsp+78h+var_18]
xor eax, eax
mov ecx, eax
lea rdx, js_module_loader
mov rsi, rcx
call JS_SetModuleLoaderFunc
mov rdi, [rsp+78h+var_18]
call js_get_thread_state
mov [rsp+78h+var_20], rax
mov rax, [rsp+78h+var_10]
mov rcx, [rax+10h]
mov rax, [rsp+78h+var_20]
mov [rax+68h], rcx
mov rax, [rsp+78h+var_10]
mov rcx, [rax+18h]
mov rax, [rsp+78h+var_20]
mov [rax+70h], rcx
mov rax, cs:js_worker_new_context_func
mov rdi, [rsp+78h+var_18]
call rax ; js_worker_new_context_func
mov [rsp+78h+var_28], rax
cmp [rsp+78h+var_28], 0
jnz short loc_1DC9F
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aJsNewcontextFa; "JS_NewContext failure"
mov al, 0
call _fprintf
loc_1DC9F:
mov rdi, [rsp+78h+var_18]
mov esi, 1
call JS_SetCanBlock
mov rdi, [rsp+78h+var_28]
mov esi, 0FFFFFFFFh
xor eax, eax
mov edx, eax
call js_std_add_helpers
mov rdi, [rsp+78h+var_28]
mov rax, [rsp+78h+var_10]
mov rsi, [rax+8]
mov rax, [rsp+78h+var_10]
mov rdx, [rax]
call JS_LoadModule
mov [rsp+78h+var_48], rax
mov [rsp+78h+var_40], rdx
mov rax, [rsp+78h+var_48]
mov [rsp+78h+var_38], rax
mov rax, [rsp+78h+var_40]
mov [rsp+78h+var_30], rax
mov rax, [rsp+78h+var_10]
mov rdi, [rax]
call _free
mov rax, [rsp+78h+var_10]
mov rdi, [rax+8]
call _free
mov rdi, [rsp+78h+var_10]
call _free
mov rdi, [rsp+78h+var_28]
mov rsi, [rsp+78h+var_38]
mov rdx, [rsp+78h+var_30]
call js_std_await
mov [rsp+78h+var_58], rax
mov [rsp+78h+var_50], rdx
mov rax, [rsp+78h+var_58]
mov [rsp+78h+var_38], rax
mov rax, [rsp+78h+var_50]
mov [rsp+78h+var_30], rax
mov rdi, [rsp+78h+var_38]
mov rsi, [rsp+78h+var_30]
call JS_IsException_0
cmp eax, 0
jz short loc_1DD6F
mov rdi, [rsp+78h+var_28]
call js_std_dump_error
loc_1DD6F:
mov rdi, [rsp+78h+var_28]
mov rsi, [rsp+78h+var_38]
mov rdx, [rsp+78h+var_30]
call JS_FreeValue
mov rax, [rsp+78h+var_28]
mov [rsp+78h+var_70], rax
mov rdi, [rsp+78h+var_28]
call js_std_loop
mov rdi, [rsp+78h+var_70]
mov [rsp+78h+var_68], rax
mov [rsp+78h+var_60], rdx
mov rsi, [rsp+78h+var_68]
mov rdx, [rsp+78h+var_60]
call JS_FreeValue
mov rdi, [rsp+78h+var_28]
call JS_FreeContext
mov rdi, [rsp+78h+var_18]
call js_std_free_handlers
mov rdi, [rsp+78h+var_18]
call JS_FreeRuntime
xor eax, eax
add rsp, 78h
retn
| long long worker_func(_QWORD *a1)
{
int v1; // edx
int v2; // ecx
int v3; // r8d
int v4; // r9d
long long v5; // rdx
long long v6; // rdx
long long v7; // rdx
long long v9; // [rsp+10h] [rbp-68h]
long long v10; // [rsp+20h] [rbp-58h]
long long Module; // [rsp+30h] [rbp-48h]
long long v12; // [rsp+48h] [rbp-30h]
long long v13; // [rsp+48h] [rbp-30h]
long long v14; // [rsp+50h] [rbp-28h]
long long thread_state; // [rsp+58h] [rbp-20h]
long long v16; // [rsp+60h] [rbp-18h]
v16 = JS_NewRuntime();
if ( !v16 )
{
fprintf(stderr, "JS_NewRuntime failure");
exit(1LL);
}
js_std_init_handlers(v16);
JS_SetModuleLoaderFunc(v16, 0LL, js_module_loader, 0LL);
thread_state = js_get_thread_state(v16, 0LL, v1, v2, v3, v4);
*(_QWORD *)(thread_state + 104) = a1[2];
*(_QWORD *)(thread_state + 112) = a1[3];
v14 = js_worker_new_context_func(v16);
if ( !v14 )
fprintf(stderr, "JS_NewContext failure");
JS_SetCanBlock(v16, 1LL);
js_std_add_helpers(v14, -1, 0LL);
Module = JS_LoadModule(v14, a1[1], *a1);
v12 = v5;
free(*a1);
free(a1[1]);
free(a1);
v10 = js_std_await(v14, Module, v12);
v13 = v6;
if ( JS_IsException_0(v10, v6) )
js_std_dump_error(v14);
JS_FreeValue(v14, v10, v13);
v9 = js_std_loop(v14, v10);
JS_FreeValue(v14, v9, v7);
JS_FreeContext(v14);
js_std_free_handlers(v16);
JS_FreeRuntime(v16);
return 0LL;
}
| worker_func:
SUB RSP,0x78
MOV qword ptr [RSP + 0x70],RDI
MOV RAX,qword ptr [RSP + 0x70]
MOV qword ptr [RSP + 0x68],RAX
CALL 0x00129ab0
MOV qword ptr [RSP + 0x60],RAX
CMP qword ptr [RSP + 0x60],0x0
JNZ 0x0011dc17
MOV RAX,qword ptr [0x0023cff8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x20f231]
MOV AL,0x0
CALL 0x0010e5a0
MOV EDI,0x1
CALL 0x0010e920
LAB_0011dc17:
MOV RDI,qword ptr [RSP + 0x60]
CALL 0x001174c0
MOV RDI,qword ptr [RSP + 0x60]
XOR EAX,EAX
MOV ECX,EAX
LEA RDX,[0x116700]
MOV RSI,RCX
CALL 0x0014fdf0
MOV RDI,qword ptr [RSP + 0x60]
CALL 0x001178c0
MOV qword ptr [RSP + 0x58],RAX
MOV RAX,qword ptr [RSP + 0x68]
MOV RCX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RAX + 0x68],RCX
MOV RAX,qword ptr [RSP + 0x68]
MOV RCX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RAX + 0x70],RCX
MOV RAX,qword ptr [0x0023dbc8]
MOV RDI,qword ptr [RSP + 0x60]
CALL RAX
MOV qword ptr [RSP + 0x50],RAX
CMP qword ptr [RSP + 0x50],0x0
JNZ 0x0011dc9f
MOV RAX,qword ptr [0x0023cff8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x20f247]
MOV AL,0x0
CALL 0x0010e5a0
LAB_0011dc9f:
MOV RDI,qword ptr [RSP + 0x60]
MOV ESI,0x1
CALL 0x00129bb0
MOV RDI,qword ptr [RSP + 0x50]
MOV ESI,0xffffffff
XOR EAX,EAX
MOV EDX,EAX
CALL 0x00117010
MOV RDI,qword ptr [RSP + 0x50]
MOV RAX,qword ptr [RSP + 0x68]
MOV RSI,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RSP + 0x68]
MOV RDX,qword ptr [RAX]
CALL 0x001506b0
MOV qword ptr [RSP + 0x30],RAX
MOV qword ptr [RSP + 0x38],RDX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x40],RAX
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x48],RAX
MOV RAX,qword ptr [RSP + 0x68]
MOV RDI,qword ptr [RAX]
CALL 0x0010e060
MOV RAX,qword ptr [RSP + 0x68]
MOV RDI,qword ptr [RAX + 0x8]
CALL 0x0010e060
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x0010e060
MOV RDI,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RSP + 0x40]
MOV RDX,qword ptr [RSP + 0x48]
CALL 0x00118570
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x28],RDX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x40],RAX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x48],RAX
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x48]
CALL 0x00116680
CMP EAX,0x0
JZ 0x0011dd6f
MOV RDI,qword ptr [RSP + 0x50]
CALL 0x00117c40
LAB_0011dd6f:
MOV RDI,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RSP + 0x40]
MOV RDX,qword ptr [RSP + 0x48]
CALL 0x00129f80
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x50]
CALL 0x00117d00
MOV RDI,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x18],RDX
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x18]
CALL 0x00129f80
MOV RDI,qword ptr [RSP + 0x50]
CALL 0x0012de40
MOV RDI,qword ptr [RSP + 0x60]
CALL 0x00117760
MOV RDI,qword ptr [RSP + 0x60]
CALL 0x00129720
XOR EAX,EAX
ADD RSP,0x78
RET
|
int8 worker_func(int8 *param_1)
{
int iVar1;
long lVar2;
long lVar3;
int1 auVar4 [16];
lVar2 = JS_NewRuntime();
if (lVar2 == 0) {
fprintf(*(FILE **)PTR_stderr_0023cff8,"JS_NewRuntime failure");
/* WARNING: Subroutine does not return */
exit(1);
}
js_std_init_handlers(lVar2);
JS_SetModuleLoaderFunc(lVar2,0,js_module_loader);
lVar3 = js_get_thread_state(lVar2);
*(int8 *)(lVar3 + 0x68) = param_1[2];
*(int8 *)(lVar3 + 0x70) = param_1[3];
lVar3 = (*js_worker_new_context_func)(lVar2);
if (lVar3 == 0) {
fprintf(*(FILE **)PTR_stderr_0023cff8,"JS_NewContext failure");
}
JS_SetCanBlock(lVar2,1);
js_std_add_helpers(lVar3,0xffffffff,0);
auVar4 = JS_LoadModule(lVar3,param_1[1],*param_1);
free((void *)*param_1);
free((void *)param_1[1]);
free(param_1);
auVar4 = js_std_await(lVar3,auVar4._0_8_,auVar4._8_8_);
iVar1 = JS_IsException(auVar4._0_8_,auVar4._8_8_);
if (iVar1 != 0) {
js_std_dump_error(lVar3);
}
JS_FreeValue(lVar3,auVar4._0_8_,auVar4._8_8_);
auVar4 = js_std_loop(lVar3);
JS_FreeValue(lVar3,auVar4._0_8_,auVar4._8_8_);
JS_FreeContext(lVar3);
js_std_free_handlers(lVar2);
JS_FreeRuntime(lVar2);
return 0;
}
| |
48,342 | worker_func | bluesky950520[P]quickjs/quickjs-libc.c | static void *worker_func(void *opaque)
{
WorkerFuncArgs *args = opaque;
JSRuntime *rt;
JSThreadState *ts;
JSContext *ctx;
JSValue val;
rt = JS_NewRuntime();
if (rt == NULL) {
fprintf(stderr, "JS_NewRuntime failure");
exit(1);
}
js_std_init_handlers(rt);
JS_SetModuleLoaderFunc(rt, NULL, js_module_loader, NULL);
/* set the pipe to communicate with the parent */
ts = js_get_thread_state(rt);
ts->recv_pipe = args->recv_pipe;
ts->send_pipe = args->send_pipe;
/* function pointer to avoid linking the whole JS_NewContext() if
not needed */
ctx = js_worker_new_context_func(rt);
if (ctx == NULL) {
fprintf(stderr, "JS_NewContext failure");
}
JS_SetCanBlock(rt, TRUE);
js_std_add_helpers(ctx, -1, NULL);
val = JS_LoadModule(ctx, args->basename, args->filename);
free(args->filename);
free(args->basename);
free(args);
val = js_std_await(ctx, val);
if (JS_IsException(val))
js_std_dump_error(ctx);
JS_FreeValue(ctx, val);
JS_FreeValue(ctx, js_std_loop(ctx));
JS_FreeContext(ctx);
js_std_free_handlers(rt);
JS_FreeRuntime(rt);
return NULL;
} | O2 | c | worker_func:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r15
callq 0x1b9f6
testq %rax, %rax
je 0x1701d
movq %rax, %rbx
movq %rax, %rdi
callq 0x13c6a
leaq -0x39b9(%rip), %rdx # 0x13564
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x2cced
movq %rbx, %rdi
callq 0x13e3a
movups 0x10(%r15), %xmm0
movups %xmm0, 0x68(%rax)
movq %rbx, %rdi
callq *0xa8c45(%rip) # 0xbfb88
movq %rax, %r14
testq %rax, %rax
je 0x16ffc
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x1ba3b
pushq $-0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x13a20
movq (%r15), %rdx
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x2d0a2
movq %rax, %r12
movq %rdx, %r13
movq (%r15), %rdi
callq 0xe060
movq 0x8(%r15), %rdi
callq 0xe060
movq %r15, %rdi
callq 0xe060
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x145e4
movq %rax, %r15
movq %rdx, %r12
cmpl $0x6, %r12d
jne 0x16fb7
movq %r14, %rdi
callq 0x1404c
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1bbce
movq %r14, %rdi
callq 0x140c0
movq %r14, %rdi
movq %rax, %rsi
callq 0x1bbce
movq %r14, %rdi
callq 0x1dae6
movq %rbx, %rdi
callq 0x13db2
movq %rbx, %rdi
callq 0x1b842
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0xa7ff5(%rip), %rax # 0xbeff8
movq (%rax), %rcx
leaq 0x6e230(%rip), %rdi # 0x8523d
pushq $0x15
popq %rsi
pushq $0x1
popq %rdx
callq 0xe970
jmp 0x16f4f
movq 0xa7fd4(%rip), %rax # 0xbeff8
movq (%rax), %rcx
leaq 0x6e1f9(%rip), %rdi # 0x85227
pushq $0x15
popq %rsi
pushq $0x1
popq %rdx
callq 0xe970
pushq $0x1
popq %rdi
callq 0xe960
| worker_func:
push r15
push r14
push r13
push r12
push rbx
mov r15, rdi
call JS_NewRuntime
test rax, rax
jz loc_1701D
mov rbx, rax
mov rdi, rax
call js_std_init_handlers
lea rdx, js_module_loader
mov rdi, rbx
xor esi, esi
xor ecx, ecx
call JS_SetModuleLoaderFunc
mov rdi, rbx
call js_get_thread_state
movups xmm0, xmmword ptr [r15+10h]
movups xmmword ptr [rax+68h], xmm0
mov rdi, rbx
call cs:js_worker_new_context_func
mov r14, rax
test rax, rax
jz loc_16FFC
loc_16F4F:
push 1
pop rsi
mov rdi, rbx
call JS_SetCanBlock
push 0FFFFFFFFFFFFFFFFh
pop rsi
mov rdi, r14
xor edx, edx
call js_std_add_helpers
mov rdx, [r15]
mov rsi, [r15+8]
mov rdi, r14
call JS_LoadModule
mov r12, rax
mov r13, rdx
mov rdi, [r15]
call _free
mov rdi, [r15+8]
call _free
mov rdi, r15
call _free
mov rdi, r14
mov rsi, r12
mov rdx, r13
call js_std_await
mov r15, rax
mov r12, rdx
cmp r12d, 6
jnz short loc_16FB7
mov rdi, r14
call js_std_dump_error
loc_16FB7:
mov rdi, r14
mov rsi, r15
mov rdx, r12
call JS_FreeValue
mov rdi, r14
call js_std_loop
mov rdi, r14
mov rsi, rax
call JS_FreeValue
mov rdi, r14
call JS_FreeContext
mov rdi, rbx
call js_std_free_handlers
mov rdi, rbx
call JS_FreeRuntime
xor eax, eax
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
loc_16FFC:
mov rax, cs:stderr_ptr
mov rcx, [rax]
lea rdi, aJsNewcontextFa; "JS_NewContext failure"
push 15h
pop rsi
push 1
pop rdx
call _fwrite
jmp loc_16F4F
loc_1701D:
mov rax, cs:stderr_ptr
mov rcx, [rax]
lea rdi, aJsNewruntimeFa; "JS_NewRuntime failure"
push 15h
pop rsi
push 1
pop rdx
call _fwrite
push 1
pop rdi
call _exit
| long long worker_func(_QWORD *a1)
{
long long v1; // rax
long long v2; // rbx
int v3; // edx
int v4; // ecx
int v5; // r8d
int v6; // r9d
long long v7; // r14
long long Module; // r12
long long v9; // rdx
long long v10; // r13
long long v11; // r15
int v12; // edx
long long v13; // rax
char v15; // [rsp+0h] [rbp-28h]
v1 = JS_NewRuntime();
if ( !v1 )
{
fwrite("JS_NewRuntime failure", 21LL, 1LL, stderr);
exit(1LL);
}
v2 = v1;
js_std_init_handlers(v1);
JS_SetModuleLoaderFunc(v2, 0LL, js_module_loader, 0LL);
*(_OWORD *)(js_get_thread_state(v2, 0LL, v3, v4, v5, v6, v15) + 104) = *((_OWORD *)a1 + 1);
v7 = js_worker_new_context_func(v2);
if ( !v7 )
fwrite("JS_NewContext failure", 21LL, 1LL, stderr);
JS_SetCanBlock(v2, 1LL);
js_std_add_helpers(v7, -1, 0LL);
Module = JS_LoadModule(v7, a1[1], *a1);
v10 = v9;
free(*a1);
free(a1[1]);
free(a1);
v11 = js_std_await(v7, Module, v10);
if ( v12 == 6 )
js_std_dump_error(v7);
JS_FreeValue(v7, v11);
v13 = js_std_loop(v7, v11);
JS_FreeValue(v7, v13);
JS_FreeContext(v7);
js_std_free_handlers(v2);
JS_FreeRuntime(v2);
return 0LL;
}
| worker_func:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV R15,RDI
CALL 0x0011b9f6
TEST RAX,RAX
JZ 0x0011701d
MOV RBX,RAX
MOV RDI,RAX
CALL 0x00113c6a
LEA RDX,[0x113564]
MOV RDI,RBX
XOR ESI,ESI
XOR ECX,ECX
CALL 0x0012cced
MOV RDI,RBX
CALL 0x00113e3a
MOVUPS XMM0,xmmword ptr [R15 + 0x10]
MOVUPS xmmword ptr [RAX + 0x68],XMM0
MOV RDI,RBX
CALL qword ptr [0x001bfb88]
MOV R14,RAX
TEST RAX,RAX
JZ 0x00116ffc
LAB_00116f4f:
PUSH 0x1
POP RSI
MOV RDI,RBX
CALL 0x0011ba3b
PUSH -0x1
POP RSI
MOV RDI,R14
XOR EDX,EDX
CALL 0x00113a20
MOV RDX,qword ptr [R15]
MOV RSI,qword ptr [R15 + 0x8]
MOV RDI,R14
CALL 0x0012d0a2
MOV R12,RAX
MOV R13,RDX
MOV RDI,qword ptr [R15]
CALL 0x0010e060
MOV RDI,qword ptr [R15 + 0x8]
CALL 0x0010e060
MOV RDI,R15
CALL 0x0010e060
MOV RDI,R14
MOV RSI,R12
MOV RDX,R13
CALL 0x001145e4
MOV R15,RAX
MOV R12,RDX
CMP R12D,0x6
JNZ 0x00116fb7
MOV RDI,R14
CALL 0x0011404c
LAB_00116fb7:
MOV RDI,R14
MOV RSI,R15
MOV RDX,R12
CALL 0x0011bbce
MOV RDI,R14
CALL 0x001140c0
MOV RDI,R14
MOV RSI,RAX
CALL 0x0011bbce
MOV RDI,R14
CALL 0x0011dae6
MOV RDI,RBX
CALL 0x00113db2
MOV RDI,RBX
CALL 0x0011b842
XOR EAX,EAX
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
LAB_00116ffc:
MOV RAX,qword ptr [0x001beff8]
MOV RCX,qword ptr [RAX]
LEA RDI,[0x18523d]
PUSH 0x15
POP RSI
PUSH 0x1
POP RDX
CALL 0x0010e970
JMP 0x00116f4f
LAB_0011701d:
MOV RAX,qword ptr [0x001beff8]
MOV RCX,qword ptr [RAX]
LEA RDI,[0x185227]
PUSH 0x15
POP RSI
PUSH 0x1
POP RDX
CALL 0x0010e970
PUSH 0x1
POP RDI
CALL 0x0010e960
|
int8 worker_func(int8 *param_1)
{
int4 uVar1;
int4 uVar2;
int4 uVar3;
long lVar4;
long lVar5;
int8 uVar6;
int1 auVar7 [16];
lVar4 = JS_NewRuntime();
if (lVar4 != 0) {
js_std_init_handlers(lVar4);
JS_SetModuleLoaderFunc(lVar4,0,js_module_loader,0);
lVar5 = js_get_thread_state(lVar4);
uVar1 = *(int4 *)((long)param_1 + 0x14);
uVar2 = *(int4 *)(param_1 + 3);
uVar3 = *(int4 *)((long)param_1 + 0x1c);
*(int4 *)(lVar5 + 0x68) = *(int4 *)(param_1 + 2);
*(int4 *)(lVar5 + 0x6c) = uVar1;
*(int4 *)(lVar5 + 0x70) = uVar2;
*(int4 *)(lVar5 + 0x74) = uVar3;
lVar5 = (*js_worker_new_context_func)(lVar4);
if (lVar5 == 0) {
fwrite("JS_NewContext failure",0x15,1,*(FILE **)PTR_stderr_001beff8);
}
JS_SetCanBlock(lVar4,1);
js_std_add_helpers(lVar5,0xffffffffffffffff,0);
auVar7 = JS_LoadModule(lVar5,param_1[1],*param_1);
free((void *)*param_1);
free((void *)param_1[1]);
free(param_1);
auVar7 = js_std_await(lVar5,auVar7._0_8_,auVar7._8_8_);
if (auVar7._8_4_ == 6) {
js_std_dump_error(lVar5);
}
JS_FreeValue(lVar5,auVar7._0_8_,auVar7._8_8_);
uVar6 = js_std_loop(lVar5);
JS_FreeValue(lVar5,uVar6);
JS_FreeContext(lVar5);
js_std_free_handlers(lVar4);
JS_FreeRuntime(lVar4);
return 0;
}
fwrite("JS_NewRuntime failure",0x15,1,*(FILE **)PTR_stderr_001beff8);
/* WARNING: Subroutine does not return */
exit(1);
}
| |
48,343 | ma_log_del_prefix | eloqsql/storage/maria/ma_write.c | static my_bool _ma_log_del_prefix(MARIA_PAGE *ma_page,
uint org_length, uint new_length,
const uchar *key_pos, uint key_length,
int move_length)
{
LSN lsn;
uchar log_data[FILEID_STORE_SIZE + PAGE_STORE_SIZE + 2 + 2 + 12 + 7];
uchar *log_pos;
LEX_CUSTRING log_array[TRANSLOG_INTERNAL_PARTS + 4];
uint offset= (uint) (key_pos - ma_page->buff);
uint diff_length= org_length + move_length - new_length;
uint translog_parts, extra_length;
MARIA_HA *info= ma_page->info;
my_off_t page= ma_page->pos / info->s->block_size;
DBUG_ENTER("_ma_log_del_prefix");
DBUG_PRINT("enter", ("page: %lu org_length: %u new_length: %u",
(ulong) page, org_length, new_length));
DBUG_ASSERT((int) diff_length > 0);
DBUG_ASSERT(ma_page->org_size == org_length);
DBUG_ASSERT(ma_page->size == new_length);
log_pos= log_data + FILEID_STORE_SIZE;
page_store(log_pos, page);
log_pos+= PAGE_STORE_SIZE;
translog_parts= 1;
extra_length= 0;
#ifdef EXTRA_DEBUG_KEY_CHANGES
*log_pos++= KEY_OP_DEBUG;
*log_pos++= KEY_OP_DEBUG_LOG_DEL_PREFIX;
#endif
/* Store keypage_flag */
*log_pos++= KEY_OP_SET_PAGEFLAG;
*log_pos++= _ma_get_keypage_flag(info->s, ma_page->buff);
if (offset < diff_length + info->s->keypage_header)
{
/*
Key is not anymore on page. Move data down, but take into account that
the original page had grown with 'move_length bytes'
*/
DBUG_ASSERT(offset + key_length <= diff_length + info->s->keypage_header);
log_pos[0]= KEY_OP_DEL_PREFIX;
int2store(log_pos+1, diff_length - move_length);
log_pos+= 3;
}
else
{
/*
Correct position to key, as data before key has been delete and key
has thus been moved down
*/
offset-= diff_length;
key_pos-= diff_length;
/* Move data down */
log_pos[0]= KEY_OP_DEL_PREFIX;
int2store(log_pos+1, diff_length);
log_pos+= 3;
log_pos[0]= KEY_OP_OFFSET;
int2store(log_pos+1, offset);
log_pos+= 3;
if (move_length)
{
log_pos[0]= KEY_OP_SHIFT;
int2store(log_pos+1, move_length);
log_pos+= 3;
}
log_pos[0]= KEY_OP_CHANGE;
int2store(log_pos+1, key_length);
log_pos+= 3;
log_array[TRANSLOG_INTERNAL_PARTS + 1].str= key_pos;
log_array[TRANSLOG_INTERNAL_PARTS + 1].length= key_length;
translog_parts= 2;
extra_length= key_length;
}
log_array[TRANSLOG_INTERNAL_PARTS + 0].str= log_data;
log_array[TRANSLOG_INTERNAL_PARTS + 0].length= (uint) (log_pos -
log_data);
_ma_log_key_changes(ma_page,
log_array + TRANSLOG_INTERNAL_PARTS + translog_parts,
log_pos, &extra_length, &translog_parts);
/* Remember new page length for future log entires for same page */
ma_page->org_size= ma_page->size;
DBUG_RETURN(translog_write_record(&lsn, LOGREC_REDO_INDEX,
info->trn, info,
(translog_size_t)
log_array[TRANSLOG_INTERNAL_PARTS +
0].length + extra_length,
TRANSLOG_INTERNAL_PARTS + translog_parts,
log_array, log_data, NULL));
} | O3 | c | ma_log_del_prefix:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rcx, %r10
movq %fs:0x28, %rax
movq %rax, -0x28(%rbp)
movq (%rdi), %rcx
movq 0x10(%rdi), %r14
movl %r10d, %r11d
subl %r14d, %r11d
subl %edx, %esi
leal (%rsi,%r9), %ebx
movq 0x18(%rdi), %rax
movq (%rcx), %r15
movl 0x7bc(%r15), %r12d
xorl %edx, %edx
divq %r12
movl %eax, -0x4e(%rbp)
shrq $0x20, %rax
movb %al, -0x4a(%rbp)
movb $0xa, -0x49(%rbp)
movl 0x744(%r15), %eax
leal -0x3(%rax), %edx
movb (%r14,%rdx), %dl
movb %dl, -0x48(%rbp)
addl %ebx, %eax
cmpl %r11d, %eax
jbe 0x680f6
leaq -0x44(%rbp), %rax
movb $0x5, -0x3(%rax)
movw %si, -0x2(%rax)
movl $0x3, %r9d
xorl %r8d, %r8d
jmp 0x6814a
subl %ebx, %r11d
movl %ebx, %eax
subq %rax, %r10
movb $0x5, -0x47(%rbp)
movw %bx, -0x46(%rbp)
movb $0x1, -0x44(%rbp)
movw %r11w, -0x43(%rbp)
testl %r9d, %r9d
je 0x68123
leaq -0x3e(%rbp), %rax
movb $0x2, -0x3(%rax)
movw %r9w, -0x2(%rax)
jmp 0x68127
leaq -0x41(%rbp), %rax
movb $0x3, (%rax)
movw %r8w, 0x1(%rax)
addq $0x3, %rax
movq %r10, -0x90(%rbp)
movl %r8d, %edx
movq %rdx, -0x88(%rbp)
movl $0x4, %r9d
leaq -0x50(%rbp), %r10
leaq -0xc0(%rbp), %r11
movq %r10, 0x20(%r11)
subq %r10, %rax
movl %eax, %edx
movq %rdx, 0x28(%r11)
movl 0x20(%rdi), %edx
movl %edx, 0x24(%rdi)
movq 0x8(%rcx), %rdx
addl %eax, %r8d
subq $0x8, %rsp
leaq -0x58(%rbp), %rdi
movl $0xc, %esi
pushq $0x0
pushq %r10
pushq %r11
callq 0x2a8ac
addq $0x20, %rsp
movq %fs:0x28, %rcx
cmpq -0x28(%rbp), %rcx
jne 0x681aa
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x29270
nop
| _ma_log_del_prefix:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 0A0h
mov r10, rcx
mov rax, fs:28h
mov [rbp+var_28], rax
mov rcx, [rdi]
mov r14, [rdi+10h]
mov r11d, r10d
sub r11d, r14d
sub esi, edx
lea ebx, [rsi+r9]
mov rax, [rdi+18h]
mov r15, [rcx]
mov r12d, [r15+7BCh]
xor edx, edx
div r12
mov [rbp+var_4E], eax
shr rax, 20h
mov [rbp+var_4A], al
mov [rbp+var_49], 0Ah
mov eax, [r15+744h]
lea edx, [rax-3]
mov dl, [r14+rdx]
mov [rbp+var_48], dl
add eax, ebx
cmp eax, r11d
jbe short loc_680F6
lea rax, [rbp+var_44]
mov byte ptr [rax-3], 5
mov [rax-2], si
mov r9d, 3
xor r8d, r8d
jmp short loc_6814A
loc_680F6:
sub r11d, ebx
mov eax, ebx
sub r10, rax
mov [rbp+var_47], 5
mov [rbp+var_46], bx
mov [rbp+var_44], 1
mov [rbp+var_43], r11w
test r9d, r9d
jz short loc_68123
lea rax, [rbp+var_3E]
mov byte ptr [rax-3], 2
mov [rax-2], r9w
jmp short loc_68127
loc_68123:
lea rax, [rbp+var_41]
loc_68127:
mov byte ptr [rax], 3
mov [rax+1], r8w
add rax, 3
mov [rbp+var_90], r10
mov edx, r8d
mov [rbp+var_88], rdx
mov r9d, 4
loc_6814A:
lea r10, [rbp+var_50]
lea r11, [rbp+var_C0]
mov [r11+20h], r10
sub rax, r10
mov edx, eax
mov [r11+28h], rdx
mov edx, [rdi+20h]
mov [rdi+24h], edx
mov rdx, [rcx+8]
add r8d, eax
sub rsp, 8
lea rdi, [rbp+var_58]
mov esi, 0Ch
push 0
push r10
push r11
call translog_write_record
add rsp, 20h
mov rcx, fs:28h
cmp rcx, [rbp+var_28]
jnz short loc_681AA
add rsp, 0A0h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_681AA:
call ___stack_chk_fail
| long long ma_log_del_prefix(long long **a1, int a2, int a3, long long a4, unsigned int a5, int a6)
{
long long *v7; // rcx
long long *v8; // r14
__int16 v9; // r11
int v10; // esi
unsigned int v11; // ebx
long long v12; // r15
unsigned long long v13; // rax
char *v14; // rax
int v15; // r9d
long long v16; // r10
char *v17; // rax
signed long long v18; // rax
__int128 v20; // [rsp+0h] [rbp-C0h] BYREF
__int16 *v21; // [rsp+20h] [rbp-A0h]
long long v22; // [rsp+28h] [rbp-98h]
long long v23; // [rsp+30h] [rbp-90h]
long long v24; // [rsp+38h] [rbp-88h]
_BYTE v25[8]; // [rsp+68h] [rbp-58h] BYREF
__int16 v26; // [rsp+70h] [rbp-50h] BYREF
int v27; // [rsp+72h] [rbp-4Eh]
char v28; // [rsp+76h] [rbp-4Ah]
char v29; // [rsp+77h] [rbp-49h]
char v30; // [rsp+78h] [rbp-48h]
char v31; // [rsp+79h] [rbp-47h]
__int16 v32; // [rsp+7Ah] [rbp-46h]
char v33; // [rsp+7Ch] [rbp-44h] BYREF
__int16 v34; // [rsp+7Dh] [rbp-43h]
char v35; // [rsp+7Fh] [rbp-41h] BYREF
__int16 v36; // [rsp+80h] [rbp-40h]
char v37; // [rsp+82h] [rbp-3Eh] BYREF
unsigned long long v38; // [rsp+98h] [rbp-28h]
v38 = __readfsqword(0x28u);
v7 = *a1;
v8 = a1[2];
v9 = a4 - (_WORD)v8;
v10 = a2 - a3;
v11 = v10 + a6;
v12 = **a1;
v13 = (unsigned long long)a1[3] / *(unsigned int *)(v12 + 1980);
v27 = v13;
v28 = BYTE4(v13);
v29 = 10;
LODWORD(v13) = *(_DWORD *)(v12 + 1860);
v30 = *((_BYTE *)v8 + (unsigned int)(v13 - 3));
if ( v10 + a6 + (int)v13 <= (unsigned int)(a4 - (_DWORD)v8) )
{
v16 = a4 - v11;
v31 = 5;
v32 = v10 + a6;
v33 = 1;
v34 = v9 - v11;
if ( a6 )
{
v17 = &v37;
v35 = 2;
v36 = a6;
}
else
{
v17 = &v35;
}
*v17 = 3;
*(_WORD *)(v17 + 1) = a5;
v14 = v17 + 3;
v23 = v16;
v24 = a5;
v15 = 4;
}
else
{
v14 = &v33;
v31 = 5;
v32 = v10;
v15 = 3;
a5 = 0;
}
v21 = &v26;
v18 = v14 - (char *)&v26;
v22 = (unsigned int)v18;
*((_DWORD *)a1 + 9) = *((_DWORD *)a1 + 8);
return translog_write_record(
(unsigned long long)v25,
&byte_9[3],
v7[1],
v7,
(unsigned int)v18 + a5,
v15,
&v20,
&v26,
0LL);
}
| _ma_log_del_prefix:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0xa0
MOV R10,RCX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
MOV RCX,qword ptr [RDI]
MOV R14,qword ptr [RDI + 0x10]
MOV R11D,R10D
SUB R11D,R14D
SUB ESI,EDX
LEA EBX,[RSI + R9*0x1]
MOV RAX,qword ptr [RDI + 0x18]
MOV R15,qword ptr [RCX]
MOV R12D,dword ptr [R15 + 0x7bc]
XOR EDX,EDX
DIV R12
MOV dword ptr [RBP + -0x4e],EAX
SHR RAX,0x20
MOV byte ptr [RBP + -0x4a],AL
MOV byte ptr [RBP + -0x49],0xa
MOV EAX,dword ptr [R15 + 0x744]
LEA EDX,[RAX + -0x3]
MOV DL,byte ptr [R14 + RDX*0x1]
MOV byte ptr [RBP + -0x48],DL
ADD EAX,EBX
CMP EAX,R11D
JBE 0x001680f6
LEA RAX,[RBP + -0x44]
MOV byte ptr [RAX + -0x3],0x5
MOV word ptr [RAX + -0x2],SI
MOV R9D,0x3
XOR R8D,R8D
JMP 0x0016814a
LAB_001680f6:
SUB R11D,EBX
MOV EAX,EBX
SUB R10,RAX
MOV byte ptr [RBP + -0x47],0x5
MOV word ptr [RBP + -0x46],BX
MOV byte ptr [RBP + -0x44],0x1
MOV word ptr [RBP + -0x43],R11W
TEST R9D,R9D
JZ 0x00168123
LEA RAX,[RBP + -0x3e]
MOV byte ptr [RAX + -0x3],0x2
MOV word ptr [RAX + -0x2],R9W
JMP 0x00168127
LAB_00168123:
LEA RAX,[RBP + -0x41]
LAB_00168127:
MOV byte ptr [RAX],0x3
MOV word ptr [RAX + 0x1],R8W
ADD RAX,0x3
MOV qword ptr [RBP + -0x90],R10
MOV EDX,R8D
MOV qword ptr [RBP + -0x88],RDX
MOV R9D,0x4
LAB_0016814a:
LEA R10,[RBP + -0x50]
LEA R11,[RBP + -0xc0]
MOV qword ptr [R11 + 0x20],R10
SUB RAX,R10
MOV EDX,EAX
MOV qword ptr [R11 + 0x28],RDX
MOV EDX,dword ptr [RDI + 0x20]
MOV dword ptr [RDI + 0x24],EDX
MOV RDX,qword ptr [RCX + 0x8]
ADD R8D,EAX
SUB RSP,0x8
LEA RDI,[RBP + -0x58]
MOV ESI,0xc
PUSH 0x0
PUSH R10
PUSH R11
CALL 0x0012a8ac
ADD RSP,0x20
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x28]
JNZ 0x001681aa
ADD RSP,0xa0
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001681aa:
CALL 0x00129270
|
void _ma_log_del_prefix(long *param_1,int param_2,int param_3,long param_4,uint param_5,int param_6)
{
long *plVar1;
int1 auVar2 [16];
int iVar3;
uint uVar4;
int1 *puVar5;
int8 uVar6;
uint uVar7;
long in_FS_OFFSET;
int1 local_c8 [32];
int1 *local_a8;
ulong local_a0;
long local_98;
ulong local_90;
int1 local_60 [8];
int1 local_58 [2];
int4 local_56;
int1 local_52;
int1 local_51;
int1 local_50;
int1 local_4f;
short local_4e;
int1 local_4c;
short local_4b;
int1 local_49;
int2 local_48;
int1 local_46 [22];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
plVar1 = (long *)*param_1;
uVar7 = (int)param_4 - (int)param_1[2];
uVar4 = (param_2 - param_3) + param_6;
auVar2._8_8_ = 0;
auVar2._0_8_ = param_1[3];
auVar2 = auVar2 / ZEXT416(*(uint *)(*plVar1 + 0x7bc));
local_56 = auVar2._0_4_;
local_52 = auVar2[4];
local_51 = 10;
iVar3 = *(int *)(*plVar1 + 0x744);
local_50 = *(int1 *)(param_1[2] + (ulong)(iVar3 - 3));
if (uVar7 < iVar3 + uVar4) {
iVar3 = (int)&local_4c;
local_4e = (short)(param_2 - param_3);
uVar6 = 3;
param_5 = 0;
}
else {
local_4e = (short)uVar4;
local_4b = (short)uVar7 - local_4e;
local_98 = param_4 - (ulong)uVar4;
local_4c = 1;
if (param_6 == 0) {
puVar5 = &local_49;
}
else {
puVar5 = local_46;
local_49 = 2;
local_48 = (int2)param_6;
}
*puVar5 = 3;
*(short *)(puVar5 + 1) = (short)param_5;
iVar3 = (int)puVar5 + 3;
local_90 = (ulong)param_5;
uVar6 = 4;
}
local_4f = 5;
local_a8 = local_58;
uVar4 = iVar3 - (int)local_a8;
local_a0 = (ulong)uVar4;
*(int *)((long)param_1 + 0x24) = (int)param_1[4];
translog_write_record(local_60,0xc,plVar1[1],plVar1,param_5 + uVar4,uVar6,local_c8,local_a8,0);
if (*(long *)(in_FS_OFFSET + 0x28) == local_30) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
48,344 | psi_prlock_wrlock | eloqsql/mysys/my_thr_init.c | ATTRIBUTE_COLD
int psi_prlock_wrlock(mysql_prlock_t *that, const char *file, uint line)
{
PSI_rwlock_locker_state state;
PSI_rwlock_locker *locker= PSI_RWLOCK_CALL(start_rwlock_wrwait)
(&state, that->m_psi, PSI_RWLOCK_WRITELOCK, file, line);
int result= rw_pr_wrlock(&that->m_prlock);
if (locker)
PSI_RWLOCK_CALL(end_rwlock_wrwait)(locker, result);
return result;
} | O0 | c | psi_prlock_wrlock:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq 0x1abafe(%rip), %rax # 0x1dd8b8
movq (%rax), %rax
movq 0x1b0(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x68(%rcx), %rsi
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %r8d
leaq -0x48(%rbp), %rdi
movl $0x1, %edx
callq *%rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0x34b70
movl %eax, -0x54(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0x31e10
leaq 0x1ababb(%rip), %rax # 0x1dd8b8
movq (%rax), %rax
movq 0x1b8(%rax), %rax
movq -0x50(%rbp), %rdi
movl -0x54(%rbp), %esi
callq *%rax
movl -0x54(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
| psi_prlock_wrlock:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1B0h]
mov rcx, [rbp+var_8]
mov rsi, [rcx+68h]
mov rcx, [rbp+var_10]
mov r8d, [rbp+var_14]
lea rdi, [rbp+var_48]
mov edx, 1
call rax
mov [rbp+var_50], rax
mov rdi, [rbp+var_8]
call rw_pr_wrlock
mov [rbp+var_54], eax
cmp [rbp+var_50], 0
jz short loc_31E10
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1B8h]
mov rdi, [rbp+var_50]
mov esi, [rbp+var_54]
call rax
loc_31E10:
mov eax, [rbp+var_54]
add rsp, 60h
pop rbp
retn
| long long psi_prlock_wrlock(long long a1, long long a2, unsigned int a3)
{
unsigned int v4; // [rsp+Ch] [rbp-54h]
long long v5; // [rsp+10h] [rbp-50h]
_BYTE v6[52]; // [rsp+18h] [rbp-48h] BYREF
unsigned int v7; // [rsp+4Ch] [rbp-14h]
long long v8; // [rsp+50h] [rbp-10h]
long long v9; // [rsp+58h] [rbp-8h]
v9 = a1;
v8 = a2;
v7 = a3;
v5 = (*((long long ( **)(_BYTE *, _QWORD, long long, long long, _QWORD))PSI_server[0] + 54))(
v6,
*(_QWORD *)(a1 + 104),
1LL,
a2,
a3);
v4 = rw_pr_wrlock(v9);
if ( v5 )
(*((void ( **)(long long, _QWORD))PSI_server[0] + 55))(v5, v4);
return v4;
}
| psi_prlock_wrlock:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
LEA RAX,[0x2dd8b8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1b0]
MOV RCX,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RCX + 0x68]
MOV RCX,qword ptr [RBP + -0x10]
MOV R8D,dword ptr [RBP + -0x14]
LEA RDI,[RBP + -0x48]
MOV EDX,0x1
CALL RAX
MOV qword ptr [RBP + -0x50],RAX
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00134b70
MOV dword ptr [RBP + -0x54],EAX
CMP qword ptr [RBP + -0x50],0x0
JZ 0x00131e10
LEA RAX,[0x2dd8b8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1b8]
MOV RDI,qword ptr [RBP + -0x50]
MOV ESI,dword ptr [RBP + -0x54]
CALL RAX
LAB_00131e10:
MOV EAX,dword ptr [RBP + -0x54]
ADD RSP,0x60
POP RBP
RET
|
int4 psi_prlock_wrlock(long param_1,int8 param_2,int4 param_3)
{
int4 uVar1;
long lVar2;
int1 local_50 [52];
int4 local_1c;
int8 local_18;
long local_10;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
lVar2 = (**(code **)(PSI_server + 0x1b0))
(local_50,*(int8 *)(param_1 + 0x68),1,param_2,param_3);
uVar1 = rw_pr_wrlock(local_10);
if (lVar2 != 0) {
(**(code **)(PSI_server + 0x1b8))(lVar2,uVar1);
}
return uVar1;
}
| |
48,345 | mi_search_last | eloqsql/storage/myisam/mi_search.c | int _mi_search_last(register MI_INFO *info, register MI_KEYDEF *keyinfo,
register my_off_t pos)
{
uint nod_flag;
uchar *buff,*page;
DBUG_ENTER("_mi_search_last");
if (pos == HA_OFFSET_ERROR)
{
my_errno=HA_ERR_KEY_NOT_FOUND; /* Didn't find key */
info->lastpos= HA_OFFSET_ERROR;
DBUG_RETURN(-1);
}
buff=info->buff;
do
{
if (!_mi_fetch_keypage(info,keyinfo,pos,DFLT_INIT_HITS,buff,0))
{
info->lastpos= HA_OFFSET_ERROR;
DBUG_RETURN(-1);
}
page= buff+mi_getint(buff);
nod_flag=mi_test_if_nod(buff);
} while ((pos=_mi_kpos(nod_flag,page)) != HA_OFFSET_ERROR);
if (!_mi_get_last_key(info,keyinfo,buff,info->lastkey,page,
&info->lastkey_length))
DBUG_RETURN(-1);
info->lastpos=_mi_dpos(info,0,info->lastkey+info->lastkey_length);
info->int_keypos=info->int_maxpos=page;
info->int_nod_flag=nod_flag;
info->int_keytree_version=keyinfo->version;
info->last_search_keypage=info->last_keypage;
info->page_changed=info->buff_used=0;
DBUG_PRINT("exit",("found key at %lu",(ulong) info->lastpos));
DBUG_RETURN(0);
} | O0 | c | mi_search_last:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $-0x1, -0x20(%rbp)
jne 0xc22a1
callq 0xf6060
movl $0x78, (%rax)
movq -0x10(%rbp), %rax
movq $-0x1, 0x170(%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc2447
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %r8
movl $0x3, %ecx
xorl %r9d, %r9d
callq 0xbdd70
cmpq $0x0, %rax
jne 0xc22ee
movq -0x10(%rbp), %rax
movq $-0x1, 0x170(%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc2447
movq -0x30(%rbp), %rax
movq -0x30(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
movzwl %cx, %ecx
movq -0x30(%rbp), %rdx
movzbl (%rdx), %edx
movzwl %dx, %edx
shll $0x8, %edx
orl %edx, %ecx
movzwl %cx, %ecx
andl $0x7fff, %ecx # imm = 0x7FFF
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0xc2341
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x17c(%rax), %eax
movl %eax, -0x3c(%rbp)
jmp 0xc2348
xorl %eax, %eax
movl %eax, -0x3c(%rbp)
jmp 0xc2348
movl -0x3c(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %edi
movq -0x38(%rbp), %rsi
callq 0xbece0
movq %rax, -0x20(%rbp)
cmpq $-0x1, %rax
jne 0xc22b0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rcx
movq -0x38(%rbp), %r8
movq -0x10(%rbp), %r9
addq $0x1d8, %r9 # imm = 0x1D8
callq 0xc1700
cmpq $0x0, %rax
jne 0xc23a7
jmp 0xc239b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc2447
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rdx
movq -0x10(%rbp), %rax
movl 0x1d8(%rax), %eax
addq %rax, %rdx
xorl %esi, %esi
callq 0xbef60
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x170(%rax)
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x130(%rax)
movq -0x10(%rbp), %rax
movq %rcx, 0x128(%rax)
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x138(%rax)
movq -0x18(%rbp), %rax
movl 0x1c(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x13c(%rax)
movq -0x10(%rbp), %rax
movq 0x190(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x198(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x33d(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x33c(%rax)
jmp 0xc243e
jmp 0xc2440
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
| _mi_search_last:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
cmp [rbp+var_20], 0FFFFFFFFFFFFFFFFh
jnz short loc_C22A1
call _my_thread_var
mov dword ptr [rax], 78h ; 'x'
mov rax, [rbp+var_10]
mov qword ptr [rax+170h], 0FFFFFFFFFFFFFFFFh
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_C2447
loc_C22A1:
mov rax, [rbp+var_10]
mov rax, [rax+100h]
mov [rbp+var_30], rax
loc_C22B0:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
mov r8, [rbp+var_30]
mov ecx, 3
xor r9d, r9d
call _mi_fetch_keypage
cmp rax, 0
jnz short loc_C22EE
mov rax, [rbp+var_10]
mov qword ptr [rax+170h], 0FFFFFFFFFFFFFFFFh
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_C2447
loc_C22EE:
mov rax, [rbp+var_30]
mov rcx, [rbp+var_30]
movzx ecx, byte ptr [rcx+1]
movzx ecx, cx
mov rdx, [rbp+var_30]
movzx edx, byte ptr [rdx]
movzx edx, dx
shl edx, 8
or ecx, edx
movzx ecx, cx
and ecx, 7FFFh
mov ecx, ecx
add rax, rcx
mov [rbp+var_38], rax
mov rax, [rbp+var_30]
movzx eax, byte ptr [rax]
and eax, 80h
cmp eax, 0
jz short loc_C2341
mov rax, [rbp+var_10]
mov rax, [rax]
mov eax, [rax+17Ch]
mov [rbp+var_3C], eax
jmp short loc_C2348
loc_C2341:
xor eax, eax
mov [rbp+var_3C], eax
jmp short $+2
loc_C2348:
mov eax, [rbp+var_3C]
mov [rbp+var_24], eax
mov edi, [rbp+var_24]
mov rsi, [rbp+var_38]
call _mi_kpos
mov [rbp+var_20], rax
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz loc_C22B0
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_30]
mov rax, [rbp+var_10]
mov rcx, [rax+108h]
mov r8, [rbp+var_38]
mov r9, [rbp+var_10]
add r9, 1D8h
call _mi_get_last_key
cmp rax, 0
jnz short loc_C23A7
jmp short $+2
loc_C239B:
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_C2447
loc_C23A7:
mov rdi, [rbp+var_10]
mov rax, [rbp+var_10]
mov rdx, [rax+108h]
mov rax, [rbp+var_10]
mov eax, [rax+1D8h]
add rdx, rax
xor esi, esi
call _mi_dpos
mov rcx, rax
mov rax, [rbp+var_10]
mov [rax+170h], rcx
mov rcx, [rbp+var_38]
mov rax, [rbp+var_10]
mov [rax+130h], rcx
mov rax, [rbp+var_10]
mov [rax+128h], rcx
mov ecx, [rbp+var_24]
mov rax, [rbp+var_10]
mov [rax+138h], ecx
mov rax, [rbp+var_18]
mov ecx, [rax+1Ch]
mov rax, [rbp+var_10]
mov [rax+13Ch], ecx
mov rax, [rbp+var_10]
mov rcx, [rax+190h]
mov rax, [rbp+var_10]
mov [rax+198h], rcx
mov rax, [rbp+var_10]
mov byte ptr [rax+33Dh], 0
mov rax, [rbp+var_10]
mov byte ptr [rax+33Ch], 0
jmp short $+2
loc_C243E:
jmp short $+2
loc_C2440:
mov [rbp+var_4], 0
loc_C2447:
mov eax, [rbp+var_4]
add rsp, 40h
pop rbp
retn
| long long mi_search_last(long long a1, long long a2, long long a3)
{
unsigned int v4; // [rsp+4h] [rbp-3Ch]
unsigned long long v5; // [rsp+8h] [rbp-38h]
unsigned __int16 *v6; // [rsp+10h] [rbp-30h]
long long v7; // [rsp+20h] [rbp-20h]
v7 = a3;
if ( a3 == -1 )
{
*(_DWORD *)my_thread_var(a1, (const char *)a2) = 120;
*(_QWORD *)(a1 + 368) = -1LL;
return (unsigned int)-1;
}
else
{
v6 = *(unsigned __int16 **)(a1 + 256);
do
{
if ( !mi_fetch_keypage((_QWORD *)a1, a2, v7, 3, (int)v6, 0) )
{
*(_QWORD *)(a1 + 368) = -1LL;
return (unsigned int)-1;
}
v5 = (unsigned long long)v6 + (_byteswap_ushort(*v6) & 0x7FFF);
if ( (*(_BYTE *)v6 & 0x80) != 0 )
v4 = *(_DWORD *)(*(_QWORD *)a1 + 380LL);
else
v4 = 0;
v7 = mi_kpos(v4, v5);
}
while ( v7 != -1 );
if ( mi_get_last_key(a1, a2, v6, *(_BYTE **)(a1 + 264), v5, (_DWORD *)(a1 + 472)) )
{
*(_QWORD *)(a1 + 368) = mi_dpos(a1, 0, *(unsigned int *)(a1 + 472) + *(_QWORD *)(a1 + 264));
*(_QWORD *)(a1 + 304) = v5;
*(_QWORD *)(a1 + 296) = v5;
*(_DWORD *)(a1 + 312) = v4;
*(_DWORD *)(a1 + 316) = *(_DWORD *)(a2 + 28);
*(_QWORD *)(a1 + 408) = *(_QWORD *)(a1 + 400);
*(_BYTE *)(a1 + 829) = 0;
*(_BYTE *)(a1 + 828) = 0;
return 0;
}
else
{
return (unsigned int)-1;
}
}
}
| _mi_search_last:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
CMP qword ptr [RBP + -0x20],-0x1
JNZ 0x001c22a1
CALL 0x001f6060
MOV dword ptr [RAX],0x78
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x170],-0x1
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001c2447
LAB_001c22a1:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x100]
MOV qword ptr [RBP + -0x30],RAX
LAB_001c22b0:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
MOV R8,qword ptr [RBP + -0x30]
MOV ECX,0x3
XOR R9D,R9D
CALL 0x001bdd70
CMP RAX,0x0
JNZ 0x001c22ee
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x170],-0x1
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001c2447
LAB_001c22ee:
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x30]
MOVZX ECX,byte ptr [RCX + 0x1]
MOVZX ECX,CX
MOV RDX,qword ptr [RBP + -0x30]
MOVZX EDX,byte ptr [RDX]
MOVZX EDX,DX
SHL EDX,0x8
OR ECX,EDX
MOVZX ECX,CX
AND ECX,0x7fff
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,byte ptr [RAX]
AND EAX,0x80
CMP EAX,0x0
JZ 0x001c2341
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x17c]
MOV dword ptr [RBP + -0x3c],EAX
JMP 0x001c2348
LAB_001c2341:
XOR EAX,EAX
MOV dword ptr [RBP + -0x3c],EAX
JMP 0x001c2348
LAB_001c2348:
MOV EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x24],EAX
MOV EDI,dword ptr [RBP + -0x24]
MOV RSI,qword ptr [RBP + -0x38]
CALL 0x001bece0
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,-0x1
JNZ 0x001c22b0
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x108]
MOV R8,qword ptr [RBP + -0x38]
MOV R9,qword ptr [RBP + -0x10]
ADD R9,0x1d8
CALL 0x001c1700
CMP RAX,0x0
JNZ 0x001c23a7
JMP 0x001c239b
LAB_001c239b:
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001c2447
LAB_001c23a7:
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x108]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x1d8]
ADD RDX,RAX
XOR ESI,ESI
CALL 0x001bef60
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x170],RCX
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x130],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x128],RCX
MOV ECX,dword ptr [RBP + -0x24]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x138],ECX
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RAX + 0x1c]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x13c],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x190]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x198],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x33d],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x33c],0x0
JMP 0x001c243e
LAB_001c243e:
JMP 0x001c2440
LAB_001c2440:
MOV dword ptr [RBP + -0x4],0x0
LAB_001c2447:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x40
POP RBP
RET
|
int4 _mi_search_last(long *param_1,long param_2,long param_3)
{
byte *pbVar1;
int4 *puVar2;
long lVar3;
byte *pbVar4;
int4 local_44;
long local_28;
int4 local_c;
if (param_3 == -1) {
puVar2 = (int4 *)_my_thread_var();
*puVar2 = 0x78;
param_1[0x2e] = -1;
local_c = 0xffffffff;
}
else {
pbVar1 = (byte *)param_1[0x20];
local_28 = param_3;
do {
lVar3 = _mi_fetch_keypage(param_1,param_2,local_28,3,pbVar1,0);
if (lVar3 == 0) {
param_1[0x2e] = -1;
return 0xffffffff;
}
pbVar4 = pbVar1 + ((uint)pbVar1[1] | (*pbVar1 & 0x7f) << 8);
if ((*pbVar1 & 0x80) == 0) {
local_44 = 0;
}
else {
local_44 = *(int4 *)(*param_1 + 0x17c);
}
local_28 = _mi_kpos(local_44,pbVar4);
} while (local_28 != -1);
lVar3 = _mi_get_last_key(param_1,param_2,pbVar1,param_1[0x21],pbVar4,param_1 + 0x3b);
if (lVar3 == 0) {
local_c = 0xffffffff;
}
else {
lVar3 = _mi_dpos(param_1,0,param_1[0x21] + (ulong)*(uint *)(param_1 + 0x3b));
param_1[0x2e] = lVar3;
param_1[0x26] = (long)pbVar4;
param_1[0x25] = (long)pbVar4;
*(int4 *)(param_1 + 0x27) = local_44;
*(int4 *)((long)param_1 + 0x13c) = *(int4 *)(param_2 + 0x1c);
param_1[0x33] = param_1[0x32];
*(int1 *)((long)param_1 + 0x33d) = 0;
*(int1 *)((long)param_1 + 0x33c) = 0;
local_c = 0;
}
}
return local_c;
}
| |
48,346 | mi_search_last | eloqsql/storage/myisam/mi_search.c | int _mi_search_last(register MI_INFO *info, register MI_KEYDEF *keyinfo,
register my_off_t pos)
{
uint nod_flag;
uchar *buff,*page;
DBUG_ENTER("_mi_search_last");
if (pos == HA_OFFSET_ERROR)
{
my_errno=HA_ERR_KEY_NOT_FOUND; /* Didn't find key */
info->lastpos= HA_OFFSET_ERROR;
DBUG_RETURN(-1);
}
buff=info->buff;
do
{
if (!_mi_fetch_keypage(info,keyinfo,pos,DFLT_INIT_HITS,buff,0))
{
info->lastpos= HA_OFFSET_ERROR;
DBUG_RETURN(-1);
}
page= buff+mi_getint(buff);
nod_flag=mi_test_if_nod(buff);
} while ((pos=_mi_kpos(nod_flag,page)) != HA_OFFSET_ERROR);
if (!_mi_get_last_key(info,keyinfo,buff,info->lastkey,page,
&info->lastkey_length))
DBUG_RETURN(-1);
info->lastpos=_mi_dpos(info,0,info->lastkey+info->lastkey_length);
info->int_keypos=info->int_maxpos=page;
info->int_nod_flag=nod_flag;
info->int_keytree_version=keyinfo->version;
info->last_search_keypage=info->last_keypage;
info->page_changed=info->buff_used=0;
DBUG_PRINT("exit",("found key at %lu",(ulong) info->lastpos));
DBUG_RETURN(0);
} | O3 | c | mi_search_last:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $-0x1, %rdx
je 0x8606d
movq %rdx, %rax
movq %rsi, %r14
movq 0x100(%rbx), %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
movl $0x3, %ecx
movq %r12, %r8
xorl %r9d, %r9d
callq 0x83ad4
testq %rax, %rax
je 0x86078
movzbl (%r12), %r15d
xorl %r13d, %r13d
testb %r15b, %r15b
jns 0x85fcb
movq (%rbx), %rax
movl 0x17c(%rax), %r13d
movzbl 0x1(%r12), %eax
andl $0x7f, %r15d
shll $0x8, %r15d
orq %rax, %r15
addq %r12, %r15
movl %r13d, %edi
movq %r15, %rsi
callq 0x8444e
cmpq $-0x1, %rax
jne 0x85f92
movq 0x108(%rbx), %rcx
leaq 0x1d8(%rbx), %r9
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r15, %r8
callq 0x8593e
testq %rax, %rax
je 0x86083
movl 0x1d8(%rbx), %edx
addq 0x108(%rbx), %rdx
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x8452d
movq %rax, 0x170(%rbx)
movq %r15, 0x130(%rbx)
movq %r15, 0x128(%rbx)
movl %r13d, 0x138(%rbx)
movl 0x1c(%r14), %eax
movl %eax, 0x13c(%rbx)
movq 0x190(%rbx), %rax
movq %rax, 0x198(%rbx)
movw $0x0, 0x33c(%rbx)
jmp 0x86089
callq 0xa1ac2
movl $0x78, (%rax)
movq $-0x1, 0x170(%rbx)
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _mi_search_last:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
cmp rdx, 0FFFFFFFFFFFFFFFFh
jz loc_8606D
mov rax, rdx
mov r14, rsi
mov r12, [rbx+100h]
loc_85F92:
mov rdi, rbx
mov rsi, r14
mov rdx, rax
mov ecx, 3
mov r8, r12
xor r9d, r9d
call _mi_fetch_keypage
test rax, rax
jz loc_86078
movzx r15d, byte ptr [r12]
xor r13d, r13d
test r15b, r15b
jns short loc_85FCB
mov rax, [rbx]
mov r13d, [rax+17Ch]
loc_85FCB:
movzx eax, byte ptr [r12+1]
and r15d, 7Fh
shl r15d, 8
or r15, rax
add r15, r12
mov edi, r13d
mov rsi, r15
call _mi_kpos
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_85F92
mov rcx, [rbx+108h]
lea r9, [rbx+1D8h]
mov rdi, rbx
mov rsi, r14
mov rdx, r12
mov r8, r15
call _mi_get_last_key
test rax, rax
jz short loc_86083
mov edx, [rbx+1D8h]
add rdx, [rbx+108h]
xor r12d, r12d
mov rdi, rbx
xor esi, esi
call _mi_dpos
mov [rbx+170h], rax
mov [rbx+130h], r15
mov [rbx+128h], r15
mov [rbx+138h], r13d
mov eax, [r14+1Ch]
mov [rbx+13Ch], eax
mov rax, [rbx+190h]
mov [rbx+198h], rax
mov word ptr [rbx+33Ch], 0
jmp short loc_86089
loc_8606D:
call _my_thread_var
mov dword ptr [rax], 78h ; 'x'
loc_86078:
mov qword ptr [rbx+170h], 0FFFFFFFFFFFFFFFFh
loc_86083:
mov r12d, 0FFFFFFFFh
loc_86089:
mov eax, r12d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long mi_search_last(long long a1, long long a2, unsigned long long a3)
{
unsigned long long v3; // rax
long long v4; // r12
unsigned int v5; // r13d
unsigned long long v6; // r15
unsigned int v7; // r12d
if ( a3 == -1LL )
{
*(_DWORD *)my_thread_var(a1) = 120;
}
else
{
v3 = a3;
v4 = *(_QWORD *)(a1 + 256);
while ( mi_fetch_keypage((_QWORD *)a1, a2, v3) )
{
v5 = 0;
if ( *(char *)v4 < 0 )
v5 = *(_DWORD *)(*(_QWORD *)a1 + 380LL);
v6 = v4 + (*(unsigned __int8 *)(v4 + 1) | (unsigned long long)((unsigned __int8)(*(_BYTE *)v4 & 0x7F) << 8));
v3 = mi_kpos(v5, v6);
if ( v3 == -1LL )
{
if ( !mi_get_last_key(a1, a2, (char *)v4, *(_BYTE **)(a1 + 264), v6, (_DWORD *)(a1 + 472)) )
return (unsigned int)-1;
v7 = 0;
*(_QWORD *)(a1 + 368) = mi_dpos((long long *)a1, 0, *(_QWORD *)(a1 + 264) + *(unsigned int *)(a1 + 472));
*(_QWORD *)(a1 + 304) = v6;
*(_QWORD *)(a1 + 296) = v6;
*(_DWORD *)(a1 + 312) = v5;
*(_DWORD *)(a1 + 316) = *(_DWORD *)(a2 + 28);
*(_QWORD *)(a1 + 408) = *(_QWORD *)(a1 + 400);
*(_WORD *)(a1 + 828) = 0;
return v7;
}
}
}
*(_QWORD *)(a1 + 368) = -1LL;
return (unsigned int)-1;
}
| _mi_search_last:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
CMP RDX,-0x1
JZ 0x0018606d
MOV RAX,RDX
MOV R14,RSI
MOV R12,qword ptr [RBX + 0x100]
LAB_00185f92:
MOV RDI,RBX
MOV RSI,R14
MOV RDX,RAX
MOV ECX,0x3
MOV R8,R12
XOR R9D,R9D
CALL 0x00183ad4
TEST RAX,RAX
JZ 0x00186078
MOVZX R15D,byte ptr [R12]
XOR R13D,R13D
TEST R15B,R15B
JNS 0x00185fcb
MOV RAX,qword ptr [RBX]
MOV R13D,dword ptr [RAX + 0x17c]
LAB_00185fcb:
MOVZX EAX,byte ptr [R12 + 0x1]
AND R15D,0x7f
SHL R15D,0x8
OR R15,RAX
ADD R15,R12
MOV EDI,R13D
MOV RSI,R15
CALL 0x0018444e
CMP RAX,-0x1
JNZ 0x00185f92
MOV RCX,qword ptr [RBX + 0x108]
LEA R9,[RBX + 0x1d8]
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R12
MOV R8,R15
CALL 0x0018593e
TEST RAX,RAX
JZ 0x00186083
MOV EDX,dword ptr [RBX + 0x1d8]
ADD RDX,qword ptr [RBX + 0x108]
XOR R12D,R12D
MOV RDI,RBX
XOR ESI,ESI
CALL 0x0018452d
MOV qword ptr [RBX + 0x170],RAX
MOV qword ptr [RBX + 0x130],R15
MOV qword ptr [RBX + 0x128],R15
MOV dword ptr [RBX + 0x138],R13D
MOV EAX,dword ptr [R14 + 0x1c]
MOV dword ptr [RBX + 0x13c],EAX
MOV RAX,qword ptr [RBX + 0x190]
MOV qword ptr [RBX + 0x198],RAX
MOV word ptr [RBX + 0x33c],0x0
JMP 0x00186089
LAB_0018606d:
CALL 0x001a1ac2
MOV dword ptr [RAX],0x78
LAB_00186078:
MOV qword ptr [RBX + 0x170],-0x1
LAB_00186083:
MOV R12D,0xffffffff
LAB_00186089:
MOV EAX,R12D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 _mi_search_last(long *param_1,long param_2,long param_3)
{
byte *pbVar1;
long lVar2;
int4 *puVar3;
int4 uVar4;
byte *pbVar5;
if (param_3 == -1) {
puVar3 = (int4 *)_my_thread_var();
*puVar3 = 0x78;
LAB_00186078:
param_1[0x2e] = -1;
}
else {
pbVar1 = (byte *)param_1[0x20];
do {
lVar2 = _mi_fetch_keypage(param_1,param_2,param_3,3,pbVar1,0);
if (lVar2 == 0) goto LAB_00186078;
uVar4 = 0;
if ((char)*pbVar1 < '\0') {
uVar4 = *(int4 *)(*param_1 + 0x17c);
}
pbVar5 = pbVar1 + ((ulong)((*pbVar1 & 0x7f) << 8) | (ulong)pbVar1[1]);
param_3 = _mi_kpos(uVar4,pbVar5);
} while (param_3 != -1);
lVar2 = _mi_get_last_key(param_1,param_2,pbVar1,param_1[0x21],pbVar5,param_1 + 0x3b);
if (lVar2 != 0) {
lVar2 = _mi_dpos(param_1,0,(ulong)*(uint *)(param_1 + 0x3b) + param_1[0x21]);
param_1[0x2e] = lVar2;
param_1[0x26] = (long)pbVar5;
param_1[0x25] = (long)pbVar5;
*(int4 *)(param_1 + 0x27) = uVar4;
*(int4 *)((long)param_1 + 0x13c) = *(int4 *)(param_2 + 0x1c);
param_1[0x33] = param_1[0x32];
*(int2 *)((long)param_1 + 0x33c) = 0;
return 0;
}
}
return 0xffffffff;
}
| |
48,347 | mi_mmap_pread | eloqsql/storage/myisam/mi_dynrec.c | size_t mi_mmap_pread(MI_INFO *info, uchar *Buffer,
size_t Count, my_off_t offset, myf MyFlags)
{
DBUG_PRINT("info", ("mi_read with mmap %d\n", info->dfile));
if (info->s->concurrent_insert)
mysql_rwlock_rdlock(&info->s->mmap_lock);
/*
The following test may fail in the following cases:
- We failed to remap a memory area (fragmented memory?)
- This thread has done some writes, but not yet extended the
memory mapped area.
*/
if (info->s->mmaped_length >= offset + Count)
{
memcpy(Buffer, info->s->file_map + offset, Count);
if (info->s->concurrent_insert)
mysql_rwlock_unlock(&info->s->mmap_lock);
return 0;
}
else
{
if (info->s->concurrent_insert)
mysql_rwlock_unlock(&info->s->mmap_lock);
return mysql_file_pread(info->dfile, Buffer, Count, offset, MyFlags);
}
} | O3 | c | mi_mmap_pread:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, -0x30(%rbp)
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r13
movq (%rdi), %rax
cmpb $0x0, 0x384(%rax)
je 0x3f9e8
leaq 0x4e0(%rax), %rdi
cmpq $0x0, 0x570(%rax)
jne 0x3fabe
callq 0x74a94
movq (%r13), %r14
leaq (%r15,%rbx), %rax
cmpq %rax, 0x4d0(%r14)
jae 0x3fa68
cmpb $0x0, 0x384(%r14)
je 0x3fa22
movq 0x570(%r14), %rdi
addq $0x4e0, %r14 # imm = 0x4E0
testq %rdi, %rdi
jne 0x3fb45
movq %r14, %rdi
callq 0x74bc2
movl 0x1c0(%r13), %r14d
leaq 0x30fab8(%rip), %rax # 0x34f4e8
movq (%rax), %rax
leaq -0x78(%rbp), %rdi
movl %r14d, %esi
movl $0x6, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x3fad4
movl %r14d, %edi
movq %r12, %rsi
movq %rbx, %rdx
movq %r15, %rcx
movq -0x30(%rbp), %r8
callq 0x709a0
movq %rax, %r15
jmp 0x3faac
addq 0x270(%r14), %r15
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x292f0
movq (%r13), %rbx
cmpb $0x0, 0x384(%rbx)
je 0x3faa9
movq 0x570(%rbx), %rdi
addq $0x4e0, %rbx # imm = 0x4E0
testq %rdi, %rdi
jne 0x3fb5a
movq %rbx, %rdi
callq 0x74bc2
xorl %r15d, %r15d
movq %r15, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6cd3c(%rip), %rsi # 0xac801
movl $0xac, %edx
callq 0x2c377
jmp 0x3f9e8
movq %rax, %r13
leaq 0x30fa0a(%rip), %rax # 0x34f4e8
movq (%rax), %rax
leaq 0x6cd19(%rip), %rdx # 0xac801
movq %r13, %rdi
movq %rbx, %rsi
movl $0xc0, %ecx
callq *0x210(%rax)
movl %r14d, %edi
movq %r12, %rsi
movq %rbx, %rdx
movq %r15, %rcx
movq -0x30(%rbp), %r14
movq %r14, %r8
callq 0x709a0
movq %rax, %r15
xorl %esi, %esi
testq %rax, %rax
cmovneq %rsi, %rbx
cmpq $-0x1, %rax
cmovneq %rax, %rsi
testb $0x6, %r14b
cmovneq %rbx, %rsi
leaq 0x30f9b4(%rip), %rax # 0x34f4e8
movq (%rax), %rax
movq %r13, %rdi
callq *0x218(%rax)
jmp 0x3faac
leaq 0x30f99c(%rip), %rax # 0x34f4e8
movq (%rax), %rax
callq *0x168(%rax)
jmp 0x3fa1a
leaq 0x30f987(%rip), %rax # 0x34f4e8
movq (%rax), %rax
callq *0x168(%rax)
jmp 0x3faa1
| mi_mmap_pread:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov [rbp+var_30], r8
mov r15, rcx
mov rbx, rdx
mov r12, rsi
mov r13, rdi
mov rax, [rdi]
cmp byte ptr [rax+384h], 0
jz short loc_3F9E8
lea rdi, [rax+4E0h]
cmp qword ptr [rax+570h], 0
jnz loc_3FABE
call my_rw_rdlock
loc_3F9E8:
mov r14, [r13+0]
lea rax, [r15+rbx]
cmp [r14+4D0h], rax
jnb short loc_3FA68
cmp byte ptr [r14+384h], 0
jz short loc_3FA22
mov rdi, [r14+570h]
add r14, 4E0h
test rdi, rdi
jnz loc_3FB45
loc_3FA1A:
mov rdi, r14
call my_rw_unlock
loc_3FA22:
mov r14d, [r13+1C0h]
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_78]
mov esi, r14d
mov edx, 6
call qword ptr [rax+158h]
test rax, rax
jnz loc_3FAD4
mov edi, r14d
mov rsi, r12
mov rdx, rbx
mov rcx, r15
mov r8, [rbp+var_30]
call my_pread
mov r15, rax
jmp short loc_3FAAC
loc_3FA68:
add r15, [r14+270h]
mov rdi, r12
mov rsi, r15
mov rdx, rbx
call _memcpy
mov rbx, [r13+0]
cmp byte ptr [rbx+384h], 0
jz short loc_3FAA9
mov rdi, [rbx+570h]
add rbx, 4E0h
test rdi, rdi
jnz loc_3FB5A
loc_3FAA1:
mov rdi, rbx
call my_rw_unlock
loc_3FAA9:
xor r15d, r15d
loc_3FAAC:
mov rax, r15
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3FABE:
lea rsi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 0ACh
call psi_rwlock_rdlock
jmp loc_3F9E8
loc_3FAD4:
mov r13, rax
lea rax, PSI_server
mov rax, [rax]
lea rdx, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r13
mov rsi, rbx
mov ecx, 0C0h
call qword ptr [rax+210h]
mov edi, r14d
mov rsi, r12
mov rdx, rbx
mov rcx, r15
mov r14, [rbp+var_30]
mov r8, r14
call my_pread
mov r15, rax
xor esi, esi
test rax, rax
cmovnz rbx, rsi
cmp rax, 0FFFFFFFFFFFFFFFFh
cmovnz rsi, rax
test r14b, 6
cmovnz rsi, rbx
lea rax, PSI_server
mov rax, [rax]
mov rdi, r13
call qword ptr [rax+218h]
jmp loc_3FAAC
loc_3FB45:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+168h]
jmp loc_3FA1A
loc_3FB5A:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+168h]
jmp loc_3FAA1
| long long mi_mmap_pread(_DWORD *a1, long long a2, long long a3, long long a4, long long a5)
{
long long v8; // rax
long long v9; // rdi
long long v10; // r14
long long v11; // rdi
long long v12; // r14
unsigned int v13; // r14d
long long v14; // rax
long long v15; // r15
long long v16; // rbx
long long v17; // rdi
long long v18; // rbx
long long v20; // r13
_BYTE v21[72]; // [rsp+8h] [rbp-78h] BYREF
long long v22; // [rsp+50h] [rbp-30h]
v22 = a5;
v8 = *(_QWORD *)a1;
if ( *(_BYTE *)(*(_QWORD *)a1 + 900LL) )
{
v9 = v8 + 1248;
if ( *(_QWORD *)(v8 + 1392) )
psi_rwlock_rdlock(v9, (long long)"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_dynrec.c", 0xACu);
else
my_rw_rdlock(v9);
}
v10 = *(_QWORD *)a1;
if ( *(_QWORD *)(*(_QWORD *)a1 + 1232LL) >= (unsigned long long)(a4 + a3) )
{
memcpy(a2, *(_QWORD *)(v10 + 624) + a4, a3);
v16 = *(_QWORD *)a1;
if ( *(_BYTE *)(*(_QWORD *)a1 + 900LL) )
{
v17 = *(_QWORD *)(v16 + 1392);
v18 = v16 + 1248;
if ( v17 )
(*((void (**)(void))PSI_server + 45))();
my_rw_unlock(v18);
}
return 0LL;
}
else
{
if ( *(_BYTE *)(v10 + 900) )
{
v11 = *(_QWORD *)(v10 + 1392);
v12 = v10 + 1248;
if ( v11 )
(*((void (**)(void))PSI_server + 45))();
my_rw_unlock(v12);
}
v13 = a1[112];
v14 = (*((long long ( **)(_BYTE *, _QWORD, long long))PSI_server + 43))(v21, v13, 6LL);
if ( v14 )
{
v20 = v14;
(*((void ( **)(long long, long long, const char *, long long))PSI_server + 66))(
v14,
a3,
"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_dynrec.c",
192LL);
v15 = my_pread(v13, a2, a3, a4, v22);
(*((void ( **)(long long))PSI_server + 67))(v20);
}
else
{
return my_pread(v13, a2, a3, a4, v22);
}
}
return v15;
}
| mi_mmap_pread:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV qword ptr [RBP + -0x30],R8
MOV R15,RCX
MOV RBX,RDX
MOV R12,RSI
MOV R13,RDI
MOV RAX,qword ptr [RDI]
CMP byte ptr [RAX + 0x384],0x0
JZ 0x0013f9e8
LEA RDI,[RAX + 0x4e0]
CMP qword ptr [RAX + 0x570],0x0
JNZ 0x0013fabe
CALL 0x00174a94
LAB_0013f9e8:
MOV R14,qword ptr [R13]
LEA RAX,[R15 + RBX*0x1]
CMP qword ptr [R14 + 0x4d0],RAX
JNC 0x0013fa68
CMP byte ptr [R14 + 0x384],0x0
JZ 0x0013fa22
MOV RDI,qword ptr [R14 + 0x570]
ADD R14,0x4e0
TEST RDI,RDI
JNZ 0x0013fb45
LAB_0013fa1a:
MOV RDI,R14
CALL 0x00174bc2
LAB_0013fa22:
MOV R14D,dword ptr [R13 + 0x1c0]
LEA RAX,[0x44f4e8]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x78]
MOV ESI,R14D
MOV EDX,0x6
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x0013fad4
MOV EDI,R14D
MOV RSI,R12
MOV RDX,RBX
MOV RCX,R15
MOV R8,qword ptr [RBP + -0x30]
CALL 0x001709a0
MOV R15,RAX
JMP 0x0013faac
LAB_0013fa68:
ADD R15,qword ptr [R14 + 0x270]
MOV RDI,R12
MOV RSI,R15
MOV RDX,RBX
CALL 0x001292f0
MOV RBX,qword ptr [R13]
CMP byte ptr [RBX + 0x384],0x0
JZ 0x0013faa9
MOV RDI,qword ptr [RBX + 0x570]
ADD RBX,0x4e0
TEST RDI,RDI
JNZ 0x0013fb5a
LAB_0013faa1:
MOV RDI,RBX
CALL 0x00174bc2
LAB_0013faa9:
XOR R15D,R15D
LAB_0013faac:
MOV RAX,R15
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013fabe:
LEA RSI,[0x1ac801]
MOV EDX,0xac
CALL 0x0012c377
JMP 0x0013f9e8
LAB_0013fad4:
MOV R13,RAX
LEA RAX,[0x44f4e8]
MOV RAX,qword ptr [RAX]
LEA RDX,[0x1ac801]
MOV RDI,R13
MOV RSI,RBX
MOV ECX,0xc0
CALL qword ptr [RAX + 0x210]
MOV EDI,R14D
MOV RSI,R12
MOV RDX,RBX
MOV RCX,R15
MOV R14,qword ptr [RBP + -0x30]
MOV R8,R14
CALL 0x001709a0
MOV R15,RAX
XOR ESI,ESI
TEST RAX,RAX
CMOVNZ RBX,RSI
CMP RAX,-0x1
CMOVNZ RSI,RAX
TEST R14B,0x6
CMOVNZ RSI,RBX
LEA RAX,[0x44f4e8]
MOV RAX,qword ptr [RAX]
MOV RDI,R13
CALL qword ptr [RAX + 0x218]
JMP 0x0013faac
LAB_0013fb45:
LEA RAX,[0x44f4e8]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x168]
JMP 0x0013fa1a
LAB_0013fb5a:
LEA RAX,[0x44f4e8]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x168]
JMP 0x0013faa1
|
size_t mi_mmap_pread(long *param_1,void *param_2,size_t param_3,long param_4,ulong param_5)
{
int4 uVar1;
ulong uVar2;
long lVar3;
size_t sVar4;
size_t sVar5;
int1 local_80 [72];
ulong local_38;
lVar3 = *param_1;
local_38 = param_5;
if (*(char *)(lVar3 + 900) != '\0') {
if (*(long *)(lVar3 + 0x570) == 0) {
my_rw_rdlock();
}
else {
psi_rwlock_rdlock(lVar3 + 0x4e0,
"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_dynrec.c",0xac);
}
}
lVar3 = *param_1;
if (*(ulong *)(lVar3 + 0x4d0) < param_4 + param_3) {
if (*(char *)(lVar3 + 900) != '\0') {
if (*(long *)(lVar3 + 0x570) != 0) {
(**(code **)(PSI_server + 0x168))();
}
my_rw_unlock(lVar3 + 0x4e0);
}
uVar1 = (int4)param_1[0x38];
lVar3 = (**(code **)(PSI_server + 0x158))(local_80,uVar1,6);
if (lVar3 == 0) {
sVar4 = my_pread(uVar1,param_2,param_3,param_4,local_38);
}
else {
(**(code **)(PSI_server + 0x210))
(lVar3,param_3,"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_dynrec.c"
,0xc0);
uVar2 = local_38;
sVar4 = my_pread(uVar1,param_2,param_3,param_4,local_38);
if (sVar4 != 0) {
param_3 = 0;
}
sVar5 = 0;
if (sVar4 != 0xffffffffffffffff) {
sVar5 = sVar4;
}
if ((uVar2 & 6) != 0) {
sVar5 = param_3;
}
(**(code **)(PSI_server + 0x218))(lVar3,sVar5);
}
}
else {
memcpy(param_2,(void *)(param_4 + *(long *)(lVar3 + 0x270)),param_3);
lVar3 = *param_1;
if (*(char *)(lVar3 + 900) != '\0') {
if (*(long *)(lVar3 + 0x570) != 0) {
(**(code **)(PSI_server + 0x168))();
}
my_rw_unlock(lVar3 + 0x4e0);
}
sVar4 = 0;
}
return sVar4;
}
| |
48,348 | minja::Value::insert(unsigned long, minja::Value const&) | monkey531[P]llama/common/minja.hpp | void insert(size_t index, const Value& v) {
if (!array_)
throw std::runtime_error("Value is not an array: " + dump());
array_->insert(array_->begin() + index, v);
} | O3 | cpp | minja::Value::insert(unsigned long, minja::Value const&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xa0c86
leaq (%rsi,%rsi,4), %rsi
shlq $0x4, %rsi
addq (%rdi), %rsi
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0xa23be
movl $0x10, %edi
callq 0x1b450
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x941f8
leaq 0x5d676(%rip), %rsi # 0xfe322
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x86aa5
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x1be80
xorl %ebp, %ebp
movq 0x9a316(%rip), %rsi # 0x13afe8
movq 0x9a27f(%rip), %rdx # 0x13af58
movq %rbx, %rdi
callq 0x1bf90
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa0cff
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1b8f0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa0d1a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1b8f0
testb %bpl, %bpl
jne 0xa0d44
jmp 0xa0d4c
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa0d44
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1b8f0
jmp 0xa0d44
movq %rax, %r14
movq %rbx, %rdi
callq 0x1b680
movq %r14, %rdi
callq 0x1c020
| _ZN5minja5Value6insertEmRKS0_:
push rbp
push r14
push rbx
sub rsp, 40h
mov r14, rdi
mov rdi, [rdi+10h]
test rdi, rdi
jz short loc_A0C86
lea rsi, [rsi+rsi*4]
shl rsi, 4
add rsi, [rdi]
add rsp, 40h
pop rbx
pop r14
pop rbp
jmp _ZNSt6vectorIN5minja5ValueESaIS1_EE6insertEN9__gnu_cxx17__normal_iteratorIPKS1_S3_EERS6_; std::vector<minja::Value>::insert(__gnu_cxx::__normal_iterator<minja::Value const*,std::vector<minja::Value>>,minja::Value const&)
loc_A0C86:
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; "Value is not an array: "
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:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+58h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A0CFF
mov rsi, [rsp+58h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A0CFF:
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A0D1A
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A0D1A:
test bpl, bpl
jnz short loc_A0D44
jmp short loc_A0D4C
mov r14, rax
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A0D44
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_A0D44
mov r14, rax
loc_A0D44:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_A0D4C:
mov rdi, r14
call __Unwind_Resume
| long long minja::Value::insert(minja::Value *this, long long a2, const minja::Value *a3)
{
_QWORD *v4; // rdi
void *exception; // rbx
_BYTE v7[16]; // [rsp+0h] [rbp-58h] BYREF
_BYTE v8[16]; // [rsp+20h] [rbp-38h] BYREF
v4 = (_QWORD *)*((_QWORD *)this + 2);
if ( !v4 )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v7, (long long)this, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v8, (long long)"Value is not an array: ", (long long)v7);
std::runtime_error::runtime_error(exception, v8);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
return std::vector<minja::Value>::insert(v4, *v4 + 80 * a2, a3);
}
| insert:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV R14,RDI
MOV RDI,qword ptr [RDI + 0x10]
TEST RDI,RDI
JZ 0x001a0c86
LEA RSI,[RSI + RSI*0x4]
SHL RSI,0x4
ADD RSI,qword ptr [RDI]
ADD RSP,0x40
POP RBX
POP R14
POP RBP
JMP 0x001a23be
LAB_001a0c86:
MOV EDI,0x10
CALL 0x0011b450
MOV RBX,RAX
LAB_001a0c93:
MOV RDI,RSP
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x001941f8
LAB_001a0ca5:
LEA RSI,[0x1fe322]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x00186aa5
MOV BPL,0x1
LAB_001a0cbc:
LEA RSI,[RSP + 0x20]
MOV RDI,RBX
CALL 0x0011be80
XOR EBP,EBP
MOV RSI,qword ptr [0x0023afe8]
MOV RDX,qword ptr [0x0023af58]
MOV RDI,RBX
CALL 0x0011bf90
|
/* minja::Value::insert(unsigned long, minja::Value const&) */
void minja::Value::insert(ulong param_1,Value *param_2)
{
vector<minja::Value,std::allocator<minja::Value>> *pvVar1;
runtime_error *this;
int1 auStack_58 [32];
string local_38 [32];
pvVar1 = *(vector<minja::Value,std::allocator<minja::Value>> **)(param_1 + 0x10);
if (pvVar1 != (vector<minja::Value,std::allocator<minja::Value>> *)0x0) {
std::vector<minja::Value,std::allocator<minja::Value>>::insert
(pvVar1,(long)param_2 * 0x50 + *(long *)pvVar1);
return;
}
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001a0c93 to 001a0ca4 has its CatchHandler @ 001a0d41 */
dump_abi_cxx11_((int)auStack_58,SUB81(param_1,0));
/* try { // try from 001a0ca5 to 001a0cb8 has its CatchHandler @ 001a0d21 */
std::operator+((char *)local_38,(string *)"Value is not an array: ");
/* try { // try from 001a0cbc to 001a0ce0 has its CatchHandler @ 001a0ce1 */
std::runtime_error::runtime_error(this,local_38);
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_0023afe8,PTR__runtime_error_0023af58);
}
| |
48,349 | pvio_socket_async_write | eloqsql/libmariadb/plugins/pvio/pvio_socket.c | ssize_t pvio_socket_async_write(MARIADB_PVIO *pvio, const uchar *buffer, size_t length)
{
ssize_t r= -1;
struct st_pvio_socket *csock= NULL;
#ifndef _WIN32
int write_flags= MSG_DONTWAIT;
#ifdef MSG_NOSIGNAL
write_flags|= MSG_NOSIGNAL;
#endif
#endif
if (!pvio || !pvio->data)
return -1;
csock= (struct st_pvio_socket *)pvio->data;
#ifndef WIN32
r= ma_send(csock->socket, buffer, length, write_flags);
#else
/* Windows doesn't support MSG_DONTWAIT, so we need to set
socket to non blocking */
pvio_socket_blocking(pvio, 0, 0);
r= send(csock->socket, (const char *)buffer, (int)length, 0);
#endif
return r;
} | O0 | c | pvio_socket_async_write:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $-0x1, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x40, -0x34(%rbp)
movl -0x34(%rbp), %eax
orl $0x4000, %eax # imm = 0x4000
movl %eax, -0x34(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3e4a7
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x3e4b1
movq $-0x1, -0x8(%rbp)
jmp 0x3e4de
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl (%rax), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x34(%rbp), %ecx
callq 0x3f920
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| pvio_socket_async_write:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], 0FFFFFFFFFFFFFFFFh
mov [rbp+var_30], 0
mov [rbp+var_34], 40h ; '@'
mov eax, [rbp+var_34]
or eax, 4000h
mov [rbp+var_34], eax
cmp [rbp+var_10], 0
jz short loc_3E4A7
mov rax, [rbp+var_10]
cmp qword ptr [rax], 0
jnz short loc_3E4B1
loc_3E4A7:
mov [rbp+var_8], 0FFFFFFFFFFFFFFFFh
jmp short loc_3E4DE
loc_3E4B1:
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
mov edi, [rax]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
mov ecx, [rbp+var_34]
call ma_send
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
mov [rbp+var_8], rax
loc_3E4DE:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
| long long pvio_socket_async_write(_QWORD *a1, long long a2, long long a3)
{
if ( a1 && *a1 )
return ma_send(*(unsigned int *)*a1, a2, a3, 16448LL);
else
return -1LL;
}
| pvio_socket_async_write:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],-0x1
MOV qword ptr [RBP + -0x30],0x0
MOV dword ptr [RBP + -0x34],0x40
MOV EAX,dword ptr [RBP + -0x34]
OR EAX,0x4000
MOV dword ptr [RBP + -0x34],EAX
CMP qword ptr [RBP + -0x10],0x0
JZ 0x0013e4a7
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX],0x0
JNZ 0x0013e4b1
LAB_0013e4a7:
MOV qword ptr [RBP + -0x8],-0x1
JMP 0x0013e4de
LAB_0013e4b1:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV EDI,dword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x34]
CALL 0x0013f920
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x8],RAX
LAB_0013e4de:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
int8 pvio_socket_async_write(long *param_1,int8 param_2,int8 param_3)
{
int8 local_10;
if ((param_1 == (long *)0x0) || (*param_1 == 0)) {
local_10 = 0xffffffffffffffff;
}
else {
local_10 = ma_send(*(int4 *)*param_1,param_2,param_3,0x4040);
}
return local_10;
}
| |
48,350 | optional_chain_test | bluesky950520[P]quickjs/quickjs.c | static void optional_chain_test(JSParseState *s, int *poptional_chaining_label,
int drop_count)
{
int label_next, i;
if (*poptional_chaining_label < 0)
*poptional_chaining_label = new_label(s);
/* XXX: could be more efficient with a specific opcode */
emit_op(s, OP_dup);
emit_op(s, OP_is_undefined_or_null);
label_next = emit_goto(s, OP_if_false, -1);
for(i = 0; i < drop_count; i++)
emit_op(s, OP_drop);
emit_op(s, OP_undefined);
emit_goto(s, OP_goto, *poptional_chaining_label);
emit_label(s, label_next);
} | O0 | c | optional_chain_test:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x18(%rsp), %rax
cmpl $0x0, (%rax)
jge 0xb40bf
movq 0x20(%rsp), %rdi
callq 0xad0a0
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movq 0x20(%rsp), %rdi
movl $0x11, %esi
callq 0xa3210
movq 0x20(%rsp), %rdi
movl $0xb0, %esi
callq 0xa3210
movq 0x20(%rsp), %rdi
movl $0x69, %esi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
callq 0xad0c0
movl %eax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0xb4123
movq 0x20(%rsp), %rdi
movl $0xe, %esi
callq 0xa3210
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xb40fd
movq 0x20(%rsp), %rdi
movl $0x6, %esi
callq 0xa3210
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movl (%rax), %edx
movl $0x6b, %esi
callq 0xad0c0
movq 0x20(%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0xad2c0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
| optional_chain_test:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov [rsp+28h+var_10], rsi
mov [rsp+28h+var_14], edx
mov rax, [rsp+28h+var_10]
cmp dword ptr [rax], 0
jge short loc_B40BF
mov rdi, [rsp+28h+var_8]
call new_label
mov ecx, eax
mov rax, [rsp+28h+var_10]
mov [rax], ecx
loc_B40BF:
mov rdi, [rsp+28h+var_8]
mov esi, 11h
call emit_op
mov rdi, [rsp+28h+var_8]
mov esi, 0B0h
call emit_op
mov rdi, [rsp+28h+var_8]
mov esi, 69h ; 'i'
mov edx, 0FFFFFFFFh
call emit_goto
mov [rsp+28h+var_18], eax
mov [rsp+28h+var_1C], 0
loc_B40FD:
mov eax, [rsp+28h+var_1C]
cmp eax, [rsp+28h+var_14]
jge short loc_B4123
mov rdi, [rsp+28h+var_8]
mov esi, 0Eh
call emit_op
mov eax, [rsp+28h+var_1C]
add eax, 1
mov [rsp+28h+var_1C], eax
jmp short loc_B40FD
loc_B4123:
mov rdi, [rsp+28h+var_8]
mov esi, 6
call emit_op
mov rdi, [rsp+28h+var_8]
mov rax, [rsp+28h+var_10]
mov edx, [rax]
mov esi, 6Bh ; 'k'
call emit_goto
mov rdi, [rsp+28h+var_8]
mov esi, [rsp+28h+var_18]
call emit_label
add rsp, 28h
retn
| long long optional_chain_test(long long a1, int *a2, int a3)
{
int i; // [rsp+Ch] [rbp-1Ch]
int v5; // [rsp+10h] [rbp-18h]
if ( *a2 < 0 )
*a2 = new_label(a1);
emit_op(a1, 17);
emit_op(a1, 176);
v5 = emit_goto(a1, 105, -1);
for ( i = 0; i < a3; ++i )
emit_op(a1, 14);
emit_op(a1, 6);
emit_goto(a1, 107, *a2);
return emit_label(a1, v5);
}
| optional_chain_test:
SUB RSP,0x28
MOV qword ptr [RSP + 0x20],RDI
MOV qword ptr [RSP + 0x18],RSI
MOV dword ptr [RSP + 0x14],EDX
MOV RAX,qword ptr [RSP + 0x18]
CMP dword ptr [RAX],0x0
JGE 0x001b40bf
MOV RDI,qword ptr [RSP + 0x20]
CALL 0x001ad0a0
MOV ECX,EAX
MOV RAX,qword ptr [RSP + 0x18]
MOV dword ptr [RAX],ECX
LAB_001b40bf:
MOV RDI,qword ptr [RSP + 0x20]
MOV ESI,0x11
CALL 0x001a3210
MOV RDI,qword ptr [RSP + 0x20]
MOV ESI,0xb0
CALL 0x001a3210
MOV RDI,qword ptr [RSP + 0x20]
MOV ESI,0x69
MOV EDX,0xffffffff
CALL 0x001ad0c0
MOV dword ptr [RSP + 0x10],EAX
MOV dword ptr [RSP + 0xc],0x0
LAB_001b40fd:
MOV EAX,dword ptr [RSP + 0xc]
CMP EAX,dword ptr [RSP + 0x14]
JGE 0x001b4123
MOV RDI,qword ptr [RSP + 0x20]
MOV ESI,0xe
CALL 0x001a3210
MOV EAX,dword ptr [RSP + 0xc]
ADD EAX,0x1
MOV dword ptr [RSP + 0xc],EAX
JMP 0x001b40fd
LAB_001b4123:
MOV RDI,qword ptr [RSP + 0x20]
MOV ESI,0x6
CALL 0x001a3210
MOV RDI,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RSP + 0x18]
MOV EDX,dword ptr [RAX]
MOV ESI,0x6b
CALL 0x001ad0c0
MOV RDI,qword ptr [RSP + 0x20]
MOV ESI,dword ptr [RSP + 0x10]
CALL 0x001ad2c0
ADD RSP,0x28
RET
|
void optional_chain_test(int8 param_1,int *param_2,int param_3)
{
int iVar1;
int4 uVar2;
int4 local_1c;
if (*param_2 < 0) {
iVar1 = new_label(param_1);
*param_2 = iVar1;
}
emit_op(param_1,0x11);
emit_op(param_1,0xb0);
uVar2 = emit_goto(param_1,0x69,0xffffffff);
for (local_1c = 0; local_1c < param_3; local_1c = local_1c + 1) {
emit_op(param_1,0xe);
}
emit_op(param_1,6);
emit_goto(param_1,0x6b,*param_2);
emit_label(param_1,uVar2);
return;
}
| |
48,351 | optional_chain_test | bluesky950520[P]quickjs/quickjs.c | static void optional_chain_test(JSParseState *s, int *poptional_chaining_label,
int drop_count)
{
int label_next, i;
if (*poptional_chaining_label < 0)
*poptional_chaining_label = new_label(s);
/* XXX: could be more efficient with a specific opcode */
emit_op(s, OP_dup);
emit_op(s, OP_is_undefined_or_null);
label_next = emit_goto(s, OP_if_false, -1);
for(i = 0; i < drop_count; i++)
emit_op(s, OP_drop);
emit_op(s, OP_undefined);
emit_goto(s, OP_goto, *poptional_chaining_label);
emit_label(s, label_next);
} | O1 | c | optional_chain_test:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, (%rsi)
jns 0x6e4d4
movq 0x90(%rbx), %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x70815
movl %eax, (%r14)
movq 0x90(%rbx), %rax
movl $0x138, %r15d # imm = 0x138
leaq (%rax,%r15), %rdi
movl 0x140(%rax), %ecx
movl %ecx, 0x168(%rax)
movl $0x11, %esi
callq 0x1f52c
movq 0x90(%rbx), %rax
addq %rax, %r15
movl 0x140(%rax), %ecx
movl %ecx, 0x168(%rax)
movq %r15, %rdi
movl $0xb0, %esi
callq 0x1f52c
movq %rbx, %rdi
movl $0x69, %esi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
callq 0x68ddf
movl %eax, %r15d
testl %ebp, %ebp
jle 0x6e55f
movq 0x90(%rbx), %rax
leaq 0x138(%rax), %rdi
movl 0x140(%rax), %ecx
movl %ecx, 0x168(%rax)
movl $0xe, %esi
callq 0x1f52c
decl %ebp
jne 0x6e537
movq 0x90(%rbx), %rax
leaq 0x138(%rax), %rdi
movl 0x140(%rax), %ecx
movl %ecx, 0x168(%rax)
movl $0x6, %esi
callq 0x1f52c
movl (%r14), %edx
movq %rbx, %rdi
movl $0x6b, %esi
callq 0x68ddf
movq %rbx, %rdi
movl %r15d, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x68f4d
| optional_chain_test:
push rbp
push r15
push r14
push rbx
push rax
mov ebp, edx
mov r14, rsi
mov rbx, rdi
cmp dword ptr [rsi], 0
jns short loc_6E4D4
mov rdi, [rbx+90h]
mov esi, 0FFFFFFFFh
call new_label_fd
mov [r14], eax
loc_6E4D4:
mov rax, [rbx+90h]
mov r15d, 138h
lea rdi, [rax+r15]
mov ecx, [rax+140h]
mov [rax+168h], ecx
mov esi, 11h
call dbuf_putc
mov rax, [rbx+90h]
add r15, rax
mov ecx, [rax+140h]
mov [rax+168h], ecx
mov rdi, r15
mov esi, 0B0h
call dbuf_putc
mov rdi, rbx
mov esi, 69h ; 'i'
mov edx, 0FFFFFFFFh
call emit_goto
mov r15d, eax
test ebp, ebp
jle short loc_6E55F
loc_6E537:
mov rax, [rbx+90h]
lea rdi, [rax+138h]
mov ecx, [rax+140h]
mov [rax+168h], ecx
mov esi, 0Eh
call dbuf_putc
dec ebp
jnz short loc_6E537
loc_6E55F:
mov rax, [rbx+90h]
lea rdi, [rax+138h]
mov ecx, [rax+140h]
mov [rax+168h], ecx
mov esi, 6
call dbuf_putc
mov edx, [r14]
mov rdi, rbx
mov esi, 6Bh ; 'k'
call emit_goto
mov rdi, rbx
mov esi, r15d
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
jmp emit_label
| long long optional_chain_test(long long a1, int *a2, int a3)
{
long long v4; // rax
long long v5; // rax
int v6; // r15d
long long v7; // rax
long long v8; // rax
if ( *a2 < 0 )
*a2 = new_label_fd(*(_QWORD *)(a1 + 144), 0xFFFFFFFFLL);
v4 = *(_QWORD *)(a1 + 144);
*(_DWORD *)(v4 + 360) = *(_DWORD *)(v4 + 320);
dbuf_putc((_QWORD *)(v4 + 312), 17);
v5 = *(_QWORD *)(a1 + 144);
*(_DWORD *)(v5 + 360) = *(_DWORD *)(v5 + 320);
dbuf_putc((_QWORD *)(v5 + 312), 176);
v6 = emit_goto(a1, 105, -1);
if ( a3 > 0 )
{
do
{
v7 = *(_QWORD *)(a1 + 144);
*(_DWORD *)(v7 + 360) = *(_DWORD *)(v7 + 320);
dbuf_putc((_QWORD *)(v7 + 312), 14);
--a3;
}
while ( a3 );
}
v8 = *(_QWORD *)(a1 + 144);
*(_DWORD *)(v8 + 360) = *(_DWORD *)(v8 + 320);
dbuf_putc((_QWORD *)(v8 + 312), 6);
emit_goto(a1, 107, *a2);
return emit_label(a1, v6);
}
| optional_chain_test:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV EBP,EDX
MOV R14,RSI
MOV RBX,RDI
CMP dword ptr [RSI],0x0
JNS 0x0016e4d4
MOV RDI,qword ptr [RBX + 0x90]
MOV ESI,0xffffffff
CALL 0x00170815
MOV dword ptr [R14],EAX
LAB_0016e4d4:
MOV RAX,qword ptr [RBX + 0x90]
MOV R15D,0x138
LEA RDI,[RAX + R15*0x1]
MOV ECX,dword ptr [RAX + 0x140]
MOV dword ptr [RAX + 0x168],ECX
MOV ESI,0x11
CALL 0x0011f52c
MOV RAX,qword ptr [RBX + 0x90]
ADD R15,RAX
MOV ECX,dword ptr [RAX + 0x140]
MOV dword ptr [RAX + 0x168],ECX
MOV RDI,R15
MOV ESI,0xb0
CALL 0x0011f52c
MOV RDI,RBX
MOV ESI,0x69
MOV EDX,0xffffffff
CALL 0x00168ddf
MOV R15D,EAX
TEST EBP,EBP
JLE 0x0016e55f
LAB_0016e537:
MOV RAX,qword ptr [RBX + 0x90]
LEA RDI,[RAX + 0x138]
MOV ECX,dword ptr [RAX + 0x140]
MOV dword ptr [RAX + 0x168],ECX
MOV ESI,0xe
CALL 0x0011f52c
DEC EBP
JNZ 0x0016e537
LAB_0016e55f:
MOV RAX,qword ptr [RBX + 0x90]
LEA RDI,[RAX + 0x138]
MOV ECX,dword ptr [RAX + 0x140]
MOV dword ptr [RAX + 0x168],ECX
MOV ESI,0x6
CALL 0x0011f52c
MOV EDX,dword ptr [R14]
MOV RDI,RBX
MOV ESI,0x6b
CALL 0x00168ddf
MOV RDI,RBX
MOV ESI,R15D
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
JMP 0x00168f4d
|
void optional_chain_test(long param_1,int *param_2,int param_3)
{
long lVar1;
int iVar2;
int4 uVar3;
if (*param_2 < 0) {
iVar2 = new_label_fd(*(int8 *)(param_1 + 0x90),0xffffffff);
*param_2 = iVar2;
}
lVar1 = *(long *)(param_1 + 0x90);
*(int4 *)(lVar1 + 0x168) = *(int4 *)(lVar1 + 0x140);
dbuf_putc(lVar1 + 0x138,0x11);
lVar1 = *(long *)(param_1 + 0x90);
*(int4 *)(lVar1 + 0x168) = *(int4 *)(lVar1 + 0x140);
dbuf_putc(lVar1 + 0x138,0xb0);
uVar3 = emit_goto(param_1,0x69,0xffffffff);
if (0 < param_3) {
do {
lVar1 = *(long *)(param_1 + 0x90);
*(int4 *)(lVar1 + 0x168) = *(int4 *)(lVar1 + 0x140);
dbuf_putc(lVar1 + 0x138,0xe);
param_3 = param_3 + -1;
} while (param_3 != 0);
}
lVar1 = *(long *)(param_1 + 0x90);
*(int4 *)(lVar1 + 0x168) = *(int4 *)(lVar1 + 0x140);
dbuf_putc(lVar1 + 0x138,6);
emit_goto(param_1,0x6b,*param_2);
emit_label(param_1,uVar3);
return;
}
| |
48,352 | optional_chain_test | bluesky950520[P]quickjs/quickjs.c | static void optional_chain_test(JSParseState *s, int *poptional_chaining_label,
int drop_count)
{
int label_next, i;
if (*poptional_chaining_label < 0)
*poptional_chaining_label = new_label(s);
/* XXX: could be more efficient with a specific opcode */
emit_op(s, OP_dup);
emit_op(s, OP_is_undefined_or_null);
label_next = emit_goto(s, OP_if_false, -1);
for(i = 0; i < drop_count; i++)
emit_op(s, OP_drop);
emit_op(s, OP_undefined);
emit_goto(s, OP_goto, *poptional_chaining_label);
emit_label(s, label_next);
} | O2 | c | optional_chain_test:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, (%rsi)
jns 0x5daa2
movq %rbx, %rdi
callq 0x59bfb
movl %eax, (%r14)
pushq $0x11
popq %rsi
movq %rbx, %rdi
callq 0x535cb
movq %rbx, %rdi
movl $0xb0, %esi
callq 0x535cb
pushq $0x69
popq %rsi
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x59c0a
movl %eax, %ebp
xorl %r12d, %r12d
testl %r15d, %r15d
cmovgl %r15d, %r12d
pushq $0xe
popq %r15
subl $0x1, %r12d
jb 0x5daeb
movq %rbx, %rdi
movl %r15d, %esi
callq 0x535cb
jmp 0x5dad8
pushq $0x6
popq %rsi
movq %rbx, %rdi
callq 0x535cb
movl (%r14), %edx
pushq $0x6b
popq %rsi
movq %rbx, %rdi
callq 0x59c0a
movq %rbx, %rdi
movl %ebp, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x59d2c
| optional_chain_test:
push rbp
push r15
push r14
push r12
push rbx
mov r15d, edx
mov r14, rsi
mov rbx, rdi
cmp dword ptr [rsi], 0
jns short loc_5DAA2
mov rdi, rbx
call new_label
mov [r14], eax
loc_5DAA2:
push 11h
pop rsi
mov rdi, rbx
call emit_op
mov rdi, rbx
mov esi, 0B0h
call emit_op
push 69h ; 'i'
pop rsi
push 0FFFFFFFFFFFFFFFFh
pop rdx
mov rdi, rbx
call emit_goto
mov ebp, eax
xor r12d, r12d
test r15d, r15d
cmovg r12d, r15d
push 0Eh
pop r15
loc_5DAD8:
sub r12d, 1
jb short loc_5DAEB
mov rdi, rbx
mov esi, r15d
call emit_op
jmp short loc_5DAD8
loc_5DAEB:
push 6
pop rsi
mov rdi, rbx
call emit_op
mov edx, [r14]
push 6Bh ; 'k'
pop rsi
mov rdi, rbx
call emit_goto
mov rdi, rbx
mov esi, ebp
pop rbx
pop r12
pop r14
pop r15
pop rbp
jmp emit_label
| long long optional_chain_test(long long a1, int *a2, int a3)
{
int v4; // ebp
int v5; // r12d
if ( *a2 < 0 )
*a2 = new_label(a1);
emit_op(a1, 17);
emit_op(a1, 176);
v4 = emit_goto(a1, 105, -1);
v5 = 0;
if ( a3 > 0 )
v5 = a3;
while ( v5-- != 0 )
emit_op(a1, 14);
emit_op(a1, 6);
emit_goto(a1, 107, *a2);
return emit_label(a1, v4);
}
| optional_chain_test:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R15D,EDX
MOV R14,RSI
MOV RBX,RDI
CMP dword ptr [RSI],0x0
JNS 0x0015daa2
MOV RDI,RBX
CALL 0x00159bfb
MOV dword ptr [R14],EAX
LAB_0015daa2:
PUSH 0x11
POP RSI
MOV RDI,RBX
CALL 0x001535cb
MOV RDI,RBX
MOV ESI,0xb0
CALL 0x001535cb
PUSH 0x69
POP RSI
PUSH -0x1
POP RDX
MOV RDI,RBX
CALL 0x00159c0a
MOV EBP,EAX
XOR R12D,R12D
TEST R15D,R15D
CMOVG R12D,R15D
PUSH 0xe
POP R15
LAB_0015dad8:
SUB R12D,0x1
JC 0x0015daeb
MOV RDI,RBX
MOV ESI,R15D
CALL 0x001535cb
JMP 0x0015dad8
LAB_0015daeb:
PUSH 0x6
POP RSI
MOV RDI,RBX
CALL 0x001535cb
MOV EDX,dword ptr [R14]
PUSH 0x6b
POP RSI
MOV RDI,RBX
CALL 0x00159c0a
MOV RDI,RBX
MOV ESI,EBP
POP RBX
POP R12
POP R14
POP R15
POP RBP
JMP 0x00159d2c
|
void optional_chain_test(int8 param_1,int *param_2,int param_3)
{
int iVar1;
int4 uVar2;
if (*param_2 < 0) {
iVar1 = new_label(param_1);
*param_2 = iVar1;
}
emit_op(param_1,0x11);
emit_op(param_1,0xb0);
uVar2 = emit_goto(param_1,0x69,0xffffffffffffffff);
iVar1 = 0;
if (0 < param_3) {
iVar1 = param_3;
}
while (iVar1 != 0) {
emit_op(param_1,0xe);
iVar1 = iVar1 + -1;
}
emit_op(param_1,6);
emit_goto(param_1,0x6b,*param_2);
emit_label(param_1,uVar2);
return;
}
| |
48,353 | ftxui::animation::easing::ExponentialInOut(float) | Andrewchistyakov[P]flashcards_lyc/build_O2/_deps/ftxui-src/src/ftxui/component/animation.cpp | float ExponentialInOut(float p) {
if (p == 0.f || p == 1.f) {
return p;
}
if (p < 0.5f) {
return 0.5f * std::pow(2.f, (20.f * p) - 10.f);
}
return -0.5f * std::pow(2.f, (-20.f * p) + 10.f) + 1.f;
} | O2 | cpp | ftxui::animation::easing::ExponentialInOut(float):
pushq %rax
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x2dbe7
jnp 0x2dc43
ucomiss 0x529a(%rip), %xmm0 # 0x32e88
jne 0x2dbf2
jnp 0x2dc43
movss 0x5296(%rip), %xmm1 # 0x32e90
ucomiss %xmm0, %xmm1
jbe 0x2dc1e
mulss 0x7851(%rip), %xmm0 # 0x35458
addss 0x783d(%rip), %xmm0 # 0x3544c
callq 0xc890
mulss 0x5274(%rip), %xmm0 # 0x32e90
jmp 0x2dc43
mulss 0x782a(%rip), %xmm0 # 0x35450
addss 0x781a(%rip), %xmm0 # 0x35448
callq 0xc890
mulss 0x7819(%rip), %xmm0 # 0x35454
addss 0x5245(%rip), %xmm0 # 0x32e88
popq %rax
retq
| _ZN5ftxui9animation6easing16ExponentialInOutEf:
push rax
xorps xmm1, xmm1
ucomiss xmm0, xmm1
jnz short loc_2DBE7
jnp short loc_2DC43
loc_2DBE7:
ucomiss xmm0, cs:dword_32E88
jnz short loc_2DBF2
jnp short loc_2DC43
loc_2DBF2:
movss xmm1, cs:dword_32E90
ucomiss xmm1, xmm0
jbe short loc_2DC1E
mulss xmm0, cs:dword_35458
addss xmm0, cs:dword_3544C
call _exp2f
mulss xmm0, cs:dword_32E90
jmp short loc_2DC43
loc_2DC1E:
mulss xmm0, cs:dword_35450
addss xmm0, cs:dword_35448
call _exp2f
mulss xmm0, cs:dword_35454
addss xmm0, cs:dword_32E88
loc_2DC43:
pop rax
retn
| float __spoils<rdx,rcx,r8,r9,r10,r11,xmm4,xmm5> ftxui::animation::easing::ExponentialInOut(
ftxui::animation::easing *this,
float result)
{
double v2; // xmm0_8
double v3; // xmm0_8
if ( result != 0.0 && result != 1.0 )
{
if ( result >= 0.5 )
{
v3 = exp2f(this, (float)(result * -20.0) + 10.0);
return (float)(*(float *)&v3 * -0.5) + 1.0;
}
else
{
v2 = exp2f(this, (float)(result * 20.0) + -10.0);
return *(float *)&v2 * 0.5;
}
}
return result;
}
| ExponentialInOut:
PUSH RAX
XORPS XMM1,XMM1
UCOMISS XMM0,XMM1
JNZ 0x0012dbe7
JNP 0x0012dc43
LAB_0012dbe7:
UCOMISS XMM0,dword ptr [0x00132e88]
JNZ 0x0012dbf2
JNP 0x0012dc43
LAB_0012dbf2:
MOVSS XMM1,dword ptr [0x00132e90]
UCOMISS XMM1,XMM0
JBE 0x0012dc1e
MULSS XMM0,dword ptr [0x00135458]
ADDSS XMM0,dword ptr [0x0013544c]
CALL 0x0010c890
MULSS XMM0,dword ptr [0x00132e90]
JMP 0x0012dc43
LAB_0012dc1e:
MULSS XMM0,dword ptr [0x00135450]
ADDSS XMM0,dword ptr [0x00135448]
CALL 0x0010c890
MULSS XMM0,dword ptr [0x00135454]
ADDSS XMM0,dword ptr [0x00132e88]
LAB_0012dc43:
POP RAX
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* ftxui::animation::easing::ExponentialInOut(float) */
int8 ftxui::animation::easing::ExponentialInOut(float param_1)
{
int8 in_RAX;
if ((param_1 != 0.0) || (NAN(param_1))) {
if ((param_1 != DAT_00132e88) || (NAN(param_1) || NAN(DAT_00132e88))) {
if (DAT_00132e90 <= param_1) {
exp2f(param_1 * _DAT_00135450 + _DAT_00135448);
}
else {
exp2f(param_1 * _DAT_00135458 + _DAT_0013544c);
}
}
}
return in_RAX;
}
| |
48,354 | translog_page_validator | eloqsql/storage/maria/ma_loghandler.c | static my_bool translog_page_validator(int res, PAGECACHE_IO_HOOK_ARGS *args)
{
uchar *page= args->page;
pgcache_page_no_t page_no= args->pageno;
uint this_page_page_overhead;
uint flags;
uchar *page_pos;
TRANSLOG_FILE *data= (TRANSLOG_FILE *) args->data;
#ifndef DBUG_OFF
pgcache_page_no_t offset= page_no * TRANSLOG_PAGE_SIZE;
#endif
DBUG_ENTER("translog_page_validator");
data->was_recovered= 0;
if (res)
{
DBUG_RETURN(1);
}
if ((pgcache_page_no_t) uint3korr(page) != page_no ||
(uint32) uint3korr(page + 3) != data->number)
{
DBUG_PRINT("error", ("Page " LSN_FMT ": "
"page address written in the page is incorrect: "
"File %lu instead of %lu or page %lu instead of %lu",
(uint)data->number, (uint)offset,
(ulong) uint3korr(page + 3), (ulong) data->number,
(ulong) uint3korr(page),
(ulong) page_no));
DBUG_RETURN(1);
}
flags= (uint)(page[TRANSLOG_PAGE_FLAGS]);
this_page_page_overhead= page_overhead[flags];
if (flags & ~(TRANSLOG_PAGE_CRC | TRANSLOG_SECTOR_PROTECTION |
TRANSLOG_RECORD_CRC))
{
DBUG_PRINT("error", ("Page " LSN_FMT ": "
"Garbage in the page flags field detected : %x",
(uint) data->number, (uint) offset,
(uint) flags));
DBUG_RETURN(1);
}
page_pos= page + (3 + 3 + 1);
if (flags & TRANSLOG_PAGE_CRC)
{
uint32 crc= translog_crc(page + this_page_page_overhead,
TRANSLOG_PAGE_SIZE -
this_page_page_overhead);
if (crc != uint4korr(page_pos))
{
DBUG_PRINT("error", ("Page " LSN_FMT ": "
"CRC mismatch: calculated: %lx on the page %lx",
(uint) data->number, (uint) offset,
(ulong) crc, (ulong) uint4korr(page_pos)));
DBUG_RETURN(1);
}
page_pos+= CRC_SIZE; /* Skip crc */
}
if (flags & TRANSLOG_SECTOR_PROTECTION &&
translog_check_sector_protection(page, data))
{
DBUG_RETURN(1);
}
DBUG_RETURN(0);
} | O0 | c | translog_page_validator:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movb $0x0, 0x50(%rax)
cmpl $0x0, -0x8(%rbp)
je 0x36b8b
jmp 0x36b82
movb $0x1, -0x1(%rbp)
jmp 0x36ca6
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
movq -0x18(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x18(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0x36bde
movq -0x18(%rbp), %rax
movzbl 0x3(%rax), %eax
movq -0x18(%rbp), %rcx
movzbl 0x4(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x18(%rbp), %rcx
movzbl 0x5(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x38(%rbp), %rcx
cmpl (%rcx), %eax
je 0x36bed
jmp 0x36be0
jmp 0x36be2
jmp 0x36be4
movb $0x1, -0x1(%rbp)
jmp 0x36ca6
movq -0x18(%rbp), %rax
movzbl 0x6(%rax), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, %ecx
leaq 0xc42f5c(%rip), %rax # 0xc79b60
movl (%rax,%rcx,4), %eax
movl %eax, -0x24(%rbp)
movl -0x28(%rbp), %eax
andl $-0x8, %eax
cmpl $0x0, %eax
je 0x36c24
jmp 0x36c17
jmp 0x36c19
jmp 0x36c1b
movb $0x1, -0x1(%rbp)
jmp 0x36ca6
movq -0x18(%rbp), %rax
addq $0x7, %rax
movq %rax, -0x30(%rbp)
movl -0x28(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x36c78
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %eax
addq %rax, %rdi
movl $0x2000, %esi # imm = 0x2000
subl -0x24(%rbp), %esi
callq 0x36cb0
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
je 0x36c6c
jmp 0x36c62
jmp 0x36c64
jmp 0x36c66
movb $0x1, -0x1(%rbp)
jmp 0x36ca6
movq -0x30(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
movl -0x28(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x36ca0
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x36ce0
movsbl %al, %eax
cmpl $0x0, %eax
je 0x36ca0
jmp 0x36c9a
movb $0x1, -0x1(%rbp)
jmp 0x36ca6
jmp 0x36ca2
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
nop
| translog_page_validator:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], edi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rax, [rax+10h]
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov byte ptr [rax+50h], 0
cmp [rbp+var_8], 0
jz short loc_36B8B
jmp short $+2
loc_36B82:
mov [rbp+var_1], 1
jmp loc_36CA6
loc_36B8B:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx+1]
shl ecx, 8
or eax, ecx
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx+2]
shl ecx, 10h
or eax, ecx
mov eax, eax
cmp rax, [rbp+var_20]
jnz short loc_36BDE
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+3]
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx+4]
shl ecx, 8
or eax, ecx
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx+5]
shl ecx, 10h
or eax, ecx
mov rcx, [rbp+var_38]
cmp eax, [rcx]
jz short loc_36BED
loc_36BDE:
jmp short $+2
loc_36BE0:
jmp short $+2
loc_36BE2:
jmp short $+2
loc_36BE4:
mov [rbp+var_1], 1
jmp loc_36CA6
loc_36BED:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+6]
mov [rbp+var_28], eax
mov eax, [rbp+var_28]
mov ecx, eax
lea rax, page_overhead
mov eax, [rax+rcx*4]
mov [rbp+var_24], eax
mov eax, [rbp+var_28]
and eax, 0FFFFFFF8h
cmp eax, 0
jz short loc_36C24
jmp short $+2
loc_36C17:
jmp short $+2
loc_36C19:
jmp short $+2
loc_36C1B:
mov [rbp+var_1], 1
jmp loc_36CA6
loc_36C24:
mov rax, [rbp+var_18]
add rax, 7
mov [rbp+var_30], rax
mov eax, [rbp+var_28]
and eax, 1
cmp eax, 0
jz short loc_36C78
mov rdi, [rbp+var_18]
mov eax, [rbp+var_24]
add rdi, rax
mov esi, 2000h
sub esi, [rbp+var_24]
call translog_crc
mov [rbp+var_3C], eax
mov eax, [rbp+var_3C]
mov rcx, [rbp+var_30]
cmp eax, [rcx]
jz short loc_36C6C
jmp short $+2
loc_36C62:
jmp short $+2
loc_36C64:
jmp short $+2
loc_36C66:
mov [rbp+var_1], 1
jmp short loc_36CA6
loc_36C6C:
mov rax, [rbp+var_30]
add rax, 4
mov [rbp+var_30], rax
loc_36C78:
mov eax, [rbp+var_28]
and eax, 2
cmp eax, 0
jz short loc_36CA0
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_38]
call translog_check_sector_protection
movsx eax, al
cmp eax, 0
jz short loc_36CA0
jmp short $+2
loc_36C9A:
mov [rbp+var_1], 1
jmp short loc_36CA6
loc_36CA0:
jmp short $+2
loc_36CA2:
mov [rbp+var_1], 0
loc_36CA6:
mov al, [rbp+var_1]
add rsp, 40h
pop rbp
retn
| bool translog_page_validator(int a1, unsigned __int16 **a2)
{
unsigned __int16 *v3; // [rsp+8h] [rbp-38h]
int v4; // [rsp+18h] [rbp-28h]
unsigned int v5; // [rsp+1Ch] [rbp-24h]
unsigned __int16 *v6; // [rsp+20h] [rbp-20h]
unsigned __int16 *v7; // [rsp+28h] [rbp-18h]
v7 = *a2;
v6 = a2[1];
v3 = a2[2];
*((_BYTE *)v3 + 80) = 0;
if ( a1 )
return 1;
if ( (unsigned __int16 *)((*((unsigned __int8 *)v7 + 2) << 16) | (unsigned int)*v7) != v6
|| ((*((unsigned __int8 *)v7 + 5) << 16) | *(unsigned __int16 *)((char *)v7 + 3)) != *(_DWORD *)v3 )
{
return 1;
}
v4 = *((unsigned __int8 *)v7 + 6);
if ( (v4 & 0xFFFFFFF8) != 0 )
return 1;
if ( (v4 & 1) == 0 )
return (v4 & 2) != 0 && (unsigned __int8)translog_check_sector_protection(v7, v3);
v5 = page_overhead[*((unsigned __int8 *)v7 + 6)];
if ( (unsigned int)translog_crc((char *)v7 + v5, 0x2000 - v5) == *(_DWORD *)((char *)v7 + 7) )
return (v4 & 2) != 0 && (unsigned __int8)translog_check_sector_protection(v7, v3);
return 1;
}
| translog_page_validator:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV dword ptr [RBP + -0x8],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX + 0x50],0x0
CMP dword ptr [RBP + -0x8],0x0
JZ 0x00136b8b
JMP 0x00136b82
LAB_00136b82:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00136ca6
LAB_00136b8b:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX + 0x1]
SHL ECX,0x8
OR EAX,ECX
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX + 0x2]
SHL ECX,0x10
OR EAX,ECX
MOV EAX,EAX
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x00136bde
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x3]
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX + 0x4]
SHL ECX,0x8
OR EAX,ECX
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX + 0x5]
SHL ECX,0x10
OR EAX,ECX
MOV RCX,qword ptr [RBP + -0x38]
CMP EAX,dword ptr [RCX]
JZ 0x00136bed
LAB_00136bde:
JMP 0x00136be0
LAB_00136be0:
JMP 0x00136be2
LAB_00136be2:
JMP 0x00136be4
LAB_00136be4:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00136ca6
LAB_00136bed:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x6]
MOV dword ptr [RBP + -0x28],EAX
MOV EAX,dword ptr [RBP + -0x28]
MOV ECX,EAX
LEA RAX,[0xd79b60]
MOV EAX,dword ptr [RAX + RCX*0x4]
MOV dword ptr [RBP + -0x24],EAX
MOV EAX,dword ptr [RBP + -0x28]
AND EAX,0xfffffff8
CMP EAX,0x0
JZ 0x00136c24
JMP 0x00136c17
LAB_00136c17:
JMP 0x00136c19
LAB_00136c19:
JMP 0x00136c1b
LAB_00136c1b:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00136ca6
LAB_00136c24:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x7
MOV qword ptr [RBP + -0x30],RAX
MOV EAX,dword ptr [RBP + -0x28]
AND EAX,0x1
CMP EAX,0x0
JZ 0x00136c78
MOV RDI,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x24]
ADD RDI,RAX
MOV ESI,0x2000
SUB ESI,dword ptr [RBP + -0x24]
CALL 0x00136cb0
MOV dword ptr [RBP + -0x3c],EAX
MOV EAX,dword ptr [RBP + -0x3c]
MOV RCX,qword ptr [RBP + -0x30]
CMP EAX,dword ptr [RCX]
JZ 0x00136c6c
JMP 0x00136c62
LAB_00136c62:
JMP 0x00136c64
LAB_00136c64:
JMP 0x00136c66
LAB_00136c66:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00136ca6
LAB_00136c6c:
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x4
MOV qword ptr [RBP + -0x30],RAX
LAB_00136c78:
MOV EAX,dword ptr [RBP + -0x28]
AND EAX,0x2
CMP EAX,0x0
JZ 0x00136ca0
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x38]
CALL 0x00136ce0
MOVSX EAX,AL
CMP EAX,0x0
JZ 0x00136ca0
JMP 0x00136c9a
LAB_00136c9a:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00136ca6
LAB_00136ca0:
JMP 0x00136ca2
LAB_00136ca2:
MOV byte ptr [RBP + -0x1],0x0
LAB_00136ca6:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x40
POP RBP
RET
|
int8 translog_page_validator(int param_1,long *param_2)
{
byte bVar1;
uint3 *puVar2;
uint *puVar3;
uint *puVar4;
char cVar5;
uint uVar6;
uint *puVar7;
int1 local_9;
puVar2 = (uint3 *)*param_2;
puVar3 = (uint *)param_2[1];
puVar4 = (uint *)param_2[2];
*(int1 *)(puVar4 + 0x14) = 0;
if (param_1 == 0) {
puVar7 = (uint *)(ulong)*puVar2;
if ((puVar7 == puVar3) &&
(puVar7 = (uint *)(ulong)(uint)*(uint3 *)((long)puVar2 + 3),
(uint)*(uint3 *)((long)puVar2 + 3) == *puVar4)) {
bVar1 = *(byte *)((long)puVar2 + 6);
puVar7 = (uint *)0x0;
if ((bVar1 & 0xf8) == 0) {
if ((bVar1 & 1) != 0) {
uVar6 = translog_crc((long)puVar2 + (ulong)*(uint *)(page_overhead + (ulong)bVar1 * 4),
0x2000 - *(uint *)(page_overhead + (ulong)bVar1 * 4));
puVar7 = (uint *)(ulong)uVar6;
if (uVar6 != *(uint *)((long)puVar2 + 7)) {
local_9 = 1;
goto LAB_00136ca6;
}
}
puVar7 = (uint *)0x0;
if ((bVar1 & 2) != 0) {
cVar5 = translog_check_sector_protection(puVar2,puVar4);
puVar7 = (uint *)(ulong)(uint)(int)cVar5;
if ((int)cVar5 != 0) {
local_9 = 1;
goto LAB_00136ca6;
}
}
local_9 = 0;
}
else {
local_9 = 1;
}
}
else {
local_9 = 1;
}
}
else {
local_9 = 1;
puVar7 = puVar4;
}
LAB_00136ca6:
return CONCAT71((int7)((ulong)puVar7 >> 8),local_9);
}
| |
48,355 | uf_space_prespace_selected | eloqsql/storage/myisam/mi_packrec.c | static void uf_space_prespace_selected(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff,
uchar *to, uchar *end)
{
uint spaces;
if (get_bit(bit_buff))
bfill((uchar*) to,(end-to),' ');
else
{
if (get_bit(bit_buff))
{
if ((spaces=get_bits(bit_buff,rec->space_length_bits))+to > end)
{
bit_buff->error=1;
return;
}
bfill((uchar*) to,spaces,' ');
if (to+spaces != end)
decode_bytes(rec,bit_buff,to+spaces,end);
}
else
decode_bytes(rec,bit_buff,to,end);
}
} | O0 | c | uf_space_prespace_selected:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0xbd207
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rdx
movl 0x4(%rdx), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rdx)
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0xbd22b
jmp 0xbd249
movq -0x10(%rbp), %rdi
callq 0xbc0c0
movq -0x10(%rbp), %rax
movl $0x1f, 0x4(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x0, %eax
je 0xbd249
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
subq %rax, %rdx
movl $0x20, %esi
callq 0x2a2a0
jmp 0xbd372
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0xbd27b
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rdx
movl 0x4(%rdx), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rdx)
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0xbd2a3
jmp 0xbd35b
movq -0x10(%rbp), %rdi
callq 0xbc0c0
movq -0x10(%rbp), %rax
movl $0x1f, 0x4(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x0, %eax
je 0xbd35b
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jb 0xbd2e6
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x8(%rbp), %rcx
movl 0x1c(%rcx), %esi
movq -0x10(%rbp), %rdx
movl 0x4(%rdx), %ecx
subl %esi, %ecx
movl %ecx, 0x4(%rdx)
shrl %cl, %eax
movq -0x8(%rbp), %rcx
movl 0x1c(%rcx), %ecx
movl %ecx, %edx
leaq 0x2024e2(%rip), %rcx # 0x2bf7c0
andl (%rcx,%rdx,4), %eax
movl %eax, -0x28(%rbp)
jmp 0xbd2f9
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %esi
callq 0xba870
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %ecx
movl %ecx, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
cmpq -0x20(%rbp), %rax
jbe 0xbd31b
movq -0x10(%rbp), %rax
movl $0x1, 0x28(%rax)
jmp 0xbd372
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %edx
movl $0x20, %esi
callq 0x2a2a0
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
addq %rcx, %rax
cmpq -0x20(%rbp), %rax
je 0xbd359
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x24(%rbp), %eax
addq %rax, %rdx
movq -0x20(%rbp), %rcx
callq 0xbc7d0
jmp 0xbd370
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xbc7d0
jmp 0xbd372
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| uf_space_prespace_selected_0:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov rax, [rbp+var_10]
cmp dword ptr [rax+4], 0
jz short loc_BD207
mov rax, [rbp+var_10]
mov eax, [rax]
mov rdx, [rbp+var_10]
mov ecx, [rdx+4]
add ecx, 0FFFFFFFFh
mov [rdx+4], ecx
mov edx, 1
shl edx, cl
mov ecx, edx
and eax, ecx
cmp eax, 0
jnz short loc_BD22B
jmp short loc_BD249
loc_BD207:
mov rdi, [rbp+var_10]
call fill_buffer_0
mov rax, [rbp+var_10]
mov dword ptr [rax+4], 1Fh
mov rax, [rbp+var_10]
mov eax, [rax]
and eax, 80000000h
cmp eax, 0
jz short loc_BD249
loc_BD22B:
mov rdi, [rbp+var_18]
mov rdx, [rbp+var_20]
mov rax, [rbp+var_18]
sub rdx, rax
mov esi, 20h ; ' '
call _memset
jmp loc_BD372
loc_BD249:
mov rax, [rbp+var_10]
cmp dword ptr [rax+4], 0
jz short loc_BD27B
mov rax, [rbp+var_10]
mov eax, [rax]
mov rdx, [rbp+var_10]
mov ecx, [rdx+4]
add ecx, 0FFFFFFFFh
mov [rdx+4], ecx
mov edx, 1
shl edx, cl
mov ecx, edx
and eax, ecx
cmp eax, 0
jnz short loc_BD2A3
jmp loc_BD35B
loc_BD27B:
mov rdi, [rbp+var_10]
call fill_buffer_0
mov rax, [rbp+var_10]
mov dword ptr [rax+4], 1Fh
mov rax, [rbp+var_10]
mov eax, [rax]
and eax, 80000000h
cmp eax, 0
jz loc_BD35B
loc_BD2A3:
mov rax, [rbp+var_10]
mov eax, [rax+4]
mov rcx, [rbp+var_8]
cmp eax, [rcx+1Ch]
jb short loc_BD2E6
mov rax, [rbp+var_10]
mov eax, [rax]
mov rcx, [rbp+var_8]
mov esi, [rcx+1Ch]
mov rdx, [rbp+var_10]
mov ecx, [rdx+4]
sub ecx, esi
mov [rdx+4], ecx
shr eax, cl
mov rcx, [rbp+var_8]
mov ecx, [rcx+1Ch]
mov edx, ecx
lea rcx, mask_0
and eax, [rcx+rdx*4]
mov [rbp+var_28], eax
jmp short loc_BD2F9
loc_BD2E6:
mov rdi, [rbp+var_10]
mov rax, [rbp+var_8]
mov esi, [rax+1Ch]
call fill_and_get_bits_0
mov [rbp+var_28], eax
loc_BD2F9:
mov ecx, [rbp+var_28]
mov [rbp+var_24], ecx
mov rax, [rbp+var_18]
mov ecx, ecx
add rax, rcx
cmp rax, [rbp+var_20]
jbe short loc_BD31B
mov rax, [rbp+var_10]
mov dword ptr [rax+28h], 1
jmp short loc_BD372
loc_BD31B:
mov rdi, [rbp+var_18]
mov eax, [rbp+var_24]
mov edx, eax
mov esi, 20h ; ' '
call _memset
mov rax, [rbp+var_18]
mov ecx, [rbp+var_24]
add rax, rcx
cmp rax, [rbp+var_20]
jz short loc_BD359
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov eax, [rbp+var_24]
add rdx, rax
mov rcx, [rbp+var_20]
call decode_bytes_0
loc_BD359:
jmp short loc_BD370
loc_BD35B:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
call decode_bytes_0
loc_BD370:
jmp short $+2
loc_BD372:
add rsp, 30h
pop rbp
retn
| long long uf_space_prespace_selected_0(long long a1, int *a2, _BYTE *a3, _BYTE *a4)
{
int v4; // eax
int v5; // ecx
long long result; // rax
int v7; // eax
int v8; // ecx
unsigned int v9; // eax
int v10; // ecx
unsigned int bits_0; // [rsp+8h] [rbp-28h]
if ( !a2[1] )
{
fill_buffer_0((long long)a2);
a2[1] = 31;
if ( *a2 >= 0 )
goto LABEL_6;
return memset(a3, 32LL, a4 - a3);
}
v4 = *a2;
v5 = a2[1] - 1;
a2[1] = v5;
if ( ((1 << v5) & v4) != 0 )
return memset(a3, 32LL, a4 - a3);
LABEL_6:
if ( a2[1] )
{
v7 = *a2;
v8 = a2[1] - 1;
a2[1] = v8;
if ( ((1 << v8) & v7) == 0 )
return decode_bytes_0(a1, (long long)a2, a3, a4);
}
else
{
fill_buffer_0((long long)a2);
a2[1] = 31;
if ( *a2 >= 0 )
return decode_bytes_0(a1, (long long)a2, a3, a4);
}
if ( (unsigned int)a2[1] < *(_DWORD *)(a1 + 28) )
{
bits_0 = fill_and_get_bits_0(a2, *(_DWORD *)(a1 + 28));
}
else
{
v9 = *a2;
v10 = a2[1] - *(_DWORD *)(a1 + 28);
a2[1] = v10;
bits_0 = mask_0[*(unsigned int *)(a1 + 28)] & (v9 >> v10);
}
if ( &a3[bits_0] <= a4 )
{
memset(a3, 32LL, bits_0);
result = (long long)&a3[bits_0];
if ( (_BYTE *)result != a4 )
return decode_bytes_0(a1, (long long)a2, &a3[bits_0], a4);
}
else
{
result = (long long)a2;
a2[10] = 1;
}
return result;
}
| uf_space_prespace_selected:
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
MOV qword ptr [RBP + -0x20],RCX
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x4],0x0
JZ 0x001bd207
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RDX + 0x4]
ADD ECX,-0x1
MOV dword ptr [RDX + 0x4],ECX
MOV EDX,0x1
SHL EDX,CL
MOV ECX,EDX
AND EAX,ECX
CMP EAX,0x0
JNZ 0x001bd22b
JMP 0x001bd249
LAB_001bd207:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001bc0c0
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x4],0x1f
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
AND EAX,0x80000000
CMP EAX,0x0
JZ 0x001bd249
LAB_001bd22b:
MOV RDI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x18]
SUB RDX,RAX
MOV ESI,0x20
CALL 0x0012a2a0
JMP 0x001bd372
LAB_001bd249:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x4],0x0
JZ 0x001bd27b
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RDX + 0x4]
ADD ECX,-0x1
MOV dword ptr [RDX + 0x4],ECX
MOV EDX,0x1
SHL EDX,CL
MOV ECX,EDX
AND EAX,ECX
CMP EAX,0x0
JNZ 0x001bd2a3
JMP 0x001bd35b
LAB_001bd27b:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001bc0c0
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x4],0x1f
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
AND EAX,0x80000000
CMP EAX,0x0
JZ 0x001bd35b
LAB_001bd2a3:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x4]
MOV RCX,qword ptr [RBP + -0x8]
CMP EAX,dword ptr [RCX + 0x1c]
JC 0x001bd2e6
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RCX + 0x1c]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RDX + 0x4]
SUB ECX,ESI
MOV dword ptr [RDX + 0x4],ECX
SHR EAX,CL
MOV RCX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RCX + 0x1c]
MOV EDX,ECX
LEA RCX,[0x3bf7c0]
AND EAX,dword ptr [RCX + RDX*0x4]
MOV dword ptr [RBP + -0x28],EAX
JMP 0x001bd2f9
LAB_001bd2e6:
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RAX + 0x1c]
CALL 0x001ba870
MOV dword ptr [RBP + -0x28],EAX
LAB_001bd2f9:
MOV ECX,dword ptr [RBP + -0x28]
MOV dword ptr [RBP + -0x24],ECX
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,ECX
ADD RAX,RCX
CMP RAX,qword ptr [RBP + -0x20]
JBE 0x001bd31b
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x28],0x1
JMP 0x001bd372
LAB_001bd31b:
MOV RDI,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x24]
MOV EDX,EAX
MOV ESI,0x20
CALL 0x0012a2a0
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x24]
ADD RAX,RCX
CMP RAX,qword ptr [RBP + -0x20]
JZ 0x001bd359
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x24]
ADD RDX,RAX
MOV RCX,qword ptr [RBP + -0x20]
CALL 0x001bc7d0
LAB_001bd359:
JMP 0x001bd370
LAB_001bd35b:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
CALL 0x001bc7d0
LAB_001bd370:
JMP 0x001bd372
LAB_001bd372:
ADD RSP,0x30
POP RBP
RET
|
void uf_space_prespace_selected(long param_1,uint *param_2,void *param_3,ulong param_4)
{
uint uVar1;
uint local_30;
if (param_2[1] == 0) {
fill_buffer(param_2);
param_2[1] = 0x1f;
uVar1 = *param_2 & 0x80000000;
}
else {
uVar1 = param_2[1];
param_2[1] = uVar1 - 1;
uVar1 = *param_2 & 1 << ((byte)(uVar1 - 1) & 0x1f);
}
if (uVar1 == 0) {
if (param_2[1] == 0) {
fill_buffer(param_2);
param_2[1] = 0x1f;
uVar1 = *param_2 & 0x80000000;
}
else {
uVar1 = param_2[1];
param_2[1] = uVar1 - 1;
uVar1 = *param_2 & 1 << ((byte)(uVar1 - 1) & 0x1f);
}
if (uVar1 == 0) {
decode_bytes(param_1,param_2,param_3,param_4);
}
else {
if (param_2[1] < *(uint *)(param_1 + 0x1c)) {
local_30 = fill_and_get_bits(param_2,*(int4 *)(param_1 + 0x1c));
}
else {
uVar1 = param_2[1] - *(int *)(param_1 + 0x1c);
param_2[1] = uVar1;
local_30 = *param_2 >> ((byte)uVar1 & 0x1f) &
*(uint *)(mask + (ulong)*(uint *)(param_1 + 0x1c) * 4);
}
if (param_4 < (long)param_3 + (ulong)local_30) {
param_2[10] = 1;
}
else {
memset(param_3,0x20,(ulong)local_30);
if ((long)param_3 + (ulong)local_30 != param_4) {
decode_bytes(param_1,param_2,(long)param_3 + (ulong)local_30,param_4);
}
}
}
}
else {
memset(param_3,0x20,param_4 - (long)param_3);
}
return;
}
| |
48,356 | my_mb_wc_gbk | eloqsql/strings/ctype-gbk.c | static int
my_mb_wc_gbk(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t *pwc, const uchar *s, const uchar *e)
{
int hi;
if (s >= e)
return MY_CS_TOOSMALL;
hi=s[0];
if (hi<0x80)
{
pwc[0]=hi;
return 1;
}
if (s+2>e)
return MY_CS_TOOSMALL2;
if (!IS_MB2_CHAR(hi, s[1]))
return MY_CS_ILSEQ;
if (!(pwc[0]=func_gbk_uni_onechar( (hi<<8) + s[1])))
return -2;
return 2;
} | O0 | c | my_mb_wc_gbk:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x404fe
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0x405d9
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x80, -0x2c(%rbp)
jge 0x40528
movslq -0x2c(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x405d9
movq -0x20(%rbp), %rax
addq $0x2, %rax
cmpq -0x28(%rbp), %rax
jbe 0x40542
movl $0xffffff9a, -0x4(%rbp) # imm = 0xFFFFFF9A
jmp 0x405d9
movl -0x2c(%rbp), %eax
movzbl %al, %ecx
movl $0x81, %eax
cmpl %ecx, %eax
jg 0x4059c
movl -0x2c(%rbp), %eax
movzbl %al, %eax
cmpl $0xfe, %eax
jg 0x4059c
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %ecx
movl $0x40, %eax
cmpl %ecx, %eax
jg 0x4057c
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x7e, %eax
jle 0x405a5
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %ecx
movl $0x80, %eax
cmpl %ecx, %eax
jg 0x4059c
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0xfe, %eax
jle 0x405a5
movl $0x0, -0x4(%rbp)
jmp 0x405d9
movl -0x2c(%rbp), %edi
shll $0x8, %edi
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
addl %eax, %edi
callq 0x40920
cltq
movq -0x18(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x405d2
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x405d9
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_mb_wc_gbk:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jb short loc_404FE
mov [rbp+var_4], 0FFFFFF9Bh
jmp loc_405D9
loc_404FE:
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax]
mov [rbp+var_2C], eax
cmp [rbp+var_2C], 80h
jge short loc_40528
movsxd rcx, [rbp+var_2C]
mov rax, [rbp+var_18]
mov [rax], rcx
mov [rbp+var_4], 1
jmp loc_405D9
loc_40528:
mov rax, [rbp+var_20]
add rax, 2
cmp rax, [rbp+var_28]
jbe short loc_40542
mov [rbp+var_4], 0FFFFFF9Ah
jmp loc_405D9
loc_40542:
mov eax, [rbp+var_2C]
movzx ecx, al
mov eax, 81h
cmp eax, ecx
jg short loc_4059C
mov eax, [rbp+var_2C]
movzx eax, al
cmp eax, 0FEh
jg short loc_4059C
mov rax, [rbp+var_20]
movzx ecx, byte ptr [rax+1]
mov eax, 40h ; '@'
cmp eax, ecx
jg short loc_4057C
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
cmp eax, 7Eh ; '~'
jle short loc_405A5
loc_4057C:
mov rax, [rbp+var_20]
movzx ecx, byte ptr [rax+1]
mov eax, 80h
cmp eax, ecx
jg short loc_4059C
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
cmp eax, 0FEh
jle short loc_405A5
loc_4059C:
mov [rbp+var_4], 0
jmp short loc_405D9
loc_405A5:
mov edi, [rbp+var_2C]
shl edi, 8
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
add edi, eax
call func_gbk_uni_onechar
cdqe
mov rcx, [rbp+var_18]
mov [rcx], rax
cmp rax, 0
jnz short loc_405D2
mov [rbp+var_4], 0FFFFFFFEh
jmp short loc_405D9
loc_405D2:
mov [rbp+var_4], 2
loc_405D9:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long my_mb_wc_gbk(long long a1, _QWORD *a2, unsigned __int8 *a3, unsigned long long a4)
{
int v4; // eax
unsigned int v6; // [rsp+4h] [rbp-2Ch]
if ( (unsigned long long)a3 < a4 )
{
v6 = *a3;
if ( v6 >= 0x80 )
{
if ( (unsigned long long)(a3 + 2) <= a4 )
{
if ( (unsigned __int8)v6 < 0x81u
|| (unsigned __int8)v6 == 255
|| (a3[1] < 0x40u || a3[1] > 0x7Eu) && (a3[1] < 0x80u || a3[1] == 255) )
{
return 0;
}
else
{
v4 = func_gbk_uni_onechar(a3[1] + (v6 << 8));
*a2 = v4;
if ( v4 )
return 2;
else
return (unsigned int)-2;
}
}
else
{
return (unsigned int)-102;
}
}
else
{
*a2 = *a3;
return 1;
}
}
else
{
return (unsigned int)-101;
}
}
| my_mb_wc_gbk:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JC 0x001404fe
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x001405d9
LAB_001404fe:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX]
MOV dword ptr [RBP + -0x2c],EAX
CMP dword ptr [RBP + -0x2c],0x80
JGE 0x00140528
MOVSXD RCX,dword ptr [RBP + -0x2c]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001405d9
LAB_00140528:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x00140542
MOV dword ptr [RBP + -0x4],0xffffff9a
JMP 0x001405d9
LAB_00140542:
MOV EAX,dword ptr [RBP + -0x2c]
MOVZX ECX,AL
MOV EAX,0x81
CMP EAX,ECX
JG 0x0014059c
MOV EAX,dword ptr [RBP + -0x2c]
MOVZX EAX,AL
CMP EAX,0xfe
JG 0x0014059c
MOV RAX,qword ptr [RBP + -0x20]
MOVZX ECX,byte ptr [RAX + 0x1]
MOV EAX,0x40
CMP EAX,ECX
JG 0x0014057c
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0x7e
JLE 0x001405a5
LAB_0014057c:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX ECX,byte ptr [RAX + 0x1]
MOV EAX,0x80
CMP EAX,ECX
JG 0x0014059c
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0xfe
JLE 0x001405a5
LAB_0014059c:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001405d9
LAB_001405a5:
MOV EDI,dword ptr [RBP + -0x2c]
SHL EDI,0x8
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
ADD EDI,EAX
CALL 0x00140920
CDQE
MOV RCX,qword ptr [RBP + -0x18]
MOV qword ptr [RCX],RAX
CMP RAX,0x0
JNZ 0x001405d2
MOV dword ptr [RBP + -0x4],0xfffffffe
JMP 0x001405d9
LAB_001405d2:
MOV dword ptr [RBP + -0x4],0x2
LAB_001405d9:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 my_mb_wc_gbk(int8 param_1,long *param_2,byte *param_3,byte *param_4)
{
uint uVar1;
int iVar2;
int4 local_c;
if (param_3 < param_4) {
uVar1 = (uint)*param_3;
if (uVar1 < 0x80) {
*param_2 = (long)(int)uVar1;
local_c = 1;
}
else if (param_4 < param_3 + 2) {
local_c = 0xffffff9a;
}
else if (((uVar1 < 0x81) || (0xfe < uVar1)) ||
(((param_3[1] < 0x40 || (0x7e < param_3[1])) &&
((param_3[1] < 0x80 || (param_3[1] == 0xff)))))) {
local_c = 0;
}
else {
iVar2 = func_gbk_uni_onechar(uVar1 * 0x100 + (uint)param_3[1]);
*param_2 = (long)iVar2;
if ((long)iVar2 == 0) {
local_c = 0xfffffffe;
}
else {
local_c = 2;
}
}
}
else {
local_c = 0xffffff9b;
}
return local_c;
}
| |
48,357 | my_mb_wc_gbk | eloqsql/strings/ctype-gbk.c | static int
my_mb_wc_gbk(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t *pwc, const uchar *s, const uchar *e)
{
int hi;
if (s >= e)
return MY_CS_TOOSMALL;
hi=s[0];
if (hi<0x80)
{
pwc[0]=hi;
return 1;
}
if (s+2>e)
return MY_CS_TOOSMALL2;
if (!IS_MB2_CHAR(hi, s[1]))
return MY_CS_ILSEQ;
if (!(pwc[0]=func_gbk_uni_onechar( (hi<<8) + s[1])))
return -2;
return 2;
} | O3 | c | my_mb_wc_gbk:
pushq %rbp
movq %rsp, %rbp
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0x3631d
movsbq (%rdx), %rdi
testq %rdi, %rdi
js 0x362a1
movq %rdi, (%rsi)
movl $0x1, %eax
jmp 0x3631d
leaq 0x2(%rdx), %r8
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %r8
ja 0x3631d
movzbl %dil, %ecx
xorl %eax, %eax
cmpl $0x80, %ecx
je 0x3631d
cmpl $0xff, %ecx
je 0x3631d
movzbl 0x1(%rdx), %edx
leal -0x7f(%rdx), %edi
cmpb $-0x3f, %dil
setb %dil
cmpb $-0x1, %dl
setge %r8b
testb %dil, %r8b
jne 0x3631d
shll $0x8, %ecx
leal (%rcx,%rdx), %eax
addl $0xffff7ec0, %eax # imm = 0xFFFF7EC0
cmpl $0x7d10, %eax # imm = 0x7D10
jae 0x36311
movl %eax, %eax
leaq 0x144fc5(%rip), %rcx # 0x17b2c0
movzwl (%rcx,%rax,2), %eax
movzwl %ax, %ecx
movq %rcx, (%rsi)
movl $0x2, %eax
testw %cx, %cx
jne 0x3631d
jmp 0x36318
movq $0x0, (%rsi)
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
popq %rbp
retq
| my_mb_wc_gbk:
push rbp
mov rbp, rsp
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb loc_3631D
movsx rdi, byte ptr [rdx]
test rdi, rdi
js short loc_362A1
mov [rsi], rdi
mov eax, 1
jmp short loc_3631D
loc_362A1:
lea r8, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp r8, rcx
ja short loc_3631D
movzx ecx, dil
xor eax, eax
cmp ecx, 80h
jz short loc_3631D
cmp ecx, 0FFh
jz short loc_3631D
movzx edx, byte ptr [rdx+1]
lea edi, [rdx-7Fh]
cmp dil, 0C1h
setb dil
cmp dl, 0FFh
setnl r8b
test r8b, dil
jnz short loc_3631D
shl ecx, 8
lea eax, [rcx+rdx]
add eax, 0FFFF7EC0h
cmp eax, 7D10h
jnb short loc_36311
mov eax, eax
lea rcx, tab_gbk_uni0
movzx eax, word ptr [rcx+rax*2]
movzx ecx, ax
mov [rsi], rcx
mov eax, 2
test cx, cx
jnz short loc_3631D
jmp short loc_36318
loc_36311:
mov qword ptr [rsi], 0
loc_36318:
mov eax, 0FFFFFFFEh
loc_3631D:
pop rbp
retn
| long long my_mb_wc_gbk(long long a1, long long *a2, char *a3, unsigned long long a4)
{
long long result; // rax
long long v5; // rdi
int v6; // edx
unsigned int v7; // eax
long long v8; // rcx
result = 4294967195LL;
if ( (unsigned long long)a3 < a4 )
{
v5 = *a3;
if ( v5 >= 0 )
{
*a2 = v5;
return 1LL;
}
result = 4294967194LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
result = 0LL;
if ( (unsigned __int8)v5 != 128 && (unsigned __int8)v5 != 255 )
{
v6 = (unsigned __int8)a3[1];
if ( (unsigned __int8)(v6 - 127) >= 0xC1u || (char)v6 < -1 )
{
v7 = ((unsigned __int8)v5 << 8) + v6 - 33088;
if ( v7 >= 0x7D10 )
{
*a2 = 0LL;
}
else
{
v8 = tab_gbk_uni0[v7];
*a2 = v8;
result = 2LL;
if ( (_WORD)v8 )
return result;
}
return 4294967294LL;
}
}
}
}
return result;
}
| my_mb_wc_gbk:
PUSH RBP
MOV RBP,RSP
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x0013631d
MOVSX RDI,byte ptr [RDX]
TEST RDI,RDI
JS 0x001362a1
MOV qword ptr [RSI],RDI
MOV EAX,0x1
JMP 0x0013631d
LAB_001362a1:
LEA R8,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP R8,RCX
JA 0x0013631d
MOVZX ECX,DIL
XOR EAX,EAX
CMP ECX,0x80
JZ 0x0013631d
CMP ECX,0xff
JZ 0x0013631d
MOVZX EDX,byte ptr [RDX + 0x1]
LEA EDI,[RDX + -0x7f]
CMP DIL,0xc1
SETC DIL
CMP DL,0xff
SETGE R8B
TEST R8B,DIL
JNZ 0x0013631d
SHL ECX,0x8
LEA EAX,[RCX + RDX*0x1]
ADD EAX,0xffff7ec0
CMP EAX,0x7d10
JNC 0x00136311
MOV EAX,EAX
LEA RCX,[0x27b2c0]
MOVZX EAX,word ptr [RCX + RAX*0x2]
MOVZX ECX,AX
MOV qword ptr [RSI],RCX
MOV EAX,0x2
TEST CX,CX
JNZ 0x0013631d
JMP 0x00136318
LAB_00136311:
MOV qword ptr [RSI],0x0
LAB_00136318:
MOV EAX,0xfffffffe
LAB_0013631d:
POP RBP
RET
|
int8 my_mb_wc_gbk(int8 param_1,ulong *param_2,byte *param_3,byte *param_4)
{
byte bVar1;
byte bVar2;
ushort uVar3;
uint uVar4;
int8 uVar5;
uVar5 = 0xffffff9b;
if (param_3 < param_4) {
bVar1 = *param_3;
if ((long)(char)bVar1 < 0) {
uVar5 = 0xffffff9a;
if ((((param_3 + 2 <= param_4) && (uVar5 = 0, bVar1 != 0x80)) && (bVar1 != 0xff)) &&
(bVar2 = param_3[1], (char)bVar2 < -1 || 0xc0 < (byte)(bVar2 + 0x81))) {
uVar4 = ((uint)bVar1 * 0x100 + (uint)bVar2) - 0x8140;
if (uVar4 < 0x7d10) {
uVar3 = *(ushort *)(&tab_gbk_uni0 + (ulong)uVar4 * 2);
*param_2 = (ulong)uVar3;
if (uVar3 != 0) {
return 2;
}
}
else {
*param_2 = 0;
}
uVar5 = 0xfffffffe;
}
}
else {
*param_2 = (long)(char)bVar1;
uVar5 = 1;
}
}
return uVar5;
}
| |
48,358 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [12], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [3], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, char const (&) [12], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, char const (&) [3], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | llama.cpp/common/json.hpp | inline OutStringType concat(Args && ... args)
{
OutStringType str;
str.reserve(concat_length(args...));
concat_into(str, std::forward<Args>(args)...);
return str;
} | O3 | cpp | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [12], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [3], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, char const (&) [12], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, char const (&) [3], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r13
movq %r8, %r14
movq %rcx, %r12
movq %rsi, %rbp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %r15
movq %rdx, 0x10(%rsp)
movq %rdx, %rdi
callq 0x20660
addq %rax, %r15
addq 0x8(%r12), %r15
movq %r14, 0x8(%rsp)
movq %r14, %rdi
callq 0x20660
addq %rax, %r15
addq 0x8(%r13), %r15
movq 0x50(%rsp), %rax
addq 0x8(%rax), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x20e00
movq (%rbp), %rsi
movq 0x8(%rbp), %rdx
movq %rbx, %rdi
callq 0x20540
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
callq 0x20b20
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rbx, %rdi
callq 0x20540
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
callq 0x20b20
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %rbx, %rdi
callq 0x20540
movq 0x50(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0x20540
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x7b48a
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x20170
movq %r14, %rdi
callq 0x20ad0
| _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJS8_RA12_KcS8_RA3_S9_S8_RKS8_EEET_DpOT0_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r13, r9
mov r14, r8
mov r12, rcx
mov rbp, rsi
mov rbx, rdi
lea rax, [rdi+10h]
mov [rsp+48h+var_48], rax
mov [rdi], rax
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
mov r15, [rsi+8]
mov [rsp+48h+var_38], rdx
mov rdi, rdx
call _strlen
add r15, rax
add r15, [r12+8]
mov [rsp+48h+var_40], r14
mov rdi, r14
call _strlen
add r15, rax
add r15, [r13+8]
mov rax, [rsp+48h+arg_0]
add r15, [rax+8]
mov rdi, rbx
mov rsi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
mov rsi, [rbp+0]
mov rdx, [rbp+8]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKcm; std::string::append(char const*,ulong)
mov rdi, rbx
mov rsi, [rsp+48h+var_38]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov rsi, [r12]
mov rdx, [r12+8]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKcm; std::string::append(char const*,ulong)
mov rdi, rbx
mov rsi, [rsp+48h+var_40]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov rsi, [r13+0]
mov rdx, [r13+8]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKcm; std::string::append(char const*,ulong)
mov rax, [rsp+48h+arg_0]
mov rsi, [rax]
mov rdx, [rax+8]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKcm; std::string::append(char const*,ulong)
mov rax, rbx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov r14, rax
mov rdi, [rbx]; void *
cmp rdi, [rsp+0]
jz short loc_7B48A
mov rax, [rsp+0]
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7B48A:
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::concat<std::string,std::string,char const(&)[12],std::string,char const(&)[3],std::string,std::string const&>(
long long a1,
_QWORD *a2,
long long a3,
_QWORD *a4,
long long a5,
_QWORD *a6,
_QWORD *a7)
{
long long v10; // r15
long long v11; // r15
long long v12; // rax
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
v10 = a2[1];
v11 = a4[1] + strlen(a3) + v10;
v12 = strlen(a5);
std::string::reserve(a1, a7[1] + a6[1] + v12 + v11);
std::string::append(a1, *a2, a2[1]);
std::string::append(a1, a3);
std::string::append(a1, *a4, a4[1]);
std::string::append(a1, a5);
std::string::append(a1, *a6, a6[1]);
std::string::append(a1, *a7, a7[1]);
return a1;
}
| concat<std::__cxx11::string,std::__cxx11::string,char_const(&)[12],std::__cxx11::string,char_const(&)[3],std::__cxx11::string,std::__cxx11::string_const&>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R13,R9
MOV R14,R8
MOV R12,RCX
MOV RBP,RSI
MOV RBX,RDI
LEA RAX,[RDI + 0x10]
MOV qword ptr [RSP],RAX
MOV qword ptr [RDI],RAX
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
MOV R15,qword ptr [RSI + 0x8]
MOV qword ptr [RSP + 0x10],RDX
MOV RDI,RDX
CALL 0x00120660
ADD R15,RAX
ADD R15,qword ptr [R12 + 0x8]
MOV qword ptr [RSP + 0x8],R14
MOV RDI,R14
CALL 0x00120660
ADD R15,RAX
ADD R15,qword ptr [R13 + 0x8]
MOV RAX,qword ptr [RSP + 0x50]
ADD R15,qword ptr [RAX + 0x8]
LAB_0017b3f3:
MOV RDI,RBX
MOV RSI,R15
CALL 0x00120e00
MOV RSI,qword ptr [RBP]
MOV RDX,qword ptr [RBP + 0x8]
MOV RDI,RBX
CALL 0x00120540
MOV RDI,RBX
MOV RSI,qword ptr [RSP + 0x10]
CALL 0x00120b20
MOV RSI,qword ptr [R12]
MOV RDX,qword ptr [R12 + 0x8]
MOV RDI,RBX
CALL 0x00120540
MOV RDI,RBX
MOV RSI,qword ptr [RSP + 0x8]
CALL 0x00120b20
MOV RSI,qword ptr [R13]
MOV RDX,qword ptr [R13 + 0x8]
MOV RDI,RBX
CALL 0x00120540
MOV RAX,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
MOV RDI,RBX
CALL 0x00120540
LAB_0017b45d:
MOV RAX,RBX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* std::__cxx11::string nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string,
std::__cxx11::string, char const (&) [12], std::__cxx11::string, char const (&) [3],
std::__cxx11::string, std::__cxx11::string const&>(std::__cxx11::string&&, char const (&) [12],
std::__cxx11::string&&, char const (&) [3], std::__cxx11::string&&, std::__cxx11::string const&)
*/
detail * __thiscall
nlohmann::json_abi_v3_11_3::detail::
concat<std::__cxx11::string,std::__cxx11::string,char_const(&)[12],std::__cxx11::string,char_const(&)[3],std::__cxx11::string,std::__cxx11::string_const&>
(detail *this,string *param_1,char *param_2,string *param_3,char *param_4,string *param_5,
string *param_6)
{
*(detail **)this = this + 0x10;
*(int8 *)(this + 8) = 0;
this[0x10] = (detail)0x0;
strlen(param_2);
strlen(param_4);
/* try { // try from 0017b3f3 to 0017b45c has its CatchHandler @ 0017b46f */
std::__cxx11::string::reserve((ulong)this);
std::__cxx11::string::append((char *)this,*(ulong *)param_1);
std::__cxx11::string::append((char *)this);
std::__cxx11::string::append((char *)this,*(ulong *)param_3);
std::__cxx11::string::append((char *)this);
std::__cxx11::string::append((char *)this,*(ulong *)param_5);
std::__cxx11::string::append((char *)this,*(ulong *)param_6);
return this;
}
| |
48,359 | LefDefParser::defiNonDefault::print(_IO_FILE*) const | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defiNonDefault.cpp | void defiNonDefault::print(FILE* f) const {
int i;
fprintf(f, "nondefaultrule %s\n", name());
fprintf(f, "%d layers %d vias %d viarules %d mincuts\n",
numLayers(),
numVias(),
numViaRules(),
numMinCuts());
for (i = 0; i < numLayers(); i++) {
fprintf(f, " Layer %s\n", layerName(i));
fprintf(f, " WIDTH %g\n", layerWidth(i));
if (hasLayerDiagWidth(i))
fprintf(f, " DIAGWIDTH %g\n", layerDiagWidth(i));
if (hasLayerSpacing(i))
fprintf(f, " SPACING %g\n", layerSpacing(i));
if (hasLayerWireExt(i))
fprintf(f, " WIREEXT %g\n",
layerWireExt(i));
}
for (i = 0; i < numVias(); i++) {
fprintf(f, " VIA %s\n", viaName(i));
}
for (i = 0; i < numViaRules(); i++) {
fprintf(f, " VIARULE %s\n", viaRuleName(i));
}
for (i = 0; i < numMinCuts(); i++) {
fprintf(f, " MINCUTS %s %d\n", cutLayerName(i),
numCuts(i));
}
} | O0 | cpp | LefDefParser::defiNonDefault::print(_IO_FILE*) const:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0xa0(%rsp), %rdi
movq %rdi, 0x78(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x70(%rsp)
callq 0x44ba0
movq 0x70(%rsp), %rdi
movq %rax, %rdx
leaq 0x2cdcc(%rip), %rsi # 0x72611
movb $0x0, %al
callq 0x7300
movq 0x78(%rsp), %rdi
movq 0x98(%rsp), %rax
movq %rax, 0x80(%rsp)
callq 0x44bc0
movq 0x78(%rsp), %rdi
movl %eax, 0x88(%rsp)
callq 0x454d0
movq 0x78(%rsp), %rdi
movl %eax, 0x8c(%rsp)
callq 0x455a0
movq 0x78(%rsp), %rdi
movl %eax, 0x90(%rsp)
callq 0x45670
movq 0x80(%rsp), %rdi
movl 0x88(%rsp), %edx
movl 0x8c(%rsp), %ecx
movl 0x90(%rsp), %r8d
movl %eax, %r9d
leaq 0x2cd63(%rip), %rsi # 0x72624
movb $0x0, %al
callq 0x7300
movl $0x0, 0x94(%rsp)
movq 0x78(%rsp), %rdi
movl 0x94(%rsp), %eax
movl %eax, 0x6c(%rsp)
callq 0x44bc0
movl %eax, %ecx
movl 0x6c(%rsp), %eax
cmpl %ecx, %eax
jge 0x45a48
movq 0x78(%rsp), %rdi
movq 0x98(%rsp), %rax
movq %rax, 0x58(%rsp)
movl 0x94(%rsp), %esi
callq 0x44bd0
movq 0x58(%rsp), %rdi
movq %rax, %rdx
leaq 0x2cd31(%rip), %rsi # 0x72654
movb $0x0, %al
callq 0x7300
movq 0x78(%rsp), %rdi
movq 0x98(%rsp), %rax
movq %rax, 0x60(%rsp)
movl 0x94(%rsp), %esi
callq 0x44c90
movq 0x60(%rsp), %rdi
leaq 0x2cd0c(%rip), %rsi # 0x72660
movb $0x1, %al
callq 0x7300
movq 0x78(%rsp), %rdi
movl 0x94(%rsp), %esi
callq 0x44e10
cmpl $0x0, %eax
je 0x459a2
movq 0x78(%rsp), %rdi
movq 0x98(%rsp), %rax
movq %rax, 0x50(%rsp)
movl 0x94(%rsp), %esi
callq 0x44ed0
movq 0x50(%rsp), %rdi
leaq 0x2ccd3(%rip), %rsi # 0x7266e
movb $0x1, %al
callq 0x7300
movq 0x78(%rsp), %rdi
movl 0x94(%rsp), %esi
callq 0x45110
cmpl $0x0, %eax
je 0x459e9
movq 0x78(%rsp), %rdi
movq 0x98(%rsp), %rax
movq %rax, 0x48(%rsp)
movl 0x94(%rsp), %esi
callq 0x45350
movq 0x48(%rsp), %rdi
leaq 0x2cc9e(%rip), %rsi # 0x72680
movb $0x1, %al
callq 0x7300
movq 0x78(%rsp), %rdi
movl 0x94(%rsp), %esi
callq 0x45050
cmpl $0x0, %eax
je 0x45a30
movq 0x78(%rsp), %rdi
movq 0x98(%rsp), %rax
movq %rax, 0x40(%rsp)
movl 0x94(%rsp), %esi
callq 0x451d0
movq 0x40(%rsp), %rdi
leaq 0x2cc67(%rip), %rsi # 0x72690
movb $0x1, %al
callq 0x7300
jmp 0x45a32
movl 0x94(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x94(%rsp)
jmp 0x458d3
movl $0x0, 0x94(%rsp)
movq 0x78(%rsp), %rdi
movl 0x94(%rsp), %eax
movl %eax, 0x3c(%rsp)
callq 0x454d0
movl %eax, %ecx
movl 0x3c(%rsp), %eax
cmpl %ecx, %eax
jge 0x45ab9
movq 0x78(%rsp), %rdi
movq 0x98(%rsp), %rax
movq %rax, 0x30(%rsp)
movl 0x94(%rsp), %esi
callq 0x454e0
movq 0x30(%rsp), %rdi
movq %rax, %rdx
leaq 0x2cc01(%rip), %rsi # 0x726a0
movb $0x0, %al
callq 0x7300
movl 0x94(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x94(%rsp)
jmp 0x45a53
movl $0x0, 0x94(%rsp)
movq 0x78(%rsp), %rdi
movl 0x94(%rsp), %eax
movl %eax, 0x2c(%rsp)
callq 0x455a0
movl %eax, %ecx
movl 0x2c(%rsp), %eax
cmpl %ecx, %eax
jge 0x45b2a
movq 0x78(%rsp), %rdi
movq 0x98(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x94(%rsp), %esi
callq 0x455b0
movq 0x20(%rsp), %rdi
movq %rax, %rdx
leaq 0x2cb9c(%rip), %rsi # 0x726ac
movb $0x0, %al
callq 0x7300
movl 0x94(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x94(%rsp)
jmp 0x45ac4
movl $0x0, 0x94(%rsp)
movq 0x78(%rsp), %rdi
movl 0x94(%rsp), %eax
movl %eax, 0x1c(%rsp)
callq 0x45670
movl %eax, %ecx
movl 0x1c(%rsp), %eax
cmpl %ecx, %eax
jge 0x45bb5
movq 0x78(%rsp), %rdi
movq 0x98(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x94(%rsp), %esi
callq 0x45680
movq 0x78(%rsp), %rdi
movq %rax, 0x10(%rsp)
movl 0x94(%rsp), %esi
callq 0x45740
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movl %eax, %ecx
leaq 0x2cb21(%rip), %rsi # 0x726bc
movb $0x0, %al
callq 0x7300
movl 0x94(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x94(%rsp)
jmp 0x45b35
addq $0xa8, %rsp
retq
nopl (%rax)
| _ZNK12LefDefParser14defiNonDefault5printEP8_IO_FILE:
sub rsp, 0A8h
mov [rsp+0A8h+var_8], rdi
mov [rsp+0A8h+var_10], rsi
mov rdi, [rsp+0A8h+var_8]; this
mov [rsp+0A8h+var_30], rdi
mov rax, [rsp+0A8h+var_10]
mov [rsp+0A8h+var_38], rax
call _ZNK12LefDefParser14defiNonDefault4nameEv; LefDefParser::defiNonDefault::name(void)
mov rdi, [rsp+0A8h+var_38]
mov rdx, rax
lea rsi, aNondefaultrule_5; "nondefaultrule %s\n"
mov al, 0
call _fprintf
mov rdi, [rsp+0A8h+var_30]; this
mov rax, [rsp+0A8h+var_10]
mov [rsp+0A8h+var_28], rax
call _ZNK12LefDefParser14defiNonDefault9numLayersEv; LefDefParser::defiNonDefault::numLayers(void)
mov rdi, [rsp+0A8h+var_30]; this
mov [rsp+0A8h+var_20], eax
call _ZNK12LefDefParser14defiNonDefault7numViasEv; LefDefParser::defiNonDefault::numVias(void)
mov rdi, [rsp+0A8h+var_30]; this
mov [rsp+0A8h+var_1C], eax
call _ZNK12LefDefParser14defiNonDefault11numViaRulesEv; LefDefParser::defiNonDefault::numViaRules(void)
mov rdi, [rsp+0A8h+var_30]; this
mov [rsp+0A8h+var_18], eax
call _ZNK12LefDefParser14defiNonDefault10numMinCutsEv; LefDefParser::defiNonDefault::numMinCuts(void)
mov rdi, [rsp+0A8h+var_28]
mov edx, [rsp+0A8h+var_20]
mov ecx, [rsp+0A8h+var_1C]
mov r8d, [rsp+0A8h+var_18]
mov r9d, eax
lea rsi, aDLayersDViasDV; "%d layers %d vias %d viarules %d "...
mov al, 0
call _fprintf
mov [rsp+0A8h+var_14], 0
loc_458D3:
mov rdi, [rsp+0A8h+var_30]; this
mov eax, [rsp+0A8h+var_14]
mov [rsp+0A8h+var_3C], eax
call _ZNK12LefDefParser14defiNonDefault9numLayersEv; LefDefParser::defiNonDefault::numLayers(void)
mov ecx, eax
mov eax, [rsp+0A8h+var_3C]
cmp eax, ecx
jge loc_45A48
mov rdi, [rsp+0A8h+var_30]; this
mov rax, [rsp+0A8h+var_10]
mov [rsp+0A8h+var_50], rax
mov esi, [rsp+0A8h+var_14]; int
call _ZNK12LefDefParser14defiNonDefault9layerNameEi; LefDefParser::defiNonDefault::layerName(int)
mov rdi, [rsp+0A8h+var_50]
mov rdx, rax
lea rsi, aLayerS_3; " Layer %s\n"
mov al, 0
call _fprintf
mov rdi, [rsp+0A8h+var_30]; this
mov rax, [rsp+0A8h+var_10]
mov [rsp+0A8h+var_48], rax
mov esi, [rsp+0A8h+var_14]; int
call _ZNK12LefDefParser14defiNonDefault10layerWidthEi; LefDefParser::defiNonDefault::layerWidth(int)
mov rdi, [rsp+0A8h+var_48]
lea rsi, aWidthG; " WIDTH %g\n"
mov al, 1
call _fprintf
mov rdi, [rsp+0A8h+var_30]; this
mov esi, [rsp+0A8h+var_14]; int
call _ZNK12LefDefParser14defiNonDefault17hasLayerDiagWidthEi; LefDefParser::defiNonDefault::hasLayerDiagWidth(int)
cmp eax, 0
jz short loc_459A2
mov rdi, [rsp+0A8h+var_30]; this
mov rax, [rsp+0A8h+var_10]
mov [rsp+0A8h+var_58], rax
mov esi, [rsp+0A8h+var_14]; int
call _ZNK12LefDefParser14defiNonDefault14layerDiagWidthEi; LefDefParser::defiNonDefault::layerDiagWidth(int)
mov rdi, [rsp+0A8h+var_58]
lea rsi, aDiagwidthG; " DIAGWIDTH %g\n"
mov al, 1
call _fprintf
loc_459A2:
mov rdi, [rsp+0A8h+var_30]; this
mov esi, [rsp+0A8h+var_14]; int
call _ZNK12LefDefParser14defiNonDefault15hasLayerSpacingEi; LefDefParser::defiNonDefault::hasLayerSpacing(int)
cmp eax, 0
jz short loc_459E9
mov rdi, [rsp+0A8h+var_30]; this
mov rax, [rsp+0A8h+var_10]
mov [rsp+0A8h+var_60], rax
mov esi, [rsp+0A8h+var_14]; int
call _ZNK12LefDefParser14defiNonDefault12layerSpacingEi; LefDefParser::defiNonDefault::layerSpacing(int)
mov rdi, [rsp+0A8h+var_60]
lea rsi, aSpacingG; " SPACING %g\n"
mov al, 1
call _fprintf
loc_459E9:
mov rdi, [rsp+0A8h+var_30]; this
mov esi, [rsp+0A8h+var_14]; int
call _ZNK12LefDefParser14defiNonDefault15hasLayerWireExtEi; LefDefParser::defiNonDefault::hasLayerWireExt(int)
cmp eax, 0
jz short loc_45A30
mov rdi, [rsp+0A8h+var_30]; this
mov rax, [rsp+0A8h+var_10]
mov [rsp+0A8h+var_68], rax
mov esi, [rsp+0A8h+var_14]; int
call _ZNK12LefDefParser14defiNonDefault12layerWireExtEi; LefDefParser::defiNonDefault::layerWireExt(int)
mov rdi, [rsp+0A8h+var_68]
lea rsi, aWireextG; " WIREEXT %g\n"
mov al, 1
call _fprintf
loc_45A30:
jmp short $+2
loc_45A32:
mov eax, [rsp+0A8h+var_14]
add eax, 1
mov [rsp+0A8h+var_14], eax
jmp loc_458D3
loc_45A48:
mov [rsp+0A8h+var_14], 0
loc_45A53:
mov rdi, [rsp+0A8h+var_30]; this
mov eax, [rsp+0A8h+var_14]
mov [rsp+0A8h+var_6C], eax
call _ZNK12LefDefParser14defiNonDefault7numViasEv; LefDefParser::defiNonDefault::numVias(void)
mov ecx, eax
mov eax, [rsp+0A8h+var_6C]
cmp eax, ecx
jge short loc_45AB9
mov rdi, [rsp+0A8h+var_30]; this
mov rax, [rsp+0A8h+var_10]
mov [rsp+0A8h+var_78], rax
mov esi, [rsp+0A8h+var_14]; int
call _ZNK12LefDefParser14defiNonDefault7viaNameEi; LefDefParser::defiNonDefault::viaName(int)
mov rdi, [rsp+0A8h+var_78]
mov rdx, rax
lea rsi, aViaS_3; " VIA %s\n"
mov al, 0
call _fprintf
mov eax, [rsp+0A8h+var_14]
add eax, 1
mov [rsp+0A8h+var_14], eax
jmp short loc_45A53
loc_45AB9:
mov [rsp+0A8h+var_14], 0
loc_45AC4:
mov rdi, [rsp+0A8h+var_30]; this
mov eax, [rsp+0A8h+var_14]
mov [rsp+0A8h+var_7C], eax
call _ZNK12LefDefParser14defiNonDefault11numViaRulesEv; LefDefParser::defiNonDefault::numViaRules(void)
mov ecx, eax
mov eax, [rsp+0A8h+var_7C]
cmp eax, ecx
jge short loc_45B2A
mov rdi, [rsp+0A8h+var_30]; this
mov rax, [rsp+0A8h+var_10]
mov [rsp+0A8h+var_88], rax
mov esi, [rsp+0A8h+var_14]; int
call _ZNK12LefDefParser14defiNonDefault11viaRuleNameEi; LefDefParser::defiNonDefault::viaRuleName(int)
mov rdi, [rsp+0A8h+var_88]
mov rdx, rax
lea rsi, aViaruleS_0; " VIARULE %s\n"
mov al, 0
call _fprintf
mov eax, [rsp+0A8h+var_14]
add eax, 1
mov [rsp+0A8h+var_14], eax
jmp short loc_45AC4
loc_45B2A:
mov [rsp+0A8h+var_14], 0
loc_45B35:
mov rdi, [rsp+0A8h+var_30]; this
mov eax, [rsp+0A8h+var_14]
mov [rsp+0A8h+var_8C], eax
call _ZNK12LefDefParser14defiNonDefault10numMinCutsEv; LefDefParser::defiNonDefault::numMinCuts(void)
mov ecx, eax
mov eax, [rsp+0A8h+var_8C]
cmp eax, ecx
jge short loc_45BB5
mov rdi, [rsp+0A8h+var_30]; this
mov rax, [rsp+0A8h+var_10]
mov [rsp+0A8h+var_A0], rax
mov esi, [rsp+0A8h+var_14]; int
call _ZNK12LefDefParser14defiNonDefault12cutLayerNameEi; LefDefParser::defiNonDefault::cutLayerName(int)
mov rdi, [rsp+0A8h+var_30]; this
mov [rsp+0A8h+var_98], rax
mov esi, [rsp+0A8h+var_14]; int
call _ZNK12LefDefParser14defiNonDefault7numCutsEi; LefDefParser::defiNonDefault::numCuts(int)
mov rdi, [rsp+0A8h+var_A0]
mov rdx, [rsp+0A8h+var_98]
mov ecx, eax
lea rsi, aMincutsSD; " MINCUTS %s %d\n"
mov al, 0
call _fprintf
mov eax, [rsp+0A8h+var_14]
add eax, 1
mov [rsp+0A8h+var_14], eax
jmp short loc_45B35
loc_45BB5:
add rsp, 0A8h
retn
| long long LefDefParser::defiNonDefault::print(LefDefParser::defiNonDefault *a1, long long a2)
{
const char *v2; // rax
int v3; // eax
const char *v4; // rax
double v5; // xmm0_8
double v6; // xmm0_8
double v7; // xmm0_8
double v8; // xmm0_8
const char *v9; // rax
const char *v10; // rax
int v11; // ecx
long long result; // rax
int v13; // eax
const char *v14; // [rsp+10h] [rbp-98h]
int v15; // [rsp+88h] [rbp-20h]
int v16; // [rsp+8Ch] [rbp-1Ch]
int v17; // [rsp+90h] [rbp-18h]
int i; // [rsp+94h] [rbp-14h]
int j; // [rsp+94h] [rbp-14h]
int k; // [rsp+94h] [rbp-14h]
int m; // [rsp+94h] [rbp-14h]
v2 = (const char *)LefDefParser::defiNonDefault::name(a1);
fprintf(a2, "nondefaultrule %s\n", v2);
v15 = LefDefParser::defiNonDefault::numLayers(a1);
v16 = LefDefParser::defiNonDefault::numVias(a1);
v17 = LefDefParser::defiNonDefault::numViaRules(a1);
v3 = LefDefParser::defiNonDefault::numMinCuts(a1);
fprintf(a2, "%d layers %d vias %d viarules %d mincuts\n", v15, v16, v17, v3);
for ( i = 0; i < (int)LefDefParser::defiNonDefault::numLayers(a1); ++i )
{
v4 = (const char *)LefDefParser::defiNonDefault::layerName((LefDefParser::defrData **)a1, i);
fprintf(a2, " Layer %s\n", v4);
v5 = LefDefParser::defiNonDefault::layerWidth((LefDefParser::defrData **)a1, i);
fprintf(a2, " WIDTH %g\n", v5);
if ( (unsigned int)LefDefParser::defiNonDefault::hasLayerDiagWidth((LefDefParser::defrData **)a1, i) )
{
v6 = LefDefParser::defiNonDefault::layerDiagWidth((LefDefParser::defrData **)a1, i);
fprintf(a2, " DIAGWIDTH %g\n", v6);
}
if ( (unsigned int)LefDefParser::defiNonDefault::hasLayerSpacing((LefDefParser::defrData **)a1, i) )
{
v7 = LefDefParser::defiNonDefault::layerSpacing((LefDefParser::defrData **)a1, i);
fprintf(a2, " SPACING %g\n", v7);
}
if ( (unsigned int)LefDefParser::defiNonDefault::hasLayerWireExt((LefDefParser::defrData **)a1, i) )
{
v8 = LefDefParser::defiNonDefault::layerWireExt((LefDefParser::defrData **)a1, i);
fprintf(a2, " WIREEXT %g\n", v8);
}
}
for ( j = 0; j < (int)LefDefParser::defiNonDefault::numVias(a1); ++j )
{
v9 = (const char *)LefDefParser::defiNonDefault::viaName((LefDefParser::defrData **)a1, j);
fprintf(a2, " VIA %s\n", v9);
}
for ( k = 0; k < (int)LefDefParser::defiNonDefault::numViaRules(a1); ++k )
{
v10 = (const char *)LefDefParser::defiNonDefault::viaRuleName((LefDefParser::defrData **)a1, k);
fprintf(a2, " VIARULE %s\n", v10);
}
for ( m = 0; ; ++m )
{
v11 = LefDefParser::defiNonDefault::numMinCuts(a1);
result = (unsigned int)m;
if ( m >= v11 )
break;
v14 = (const char *)LefDefParser::defiNonDefault::cutLayerName((LefDefParser::defrData **)a1, m);
v13 = LefDefParser::defiNonDefault::numCuts((LefDefParser::defrData **)a1, m);
fprintf(a2, " MINCUTS %s %d\n", v14, v13);
}
return result;
}
| print:
SUB RSP,0xa8
MOV qword ptr [RSP + 0xa0],RDI
MOV qword ptr [RSP + 0x98],RSI
MOV RDI,qword ptr [RSP + 0xa0]
MOV qword ptr [RSP + 0x78],RDI
MOV RAX,qword ptr [RSP + 0x98]
MOV qword ptr [RSP + 0x70],RAX
CALL 0x00144ba0
MOV RDI,qword ptr [RSP + 0x70]
MOV RDX,RAX
LEA RSI,[0x172611]
MOV AL,0x0
CALL 0x00107300
MOV RDI,qword ptr [RSP + 0x78]
MOV RAX,qword ptr [RSP + 0x98]
MOV qword ptr [RSP + 0x80],RAX
CALL 0x00144bc0
MOV RDI,qword ptr [RSP + 0x78]
MOV dword ptr [RSP + 0x88],EAX
CALL 0x001454d0
MOV RDI,qword ptr [RSP + 0x78]
MOV dword ptr [RSP + 0x8c],EAX
CALL 0x001455a0
MOV RDI,qword ptr [RSP + 0x78]
MOV dword ptr [RSP + 0x90],EAX
CALL 0x00145670
MOV RDI,qword ptr [RSP + 0x80]
MOV EDX,dword ptr [RSP + 0x88]
MOV ECX,dword ptr [RSP + 0x8c]
MOV R8D,dword ptr [RSP + 0x90]
MOV R9D,EAX
LEA RSI,[0x172624]
MOV AL,0x0
CALL 0x00107300
MOV dword ptr [RSP + 0x94],0x0
LAB_001458d3:
MOV RDI,qword ptr [RSP + 0x78]
MOV EAX,dword ptr [RSP + 0x94]
MOV dword ptr [RSP + 0x6c],EAX
CALL 0x00144bc0
MOV ECX,EAX
MOV EAX,dword ptr [RSP + 0x6c]
CMP EAX,ECX
JGE 0x00145a48
MOV RDI,qword ptr [RSP + 0x78]
MOV RAX,qword ptr [RSP + 0x98]
MOV qword ptr [RSP + 0x58],RAX
MOV ESI,dword ptr [RSP + 0x94]
CALL 0x00144bd0
MOV RDI,qword ptr [RSP + 0x58]
MOV RDX,RAX
LEA RSI,[0x172654]
MOV AL,0x0
CALL 0x00107300
MOV RDI,qword ptr [RSP + 0x78]
MOV RAX,qword ptr [RSP + 0x98]
MOV qword ptr [RSP + 0x60],RAX
MOV ESI,dword ptr [RSP + 0x94]
CALL 0x00144c90
MOV RDI,qword ptr [RSP + 0x60]
LEA RSI,[0x172660]
MOV AL,0x1
CALL 0x00107300
MOV RDI,qword ptr [RSP + 0x78]
MOV ESI,dword ptr [RSP + 0x94]
CALL 0x00144e10
CMP EAX,0x0
JZ 0x001459a2
MOV RDI,qword ptr [RSP + 0x78]
MOV RAX,qword ptr [RSP + 0x98]
MOV qword ptr [RSP + 0x50],RAX
MOV ESI,dword ptr [RSP + 0x94]
CALL 0x00144ed0
MOV RDI,qword ptr [RSP + 0x50]
LEA RSI,[0x17266e]
MOV AL,0x1
CALL 0x00107300
LAB_001459a2:
MOV RDI,qword ptr [RSP + 0x78]
MOV ESI,dword ptr [RSP + 0x94]
CALL 0x00145110
CMP EAX,0x0
JZ 0x001459e9
MOV RDI,qword ptr [RSP + 0x78]
MOV RAX,qword ptr [RSP + 0x98]
MOV qword ptr [RSP + 0x48],RAX
MOV ESI,dword ptr [RSP + 0x94]
CALL 0x00145350
MOV RDI,qword ptr [RSP + 0x48]
LEA RSI,[0x172680]
MOV AL,0x1
CALL 0x00107300
LAB_001459e9:
MOV RDI,qword ptr [RSP + 0x78]
MOV ESI,dword ptr [RSP + 0x94]
CALL 0x00145050
CMP EAX,0x0
JZ 0x00145a30
MOV RDI,qword ptr [RSP + 0x78]
MOV RAX,qword ptr [RSP + 0x98]
MOV qword ptr [RSP + 0x40],RAX
MOV ESI,dword ptr [RSP + 0x94]
CALL 0x001451d0
MOV RDI,qword ptr [RSP + 0x40]
LEA RSI,[0x172690]
MOV AL,0x1
CALL 0x00107300
LAB_00145a30:
JMP 0x00145a32
LAB_00145a32:
MOV EAX,dword ptr [RSP + 0x94]
ADD EAX,0x1
MOV dword ptr [RSP + 0x94],EAX
JMP 0x001458d3
LAB_00145a48:
MOV dword ptr [RSP + 0x94],0x0
LAB_00145a53:
MOV RDI,qword ptr [RSP + 0x78]
MOV EAX,dword ptr [RSP + 0x94]
MOV dword ptr [RSP + 0x3c],EAX
CALL 0x001454d0
MOV ECX,EAX
MOV EAX,dword ptr [RSP + 0x3c]
CMP EAX,ECX
JGE 0x00145ab9
MOV RDI,qword ptr [RSP + 0x78]
MOV RAX,qword ptr [RSP + 0x98]
MOV qword ptr [RSP + 0x30],RAX
MOV ESI,dword ptr [RSP + 0x94]
CALL 0x001454e0
MOV RDI,qword ptr [RSP + 0x30]
MOV RDX,RAX
LEA RSI,[0x1726a0]
MOV AL,0x0
CALL 0x00107300
MOV EAX,dword ptr [RSP + 0x94]
ADD EAX,0x1
MOV dword ptr [RSP + 0x94],EAX
JMP 0x00145a53
LAB_00145ab9:
MOV dword ptr [RSP + 0x94],0x0
LAB_00145ac4:
MOV RDI,qword ptr [RSP + 0x78]
MOV EAX,dword ptr [RSP + 0x94]
MOV dword ptr [RSP + 0x2c],EAX
CALL 0x001455a0
MOV ECX,EAX
MOV EAX,dword ptr [RSP + 0x2c]
CMP EAX,ECX
JGE 0x00145b2a
MOV RDI,qword ptr [RSP + 0x78]
MOV RAX,qword ptr [RSP + 0x98]
MOV qword ptr [RSP + 0x20],RAX
MOV ESI,dword ptr [RSP + 0x94]
CALL 0x001455b0
MOV RDI,qword ptr [RSP + 0x20]
MOV RDX,RAX
LEA RSI,[0x1726ac]
MOV AL,0x0
CALL 0x00107300
MOV EAX,dword ptr [RSP + 0x94]
ADD EAX,0x1
MOV dword ptr [RSP + 0x94],EAX
JMP 0x00145ac4
LAB_00145b2a:
MOV dword ptr [RSP + 0x94],0x0
LAB_00145b35:
MOV RDI,qword ptr [RSP + 0x78]
MOV EAX,dword ptr [RSP + 0x94]
MOV dword ptr [RSP + 0x1c],EAX
CALL 0x00145670
MOV ECX,EAX
MOV EAX,dword ptr [RSP + 0x1c]
CMP EAX,ECX
JGE 0x00145bb5
MOV RDI,qword ptr [RSP + 0x78]
MOV RAX,qword ptr [RSP + 0x98]
MOV qword ptr [RSP + 0x8],RAX
MOV ESI,dword ptr [RSP + 0x94]
CALL 0x00145680
MOV RDI,qword ptr [RSP + 0x78]
MOV qword ptr [RSP + 0x10],RAX
MOV ESI,dword ptr [RSP + 0x94]
CALL 0x00145740
MOV RDI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
MOV ECX,EAX
LEA RSI,[0x1726bc]
MOV AL,0x0
CALL 0x00107300
MOV EAX,dword ptr [RSP + 0x94]
ADD EAX,0x1
MOV dword ptr [RSP + 0x94],EAX
JMP 0x00145b35
LAB_00145bb5:
ADD RSP,0xa8
RET
|
/* LefDefParser::defiNonDefault::print(_IO_FILE*) const */
void __thiscall LefDefParser::defiNonDefault::print(defiNonDefault *this,_IO_FILE *param_1)
{
uint uVar1;
uint uVar2;
uint uVar3;
uint uVar4;
int iVar5;
int8 uVar6;
int local_14;
uVar6 = name(this);
fprintf(param_1,"nondefaultrule %s\n",uVar6);
uVar1 = numLayers(this);
uVar2 = numVias(this);
uVar3 = numViaRules(this);
uVar4 = numMinCuts(this);
fprintf(param_1,"%d layers %d vias %d viarules %d mincuts\n",(ulong)uVar1,(ulong)uVar2,
(ulong)uVar3,(ulong)uVar4);
local_14 = 0;
while( true ) {
iVar5 = numLayers(this);
if (iVar5 <= local_14) break;
uVar6 = layerName(this,local_14);
fprintf(param_1," Layer %s\n",uVar6);
layerWidth(this,local_14);
fprintf(param_1," WIDTH %g\n");
iVar5 = hasLayerDiagWidth(this,local_14);
if (iVar5 != 0) {
layerDiagWidth(this,local_14);
fprintf(param_1," DIAGWIDTH %g\n");
}
iVar5 = hasLayerSpacing(this,local_14);
if (iVar5 != 0) {
layerSpacing(this,local_14);
fprintf(param_1," SPACING %g\n");
}
iVar5 = hasLayerWireExt(this,local_14);
if (iVar5 != 0) {
layerWireExt(this,local_14);
fprintf(param_1," WIREEXT %g\n");
}
local_14 = local_14 + 1;
}
local_14 = 0;
while( true ) {
iVar5 = numVias(this);
if (iVar5 <= local_14) break;
uVar6 = viaName(this,local_14);
fprintf(param_1," VIA %s\n",uVar6);
local_14 = local_14 + 1;
}
local_14 = 0;
while( true ) {
iVar5 = numViaRules(this);
if (iVar5 <= local_14) break;
uVar6 = viaRuleName(this,local_14);
fprintf(param_1," VIARULE %s\n",uVar6);
local_14 = local_14 + 1;
}
local_14 = 0;
while( true ) {
iVar5 = numMinCuts(this);
if (iVar5 <= local_14) break;
uVar6 = cutLayerName(this,local_14);
uVar1 = numCuts(this,local_14);
fprintf(param_1," MINCUTS %s %d\n",uVar6,(ulong)uVar1);
local_14 = local_14 + 1;
}
return;
}
| |
48,360 | test_bug4026 | eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c | static int test_bug4026(MYSQL *mysql)
{
MYSQL_STMT *stmt;
MYSQL_BIND my_bind[2];
MYSQL_TIME time_in, time_out;
MYSQL_TIME datetime_in, datetime_out;
const char *stmt_text;
int rc;
/* Check that microseconds are inserted and selected successfully */
/* Create a statement handle and prepare it with select */
stmt= mysql_stmt_init(mysql);
stmt_text= "SELECT ?, ?";
rc= mysql_stmt_prepare(stmt, SL(stmt_text));
check_stmt_rc(rc, stmt);
/* Bind input buffers */
memset(my_bind, '\0', sizeof(MYSQL_BIND) * 2);
memset(&time_in, '\0', sizeof(MYSQL_TIME));
memset(&time_out, '\0', sizeof(MYSQL_TIME));
memset(&datetime_in, '\0', sizeof(MYSQL_TIME));
memset(&datetime_out, '\0', sizeof(MYSQL_TIME));
my_bind[0].buffer_type= MYSQL_TYPE_TIME;
my_bind[0].buffer= (void *) &time_in;
my_bind[1].buffer_type= MYSQL_TYPE_DATETIME;
my_bind[1].buffer= (void *) &datetime_in;
time_in.hour= 23;
time_in.minute= 59;
time_in.second= 59;
time_in.second_part= 123456;
/*
This is not necessary, just to make DIE_UNLESS below work: this field
is filled in when time is received from server
*/
time_in.time_type= MYSQL_TIMESTAMP_TIME;
datetime_in= time_in;
datetime_in.year= 2003;
datetime_in.month= 12;
datetime_in.day= 31;
datetime_in.time_type= MYSQL_TIMESTAMP_DATETIME;
mysql_stmt_bind_param(stmt, my_bind);
/* Execute the select statement */
rc= mysql_stmt_execute(stmt);
check_stmt_rc(rc, stmt);
my_bind[0].buffer= (void *) &time_out;
my_bind[1].buffer= (void *) &datetime_out;
mysql_stmt_bind_result(stmt, my_bind);
rc= mysql_stmt_fetch(stmt);
FAIL_UNLESS(rc == 0, "rc != 0");
FAIL_UNLESS(memcmp(&time_in, &time_out, sizeof(time_in)) == 0, "time_in != time_out");
FAIL_UNLESS(memcmp(&datetime_in, &datetime_out, sizeof(datetime_in)) == 0, "datetime_in != datetime_out");
mysql_stmt_close(stmt);
return OK;
} | O0 | c | test_bug4026:
pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp # imm = 0x1C0
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x44950
movq %rax, -0x18(%rbp)
leaq 0x42baa(%rip), %rax # 0x68d5d
movq %rax, -0x1a8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x1c0(%rbp)
movq -0x1a8(%rbp), %rax
movq %rax, -0x1b8(%rbp)
movq -0x1a8(%rbp), %rdi
callq 0x141a0
movq -0x1c0(%rbp), %rdi
movq -0x1b8(%rbp), %rsi
movq %rax, %rdx
callq 0x45070
movl %eax, -0x1ac(%rbp)
cmpl $0x0, -0x1ac(%rbp)
je 0x26236
movq -0x18(%rbp), %rdi
callq 0x43fd0
movq %rax, %rsi
leaq 0x3f379(%rip), %rdi # 0x65590
leaq 0x3fe4f(%rip), %rdx # 0x6606d
movl $0x8c0, %ecx # imm = 0x8C0
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x4(%rbp)
jmp 0x264a6
jmp 0x26238
leaq -0x100(%rbp), %rdi
xorl %esi, %esi
movl $0xe0, %edx
callq 0x14260
leaq -0x128(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x14260
leaq -0x150(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x14260
leaq -0x178(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x14260
leaq -0x1a0(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x14260
movl $0xb, -0xa0(%rbp)
leaq -0x128(%rbp), %rax
movq %rax, -0xf0(%rbp)
movl $0xc, -0x30(%rbp)
leaq -0x178(%rbp), %rax
movq %rax, -0x80(%rbp)
movl $0x17, -0x11c(%rbp)
movl $0x3b, -0x118(%rbp)
movl $0x3b, -0x114(%rbp)
movq $0x1e240, -0x110(%rbp) # imm = 0x1E240
movl $0x2, -0x104(%rbp)
leaq -0x178(%rbp), %rdi
leaq -0x128(%rbp), %rsi
movl $0x28, %edx
callq 0x14370
movl $0x7d3, -0x178(%rbp) # imm = 0x7D3
movl $0xc, -0x174(%rbp)
movl $0x1f, -0x170(%rbp)
movl $0x1, -0x154(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x100(%rbp), %rsi
callq 0x432c0
movq -0x18(%rbp), %rdi
callq 0x46580
movl %eax, -0x1ac(%rbp)
cmpl $0x0, -0x1ac(%rbp)
je 0x2638e
movq -0x18(%rbp), %rdi
callq 0x43fd0
movq %rax, %rsi
leaq 0x3f221(%rip), %rdi # 0x65590
leaq 0x3fcf7(%rip), %rdx # 0x6606d
movl $0x8e0, %ecx # imm = 0x8E0
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x4(%rbp)
jmp 0x264a6
jmp 0x26390
leaq -0x150(%rbp), %rax
movq %rax, -0xf0(%rbp)
leaq -0x1a0(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x100(%rbp), %rsi
callq 0x43940
movq -0x18(%rbp), %rdi
callq 0x44020
movl %eax, -0x1ac(%rbp)
cmpl $0x0, -0x1ac(%rbp)
je 0x263fe
leaq 0x3f1b8(%rip), %rdi # 0x65590
leaq 0x4298a(%rip), %rsi # 0x68d69
leaq 0x3fc87(%rip), %rdx # 0x6606d
movl $0x8e7, %ecx # imm = 0x8E7
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x4(%rbp)
jmp 0x264a6
jmp 0x26400
jmp 0x26402
leaq -0x128(%rbp), %rdi
leaq -0x150(%rbp), %rsi
movl $0x28, %edx
callq 0x141b0
cmpl $0x0, %eax
je 0x26449
leaq 0x3f16a(%rip), %rdi # 0x65590
leaq 0x409e0(%rip), %rsi # 0x66e0d
leaq 0x3fc39(%rip), %rdx # 0x6606d
movl $0x8e8, %ecx # imm = 0x8E8
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x4(%rbp)
jmp 0x264a6
jmp 0x2644b
jmp 0x2644d
leaq -0x178(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
movl $0x28, %edx
callq 0x141b0
cmpl $0x0, %eax
je 0x26494
leaq 0x3f11f(%rip), %rdi # 0x65590
leaq 0x428f9(%rip), %rsi # 0x68d71
leaq 0x3fbee(%rip), %rdx # 0x6606d
movl $0x8e9, %ecx # imm = 0x8E9
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x4(%rbp)
jmp 0x264a6
jmp 0x26496
movq -0x18(%rbp), %rdi
callq 0x43eb0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x1c0, %rsp # imm = 0x1C0
popq %rbp
retq
nopw %cs:(%rax,%rax)
| test_bug4026:
push rbp
mov rbp, rsp
sub rsp, 1C0h
mov [rbp+var_10], rdi
mov rdi, [rbp+var_10]
call mysql_stmt_init
mov [rbp+var_18], rax
lea rax, aSelect_0; "SELECT ?, ?"
mov [rbp+var_1A8], rax
mov rax, [rbp+var_18]
mov [rbp+var_1C0], rax
mov rax, [rbp+var_1A8]
mov [rbp+var_1B8], rax
mov rdi, [rbp+var_1A8]
call _strlen
mov rdi, [rbp+var_1C0]
mov rsi, [rbp+var_1B8]
mov rdx, rax
call mysql_stmt_prepare
mov [rbp+var_1AC], eax
cmp [rbp+var_1AC], 0
jz short loc_26236
mov rdi, [rbp+var_18]
call mysql_stmt_error
mov rsi, rax
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rdx, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 8C0h
mov al, 0
call diag
mov [rbp+var_4], 1
jmp loc_264A6
loc_26236:
jmp short $+2
loc_26238:
lea rdi, [rbp+var_100]
xor esi, esi
mov edx, 0E0h
call _memset
lea rdi, [rbp+var_128]
xor esi, esi
mov edx, 28h ; '('
call _memset
lea rdi, [rbp+var_150]
xor esi, esi
mov edx, 28h ; '('
call _memset
lea rdi, [rbp+var_178]
xor esi, esi
mov edx, 28h ; '('
call _memset
lea rdi, [rbp+var_1A0]
xor esi, esi
mov edx, 28h ; '('
call _memset
mov [rbp+var_A0], 0Bh
lea rax, [rbp+var_128]
mov [rbp+var_F0], rax
mov [rbp+var_30], 0Ch
lea rax, [rbp+var_178]
mov [rbp+var_80], rax
mov [rbp+var_11C], 17h
mov [rbp+var_118], 3Bh ; ';'
mov [rbp+var_114], 3Bh ; ';'
mov [rbp+var_110], offset loc_1E240
mov [rbp+var_104], 2
lea rdi, [rbp+var_178]
lea rsi, [rbp+var_128]
mov edx, 28h ; '('
call _memcpy
mov [rbp+var_178], 7D3h
mov [rbp+var_174], 0Ch
mov [rbp+var_170], 1Fh
mov [rbp+var_154], 1
mov rdi, [rbp+var_18]
lea rsi, [rbp+var_100]
call mysql_stmt_bind_param
mov rdi, [rbp+var_18]
call mysql_stmt_execute
mov [rbp+var_1AC], eax
cmp [rbp+var_1AC], 0
jz short loc_2638E
mov rdi, [rbp+var_18]
call mysql_stmt_error
mov rsi, rax
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rdx, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 8E0h
mov al, 0
call diag
mov [rbp+var_4], 1
jmp loc_264A6
loc_2638E:
jmp short $+2
loc_26390:
lea rax, [rbp+var_150]
mov [rbp+var_F0], rax
lea rax, [rbp+var_1A0]
mov [rbp+var_80], rax
mov rdi, [rbp+var_18]
lea rsi, [rbp+var_100]
call mysql_stmt_bind_result
mov rdi, [rbp+var_18]
call mysql_stmt_fetch
mov [rbp+var_1AC], eax
cmp [rbp+var_1AC], 0
jz short loc_263FE
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rsi, aRc0_0; "rc != 0"
lea rdx, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 8E7h
mov al, 0
call diag
mov [rbp+var_4], 1
jmp loc_264A6
loc_263FE:
jmp short $+2
loc_26400:
jmp short $+2
loc_26402:
lea rdi, [rbp+var_128]
lea rsi, [rbp+var_150]
mov edx, 28h ; '('
call _memcmp
cmp eax, 0
jz short loc_26449
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rsi, aTimeInTimeOut; "time_in != time_out"
lea rdx, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 8E8h
mov al, 0
call diag
mov [rbp+var_4], 1
jmp short loc_264A6
loc_26449:
jmp short $+2
loc_2644B:
jmp short $+2
loc_2644D:
lea rdi, [rbp+var_178]
lea rsi, [rbp+var_1A0]
mov edx, 28h ; '('
call _memcmp
cmp eax, 0
jz short loc_26494
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rsi, aDatetimeInDate; "datetime_in != datetime_out"
lea rdx, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 8E9h
mov al, 0
call diag
mov [rbp+var_4], 1
jmp short loc_264A6
loc_26494:
jmp short $+2
loc_26496:
mov rdi, [rbp+var_18]
call mysql_stmt_close
mov [rbp+var_4], 0
loc_264A6:
mov eax, [rbp+var_4]
add rsp, 1C0h
pop rbp
retn
| long long test_bug4026(long long a1)
{
long long v1; // rax
int v2; // eax
int v3; // r8d
int v4; // r9d
int v5; // eax
int v6; // r8d
int v7; // r9d
int v8; // r8d
int v9; // r9d
int v10; // r8d
int v11; // r9d
int v12; // r8d
int v13; // r9d
_BYTE v15[40]; // [rsp+20h] [rbp-1A0h] BYREF
_DWORD v16[10]; // [rsp+48h] [rbp-178h] BYREF
_BYTE v17[40]; // [rsp+70h] [rbp-150h] BYREF
_BYTE v18[12]; // [rsp+98h] [rbp-128h] BYREF
int v19; // [rsp+A4h] [rbp-11Ch]
int v20; // [rsp+A8h] [rbp-118h]
int v21; // [rsp+ACh] [rbp-114h]
void *v22; // [rsp+B0h] [rbp-110h]
int v23; // [rsp+BCh] [rbp-104h]
_BYTE v24[16]; // [rsp+C0h] [rbp-100h] BYREF
_BYTE *v25; // [rsp+D0h] [rbp-F0h]
int v26; // [rsp+120h] [rbp-A0h]
_BYTE *v27; // [rsp+140h] [rbp-80h]
int v28; // [rsp+190h] [rbp-30h]
long long v29; // [rsp+1A8h] [rbp-18h]
long long v30; // [rsp+1B0h] [rbp-10h]
v30 = a1;
v29 = mysql_stmt_init(a1);
v1 = strlen("SELECT ?, ?");
if ( (unsigned int)mysql_stmt_prepare(v29, "SELECT ?, ?", v1) )
{
v2 = mysql_stmt_error(v29);
diag(
(unsigned int)"Error: %s (%s: %d)",
v2,
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
2240,
v3,
v4);
return 1;
}
else
{
memset(v24, 0LL, 224LL);
memset(v18, 0LL, 40LL);
memset(v17, 0LL, sizeof(v17));
memset(v16, 0LL, sizeof(v16));
memset(v15, 0LL, sizeof(v15));
v26 = 11;
v25 = v18;
v28 = 12;
v27 = v16;
v19 = 23;
v20 = 59;
v21 = 59;
v22 = &loc_1E240;
v23 = 2;
memcpy(v16, v18, sizeof(v16));
v16[0] = 2003;
v16[1] = 12;
v16[2] = 31;
v16[9] = 1;
mysql_stmt_bind_param(v29, v24);
if ( (unsigned int)mysql_stmt_execute(v29) )
{
v5 = mysql_stmt_error(v29);
diag(
(unsigned int)"Error: %s (%s: %d)",
v5,
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
2272,
v6,
v7);
return 1;
}
else
{
v25 = v17;
v27 = v15;
mysql_stmt_bind_result(v29, v24);
if ( (unsigned int)mysql_stmt_fetch(v29) )
{
diag(
(unsigned int)"Error: %s (%s: %d)",
(unsigned int)"rc != 0",
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
2279,
v8,
v9);
return 1;
}
else if ( !(unsigned int)memcmp(v18, v17, 40LL) )
{
if ( !(unsigned int)memcmp(v16, v15, 40LL) )
{
mysql_stmt_close(v29);
return 0;
}
else
{
diag(
(unsigned int)"Error: %s (%s: %d)",
(unsigned int)"datetime_in != datetime_out",
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
2281,
v12,
v13);
return 1;
}
}
else
{
diag(
(unsigned int)"Error: %s (%s: %d)",
(unsigned int)"time_in != time_out",
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
2280,
v10,
v11);
return 1;
}
}
}
}
| test_bug4026:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x1c0
MOV qword ptr [RBP + -0x10],RDI
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00144950
MOV qword ptr [RBP + -0x18],RAX
LEA RAX,[0x168d5d]
MOV qword ptr [RBP + -0x1a8],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x1c0],RAX
MOV RAX,qword ptr [RBP + -0x1a8]
MOV qword ptr [RBP + -0x1b8],RAX
MOV RDI,qword ptr [RBP + -0x1a8]
CALL 0x001141a0
MOV RDI,qword ptr [RBP + -0x1c0]
MOV RSI,qword ptr [RBP + -0x1b8]
MOV RDX,RAX
CALL 0x00145070
MOV dword ptr [RBP + -0x1ac],EAX
CMP dword ptr [RBP + -0x1ac],0x0
JZ 0x00126236
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00143fd0
MOV RSI,RAX
LEA RDI,[0x165590]
LEA RDX,[0x16606d]
MOV ECX,0x8c0
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001264a6
LAB_00126236:
JMP 0x00126238
LAB_00126238:
LEA RDI,[RBP + -0x100]
XOR ESI,ESI
MOV EDX,0xe0
CALL 0x00114260
LEA RDI,[RBP + -0x128]
XOR ESI,ESI
MOV EDX,0x28
CALL 0x00114260
LEA RDI,[RBP + -0x150]
XOR ESI,ESI
MOV EDX,0x28
CALL 0x00114260
LEA RDI,[RBP + -0x178]
XOR ESI,ESI
MOV EDX,0x28
CALL 0x00114260
LEA RDI,[RBP + -0x1a0]
XOR ESI,ESI
MOV EDX,0x28
CALL 0x00114260
MOV dword ptr [RBP + -0xa0],0xb
LEA RAX,[RBP + -0x128]
MOV qword ptr [RBP + -0xf0],RAX
MOV dword ptr [RBP + -0x30],0xc
LEA RAX,[RBP + -0x178]
MOV qword ptr [RBP + -0x80],RAX
MOV dword ptr [RBP + -0x11c],0x17
MOV dword ptr [RBP + -0x118],0x3b
MOV dword ptr [RBP + -0x114],0x3b
MOV qword ptr [RBP + -0x110],0x1e240
MOV dword ptr [RBP + -0x104],0x2
LEA RDI,[RBP + -0x178]
LEA RSI,[RBP + -0x128]
MOV EDX,0x28
CALL 0x00114370
MOV dword ptr [RBP + -0x178],0x7d3
MOV dword ptr [RBP + -0x174],0xc
MOV dword ptr [RBP + -0x170],0x1f
MOV dword ptr [RBP + -0x154],0x1
MOV RDI,qword ptr [RBP + -0x18]
LEA RSI,[RBP + -0x100]
CALL 0x001432c0
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00146580
MOV dword ptr [RBP + -0x1ac],EAX
CMP dword ptr [RBP + -0x1ac],0x0
JZ 0x0012638e
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00143fd0
MOV RSI,RAX
LEA RDI,[0x165590]
LEA RDX,[0x16606d]
MOV ECX,0x8e0
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001264a6
LAB_0012638e:
JMP 0x00126390
LAB_00126390:
LEA RAX,[RBP + -0x150]
MOV qword ptr [RBP + -0xf0],RAX
LEA RAX,[RBP + -0x1a0]
MOV qword ptr [RBP + -0x80],RAX
MOV RDI,qword ptr [RBP + -0x18]
LEA RSI,[RBP + -0x100]
CALL 0x00143940
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00144020
MOV dword ptr [RBP + -0x1ac],EAX
CMP dword ptr [RBP + -0x1ac],0x0
JZ 0x001263fe
LEA RDI,[0x165590]
LEA RSI,[0x168d69]
LEA RDX,[0x16606d]
MOV ECX,0x8e7
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001264a6
LAB_001263fe:
JMP 0x00126400
LAB_00126400:
JMP 0x00126402
LAB_00126402:
LEA RDI,[RBP + -0x128]
LEA RSI,[RBP + -0x150]
MOV EDX,0x28
CALL 0x001141b0
CMP EAX,0x0
JZ 0x00126449
LEA RDI,[0x165590]
LEA RSI,[0x166e0d]
LEA RDX,[0x16606d]
MOV ECX,0x8e8
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001264a6
LAB_00126449:
JMP 0x0012644b
LAB_0012644b:
JMP 0x0012644d
LAB_0012644d:
LEA RDI,[RBP + -0x178]
LEA RSI,[RBP + -0x1a0]
MOV EDX,0x28
CALL 0x001141b0
CMP EAX,0x0
JZ 0x00126494
LEA RDI,[0x165590]
LEA RSI,[0x168d71]
LEA RDX,[0x16606d]
MOV ECX,0x8e9
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001264a6
LAB_00126494:
JMP 0x00126496
LAB_00126496:
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00143eb0
MOV dword ptr [RBP + -0x4],0x0
LAB_001264a6:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x1c0
POP RBP
RET
|
int4 test_bug4026(int8 param_1)
{
int iVar1;
int8 uVar2;
size_t sVar3;
int1 local_1a8 [40];
int4 local_180;
int4 local_17c;
int4 local_178;
int4 local_15c;
int1 local_158 [40];
int1 local_130 [12];
int4 local_124;
int4 local_120;
int4 local_11c;
int8 local_118;
int4 local_10c;
int1 local_108 [16];
int1 *local_f8;
int4 local_a8;
int4 *local_88;
int4 local_38;
int8 local_20;
int8 local_18;
int4 local_c;
local_18 = param_1;
uVar2 = mysql_stmt_init(param_1);
local_20 = uVar2;
sVar3 = strlen("SELECT ?, ?");
iVar1 = mysql_stmt_prepare(uVar2,"SELECT ?, ?",sVar3);
if (iVar1 == 0) {
memset(local_108,0,0xe0);
memset(local_130,0,0x28);
memset(local_158,0,0x28);
memset(&local_180,0,0x28);
memset(local_1a8,0,0x28);
local_a8 = 0xb;
local_f8 = local_130;
local_38 = 0xc;
local_88 = &local_180;
local_124 = 0x17;
local_120 = 0x3b;
local_11c = 0x3b;
local_118 = 0x1e240;
local_10c = 2;
memcpy(&local_180,local_130,0x28);
local_180 = 0x7d3;
local_17c = 0xc;
local_178 = 0x1f;
local_15c = 1;
mysql_stmt_bind_param(local_20,local_108);
iVar1 = mysql_stmt_execute(local_20);
if (iVar1 == 0) {
local_f8 = local_158;
local_88 = (int4 *)local_1a8;
mysql_stmt_bind_result(local_20,local_108);
iVar1 = mysql_stmt_fetch(local_20);
if (iVar1 == 0) {
iVar1 = memcmp(local_130,local_158,0x28);
if (iVar1 == 0) {
iVar1 = memcmp(&local_180,local_1a8,0x28);
if (iVar1 == 0) {
mysql_stmt_close(local_20);
local_c = 0;
}
else {
diag("Error: %s (%s: %d)","datetime_in != datetime_out",
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c"
,0x8e9);
local_c = 1;
}
}
else {
diag("Error: %s (%s: %d)","time_in != time_out",
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
0x8e8);
local_c = 1;
}
}
else {
diag("Error: %s (%s: %d)","rc != 0",
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
0x8e7);
local_c = 1;
}
}
else {
uVar2 = mysql_stmt_error(local_20);
diag("Error: %s (%s: %d)",uVar2,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",0x8e0
);
local_c = 1;
}
}
else {
uVar2 = mysql_stmt_error(local_20);
diag("Error: %s (%s: %d)",uVar2,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",0x8c0);
local_c = 1;
}
return local_c;
}
| |
48,361 | ggml_unary_impl | llama.cpp/ggml/src/ggml.c | static struct ggml_tensor * ggml_unary_impl(
struct ggml_context * ctx,
struct ggml_tensor * a,
enum ggml_unary_op op,
bool inplace) {
GGML_ASSERT(ggml_is_contiguous_1(a));
struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);
ggml_set_op_params_i32(result, 0, (int32_t) op);
result->op = GGML_OP_UNARY;
result->src[0] = a;
return result;
} | O3 | c | ggml_unary_impl:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl $0x1, %esi
callq 0x19721
testb %al, %al
je 0x1f4e1
testb %r15b, %r15b
je 0x1f4ac
movq %r14, %rdi
movq %rbx, %rsi
callq 0x16240
jmp 0x1f4c5
movl (%rbx), %esi
leaq 0x10(%rbx), %rcx
movq %r14, %rdi
movl $0x4, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x19be7
movl %ebp, 0x54(%rax)
movl $0x49, 0x50(%rax)
movq %rbx, 0x98(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2b12b(%rip), %rdi # 0x4a613
leaq 0x2b15f(%rip), %rdx # 0x4a64e
leaq 0x2d4d7(%rip), %rcx # 0x4c9cd
movl $0x12ce, %esi # imm = 0x12CE
xorl %eax, %eax
callq 0x17c80
| ggml_unary_impl:
push rbp
push r15
push r14
push rbx
push rax
mov r15d, ecx
mov ebp, edx
mov rbx, rsi
mov r14, rdi
mov rdi, rsi
mov esi, 1
call ggml_is_contiguous_n
test al, al
jz short loc_1F4E1
test r15b, r15b
jz short loc_1F4AC
mov rdi, r14
mov rsi, rbx
call _ggml_view_tensor
jmp short loc_1F4C5
loc_1F4AC:
mov esi, [rbx]
lea rcx, [rbx+10h]
mov rdi, r14
mov edx, 4
xor r8d, r8d
xor r9d, r9d
call ggml_new_tensor_impl
loc_1F4C5:
mov [rax+54h], ebp
mov dword ptr [rax+50h], 49h ; 'I'
mov [rax+98h], rbx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_1F4E1:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlIsContiguo_21; "ggml_is_contiguous_1(a)"
mov esi, 12CEh
xor eax, eax
call _ggml_abort
| long long ggml_unary_impl(long long a1, long long a2, int a3, char a4)
{
int v6; // r8d
int v7; // r9d
long long result; // rax
if ( !ggml_is_contiguous_n((unsigned int *)a2, 1) )
ggml_abort(
(unsigned int)"/workspace/llm4binary/github2025/llama.cpp/ggml/src/ggml.c",
4814,
(unsigned int)"GGML_ASSERT(%s) failed",
(unsigned int)"ggml_is_contiguous_1(a)",
v6,
v7);
if ( a4 )
result = ggml_view_tensor(a1, a2);
else
result = ggml_new_tensor_impl(a1, *(_DWORD *)a2, 4u, (_QWORD *)(a2 + 16), 0LL, 0LL);
*(_DWORD *)(result + 84) = a3;
*(_DWORD *)(result + 80) = 73;
*(_QWORD *)(result + 152) = a2;
return result;
}
| ggml_unary_impl:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R15D,ECX
MOV EBP,EDX
MOV RBX,RSI
MOV R14,RDI
MOV RDI,RSI
MOV ESI,0x1
CALL 0x00119721
TEST AL,AL
JZ 0x0011f4e1
TEST R15B,R15B
JZ 0x0011f4ac
MOV RDI,R14
MOV RSI,RBX
CALL 0x00116240
JMP 0x0011f4c5
LAB_0011f4ac:
MOV ESI,dword ptr [RBX]
LEA RCX,[RBX + 0x10]
MOV RDI,R14
MOV EDX,0x4
XOR R8D,R8D
XOR R9D,R9D
CALL 0x00119be7
LAB_0011f4c5:
MOV dword ptr [RAX + 0x54],EBP
MOV dword ptr [RAX + 0x50],0x49
MOV qword ptr [RAX + 0x98],RBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0011f4e1:
LEA RDI,[0x14a613]
LEA RDX,[0x14a64e]
LEA RCX,[0x14c9cd]
MOV ESI,0x12ce
XOR EAX,EAX
CALL 0x00117c80
|
void ggml_unary_impl(int8 param_1,int4 *param_2,int4 param_3,char param_4)
{
char cVar1;
long lVar2;
cVar1 = ggml_is_contiguous_n(param_2,1);
if (cVar1 != '\0') {
if (param_4 == '\0') {
lVar2 = ggml_new_tensor_impl(param_1,*param_2,4,param_2 + 4,0,0);
}
else {
lVar2 = ggml_view_tensor(param_1,param_2);
}
*(int4 *)(lVar2 + 0x54) = param_3;
*(int4 *)(lVar2 + 0x50) = 0x49;
*(int4 **)(lVar2 + 0x98) = param_2;
return;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/ggml/src/ggml.c",0x12ce,
"GGML_ASSERT(%s) failed","ggml_is_contiguous_1(a)");
}
| |
48,362 | get_and_remove_tx_type | corpus-core[P]colibri-stateless/src/chains/eth/verifier/eth_tx.c | static bool get_and_remove_tx_type(verify_ctx_t* ctx, bytes_t* raw_tx, tx_type_t* type) {
if (raw_tx->len < 1) RETURN_VERIFY_ERROR(ctx, "invalid tx data, missing type!");
*type = raw_tx->data[0];
if (*type >= 0x7f)
*type = TX_TYPE_LEGACY; // legacy tx
else if (*type > 3)
RETURN_VERIFY_ERROR(ctx, "invalid tx type, must be 1,2,3 or legacy tx!");
else {
raw_tx->data++;
raw_tx->len--;
}
return true;
} | O3 | c | get_and_remove_tx_type:
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, (%rsi)
je 0x2bcb4
movq 0x8(%rsi), %rax
movzbl (%rax), %ecx
movl %ecx, (%rdx)
cmpl $0x7f, %ecx
jb 0x2bcc1
movl $0x0, (%rdx)
jmp 0x2bce7
leaq 0x70(%rbx), %rdi
leaq 0x56d75(%rip), %rsi # 0x82a34
jmp 0x2bcd1
cmpb $0x4, %cl
jb 0x2bcde
leaq 0x70(%rbx), %rdi
leaq 0x56fdc(%rip), %rsi # 0x82cad
callq 0x589cd
movb $0x0, 0x68(%rbx)
xorl %eax, %eax
jmp 0x2bce9
incq %rax
movq %rax, 0x8(%rsi)
decl (%rsi)
movb $0x1, %al
popq %rbx
retq
| get_and_remove_tx_type:
push rbx
mov rbx, rdi
cmp dword ptr [rsi], 0
jz short loc_2BCB4
mov rax, [rsi+8]
movzx ecx, byte ptr [rax]
mov [rdx], ecx
cmp ecx, 7Fh
jb short loc_2BCC1
mov dword ptr [rdx], 0
jmp short loc_2BCE7
loc_2BCB4:
lea rdi, [rbx+70h]
lea rsi, aInvalidTxDataM; "invalid tx data, missing type!"
jmp short loc_2BCD1
loc_2BCC1:
cmp cl, 4
jb short loc_2BCDE
lea rdi, [rbx+70h]
lea rsi, aInvalidTxTypeM; "invalid tx type, must be 1,2,3 or legac"...
loc_2BCD1:
call c4_state_add_error
mov byte ptr [rbx+68h], 0
xor eax, eax
jmp short loc_2BCE9
loc_2BCDE:
inc rax
mov [rsi+8], rax
dec dword ptr [rsi]
loc_2BCE7:
mov al, 1
loc_2BCE9:
pop rbx
retn
| char get_and_remove_tx_type(long long a1, long long a2, unsigned int *a3)
{
unsigned __int8 *v4; // rax
unsigned int v5; // ecx
long long v6; // rdi
const char *v7; // rsi
if ( !*(_DWORD *)a2 )
{
v6 = a1 + 112;
v7 = "invalid tx data, missing type!";
goto LABEL_7;
}
v4 = *(unsigned __int8 **)(a2 + 8);
v5 = *v4;
*a3 = v5;
if ( v5 < 0x7F )
{
if ( (unsigned __int8)v5 < 4u )
{
*(_QWORD *)(a2 + 8) = v4 + 1;
--*(_DWORD *)a2;
return 1;
}
v6 = a1 + 112;
v7 = "invalid tx type, must be 1,2,3 or legacy tx!";
LABEL_7:
c4_state_add_error(v6, v7);
*(_BYTE *)(a1 + 104) = 0;
return 0;
}
*a3 = 0;
return 1;
}
| get_and_remove_tx_type:
PUSH RBX
MOV RBX,RDI
CMP dword ptr [RSI],0x0
JZ 0x0012bcb4
MOV RAX,qword ptr [RSI + 0x8]
MOVZX ECX,byte ptr [RAX]
MOV dword ptr [RDX],ECX
CMP ECX,0x7f
JC 0x0012bcc1
MOV dword ptr [RDX],0x0
JMP 0x0012bce7
LAB_0012bcb4:
LEA RDI,[RBX + 0x70]
LEA RSI,[0x182a34]
JMP 0x0012bcd1
LAB_0012bcc1:
CMP CL,0x4
JC 0x0012bcde
LEA RDI,[RBX + 0x70]
LEA RSI,[0x182cad]
LAB_0012bcd1:
CALL 0x001589cd
MOV byte ptr [RBX + 0x68],0x0
XOR EAX,EAX
JMP 0x0012bce9
LAB_0012bcde:
INC RAX
MOV qword ptr [RSI + 0x8],RAX
DEC dword ptr [RSI]
LAB_0012bce7:
MOV AL,0x1
LAB_0012bce9:
POP RBX
RET
|
int8 get_and_remove_tx_type(long param_1,int *param_2,uint *param_3)
{
byte bVar1;
byte *pbVar2;
int8 uVar3;
char *pcVar4;
if (*param_2 == 0) {
pcVar4 = "invalid tx data, missing type!";
LAB_0012bcd1:
c4_state_add_error(param_1 + 0x70,pcVar4);
*(int1 *)(param_1 + 0x68) = 0;
uVar3 = 0;
}
else {
pbVar2 = *(byte **)(param_2 + 2);
bVar1 = *pbVar2;
*param_3 = (uint)bVar1;
if (bVar1 < 0x7f) {
if (3 < bVar1) {
pcVar4 = "invalid tx type, must be 1,2,3 or legacy tx!";
goto LAB_0012bcd1;
}
pbVar2 = pbVar2 + 1;
*(byte **)(param_2 + 2) = pbVar2;
*param_2 = *param_2 + -1;
}
else {
*param_3 = 0;
}
uVar3 = CONCAT71((int7)((ulong)pbVar2 >> 8),1);
}
return uVar3;
}
| |
48,363 | LefDefParser::defwStartSlots(int) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defwWriter.cpp | int
defwStartSlots(int count)
{
defwFunc = DEFW_SLOT_START; // Current function of writer
if (!defwFile)
return DEFW_UNINITIALIZED;
if ((defwState >= DEFW_SLOT_START) && (defwState <= DEFW_SLOT_END))
return DEFW_BAD_ORDER;
if (defVersionNum < 5.4)
return DEFW_WRONG_VERSION;
fprintf(defwFile, "SLOTS %d ;\n", count);
defwLines++;
defwState = DEFW_SLOT_START;
defwCounter = count;
return DEFW_OK;
} | O0 | cpp | LefDefParser::defwStartSlots(int):
pushq %rax
movl %edi, (%rsp)
leaq 0xae7d(%rip), %rax # 0x2b168
movl $0x50, (%rax)
leaq 0xae60(%rip), %rax # 0x2b158
cmpq $0x0, (%rax)
jne 0x2030b
movl $0x1, 0x4(%rsp)
jmp 0x2039a
leaq 0xae52(%rip), %rax # 0x2b164
cmpl $0x50, (%rax)
jl 0x2032d
leaq 0xae46(%rip), %rax # 0x2b164
cmpl $0x53, (%rax)
jg 0x2032d
movl $0x2, 0x4(%rsp)
jmp 0x2039a
movsd 0x2ffb(%rip), %xmm0 # 0x23330
ucomisd 0xad73(%rip), %xmm0 # 0x2b0b0
jbe 0x20349
movl $0x5, 0x4(%rsp)
jmp 0x2039a
leaq 0xae08(%rip), %rax # 0x2b158
movq (%rax), %rdi
movl (%rsp), %edx
leaq 0x4ed0(%rip), %rsi # 0x2522d
movb $0x0, %al
callq 0x10f0
leaq 0xadf5(%rip), %rax # 0x2b160
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0xade9(%rip), %rax # 0x2b160
movl %ecx, (%rax)
leaq 0xade4(%rip), %rax # 0x2b164
movl $0x50, (%rax)
movl (%rsp), %ecx
leaq 0xade8(%rip), %rax # 0x2b178
movl %ecx, (%rax)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
popq %rcx
retq
| _ZN12LefDefParser14defwStartSlotsEi:
push rax
mov [rsp+8+var_8], edi
lea rax, _ZN12LefDefParser8defwFuncE; LefDefParser::defwFunc
mov dword ptr [rax], 50h ; 'P'
lea rax, _ZN12LefDefParser8defwFileE; LefDefParser::defwFile
cmp qword ptr [rax], 0
jnz short loc_2030B
mov [rsp+8+var_4], 1
jmp loc_2039A
loc_2030B:
lea rax, _ZN12LefDefParser9defwStateE; LefDefParser::defwState
cmp dword ptr [rax], 50h ; 'P'
jl short loc_2032D
lea rax, _ZN12LefDefParser9defwStateE; LefDefParser::defwState
cmp dword ptr [rax], 53h ; 'S'
jg short loc_2032D
mov [rsp+8+var_4], 2
jmp short loc_2039A
loc_2032D:
movsd xmm0, cs:qword_23330
ucomisd xmm0, cs:_ZN12LefDefParserL13defVersionNumE; LefDefParser::defVersionNum
jbe short loc_20349
mov [rsp+8+var_4], 5
jmp short loc_2039A
loc_20349:
lea rax, _ZN12LefDefParser8defwFileE; LefDefParser::defwFile
mov rdi, [rax]
mov edx, [rsp+8+var_8]
lea rsi, aSlotsD; "SLOTS %d ;\n"
mov al, 0
call _fprintf
lea rax, _ZN12LefDefParser9defwLinesE; LefDefParser::defwLines
mov ecx, [rax]
add ecx, 1
lea rax, _ZN12LefDefParser9defwLinesE; LefDefParser::defwLines
mov [rax], ecx
lea rax, _ZN12LefDefParser9defwStateE; LefDefParser::defwState
mov dword ptr [rax], 50h ; 'P'
mov ecx, [rsp+8+var_8]
lea rax, _ZN12LefDefParser11defwCounterE; LefDefParser::defwCounter
mov [rax], ecx
mov [rsp+8+var_4], 0
loc_2039A:
mov eax, [rsp+8+var_4]
pop rcx
retn
| long long LefDefParser::defwStartSlots(LefDefParser *this)
{
LefDefParser::defwFunc = 80;
if ( LefDefParser::defwFile )
{
if ( LefDefParser::defwState < 80 || LefDefParser::defwState > 83 )
{
if ( *(double *)&LefDefParser::defVersionNum >= 5.4 )
{
fprintf(LefDefParser::defwFile, "SLOTS %d ;\n", (_DWORD)this);
++LefDefParser::defwLines;
LefDefParser::defwState = 80;
LefDefParser::defwCounter = (_DWORD)this;
return 0;
}
else
{
return 5;
}
}
else
{
return 2;
}
}
else
{
return 1;
}
}
| defwStartSlots:
PUSH RAX
MOV dword ptr [RSP],EDI
LEA RAX,[0x12b168]
MOV dword ptr [RAX],0x50
LEA RAX,[0x12b158]
CMP qword ptr [RAX],0x0
JNZ 0x0012030b
MOV dword ptr [RSP + 0x4],0x1
JMP 0x0012039a
LAB_0012030b:
LEA RAX,[0x12b164]
CMP dword ptr [RAX],0x50
JL 0x0012032d
LEA RAX,[0x12b164]
CMP dword ptr [RAX],0x53
JG 0x0012032d
MOV dword ptr [RSP + 0x4],0x2
JMP 0x0012039a
LAB_0012032d:
MOVSD XMM0,qword ptr [0x00123330]
UCOMISD XMM0,qword ptr [0x0012b0b0]
JBE 0x00120349
MOV dword ptr [RSP + 0x4],0x5
JMP 0x0012039a
LAB_00120349:
LEA RAX,[0x12b158]
MOV RDI,qword ptr [RAX]
MOV EDX,dword ptr [RSP]
LEA RSI,[0x12522d]
MOV AL,0x0
CALL 0x001010f0
LEA RAX,[0x12b160]
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
LEA RAX,[0x12b160]
MOV dword ptr [RAX],ECX
LEA RAX,[0x12b164]
MOV dword ptr [RAX],0x50
MOV ECX,dword ptr [RSP]
LEA RAX,[0x12b178]
MOV dword ptr [RAX],ECX
MOV dword ptr [RSP + 0x4],0x0
LAB_0012039a:
MOV EAX,dword ptr [RSP + 0x4]
POP RCX
RET
|
/* LefDefParser::defwStartSlots(int) */
int4 LefDefParser::defwStartSlots(int param_1)
{
int4 local_4;
defwFunc = 0x50;
if (defwFile == (FILE *)0x0) {
local_4 = 1;
}
else if ((defwState < 0x50) || (0x53 < defwState)) {
if (DAT_00123330 <= defVersionNum) {
fprintf(defwFile,"SLOTS %d ;\n",param_1);
defwLines = defwLines + 1;
defwState = 0x50;
local_4 = 0;
defwCounter = param_1;
}
else {
local_4 = 5;
}
}
else {
local_4 = 2;
}
return local_4;
}
| |
48,364 | buffer_grow | corpus-core[P]colibri-stateless/src/util/bytes.c | void buffer_grow(buffer_t* buffer, size_t min_len) {
if (buffer->data.data == NULL) {
if (buffer->allocated > 0 && (size_t) buffer->allocated > min_len) min_len = (size_t) buffer->allocated;
buffer->data.data = safe_malloc(min_len);
buffer->allocated = (int32_t) min_len;
}
else if (buffer->allocated >= 0 && (size_t) buffer->allocated < min_len) {
size_t new_len = (size_t) buffer->allocated;
while (new_len < min_len) new_len = (new_len + 1) * 3 / 2;
buffer->data.data = safe_realloc(buffer->data.data, new_len);
buffer->allocated = (int32_t) new_len;
}
} | O0 | c | buffer_grow:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x9c9b2
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jle 0x9c98f
movq -0x8(%rbp), %rax
movslq 0x10(%rax), %rax
cmpq -0x10(%rbp), %rax
jbe 0x9c98f
movq -0x8(%rbp), %rax
movslq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9c400
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
jmp 0x9ca20
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jl 0x9ca1e
movq -0x8(%rbp), %rax
movslq 0x10(%rax), %rax
cmpq -0x10(%rbp), %rax
jae 0x9ca1e
movq -0x8(%rbp), %rax
movslq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x9c9f5
movq -0x18(%rbp), %rax
addq $0x1, %rax
imulq $0x3, %rax, %rax
shrq %rax
movq %rax, -0x18(%rbp)
jmp 0x9c9d6
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x9c520
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
jmp 0x9ca20
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| buffer_grow:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
cmp qword ptr [rax+8], 0
jnz short loc_9C9B2
mov rax, [rbp+var_8]
cmp dword ptr [rax+10h], 0
jle short loc_9C98F
mov rax, [rbp+var_8]
movsxd rax, dword ptr [rax+10h]
cmp rax, [rbp+var_10]
jbe short loc_9C98F
mov rax, [rbp+var_8]
movsxd rax, dword ptr [rax+10h]
mov [rbp+var_10], rax
loc_9C98F:
mov rdi, [rbp+var_10]
call safe_malloc
mov rcx, rax
mov rax, [rbp+var_8]
mov [rax+8], rcx
mov rax, [rbp+var_10]
mov ecx, eax
mov rax, [rbp+var_8]
mov [rax+10h], ecx
jmp short loc_9CA20
loc_9C9B2:
mov rax, [rbp+var_8]
cmp dword ptr [rax+10h], 0
jl short loc_9CA1E
mov rax, [rbp+var_8]
movsxd rax, dword ptr [rax+10h]
cmp rax, [rbp+var_10]
jnb short loc_9CA1E
mov rax, [rbp+var_8]
movsxd rax, dword ptr [rax+10h]
mov [rbp+var_18], rax
loc_9C9D6:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_10]
jnb short loc_9C9F5
mov rax, [rbp+var_18]
add rax, 1
imul rax, 3
shr rax, 1
mov [rbp+var_18], rax
jmp short loc_9C9D6
loc_9C9F5:
mov rax, [rbp+var_8]
mov rdi, [rax+8]
mov rsi, [rbp+var_18]
call safe_realloc
mov rcx, rax
mov rax, [rbp+var_8]
mov [rax+8], rcx
mov rax, [rbp+var_18]
mov ecx, eax
mov rax, [rbp+var_8]
mov [rax+10h], ecx
loc_9CA1E:
jmp short $+2
loc_9CA20:
add rsp, 20h
pop rbp
retn
| unsigned long long buffer_grow(unsigned long long a1, unsigned long long a2)
{
unsigned long long result; // rax
unsigned long long i; // [rsp+8h] [rbp-18h]
long long v4; // [rsp+10h] [rbp-10h]
v4 = a2;
if ( *(_QWORD *)(a1 + 8) )
{
result = a1;
if ( *(int *)(a1 + 16) >= 0 )
{
result = *(int *)(a1 + 16);
if ( result < a2 )
{
for ( i = *(int *)(a1 + 16); i < a2; i = (3 * (i + 1)) >> 1 )
;
*(_QWORD *)(a1 + 8) = safe_realloc(*(_QWORD *)(a1 + 8), i);
result = a1;
*(_DWORD *)(a1 + 16) = i;
}
}
}
else
{
if ( *(int *)(a1 + 16) > 0 && *(int *)(a1 + 16) > a2 )
v4 = *(int *)(a1 + 16);
*(_QWORD *)(a1 + 8) = safe_malloc(v4);
result = a1;
*(_DWORD *)(a1 + 16) = v4;
}
return result;
}
| buffer_grow:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x8],0x0
JNZ 0x0019c9b2
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x10],0x0
JLE 0x0019c98f
MOV RAX,qword ptr [RBP + -0x8]
MOVSXD RAX,dword ptr [RAX + 0x10]
CMP RAX,qword ptr [RBP + -0x10]
JBE 0x0019c98f
MOV RAX,qword ptr [RBP + -0x8]
MOVSXD RAX,dword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x10],RAX
LAB_0019c98f:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0019c400
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x10],ECX
JMP 0x0019ca20
LAB_0019c9b2:
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x10],0x0
JL 0x0019ca1e
MOV RAX,qword ptr [RBP + -0x8]
MOVSXD RAX,dword ptr [RAX + 0x10]
CMP RAX,qword ptr [RBP + -0x10]
JNC 0x0019ca1e
MOV RAX,qword ptr [RBP + -0x8]
MOVSXD RAX,dword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x18],RAX
LAB_0019c9d6:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x10]
JNC 0x0019c9f5
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
IMUL RAX,RAX,0x3
SHR RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0019c9d6
LAB_0019c9f5:
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x8]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x0019c520
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x10],ECX
LAB_0019ca1e:
JMP 0x0019ca20
LAB_0019ca20:
ADD RSP,0x20
POP RBP
RET
|
void buffer_grow(long param_1,ulong param_2)
{
int8 uVar1;
ulong local_20;
ulong local_18;
if (*(long *)(param_1 + 8) == 0) {
local_18 = param_2;
if ((0 < *(int *)(param_1 + 0x10)) && (param_2 < (ulong)(long)*(int *)(param_1 + 0x10))) {
local_18 = (ulong)*(int *)(param_1 + 0x10);
}
uVar1 = safe_malloc(local_18);
*(int8 *)(param_1 + 8) = uVar1;
*(int *)(param_1 + 0x10) = (int)local_18;
}
else if ((-1 < *(int *)(param_1 + 0x10)) && ((ulong)(long)*(int *)(param_1 + 0x10) < param_2)) {
for (local_20 = (ulong)*(int *)(param_1 + 0x10); local_20 < param_2;
local_20 = (local_20 + 1) * 3 >> 1) {
}
uVar1 = safe_realloc(*(int8 *)(param_1 + 8),local_20);
*(int8 *)(param_1 + 8) = uVar1;
*(int *)(param_1 + 0x10) = (int)local_20;
}
return;
}
| |
48,365 | buffer_grow | corpus-core[P]colibri-stateless/src/util/bytes.c | void buffer_grow(buffer_t* buffer, size_t min_len) {
if (buffer->data.data == NULL) {
if (buffer->allocated > 0 && (size_t) buffer->allocated > min_len) min_len = (size_t) buffer->allocated;
buffer->data.data = safe_malloc(min_len);
buffer->allocated = (int32_t) min_len;
}
else if (buffer->allocated >= 0 && (size_t) buffer->allocated < min_len) {
size_t new_len = (size_t) buffer->allocated;
while (new_len < min_len) new_len = (new_len + 1) * 3 / 2;
buffer->data.data = safe_realloc(buffer->data.data, new_len);
buffer->allocated = (int32_t) new_len;
}
} | O3 | c | buffer_grow:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movl 0x10(%rbx), %r14d
testq %rdi, %rdi
je 0x50fb3
testl %r14d, %r14d
setns %al
cmpq %rsi, %r14
setb %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x50fd7
leaq (%r14,%r14,2), %r14
addq $0x3, %r14
shrq %r14
cmpq %rsi, %r14
jb 0x50f99
movq %r14, %rsi
callq 0x50f29
jmp 0x50fcf
cmpq %rsi, %r14
movq %r14, %r15
cmovbeq %rsi, %r15
testl %r14d, %r14d
cmovleq %rsi, %r15
movq %r15, %rdi
callq 0x50ecc
movq %r15, %r14
movq %rax, 0x8(%rbx)
movl %r14d, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
| buffer_grow:
push r15
push r14
push rbx
mov rbx, rdi
mov rdi, [rdi+8]
mov r14d, [rbx+10h]
test rdi, rdi
jz short loc_50FB3
test r14d, r14d
setns al
cmp r14, rsi
setb cl
and cl, al
cmp cl, 1
jnz short loc_50FD7
loc_50F99:
lea r14, [r14+r14*2]
add r14, 3
shr r14, 1
cmp r14, rsi
jb short loc_50F99
mov rsi, r14
call safe_realloc
jmp short loc_50FCF
loc_50FB3:
cmp r14, rsi
mov r15, r14
cmovbe r15, rsi
test r14d, r14d
cmovle r15, rsi
mov rdi, r15
call safe_malloc
mov r14, r15
loc_50FCF:
mov [rbx+8], rax
mov [rbx+10h], r14d
loc_50FD7:
pop rbx
pop r14
pop r15
retn
| char buffer_grow(long long a1, unsigned long long a2)
{
long long v3; // rdi
unsigned long long v4; // r14
long long v5; // rax
long long v6; // r15
v3 = *(_QWORD *)(a1 + 8);
v4 = *(unsigned int *)(a1 + 16);
if ( !v3 )
{
v6 = *(unsigned int *)(a1 + 16);
if ( v4 <= a2 )
v6 = a2;
if ( (int)v4 <= 0 )
v6 = a2;
v5 = safe_malloc(v6);
LODWORD(v4) = v6;
goto LABEL_10;
}
LOBYTE(v5) = (v4 & 0x80000000) == 0LL;
if ( (v4 & 0x80000000) == 0LL && v4 < a2 )
{
do
v4 = (3 * v4 + 3) >> 1;
while ( v4 < a2 );
v5 = safe_realloc(v3, v4);
LABEL_10:
*(_QWORD *)(a1 + 8) = v5;
*(_DWORD *)(a1 + 16) = v4;
}
return v5;
}
| buffer_grow:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x8]
MOV R14D,dword ptr [RBX + 0x10]
TEST RDI,RDI
JZ 0x00150fb3
TEST R14D,R14D
SETNS AL
CMP R14,RSI
SETC CL
AND CL,AL
CMP CL,0x1
JNZ 0x00150fd7
LAB_00150f99:
LEA R14,[R14 + R14*0x2]
ADD R14,0x3
SHR R14,0x1
CMP R14,RSI
JC 0x00150f99
MOV RSI,R14
CALL 0x00150f29
JMP 0x00150fcf
LAB_00150fb3:
CMP R14,RSI
MOV R15,R14
CMOVBE R15,RSI
TEST R14D,R14D
CMOVLE R15,RSI
MOV RDI,R15
CALL 0x00150ecc
MOV R14,R15
LAB_00150fcf:
MOV qword ptr [RBX + 0x8],RAX
MOV dword ptr [RBX + 0x10],R14D
LAB_00150fd7:
POP RBX
POP R14
POP R15
RET
|
void buffer_grow(long param_1,ulong param_2)
{
uint uVar1;
int8 uVar2;
ulong uVar3;
uVar1 = *(uint *)(param_1 + 0x10);
uVar3 = (ulong)uVar1;
if (*(long *)(param_1 + 8) == 0) {
if (uVar3 <= param_2) {
uVar3 = param_2;
}
if ((int)uVar1 < 1) {
uVar3 = param_2;
}
uVar2 = safe_malloc(uVar3);
}
else {
if (param_2 <= uVar3 || (int)uVar1 < 0) {
return;
}
do {
uVar3 = uVar3 * 3 + 3 >> 1;
} while (uVar3 < param_2);
uVar2 = safe_realloc(*(long *)(param_1 + 8),uVar3);
}
*(int8 *)(param_1 + 8) = uVar2;
*(int *)(param_1 + 0x10) = (int)uVar3;
return;
}
| |
48,366 | ma_read_key_record | eloqsql/storage/maria/ma_key.c | int _ma_read_key_record(MARIA_HA *info, uchar *buf, MARIA_RECORD_POS filepos)
{
fast_ma_writeinfo(info);
if (filepos != HA_OFFSET_ERROR)
{
if (info->lastinx >= 0)
{ /* Read only key */
if (_ma_put_key_in_record(info, (uint)info->lastinx, TRUE, buf))
{
_ma_set_fatal_error(info, HA_ERR_CRASHED);
return -1;
}
info->update|= HA_STATE_AKTIV; /* We should find a record */
return 0;
}
my_errno=HA_ERR_WRONG_INDEX;
}
return(-1); /* Wrong data to read */
} | O3 | c | ma_read_key_record:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rax
cmpl $0x0, 0x7b8(%rax)
jne 0x373ce
movq %r14, %rdi
xorl %esi, %esi
callq 0x37dbe
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
cmpq $-0x1, %r12
je 0x3741e
movl 0x62c(%r14), %esi
testl %esi, %esi
js 0x37407
movq %r14, %rdi
movl $0x1, %edx
movq %r15, %rcx
callq 0x37429
testl %eax, %eax
je 0x37414
movq %r14, %rdi
movl $0x7e, %esi
callq 0x36a24
jmp 0x3741e
callq 0xa1afa
movl $0x7c, (%rax)
jmp 0x3741e
orb $0x2, 0x624(%r14)
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| _ma_read_key_record:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov r12, rdx
mov r15, rsi
mov r14, rdi
mov rax, [rdi]
cmp dword ptr [rax+7B8h], 0
jnz short loc_373CE
mov rdi, r14
xor esi, esi
call _ma_writeinfo
loc_373CE:
mov ebx, 0FFFFFFFFh
cmp r12, 0FFFFFFFFFFFFFFFFh
jz short loc_3741E
mov esi, [r14+62Ch]
test esi, esi
js short loc_37407
mov rdi, r14
mov edx, 1
mov rcx, r15
call _ma_put_key_in_record
test eax, eax
jz short loc_37414
mov rdi, r14
mov esi, 7Eh ; '~'
call _ma_set_fatal_error
jmp short loc_3741E
loc_37407:
call _my_thread_var
mov dword ptr [rax], 7Ch ; '|'
jmp short loc_3741E
loc_37414:
or byte ptr [r14+624h], 2
xor ebx, ebx
loc_3741E:
mov eax, ebx
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long ma_read_key_record(unsigned int *a1, long long a2, long long a3, long long a4, long long a5)
{
unsigned int v7; // ebx
long long v8; // rsi
long long v9; // rdx
long long v10; // rcx
long long v11; // r8
int v12; // r9d
if ( !*(_DWORD *)(*(_QWORD *)a1 + 1976LL) )
ma_writeinfo(a1, 0LL);
v7 = -1;
if ( a3 != -1 )
{
v8 = a1[395];
if ( (int)v8 < 0 )
{
*(_DWORD *)my_thread_var(a1, v8, a3, a4, a5) = 124;
}
else if ( (unsigned int)ma_put_key_in_record(a1, v8, 1LL, a2) )
{
ma_set_fatal_error(a1, 126LL, v9, v10, v11, v12);
}
else
{
*((_BYTE *)a1 + 1572) |= 2u;
return 0;
}
}
return v7;
}
| _ma_read_key_record:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R12,RDX
MOV R15,RSI
MOV R14,RDI
MOV RAX,qword ptr [RDI]
CMP dword ptr [RAX + 0x7b8],0x0
JNZ 0x001373ce
MOV RDI,R14
XOR ESI,ESI
CALL 0x00137dbe
LAB_001373ce:
MOV EBX,0xffffffff
CMP R12,-0x1
JZ 0x0013741e
MOV ESI,dword ptr [R14 + 0x62c]
TEST ESI,ESI
JS 0x00137407
MOV RDI,R14
MOV EDX,0x1
MOV RCX,R15
CALL 0x00137429
TEST EAX,EAX
JZ 0x00137414
MOV RDI,R14
MOV ESI,0x7e
CALL 0x00136a24
JMP 0x0013741e
LAB_00137407:
CALL 0x001a1afa
MOV dword ptr [RAX],0x7c
JMP 0x0013741e
LAB_00137414:
OR byte ptr [R14 + 0x624],0x2
XOR EBX,EBX
LAB_0013741e:
MOV EAX,EBX
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
int8 _ma_read_key_record(long *param_1,int8 param_2,long param_3)
{
int iVar1;
int4 *puVar2;
int8 uVar3;
if (*(int *)(*param_1 + 0x7b8) == 0) {
_ma_writeinfo(param_1,0);
}
uVar3 = 0xffffffff;
if (param_3 != -1) {
if (*(int *)((long)param_1 + 0x62c) < 0) {
puVar2 = (int4 *)_my_thread_var();
*puVar2 = 0x7c;
}
else {
iVar1 = _ma_put_key_in_record(param_1,*(int *)((long)param_1 + 0x62c),1,param_2);
if (iVar1 == 0) {
*(byte *)((long)param_1 + 0x624) = *(byte *)((long)param_1 + 0x624) | 2;
uVar3 = 0;
}
else {
_ma_set_fatal_error(param_1,0x7e);
}
}
}
return uVar3;
}
| |
48,367 | GLOBAL__sub_I_crc32c.cc | eloqsql/mysys/crc32/crc32c.cc | static uint32_t cpuid_ecx()
{
#ifdef __GNUC__
uint32_t reax= 0, rebx= 0, recx= 0, redx= 0;
__cpuid(1, reax, rebx, recx, redx);
return recx;
#elif defined _MSC_VER
int regs[4];
__cpuid(regs, 1);
return regs[2];
#else
# error "unknown compiler"
#endif
} | O3 | cpp | GLOBAL__sub_I_crc32c.cc:
movl $0x1, %eax
xchgq %rbx, %rsi
cpuid
xchgq %rbx, %rsi
movl $0x100002, %edx # imm = 0x100002
andl %edx, %ecx
cmpl $0x100000, %ecx # imm = 0x100000
leaq 0x3738b(%rip), %rsi # 0x61aef
leaq 0x37465(%rip), %rax # 0x61bd0
cmoveq %rsi, %rax
cmpl %edx, %ecx
jne 0x2a77f
pushq %rbp
movq %rsp, %rbp
leaq 0x3769a(%rip), %rax # 0x61e18
popq %rbp
movq %rax, 0x384ffa(%rip) # 0x3af780
retq
nopw (%rax,%rax)
| _GLOBAL__sub_I_crc32c_cc:
mov eax, 1
xchg rsi, rbx
cpuid
xchg rsi, rbx
mov edx, offset unk_100002
and ecx, edx
cmp ecx, offset unk_100000
lea rsi, _ZN15mysys_namespace6crc32cL12crc32c_sse42EjPKcm; mysys_namespace::crc32c::crc32c_sse42(uint,char const*,ulong)
lea rax, _ZN15mysys_namespace6crc32cL11crc32c_slowEjPKcm; mysys_namespace::crc32c::crc32c_slow(uint,char const*,ulong)
cmovz rax, rsi
cmp ecx, edx
jnz short loc_2A77F
push rbp
mov rbp, rsp
lea rax, crc32c_3way
pop rbp
loc_2A77F:
mov cs:_ZN15mysys_namespace6crc32cL12ChosenExtendE, rax; mysys_namespace::crc32c::ChosenExtend
retn
| long long ( *GLOBAL__sub_I_crc32c_cc())()
{
int v5; // ecx
long long ( *result)(); // rax
_RAX = 1LL;
__asm { cpuid }
v5 = (unsigned int)&unk_100002 & _RCX;
result = (long long ( *)())mysys_namespace::crc32c::crc32c_slow;
if ( v5 == (_DWORD)&unk_100000 )
result = (long long ( *)())mysys_namespace::crc32c::crc32c_sse42;
if ( v5 == (unsigned int)&unk_100002 )
result = crc32c_3way;
mysys_namespace::crc32c::ChosenExtend = (long long)result;
return result;
}
| _GLOBAL__sub_I_crc32c.cc:
MOV EAX,0x1
XCHG RBX,RSI
CPUID
XCHG RBX,RSI
MOV EDX,0x100002
AND ECX,EDX
CMP ECX,0x100000
LEA RSI,[0x161aef]
LEA RAX,[0x161bd0]
CMOVZ RAX,RSI
CMP ECX,EDX
JNZ 0x0012a77f
PUSH RBP
MOV RBP,RSP
LEA RAX,[0x161e18]
POP RBP
LAB_0012a77f:
MOV qword ptr [0x004af780],RAX
RET
|
/* WARNING: Removing unreachable block (ram,0x0012a74b) */
void _GLOBAL__sub_I_crc32c_cc(void)
{
long lVar1;
uint uVar2;
lVar1 = cpuid_Version_info(1);
uVar2 = *(uint *)(lVar1 + 0xc) & 0x100002;
mysys_namespace::crc32c::ChosenExtend = mysys_namespace::crc32c::crc32c_slow;
if (uVar2 == 0x100000) {
mysys_namespace::crc32c::ChosenExtend = mysys_namespace::crc32c::crc32c_sse42;
}
if (uVar2 == 0x100002) {
mysys_namespace::crc32c::ChosenExtend = crc32c_3way;
}
return;
}
| |
48,368 | js_math_sumPrecise | bluesky950520[P]quickjs/quickjs.c | static JSValue js_math_sumPrecise(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue iter, next, item, ret;
bf_t a, b;
BOOL done;
double d;
int r;
iter = JS_GetIterator(ctx, argv[0], /*async*/FALSE);
if (JS_IsException(iter))
return JS_EXCEPTION;
bf_init(ctx->bf_ctx, &a);
bf_init(ctx->bf_ctx, &b);
ret = JS_EXCEPTION;
next = JS_GetProperty(ctx, iter, JS_ATOM_next);
if (JS_IsException(next))
goto fail;
bf_set_zero(&a, /*is_neg*/TRUE);
for (;;) {
item = JS_IteratorNext(ctx, iter, next, 0, NULL, &done);
if (JS_IsException(item))
goto fail;
if (done)
break; // item == JS_UNDEFINED
switch (JS_VALUE_GET_TAG(item)) {
default:
JS_FreeValue(ctx, item);
JS_ThrowTypeError(ctx, "not a number");
goto fail;
case JS_TAG_INT:
d = JS_VALUE_GET_INT(item);
break;
case JS_TAG_FLOAT64:
d = JS_VALUE_GET_FLOAT64(item);
break;
}
if (bf_set_float64(&b, d))
goto oom;
// Infinity + -Infinity results in BF_ST_INVALID_OP, sets |a| to nan
if ((r = bf_add(&a, &a, &b, BF_PREC_INF, BF_RNDN)))
if (r != BF_ST_INVALID_OP)
goto oom;
}
bf_get_float64(&a, &d, BF_RNDN); // return value deliberately ignored
ret = js_float64(d);
fail:
JS_IteratorClose(ctx, iter, JS_IsException(ret));
JS_FreeValue(ctx, iter);
JS_FreeValue(ctx, next);
bf_delete(&a);
bf_delete(&b);
return ret;
oom:
JS_ThrowOutOfMemory(ctx);
goto fail;
} | O0 | c | js_math_sumPrecise:
subq $0x178, %rsp # imm = 0x178
movq %rsi, 0x158(%rsp)
movq %rdx, 0x160(%rsp)
movq %rdi, 0x150(%rsp)
movl %ecx, 0x14c(%rsp)
movq %r8, 0x140(%rsp)
movq 0x150(%rsp), %rdi
movq 0x140(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
xorl %ecx, %ecx
callq 0x74aa0
movq %rax, 0x88(%rsp)
movq %rdx, 0x90(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x130(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x138(%rsp)
movq 0x130(%rsp), %rdi
movq 0x138(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
je 0xdef62
movl $0x0, 0x168(%rsp)
movq $0x6, 0x170(%rsp)
jmp 0xdf2df
movq 0x150(%rsp), %rax
movq 0x1d0(%rax), %rdi
leaq 0xd8(%rsp), %rsi
callq 0xec260
movq 0x150(%rsp), %rax
movq 0x1d0(%rax), %rdi
leaq 0xb0(%rsp), %rsi
callq 0xec260
movl $0x0, 0x78(%rsp)
movq $0x6, 0x80(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x100(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x108(%rsp)
movq 0x150(%rsp), %rdi
movq 0x130(%rsp), %rsi
movq 0x138(%rsp), %rdx
movl $0x6b, %ecx
callq 0x30070
movq %rax, 0x68(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x120(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x128(%rsp)
movq 0x120(%rsp), %rdi
movq 0x128(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
je 0xdf030
jmp 0xdf20f
leaq 0xd8(%rsp), %rdi
movl $0x1, %esi
callq 0xec530
movq 0x150(%rsp), %rdi
movq 0x130(%rsp), %rsi
movq 0x138(%rsp), %rdx
movq 0x120(%rsp), %rcx
movq 0x128(%rsp), %r8
xorl %r9d, %r9d
xorl %eax, %eax
leaq 0xac(%rsp), %rax
movq $0x0, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x751a0
movq %rax, 0x58(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x110(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x118(%rsp)
movq 0x110(%rsp), %rdi
movq 0x118(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
je 0xdf0cc
jmp 0xdf20f
cmpl $0x0, 0xac(%rsp)
je 0xdf0db
jmp 0xdf1c6
movl 0x118(%rsp), %eax
movl %eax, 0x24(%rsp)
testl %eax, %eax
je 0xdf139
jmp 0xdf0ec
movl 0x24(%rsp), %eax
subl $0x7, %eax
je 0xdf14d
jmp 0xdf0f7
movq 0x150(%rsp), %rdi
movq 0x110(%rsp), %rsi
movq 0x118(%rsp), %rdx
callq 0x29f80
movq 0x150(%rsp), %rdi
leaq 0x36371(%rip), %rsi # 0x115494
movb $0x0, %al
callq 0x335f0
movq %rax, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
jmp 0xdf20f
cvtsi2sdl 0x110(%rsp), %xmm0
movsd %xmm0, 0xa0(%rsp)
jmp 0xdf15f
movsd 0x110(%rsp), %xmm0
movsd %xmm0, 0xa0(%rsp)
movsd 0xa0(%rsp), %xmm0
leaq 0xb0(%rsp), %rdi
callq 0xf12a0
cmpl $0x0, %eax
je 0xdf17f
jmp 0xdf2c3
leaq 0xd8(%rsp), %rsi
leaq 0xb0(%rsp), %rdx
movabsq $0x3fffffffffffffff, %rcx # imm = 0x3FFFFFFFFFFFFFFF
xorl %r8d, %r8d
movq %rsi, %rdi
callq 0xf0460
movl %eax, 0x9c(%rsp)
cmpl $0x0, %eax
je 0xdf1c1
cmpl $0x1, 0x9c(%rsp)
je 0xdf1bf
jmp 0xdf2c3
jmp 0xdf1c1
jmp 0xdf042
leaq 0xd8(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
xorl %edx, %edx
callq 0xf1090
movsd 0xa0(%rsp), %xmm0
callq 0x53950
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x100(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x108(%rsp)
movq 0x150(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x100(%rsp), %rdi
movq 0x108(%rsp), %rsi
callq 0x29fb0
movq 0x18(%rsp), %rdi
movl %eax, %ecx
movq 0x130(%rsp), %rsi
movq 0x138(%rsp), %rdx
callq 0x6e2b0
movq 0x150(%rsp), %rdi
movq 0x130(%rsp), %rsi
movq 0x138(%rsp), %rdx
callq 0x29f80
movq 0x150(%rsp), %rdi
movq 0x120(%rsp), %rsi
movq 0x128(%rsp), %rdx
callq 0x29f80
leaq 0xd8(%rsp), %rdi
callq 0x64c10
leaq 0xb0(%rsp), %rdi
callq 0x64c10
movq 0x100(%rsp), %rax
movq %rax, 0x168(%rsp)
movq 0x108(%rsp), %rax
movq %rax, 0x170(%rsp)
jmp 0xdf2df
movq 0x150(%rsp), %rdi
callq 0x27f00
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
jmp 0xdf20f
movq 0x168(%rsp), %rax
movq 0x170(%rsp), %rdx
addq $0x178, %rsp # imm = 0x178
retq
nopw (%rax,%rax)
| js_math_sumPrecise:
sub rsp, 178h
mov [rsp+178h+var_20], rsi
mov [rsp+178h+var_18], rdx
mov [rsp+178h+var_28], rdi
mov [rsp+178h+var_2C], ecx
mov [rsp+178h+var_38], r8
mov rdi, [rsp+178h+var_28]
mov rax, [rsp+178h+var_38]
mov rsi, [rax]
mov rdx, [rax+8]
xor ecx, ecx
call JS_GetIterator
mov [rsp+178h+var_F0], rax
mov [rsp+178h+var_E8], rdx
mov rax, [rsp+178h+var_F0]
mov [rsp+178h+var_48], rax
mov rax, [rsp+178h+var_E8]
mov [rsp+178h+var_40], rax
mov rdi, [rsp+178h+var_48]
mov rsi, [rsp+178h+var_40]
call JS_IsException_1
cmp eax, 0
jz short loc_DEF62
mov dword ptr [rsp+178h+var_10], 0
mov [rsp+178h+var_8], 6
jmp loc_DF2DF
loc_DEF62:
mov rax, [rsp+178h+var_28]
mov rdi, [rax+1D0h]
lea rsi, [rsp+178h+var_A0]
call bf_init
mov rax, [rsp+178h+var_28]
mov rdi, [rax+1D0h]
lea rsi, [rsp+178h+var_C8]
call bf_init
mov dword ptr [rsp+178h+var_100], 0
mov [rsp+178h+var_F8], 6
mov rax, [rsp+178h+var_100]
mov [rsp+178h+var_78], rax
mov rax, [rsp+178h+var_F8]
mov [rsp+178h+var_70], rax
mov rdi, [rsp+178h+var_28]
mov rsi, [rsp+178h+var_48]
mov rdx, [rsp+178h+var_40]
mov ecx, 6Bh ; 'k'
call JS_GetProperty
mov [rsp+178h+var_110], rax
mov [rsp+178h+var_108], rdx
mov rax, [rsp+178h+var_110]
mov [rsp+178h+var_58], rax
mov rax, [rsp+178h+var_108]
mov [rsp+178h+var_50], rax
mov rdi, [rsp+178h+var_58]
mov rsi, [rsp+178h+var_50]
call JS_IsException_1
cmp eax, 0
jz short loc_DF030
jmp loc_DF20F
loc_DF030:
lea rdi, [rsp+178h+var_A0]
mov esi, 1
call bf_set_zero
loc_DF042:
mov rdi, [rsp+178h+var_28]
mov rsi, [rsp+178h+var_48]
mov rdx, [rsp+178h+var_40]
mov rcx, [rsp+178h+var_58]
mov r8, [rsp+178h+var_50]
xor r9d, r9d
xor eax, eax
lea rax, [rsp+178h+var_CC]
mov [rsp+178h+var_178], 0
mov [rsp+178h+var_170], rax
call JS_IteratorNext
mov [rsp+178h+var_120], rax
mov [rsp+178h+var_118], rdx
mov rax, [rsp+178h+var_120]
mov [rsp+178h+var_68], rax
mov rax, [rsp+178h+var_118]
mov [rsp+178h+var_60], rax
mov rdi, [rsp+178h+var_68]
mov rsi, [rsp+178h+var_60]
call JS_IsException_1
cmp eax, 0
jz short loc_DF0CC
jmp loc_DF20F
loc_DF0CC:
cmp [rsp+178h+var_CC], 0
jz short loc_DF0DB
jmp loc_DF1C6
loc_DF0DB:
mov eax, dword ptr [rsp+178h+var_60]
mov [rsp+178h+var_154], eax
test eax, eax
jz short loc_DF139
jmp short $+2
loc_DF0EC:
mov eax, [rsp+178h+var_154]
sub eax, 7
jz short loc_DF14D
jmp short $+2
loc_DF0F7:
mov rdi, [rsp+178h+var_28]
mov rsi, [rsp+178h+var_68]
mov rdx, [rsp+178h+var_60]
call JS_FreeValue
mov rdi, [rsp+178h+var_28]
lea rsi, aSizeIsNotANumb+9; "not a number"
mov al, 0
call JS_ThrowTypeError
mov [rsp+178h+var_130], rax
mov [rsp+178h+var_128], rdx
jmp loc_DF20F
loc_DF139:
cvtsi2sd xmm0, dword ptr [rsp+178h+var_68]
movsd [rsp+178h+var_D8], xmm0
jmp short loc_DF15F
loc_DF14D:
movsd xmm0, [rsp+178h+var_68]
movsd [rsp+178h+var_D8], xmm0
loc_DF15F:
movsd xmm0, [rsp+178h+var_D8]
lea rdi, [rsp+178h+var_C8]
call bf_set_float64
cmp eax, 0
jz short loc_DF17F
jmp loc_DF2C3
loc_DF17F:
lea rsi, [rsp+178h+var_A0]
lea rdx, [rsp+178h+var_C8]
mov rcx, 3FFFFFFFFFFFFFFFh
xor r8d, r8d
mov rdi, rsi
call bf_add
mov [rsp+178h+var_DC], eax
cmp eax, 0
jz short loc_DF1C1
cmp [rsp+178h+var_DC], 1
jz short loc_DF1BF
jmp loc_DF2C3
loc_DF1BF:
jmp short $+2
loc_DF1C1:
jmp loc_DF042
loc_DF1C6:
lea rdi, [rsp+178h+var_A0]
lea rsi, [rsp+178h+var_D8]
xor edx, edx
call bf_get_float64
movsd xmm0, [rsp+178h+var_D8]
call js_float64
mov [rsp+178h+var_140], rax
mov [rsp+178h+var_138], rdx
mov rax, [rsp+178h+var_140]
mov [rsp+178h+var_78], rax
mov rax, [rsp+178h+var_138]
mov [rsp+178h+var_70], rax
loc_DF20F:
mov rax, [rsp+178h+var_28]
mov [rsp+178h+var_160], rax
mov rdi, [rsp+178h+var_78]
mov rsi, [rsp+178h+var_70]
call JS_IsException_1
mov rdi, [rsp+178h+var_160]
mov ecx, eax
mov rsi, [rsp+178h+var_48]
mov rdx, [rsp+178h+var_40]
call JS_IteratorClose
mov rdi, [rsp+178h+var_28]
mov rsi, [rsp+178h+var_48]
mov rdx, [rsp+178h+var_40]
call JS_FreeValue
mov rdi, [rsp+178h+var_28]
mov rsi, [rsp+178h+var_58]
mov rdx, [rsp+178h+var_50]
call JS_FreeValue
lea rdi, [rsp+178h+var_A0]
call bf_delete
lea rdi, [rsp+178h+var_C8]
call bf_delete
mov rax, [rsp+178h+var_78]
mov [rsp+178h+var_10], rax
mov rax, [rsp+178h+var_70]
mov [rsp+178h+var_8], rax
jmp short loc_DF2DF
loc_DF2C3:
mov rdi, [rsp+178h+var_28]
call JS_ThrowOutOfMemory
mov [rsp+178h+var_150], rax
mov [rsp+178h+var_148], rdx
jmp loc_DF20F
loc_DF2DF:
mov rax, [rsp+178h+var_10]
mov rdx, [rsp+178h+var_8]
add rsp, 178h
retn
| long long js_math_sumPrecise(
long long a1,
long long a2,
long long a3,
int a4,
long long *a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
double a10,
double a11,
__m128 a12,
__m128 a13)
{
long long v13; // rdx
long long v14; // rdx
long long v15; // rdx
long long *v16; // rsi
long long v17; // rdx
long long v18; // rcx
long long v19; // r8
long long v20; // r9
__m128 v21; // xmm4
__m128 v22; // xmm5
int v23; // edx
long long v24; // rcx
int v25; // r8d
int v26; // r9d
long long v27; // rdx
BOOL IsException_1; // eax
double v29; // xmm4_8
double v30; // xmm5_8
char v32; // [rsp+0h] [rbp-178h]
long long v33; // [rsp+18h] [rbp-160h]
long long v34; // [rsp+78h] [rbp-100h]
double v35; // [rsp+A0h] [rbp-D8h] BYREF
int v36; // [rsp+ACh] [rbp-CCh] BYREF
long long v37[5]; // [rsp+B0h] [rbp-C8h] BYREF
long long v38[5]; // [rsp+D8h] [rbp-A0h] BYREF
long long v39; // [rsp+100h] [rbp-78h]
long long v40; // [rsp+108h] [rbp-70h]
double v41; // [rsp+110h] [rbp-68h]
long long v42; // [rsp+118h] [rbp-60h]
long long Property; // [rsp+120h] [rbp-58h]
long long v44; // [rsp+128h] [rbp-50h]
long long Iterator; // [rsp+130h] [rbp-48h]
long long v46; // [rsp+138h] [rbp-40h]
long long *v47; // [rsp+140h] [rbp-38h]
int v48; // [rsp+14Ch] [rbp-2Ch]
long long v49; // [rsp+150h] [rbp-28h]
long long v50; // [rsp+158h] [rbp-20h]
long long v51; // [rsp+160h] [rbp-18h]
long long v52; // [rsp+168h] [rbp-10h]
long long v53; // [rsp+170h] [rbp-8h]
v50 = a2;
v51 = a3;
v49 = a1;
v48 = a4;
v47 = a5;
Iterator = JS_GetIterator(a1, *a5, a5[1], 0, a6, a7, a8, a9, a10, a11, a12, a13);
v46 = v13;
if ( JS_IsException_1(Iterator, v13) )
{
LODWORD(v52) = 0;
v53 = 6LL;
}
else
{
bf_init(*(_QWORD *)(v49 + 464), v38);
bf_init(*(_QWORD *)(v49 + 464), v37);
LODWORD(v34) = 0;
v39 = v34;
v40 = 6LL;
Property = JS_GetProperty(v49, Iterator, v46, 107);
v44 = v14;
if ( !JS_IsException_1(Property, v14) )
{
bf_set_zero(v38, 1LL);
while ( 1 )
{
v41 = COERCE_DOUBLE(JS_IteratorNext(v49, Iterator, v46, Property, v44, 0, 0LL, &v36));
v42 = v15;
v16 = (long long *)v15;
if ( JS_IsException_1(*(long long *)&v41, v15) )
break;
if ( v36 )
{
bf_get_float64(v38, &v35, 0LL);
a6 = (__m128)*(unsigned long long *)&v35;
v39 = js_float64(v35);
v40 = v27;
break;
}
if ( (_DWORD)v42 )
{
if ( (_DWORD)v42 != 7 )
{
JS_FreeValue(v49, *(long long *)&v41, v42);
JS_ThrowTypeError(v49, (long long)"not a number", v17, v18, v19, v20, a6, a7, a8, a9, v21, v22, a12, a13, v32);
break;
}
v35 = v41;
}
else
{
v35 = (double)SLODWORD(v41);
}
a6 = (__m128)*(unsigned long long *)&v35;
if ( !(unsigned int)bf_set_float64(v37, v35) )
{
v16 = v38;
if ( (unsigned int)bf_add(v38, v38, v37, 0x3FFFFFFFFFFFFFFFLL, 0LL) <= 1 )
continue;
}
JS_ThrowOutOfMemory(v49, (long long)v16, v23, v24, v25, v26);
break;
}
}
v33 = v49;
IsException_1 = JS_IsException_1(v39, v40);
JS_IteratorClose(v33, Iterator, v46, IsException_1, a6, a7, a8, a9, v29, v30, a12, a13);
JS_FreeValue(v49, Iterator, v46);
JS_FreeValue(v49, Property, v44);
bf_delete(v38);
bf_delete(v37);
v52 = v39;
v53 = v40;
}
return v52;
}
| js_math_sumPrecise:
SUB RSP,0x178
MOV qword ptr [RSP + 0x158],RSI
MOV qword ptr [RSP + 0x160],RDX
MOV qword ptr [RSP + 0x150],RDI
MOV dword ptr [RSP + 0x14c],ECX
MOV qword ptr [RSP + 0x140],R8
MOV RDI,qword ptr [RSP + 0x150]
MOV RAX,qword ptr [RSP + 0x140]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
XOR ECX,ECX
CALL 0x00174aa0
MOV qword ptr [RSP + 0x88],RAX
MOV qword ptr [RSP + 0x90],RDX
MOV RAX,qword ptr [RSP + 0x88]
MOV qword ptr [RSP + 0x130],RAX
MOV RAX,qword ptr [RSP + 0x90]
MOV qword ptr [RSP + 0x138],RAX
MOV RDI,qword ptr [RSP + 0x130]
MOV RSI,qword ptr [RSP + 0x138]
CALL 0x00129fb0
CMP EAX,0x0
JZ 0x001def62
MOV dword ptr [RSP + 0x168],0x0
MOV qword ptr [RSP + 0x170],0x6
JMP 0x001df2df
LAB_001def62:
MOV RAX,qword ptr [RSP + 0x150]
MOV RDI,qword ptr [RAX + 0x1d0]
LEA RSI,[RSP + 0xd8]
CALL 0x001ec260
MOV RAX,qword ptr [RSP + 0x150]
MOV RDI,qword ptr [RAX + 0x1d0]
LEA RSI,[RSP + 0xb0]
CALL 0x001ec260
MOV dword ptr [RSP + 0x78],0x0
MOV qword ptr [RSP + 0x80],0x6
MOV RAX,qword ptr [RSP + 0x78]
MOV qword ptr [RSP + 0x100],RAX
MOV RAX,qword ptr [RSP + 0x80]
MOV qword ptr [RSP + 0x108],RAX
MOV RDI,qword ptr [RSP + 0x150]
MOV RSI,qword ptr [RSP + 0x130]
MOV RDX,qword ptr [RSP + 0x138]
MOV ECX,0x6b
CALL 0x00130070
MOV qword ptr [RSP + 0x68],RAX
MOV qword ptr [RSP + 0x70],RDX
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RSP + 0x120],RAX
MOV RAX,qword ptr [RSP + 0x70]
MOV qword ptr [RSP + 0x128],RAX
MOV RDI,qword ptr [RSP + 0x120]
MOV RSI,qword ptr [RSP + 0x128]
CALL 0x00129fb0
CMP EAX,0x0
JZ 0x001df030
JMP 0x001df20f
LAB_001df030:
LEA RDI,[RSP + 0xd8]
MOV ESI,0x1
CALL 0x001ec530
LAB_001df042:
MOV RDI,qword ptr [RSP + 0x150]
MOV RSI,qword ptr [RSP + 0x130]
MOV RDX,qword ptr [RSP + 0x138]
MOV RCX,qword ptr [RSP + 0x120]
MOV R8,qword ptr [RSP + 0x128]
XOR R9D,R9D
XOR EAX,EAX
LEA RAX,[RSP + 0xac]
MOV qword ptr [RSP],0x0
MOV qword ptr [RSP + 0x8],RAX
CALL 0x001751a0
MOV qword ptr [RSP + 0x58],RAX
MOV qword ptr [RSP + 0x60],RDX
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0x110],RAX
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x118],RAX
MOV RDI,qword ptr [RSP + 0x110]
MOV RSI,qword ptr [RSP + 0x118]
CALL 0x00129fb0
CMP EAX,0x0
JZ 0x001df0cc
JMP 0x001df20f
LAB_001df0cc:
CMP dword ptr [RSP + 0xac],0x0
JZ 0x001df0db
JMP 0x001df1c6
LAB_001df0db:
MOV EAX,dword ptr [RSP + 0x118]
MOV dword ptr [RSP + 0x24],EAX
TEST EAX,EAX
JZ 0x001df139
JMP 0x001df0ec
LAB_001df0ec:
MOV EAX,dword ptr [RSP + 0x24]
SUB EAX,0x7
JZ 0x001df14d
JMP 0x001df0f7
LAB_001df0f7:
MOV RDI,qword ptr [RSP + 0x150]
MOV RSI,qword ptr [RSP + 0x110]
MOV RDX,qword ptr [RSP + 0x118]
CALL 0x00129f80
MOV RDI,qword ptr [RSP + 0x150]
LEA RSI,[0x215494]
MOV AL,0x0
CALL 0x001335f0
MOV qword ptr [RSP + 0x48],RAX
MOV qword ptr [RSP + 0x50],RDX
JMP 0x001df20f
LAB_001df139:
CVTSI2SD XMM0,dword ptr [RSP + 0x110]
MOVSD qword ptr [RSP + 0xa0],XMM0
JMP 0x001df15f
LAB_001df14d:
MOVSD XMM0,qword ptr [RSP + 0x110]
MOVSD qword ptr [RSP + 0xa0],XMM0
LAB_001df15f:
MOVSD XMM0,qword ptr [RSP + 0xa0]
LEA RDI,[RSP + 0xb0]
CALL 0x001f12a0
CMP EAX,0x0
JZ 0x001df17f
JMP 0x001df2c3
LAB_001df17f:
LEA RSI,[RSP + 0xd8]
LEA RDX,[RSP + 0xb0]
MOV RCX,0x3fffffffffffffff
XOR R8D,R8D
MOV RDI,RSI
CALL 0x001f0460
MOV dword ptr [RSP + 0x9c],EAX
CMP EAX,0x0
JZ 0x001df1c1
CMP dword ptr [RSP + 0x9c],0x1
JZ 0x001df1bf
JMP 0x001df2c3
LAB_001df1bf:
JMP 0x001df1c1
LAB_001df1c1:
JMP 0x001df042
LAB_001df1c6:
LEA RDI,[RSP + 0xd8]
LEA RSI,[RSP + 0xa0]
XOR EDX,EDX
CALL 0x001f1090
MOVSD XMM0,qword ptr [RSP + 0xa0]
CALL 0x00153950
MOV qword ptr [RSP + 0x38],RAX
MOV qword ptr [RSP + 0x40],RDX
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x100],RAX
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x108],RAX
LAB_001df20f:
MOV RAX,qword ptr [RSP + 0x150]
MOV qword ptr [RSP + 0x18],RAX
MOV RDI,qword ptr [RSP + 0x100]
MOV RSI,qword ptr [RSP + 0x108]
CALL 0x00129fb0
MOV RDI,qword ptr [RSP + 0x18]
MOV ECX,EAX
MOV RSI,qword ptr [RSP + 0x130]
MOV RDX,qword ptr [RSP + 0x138]
CALL 0x0016e2b0
MOV RDI,qword ptr [RSP + 0x150]
MOV RSI,qword ptr [RSP + 0x130]
MOV RDX,qword ptr [RSP + 0x138]
CALL 0x00129f80
MOV RDI,qword ptr [RSP + 0x150]
MOV RSI,qword ptr [RSP + 0x120]
MOV RDX,qword ptr [RSP + 0x128]
CALL 0x00129f80
LEA RDI,[RSP + 0xd8]
CALL 0x00164c10
LEA RDI,[RSP + 0xb0]
CALL 0x00164c10
MOV RAX,qword ptr [RSP + 0x100]
MOV qword ptr [RSP + 0x168],RAX
MOV RAX,qword ptr [RSP + 0x108]
MOV qword ptr [RSP + 0x170],RAX
JMP 0x001df2df
LAB_001df2c3:
MOV RDI,qword ptr [RSP + 0x150]
CALL 0x00127f00
MOV qword ptr [RSP + 0x28],RAX
MOV qword ptr [RSP + 0x30],RDX
JMP 0x001df20f
LAB_001df2df:
MOV RAX,qword ptr [RSP + 0x168]
MOV RDX,qword ptr [RSP + 0x170]
ADD RSP,0x178
RET
|
int1 [16]
js_math_sumPrecise(long param_1,int8 param_2,int8 param_3,int4 param_4,
int8 *param_5)
{
int8 uVar1;
long lVar2;
int iVar3;
int4 uVar4;
int1 auVar5 [16];
uint uStack_fc;
double local_d8;
int local_cc;
int1 local_c8 [40];
int1 local_a0 [40];
int1 local_78 [16];
int1 local_68 [16];
int1 local_58 [16];
int1 local_48 [16];
int8 *local_38;
int4 local_2c;
long local_28;
int8 local_20;
int8 local_18;
int4 local_10;
int4 uStack_c;
int8 local_8;
local_38 = param_5;
local_2c = param_4;
local_28 = param_1;
local_20 = param_2;
local_18 = param_3;
local_48 = JS_GetIterator(param_1,*param_5,param_5[1],0);
iVar3 = JS_IsException(local_48._0_8_,local_48._8_8_);
if (iVar3 == 0) {
bf_init(*(int8 *)(local_28 + 0x1d0),local_a0);
bf_init(*(int8 *)(local_28 + 0x1d0),local_c8);
local_78._0_8_ = (ulong)uStack_fc << 0x20;
local_78._8_8_ = 6;
local_58 = JS_GetProperty(local_28,local_48._0_8_,local_48._8_8_,0x6b);
iVar3 = JS_IsException(local_58._0_8_,local_58._8_8_);
if (iVar3 == 0) {
bf_set_zero(local_a0,1);
do {
auVar5 = JS_IteratorNext(local_28,local_48._0_8_,local_48._8_8_,local_58._0_8_,
local_58._8_8_,0,0,&local_cc);
local_68 = auVar5;
iVar3 = JS_IsException(auVar5._0_8_,auVar5._8_8_);
uVar1 = local_68._8_8_;
if (iVar3 != 0) goto LAB_001df20f;
if (local_cc != 0) {
bf_get_float64(local_a0,&local_d8,0);
local_78 = js_float64(local_d8);
goto LAB_001df20f;
}
if (local_68._8_4_ == 0) {
local_d8 = (double)(int)local_68._0_4_;
}
else {
if (local_68._8_4_ != 7) {
JS_FreeValue(local_28,local_68._0_8_,uVar1);
JS_ThrowTypeError(local_28,"not a number");
goto LAB_001df20f;
}
local_d8 = (double)local_68._0_8_;
}
iVar3 = bf_set_float64(local_d8,local_c8);
if (iVar3 != 0) break;
iVar3 = bf_add(local_a0,local_a0,local_c8,0x3fffffffffffffff,0);
} while ((iVar3 == 0) || (iVar3 == 1));
JS_ThrowOutOfMemory(local_28);
}
LAB_001df20f:
lVar2 = local_28;
uVar4 = JS_IsException(local_78._0_8_,local_78._8_8_);
JS_IteratorClose(lVar2,local_48._0_8_,local_48._8_8_,uVar4);
JS_FreeValue(local_28,local_48._0_8_,local_48._8_8_);
JS_FreeValue(local_28,local_58._0_8_,local_58._8_8_);
bf_delete(local_a0);
bf_delete(local_c8);
local_10 = local_78._0_4_;
uStack_c = local_78._4_4_;
local_8 = local_78._8_8_;
}
else {
local_10 = 0;
local_8 = 6;
}
auVar5._4_4_ = uStack_c;
auVar5._0_4_ = local_10;
auVar5._8_8_ = local_8;
return auVar5;
}
| |
48,369 | ft_nlq_find_relevance | eloqsql/storage/myisam/ft_nlq_search.c | float ft_nlq_find_relevance(FT_INFO *handler,
uchar *record __attribute__((unused)),
uint length __attribute__((unused)))
{
int a,b,c;
FT_DOC *docs=handler->doc;
my_off_t docid=handler->info->lastpos;
if (docid == HA_POS_ERROR)
return -5.0;
/* Assuming docs[] is sorted by dpos... */
for (a=0, b=handler->ndocs, c=(a+b)/2; b-a>1; c=(a+b)/2)
{
if (docs[c].dpos > docid)
b=c;
else
a=c;
}
/* bounds check to avoid accessing unallocated handler->doc */
if (a < handler->ndocs && docs[a].dpos == docid)
return (float) docs[a].weight;
else
return 0.0;
} | O3 | c | ft_nlq_find_relevance:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
movq 0x170(%rax), %rax
cmpq $-0x1, %rax
je 0x4d74b
movl 0x10(%rdi), %ecx
addq $0x18, %rdi
xorl %edx, %edx
cmpl $0x2, %ecx
jl 0x4d72a
xorl %r8d, %r8d
movl %ecx, %r9d
movl %ecx, %esi
movl %r9d, %edx
shrl $0x1f, %edx
addl %r9d, %edx
sarl %edx
movslq %edx, %r9
shlq $0x4, %r9
cmpq %rax, (%rdi,%r9)
jbe 0x4d717
movl %edx, %esi
movl %r8d, %edx
leal (%rdx,%rsi), %r9d
movl %esi, %r10d
subl %edx, %r10d
movl %edx, %r8d
cmpl $0x1, %r10d
jg 0x4d6fa
xorps %xmm0, %xmm0
cmpl %ecx, %edx
jge 0x4d753
movslq %edx, %rcx
shlq $0x4, %rcx
cmpq %rax, (%rdi,%rcx)
jne 0x4d753
addq %rcx, %rdi
xorps %xmm0, %xmm0
cvtsd2ss 0x8(%rdi), %xmm0
jmp 0x4d753
movss 0x478c1(%rip), %xmm0 # 0x95014
popq %rbp
retq
| ft_nlq_find_relevance:
push rbp
mov rbp, rsp
mov rax, [rdi+8]
mov rax, [rax+170h]
cmp rax, 0FFFFFFFFFFFFFFFFh
jz short loc_4D74B
mov ecx, [rdi+10h]
add rdi, 18h
xor edx, edx
cmp ecx, 2
jl short loc_4D72A
xor r8d, r8d
mov r9d, ecx
mov esi, ecx
loc_4D6FA:
mov edx, r9d
shr edx, 1Fh
add edx, r9d
sar edx, 1
movsxd r9, edx
shl r9, 4
cmp [rdi+r9], rax
jbe short loc_4D717
mov esi, edx
mov edx, r8d
loc_4D717:
lea r9d, [rdx+rsi]
mov r10d, esi
sub r10d, edx
mov r8d, edx
cmp r10d, 1
jg short loc_4D6FA
loc_4D72A:
xorps xmm0, xmm0
cmp edx, ecx
jge short loc_4D753
movsxd rcx, edx
shl rcx, 4
cmp [rdi+rcx], rax
jnz short loc_4D753
add rdi, rcx
xorps xmm0, xmm0
cvtsd2ss xmm0, qword ptr [rdi+8]
jmp short loc_4D753
loc_4D74B:
movss xmm0, cs:dword_95014
loc_4D753:
pop rbp
retn
| float ft_nlq_find_relevance(long long a1)
{
unsigned long long v1; // rax
int v2; // ecx
long long v3; // rdi
int v4; // edx
int v5; // r8d
int v6; // r9d
int v7; // esi
float result; // xmm0_4
long long v9; // rcx
v1 = *(_QWORD *)(*(_QWORD *)(a1 + 8) + 368LL);
if ( v1 == -1LL )
return -5.0;
v2 = *(_DWORD *)(a1 + 16);
v3 = a1 + 24;
v4 = 0;
if ( v2 >= 2 )
{
v5 = 0;
v6 = v2;
v7 = v2;
do
{
v4 = v6 / 2;
if ( *(_QWORD *)(v3 + 16LL * (v6 / 2)) > v1 )
{
v7 = v6 / 2;
v4 = v5;
}
v6 = v4 + v7;
v5 = v4;
}
while ( v7 - v4 > 1 );
}
result = 0.0;
if ( v4 < v2 )
{
v9 = 16LL * v4;
if ( *(_QWORD *)(v3 + v9) == v1 )
return *(double *)(v9 + v3 + 8);
}
return result;
}
| ft_nlq_find_relevance:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RDI + 0x8]
MOV RAX,qword ptr [RAX + 0x170]
CMP RAX,-0x1
JZ 0x0014d74b
MOV ECX,dword ptr [RDI + 0x10]
ADD RDI,0x18
XOR EDX,EDX
CMP ECX,0x2
JL 0x0014d72a
XOR R8D,R8D
MOV R9D,ECX
MOV ESI,ECX
LAB_0014d6fa:
MOV EDX,R9D
SHR EDX,0x1f
ADD EDX,R9D
SAR EDX,0x1
MOVSXD R9,EDX
SHL R9,0x4
CMP qword ptr [RDI + R9*0x1],RAX
JBE 0x0014d717
MOV ESI,EDX
MOV EDX,R8D
LAB_0014d717:
LEA R9D,[RDX + RSI*0x1]
MOV R10D,ESI
SUB R10D,EDX
MOV R8D,EDX
CMP R10D,0x1
JG 0x0014d6fa
LAB_0014d72a:
XORPS XMM0,XMM0
CMP EDX,ECX
JGE 0x0014d753
MOVSXD RCX,EDX
SHL RCX,0x4
CMP qword ptr [RDI + RCX*0x1],RAX
JNZ 0x0014d753
ADD RDI,RCX
XORPS XMM0,XMM0
CVTSD2SS XMM0,qword ptr [RDI + 0x8]
JMP 0x0014d753
LAB_0014d74b:
MOVSS XMM0,dword ptr [0x00195014]
LAB_0014d753:
POP RBP
RET
|
float ft_nlq_find_relevance(long param_1)
{
int iVar1;
ulong uVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
float fVar7;
uVar2 = *(ulong *)(*(long *)(param_1 + 8) + 0x170);
fVar7 = DAT_00195014;
if (uVar2 != 0xffffffffffffffff) {
iVar1 = *(int *)(param_1 + 0x10);
param_1 = param_1 + 0x18;
iVar3 = 0;
if (1 < iVar1) {
iVar6 = iVar1;
iVar4 = iVar1;
iVar5 = 0;
do {
iVar3 = iVar6 / 2;
if (uVar2 < *(ulong *)(param_1 + (long)iVar3 * 0x10)) {
iVar4 = iVar3;
iVar3 = iVar5;
}
iVar6 = iVar3 + iVar4;
iVar5 = iVar3;
} while (1 < iVar4 - iVar3);
}
fVar7 = 0.0;
if ((iVar3 < iVar1) && (*(ulong *)(param_1 + (long)iVar3 * 0x10) == uVar2)) {
fVar7 = (float)*(double *)(param_1 + (long)iVar3 * 0x10 + 8);
}
}
return fVar7;
}
| |
48,370 | lock_control_file | eloqsql/storage/maria/ma_control_file.c | static int lock_control_file(const char *name, my_bool do_retry)
{
/*
On Windows, my_lock() uses locking() which is mandatory locking and so
prevents maria-recovery.test from copying the control file. And in case of
crash, it may take a while for Windows to unlock file, causing downtime.
*/
/**
@todo BUG We should explore my_sopen(_SH_DENYWRD) to open or create the
file under Windows.
*/
#ifndef _WIN32
uint retry= 0;
uint retry_count= do_retry ? MARIA_MAX_CONTROL_FILE_LOCK_RETRY : 0;
/*
We can't here use the automatic wait in my_lock() as the alarm thread
may not yet exists.
*/
while (my_lock(control_file_fd, F_WRLCK, 0L, F_TO_EOF,
MYF(MY_SEEK_NOT_DONE | MY_FORCE_LOCK | MY_NO_WAIT)))
{
if (retry == 0)
my_printf_error(HA_ERR_INITIALIZATION,
"Can't lock aria control file '%s' for exclusive use, "
"error: %d. Will retry for %d seconds", 0,
name, my_errno, retry_count);
if (++retry > retry_count)
return 1;
sleep(1);
}
#endif
return 0;
} | O0 | c | lock_control_file:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
movsbl -0x11(%rbp), %edx
xorl %eax, %eax
movl $0x1e, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x1c(%rbp)
movl 0x29a29d(%rip), %edi # 0x2c84c0
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %ecx
movl $0x1a0, %r8d # imm = 0x1A0
movq %rcx, %rdx
callq 0xfbcf0
cmpl $0x0, %eax
je 0x2e297
cmpl $0x0, -0x18(%rbp)
jne 0x2e274
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0xfe880
movq -0x28(%rbp), %rcx
movl (%rax), %r8d
movl -0x1c(%rbp), %r9d
movl $0xae, %edi
leaq 0x12cc8b(%rip), %rsi # 0x15aef4
xorl %eax, %eax
movl %eax, %edx
movb $0x0, %al
callq 0xf40a0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
cmpl -0x1c(%rbp), %eax
jbe 0x2e28b
movl $0x1, -0x4(%rbp)
jmp 0x2e29e
movl $0x1, %edi
callq 0x2a910
jmp 0x2e21d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| lock_control_file:
push rbp
mov rbp, rsp
sub rsp, 30h
mov al, sil
mov [rbp+var_10], rdi
mov [rbp+var_11], al
mov [rbp+var_18], 0
movsx edx, [rbp+var_11]
xor eax, eax
mov ecx, 1Eh
cmp edx, 0
cmovnz eax, ecx
mov [rbp+var_1C], eax
loc_2E21D:
mov edi, cs:control_file_fd
mov esi, 1
xor eax, eax
mov ecx, eax
mov r8d, 1A0h
mov rdx, rcx
call my_lock
cmp eax, 0
jz short loc_2E297
cmp [rbp+var_18], 0
jnz short loc_2E274
mov rax, [rbp+var_10]
mov [rbp+var_28], rax
call _my_thread_var
mov rcx, [rbp+var_28]
mov r8d, [rax]
mov r9d, [rbp+var_1C]
mov edi, 0AEh
lea rsi, aCanTLockAriaCo; "Can't lock aria control file '%s' for e"...
xor eax, eax
mov edx, eax
mov al, 0
call my_printf_error
loc_2E274:
mov eax, [rbp+var_18]
add eax, 1
mov [rbp+var_18], eax
cmp eax, [rbp+var_1C]
jbe short loc_2E28B
mov [rbp+var_4], 1
jmp short loc_2E29E
loc_2E28B:
mov edi, 1
call _sleep
jmp short loc_2E21D
loc_2E297:
mov [rbp+var_4], 0
loc_2E29E:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long lock_control_file(int a1, char a2)
{
int v2; // eax
_DWORD *v3; // rax
char v5; // [rsp+0h] [rbp-30h]
unsigned int v6; // [rsp+14h] [rbp-1Ch]
int v7; // [rsp+18h] [rbp-18h]
v7 = 0;
v2 = 0;
if ( a2 )
v2 = 30;
v6 = v2;
while ( (unsigned int)my_lock((unsigned int)control_file_fd, 1LL, 0LL, 0LL, 416LL) )
{
if ( !v7 )
{
v3 = (_DWORD *)my_thread_var();
my_printf_error(
174,
(unsigned int)"Can't lock aria control file '%s' for exclusive use, error: %d. Will retry for %d seconds",
0,
a1,
*v3,
v6,
v5);
}
if ( ++v7 > v6 )
return 1;
sleep(1LL);
}
return 0;
}
| lock_control_file:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV AL,SIL
MOV qword ptr [RBP + -0x10],RDI
MOV byte ptr [RBP + -0x11],AL
MOV dword ptr [RBP + -0x18],0x0
MOVSX EDX,byte ptr [RBP + -0x11]
XOR EAX,EAX
MOV ECX,0x1e
CMP EDX,0x0
CMOVNZ EAX,ECX
MOV dword ptr [RBP + -0x1c],EAX
LAB_0012e21d:
MOV EDI,dword ptr [0x003c84c0]
MOV ESI,0x1
XOR EAX,EAX
MOV ECX,EAX
MOV R8D,0x1a0
MOV RDX,RCX
CALL 0x001fbcf0
CMP EAX,0x0
JZ 0x0012e297
CMP dword ptr [RBP + -0x18],0x0
JNZ 0x0012e274
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x28],RAX
CALL 0x001fe880
MOV RCX,qword ptr [RBP + -0x28]
MOV R8D,dword ptr [RAX]
MOV R9D,dword ptr [RBP + -0x1c]
MOV EDI,0xae
LEA RSI,[0x25aef4]
XOR EAX,EAX
MOV EDX,EAX
MOV AL,0x0
CALL 0x001f40a0
LAB_0012e274:
MOV EAX,dword ptr [RBP + -0x18]
ADD EAX,0x1
MOV dword ptr [RBP + -0x18],EAX
CMP EAX,dword ptr [RBP + -0x1c]
JBE 0x0012e28b
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0012e29e
LAB_0012e28b:
MOV EDI,0x1
CALL 0x0012a910
JMP 0x0012e21d
LAB_0012e297:
MOV dword ptr [RBP + -0x4],0x0
LAB_0012e29e:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 lock_control_file(int8 param_1,char param_2)
{
uint uVar1;
int iVar2;
int4 *puVar3;
uint local_20;
local_20 = 0;
uVar1 = 0;
if (param_2 != '\0') {
uVar1 = 0x1e;
}
while( true ) {
iVar2 = my_lock(control_file_fd,1,0,0,0x1a0);
if (iVar2 == 0) {
return 0;
}
if (local_20 == 0) {
puVar3 = (int4 *)_my_thread_var();
my_printf_error(0xae,
"Can\'t lock aria control file \'%s\' for exclusive use, error: %d. Will retry for %d seconds"
,0,param_1,*puVar3,uVar1);
}
local_20 = local_20 + 1;
if (uVar1 < local_20) break;
sleep(1);
}
return 1;
}
| |
48,371 | common_params_get_system_info[abi:cxx11](common_params const&) | monkey531[P]llama/common/common.cpp | std::string common_params_get_system_info(const common_params & params) {
std::ostringstream os;
os << "system_info: n_threads = " << params.cpuparams.n_threads;
if (params.cpuparams_batch.n_threads != -1) {
os << " (n_threads_batch = " << params.cpuparams_batch.n_threads << ")";
}
#if defined(_WIN32) && (_WIN32_WINNT >= 0x0601) && !defined(__MINGW64__) // windows 7 and later
// TODO: windows + arm64 + mingw64
DWORD logicalProcessorCount = GetActiveProcessorCount(ALL_PROCESSOR_GROUPS);
os << " / " << logicalProcessorCount << " | " << llama_print_system_info();
#else
os << " / " << std::thread::hardware_concurrency() << " | " << llama_print_system_info();
#endif
return os.str();
} | O2 | cpp | common_params_get_system_info[abi:cxx11](common_params const&):
pushq %r15
pushq %r14
pushq %rbx
subq $0x180, %rsp # imm = 0x180
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x23c00
leaq 0x5f26c(%rip), %rsi # 0xb41ba
movq %r15, %rdi
callq 0x238b0
movl 0x274(%r14), %esi
movq %rax, %rdi
callq 0x23fc0
cmpl $-0x1, 0x488(%r14)
je 0x54f9e
leaq 0x5f25e(%rip), %rsi # 0xb41d4
leaq 0x8(%rsp), %rdi
callq 0x238b0
movl 0x488(%r14), %esi
movq %rax, %rdi
callq 0x23fc0
leaq 0x64d7d(%rip), %rsi # 0xb9d13
movq %rax, %rdi
callq 0x238b0
leaq 0x5f244(%rip), %rsi # 0xb41e9
leaq 0x8(%rsp), %rdi
callq 0x238b0
movq %rax, %r14
callq 0x23c40
movl %eax, %esi
movq %r14, %rdi
callq 0x23620
leaq 0x65192(%rip), %rsi # 0xba15a
movq %rax, %rdi
callq 0x238b0
movq %rax, %r14
callq 0x23530
movq %r14, %rdi
movq %rax, %rsi
callq 0x238b0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x23e50
leaq 0x8(%rsp), %rdi
callq 0x231e0
movq %rbx, %rax
addq $0x180, %rsp # imm = 0x180
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x231e0
movq %rbx, %rdi
callq 0x24030
| _Z29common_params_get_system_infoB5cxx11RK13common_params:
push r15
push r14
push rbx
sub rsp, 180h
mov r14, rsi
mov rbx, rdi
lea r15, [rsp+198h+var_190]
mov rdi, r15
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::ostringstream::basic_ostringstream(void)
lea rsi, aSystemInfoNThr; "system_info: n_threads = "
mov rdi, r15
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov esi, [r14+274h]
mov rdi, rax
call __ZNSolsEi; std::ostream::operator<<(int)
cmp dword ptr [r14+488h], 0FFFFFFFFh
jz short loc_54F9E
lea rsi, aNThreadsBatch; " (n_threads_batch = "
lea rdi, [rsp+198h+var_190]
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov esi, [r14+488h]
mov rdi, rax
call __ZNSolsEi; std::ostream::operator<<(int)
lea rsi, a09401910201912+51h; ")"
mov rdi, rax
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
loc_54F9E:
lea rsi, asc_B41E9; " / "
lea rdi, [rsp+198h+var_190]; this
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov r14, rax
call __ZNSt6thread20hardware_concurrencyEv; std::thread::hardware_concurrency(void)
mov esi, eax
mov rdi, r14
call __ZNSo9_M_insertImEERSoT_; std::ostream::_M_insert<ulong>(ulong)
lea rsi, asc_BA159+1; " | "
mov rdi, rax
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov r14, rax
call _llama_print_system_info
mov rdi, r14
mov rsi, rax
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
lea rsi, [rsp+198h+var_188]
mov rdi, rbx
call __ZNKSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
lea rdi, [rsp+198h+var_190]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED1Ev; std::ostringstream::~ostringstream()
mov rax, rbx
add rsp, 180h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
lea rdi, [rsp+arg_0]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED1Ev; std::ostringstream::~ostringstream()
mov rdi, rbx
call __Unwind_Resume
| long long common_params_get_system_info[abi:cxx11](long long a1, long long a2)
{
long long v3; // rax
long long v4; // rax
long long v5; // rax
long long v6; // r14
unsigned int v7; // eax
long long v8; // rdi
long long v9; // r14
long long v10; // rax
_BYTE v12[8]; // [rsp+8h] [rbp-190h] BYREF
_BYTE v13[392]; // [rsp+10h] [rbp-188h] BYREF
std::ostringstream::basic_ostringstream(v12);
v3 = std::operator<<<std::char_traits<char>>(v12, "system_info: n_threads = ");
std::ostream::operator<<(v3, *(unsigned int *)(a2 + 628));
if ( *(_DWORD *)(a2 + 1160) != -1 )
{
v4 = std::operator<<<std::char_traits<char>>(v12, " (n_threads_batch = ");
v5 = std::ostream::operator<<(v4, *(unsigned int *)(a2 + 1160));
std::operator<<<std::char_traits<char>>(v5, ")");
}
v6 = std::operator<<<std::char_traits<char>>(v12, " / ");
v7 = std::thread::hardware_concurrency((std::thread *)v12);
v8 = std::ostream::_M_insert<unsigned long>(v6, v7);
v9 = std::operator<<<std::char_traits<char>>(v8, " | ");
v10 = llama_print_system_info();
std::operator<<<std::char_traits<char>>(v9, v10);
std::stringbuf::str(a1, v13);
std::ostringstream::~ostringstream(v12);
return a1;
}
| common_params_get_system_info[abi:cxx11]:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x180
MOV R14,RSI
MOV RBX,RDI
LEA R15,[RSP + 0x8]
MOV RDI,R15
CALL 0x00123c00
LAB_00154f47:
LEA RSI,[0x1b41ba]
MOV RDI,R15
CALL 0x001238b0
MOV ESI,dword ptr [R14 + 0x274]
MOV RDI,RAX
CALL 0x00123fc0
CMP dword ptr [R14 + 0x488],-0x1
JZ 0x00154f9e
LEA RSI,[0x1b41d4]
LEA RDI,[RSP + 0x8]
CALL 0x001238b0
MOV ESI,dword ptr [R14 + 0x488]
MOV RDI,RAX
CALL 0x00123fc0
LEA RSI,[0x1b9d13]
MOV RDI,RAX
CALL 0x001238b0
LAB_00154f9e:
LEA RSI,[0x1b41e9]
LEA RDI,[RSP + 0x8]
CALL 0x001238b0
MOV R14,RAX
CALL 0x00123c40
MOV ESI,EAX
MOV RDI,R14
CALL 0x00123620
LEA RSI,[0x1ba15a]
MOV RDI,RAX
CALL 0x001238b0
MOV R14,RAX
CALL 0x00123530
MOV RDI,R14
MOV RSI,RAX
CALL 0x001238b0
LEA RSI,[RSP + 0x10]
MOV RDI,RBX
CALL 0x00123e50
LAB_00154ff0:
LEA RDI,[RSP + 0x8]
CALL 0x001231e0
MOV RAX,RBX
ADD RSP,0x180
POP RBX
POP R14
POP R15
RET
|
/* common_params_get_system_info[abi:cxx11](common_params const&) */
common_params * common_params_get_system_info_abi_cxx11_(common_params *param_1)
{
ostream *poVar1;
char *pcVar2;
long in_RSI;
ostringstream local_190 [376];
std::__cxx11::ostringstream::ostringstream(local_190);
/* try { // try from 00154f47 to 00154fef has its CatchHandler @ 0015500a */
poVar1 = std::operator<<((ostream *)local_190,"system_info: n_threads = ");
std::ostream::operator<<(poVar1,*(int *)(in_RSI + 0x274));
if (*(int *)(in_RSI + 0x488) != -1) {
poVar1 = std::operator<<((ostream *)local_190," (n_threads_batch = ");
poVar1 = (ostream *)std::ostream::operator<<(poVar1,*(int *)(in_RSI + 0x488));
std::operator<<(poVar1,")");
}
poVar1 = std::operator<<((ostream *)local_190," / ");
std::thread::hardware_concurrency();
poVar1 = std::ostream::_M_insert<unsigned_long>((ulong)poVar1);
poVar1 = std::operator<<(poVar1," | ");
pcVar2 = (char *)llama_print_system_info();
std::operator<<(poVar1,pcVar2);
std::__cxx11::stringbuf::str();
std::__cxx11::ostringstream::~ostringstream(local_190);
return param_1;
}
| |
48,372 | get_defaults_options | eloqsql/mysys/my_default.c | int get_defaults_options(char **argv)
{
static char file_buffer[FN_REFLEN];
static char extra_file_buffer[FN_REFLEN];
char **orig_argv= argv;
argv++; /* Skip program name */
my_defaults_file= my_defaults_group_suffix= my_defaults_extra_file= 0;
my_no_defaults= my_print_defaults= FALSE;
if (*argv && !strcmp(*argv, "--no-defaults"))
{
my_no_defaults= 1;
argv++;
}
else
for(; *argv; argv++)
{
if (!my_defaults_file && is_prefix(*argv, "--defaults-file="))
my_defaults_file= *argv + sizeof("--defaults-file=")-1;
else
if (!my_defaults_extra_file && is_prefix(*argv, "--defaults-extra-file="))
my_defaults_extra_file= *argv + sizeof("--defaults-extra-file=")-1;
else
if (!my_defaults_group_suffix && is_prefix(*argv, "--defaults-group-suffix="))
my_defaults_group_suffix= *argv + sizeof("--defaults-group-suffix=")-1;
else
break;
}
if (*argv && !strcmp(*argv, "--print-defaults"))
{
my_print_defaults= 1;
my_defaults_mark_files= FALSE;
argv++;
}
if (! my_defaults_group_suffix)
my_defaults_group_suffix= getenv("MYSQL_GROUP_SUFFIX");
if (my_defaults_extra_file && my_defaults_extra_file != extra_file_buffer)
{
my_realpath(extra_file_buffer, my_defaults_extra_file, MYF(0));
my_defaults_extra_file= extra_file_buffer;
}
if (my_defaults_file && my_defaults_file != file_buffer)
{
my_realpath(file_buffer, my_defaults_file, MYF(0));
my_defaults_file= file_buffer;
}
return (int)(argv - orig_argv);
} | O0 | c | get_defaults_options:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
leaq 0xbabce1(%rip), %rax # 0xc894b8
movq $0x0, (%rax)
leaq 0xbabccb(%rip), %rax # 0xc894b0
movq $0x0, (%rax)
leaq 0xbabcb5(%rip), %rax # 0xc894a8
movq $0x0, (%rax)
leaq 0xbabca1(%rip), %rax # 0xc894a2
movb $0x0, (%rax)
leaq 0xbabc96(%rip), %rax # 0xc894a1
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xdd84b
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x7c7eb(%rip), %rsi # 0x15a011
callq 0x2a650
cmpl $0x0, %eax
jne 0xdd84b
leaq 0xbabc6a(%rip), %rax # 0xc894a1
movb $0x1, (%rax)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0xdd939
jmp 0xdd84d
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xdd937
leaq 0xbabc46(%rip), %rax # 0xc894a8
cmpq $0x0, (%rax)
jne 0xdd89e
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x7c7a9(%rip), %rsi # 0x15a01f
callq 0x151080
cmpl $0x0, %eax
je 0xdd89e
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x11, %rcx
addq $-0x1, %rcx
leaq 0xbabc12(%rip), %rax # 0xc894a8
movq %rcx, (%rax)
jmp 0xdd924
leaq 0xbabc13(%rip), %rax # 0xc894b8
cmpq $0x0, (%rax)
jne 0xdd8de
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x7c777(%rip), %rsi # 0x15a030
callq 0x151080
cmpl $0x0, %eax
je 0xdd8de
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x17, %rcx
addq $-0x1, %rcx
leaq 0xbabbdf(%rip), %rax # 0xc894b8
movq %rcx, (%rax)
jmp 0xdd922
leaq 0xbabbcb(%rip), %rax # 0xc894b0
cmpq $0x0, (%rax)
jne 0xdd91e
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x7c74e(%rip), %rsi # 0x15a047
callq 0x151080
cmpl $0x0, %eax
je 0xdd91e
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x19, %rcx
addq $-0x1, %rcx
leaq 0xbabb97(%rip), %rax # 0xc894b0
movq %rcx, (%rax)
jmp 0xdd920
jmp 0xdd937
jmp 0xdd922
jmp 0xdd924
jmp 0xdd926
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0xdd84d
jmp 0xdd939
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xdd97b
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x7c70f(%rip), %rsi # 0x15a060
callq 0x2a650
cmpl $0x0, %eax
jne 0xdd97b
leaq 0xbabb40(%rip), %rax # 0xc894a2
movb $0x1, (%rax)
leaq 0xbabb34(%rip), %rax # 0xc894a0
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
leaq 0xbabb2e(%rip), %rax # 0xc894b0
cmpq $0x0, (%rax)
jne 0xdd9a1
leaq 0x7c6e2(%rip), %rdi # 0x15a071
callq 0x2a5d0
movq %rax, %rcx
leaq 0xbabb12(%rip), %rax # 0xc894b0
movq %rcx, (%rax)
leaq 0xbabb10(%rip), %rax # 0xc894b8
cmpq $0x0, (%rax)
je 0xdd9ec
leaq 0xbabd0b(%rip), %rcx # 0xc896c0
leaq 0xbabafc(%rip), %rax # 0xc894b8
cmpq %rcx, (%rax)
je 0xdd9ec
leaq 0xbabaf0(%rip), %rax # 0xc894b8
movq (%rax), %rsi
leaq 0xbabcee(%rip), %rdi # 0xc896c0
xorl %eax, %eax
movl %eax, %edx
callq 0xfb170
leaq 0xbabad6(%rip), %rax # 0xc894b8
leaq 0xbabcd7(%rip), %rcx # 0xc896c0
movq %rcx, (%rax)
leaq 0xbabab5(%rip), %rax # 0xc894a8
cmpq $0x0, (%rax)
je 0xdda37
leaq 0xbabac0(%rip), %rcx # 0xc894c0
leaq 0xbabaa1(%rip), %rax # 0xc894a8
cmpq %rcx, (%rax)
je 0xdda37
leaq 0xbaba95(%rip), %rax # 0xc894a8
movq (%rax), %rsi
leaq 0xbabaa3(%rip), %rdi # 0xc894c0
xorl %eax, %eax
movl %eax, %edx
callq 0xfb170
leaq 0xbaba7b(%rip), %rax # 0xc894a8
leaq 0xbaba8c(%rip), %rcx # 0xc894c0
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
sarq $0x3, %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| get_defaults_options:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
mov rax, [rbp+var_8]
add rax, 8
mov [rbp+var_8], rax
lea rax, my_defaults_extra_file
mov qword ptr [rax], 0
lea rax, my_defaults_group_suffix
mov qword ptr [rax], 0
lea rax, my_defaults_file
mov qword ptr [rax], 0
lea rax, my_print_defaults
mov byte ptr [rax], 0
lea rax, my_no_defaults
mov byte ptr [rax], 0
mov rax, [rbp+var_8]
cmp qword ptr [rax], 0
jz short loc_DD84B
mov rax, [rbp+var_8]
mov rdi, [rax]
lea rsi, aNoDefaults; "--no-defaults"
call _strcmp
cmp eax, 0
jnz short loc_DD84B
lea rax, my_no_defaults
mov byte ptr [rax], 1
mov rax, [rbp+var_8]
add rax, 8
mov [rbp+var_8], rax
jmp loc_DD939
loc_DD84B:
jmp short $+2
loc_DD84D:
mov rax, [rbp+var_8]
cmp qword ptr [rax], 0
jz loc_DD937
lea rax, my_defaults_file
cmp qword ptr [rax], 0
jnz short loc_DD89E
mov rax, [rbp+var_8]
mov rdi, [rax]
lea rsi, aDefaultsFile; "--defaults-file="
call is_prefix
cmp eax, 0
jz short loc_DD89E
mov rax, [rbp+var_8]
mov rcx, [rax]
add rcx, 11h
add rcx, 0FFFFFFFFFFFFFFFFh
lea rax, my_defaults_file
mov [rax], rcx
jmp loc_DD924
loc_DD89E:
lea rax, my_defaults_extra_file
cmp qword ptr [rax], 0
jnz short loc_DD8DE
mov rax, [rbp+var_8]
mov rdi, [rax]
lea rsi, aDefaultsExtraF; "--defaults-extra-file="
call is_prefix
cmp eax, 0
jz short loc_DD8DE
mov rax, [rbp+var_8]
mov rcx, [rax]
add rcx, 17h
add rcx, 0FFFFFFFFFFFFFFFFh
lea rax, my_defaults_extra_file
mov [rax], rcx
jmp short loc_DD922
loc_DD8DE:
lea rax, my_defaults_group_suffix
cmp qword ptr [rax], 0
jnz short loc_DD91E
mov rax, [rbp+var_8]
mov rdi, [rax]
lea rsi, aDefaultsGroupS; "--defaults-group-suffix="
call is_prefix
cmp eax, 0
jz short loc_DD91E
mov rax, [rbp+var_8]
mov rcx, [rax]
add rcx, 19h
add rcx, 0FFFFFFFFFFFFFFFFh
lea rax, my_defaults_group_suffix
mov [rax], rcx
jmp short loc_DD920
loc_DD91E:
jmp short loc_DD937
loc_DD920:
jmp short $+2
loc_DD922:
jmp short $+2
loc_DD924:
jmp short $+2
loc_DD926:
mov rax, [rbp+var_8]
add rax, 8
mov [rbp+var_8], rax
jmp loc_DD84D
loc_DD937:
jmp short $+2
loc_DD939:
mov rax, [rbp+var_8]
cmp qword ptr [rax], 0
jz short loc_DD97B
mov rax, [rbp+var_8]
mov rdi, [rax]
lea rsi, aPrintDefaults; "--print-defaults"
call _strcmp
cmp eax, 0
jnz short loc_DD97B
lea rax, my_print_defaults
mov byte ptr [rax], 1
lea rax, my_defaults_mark_files
mov byte ptr [rax], 0
mov rax, [rbp+var_8]
add rax, 8
mov [rbp+var_8], rax
loc_DD97B:
lea rax, my_defaults_group_suffix
cmp qword ptr [rax], 0
jnz short loc_DD9A1
lea rdi, aMysqlGroupSuff; "MYSQL_GROUP_SUFFIX"
call _getenv
mov rcx, rax
lea rax, my_defaults_group_suffix
mov [rax], rcx
loc_DD9A1:
lea rax, my_defaults_extra_file
cmp qword ptr [rax], 0
jz short loc_DD9EC
lea rcx, get_defaults_options_extra_file_buffer
lea rax, my_defaults_extra_file
cmp [rax], rcx
jz short loc_DD9EC
lea rax, my_defaults_extra_file
mov rsi, [rax]
lea rdi, get_defaults_options_extra_file_buffer
xor eax, eax
mov edx, eax
call my_realpath
lea rax, my_defaults_extra_file
lea rcx, get_defaults_options_extra_file_buffer
mov [rax], rcx
loc_DD9EC:
lea rax, my_defaults_file
cmp qword ptr [rax], 0
jz short loc_DDA37
lea rcx, get_defaults_options_file_buffer
lea rax, my_defaults_file
cmp [rax], rcx
jz short loc_DDA37
lea rax, my_defaults_file
mov rsi, [rax]
lea rdi, get_defaults_options_file_buffer
xor eax, eax
mov edx, eax
call my_realpath
lea rax, my_defaults_file
lea rcx, get_defaults_options_file_buffer
mov [rax], rcx
loc_DDA37:
mov rax, [rbp+var_8]
mov rcx, [rbp+var_10]
sub rax, rcx
sar rax, 3
add rsp, 10h
pop rbp
retn
| long long get_defaults_options(long long a1)
{
_QWORD *v2; // [rsp+8h] [rbp-8h]
v2 = (_QWORD *)(a1 + 8);
my_defaults_extra_file = 0LL;
my_defaults_group_suffix = 0LL;
my_defaults_file = 0LL;
my_print_defaults = 0;
my_no_defaults = 0;
if ( *(_QWORD *)(a1 + 8) && !(unsigned int)strcmp(*v2, "--no-defaults") )
{
my_no_defaults = 1;
v2 = (_QWORD *)(a1 + 16);
}
else
{
while ( *v2 )
{
if ( my_defaults_file || !(unsigned int)is_prefix(*v2, "--defaults-file=") )
{
if ( my_defaults_extra_file || !(unsigned int)is_prefix(*v2, "--defaults-extra-file=") )
{
if ( my_defaults_group_suffix || !(unsigned int)is_prefix(*v2, "--defaults-group-suffix=") )
break;
my_defaults_group_suffix = *v2 + 24LL;
}
else
{
my_defaults_extra_file = *v2 + 22LL;
}
}
else
{
my_defaults_file = *v2 + 16LL;
}
++v2;
}
}
if ( *v2 && !(unsigned int)strcmp(*v2, "--print-defaults") )
{
my_print_defaults = 1;
my_defaults_mark_files = 0;
++v2;
}
if ( !my_defaults_group_suffix )
my_defaults_group_suffix = getenv("MYSQL_GROUP_SUFFIX");
if ( my_defaults_extra_file && (_UNKNOWN *)my_defaults_extra_file != &get_defaults_options_extra_file_buffer )
{
my_realpath(&get_defaults_options_extra_file_buffer, my_defaults_extra_file, 0LL);
my_defaults_extra_file = &get_defaults_options_extra_file_buffer;
}
if ( my_defaults_file && (_UNKNOWN *)my_defaults_file != &get_defaults_options_file_buffer )
{
my_realpath(&get_defaults_options_file_buffer, my_defaults_file, 0LL);
my_defaults_file = &get_defaults_options_file_buffer;
}
return ((long long)v2 - a1) >> 3;
}
| get_defaults_options:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x8
MOV qword ptr [RBP + -0x8],RAX
LEA RAX,[0xd894b8]
MOV qword ptr [RAX],0x0
LEA RAX,[0xd894b0]
MOV qword ptr [RAX],0x0
LEA RAX,[0xd894a8]
MOV qword ptr [RAX],0x0
LEA RAX,[0xd894a2]
MOV byte ptr [RAX],0x0
LEA RAX,[0xd894a1]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX],0x0
JZ 0x001dd84b
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x25a011]
CALL 0x0012a650
CMP EAX,0x0
JNZ 0x001dd84b
LEA RAX,[0xd894a1]
MOV byte ptr [RAX],0x1
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x8
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001dd939
LAB_001dd84b:
JMP 0x001dd84d
LAB_001dd84d:
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX],0x0
JZ 0x001dd937
LEA RAX,[0xd894a8]
CMP qword ptr [RAX],0x0
JNZ 0x001dd89e
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x25a01f]
CALL 0x00251080
CMP EAX,0x0
JZ 0x001dd89e
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX]
ADD RCX,0x11
ADD RCX,-0x1
LEA RAX,[0xd894a8]
MOV qword ptr [RAX],RCX
JMP 0x001dd924
LAB_001dd89e:
LEA RAX,[0xd894b8]
CMP qword ptr [RAX],0x0
JNZ 0x001dd8de
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x25a030]
CALL 0x00251080
CMP EAX,0x0
JZ 0x001dd8de
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX]
ADD RCX,0x17
ADD RCX,-0x1
LEA RAX,[0xd894b8]
MOV qword ptr [RAX],RCX
JMP 0x001dd922
LAB_001dd8de:
LEA RAX,[0xd894b0]
CMP qword ptr [RAX],0x0
JNZ 0x001dd91e
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x25a047]
CALL 0x00251080
CMP EAX,0x0
JZ 0x001dd91e
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX]
ADD RCX,0x19
ADD RCX,-0x1
LEA RAX,[0xd894b0]
MOV qword ptr [RAX],RCX
JMP 0x001dd920
LAB_001dd91e:
JMP 0x001dd937
LAB_001dd920:
JMP 0x001dd922
LAB_001dd922:
JMP 0x001dd924
LAB_001dd924:
JMP 0x001dd926
LAB_001dd926:
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x8
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001dd84d
LAB_001dd937:
JMP 0x001dd939
LAB_001dd939:
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX],0x0
JZ 0x001dd97b
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x25a060]
CALL 0x0012a650
CMP EAX,0x0
JNZ 0x001dd97b
LEA RAX,[0xd894a2]
MOV byte ptr [RAX],0x1
LEA RAX,[0xd894a0]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x8
MOV qword ptr [RBP + -0x8],RAX
LAB_001dd97b:
LEA RAX,[0xd894b0]
CMP qword ptr [RAX],0x0
JNZ 0x001dd9a1
LEA RDI,[0x25a071]
CALL 0x0012a5d0
MOV RCX,RAX
LEA RAX,[0xd894b0]
MOV qword ptr [RAX],RCX
LAB_001dd9a1:
LEA RAX,[0xd894b8]
CMP qword ptr [RAX],0x0
JZ 0x001dd9ec
LEA RCX,[0xd896c0]
LEA RAX,[0xd894b8]
CMP qword ptr [RAX],RCX
JZ 0x001dd9ec
LEA RAX,[0xd894b8]
MOV RSI,qword ptr [RAX]
LEA RDI,[0xd896c0]
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001fb170
LEA RAX,[0xd894b8]
LEA RCX,[0xd896c0]
MOV qword ptr [RAX],RCX
LAB_001dd9ec:
LEA RAX,[0xd894a8]
CMP qword ptr [RAX],0x0
JZ 0x001dda37
LEA RCX,[0xd894c0]
LEA RAX,[0xd894a8]
CMP qword ptr [RAX],RCX
JZ 0x001dda37
LEA RAX,[0xd894a8]
MOV RSI,qword ptr [RAX]
LEA RDI,[0xd894c0]
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001fb170
LEA RAX,[0xd894a8]
LEA RCX,[0xd894c0]
MOV qword ptr [RAX],RCX
LAB_001dda37:
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x10]
SUB RAX,RCX
SAR RAX,0x3
ADD RSP,0x10
POP RBP
RET
|
long get_defaults_options(long param_1)
{
int iVar1;
long *local_10;
local_10 = (long *)(param_1 + 8);
my_defaults_extra_file = (int1 *)0x0;
my_defaults_group_suffix = (char *)0x0;
my_defaults_file = (int1 *)0x0;
my_print_defaults = 0;
my_no_defaults = 0;
if ((*local_10 == 0) || (iVar1 = strcmp((char *)*local_10,"--no-defaults"), iVar1 != 0)) {
for (; *local_10 != 0; local_10 = local_10 + 1) {
if ((my_defaults_file == (int1 *)0x0) &&
(iVar1 = is_prefix(*local_10,"--defaults-file="), iVar1 != 0)) {
my_defaults_file = (int1 *)(*local_10 + 0x10);
}
else if ((my_defaults_extra_file == (int1 *)0x0) &&
(iVar1 = is_prefix(*local_10,"--defaults-extra-file="), iVar1 != 0)) {
my_defaults_extra_file = (int1 *)(*local_10 + 0x16);
}
else {
if ((my_defaults_group_suffix != (char *)0x0) ||
(iVar1 = is_prefix(*local_10,"--defaults-group-suffix="), iVar1 == 0)) break;
my_defaults_group_suffix = (char *)(*local_10 + 0x18);
}
}
}
else {
my_no_defaults = 1;
local_10 = (long *)(param_1 + 0x10);
}
if ((*local_10 != 0) && (iVar1 = strcmp((char *)*local_10,"--print-defaults"), iVar1 == 0)) {
my_print_defaults = 1;
my_defaults_mark_files = 0;
local_10 = local_10 + 1;
}
if (my_defaults_group_suffix == (char *)0x0) {
my_defaults_group_suffix = getenv("MYSQL_GROUP_SUFFIX");
}
if ((my_defaults_extra_file != (int1 *)0x0) &&
(my_defaults_extra_file != get_defaults_options_extra_file_buffer)) {
my_realpath(get_defaults_options_extra_file_buffer,my_defaults_extra_file,0);
my_defaults_extra_file = get_defaults_options_extra_file_buffer;
}
if ((my_defaults_file != (int1 *)0x0) &&
(my_defaults_file != get_defaults_options_file_buffer)) {
my_realpath(get_defaults_options_file_buffer,my_defaults_file,0);
my_defaults_file = get_defaults_options_file_buffer;
}
return (long)local_10 - param_1 >> 3;
}
| |
48,373 | minja::LoopControlException::LoopControlException(minja::LoopControlType) | monkey531[P]llama/common/minja.hpp | LoopControlException(LoopControlType control_type)
: std::runtime_error((control_type == LoopControlType::Continue ? "continue" : "break") + std::string(" outside of a loop")),
control_type(control_type) {} | O1 | cpp | minja::LoopControlException::LoopControlException(minja::LoopControlType):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x51ea1(%rip), %rsi # 0xf4576
leaq 0x51eac(%rip), %rdx # 0xf4588
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x2337c
xorl %eax, %eax
cmpl $0x1, %ebx
sete %al
leaq 0x50b47(%rip), %rdx # 0xf323f
leaq 0x50b3a(%rip), %rcx # 0xf3239
cmoveq %rdx, %rcx
leaq (%rax,%rax,2), %r8
addq $0x5, %r8
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1b9f0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xa273e
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0xa2745
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %r14, %rdi
callq 0x1baf0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xa2780
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b8f0
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xa2797
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1b8f0
leaq 0x8b87a(%rip), %rax # 0x12e018
addq $0x10, %rax
movq %rax, (%r14)
movl %ebx, 0x10(%r14)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xa27d4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b8f0
jmp 0xa27d4
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xa27eb
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1b8f0
movq %rbx, %rdi
callq 0x1bfb0
nop
| _ZN5minja20LoopControlExceptionC2ENS_15LoopControlTypeE:
push r15
push r14
push r12
push rbx
sub rsp, 48h
mov ebx, esi
mov r14, rdi
lea r12, [rsp+68h+var_30]
mov [r12-10h], r12
lea rsi, aOutsideOfALoop; " outside of a loop"
lea rdx, aOutsideOfALoop+12h; ""
lea r15, [rsp+68h+var_40]
mov rdi, r15
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
xor eax, eax
cmp ebx, 1
setz al
lea rdx, aContinue; "continue"
lea rcx, aBreak; "break"
cmovz rcx, rdx
lea r8, [rax+rax*2]
add r8, 5
mov rdi, r15
xor esi, esi
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7replaceEmmPKcm; std::string::replace(ulong,ulong,char const*,ulong)
lea r15, [rsp+68h+var_50]
mov [r15-10h], r15
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_A273E
mov [rsp+68h+var_60], rdx
mov rdx, [rcx]
mov [rsp+68h+var_50], rdx
jmp short loc_A2745
loc_A273E:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r15], xmm0
loc_A2745:
mov rdx, [rax+8]
lea rsi, [rsp+68h+var_60]
mov [rsi+8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
mov rdi, r14
call __ZNSt13runtime_errorC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
mov rdi, [rsp+68h+var_60]; void *
cmp rdi, r15
jz short loc_A2780
mov rsi, [rsp+68h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A2780:
mov rdi, [rsp+68h+var_40]; void *
cmp rdi, r12
jz short loc_A2797
mov rsi, [rsp+68h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A2797:
lea rax, _ZTVN5minja20LoopControlExceptionE; `vtable for'minja::LoopControlException
add rax, 10h
mov [r14], rax
mov [r14+10h], ebx
add rsp, 48h
pop rbx
pop r12
pop r14
pop r15
retn
mov rbx, rax
mov rdi, [rsp+arg_0]; void *
cmp rdi, r15
jz short loc_A27D4
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_A27D4
mov rbx, rax
loc_A27D4:
mov rdi, [rsp+arg_20]; void *
cmp rdi, r12
jz short loc_A27EB
mov rsi, [rsp+arg_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A27EB:
mov rdi, rbx
call __Unwind_Resume
| long long * minja::LoopControlException::LoopControlException(long long a1, int a2)
{
const char *v2; // rcx
long long v3; // rax
__int128 *v4; // rcx
long long *result; // rax
void *v6[2]; // [rsp+8h] [rbp-60h] BYREF
__int128 v7; // [rsp+18h] [rbp-50h] BYREF
void *v8[2]; // [rsp+28h] [rbp-40h] BYREF
_QWORD v9[6]; // [rsp+38h] [rbp-30h] BYREF
v8[0] = v9;
std::string::_M_construct<char const*>(v8, " outside of a loop", (long long)"");
v2 = "break";
if ( a2 == 1 )
v2 = "continue";
v3 = std::string::replace(v8, 0LL, 0LL, v2, 3LL * (a2 == 1) + 5);
v6[0] = &v7;
v4 = (__int128 *)(v3 + 16);
if ( *(_QWORD *)v3 == v3 + 16 )
{
v7 = *v4;
}
else
{
v6[0] = *(void **)v3;
*(_QWORD *)&v7 = *(_QWORD *)v4;
}
v6[1] = *(void **)(v3 + 8);
*(_QWORD *)v3 = v4;
*(_QWORD *)(v3 + 8) = 0LL;
*(_BYTE *)(v3 + 16) = 0;
std::runtime_error::runtime_error(a1, v6);
if ( v6[0] != &v7 )
operator delete(v6[0], v7 + 1);
if ( v8[0] != v9 )
operator delete(v8[0], v9[0] + 1LL);
result = &`vtable for'minja::LoopControlException + 2;
*(_QWORD *)a1 = &`vtable for'minja::LoopControlException + 2;
*(_DWORD *)(a1 + 16) = a2;
return result;
}
| LoopControlException:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV EBX,ESI
MOV R14,RDI
LEA R12,[RSP + 0x38]
MOV qword ptr [R12 + -0x10],R12
LEA RSI,[0x1f4576]
LEA RDX,[0x1f4588]
LEA R15,[RSP + 0x28]
MOV RDI,R15
CALL 0x0012337c
XOR EAX,EAX
CMP EBX,0x1
SETZ AL
LEA RDX,[0x1f323f]
LEA RCX,[0x1f3239]
CMOVZ RCX,RDX
LEA R8,[RAX + RAX*0x2]
ADD R8,0x5
LAB_001a270b:
MOV RDI,R15
XOR ESI,ESI
XOR EDX,EDX
CALL 0x0011b9f0
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x10],R15
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x001a273e
MOV qword ptr [RSP + 0x8],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x18],RDX
JMP 0x001a2745
LAB_001a273e:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [R15],XMM0
LAB_001a2745:
MOV RDX,qword ptr [RAX + 0x8]
LEA RSI,[RSP + 0x8]
MOV qword ptr [RSI + 0x8],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
LAB_001a2761:
MOV RDI,R14
CALL 0x0011baf0
LAB_001a2769:
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R15
JZ 0x001a2780
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011b8f0
LAB_001a2780:
MOV RDI,qword ptr [RSP + 0x28]
CMP RDI,R12
JZ 0x001a2797
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x0011b8f0
LAB_001a2797:
LEA RAX,[0x22e018]
ADD RAX,0x10
MOV qword ptr [R14],RAX
MOV dword ptr [R14 + 0x10],EBX
ADD RSP,0x48
POP RBX
POP R12
POP R14
POP R15
RET
|
/* minja::LoopControlException::LoopControlException(minja::LoopControlType) */
void __thiscall
minja::LoopControlException::LoopControlException(LoopControlException *this,int param_2)
{
long *plVar1;
char *pcVar2;
long *plVar3;
long *local_60;
long local_58;
long local_50;
long lStack_48;
long *local_40 [2];
long local_30 [2];
local_40[0] = local_30;
std::__cxx11::string::_M_construct<char_const*>(local_40," outside of a loop","");
pcVar2 = "break";
if (param_2 == 1) {
pcVar2 = "continue";
}
/* try { // try from 001a270b to 001a2716 has its CatchHandler @ 001a27d1 */
plVar1 = (long *)std::__cxx11::string::replace((ulong)local_40,0,(char *)0x0,(ulong)pcVar2);
plVar3 = plVar1 + 2;
if ((long *)*plVar1 == plVar3) {
local_50 = *plVar3;
lStack_48 = plVar1[3];
local_60 = &local_50;
}
else {
local_50 = *plVar3;
local_60 = (long *)*plVar1;
}
local_58 = plVar1[1];
*plVar1 = (long)plVar3;
plVar1[1] = 0;
*(int1 *)(plVar1 + 2) = 0;
/* try { // try from 001a2761 to 001a2768 has its CatchHandler @ 001a27b5 */
std::runtime_error::runtime_error((runtime_error *)this,(string *)&local_60);
if (local_60 != &local_50) {
operator_delete(local_60,local_50 + 1);
}
if (local_40[0] != local_30) {
operator_delete(local_40[0],local_30[0] + 1);
}
*(int ***)this = &PTR__runtime_error_0022e028;
*(int *)(this + 0x10) = param_2;
return;
}
| |
48,374 | compare_bin | eloqsql/mysys/my_compare.c | static int compare_bin(const uchar *a, uint a_length,
const uchar *b, uint b_length,
my_bool part_key, my_bool skip_end_space)
{
uint length= MY_MIN(a_length,b_length);
const uchar *end= a+ length;
int flag;
while (a < end)
if ((flag= (int) *a++ - (int) *b++))
return flag;
if (part_key && b_length < a_length)
return 0;
if (skip_end_space && a_length != b_length)
{
int swap= 1;
/*
We are using space compression. We have to check if longer key
has next character < ' ', in which case it's less than the shorter
key that has an implicite space afterwards.
This code is identical to the one in
strings/ctype-simple.c:my_strnncollsp_simple
*/
if (a_length < b_length)
{
/* put shorter key in a */
a_length= b_length;
a= b;
swap= -1; /* swap sign of result */
}
for (end= a + a_length-length; a < end ; a++)
{
if (*a != ' ')
return (*a < ' ') ? -swap : swap;
}
return 0;
}
return (int) (a_length-b_length);
} | O3 | c | compare_bin:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
cmpl %ecx, %esi
movl %ecx, %r10d
cmovbl %esi, %r10d
leaq (%rdi,%r10), %r11
cmpq %r11, %rdi
jae 0x9f1c8
movzbl (%rdi), %eax
incq %rdi
movzbl (%rdx), %ebx
incq %rdx
subl %ebx, %eax
je 0x9f1b1
jmp 0x9f236
testb %r8b, %r8b
setne %al
cmpl %ecx, %esi
seta %r8b
testb %al, %r8b
je 0x9f1dd
xorl %eax, %eax
jmp 0x9f236
testb %r9b, %r9b
sete %r8b
movl %esi, %eax
subl %ecx, %eax
sete %r9b
orb %r8b, %r9b
jne 0x9f236
xorl %eax, %eax
cmpl %ecx, %esi
cmoval %esi, %ecx
cmovbq %rdx, %rdi
movl $0x0, %edx
sbbl %edx, %edx
leaq (%rdi,%rcx), %rsi
subq %r10, %rsi
cmpq %rsi, %rdi
jae 0x9f236
orl $0x1, %edx
subq %r10, %rcx
xorl %eax, %eax
movb (%rdi,%rax), %sil
cmpb $0x20, %sil
jne 0x9f22b
incq %rax
cmpq %rax, %rcx
jne 0x9f217
jmp 0x9f1d9
movl %edx, %eax
negl %eax
cmpb $0x20, %sil
cmovael %edx, %eax
popq %rbx
popq %rbp
retq
| compare_bin:
push rbp
mov rbp, rsp
push rbx
cmp esi, ecx
mov r10d, ecx
cmovb r10d, esi
lea r11, [rdi+r10]
loc_9F1B1:
cmp rdi, r11
jnb short loc_9F1C8
movzx eax, byte ptr [rdi]
inc rdi
movzx ebx, byte ptr [rdx]
inc rdx
sub eax, ebx
jz short loc_9F1B1
jmp short loc_9F236
loc_9F1C8:
test r8b, r8b
setnz al
cmp esi, ecx
setnbe r8b
test r8b, al
jz short loc_9F1DD
loc_9F1D9:
xor eax, eax
jmp short loc_9F236
loc_9F1DD:
test r9b, r9b
setz r8b
mov eax, esi
sub eax, ecx
setz r9b
or r9b, r8b
jnz short loc_9F236
xor eax, eax
cmp esi, ecx
cmova ecx, esi
cmovb rdi, rdx
mov edx, 0
sbb edx, edx
lea rsi, [rdi+rcx]
sub rsi, r10
cmp rdi, rsi
jnb short loc_9F236
or edx, 1
sub rcx, r10
xor eax, eax
loc_9F217:
mov sil, [rdi+rax]
cmp sil, 20h ; ' '
jnz short loc_9F22B
inc rax
cmp rcx, rax
jnz short loc_9F217
jmp short loc_9F1D9
loc_9F22B:
mov eax, edx
neg eax
cmp sil, 20h ; ' '
cmovnb eax, edx
loc_9F236:
pop rbx
pop rbp
retn
| long long compare_bin(unsigned __int8 *a1, unsigned int a2, unsigned __int8 *a3, long long a4, char a5, char a6)
{
long long v6; // r10
unsigned __int8 *v7; // r11
int v8; // eax
int v9; // ebx
long long result; // rax
bool v11; // cf
unsigned int v12; // edx
long long v13; // rcx
long long v14; // rax
unsigned __int8 v15; // si
v6 = (unsigned int)a4;
if ( a2 < (unsigned int)a4 )
v6 = a2;
v7 = &a1[v6];
while ( a1 < v7 )
{
v8 = *a1++;
v9 = *a3++;
result = (unsigned int)(v8 - v9);
if ( (_DWORD)result )
return result;
}
if ( a5 != 0 && a2 > (unsigned int)a4 )
return 0LL;
result = a2 - (unsigned int)a4;
if ( a6 != 0 && a2 != (_DWORD)a4 )
{
result = 0LL;
v11 = a2 < (unsigned int)a4;
if ( a2 > (unsigned int)a4 )
a4 = a2;
if ( v11 )
a1 = a3;
if ( a1 < &a1[a4 - v6] )
{
v12 = v11 ? -1 : 1;
v13 = a4 - v6;
v14 = 0LL;
while ( 1 )
{
v15 = a1[v14];
if ( v15 != 32 )
break;
if ( v13 == ++v14 )
return 0LL;
}
result = -v12;
if ( v15 >= 0x20u )
return v12;
}
}
return result;
}
| compare_bin:
PUSH RBP
MOV RBP,RSP
PUSH RBX
CMP ESI,ECX
MOV R10D,ECX
CMOVC R10D,ESI
LEA R11,[RDI + R10*0x1]
LAB_0019f1b1:
CMP RDI,R11
JNC 0x0019f1c8
MOVZX EAX,byte ptr [RDI]
INC RDI
MOVZX EBX,byte ptr [RDX]
INC RDX
SUB EAX,EBX
JZ 0x0019f1b1
JMP 0x0019f236
LAB_0019f1c8:
TEST R8B,R8B
SETNZ AL
CMP ESI,ECX
SETA R8B
TEST R8B,AL
JZ 0x0019f1dd
LAB_0019f1d9:
XOR EAX,EAX
JMP 0x0019f236
LAB_0019f1dd:
TEST R9B,R9B
SETZ R8B
MOV EAX,ESI
SUB EAX,ECX
SETZ R9B
OR R9B,R8B
JNZ 0x0019f236
XOR EAX,EAX
CMP ESI,ECX
CMOVA ECX,ESI
CMOVC RDI,RDX
MOV EDX,0x0
SBB EDX,EDX
LEA RSI,[RDI + RCX*0x1]
SUB RSI,R10
CMP RDI,RSI
JNC 0x0019f236
OR EDX,0x1
SUB RCX,R10
XOR EAX,EAX
LAB_0019f217:
MOV SIL,byte ptr [RDI + RAX*0x1]
CMP SIL,0x20
JNZ 0x0019f22b
INC RAX
CMP RCX,RAX
JNZ 0x0019f217
JMP 0x0019f1d9
LAB_0019f22b:
MOV EAX,EDX
NEG EAX
CMP SIL,0x20
CMOVNC EAX,EDX
LAB_0019f236:
POP RBX
POP RBP
RET
|
uint compare_bin(byte *param_1,uint param_2,byte *param_3,uint param_4,char param_5,char param_6)
{
byte *pbVar1;
byte bVar2;
byte bVar3;
long lVar4;
ulong uVar5;
uint uVar6;
ulong uVar7;
uVar7 = (ulong)param_4;
if (param_2 < param_4) {
uVar7 = (ulong)param_2;
}
pbVar1 = param_1 + uVar7;
while (param_1 < pbVar1) {
bVar2 = *param_1;
param_1 = param_1 + 1;
bVar3 = *param_3;
param_3 = param_3 + 1;
if ((uint)bVar2 - (uint)bVar3 != 0) {
return (uint)bVar2 - (uint)bVar3;
}
}
if (param_2 <= param_4 || param_5 == '\0') {
if (param_2 - param_4 == 0 || param_6 == '\0') {
return param_2 - param_4;
}
uVar5 = (ulong)param_4;
if (param_4 < param_2) {
uVar5 = (ulong)param_2;
}
if (param_2 < param_4) {
param_1 = param_3;
}
if (param_1 + (uVar5 - uVar7) <= param_1) {
return 0;
}
uVar6 = -(uint)(param_2 < param_4) | 1;
lVar4 = 0;
do {
if (param_1[lVar4] != 0x20) {
if (param_1[lVar4] < 0x20) {
return -uVar6;
}
return uVar6;
}
lVar4 = lVar4 + 1;
} while (uVar5 - uVar7 != lVar4);
}
return 0;
}
| |
48,375 | ps_fetch_int32 | eloqsql/libmariadb/libmariadb/ma_stmt_codec.c | static
void ps_fetch_int32(MYSQL_BIND *r_param, const MYSQL_FIELD * const field,
unsigned char **row)
{
switch (r_param->buffer_type) {
/* case MYSQL_TYPE_TINY:
ps_fetch_from_1_to_8_bytes(r_param, field, row, 1);
break;
case MYSQL_TYPE_YEAR:
case MYSQL_TYPE_SHORT:
ps_fetch_from_1_to_8_bytes(r_param, field, row, 2);
break; */
case MYSQL_TYPE_INT24:
case MYSQL_TYPE_LONG:
ps_fetch_from_1_to_8_bytes(r_param, field, row, 4);
break;
default:
{
int32 sval= sint4korr(*row);
longlong lval= field->flags & UNSIGNED_FLAG ? (longlong)(uint32) sval : (longlong)sval;
convert_from_long(r_param, field, lval, field->flags & UNSIGNED_FLAG);
(*row) += 4;
}
break;
}
} | O0 | c | ps_fetch_int32:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x60(%rax), %eax
movl %eax, -0x2c(%rbp)
subl $0x3, %eax
je 0x2ecdf
jmp 0x2ecd5
movl -0x2c(%rbp), %eax
subl $0x9, %eax
jne 0x2ecfa
jmp 0x2ecdf
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x4, %ecx
callq 0x2d970
jmp 0x2ed8e
movq -0x18(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
addl %ecx, %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x10, %ecx
addl %ecx, %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movzbl 0x3(%rcx), %ecx
movswl %cx, %ecx
shll $0x18, %ecx
addl %ecx, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x64(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x2ed52
movl -0x1c(%rbp), %eax
movq %rax, -0x38(%rbp)
jmp 0x2ed5a
movslq -0x1c(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rax
movl 0x64(%rax), %eax
andl $0x20, %eax
movsbl %al, %ecx
callq 0x2f680
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| ps_fetch_int32:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_8]
mov eax, [rax+60h]
mov [rbp+var_2C], eax
sub eax, 3
jz short loc_2ECDF
jmp short $+2
loc_2ECD5:
mov eax, [rbp+var_2C]
sub eax, 9
jnz short loc_2ECFA
jmp short $+2
loc_2ECDF:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov ecx, 4
call ps_fetch_from_1_to_8_bytes
jmp loc_2ED8E
loc_2ECFA:
mov rax, [rbp+var_18]
mov rax, [rax]
movzx eax, byte ptr [rax]
mov rcx, [rbp+var_18]
mov rcx, [rcx]
movzx ecx, byte ptr [rcx+1]
shl ecx, 8
add eax, ecx
mov rcx, [rbp+var_18]
mov rcx, [rcx]
movzx ecx, byte ptr [rcx+2]
shl ecx, 10h
add eax, ecx
mov rcx, [rbp+var_18]
mov rcx, [rcx]
movzx ecx, byte ptr [rcx+3]
movsx ecx, cx
shl ecx, 18h
add eax, ecx
mov [rbp+var_1C], eax
mov rax, [rbp+var_10]
mov eax, [rax+64h]
and eax, 20h
cmp eax, 0
jz short loc_2ED52
mov eax, [rbp+var_1C]
mov [rbp+var_38], rax
jmp short loc_2ED5A
loc_2ED52:
movsxd rax, [rbp+var_1C]
mov [rbp+var_38], rax
loc_2ED5A:
mov rax, [rbp+var_38]
mov [rbp+var_28], rax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_28]
mov rax, [rbp+var_10]
mov eax, [rax+64h]
and eax, 20h
movsx ecx, al
call convert_from_long
mov rax, [rbp+var_18]
mov rcx, [rax]
add rcx, 4
mov [rax], rcx
loc_2ED8E:
add rsp, 40h
pop rbp
retn
| _BYTE ** ps_fetch_int32(long long a1, long long a2, _BYTE **a3)
{
_BYTE **result; // rax
long long v4; // [rsp+8h] [rbp-38h]
int v5; // [rsp+14h] [rbp-2Ch]
int v6; // [rsp+24h] [rbp-1Ch]
v5 = *(_DWORD *)(a1 + 96);
if ( v5 == 3 || v5 == 9 )
return ps_fetch_from_1_to_8_bytes(a1, a2, a3, 4u);
v6 = ((unsigned __int8)(*a3)[3] << 24)
+ ((unsigned __int8)(*a3)[2] << 16)
+ ((unsigned __int8)(*a3)[1] << 8)
+ (unsigned __int8)**a3;
if ( (*(_DWORD *)(a2 + 100) & 0x20) != 0 )
v4 = (unsigned int)v6;
else
v4 = v6;
convert_from_long(a1, a2, v4, *(_BYTE *)(a2 + 100) & 0x20);
result = a3;
*a3 += 4;
return result;
}
| ps_fetch_int32:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x60]
MOV dword ptr [RBP + -0x2c],EAX
SUB EAX,0x3
JZ 0x0012ecdf
JMP 0x0012ecd5
LAB_0012ecd5:
MOV EAX,dword ptr [RBP + -0x2c]
SUB EAX,0x9
JNZ 0x0012ecfa
JMP 0x0012ecdf
LAB_0012ecdf:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV ECX,0x4
CALL 0x0012d970
JMP 0x0012ed8e
LAB_0012ecfa:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOVZX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX]
MOVZX ECX,byte ptr [RCX + 0x1]
SHL ECX,0x8
ADD EAX,ECX
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX]
MOVZX ECX,byte ptr [RCX + 0x2]
SHL ECX,0x10
ADD EAX,ECX
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX]
MOVZX ECX,byte ptr [RCX + 0x3]
MOVSX ECX,CX
SHL ECX,0x18
ADD EAX,ECX
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x64]
AND EAX,0x20
CMP EAX,0x0
JZ 0x0012ed52
MOV EAX,dword ptr [RBP + -0x1c]
MOV qword ptr [RBP + -0x38],RAX
JMP 0x0012ed5a
LAB_0012ed52:
MOVSXD RAX,dword ptr [RBP + -0x1c]
MOV qword ptr [RBP + -0x38],RAX
LAB_0012ed5a:
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x64]
AND EAX,0x20
MOVSX ECX,AL
CALL 0x0012f680
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RAX]
ADD RCX,0x4
MOV qword ptr [RAX],RCX
LAB_0012ed8e:
ADD RSP,0x40
POP RBP
RET
|
void ps_fetch_int32(long param_1,long param_2,long *param_3)
{
uint uVar1;
ulong local_40;
if ((*(int *)(param_1 + 0x60) == 3) || (*(int *)(param_1 + 0x60) == 9)) {
ps_fetch_from_1_to_8_bytes(param_1,param_2,param_3,4);
}
else {
uVar1 = (uint)*(byte *)*param_3 + (uint)*(byte *)(*param_3 + 1) * 0x100 +
(uint)*(byte *)(*param_3 + 2) * 0x10000 +
(short)(ushort)*(byte *)(*param_3 + 3) * 0x1000000;
if ((*(uint *)(param_2 + 100) & 0x20) == 0) {
local_40 = (ulong)(int)uVar1;
}
else {
local_40 = (ulong)uVar1;
}
convert_from_long(param_1,param_2,local_40,(byte)*(int4 *)(param_2 + 100) & 0x20);
*param_3 = *param_3 + 4;
}
return;
}
| |
48,376 | write_hook_for_clr_end | eloqsql/storage/maria/ma_key_recover.c | my_bool write_hook_for_clr_end(enum translog_record_type type
__attribute__ ((unused)),
TRN *trn, MARIA_HA *tbl_info,
LSN *lsn __attribute__ ((unused)),
void *hook_arg)
{
MARIA_SHARE *share= tbl_info->s;
struct st_msg_to_write_hook_for_clr_end *msg=
(struct st_msg_to_write_hook_for_clr_end *)hook_arg;
my_bool error= FALSE;
DBUG_ENTER("write_hook_for_clr_end");
DBUG_ASSERT(trn->trid != 0);
trn->undo_lsn= msg->previous_undo_lsn;
switch (msg->undone_record_type) {
case LOGREC_UNDO_ROW_DELETE:
share->state.state.records++;
share->state.state.checksum+= msg->checksum_delta;
break;
case LOGREC_UNDO_ROW_INSERT:
share->state.state.records--;
share->state.state.checksum+= msg->checksum_delta;
break;
case LOGREC_UNDO_ROW_UPDATE:
share->state.state.checksum+= msg->checksum_delta;
break;
case LOGREC_UNDO_KEY_INSERT_WITH_ROOT:
case LOGREC_UNDO_KEY_DELETE_WITH_ROOT:
{
/* Update key root */
struct st_msg_to_write_hook_for_undo_key *extra_msg=
(struct st_msg_to_write_hook_for_undo_key *) msg->extra_msg;
*extra_msg->root= extra_msg->value;
break;
}
case LOGREC_UNDO_KEY_INSERT:
case LOGREC_UNDO_KEY_DELETE:
break;
case LOGREC_UNDO_BULK_INSERT:
mysql_mutex_assert_owner(&share->intern_lock);
error= (maria_enable_indexes(tbl_info) ||
/* we enabled indices, need '2' below */
_ma_state_info_write(share,
MA_STATE_INFO_WRITE_DONT_MOVE_OFFSET |
MA_STATE_INFO_WRITE_FULL_INFO));
/* no need for _ma_reset_status(): REDO_DELETE_ALL is just before us */
break;
default:
DBUG_ASSERT(0);
}
if (trn->undo_lsn == LSN_IMPOSSIBLE) /* has fully rolled back */
trn->first_undo_lsn= LSN_WITH_FLAGS_TO_FLAGS(trn->first_undo_lsn);
DBUG_RETURN(error);
} | O0 | c | write_hook_for_clr_end:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x0, -0x39(%rbp)
jmp 0x6f9d4
movq -0x38(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x98(%rax)
movq -0x38(%rbp), %rax
movl 0x8(%rax), %eax
addl $-0x12, %eax
movl %eax, %ecx
movq %rcx, -0x50(%rbp)
subl $0x15, %eax
ja 0x6face
movq -0x50(%rbp), %rax
leaq 0xe82ba(%rip), %rcx # 0x157cc4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x30(%rbp), %rax
addl 0x48(%rax), %ecx
movl %ecx, 0x48(%rax)
jmp 0x6fad4
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x30(%rbp), %rax
addl 0x48(%rax), %ecx
movl %ecx, 0x48(%rax)
jmp 0x6fad4
movq -0x38(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x30(%rbp), %rax
addl 0x48(%rax), %ecx
movl %ecx, 0x48(%rax)
jmp 0x6fad4
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
jmp 0x6fad4
jmp 0x6fad4
jmp 0x6fa93
jmp 0x6fa95
movq -0x18(%rbp), %rdi
callq 0x68420
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x51(%rbp)
jne 0x6fac1
movq -0x30(%rbp), %rdi
movl $0x3, %esi
callq 0x64b50
cmpl $0x0, %eax
setne %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x39(%rbp)
jmp 0x6fad4
jmp 0x6fad0
jmp 0x6fad2
jmp 0x6fad4
movq -0x10(%rbp), %rax
cmpq $0x0, 0x98(%rax)
jne 0x6fb02
movq -0x10(%rbp), %rax
movabsq $-0x100000000000000, %rcx # imm = 0xFF00000000000000
andq 0xa0(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xa0(%rax)
jmp 0x6fb04
movb -0x39(%rbp), %al
movb %al, -0x52(%rbp)
movb -0x52(%rbp), %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| write_hook_for_clr_end:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rbp+var_30], rax
mov rax, [rbp+var_28]
mov [rbp+var_38], rax
mov [rbp+var_39], 0
jmp short $+2
loc_6F9D4:
mov rax, [rbp+var_38]
mov rcx, [rax]
mov rax, [rbp+var_10]
mov [rax+98h], rcx
mov rax, [rbp+var_38]
mov eax, [rax+8]
add eax, 0FFFFFFEEh; switch 22 cases
mov ecx, eax
mov [rbp+var_50], rcx
sub eax, 15h
ja def_6FA11; jumptable 000000000006FA11 default case, cases 25-38
mov rax, [rbp+var_50]
lea rcx, jpt_6FA11
movsxd rax, ds:(jpt_6FA11 - 157CC4h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_6FA13:
mov rax, [rbp+var_30]; jumptable 000000000006FA11 case 19
mov rcx, [rax+18h]
add rcx, 1
mov [rax+18h], rcx
mov rax, [rbp+var_38]
mov ecx, [rax+0Ch]
mov rax, [rbp+var_30]
add ecx, [rax+48h]
mov [rax+48h], ecx
jmp loc_6FAD4
loc_6FA39:
mov rax, [rbp+var_30]; jumptable 000000000006FA11 case 18
mov rcx, [rax+18h]
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rax+18h], rcx
mov rax, [rbp+var_38]
mov ecx, [rax+0Ch]
mov rax, [rbp+var_30]
add ecx, [rax+48h]
mov [rax+48h], ecx
jmp short loc_6FAD4
loc_6FA5C:
mov rax, [rbp+var_38]; jumptable 000000000006FA11 case 20
mov ecx, [rax+0Ch]
mov rax, [rbp+var_30]
add ecx, [rax+48h]
mov [rax+48h], ecx
jmp short loc_6FAD4
loc_6FA6F:
mov rax, [rbp+var_38]; jumptable 000000000006FA11 cases 22,24
mov rax, [rax+10h]
mov [rbp+var_48], rax
mov rax, [rbp+var_48]
mov rcx, [rax+8]
mov rax, [rbp+var_48]
mov rax, [rax]
mov [rax], rcx
jmp short loc_6FAD4
loc_6FA8F:
jmp short loc_6FAD4; jumptable 000000000006FA11 cases 21,23
loc_6FA91:
jmp short $+2; jumptable 000000000006FA11 case 39
loc_6FA93:
jmp short $+2
loc_6FA95:
mov rdi, [rbp+var_18]
call maria_enable_indexes
mov ecx, eax
mov al, 1
cmp ecx, 0
mov [rbp+var_51], al
jnz short loc_6FAC1
mov rdi, [rbp+var_30]
mov esi, 3
call _ma_state_info_write
cmp eax, 0
setnz al
mov [rbp+var_51], al
loc_6FAC1:
mov al, [rbp+var_51]
and al, 1
movzx eax, al
mov [rbp+var_39], al
jmp short loc_6FAD4
def_6FA11:
jmp short $+2; jumptable 000000000006FA11 default case, cases 25-38
loc_6FAD0:
jmp short $+2
loc_6FAD2:
jmp short $+2
loc_6FAD4:
mov rax, [rbp+var_10]
cmp qword ptr [rax+98h], 0
jnz short loc_6FB02
mov rax, [rbp+var_10]
mov rcx, 0FF00000000000000h
and rcx, [rax+0A0h]
mov rax, [rbp+var_10]
mov [rax+0A0h], rcx
loc_6FB02:
jmp short $+2
loc_6FB04:
mov al, [rbp+var_39]
mov [rbp+var_52], al
mov al, [rbp+var_52]
add rsp, 60h
pop rbp
retn
| bool write_hook_for_clr_end(long long a1, long long a2, _DWORD *a3, long long a4, long long a5, int a6)
{
int v6; // eax
bool v8; // [rsp+Fh] [rbp-51h]
bool v9; // [rsp+27h] [rbp-39h]
long long v10; // [rsp+30h] [rbp-30h]
v10 = *(_QWORD *)a3;
v9 = 0;
*(_QWORD *)(a2 + 152) = *(_QWORD *)a5;
v6 = *(_DWORD *)(a5 + 8);
switch ( v6 )
{
case 18:
--*(_QWORD *)(v10 + 24);
*(_DWORD *)(v10 + 72) += *(_DWORD *)(a5 + 12);
break;
case 19:
++*(_QWORD *)(v10 + 24);
*(_DWORD *)(v10 + 72) += *(_DWORD *)(a5 + 12);
break;
case 20:
*(_DWORD *)(v10 + 72) += *(_DWORD *)(a5 + 12);
break;
case 22:
case 24:
***(_QWORD ***)(a5 + 16) = *(_QWORD *)(*(_QWORD *)(a5 + 16) + 8LL);
break;
case 39:
v8 = 1;
if ( !(unsigned int)maria_enable_indexes(a3, a2, (long long)a3, (unsigned int)(v6 - 18), a5, a6) )
v8 = (unsigned int)ma_state_info_write(v10, 3u) != 0;
v9 = v8;
break;
default:
break;
}
if ( !*(_QWORD *)(a2 + 152) )
*(_QWORD *)(a2 + 160) &= 0xFF00000000000000LL;
return v9;
}
| write_hook_for_clr_end:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x38],RAX
MOV byte ptr [RBP + -0x39],0x0
JMP 0x0016f9d4
LAB_0016f9d4:
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x98],RCX
MOV RAX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RAX + 0x8]
ADD EAX,-0x12
MOV ECX,EAX
MOV qword ptr [RBP + -0x50],RCX
SUB EAX,0x15
JA 0x0016face
MOV RAX,qword ptr [RBP + -0x50]
LEA RCX,[0x257cc4]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_13:
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RAX + 0x18]
ADD RCX,0x1
MOV qword ptr [RAX + 0x18],RCX
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RAX + 0xc]
MOV RAX,qword ptr [RBP + -0x30]
ADD ECX,dword ptr [RAX + 0x48]
MOV dword ptr [RAX + 0x48],ECX
JMP 0x0016fad4
caseD_12:
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RAX + 0x18]
ADD RCX,-0x1
MOV qword ptr [RAX + 0x18],RCX
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RAX + 0xc]
MOV RAX,qword ptr [RBP + -0x30]
ADD ECX,dword ptr [RAX + 0x48]
MOV dword ptr [RAX + 0x48],ECX
JMP 0x0016fad4
caseD_14:
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RAX + 0xc]
MOV RAX,qword ptr [RBP + -0x30]
ADD ECX,dword ptr [RAX + 0x48]
MOV dword ptr [RAX + 0x48],ECX
JMP 0x0016fad4
caseD_16:
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX],RCX
JMP 0x0016fad4
caseD_15:
JMP 0x0016fad4
caseD_27:
JMP 0x0016fa93
LAB_0016fa93:
JMP 0x0016fa95
LAB_0016fa95:
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00168420
MOV ECX,EAX
MOV AL,0x1
CMP ECX,0x0
MOV byte ptr [RBP + -0x51],AL
JNZ 0x0016fac1
MOV RDI,qword ptr [RBP + -0x30]
MOV ESI,0x3
CALL 0x00164b50
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0x51],AL
LAB_0016fac1:
MOV AL,byte ptr [RBP + -0x51]
AND AL,0x1
MOVZX EAX,AL
MOV byte ptr [RBP + -0x39],AL
JMP 0x0016fad4
caseD_19:
JMP 0x0016fad0
LAB_0016fad0:
JMP 0x0016fad2
LAB_0016fad2:
JMP 0x0016fad4
LAB_0016fad4:
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x98],0x0
JNZ 0x0016fb02
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,-0x100000000000000
AND RCX,qword ptr [RAX + 0xa0]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0xa0],RCX
LAB_0016fb02:
JMP 0x0016fb04
LAB_0016fb04:
MOV AL,byte ptr [RBP + -0x39]
MOV byte ptr [RBP + -0x52],AL
MOV AL,byte ptr [RBP + -0x52]
ADD RSP,0x60
POP RBP
RET
|
bool write_hook_for_clr_end
(int8 param_1,long param_2,long *param_3,int8 param_4,int8 *param_5
)
{
long lVar1;
int iVar2;
bool local_59;
bool local_41;
lVar1 = *param_3;
local_41 = false;
*(int8 *)(param_2 + 0x98) = *param_5;
switch(*(int4 *)(param_5 + 1)) {
case 0x12:
*(long *)(lVar1 + 0x18) = *(long *)(lVar1 + 0x18) + -1;
*(int *)(lVar1 + 0x48) = *(int *)((long)param_5 + 0xc) + *(int *)(lVar1 + 0x48);
break;
case 0x13:
*(long *)(lVar1 + 0x18) = *(long *)(lVar1 + 0x18) + 1;
*(int *)(lVar1 + 0x48) = *(int *)((long)param_5 + 0xc) + *(int *)(lVar1 + 0x48);
break;
case 0x14:
*(int *)(lVar1 + 0x48) = *(int *)((long)param_5 + 0xc) + *(int *)(lVar1 + 0x48);
break;
case 0x15:
case 0x17:
break;
case 0x16:
case 0x18:
**(int8 **)param_5[2] = ((int8 *)param_5[2])[1];
break;
default:
break;
case 0x27:
iVar2 = maria_enable_indexes(param_3);
local_59 = true;
if (iVar2 == 0) {
iVar2 = _ma_state_info_write(lVar1,3);
local_59 = iVar2 != 0;
}
local_41 = local_59;
}
if (*(long *)(param_2 + 0x98) == 0) {
*(ulong *)(param_2 + 0xa0) = *(ulong *)(param_2 + 0xa0) & 0xff00000000000000;
}
return local_41;
}
| |
48,377 | LefDefParser::lefiViaLayer::clone() | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiVia.cpp | lefiViaLayer *
lefiViaLayer::clone()
{
lefiViaLayer *vl = (lefiViaLayer*) lefMalloc(sizeof(lefiViaLayer));
int i, j;
if (numRects_ > 0) {
vl->xl_ = (double*) lefMalloc(sizeof(double) * numRects_);
vl->yl_ = (double*) lefMalloc(sizeof(double) * numRects_);
vl->xh_ = (double*) lefMalloc(sizeof(double) * numRects_);
vl->yh_ = (double*) lefMalloc(sizeof(double) * numRects_);
vl->rectColorMask_ = (int*) lefMalloc(sizeof(int) * numRects_);
vl->numRects_ = numRects_;
vl->rectsAllocated_ = rectsAllocated_;
for (i = 0; i < numRects_; i++) {
vl->xl_[i] = xl_[i];
vl->yl_[i] = yl_[i];
vl->xh_[i] = xh_[i];
vl->yh_[i] = yh_[i];
vl->rectColorMask_[i] = rectColorMask_[i];
}
} else {
vl->xl_ = 0;
vl->yl_ = 0;
vl->xh_ = 0;
vl->yh_ = 0;
vl->rectColorMask_ = 0;
vl->numRects_ = numRects_;
vl->rectsAllocated_ = rectsAllocated_;
}
vl->numPolys_ = numPolys_;
vl->polysAllocated_ = polysAllocated_;
vl->polygons_ = (lefiGeomPolygon**)
lefMalloc(sizeof(lefiGeomPolygon*) * polysAllocated_);
if (numPolys_ > 0) {
vl->polyColorMask_ = (int*) lefMalloc(sizeof(int) * numPolys_);
} else {
vl->polyColorMask_ = 0;
}
for (i = 0; i < numPolys_; i++) {
vl->polygons_[i] = (lefiGeomPolygon*) lefMalloc(sizeof(lefiGeomPolygon));
vl->polygons_[i]->numPoints = polygons_[i]->numPoints;
vl->polygons_[i]->x = (double*) lefMalloc(sizeof(double) *
polygons_[i]->numPoints);
vl->polygons_[i]->y = (double*) lefMalloc(sizeof(double) *
polygons_[i]->numPoints);
vl->polygons_[i]->colorMask = polygons_[i]->colorMask;
vl->polyColorMask_[i] = polyColorMask_[i];
for (j = 0; j < polygons_[i]->numPoints; j++) {
vl->polygons_[i]->x[j] = polygons_[i]->x[j];
vl->polygons_[i]->y[j] = polygons_[i]->y[j];
}
/*
vl->polygons_[i] = polygons_[i];
*/
}
vl->name_ = (char*) lefMalloc(strlen(name_) + 1);
strcpy(vl->name_, name_);
return vl;
} | O3 | cpp | LefDefParser::lefiViaLayer::clone():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x50, %edi
callq 0x30c15
movq %rax, %rbx
movslq 0x18(%r14), %rdi
testq %rdi, %rdi
jle 0xe312
shlq $0x3, %rdi
callq 0x30c15
movq %rax, 0x20(%rbx)
movslq 0x18(%r14), %rdi
shlq $0x3, %rdi
callq 0x30c15
movq %rax, 0x28(%rbx)
movslq 0x18(%r14), %rdi
shlq $0x3, %rdi
callq 0x30c15
movq %rax, 0x30(%rbx)
movslq 0x18(%r14), %rdi
shlq $0x3, %rdi
callq 0x30c15
movq %rax, 0x38(%rbx)
movslq 0x18(%r14), %rdi
shlq $0x2, %rdi
callq 0x30c15
movq %rax, 0x8(%rbx)
movq 0x18(%r14), %rcx
movq %rcx, 0x18(%rbx)
testl %ecx, %ecx
jle 0xe32f
movq 0x8(%r14), %rcx
movq 0x20(%r14), %rdx
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdi
movq 0x28(%r14), %r8
movq 0x30(%r14), %r9
movq 0x30(%rbx), %r10
movq 0x38(%r14), %r11
movq 0x38(%rbx), %r15
xorl %r12d, %r12d
movsd (%rdx,%r12,8), %xmm0
movsd %xmm0, (%rsi,%r12,8)
movsd (%r8,%r12,8), %xmm0
movsd %xmm0, (%rdi,%r12,8)
movsd (%r9,%r12,8), %xmm0
movsd %xmm0, (%r10,%r12,8)
movsd (%r11,%r12,8), %xmm0
movsd %xmm0, (%r15,%r12,8)
movl (%rcx,%r12,4), %ebp
movl %ebp, (%rax,%r12,4)
incq %r12
movslq 0x18(%r14), %r13
cmpq %r13, %r12
jl 0xe2cc
jmp 0xe32f
movq $0x0, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x30(%rbx)
movl %edi, 0x18(%rbx)
movl 0x1c(%r14), %eax
movl %eax, 0x1c(%rbx)
movl 0x40(%r14), %eax
movl %eax, 0x40(%rbx)
movslq 0x44(%r14), %rdi
movl %edi, 0x44(%rbx)
shlq $0x3, %rdi
callq 0x30c15
movq %rax, 0x48(%rbx)
movslq 0x40(%r14), %rdi
testq %rdi, %rdi
jle 0xe43d
shlq $0x2, %rdi
callq 0x30c15
cmpl $0x0, 0x40(%r14)
movq %rax, 0x10(%rbx)
jle 0xe445
xorl %r15d, %r15d
movl $0x20, %edi
callq 0x30c15
movq 0x48(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
movq 0x48(%r14), %rax
movq (%rax,%r15,8), %rax
movslq (%rax), %rdi
movq 0x48(%rbx), %rax
movq (%rax,%r15,8), %rax
movl %edi, (%rax)
shlq $0x3, %rdi
callq 0x30c15
movq 0x48(%rbx), %rcx
movq (%rcx,%r15,8), %rcx
movq %rax, 0x8(%rcx)
movq 0x48(%r14), %rax
movq (%rax,%r15,8), %rax
movslq (%rax), %rdi
shlq $0x3, %rdi
callq 0x30c15
movq 0x48(%rbx), %rcx
movq (%rcx,%r15,8), %rdx
movq %rax, 0x10(%rdx)
movq 0x48(%r14), %rax
movq (%rax,%r15,8), %rdx
movl 0x18(%rdx), %eax
movq (%rcx,%r15,8), %rdi
movl %eax, 0x18(%rdi)
movq 0x10(%r14), %rax
movl (%rax,%r15,4), %eax
movq 0x10(%rbx), %rcx
movl %eax, (%rcx,%r15,4)
movslq (%rdx), %rax
testq %rax, %rax
jle 0xe42b
movq 0x8(%rdx), %rcx
movq 0x10(%rdx), %rdx
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdi
xorl %r8d, %r8d
movsd (%rcx,%r8,8), %xmm0
movsd %xmm0, (%rsi,%r8,8)
movsd (%rdx,%r8,8), %xmm0
movsd %xmm0, (%rdi,%r8,8)
incq %r8
cmpq %r8, %rax
jne 0xe40b
incq %r15
movslq 0x40(%r14), %rax
cmpq %rax, %r15
jl 0xe372
jmp 0xe445
movq $0x0, 0x10(%rbx)
movq (%r14), %rdi
callq 0x20e0
leaq 0x1(%rax), %rdi
callq 0x30c15
movq %rax, (%rbx)
movq (%r14), %rsi
movq %rax, %rdi
callq 0x21d0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZN12LefDefParser12lefiViaLayer5cloneEv:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rdi
mov edi, offset off_50; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov rbx, rax
movsxd rdi, dword ptr [r14+18h]
test rdi, rdi
jle loc_E312
shl rdi, 3; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov [rbx+20h], rax
movsxd rdi, dword ptr [r14+18h]
shl rdi, 3; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov [rbx+28h], rax
movsxd rdi, dword ptr [r14+18h]
shl rdi, 3; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov [rbx+30h], rax
movsxd rdi, dword ptr [r14+18h]
shl rdi, 3; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov [rbx+38h], rax
movsxd rdi, dword ptr [r14+18h]
shl rdi, 2; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov [rbx+8], rax
mov rcx, [r14+18h]
mov [rbx+18h], rcx
test ecx, ecx
jle loc_E32F
mov rcx, [r14+8]
mov rdx, [r14+20h]
mov rsi, [rbx+20h]; unsigned __int64
mov rdi, [rbx+28h]
mov r8, [r14+28h]
mov r9, [r14+30h]
mov r10, [rbx+30h]
mov r11, [r14+38h]
mov r15, [rbx+38h]
xor r12d, r12d
loc_E2CC:
movsd xmm0, qword ptr [rdx+r12*8]
movsd qword ptr [rsi+r12*8], xmm0
movsd xmm0, qword ptr [r8+r12*8]
movsd qword ptr [rdi+r12*8], xmm0
movsd xmm0, qword ptr [r9+r12*8]
movsd qword ptr [r10+r12*8], xmm0
movsd xmm0, qword ptr [r11+r12*8]
movsd qword ptr [r15+r12*8], xmm0
mov ebp, [rcx+r12*4]
mov [rax+r12*4], ebp
inc r12
movsxd r13, dword ptr [r14+18h]
cmp r12, r13
jl short loc_E2CC
jmp short loc_E32F
loc_E312:
mov qword ptr [rbx+8], 0
xorps xmm0, xmm0
movups xmmword ptr [rbx+20h], xmm0
movups xmmword ptr [rbx+30h], xmm0
mov [rbx+18h], edi
mov eax, [r14+1Ch]
mov [rbx+1Ch], eax
loc_E32F:
mov eax, [r14+40h]
mov [rbx+40h], eax
movsxd rdi, dword ptr [r14+44h]
mov [rbx+44h], edi
shl rdi, 3; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov [rbx+48h], rax
movsxd rdi, dword ptr [r14+40h]
test rdi, rdi
jle loc_E43D
shl rdi, 2; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
cmp dword ptr [r14+40h], 0
mov [rbx+10h], rax
jle loc_E445
xor r15d, r15d
loc_E372:
mov edi, offset qword_20; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov rcx, [rbx+48h]
mov [rcx+r15*8], rax
mov rax, [r14+48h]
mov rax, [rax+r15*8]
movsxd rdi, dword ptr [rax]
mov rax, [rbx+48h]
mov rax, [rax+r15*8]
mov [rax], edi
shl rdi, 3; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov rcx, [rbx+48h]
mov rcx, [rcx+r15*8]
mov [rcx+8], rax
mov rax, [r14+48h]
mov rax, [rax+r15*8]
movsxd rdi, dword ptr [rax]
shl rdi, 3; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov rcx, [rbx+48h]
mov rdx, [rcx+r15*8]
mov [rdx+10h], rax
mov rax, [r14+48h]
mov rdx, [rax+r15*8]
mov eax, [rdx+18h]
mov rdi, [rcx+r15*8]
mov [rdi+18h], eax
mov rax, [r14+10h]
mov eax, [rax+r15*4]
mov rcx, [rbx+10h]
mov [rcx+r15*4], eax
movsxd rax, dword ptr [rdx]
test rax, rax
jle short loc_E42B
mov rcx, [rdx+8]
mov rdx, [rdx+10h]
mov rsi, [rdi+8]; unsigned __int64
mov rdi, [rdi+10h]
xor r8d, r8d
loc_E40B:
movsd xmm0, qword ptr [rcx+r8*8]
movsd qword ptr [rsi+r8*8], xmm0
movsd xmm0, qword ptr [rdx+r8*8]
movsd qword ptr [rdi+r8*8], xmm0
inc r8
cmp rax, r8
jnz short loc_E40B
loc_E42B:
inc r15
movsxd rax, dword ptr [r14+40h]
cmp r15, rax
jl loc_E372
jmp short loc_E445
loc_E43D:
mov qword ptr [rbx+10h], 0
loc_E445:
mov rdi, [r14]
call _strlen
lea rdi, [rax+1]; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov [rbx], rax
mov rsi, [r14]
mov rdi, rax
call _strcpy
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long LefDefParser::lefiViaLayer::clone(LefDefParser::lefiViaLayer *this, unsigned long long a2)
{
long long v3; // rax
long long v4; // rbx
long long v5; // rdi
long long v6; // rax
long long v7; // rcx
long long v8; // rcx
long long v9; // rdx
long long v10; // rdi
long long v11; // r8
long long v12; // r9
long long v13; // r10
long long v14; // r11
long long v15; // r15
long long v16; // r12
long long v17; // rdi
long long v18; // rdi
long long v19; // rax
bool v20; // cc
long long v21; // r15
long long v22; // rdi
long long v23; // rax
long long v24; // rcx
int *v25; // rdx
long long v26; // rdi
long long v27; // rax
long long v28; // rcx
long long v29; // rdx
long long v30; // rdi
long long i; // r8
long long v32; // rax
long long v33; // rax
v3 = LefDefParser::lefMalloc((LefDefParser *)off_50, a2);
v4 = v3;
v5 = *((int *)this + 6);
if ( v5 <= 0 )
{
*(_QWORD *)(v3 + 8) = 0LL;
*(_OWORD *)(v3 + 32) = 0LL;
*(_OWORD *)(v3 + 48) = 0LL;
*(_DWORD *)(v3 + 24) = v5;
*(_DWORD *)(v3 + 28) = *((_DWORD *)this + 7);
}
else
{
*(_QWORD *)(v3 + 32) = LefDefParser::lefMalloc((LefDefParser *)(8 * v5), a2);
*(_QWORD *)(v4 + 40) = LefDefParser::lefMalloc((LefDefParser *)(8LL * *((int *)this + 6)), a2);
*(_QWORD *)(v4 + 48) = LefDefParser::lefMalloc((LefDefParser *)(8LL * *((int *)this + 6)), a2);
*(_QWORD *)(v4 + 56) = LefDefParser::lefMalloc((LefDefParser *)(8LL * *((int *)this + 6)), a2);
v6 = LefDefParser::lefMalloc((LefDefParser *)(4LL * *((int *)this + 6)), a2);
*(_QWORD *)(v4 + 8) = v6;
v7 = *((_QWORD *)this + 3);
*(_QWORD *)(v4 + 24) = v7;
if ( (int)v7 > 0 )
{
v8 = *((_QWORD *)this + 1);
v9 = *((_QWORD *)this + 4);
a2 = *(_QWORD *)(v4 + 32);
v10 = *(_QWORD *)(v4 + 40);
v11 = *((_QWORD *)this + 5);
v12 = *((_QWORD *)this + 6);
v13 = *(_QWORD *)(v4 + 48);
v14 = *((_QWORD *)this + 7);
v15 = *(_QWORD *)(v4 + 56);
v16 = 0LL;
do
{
*(_QWORD *)(a2 + 8 * v16) = *(_QWORD *)(v9 + 8 * v16);
*(_QWORD *)(v10 + 8 * v16) = *(_QWORD *)(v11 + 8 * v16);
*(_QWORD *)(v13 + 8 * v16) = *(_QWORD *)(v12 + 8 * v16);
*(_QWORD *)(v15 + 8 * v16) = *(_QWORD *)(v14 + 8 * v16);
*(_DWORD *)(v6 + 4 * v16) = *(_DWORD *)(v8 + 4 * v16);
++v16;
}
while ( v16 < *((int *)this + 6) );
}
}
*(_DWORD *)(v4 + 64) = *((_DWORD *)this + 16);
v17 = *((int *)this + 17);
*(_DWORD *)(v4 + 68) = v17;
*(_QWORD *)(v4 + 72) = LefDefParser::lefMalloc((LefDefParser *)(8 * v17), a2);
v18 = *((int *)this + 16);
if ( v18 <= 0 )
{
*(_QWORD *)(v4 + 16) = 0LL;
}
else
{
v19 = LefDefParser::lefMalloc((LefDefParser *)(4 * v18), a2);
v20 = *((_DWORD *)this + 16) <= 0;
*(_QWORD *)(v4 + 16) = v19;
if ( !v20 )
{
v21 = 0LL;
do
{
*(_QWORD *)(*(_QWORD *)(v4 + 72) + 8 * v21) = LefDefParser::lefMalloc((LefDefParser *)&qword_20, a2);
v22 = **(int **)(*((_QWORD *)this + 9) + 8 * v21);
**(_DWORD **)(*(_QWORD *)(v4 + 72) + 8 * v21) = v22;
*(_QWORD *)(*(_QWORD *)(*(_QWORD *)(v4 + 72) + 8 * v21) + 8LL) = LefDefParser::lefMalloc(
(LefDefParser *)(8 * v22),
a2);
v23 = LefDefParser::lefMalloc((LefDefParser *)(8LL * **(int **)(*((_QWORD *)this + 9) + 8 * v21)), a2);
v24 = *(_QWORD *)(v4 + 72);
*(_QWORD *)(*(_QWORD *)(v24 + 8 * v21) + 16LL) = v23;
v25 = *(int **)(*((_QWORD *)this + 9) + 8 * v21);
v26 = *(_QWORD *)(v24 + 8 * v21);
*(_DWORD *)(v26 + 24) = v25[6];
*(_DWORD *)(*(_QWORD *)(v4 + 16) + 4 * v21) = *(_DWORD *)(*((_QWORD *)this + 2) + 4 * v21);
v27 = *v25;
if ( v27 > 0 )
{
v28 = *((_QWORD *)v25 + 1);
v29 = *((_QWORD *)v25 + 2);
a2 = *(_QWORD *)(v26 + 8);
v30 = *(_QWORD *)(v26 + 16);
for ( i = 0LL; i != v27; ++i )
{
*(_QWORD *)(a2 + 8 * i) = *(_QWORD *)(v28 + 8 * i);
*(_QWORD *)(v30 + 8 * i) = *(_QWORD *)(v29 + 8 * i);
}
}
++v21;
}
while ( v21 < *((int *)this + 16) );
}
}
v32 = strlen(*(_QWORD *)this);
v33 = LefDefParser::lefMalloc((LefDefParser *)(v32 + 1), a2);
*(_QWORD *)v4 = v33;
strcpy(v33, *(_QWORD *)this);
return v4;
}
| clone:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDI
MOV EDI,0x50
CALL 0x00130c15
MOV RBX,RAX
MOVSXD RDI,dword ptr [R14 + 0x18]
TEST RDI,RDI
JLE 0x0010e312
SHL RDI,0x3
CALL 0x00130c15
MOV qword ptr [RBX + 0x20],RAX
MOVSXD RDI,dword ptr [R14 + 0x18]
SHL RDI,0x3
CALL 0x00130c15
MOV qword ptr [RBX + 0x28],RAX
MOVSXD RDI,dword ptr [R14 + 0x18]
SHL RDI,0x3
CALL 0x00130c15
MOV qword ptr [RBX + 0x30],RAX
MOVSXD RDI,dword ptr [R14 + 0x18]
SHL RDI,0x3
CALL 0x00130c15
MOV qword ptr [RBX + 0x38],RAX
MOVSXD RDI,dword ptr [R14 + 0x18]
SHL RDI,0x2
CALL 0x00130c15
MOV qword ptr [RBX + 0x8],RAX
MOV RCX,qword ptr [R14 + 0x18]
MOV qword ptr [RBX + 0x18],RCX
TEST ECX,ECX
JLE 0x0010e32f
MOV RCX,qword ptr [R14 + 0x8]
MOV RDX,qword ptr [R14 + 0x20]
MOV RSI,qword ptr [RBX + 0x20]
MOV RDI,qword ptr [RBX + 0x28]
MOV R8,qword ptr [R14 + 0x28]
MOV R9,qword ptr [R14 + 0x30]
MOV R10,qword ptr [RBX + 0x30]
MOV R11,qword ptr [R14 + 0x38]
MOV R15,qword ptr [RBX + 0x38]
XOR R12D,R12D
LAB_0010e2cc:
MOVSD XMM0,qword ptr [RDX + R12*0x8]
MOVSD qword ptr [RSI + R12*0x8],XMM0
MOVSD XMM0,qword ptr [R8 + R12*0x8]
MOVSD qword ptr [RDI + R12*0x8],XMM0
MOVSD XMM0,qword ptr [R9 + R12*0x8]
MOVSD qword ptr [R10 + R12*0x8],XMM0
MOVSD XMM0,qword ptr [R11 + R12*0x8]
MOVSD qword ptr [R15 + R12*0x8],XMM0
MOV EBP,dword ptr [RCX + R12*0x4]
MOV dword ptr [RAX + R12*0x4],EBP
INC R12
MOVSXD R13,dword ptr [R14 + 0x18]
CMP R12,R13
JL 0x0010e2cc
JMP 0x0010e32f
LAB_0010e312:
MOV qword ptr [RBX + 0x8],0x0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x20],XMM0
MOVUPS xmmword ptr [RBX + 0x30],XMM0
MOV dword ptr [RBX + 0x18],EDI
MOV EAX,dword ptr [R14 + 0x1c]
MOV dword ptr [RBX + 0x1c],EAX
LAB_0010e32f:
MOV EAX,dword ptr [R14 + 0x40]
MOV dword ptr [RBX + 0x40],EAX
MOVSXD RDI,dword ptr [R14 + 0x44]
MOV dword ptr [RBX + 0x44],EDI
SHL RDI,0x3
CALL 0x00130c15
MOV qword ptr [RBX + 0x48],RAX
MOVSXD RDI,dword ptr [R14 + 0x40]
TEST RDI,RDI
JLE 0x0010e43d
SHL RDI,0x2
CALL 0x00130c15
CMP dword ptr [R14 + 0x40],0x0
MOV qword ptr [RBX + 0x10],RAX
JLE 0x0010e445
XOR R15D,R15D
LAB_0010e372:
MOV EDI,0x20
CALL 0x00130c15
MOV RCX,qword ptr [RBX + 0x48]
MOV qword ptr [RCX + R15*0x8],RAX
MOV RAX,qword ptr [R14 + 0x48]
MOV RAX,qword ptr [RAX + R15*0x8]
MOVSXD RDI,dword ptr [RAX]
MOV RAX,qword ptr [RBX + 0x48]
MOV RAX,qword ptr [RAX + R15*0x8]
MOV dword ptr [RAX],EDI
SHL RDI,0x3
CALL 0x00130c15
MOV RCX,qword ptr [RBX + 0x48]
MOV RCX,qword ptr [RCX + R15*0x8]
MOV qword ptr [RCX + 0x8],RAX
MOV RAX,qword ptr [R14 + 0x48]
MOV RAX,qword ptr [RAX + R15*0x8]
MOVSXD RDI,dword ptr [RAX]
SHL RDI,0x3
CALL 0x00130c15
MOV RCX,qword ptr [RBX + 0x48]
MOV RDX,qword ptr [RCX + R15*0x8]
MOV qword ptr [RDX + 0x10],RAX
MOV RAX,qword ptr [R14 + 0x48]
MOV RDX,qword ptr [RAX + R15*0x8]
MOV EAX,dword ptr [RDX + 0x18]
MOV RDI,qword ptr [RCX + R15*0x8]
MOV dword ptr [RDI + 0x18],EAX
MOV RAX,qword ptr [R14 + 0x10]
MOV EAX,dword ptr [RAX + R15*0x4]
MOV RCX,qword ptr [RBX + 0x10]
MOV dword ptr [RCX + R15*0x4],EAX
MOVSXD RAX,dword ptr [RDX]
TEST RAX,RAX
JLE 0x0010e42b
MOV RCX,qword ptr [RDX + 0x8]
MOV RDX,qword ptr [RDX + 0x10]
MOV RSI,qword ptr [RDI + 0x8]
MOV RDI,qword ptr [RDI + 0x10]
XOR R8D,R8D
LAB_0010e40b:
MOVSD XMM0,qword ptr [RCX + R8*0x8]
MOVSD qword ptr [RSI + R8*0x8],XMM0
MOVSD XMM0,qword ptr [RDX + R8*0x8]
MOVSD qword ptr [RDI + R8*0x8],XMM0
INC R8
CMP RAX,R8
JNZ 0x0010e40b
LAB_0010e42b:
INC R15
MOVSXD RAX,dword ptr [R14 + 0x40]
CMP R15,RAX
JL 0x0010e372
JMP 0x0010e445
LAB_0010e43d:
MOV qword ptr [RBX + 0x10],0x0
LAB_0010e445:
MOV RDI,qword ptr [R14]
CALL 0x001020e0
LEA RDI,[RAX + 0x1]
CALL 0x00130c15
MOV qword ptr [RBX],RAX
MOV RSI,qword ptr [R14]
MOV RDI,RAX
CALL 0x001021d0
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* LefDefParser::lefiViaLayer::clone() */
int8 * LefDefParser::lefiViaLayer::clone(void)
{
int iVar1;
long lVar2;
long lVar3;
long lVar4;
long lVar5;
long lVar6;
long lVar7;
long lVar8;
int *piVar9;
int8 *puVar10;
int8 uVar11;
long lVar12;
size_t sVar13;
char *__dest;
ulong in_RSI;
int8 *in_RDI;
long lVar14;
long lVar15;
puVar10 = (int8 *)lefMalloc((LefDefParser *)0x50,in_RSI);
iVar1 = *(int *)(in_RDI + 3);
if ((long)iVar1 < 1) {
puVar10[1] = 0;
puVar10[4] = 0;
puVar10[5] = 0;
puVar10[6] = 0;
puVar10[7] = 0;
*(int *)(puVar10 + 3) = iVar1;
*(int4 *)((long)puVar10 + 0x1c) = *(int4 *)((long)in_RDI + 0x1c);
}
else {
uVar11 = lefMalloc((LefDefParser *)((long)iVar1 << 3),in_RSI);
puVar10[4] = uVar11;
uVar11 = lefMalloc((LefDefParser *)((long)*(int *)(in_RDI + 3) << 3),in_RSI);
puVar10[5] = uVar11;
uVar11 = lefMalloc((LefDefParser *)((long)*(int *)(in_RDI + 3) << 3),in_RSI);
puVar10[6] = uVar11;
uVar11 = lefMalloc((LefDefParser *)((long)*(int *)(in_RDI + 3) << 3),in_RSI);
puVar10[7] = uVar11;
lVar12 = lefMalloc((LefDefParser *)((long)*(int *)(in_RDI + 3) << 2),in_RSI);
puVar10[1] = lVar12;
uVar11 = in_RDI[3];
puVar10[3] = uVar11;
if (0 < (int)uVar11) {
lVar2 = in_RDI[1];
lVar3 = in_RDI[4];
in_RSI = puVar10[4];
lVar4 = puVar10[5];
lVar14 = in_RDI[5];
lVar5 = in_RDI[6];
lVar6 = puVar10[6];
lVar7 = in_RDI[7];
lVar8 = puVar10[7];
lVar15 = 0;
do {
*(int8 *)(in_RSI + lVar15 * 8) = *(int8 *)(lVar3 + lVar15 * 8);
*(int8 *)(lVar4 + lVar15 * 8) = *(int8 *)(lVar14 + lVar15 * 8);
*(int8 *)(lVar6 + lVar15 * 8) = *(int8 *)(lVar5 + lVar15 * 8);
*(int8 *)(lVar8 + lVar15 * 8) = *(int8 *)(lVar7 + lVar15 * 8);
*(int4 *)(lVar12 + lVar15 * 4) = *(int4 *)(lVar2 + lVar15 * 4);
lVar15 = lVar15 + 1;
} while (lVar15 < *(int *)(in_RDI + 3));
}
}
*(int4 *)(puVar10 + 8) = *(int4 *)(in_RDI + 8);
iVar1 = *(int *)((long)in_RDI + 0x44);
*(int *)((long)puVar10 + 0x44) = iVar1;
uVar11 = lefMalloc((LefDefParser *)((long)iVar1 << 3),in_RSI);
puVar10[9] = uVar11;
if ((long)*(int *)(in_RDI + 8) < 1) {
puVar10[2] = 0;
}
else {
uVar11 = lefMalloc((LefDefParser *)((long)*(int *)(in_RDI + 8) << 2),in_RSI);
iVar1 = *(int *)(in_RDI + 8);
puVar10[2] = uVar11;
if (0 < iVar1) {
lVar12 = 0;
do {
uVar11 = lefMalloc((LefDefParser *)0x20,in_RSI);
*(int8 *)(puVar10[9] + lVar12 * 8) = uVar11;
iVar1 = **(int **)(in_RDI[9] + lVar12 * 8);
**(int **)(puVar10[9] + lVar12 * 8) = iVar1;
uVar11 = lefMalloc((LefDefParser *)((long)iVar1 << 3),in_RSI);
*(int8 *)(*(long *)(puVar10[9] + lVar12 * 8) + 8) = uVar11;
uVar11 = lefMalloc((LefDefParser *)((long)**(int **)(in_RDI[9] + lVar12 * 8) << 3),in_RSI);
lVar2 = puVar10[9];
*(int8 *)(*(long *)(lVar2 + lVar12 * 8) + 0x10) = uVar11;
piVar9 = *(int **)(in_RDI[9] + lVar12 * 8);
lVar2 = *(long *)(lVar2 + lVar12 * 8);
*(int *)(lVar2 + 0x18) = piVar9[6];
*(int4 *)(puVar10[2] + lVar12 * 4) = *(int4 *)(in_RDI[2] + lVar12 * 4);
iVar1 = *piVar9;
if (0 < (long)iVar1) {
lVar3 = *(long *)(piVar9 + 2);
lVar4 = *(long *)(piVar9 + 4);
in_RSI = *(ulong *)(lVar2 + 8);
lVar2 = *(long *)(lVar2 + 0x10);
lVar14 = 0;
do {
*(int8 *)(in_RSI + lVar14 * 8) = *(int8 *)(lVar3 + lVar14 * 8);
*(int8 *)(lVar2 + lVar14 * 8) = *(int8 *)(lVar4 + lVar14 * 8);
lVar14 = lVar14 + 1;
} while (iVar1 != lVar14);
}
lVar12 = lVar12 + 1;
} while (lVar12 < *(int *)(in_RDI + 8));
}
}
sVar13 = strlen((char *)*in_RDI);
__dest = (char *)lefMalloc((LefDefParser *)(sVar13 + 1),in_RSI);
*puVar10 = __dest;
strcpy(__dest,(char *)*in_RDI);
return puVar10;
}
| |
48,378 | ggml_op_can_inplace | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-alloc.c | static bool ggml_op_can_inplace(enum ggml_op op) {
switch (op) {
case GGML_OP_SCALE:
case GGML_OP_DIAG_MASK_ZERO:
case GGML_OP_DIAG_MASK_INF:
case GGML_OP_ADD:
case GGML_OP_ADD1:
case GGML_OP_SUB:
case GGML_OP_MUL:
case GGML_OP_DIV:
case GGML_OP_SQR:
case GGML_OP_SQRT:
case GGML_OP_LOG:
case GGML_OP_UNARY:
case GGML_OP_ROPE:
case GGML_OP_RMS_NORM:
case GGML_OP_SOFT_MAX:
return true;
default:
return false;
}
} | O0 | c | ggml_op_can_inplace:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
addl $-0x2, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x45, %eax
ja 0x5cf52
movq -0x10(%rbp), %rax
leaq 0x5737d(%rip), %rcx # 0xb42c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, -0x1(%rbp)
jmp 0x5cf56
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
| ggml_op_can_inplace:
push rbp
mov rbp, rsp
mov [rbp+var_8], edi
mov eax, [rbp+var_8]
add eax, 0FFFFFFFEh; switch 70 cases
mov ecx, eax
mov [rbp+var_10], rcx
sub eax, 45h
ja short def_5CF4A; jumptable 000000000005CF4A default case, cases 4,11-22,24-28,30-39,43,45-70
mov rax, [rbp+var_10]
lea rcx, jpt_5CF4A
movsxd rax, ds:(jpt_5CF4A - 0B42C0h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_5CF4C:
mov [rbp+var_1], 1; jumptable 000000000005CF4A cases 2,3,5-10,23,29,40-42,44,71
jmp short loc_5CF56
def_5CF4A:
mov [rbp+var_1], 0; jumptable 000000000005CF4A default case, cases 4,11-22,24-28,30-39,43,45-70
loc_5CF56:
mov al, [rbp+var_1]
and al, 1
pop rbp
retn
| char ggml_op_can_inplace(int a1)
{
char v2; // [rsp+Fh] [rbp-1h]
switch ( a1 )
{
case 2:
case 3:
case 5:
case 6:
case 7:
case 8:
case 9:
case 10:
case 23:
case 29:
case 40:
case 41:
case 42:
case 44:
case 71:
v2 = 1;
break;
default:
v2 = 0;
break;
}
return v2;
}
| ggml_op_can_inplace:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x8],EDI
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,-0x2
MOV ECX,EAX
MOV qword ptr [RBP + -0x10],RCX
SUB EAX,0x45
JA 0x0015cf52
MOV RAX,qword ptr [RBP + -0x10]
LEA RCX,[0x1b42c0]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_15cf4c:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0015cf56
caseD_15cf52:
MOV byte ptr [RBP + -0x1],0x0
LAB_0015cf56:
MOV AL,byte ptr [RBP + -0x1]
AND AL,0x1
POP RBP
RET
|
int8 ggml_op_can_inplace(int param_1)
{
ulong uVar1;
int1 local_9;
uVar1 = (ulong)(param_1 - 0x47U);
if (param_1 - 2U < 0x45 || param_1 - 0x47U == 0) {
uVar1 = (long)&switchD_0015cf4a::switchdataD_001b42c0 +
(long)(int)(&switchD_0015cf4a::switchdataD_001b42c0)[param_1 - 2U];
switch(uVar1) {
case 0x15cf4c:
local_9 = 1;
goto LAB_0015cf56;
}
}
local_9 = 0;
LAB_0015cf56:
return CONCAT71((int7)(uVar1 >> 8),local_9);
}
| |
48,379 | Catch::BinaryExpr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [1]>::streamReconstructedExpression(std::ostream&) const | 11AgReS1SoR11[P]Graph/build_O1/_deps/catch2-src/src/catch2/../catch2/internal/catch_decomposer.hpp | void streamReconstructedExpression( std::ostream &os ) const override {
formatReconstructedExpression
( os, Catch::Detail::stringify( m_lhs ), m_op, Catch::Detail::stringify( m_rhs ) );
} | O1 | cpp | Catch::BinaryExpr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [1]>::streamReconstructedExpression(std::ostream&) const:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r12
movq 0x10(%rdi), %rsi
leaq 0x20(%rsp), %rdi
callq 0x43110
movq 0x18(%r12), %r14
movq 0x20(%r12), %r15
movq 0x28(%r12), %r12
movl $0x15, %r13d
movl $0x15, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0x11580
movq %rax, %rdx
subq %r12, %rdx
testq %rax, %rax
cmoveq %r13, %rdx
movq %rsp, %rdi
movq %r12, %rsi
callq 0x42fbd
leaq 0x20(%rsp), %rsi
movq %rsp, %r8
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
callq 0x5091c
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3c6e0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x114e0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3c6fb
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x114e0
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3c72c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x114e0
jmp 0x3c72c
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3c747
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x114e0
movq %rbx, %rdi
callq 0x11910
nop
| _ZNK5Catch10BinaryExprIRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERA21_KcE29streamReconstructedExpressionERSo:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 40h
mov rbx, rsi
mov r12, rdi
mov rsi, [rdi+10h]
lea rdi, [rsp+68h+var_48]
call _ZN5Catch11StringMakerINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEvE7convertERKS6_; Catch::StringMaker<std::string,void>::convert(std::string const&)
mov r14, [r12+18h]
mov r15, [r12+20h]
mov r12, [r12+28h]
mov r13d, 15h
mov edx, 15h
mov rdi, r12
xor esi, esi
call _memchr
mov rdx, rax
sub rdx, r12
test rax, rax
cmovz rdx, r13
mov rdi, rsp
mov rsi, r12
call _ZN5Catch6Detail17convertIntoStringB5cxx11ENS_9StringRefE; Catch::Detail::convertIntoString(Catch::StringRef)
lea rsi, [rsp+68h+var_48]
mov r8, rsp
mov rdi, rbx
mov rdx, r14
mov rcx, r15
call _ZN5Catch29formatReconstructedExpressionERSoRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS_9StringRefES8_; Catch::formatReconstructedExpression(std::ostream &,std::string const&,Catch::StringRef,std::string const&)
lea rax, [rsp+68h+var_58]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_3C6E0
mov rsi, [rsp+68h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3C6E0:
lea rax, [rsp+68h+var_38]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_3C6FB
mov rsi, [rsp+68h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3C6FB:
add rsp, 40h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
mov rbx, rax
lea rax, [rsp+arg_8]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_3C72C
mov rsi, [rsp+arg_8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_3C72C
mov rbx, rax
loc_3C72C:
lea rax, [rsp+arg_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_3C747
mov rsi, [rsp+arg_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3C747:
mov rdi, rbx
call __Unwind_Resume
| void Catch::BinaryExpr<std::string const&,char const(&)[21]>::streamReconstructedExpression(
_QWORD *a1,
long long a2)
{
long long v2; // r14
long long v3; // r15
long long v4; // r12
long long v5; // rax
long long v6; // rdx
void *v7[2]; // [rsp+0h] [rbp-68h] BYREF
long long v8; // [rsp+10h] [rbp-58h] BYREF
void *v9[2]; // [rsp+20h] [rbp-48h] BYREF
long long v10; // [rsp+30h] [rbp-38h] BYREF
Catch::StringMaker<std::string,void>::convert(v9, a1[2]);
v2 = a1[3];
v3 = a1[4];
v4 = a1[5];
v5 = memchr(v4, 0LL, 21LL);
v6 = v5 - v4;
if ( !v5 )
v6 = 21LL;
Catch::Detail::convertIntoString[abi:cxx11](v7, v4, v6);
Catch::formatReconstructedExpression(a2, v9, v2, v3, v7);
if ( v7[0] != &v8 )
operator delete(v7[0], v8 + 1);
if ( v9[0] != &v10 )
operator delete(v9[0], v10 + 1);
}
| streamReconstructedExpression:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x40
MOV RBX,RSI
MOV R12,RDI
MOV RSI,qword ptr [RDI + 0x10]
LEA RDI,[RSP + 0x20]
CALL 0x00143110
MOV R14,qword ptr [R12 + 0x18]
MOV R15,qword ptr [R12 + 0x20]
MOV R12,qword ptr [R12 + 0x28]
MOV R13D,0x15
MOV EDX,0x15
MOV RDI,R12
XOR ESI,ESI
CALL 0x00111580
MOV RDX,RAX
SUB RDX,R12
TEST RAX,RAX
CMOVZ RDX,R13
LAB_0013c6a4:
MOV RDI,RSP
MOV RSI,R12
CALL 0x00142fbd
LAB_0013c6af:
LEA RSI,[RSP + 0x20]
MOV R8,RSP
MOV RDI,RBX
MOV RDX,R14
MOV RCX,R15
CALL 0x0015091c
LAB_0013c6c5:
LEA RAX,[RSP + 0x10]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0013c6e0
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x001114e0
LAB_0013c6e0:
LEA RAX,[RSP + 0x30]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0013c6fb
MOV RSI,qword ptr [RSP + 0x30]
INC RSI
CALL 0x001114e0
LAB_0013c6fb:
ADD RSP,0x40
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* Catch::BinaryExpr<std::__cxx11::string const&, char const (&)
[21]>::streamReconstructedExpression(std::ostream&) const */
void __thiscall
Catch::BinaryExpr<std::__cxx11::string_const&,char_const(&)[21]>::streamReconstructedExpression
(BinaryExpr<std::__cxx11::string_const&,char_const(&)[21]> *this,ostream *param_1)
{
int8 uVar1;
int8 uVar2;
void *__s;
void *pvVar3;
long lVar4;
long *local_68 [2];
long local_58 [2];
long *local_48 [2];
long local_38 [2];
StringMaker<std::__cxx11::string,void>::convert
((StringMaker<std::__cxx11::string,void> *)local_48,*(string **)(this + 0x10));
uVar1 = *(int8 *)(this + 0x18);
uVar2 = *(int8 *)(this + 0x20);
__s = *(void **)(this + 0x28);
pvVar3 = memchr(__s,0,0x15);
lVar4 = (long)pvVar3 - (long)__s;
if (pvVar3 == (void *)0x0) {
lVar4 = 0x15;
}
/* try { // try from 0013c6a4 to 0013c6ae has its CatchHandler @ 0013c729 */
Detail::convertIntoString_abi_cxx11_(local_68,__s,lVar4);
/* try { // try from 0013c6af to 0013c6c4 has its CatchHandler @ 0013c709 */
formatReconstructedExpression((Catch *)param_1,local_48,uVar1,uVar2,local_68);
if (local_68[0] != local_58) {
operator_delete(local_68[0],local_58[0] + 1);
}
if (local_48[0] != local_38) {
operator_delete(local_48[0],local_38[0] + 1);
}
return;
}
| |
48,380 | c4_get_storage_config | corpus-core[P]colibri-stateless/src/util/plugin.c | void c4_get_storage_config(storage_plugin_t* plugin) {
if (!storage_conf.max_sync_states) storage_conf.max_sync_states = MAX_SYNC_STATES_DEFAULT;
#ifdef FILE_STORAGE
if (!storage_conf.get) {
storage_conf.get = file_get;
storage_conf.set = file_set;
storage_conf.del = file_delete;
}
#endif
*plugin = storage_conf;
} | O0 | c | c4_get_storage_config:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x94b59(%rip) # 0x139988
jne 0xa4e3b
movl $0x3, 0x94b4d(%rip) # 0x139988
cmpq $0x0, 0x94b2d(%rip) # 0x139970
jne 0xa4e6f
leaq 0x54(%rip), %rax # 0xa4ea0
movq %rax, 0x94b1d(%rip) # 0x139970
leaq 0x1c6(%rip), %rax # 0xa5020
movq %rax, 0x94b17(%rip) # 0x139978
leaq 0x238(%rip), %rax # 0xa50a0
movq %rax, 0x94b11(%rip) # 0x139980
movq -0x8(%rbp), %rax
movq 0x94af6(%rip), %rcx # 0x139970
movq %rcx, (%rax)
movq 0x94af4(%rip), %rcx # 0x139978
movq %rcx, 0x8(%rax)
movq 0x94af1(%rip), %rcx # 0x139980
movq %rcx, 0x10(%rax)
movq 0x94aee(%rip), %rcx # 0x139988
movq %rcx, 0x18(%rax)
popq %rbp
retq
| c4_get_storage_config:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
cmp dword ptr cs:qword_139988, 0
jnz short loc_A4E3B
mov dword ptr cs:qword_139988, 3
loc_A4E3B:
cmp cs:storage_conf, 0
jnz short loc_A4E6F
lea rax, file_get
mov cs:storage_conf, rax
lea rax, file_set
mov cs:qword_139978, rax
lea rax, file_delete
mov cs:qword_139980, rax
loc_A4E6F:
mov rax, [rbp+var_8]
mov rcx, cs:storage_conf
mov [rax], rcx
mov rcx, cs:qword_139978
mov [rax+8], rcx
mov rcx, cs:qword_139980
mov [rax+10h], rcx
mov rcx, cs:qword_139988
mov [rax+18h], rcx
pop rbp
retn
| _QWORD * c4_get_storage_config(_QWORD *a1)
{
_QWORD *result; // rax
if ( !(_DWORD)qword_139988 )
LODWORD(qword_139988) = 3;
if ( !storage_conf )
{
storage_conf = (long long)file_get;
qword_139978 = (long long)file_set;
qword_139980 = (long long)file_delete;
}
result = a1;
*a1 = storage_conf;
a1[1] = qword_139978;
a1[2] = qword_139980;
a1[3] = qword_139988;
return result;
}
| c4_get_storage_config:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
CMP dword ptr [0x00239988],0x0
JNZ 0x001a4e3b
MOV dword ptr [0x00239988],0x3
LAB_001a4e3b:
CMP qword ptr [0x00239970],0x0
JNZ 0x001a4e6f
LEA RAX,[0x1a4ea0]
MOV qword ptr [0x00239970],RAX
LEA RAX,[0x1a5020]
MOV qword ptr [0x00239978],RAX
LEA RAX,[0x1a50a0]
MOV qword ptr [0x00239980],RAX
LAB_001a4e6f:
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [0x00239970]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [0x00239978]
MOV qword ptr [RAX + 0x8],RCX
MOV RCX,qword ptr [0x00239980]
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,qword ptr [0x00239988]
MOV qword ptr [RAX + 0x18],RCX
POP RBP
RET
|
void c4_get_storage_config(long *param_1)
{
if ((int)DAT_00239988 == 0) {
DAT_00239988._0_4_ = 3;
}
if (storage_conf == (code *)0x0) {
storage_conf = file_get;
DAT_00239978 = file_set;
DAT_00239980 = file_delete;
}
*param_1 = (long)storage_conf;
param_1[1] = (long)DAT_00239978;
param_1[2] = (long)DAT_00239980;
param_1[3] = CONCAT44(DAT_00239988._4_4_,(int)DAT_00239988);
return;
}
| |
48,381 | glfwPlatformSetCursorPos | untodesu[P]riteg/build_O3/_deps/glfw-src/src/x11_window.c | void _glfwPlatformSetCursorPos(_GLFWwindow* window, double x, double y)
{
// Store the new position so it can be recognized later
window->x11.warpCursorPosX = (int) x;
window->x11.warpCursorPosY = (int) y;
XWarpPointer(_glfw.x11.display, None, window->x11.handle,
0,0,0,0, (int) x, (int) y);
XFlush(_glfw.x11.display);
} | O3 | c | glfwPlatformSetCursorPos:
pushq %rbx
subq $0x20, %rsp
unpcklpd %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
cvttpd2dq %xmm0, %xmm0
movlpd %xmm0, 0x380(%rdi)
leaq 0x836aa(%rip), %rbx # 0xa8638
movq 0x1fec0(%rbx), %rax
movq 0x348(%rdi), %rdx
pshufd $0x55, %xmm0, %xmm1 # xmm1 = xmm0[1,1,1,1]
movd %xmm1, 0x10(%rsp)
movd %xmm0, 0x8(%rsp)
movl $0x0, (%rsp)
movq %rax, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xcc60
movq 0x1fec0(%rbx), %rdi
addq $0x20, %rsp
popq %rbx
jmp 0xcce0
| _glfwPlatformSetCursorPos:
push rbx
sub rsp, 20h
unpcklpd xmm0, xmm1
cvttpd2dq xmm0, xmm0
movlpd qword ptr [rdi+380h], xmm0
lea rbx, _glfw
mov rax, [rbx+1FEC0h]
mov rdx, [rdi+348h]
pshufd xmm1, xmm0, 55h ; 'U'
movd [rsp+28h+var_18], xmm1
movd [rsp+28h+var_20], xmm0
mov [rsp+28h+var_28], 0
mov rdi, rax
xor esi, esi
xor ecx, ecx
xor r8d, r8d
xor r9d, r9d
call _XWarpPointer
mov rdi, [rbx+1FEC0h]
add rsp, 20h
pop rbx
jmp _XFlush
| long long glfwPlatformSetCursorPos(long long a1, __m128d a2, __m128d a3)
{
__m128i v3; // xmm0
v3 = _mm_cvttpd_epi32(_mm_unpacklo_pd(a2, a3));
*(_QWORD *)(a1 + 896) = v3.m128i_i64[0];
XWarpPointer(
*(_QWORD *)&glfw[32688],
0LL,
*(_QWORD *)(a1 + 840),
0LL,
0LL,
0LL,
0,
_mm_cvtsi128_si32(v3),
_mm_cvtsi128_si32(_mm_shuffle_epi32(v3, 85)));
return XFlush(*(_QWORD *)&glfw[32688]);
}
| _glfwPlatformSetCursorPos:
PUSH RBX
SUB RSP,0x20
UNPCKLPD XMM0,XMM1
CVTTPD2DQ XMM0,XMM0
MOVLPD qword ptr [RDI + 0x380],XMM0
LEA RBX,[0x1a8638]
MOV RAX,qword ptr [RBX + 0x1fec0]
MOV RDX,qword ptr [RDI + 0x348]
PSHUFD XMM1,XMM0,0x55
MOVD dword ptr [RSP + 0x10],XMM1
MOVD dword ptr [RSP + 0x8],XMM0
MOV dword ptr [RSP],0x0
MOV RDI,RAX
XOR ESI,ESI
XOR ECX,ECX
XOR R8D,R8D
XOR R9D,R9D
CALL 0x0010cc60
MOV RDI,qword ptr [RBX + 0x1fec0]
ADD RSP,0x20
POP RBX
JMP 0x0010cce0
|
void _glfwPlatformSetCursorPos(double param_1,double param_2,long param_3)
{
*(ulong *)(param_3 + 0x380) = CONCAT44((int)param_2,(int)param_1);
XWarpPointer(DAT_001c84f8,0,*(int8 *)(param_3 + 0x348),0,0,0,0,(int)param_1,(int)param_2);
XFlush(DAT_001c84f8);
return;
}
| |
48,382 | ParseGetIdentifierId | navaro[P]qoraal-tictactoe/build_O3/_deps/qoraal_engine-src/src/tool/parse.c | enum parseType
ParseGetIdentifierId (const char * name, uint32_t len, uint32_t * Id)
{
struct Value Value ;
enum parseType type ;
*Id = 0 ;
if (len == 0) len = strlen (name) ;
if (parse_get_identifier(name, len, &Value)) {
*Id = PARSER_ID_VALUE(Value.Id) ;
type = PARSER_ID_TYPE(Value.Id) ;
return type ;
}
return parseInvalid ;
} | O3 | c | ParseGetIdentifierId:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movl $0x0, (%rdx)
testl %esi, %esi
jne 0xce92
movq %r14, %rdi
callq 0x61a0
movq %rax, %rsi
leaq -0x28(%rbp), %rdx
movq %r14, %rdi
callq 0xcebd
testl %eax, %eax
je 0xceb2
movl -0x18(%rbp), %eax
movzwl %ax, %ecx
movl %ecx, (%rbx)
shrl $0x10, %eax
movzbl %al, %eax
jmp 0xceb4
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
| ParseGetIdentifierId:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 20h
mov rbx, rdx
mov r14, rdi
mov dword ptr [rdx], 0
test esi, esi
jnz short loc_CE92
mov rdi, r14
call _strlen
mov rsi, rax
loc_CE92:
lea rdx, [rbp+var_28]
mov rdi, r14
call parse_get_identifier
test eax, eax
jz short loc_CEB2
mov eax, [rbp+var_18]
movzx ecx, ax
mov [rbx], ecx
shr eax, 10h
movzx eax, al
jmp short loc_CEB4
loc_CEB2:
xor eax, eax
loc_CEB4:
add rsp, 20h
pop rbx
pop r14
pop rbp
retn
| long long ParseGetIdentifierId(long long a1, long long a2, _DWORD *a3)
{
unsigned __int8 v4; // eax^2
_BYTE v6[16]; // [rsp+8h] [rbp-28h] BYREF
unsigned __int16 v7; // [rsp+18h] [rbp-18h]
unsigned __int8 v8; // [rsp+1Ah] [rbp-16h]
*a3 = 0;
if ( !(_DWORD)a2 )
a2 = strlen(a1);
if ( !(unsigned int)parse_get_identifier(a1, a2, v6) )
return 0LL;
v4 = v8;
*a3 = v7;
return v4;
}
| ParseGetIdentifierId:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x20
MOV RBX,RDX
MOV R14,RDI
MOV dword ptr [RDX],0x0
TEST ESI,ESI
JNZ 0x0010ce92
MOV RDI,R14
CALL 0x001061a0
MOV RSI,RAX
LAB_0010ce92:
LEA RDX,[RBP + -0x28]
MOV RDI,R14
CALL 0x0010cebd
TEST EAX,EAX
JZ 0x0010ceb2
MOV EAX,dword ptr [RBP + -0x18]
MOVZX ECX,AX
MOV dword ptr [RBX],ECX
SHR EAX,0x10
MOVZX EAX,AL
JMP 0x0010ceb4
LAB_0010ceb2:
XOR EAX,EAX
LAB_0010ceb4:
ADD RSP,0x20
POP RBX
POP R14
POP RBP
RET
|
uint ParseGetIdentifierId(char *param_1,size_t param_2,uint *param_3)
{
int iVar1;
uint uVar2;
int1 local_30 [16];
uint local_20;
*param_3 = 0;
if ((int)param_2 == 0) {
param_2 = strlen(param_1);
}
iVar1 = parse_get_identifier(param_1,param_2,local_30);
if (iVar1 == 0) {
uVar2 = 0;
}
else {
*param_3 = local_20 & 0xffff;
uVar2 = local_20 >> 0x10 & 0xff;
}
return uVar2;
}
| |
48,383 | init_one_value | eloqsql/mysys/my_getopt.c | static void init_one_value(const struct my_option *option, void *variable,
longlong value)
{
DBUG_ENTER("init_one_value");
switch ((option->var_type & GET_TYPE_MASK)) {
case GET_BOOL:
*((my_bool*) variable)= (my_bool) value;
break;
case GET_INT:
*((int*) variable)= (int) getopt_ll_limit_value((int) value, option, NULL);
break;
case GET_ENUM:
*((ulong*) variable)= (ulong) value;
break;
case GET_UINT:
*((uint*) variable)= (uint) getopt_ull_limit_value((uint) value, option, NULL);
break;
case GET_LONG:
*((long*) variable)= (long) getopt_ll_limit_value((long) value, option, NULL);
break;
case GET_ULONG:
*((ulong*) variable)= (ulong) getopt_ull_limit_value((ulong) value, option, NULL);
break;
case GET_LL:
*((longlong*) variable)= (longlong) getopt_ll_limit_value((longlong) value, option, NULL);
break;
case GET_ULL:
*((ulonglong*) variable)= (ulonglong) getopt_ull_limit_value((ulonglong) value, option, NULL);
break;
case GET_SET:
case GET_FLAGSET:
*((ulonglong*) variable)= (ulonglong) value;
break;
case GET_BIT:
{
ulonglong bit= (option->block_size >= 0 ?
option->block_size :
-option->block_size);
if (option->block_size < 0)
value= !value;
if (value)
(*(ulonglong*)variable)|= bit;
else
(*(ulonglong*)variable)&= ~bit;
break;
}
case GET_DOUBLE:
*((double*) variable)= getopt_ulonglong2double(value);
break;
case GET_STR:
/*
Do not clear variable value if it has no default value.
The default value may already be set.
NOTE: To avoid compiler warnings, we first cast longlong to intptr,
so that the value has the same size as a pointer.
*/
if ((char*) (intptr) value)
*((char**) variable)= (char*) (intptr) value;
break;
case GET_STR_ALLOC:
/*
Do not clear variable value if it has no default value.
The default value may already be set.
NOTE: To avoid compiler warnings, we first cast longlong to intptr,
so that the value has the same size as a pointer.
*/
if ((char*) (intptr) value)
{
char **pstr= (char **) variable;
my_free(*pstr);
*pstr= my_strdup(key_memory_defaults, (char*) (intptr) value, MYF(MY_WME));
}
break;
default: /* dummy default to avoid compiler warnings */
break;
}
DBUG_VOID_RETURN;
} | O3 | c | init_one_value:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x30(%rdi), %rax
andl $0x3f, %eax
addq $-0x2, %rax
cmpq $0xe, %rax
ja 0xa7547
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x462e0(%rip), %rcx # 0xed77c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, (%rbx)
jmp 0xa7547
movq %r14, %rdi
xorl %edx, %edx
callq 0xa7a33
jmp 0xa7544
movq %r14, %rdi
xorl %edx, %edx
callq 0xa7b54
jmp 0xa7544
movq 0x60(%rsi), %rcx
movq %rcx, %rax
negq %rax
cmovsq %rcx, %rax
xorl %edx, %edx
testq %r14, %r14
sete %dl
testq %rcx, %rcx
cmovnsq %r14, %rdx
testq %rdx, %rdx
je 0xa753e
orq (%rbx), %rax
jmp 0xa7544
movb %r14b, (%rbx)
jmp 0xa7547
movl %r14d, %edi
xorl %edx, %edx
callq 0xa7b54
jmp 0xa752f
testq %r14, %r14
je 0xa7547
movq (%rbx), %rdi
callq 0xaa406
leaq 0xb6ecc4(%rip), %rax # 0xc161d8
movl (%rax), %edi
movl $0x10, %edx
movq %r14, %rsi
callq 0xaa49c
jmp 0xa7544
movslq %r14d, %rdi
xorl %edx, %edx
callq 0xa7a33
movl %eax, (%rbx)
jmp 0xa7547
testq %r14, %r14
jne 0xa74a5
jmp 0xa7547
notq %rax
andq (%rbx), %rax
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
| init_one_value:
push rbp
mov rbp, rsp
push r14
push rbx
mov rax, [rdi+30h]
and eax, 3Fh
add rax, 0FFFFFFFFFFFFFFFEh; switch 15 cases
cmp rax, 0Eh
ja def_A74A3; jumptable 00000000000A74A3 default case, case 11
mov r14, rdx
mov rbx, rsi
mov rsi, rdi
lea rcx, jpt_A74A3
movsxd rax, ds:(jpt_A74A3 - 0ED77Ch)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_A74A5:
mov [rbx], r14; jumptable 00000000000A74A3 cases 12-15
jmp def_A74A3; jumptable 00000000000A74A3 default case, case 11
loc_A74AD:
mov rdi, r14; jumptable 00000000000A74A3 cases 5,7
xor edx, edx
call getopt_ll_limit_value
jmp loc_A7544
loc_A74BC:
mov rdi, r14; jumptable 00000000000A74A3 cases 6,8
xor edx, edx
call getopt_ull_limit_value
jmp short loc_A7544
loc_A74C8:
mov rcx, [rsi+60h]; jumptable 00000000000A74A3 case 16
mov rax, rcx
neg rax
cmovs rax, rcx
xor edx, edx
test r14, r14
setz dl
test rcx, rcx
cmovns rdx, r14
test rdx, rdx
jz short loc_A753E
or rax, [rbx]
jmp short loc_A7544
loc_A74EF:
mov [rbx], r14b; jumptable 00000000000A74A3 case 2
jmp short def_A74A3; jumptable 00000000000A74A3 default case, case 11
loc_A74F4:
mov edi, r14d; jumptable 00000000000A74A3 case 4
xor edx, edx
call getopt_ull_limit_value
jmp short loc_A752F
loc_A7500:
test r14, r14; jumptable 00000000000A74A3 case 10
jz short def_A74A3; jumptable 00000000000A74A3 default case, case 11
mov rdi, [rbx]
call my_free
lea rax, key_memory_defaults
mov edi, [rax]
mov edx, 10h
mov rsi, r14
call my_strdup
jmp short loc_A7544
loc_A7525:
movsxd rdi, r14d; jumptable 00000000000A74A3 case 3
xor edx, edx
call getopt_ll_limit_value
loc_A752F:
mov [rbx], eax
jmp short def_A74A3; jumptable 00000000000A74A3 default case, case 11
loc_A7533:
test r14, r14; jumptable 00000000000A74A3 case 9
jnz loc_A74A5; jumptable 00000000000A74A3 cases 12-15
jmp short def_A74A3; jumptable 00000000000A74A3 default case, case 11
loc_A753E:
not rax
and rax, [rbx]
loc_A7544:
mov [rbx], rax
def_A74A3:
pop rbx; jumptable 00000000000A74A3 default case, case 11
pop r14
pop rbp
retn
| long long init_one_value(long long a1, long long *a2, _BOOL8 a3)
{
long long result; // rax
long long v5; // rax
_BOOL8 v6; // rdx
result = (*(_QWORD *)(a1 + 48) & 0x3FLL) - 2;
switch ( *(_QWORD *)(a1 + 48) & 0x3FLL )
{
case 2LL:
*(_BYTE *)a2 = a3;
return result;
case 3LL:
result = getopt_ll_limit_value(a3, a1, 0LL);
goto LABEL_16;
case 4LL:
result = getopt_ull_limit_value(a3, a1, 0LL);
LABEL_16:
*(_DWORD *)a2 = result;
return result;
case 5LL:
case 7LL:
result = getopt_ll_limit_value(a3, a1, 0LL);
goto LABEL_20;
case 6LL:
case 8LL:
result = getopt_ull_limit_value(a3, a1, 0LL);
goto LABEL_20;
case 9LL:
if ( !a3 )
return result;
goto LABEL_2;
case 0xALL:
if ( !a3 )
return result;
my_free(*a2);
result = my_strdup(key_memory_defaults, a3, 16LL);
goto LABEL_20;
case 0xCLL:
case 0xDLL:
case 0xELL:
case 0xFLL:
LABEL_2:
*a2 = a3;
return result;
case 0x10LL:
v5 = -*(_QWORD *)(a1 + 96);
if ( *(long long *)(a1 + 96) > 0 )
v5 = *(_QWORD *)(a1 + 96);
v6 = !a3;
if ( *(long long *)(a1 + 96) >= 0 )
v6 = a3;
if ( v6 )
result = *a2 | v5;
else
result = *a2 & ~v5;
LABEL_20:
*a2 = result;
break;
default:
return result;
}
return result;
}
| init_one_value:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RAX,qword ptr [RDI + 0x30]
AND EAX,0x3f
ADD RAX,-0x2
CMP RAX,0xe
JA 0x001a7547
MOV R14,RDX
MOV RBX,RSI
MOV RSI,RDI
LEA RCX,[0x1ed77c]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_c:
MOV qword ptr [RBX],R14
JMP 0x001a7547
caseD_5:
MOV RDI,R14
XOR EDX,EDX
CALL 0x001a7a33
JMP 0x001a7544
caseD_6:
MOV RDI,R14
XOR EDX,EDX
CALL 0x001a7b54
JMP 0x001a7544
caseD_10:
MOV RCX,qword ptr [RSI + 0x60]
MOV RAX,RCX
NEG RAX
CMOVS RAX,RCX
XOR EDX,EDX
TEST R14,R14
SETZ DL
TEST RCX,RCX
CMOVNS RDX,R14
TEST RDX,RDX
JZ 0x001a753e
OR RAX,qword ptr [RBX]
JMP 0x001a7544
caseD_2:
MOV byte ptr [RBX],R14B
JMP 0x001a7547
caseD_4:
MOV EDI,R14D
XOR EDX,EDX
CALL 0x001a7b54
JMP 0x001a752f
caseD_a:
TEST R14,R14
JZ 0x001a7547
MOV RDI,qword ptr [RBX]
CALL 0x001aa406
LEA RAX,[0xd161d8]
MOV EDI,dword ptr [RAX]
MOV EDX,0x10
MOV RSI,R14
CALL 0x001aa49c
JMP 0x001a7544
caseD_3:
MOVSXD RDI,R14D
XOR EDX,EDX
CALL 0x001a7a33
LAB_001a752f:
MOV dword ptr [RBX],EAX
JMP 0x001a7547
caseD_9:
TEST R14,R14
JNZ 0x001a74a5
JMP 0x001a7547
LAB_001a753e:
NOT RAX
AND RAX,qword ptr [RBX]
LAB_001a7544:
MOV qword ptr [RBX],RAX
caseD_b:
POP RBX
POP R14
POP RBP
RET
|
void init_one_value(long param_1,ulong *param_2,ulong param_3)
{
ulong uVar1;
int4 uVar2;
ulong uVar3;
ulong uVar4;
switch((uint)*(int8 *)(param_1 + 0x30) & 0x3f) {
case 2:
*(char *)param_2 = (char)param_3;
return;
case 3:
uVar2 = getopt_ll_limit_value((long)(int)param_3,param_1,0);
goto LAB_001a752f;
case 4:
uVar2 = getopt_ull_limit_value(param_3 & 0xffffffff,param_1,0);
LAB_001a752f:
*(int4 *)param_2 = uVar2;
return;
case 5:
case 7:
uVar3 = getopt_ll_limit_value(param_3,param_1,0);
break;
case 6:
case 8:
uVar3 = getopt_ull_limit_value(param_3,param_1,0);
break;
case 9:
if (param_3 == 0) {
return;
}
case 0xc:
case 0xd:
case 0xe:
case 0xf:
*param_2 = param_3;
return;
case 10:
if (param_3 == 0) {
return;
}
my_free(*param_2);
uVar3 = my_strdup(key_memory_defaults,param_3,0x10);
break;
default:
goto switchD_001a74a3_caseD_b;
case 0x10:
uVar1 = *(ulong *)(param_1 + 0x60);
uVar3 = -uVar1;
if (0 < (long)uVar1) {
uVar3 = uVar1;
}
uVar4 = (ulong)(param_3 == 0);
if (-1 < (long)uVar1) {
uVar4 = param_3;
}
if (uVar4 == 0) {
uVar3 = ~uVar3 & *param_2;
}
else {
uVar3 = uVar3 | *param_2;
}
}
*param_2 = uVar3;
switchD_001a74a3_caseD_b:
return;
}
| |
48,384 | lre_parse_escape | bluesky950520[P]quickjs/libregexp.c | int lre_parse_escape(const uint8_t **pp, int allow_utf16)
{
const uint8_t *p;
uint32_t c;
p = *pp;
c = *p++;
switch(c) {
case 'b':
c = '\b';
break;
case 'f':
c = '\f';
break;
case 'n':
c = '\n';
break;
case 'r':
c = '\r';
break;
case 't':
c = '\t';
break;
case 'v':
c = '\v';
break;
case 'x':
case 'u':
{
int h, n, i;
uint32_t c1;
if (*p == '{' && allow_utf16) {
p++;
c = 0;
for(;;) {
h = from_hex(*p++);
if (h < 0)
return -1;
c = (c << 4) | h;
if (c > 0x10FFFF)
return -1;
if (*p == '}')
break;
}
p++;
} else {
if (c == 'x') {
n = 2;
} else {
n = 4;
}
c = 0;
for(i = 0; i < n; i++) {
h = from_hex(*p++);
if (h < 0) {
return -1;
}
c = (c << 4) | h;
}
if (is_hi_surrogate(c) &&
allow_utf16 == 2 && p[0] == '\\' && p[1] == 'u') {
/* convert an escaped surrogate pair into a
unicode char */
c1 = 0;
for(i = 0; i < 4; i++) {
h = from_hex(p[2 + i]);
if (h < 0)
break;
c1 = (c1 << 4) | h;
}
if (i == 4 && is_lo_surrogate(c1)) {
p += 6;
c = from_surrogate(c, c1);
}
}
}
}
break;
case '0': case '1': case '2': case '3':
case '4': case '5': case '6': case '7':
c -= '0';
if (allow_utf16 == 2) {
/* only accept \0 not followed by digit */
if (c != 0 || lre_is_digit(*p))
return -1;
} else {
/* parse a legacy octal sequence */
uint32_t v;
v = *p - '0';
if (v > 7)
break;
c = (c << 3) | v;
p++;
if (c >= 32)
break;
v = *p - '0';
if (v > 7)
break;
c = (c << 3) | v;
p++;
}
break;
default:
return -2;
}
*pp = p;
return c;
} | O1 | c | lre_parse_escape:
pushq %r14
pushq %rbx
movq (%rdi), %r8
leaq 0x1(%r8), %rcx
movzbl (%r8), %edx
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
cmpl $0x61, %edx
jg 0x985eb
addl $-0x30, %edx
cmpl $0x8, %edx
jae 0x98859
cmpl $0x2, %esi
jne 0x9868a
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testl %edx, %edx
jne 0x98859
movzbl (%rcx), %esi
addl $-0x3a, %esi
xorl %edx, %edx
cmpl $-0xa, %esi
jb 0x98854
jmp 0x98859
leal -0x6e(%rdx), %r9d
cmpl $0xa, %r9d
ja 0x986c7
leaq 0xedd0(%rip), %r10 # 0xa73d0
movslq (%r10,%r9,4), %r9
addq %r10, %r9
jmpq *%r9
testl %esi, %esi
je 0x986e3
cmpb $0x7b, (%rcx)
jne 0x986e3
addq $0x3, %r8
xorl %edx, %edx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
movq %r8, %rcx
movzbl -0x1(%rcx), %r8d
leal -0x30(%r8), %esi
cmpl $0xa, %esi
jb 0x98658
leal -0x41(%r8), %esi
cmpl $0x5, %esi
ja 0x98646
addl $-0x37, %r8d
jmp 0x98655
leal -0x61(%r8), %esi
addl $-0x57, %r8d
cmpl $0x6, %esi
cmovael %eax, %r8d
movl %r8d, %esi
testl %esi, %esi
js 0x98801
shll $0x4, %edx
orl %edx, %esi
cmpl $0x10ffff, %esi # imm = 0x10FFFF
ja 0x98806
leaq 0x1(%rcx), %r8
cmpb $0x7d, (%rcx)
movq %r8, %rcx
movl %esi, %edx
jne 0x98629
movb $0x1, %r9b
movq %r8, %rcx
jmp 0x98809
movzbl (%rcx), %eax
addl $-0x30, %eax
cmpl $0x7, %eax
ja 0x98854
leal (%rax,%rdx,8), %edx
leaq 0x2(%r8), %rcx
cmpl $0x1f, %edx
ja 0x98854
movzbl (%rcx), %eax
addl $-0x30, %eax
cmpl $0x7, %eax
ja 0x98854
leal (%rax,%rdx,8), %edx
addq $0x3, %r8
movq %r8, %rcx
jmp 0x98854
cmpl $0x62, %edx
je 0x987fa
cmpl $0x66, %edx
jne 0x98859
movl $0xc, %edx
jmp 0x98854
xorl %eax, %eax
cmpl $0x78, %edx
setne %al
leal 0x2(,%rax,2), %r9d
leaq 0x2(%r8), %rbx
xorl %r10d, %r10d
movl $0xffffffff, %r11d # imm = 0xFFFFFFFF
xorl %edx, %edx
movq %rbx, %rcx
movzbl -0x1(%rbx), %ebx
leal -0x30(%rbx), %eax
cmpl $0xa, %eax
jb 0x9872d
leal -0x41(%rbx), %eax
cmpl $0x5, %eax
ja 0x9871e
addl $-0x37, %ebx
jmp 0x9872b
leal -0x61(%rbx), %eax
addl $-0x57, %ebx
cmpl $0x6, %eax
cmovael %r11d, %ebx
movl %ebx, %eax
testl %eax, %eax
js 0x98801
shll $0x4, %edx
orl %edx, %eax
decq %r10
leaq 0x1(%rcx), %rbx
movl %eax, %edx
decl %r9d
jne 0x98702
movb $0x1, %r9b
cmpl $0x2, %esi
jne 0x98848
movl %eax, %edx
andl $0xfffffc00, %edx # imm = 0xFFFFFC00
cmpl $0xd800, %edx # imm = 0xD800
jne 0x98848
cmpb $0x5c, -0x1(%rbx)
jne 0x98848
cmpb $0x75, (%rbx)
jne 0x98848
subq %r10, %r8
leaq 0x3(%r8), %rsi
xorl %edx, %edx
movl $0xffffffff, %r10d # imm = 0xFFFFFFFF
xorl %ebx, %ebx
movzbl (%rsi), %r14d
leal -0x30(%r14), %r11d
cmpl $0xa, %r11d
jb 0x987bd
leal -0x41(%r14), %r11d
cmpl $0x5, %r11d
ja 0x987aa
addl $-0x37, %r14d
jmp 0x987ba
leal -0x61(%r14), %r11d
addl $-0x57, %r14d
cmpl $0x6, %r11d
cmovael %r10d, %r14d
movl %r14d, %r11d
testl %r11d, %r11d
js 0x9880d
shll $0x4, %ebx
orl %ebx, %r11d
incq %rdx
incq %rsi
movl %r11d, %ebx
cmpq $0x4, %rdx
jne 0x9878c
movl $0x4, %edx
jmp 0x98810
movl $0xd, %edx
jmp 0x98854
movl $0x9, %edx
jmp 0x98854
movl $0xa, %edx
jmp 0x98854
movl $0xb, %edx
jmp 0x98854
movl $0x8, %edx
jmp 0x98854
xorl %r9d, %r9d
jmp 0x9884a
xorl %r9d, %r9d
movl %esi, %edx
jmp 0x9884a
movl %ebx, %r11d
cmpl $0x4, %edx
jne 0x98848
movl %r11d, %edx
andl $0xfffffc00, %edx # imm = 0xFFFFFC00
cmpl $0xdc00, %edx # imm = 0xDC00
jne 0x98848
addq $0x7, %r8
shll $0xa, %eax
andl $0xffc00, %eax # imm = 0xFFC00
andl $0x3ff, %r11d # imm = 0x3FF
leal (%rax,%r11), %edx
addl $0x10000, %edx # imm = 0x10000
movq %r8, %rcx
jmp 0x9884a
movl %eax, %edx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testb %r9b, %r9b
je 0x98859
movq %rcx, (%rdi)
movl %edx, %eax
popq %rbx
popq %r14
retq
| lre_parse_escape:
push r14
push rbx
mov r8, [rdi]
lea rcx, [r8+1]
movzx edx, byte ptr [r8]
mov eax, 0FFFFFFFEh
cmp edx, 61h ; 'a'
jg short loc_985EB
add edx, 0FFFFFFD0h
cmp edx, 8
jnb loc_98859; jumptable 0000000000098607 cases 111-113,115,119
cmp esi, 2
jnz loc_9868A
mov eax, 0FFFFFFFFh
test edx, edx
jnz loc_98859; jumptable 0000000000098607 cases 111-113,115,119
movzx esi, byte ptr [rcx]
add esi, 0FFFFFFC6h
xor edx, edx
cmp esi, 0FFFFFFF6h
jb loc_98854
jmp loc_98859; jumptable 0000000000098607 cases 111-113,115,119
loc_985EB:
lea r9d, [rdx-6Eh]; switch 11 cases
cmp r9d, 0Ah
ja def_98607; jumptable 0000000000098607 default case
lea r10, jpt_98607
movsxd r9, ds:(jpt_98607 - 0A73D0h)[r10+r9*4]
add r9, r10
jmp r9; switch jump
loc_9860A:
test esi, esi; jumptable 0000000000098607 cases 117,120
jz loc_986E3
cmp byte ptr [rcx], 7Bh ; '{'
jnz loc_986E3
add r8, 3
xor edx, edx
mov eax, 0FFFFFFFFh
mov rcx, r8
loc_98629:
movzx r8d, byte ptr [rcx-1]
lea esi, [r8-30h]
cmp esi, 0Ah
jb short loc_98658
lea esi, [r8-41h]
cmp esi, 5
ja short loc_98646
add r8d, 0FFFFFFC9h
jmp short loc_98655
loc_98646:
lea esi, [r8-61h]
add r8d, 0FFFFFFA9h
cmp esi, 6
cmovnb r8d, eax
loc_98655:
mov esi, r8d
loc_98658:
test esi, esi
js loc_98801
shl edx, 4
or esi, edx
cmp esi, 10FFFFh
ja loc_98806
lea r8, [rcx+1]
cmp byte ptr [rcx], 7Dh ; '}'
mov rcx, r8
mov edx, esi
jnz short loc_98629
mov r9b, 1
mov rcx, r8
jmp loc_98809
loc_9868A:
movzx eax, byte ptr [rcx]
add eax, 0FFFFFFD0h
cmp eax, 7
ja loc_98854
lea edx, [rax+rdx*8]
lea rcx, [r8+2]
cmp edx, 1Fh
ja loc_98854
movzx eax, byte ptr [rcx]
add eax, 0FFFFFFD0h
cmp eax, 7
ja loc_98854
lea edx, [rax+rdx*8]
add r8, 3
mov rcx, r8
jmp loc_98854
def_98607:
cmp edx, 62h ; 'b'; jumptable 0000000000098607 default case
jz loc_987FA
cmp edx, 66h ; 'f'
jnz loc_98859; jumptable 0000000000098607 cases 111-113,115,119
mov edx, 0Ch
jmp loc_98854
loc_986E3:
xor eax, eax
cmp edx, 78h ; 'x'
setnz al
lea r9d, ds:2[rax*2]
lea rbx, [r8+2]
xor r10d, r10d
mov r11d, 0FFFFFFFFh
xor edx, edx
loc_98702:
mov rcx, rbx
movzx ebx, byte ptr [rbx-1]
lea eax, [rbx-30h]
cmp eax, 0Ah
jb short loc_9872D
lea eax, [rbx-41h]
cmp eax, 5
ja short loc_9871E
add ebx, 0FFFFFFC9h
jmp short loc_9872B
loc_9871E:
lea eax, [rbx-61h]
add ebx, 0FFFFFFA9h
cmp eax, 6
cmovnb ebx, r11d
loc_9872B:
mov eax, ebx
loc_9872D:
test eax, eax
js loc_98801
shl edx, 4
or eax, edx
dec r10
lea rbx, [rcx+1]
mov edx, eax
dec r9d
jnz short loc_98702
mov r9b, 1
cmp esi, 2
jnz loc_98848
mov edx, eax
and edx, 0FFFFFC00h
cmp edx, 0D800h
jnz loc_98848
cmp byte ptr [rbx-1], 5Ch ; '\'
jnz loc_98848
cmp byte ptr [rbx], 75h ; 'u'
jnz loc_98848
sub r8, r10
lea rsi, [r8+3]
xor edx, edx
mov r10d, 0FFFFFFFFh
xor ebx, ebx
loc_9878C:
movzx r14d, byte ptr [rsi]
lea r11d, [r14-30h]
cmp r11d, 0Ah
jb short loc_987BD
lea r11d, [r14-41h]
cmp r11d, 5
ja short loc_987AA
add r14d, 0FFFFFFC9h
jmp short loc_987BA
loc_987AA:
lea r11d, [r14-61h]
add r14d, 0FFFFFFA9h
cmp r11d, 6
cmovnb r14d, r10d
loc_987BA:
mov r11d, r14d
loc_987BD:
test r11d, r11d
js short loc_9880D
shl ebx, 4
or r11d, ebx
inc rdx
inc rsi
mov ebx, r11d
cmp rdx, 4
jnz short loc_9878C
mov edx, 4
jmp short loc_98810
loc_987DE:
mov edx, 0Dh; jumptable 0000000000098607 case 114
jmp short loc_98854
loc_987E5:
mov edx, 9; jumptable 0000000000098607 case 116
jmp short loc_98854
loc_987EC:
mov edx, 0Ah; jumptable 0000000000098607 case 110
jmp short loc_98854
loc_987F3:
mov edx, 0Bh; jumptable 0000000000098607 case 118
jmp short loc_98854
loc_987FA:
mov edx, 8
jmp short loc_98854
loc_98801:
xor r9d, r9d
jmp short loc_9884A
loc_98806:
xor r9d, r9d
loc_98809:
mov edx, esi
jmp short loc_9884A
loc_9880D:
mov r11d, ebx
loc_98810:
cmp edx, 4
jnz short loc_98848
mov edx, r11d
and edx, 0FFFFFC00h
cmp edx, 0DC00h
jnz short loc_98848
add r8, 7
shl eax, 0Ah
and eax, 0FFC00h
and r11d, 3FFh
lea edx, [rax+r11]
add edx, 10000h
mov rcx, r8
jmp short loc_9884A
loc_98848:
mov edx, eax
loc_9884A:
mov eax, 0FFFFFFFFh
test r9b, r9b
jz short loc_98859; jumptable 0000000000098607 cases 111-113,115,119
loc_98854:
mov [rdi], rcx
mov eax, edx
loc_98859:
pop rbx; jumptable 0000000000098607 cases 111-113,115,119
pop r14
retn
| long long lre_parse_escape(unsigned __int8 **a1, int a2)
{
_BYTE *v2; // r8
unsigned __int8 *v3; // rcx
unsigned int v4; // edx
long long result; // rax
unsigned int v6; // edx
int v7; // r8d
int v8; // esi
int v9; // r8d
unsigned int v10; // esi
unsigned int v11; // esi
unsigned __int8 *v12; // r8
bool v13; // zf
char v14; // r9
unsigned int v15; // eax
unsigned int v16; // eax
int v17; // r9d
unsigned __int8 *v18; // rbx
long long v19; // r10
int v20; // ebx
int v21; // eax
int v22; // ebx
unsigned int v23; // eax
int v24; // eax
_BYTE *v25; // r8
unsigned __int8 *v26; // rsi
long long v27; // rdx
int v28; // ebx
int v29; // r14d
int v30; // r11d
int v31; // r14d
unsigned int v32; // r11d
int v33; // r11d
v2 = *a1;
v3 = *a1 + 1;
v4 = **a1;
result = 4294967294LL;
if ( v4 <= 0x61 )
{
v6 = v4 - 48;
if ( v6 >= 8 )
return result;
if ( a2 == 2 )
{
result = 0xFFFFFFFFLL;
if ( v6 )
return result;
v6 = 0;
if ( (unsigned int)*v3 - 58 >= 0xFFFFFFF6 )
return result;
}
else
{
v15 = *v3 - 48;
if ( v15 <= 7 )
{
v6 = v15 + 8 * v6;
v3 = v2 + 2;
if ( v6 <= 0x1F )
{
v16 = *v3 - 48;
if ( v16 <= 7 )
{
v6 = v16 + 8 * v6;
v3 = v2 + 3;
}
}
}
}
LABEL_65:
*a1 = v3;
return v6;
}
switch ( **a1 )
{
case 'n':
v6 = 10;
goto LABEL_65;
case 'o':
case 'p':
case 'q':
case 's':
case 'w':
return result;
case 'r':
v6 = 13;
goto LABEL_65;
case 't':
v6 = 9;
goto LABEL_65;
case 'u':
case 'x':
if ( a2 && *v3 == 123 )
{
v6 = 0;
v3 = v2 + 3;
while ( 1 )
{
v7 = *(v3 - 1);
v8 = v7 - 48;
if ( (unsigned int)(v7 - 48) >= 0xA )
{
if ( (unsigned int)(v7 - 65) > 5 )
{
v10 = v7 - 97;
v9 = v7 - 87;
if ( v10 >= 6 )
v9 = -1;
}
else
{
v9 = v7 - 55;
}
v8 = v9;
}
if ( v8 < 0 )
goto LABEL_56;
v11 = (16 * v6) | v8;
if ( v11 > 0x10FFFF )
break;
v12 = v3 + 1;
v13 = *v3++ == 125;
v6 = v11;
if ( v13 )
{
v14 = 1;
v3 = v12;
LABEL_58:
v6 = v11;
goto LABEL_64;
}
}
v14 = 0;
goto LABEL_58;
}
v17 = 2 * (v4 != 120) + 2;
v18 = v2 + 2;
v19 = 0LL;
v6 = 0;
do
{
v3 = v18;
v20 = *(v18 - 1);
v21 = v20 - 48;
if ( (unsigned int)(v20 - 48) >= 0xA )
{
if ( (unsigned int)(v20 - 65) > 5 )
{
v23 = v20 - 97;
v22 = v20 - 87;
if ( v23 >= 6 )
v22 = -1;
}
else
{
v22 = v20 - 55;
}
v21 = v22;
}
if ( v21 < 0 )
{
LABEL_56:
v14 = 0;
goto LABEL_64;
}
v24 = (16 * v6) | v21;
--v19;
v18 = v3 + 1;
v6 = v24;
--v17;
}
while ( v17 );
v14 = 1;
if ( a2 != 2 || (v24 & 0xFFFFFC00) != 0xD800 || *v3 != 92 || *v18 != 117 )
goto LABEL_63;
v25 = &v2[-v19];
v26 = v25 + 3;
v27 = 0LL;
v28 = 0;
break;
case 'v':
v6 = 11;
goto LABEL_65;
default:
if ( v4 == 98 )
{
v6 = 8;
}
else
{
if ( v4 != 102 )
return result;
v6 = 12;
}
goto LABEL_65;
}
while ( 1 )
{
v29 = *v26;
v30 = v29 - 48;
if ( (unsigned int)(v29 - 48) >= 0xA )
{
if ( (unsigned int)(v29 - 65) > 5 )
{
v32 = v29 - 97;
v31 = v29 - 87;
if ( v32 >= 6 )
v31 = -1;
}
else
{
v31 = v29 - 55;
}
v30 = v31;
}
if ( v30 < 0 )
break;
v33 = (16 * v28) | v30;
++v27;
++v26;
v28 = v33;
if ( v27 == 4 )
{
LODWORD(v27) = 4;
goto LABEL_60;
}
}
v33 = v28;
LABEL_60:
if ( (_DWORD)v27 == 4 && (v33 & 0xFFFFFC00) == 0xDC00 )
{
v6 = ((v24 << 10) & 0xFFC00) + (v33 & 0x3FF) + 0x10000;
v3 = v25 + 7;
}
else
{
LABEL_63:
v6 = v24;
}
LABEL_64:
result = 0xFFFFFFFFLL;
if ( v14 )
goto LABEL_65;
return result;
}
| lre_parse_escape:
PUSH R14
PUSH RBX
MOV R8,qword ptr [RDI]
LEA RCX,[R8 + 0x1]
MOVZX EDX,byte ptr [R8]
MOV EAX,0xfffffffe
CMP EDX,0x61
JG 0x001985eb
ADD EDX,-0x30
CMP EDX,0x8
JNC 0x00198859
CMP ESI,0x2
JNZ 0x0019868a
MOV EAX,0xffffffff
TEST EDX,EDX
JNZ 0x00198859
MOVZX ESI,byte ptr [RCX]
ADD ESI,-0x3a
XOR EDX,EDX
CMP ESI,-0xa
JC 0x00198854
JMP 0x00198859
LAB_001985eb:
LEA R9D,[RDX + -0x6e]
CMP R9D,0xa
JA 0x001986c7
LEA R10,[0x1a73d0]
MOVSXD R9,dword ptr [R10 + R9*0x4]
ADD R9,R10
switchD:
JMP R9
caseD_75:
TEST ESI,ESI
JZ 0x001986e3
CMP byte ptr [RCX],0x7b
JNZ 0x001986e3
ADD R8,0x3
XOR EDX,EDX
MOV EAX,0xffffffff
MOV RCX,R8
LAB_00198629:
MOVZX R8D,byte ptr [RCX + -0x1]
LEA ESI,[R8 + -0x30]
CMP ESI,0xa
JC 0x00198658
LEA ESI,[R8 + -0x41]
CMP ESI,0x5
JA 0x00198646
ADD R8D,-0x37
JMP 0x00198655
LAB_00198646:
LEA ESI,[R8 + -0x61]
ADD R8D,-0x57
CMP ESI,0x6
CMOVNC R8D,EAX
LAB_00198655:
MOV ESI,R8D
LAB_00198658:
TEST ESI,ESI
JS 0x00198801
SHL EDX,0x4
OR ESI,EDX
CMP ESI,0x10ffff
JA 0x00198806
LEA R8,[RCX + 0x1]
CMP byte ptr [RCX],0x7d
MOV RCX,R8
MOV EDX,ESI
JNZ 0x00198629
MOV R9B,0x1
MOV RCX,R8
JMP 0x00198809
LAB_0019868a:
MOVZX EAX,byte ptr [RCX]
ADD EAX,-0x30
CMP EAX,0x7
JA 0x00198854
LEA EDX,[RAX + RDX*0x8]
LEA RCX,[R8 + 0x2]
CMP EDX,0x1f
JA 0x00198854
MOVZX EAX,byte ptr [RCX]
ADD EAX,-0x30
CMP EAX,0x7
JA 0x00198854
LEA EDX,[RAX + RDX*0x8]
ADD R8,0x3
MOV RCX,R8
JMP 0x00198854
default:
CMP EDX,0x62
JZ 0x001987fa
CMP EDX,0x66
JNZ 0x00198859
MOV EDX,0xc
JMP 0x00198854
LAB_001986e3:
XOR EAX,EAX
CMP EDX,0x78
SETNZ AL
LEA R9D,[0x2 + RAX*0x2]
LEA RBX,[R8 + 0x2]
XOR R10D,R10D
MOV R11D,0xffffffff
XOR EDX,EDX
LAB_00198702:
MOV RCX,RBX
MOVZX EBX,byte ptr [RBX + -0x1]
LEA EAX,[RBX + -0x30]
CMP EAX,0xa
JC 0x0019872d
LEA EAX,[RBX + -0x41]
CMP EAX,0x5
JA 0x0019871e
ADD EBX,-0x37
JMP 0x0019872b
LAB_0019871e:
LEA EAX,[RBX + -0x61]
ADD EBX,-0x57
CMP EAX,0x6
CMOVNC EBX,R11D
LAB_0019872b:
MOV EAX,EBX
LAB_0019872d:
TEST EAX,EAX
JS 0x00198801
SHL EDX,0x4
OR EAX,EDX
DEC R10
LEA RBX,[RCX + 0x1]
MOV EDX,EAX
DEC R9D
JNZ 0x00198702
MOV R9B,0x1
CMP ESI,0x2
JNZ 0x00198848
MOV EDX,EAX
AND EDX,0xfffffc00
CMP EDX,0xd800
JNZ 0x00198848
CMP byte ptr [RBX + -0x1],0x5c
JNZ 0x00198848
CMP byte ptr [RBX],0x75
JNZ 0x00198848
SUB R8,R10
LEA RSI,[R8 + 0x3]
XOR EDX,EDX
MOV R10D,0xffffffff
XOR EBX,EBX
LAB_0019878c:
MOVZX R14D,byte ptr [RSI]
LEA R11D,[R14 + -0x30]
CMP R11D,0xa
JC 0x001987bd
LEA R11D,[R14 + -0x41]
CMP R11D,0x5
JA 0x001987aa
ADD R14D,-0x37
JMP 0x001987ba
LAB_001987aa:
LEA R11D,[R14 + -0x61]
ADD R14D,-0x57
CMP R11D,0x6
CMOVNC R14D,R10D
LAB_001987ba:
MOV R11D,R14D
LAB_001987bd:
TEST R11D,R11D
JS 0x0019880d
SHL EBX,0x4
OR R11D,EBX
INC RDX
INC RSI
MOV EBX,R11D
CMP RDX,0x4
JNZ 0x0019878c
MOV EDX,0x4
JMP 0x00198810
caseD_72:
MOV EDX,0xd
JMP 0x00198854
caseD_74:
MOV EDX,0x9
JMP 0x00198854
caseD_6e:
MOV EDX,0xa
JMP 0x00198854
caseD_76:
MOV EDX,0xb
JMP 0x00198854
LAB_001987fa:
MOV EDX,0x8
JMP 0x00198854
LAB_00198801:
XOR R9D,R9D
JMP 0x0019884a
LAB_00198806:
XOR R9D,R9D
LAB_00198809:
MOV EDX,ESI
JMP 0x0019884a
LAB_0019880d:
MOV R11D,EBX
LAB_00198810:
CMP EDX,0x4
JNZ 0x00198848
MOV EDX,R11D
AND EDX,0xfffffc00
CMP EDX,0xdc00
JNZ 0x00198848
ADD R8,0x7
SHL EAX,0xa
AND EAX,0xffc00
AND R11D,0x3ff
LEA EDX,[RAX + R11*0x1]
ADD EDX,0x10000
MOV RCX,R8
JMP 0x0019884a
LAB_00198848:
MOV EDX,EAX
LAB_0019884a:
MOV EAX,0xffffffff
TEST R9B,R9B
JZ 0x00198859
LAB_00198854:
MOV qword ptr [RDI],RCX
MOV EAX,EDX
caseD_6f:
POP RBX
POP R14
RET
|
uint lre_parse_escape(long *param_1,int param_2)
{
byte bVar1;
byte *pbVar2;
bool bVar3;
uint uVar4;
long lVar5;
uint uVar6;
byte *pbVar7;
byte *pbVar8;
int iVar9;
long lVar10;
uint uVar11;
pbVar2 = (byte *)*param_1;
pbVar8 = pbVar2 + 1;
bVar1 = *pbVar2;
uVar4 = 0xfffffffe;
uVar6 = (uint)bVar1;
if (bVar1 < 0x62) {
uVar4 = uVar6 - 0x30;
if (7 < uVar4) {
return 0xfffffffe;
}
if (param_2 == 2) {
if (uVar4 != 0) {
return 0xffffffff;
}
uVar4 = 0;
if (0xfffffff5 < *pbVar8 - 0x3a) {
return 0xffffffff;
}
}
else if (*pbVar8 - 0x30 < 8) {
uVar4 = (*pbVar8 - 0x30) + uVar4 * 8;
pbVar8 = pbVar2 + 2;
if ((uVar4 < 0x20) && (*pbVar8 - 0x30 < 8)) {
uVar4 = (*pbVar8 - 0x30) + uVar4 * 8;
pbVar8 = pbVar2 + 3;
}
}
}
else {
switch(bVar1) {
case 0x6e:
uVar4 = 10;
break;
case 0x6f:
case 0x70:
case 0x71:
case 0x73:
case 0x77:
goto switchD_00198607_caseD_6f;
case 0x72:
uVar4 = 0xd;
break;
case 0x74:
uVar4 = 9;
break;
case 0x75:
case 0x78:
if ((param_2 == 0) || (*pbVar8 != 0x7b)) {
iVar9 = (uint)(uVar6 != 0x78) * 2 + 2;
lVar10 = 0;
uVar4 = 0;
pbVar7 = pbVar2 + 2;
do {
pbVar8 = pbVar7;
bVar1 = pbVar8[-1];
uVar6 = bVar1 - 0x30;
if (9 < uVar6) {
if (bVar1 - 0x41 < 6) {
uVar6 = bVar1 - 0x37;
}
else {
uVar6 = bVar1 - 0x57;
if (5 < bVar1 - 0x61) {
uVar6 = 0xffffffff;
}
}
}
if ((int)uVar6 < 0) goto LAB_00198801;
uVar4 = uVar6 | uVar4 << 4;
lVar10 = lVar10 + -1;
iVar9 = iVar9 + -1;
pbVar7 = pbVar8 + 1;
} while (iVar9 != 0);
bVar3 = true;
if ((((param_2 == 2) && ((uVar4 & 0xfffffc00) == 0xd800)) && (*pbVar8 == 0x5c)) &&
(pbVar8[1] == 0x75)) {
pbVar7 = pbVar2 + (3 - lVar10);
lVar5 = 0;
uVar6 = 0;
do {
bVar1 = *pbVar7;
uVar11 = bVar1 - 0x30;
if (9 < uVar11) {
if (bVar1 - 0x41 < 6) {
uVar11 = bVar1 - 0x37;
}
else {
uVar11 = bVar1 - 0x57;
if (5 < bVar1 - 0x61) {
uVar11 = 0xffffffff;
}
}
}
if ((int)uVar11 < 0) goto LAB_00198810;
uVar6 = uVar11 | uVar6 << 4;
lVar5 = lVar5 + 1;
pbVar7 = pbVar7 + 1;
} while (lVar5 != 4);
lVar5 = 4;
LAB_00198810:
if (((int)lVar5 == 4) && ((uVar6 & 0xfffffc00) == 0xdc00)) {
uVar4 = (uVar4 & 0x3ff) * 0x400 + (uVar6 & 0x3ff) + 0x10000;
pbVar8 = pbVar2 + (7 - lVar10);
}
}
}
else {
uVar4 = 0;
pbVar8 = pbVar2 + 3;
do {
bVar1 = pbVar8[-1];
uVar6 = bVar1 - 0x30;
if (9 < uVar6) {
if (bVar1 - 0x41 < 6) {
uVar6 = bVar1 - 0x37;
}
else {
uVar6 = bVar1 - 0x57;
if (5 < bVar1 - 0x61) {
uVar6 = 0xffffffff;
}
}
}
if ((int)uVar6 < 0) goto LAB_00198801;
uVar4 = uVar6 | uVar4 << 4;
if (0x10ffff < uVar4) {
bVar3 = false;
goto LAB_0019884a;
}
pbVar2 = pbVar8 + 1;
bVar1 = *pbVar8;
pbVar8 = pbVar2;
} while (bVar1 != 0x7d);
bVar3 = true;
}
goto LAB_0019884a;
case 0x76:
uVar4 = 0xb;
break;
default:
if (bVar1 == 0x62) {
uVar4 = 8;
}
else {
if (uVar6 != 0x66) {
return 0xfffffffe;
}
uVar4 = 0xc;
}
}
}
goto LAB_00198854;
LAB_00198801:
bVar3 = false;
LAB_0019884a:
if (!bVar3) {
return 0xffffffff;
}
LAB_00198854:
*param_1 = (long)pbVar8;
switchD_00198607_caseD_6f:
return uVar4;
}
| |
48,385 | lre_parse_escape | bluesky950520[P]quickjs/libregexp.c | int lre_parse_escape(const uint8_t **pp, int allow_utf16)
{
const uint8_t *p;
uint32_t c;
p = *pp;
c = *p++;
switch(c) {
case 'b':
c = '\b';
break;
case 'f':
c = '\f';
break;
case 'n':
c = '\n';
break;
case 'r':
c = '\r';
break;
case 't':
c = '\t';
break;
case 'v':
c = '\v';
break;
case 'x':
case 'u':
{
int h, n, i;
uint32_t c1;
if (*p == '{' && allow_utf16) {
p++;
c = 0;
for(;;) {
h = from_hex(*p++);
if (h < 0)
return -1;
c = (c << 4) | h;
if (c > 0x10FFFF)
return -1;
if (*p == '}')
break;
}
p++;
} else {
if (c == 'x') {
n = 2;
} else {
n = 4;
}
c = 0;
for(i = 0; i < n; i++) {
h = from_hex(*p++);
if (h < 0) {
return -1;
}
c = (c << 4) | h;
}
if (is_hi_surrogate(c) &&
allow_utf16 == 2 && p[0] == '\\' && p[1] == 'u') {
/* convert an escaped surrogate pair into a
unicode char */
c1 = 0;
for(i = 0; i < 4; i++) {
h = from_hex(p[2 + i]);
if (h < 0)
break;
c1 = (c1 << 4) | h;
}
if (i == 4 && is_lo_surrogate(c1)) {
p += 6;
c = from_surrogate(c, c1);
}
}
}
}
break;
case '0': case '1': case '2': case '3':
case '4': case '5': case '6': case '7':
c -= '0';
if (allow_utf16 == 2) {
/* only accept \0 not followed by digit */
if (c != 0 || lre_is_digit(*p))
return -1;
} else {
/* parse a legacy octal sequence */
uint32_t v;
v = *p - '0';
if (v > 7)
break;
c = (c << 3) | v;
p++;
if (c >= 32)
break;
v = *p - '0';
if (v > 7)
break;
c = (c << 3) | v;
p++;
}
break;
default:
return -2;
}
*pp = p;
return c;
} | O3 | c | lre_parse_escape:
pushq %rbx
movq (%rdi), %r8
leaq 0x1(%r8), %rcx
movzbl (%r8), %edx
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
cmpl $0x61, %edx
jg 0x9b0d5
addl $-0x30, %edx
cmpl $0x8, %edx
jae 0x9b305
cmpl $0x2, %esi
jne 0x9b173
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testl %edx, %edx
jne 0x9b305
movzbl (%rcx), %esi
addl $-0x3a, %esi
xorl %edx, %edx
cmpl $-0xa, %esi
jb 0x9b300
jmp 0x9b305
leal -0x6e(%rdx), %r9d
cmpl $0xa, %r9d
ja 0x9b1b0
leaq 0xf266(%rip), %r10 # 0xaa350
movslq (%r10,%r9,4), %r9
addq %r10, %r9
jmpq *%r9
testl %esi, %esi
je 0x9b1cc
cmpb $0x7b, (%rcx)
jne 0x9b1cc
movb 0x2(%r8), %sil
addq $0x3, %r8
xorl %edx, %edx
movq %r8, %rcx
movzbl %sil, %r8d
leal -0x30(%r8), %eax
cmpl $0xa, %eax
jb 0x9b151
leal -0x41(%r8), %eax
cmpl $0x5, %eax
ja 0x9b12e
addl $-0x37, %r8d
jmp 0x9b14e
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpb $0x57, %sil
jb 0x9b305
leal -0x67(%r8), %esi
cmpl $-0x6, %esi
jb 0x9b305
addl $-0x57, %r8d
movl %r8d, %eax
shll $0x4, %edx
orl %eax, %edx
cmpl $0x10ffff, %edx # imm = 0x10FFFF
ja 0x9b307
movb (%rcx), %sil
incq %rcx
cmpb $0x7d, %sil
jne 0x9b112
jmp 0x9b300
movzbl (%rcx), %eax
addl $-0x30, %eax
cmpl $0x7, %eax
ja 0x9b300
leal (%rax,%rdx,8), %edx
leaq 0x2(%r8), %rcx
cmpl $0x1f, %edx
ja 0x9b300
movzbl (%rcx), %eax
addl $-0x30, %eax
cmpl $0x7, %eax
ja 0x9b300
leal (%rax,%rdx,8), %edx
addq $0x3, %r8
movq %r8, %rcx
jmp 0x9b300
cmpl $0x62, %edx
je 0x9b2fb
cmpl $0x66, %edx
jne 0x9b305
movl $0xc, %edx
jmp 0x9b300
xorl %eax, %eax
cmpl $0x78, %edx
setne %al
leal 0x2(,%rax,2), %r10d
xorl %r9d, %r9d
xorl %edx, %edx
movzbl (%rcx), %r11d
leal -0x30(%r11), %eax
cmpl $0xa, %eax
jb 0x9b220
leal -0x41(%r11), %eax
cmpl $0x5, %eax
ja 0x9b1fd
addl $-0x37, %r11d
jmp 0x9b21d
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpb $0x57, %r11b
jb 0x9b305
leal -0x67(%r11), %ebx
cmpl $-0x6, %ebx
jb 0x9b305
addl $-0x57, %r11d
movl %r11d, %eax
incq %rcx
shll $0x4, %edx
orl %eax, %edx
decq %r9
decl %r10d
jne 0x9b1e1
cmpl $0x2, %esi
jne 0x9b300
movl %edx, %eax
andl $0xfffffc00, %eax # imm = 0xFFFFFC00
cmpl $0xd800, %eax # imm = 0xD800
jne 0x9b300
cmpb $0x5c, (%rcx)
jne 0x9b300
cmpb $0x75, 0x1(%rcx)
jne 0x9b300
subq %r9, %r8
leaq 0x3(%r8), %rsi
xorl %eax, %eax
movl $0x4, %r9d
movzbl (%rsi), %r10d
leal -0x30(%r10), %r11d
cmpl $0xa, %r11d
jb 0x9b2a2
leal -0x41(%r10), %r11d
cmpl $0x5, %r11d
ja 0x9b28b
addl $-0x37, %r10d
jmp 0x9b29f
cmpb $0x57, %r10b
jb 0x9b300
leal -0x67(%r10), %r11d
cmpl $-0x6, %r11d
jb 0x9b300
addl $-0x57, %r10d
movl %r10d, %r11d
shll $0x4, %eax
orl %r11d, %eax
incq %rsi
decq %r9
jne 0x9b26d
movl %eax, %esi
andl $0xfffffc00, %esi # imm = 0xFFFFFC00
cmpl $0xdc00, %esi # imm = 0xDC00
jne 0x9b300
addq $0x7, %r8
shll $0xa, %edx
andl $0xffc00, %edx # imm = 0xFFC00
andl $0x3ff, %eax # imm = 0x3FF
addl %eax, %edx
addl $0x10000, %edx # imm = 0x10000
jmp 0x9b1a8
movl $0xd, %edx
jmp 0x9b300
movl $0x9, %edx
jmp 0x9b300
movl $0xa, %edx
jmp 0x9b300
movl $0xb, %edx
jmp 0x9b300
movl $0x8, %edx
movq %rcx, (%rdi)
movl %edx, %eax
popq %rbx
retq
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0x9b305
| lre_parse_escape:
push rbx
mov r8, [rdi]
lea rcx, [r8+1]
movzx edx, byte ptr [r8]
mov eax, 0FFFFFFFEh
cmp edx, 61h ; 'a'
jg short loc_9B0D5
add edx, 0FFFFFFD0h
cmp edx, 8
jnb loc_9B305; jumptable 000000000009B0F1 cases 111-113,115,119
cmp esi, 2
jnz loc_9B173
mov eax, 0FFFFFFFFh
test edx, edx
jnz loc_9B305; jumptable 000000000009B0F1 cases 111-113,115,119
movzx esi, byte ptr [rcx]
add esi, 0FFFFFFC6h
xor edx, edx
cmp esi, 0FFFFFFF6h
jb loc_9B300
jmp loc_9B305; jumptable 000000000009B0F1 cases 111-113,115,119
loc_9B0D5:
lea r9d, [rdx-6Eh]; switch 11 cases
cmp r9d, 0Ah
ja def_9B0F1; jumptable 000000000009B0F1 default case
lea r10, jpt_9B0F1
movsxd r9, ds:(jpt_9B0F1 - 0AA350h)[r10+r9*4]
add r9, r10
jmp r9; switch jump
loc_9B0F4:
test esi, esi; jumptable 000000000009B0F1 cases 117,120
jz loc_9B1CC
cmp byte ptr [rcx], 7Bh ; '{'
jnz loc_9B1CC
mov sil, [r8+2]
add r8, 3
xor edx, edx
mov rcx, r8
loc_9B112:
movzx r8d, sil
lea eax, [r8-30h]
cmp eax, 0Ah
jb short loc_9B151
lea eax, [r8-41h]
cmp eax, 5
ja short loc_9B12E
add r8d, 0FFFFFFC9h
jmp short loc_9B14E
loc_9B12E:
mov eax, 0FFFFFFFFh
cmp sil, 57h ; 'W'
jb loc_9B305; jumptable 000000000009B0F1 cases 111-113,115,119
lea esi, [r8-67h]
cmp esi, 0FFFFFFFAh
jb loc_9B305; jumptable 000000000009B0F1 cases 111-113,115,119
add r8d, 0FFFFFFA9h
loc_9B14E:
mov eax, r8d
loc_9B151:
shl edx, 4
or edx, eax
cmp edx, 10FFFFh
ja loc_9B307
mov sil, [rcx]
inc rcx
cmp sil, 7Dh ; '}'
jnz short loc_9B112
jmp loc_9B300
loc_9B173:
movzx eax, byte ptr [rcx]
add eax, 0FFFFFFD0h
cmp eax, 7
ja loc_9B300
lea edx, [rax+rdx*8]
lea rcx, [r8+2]
cmp edx, 1Fh
ja loc_9B300
movzx eax, byte ptr [rcx]
add eax, 0FFFFFFD0h
cmp eax, 7
ja loc_9B300
lea edx, [rax+rdx*8]
add r8, 3
loc_9B1A8:
mov rcx, r8
jmp loc_9B300
def_9B0F1:
cmp edx, 62h ; 'b'; jumptable 000000000009B0F1 default case
jz loc_9B2FB
cmp edx, 66h ; 'f'
jnz loc_9B305; jumptable 000000000009B0F1 cases 111-113,115,119
mov edx, 0Ch
jmp loc_9B300
loc_9B1CC:
xor eax, eax
cmp edx, 78h ; 'x'
setnz al
lea r10d, ds:2[rax*2]
xor r9d, r9d
xor edx, edx
loc_9B1E1:
movzx r11d, byte ptr [rcx]
lea eax, [r11-30h]
cmp eax, 0Ah
jb short loc_9B220
lea eax, [r11-41h]
cmp eax, 5
ja short loc_9B1FD
add r11d, 0FFFFFFC9h
jmp short loc_9B21D
loc_9B1FD:
mov eax, 0FFFFFFFFh
cmp r11b, 57h ; 'W'
jb loc_9B305; jumptable 000000000009B0F1 cases 111-113,115,119
lea ebx, [r11-67h]
cmp ebx, 0FFFFFFFAh
jb loc_9B305; jumptable 000000000009B0F1 cases 111-113,115,119
add r11d, 0FFFFFFA9h
loc_9B21D:
mov eax, r11d
loc_9B220:
inc rcx
shl edx, 4
or edx, eax
dec r9
dec r10d
jnz short loc_9B1E1
cmp esi, 2
jnz loc_9B300
mov eax, edx
and eax, 0FFFFFC00h
cmp eax, 0D800h
jnz loc_9B300
cmp byte ptr [rcx], 5Ch ; '\'
jnz loc_9B300
cmp byte ptr [rcx+1], 75h ; 'u'
jnz loc_9B300
sub r8, r9
lea rsi, [r8+3]
xor eax, eax
mov r9d, 4
loc_9B26D:
movzx r10d, byte ptr [rsi]
lea r11d, [r10-30h]
cmp r11d, 0Ah
jb short loc_9B2A2
lea r11d, [r10-41h]
cmp r11d, 5
ja short loc_9B28B
add r10d, 0FFFFFFC9h
jmp short loc_9B29F
loc_9B28B:
cmp r10b, 57h ; 'W'
jb short loc_9B300
lea r11d, [r10-67h]
cmp r11d, 0FFFFFFFAh
jb short loc_9B300
add r10d, 0FFFFFFA9h
loc_9B29F:
mov r11d, r10d
loc_9B2A2:
shl eax, 4
or eax, r11d
inc rsi
dec r9
jnz short loc_9B26D
mov esi, eax
and esi, 0FFFFFC00h
cmp esi, 0DC00h
jnz short loc_9B300
add r8, 7
shl edx, 0Ah
and edx, 0FFC00h
and eax, 3FFh
add edx, eax
add edx, 10000h
jmp loc_9B1A8
loc_9B2DF:
mov edx, 0Dh; jumptable 000000000009B0F1 case 114
jmp short loc_9B300
loc_9B2E6:
mov edx, 9; jumptable 000000000009B0F1 case 116
jmp short loc_9B300
loc_9B2ED:
mov edx, 0Ah; jumptable 000000000009B0F1 case 110
jmp short loc_9B300
loc_9B2F4:
mov edx, 0Bh; jumptable 000000000009B0F1 case 118
jmp short loc_9B300
loc_9B2FB:
mov edx, 8
loc_9B300:
mov [rdi], rcx
mov eax, edx
loc_9B305:
pop rbx; jumptable 000000000009B0F1 cases 111-113,115,119
retn
loc_9B307:
mov eax, 0FFFFFFFFh
jmp short loc_9B305; jumptable 000000000009B0F1 cases 111-113,115,119
| long long lre_parse_escape(unsigned __int8 **a1, int a2)
{
_BYTE *v2; // r8
unsigned __int8 *v3; // rcx
unsigned int v4; // edx
long long result; // rax
unsigned int v6; // edx
unsigned __int8 v7; // si
unsigned int v8; // eax
int v9; // r8d
unsigned int v10; // eax
unsigned int v11; // eax
unsigned __int8 *v12; // r8
int v13; // r10d
long long v14; // r9
int v15; // r11d
int v16; // eax
int v17; // r11d
_BYTE *v18; // r8
unsigned __int8 *v19; // rsi
int v20; // eax
long long v21; // r9
int v22; // r10d
int v23; // r11d
int v24; // r10d
v2 = *a1;
v3 = *a1 + 1;
v4 = **a1;
result = 4294967294LL;
if ( v4 > 0x61 )
{
switch ( **a1 )
{
case 'n':
v6 = 10;
goto LABEL_58;
case 'o':
case 'p':
case 'q':
case 's':
case 'w':
return result;
case 'r':
v6 = 13;
goto LABEL_58;
case 't':
v6 = 9;
goto LABEL_58;
case 'u':
case 'x':
if ( a2 && *v3 == 123 )
{
v7 = v2[2];
v6 = 0;
v3 = v2 + 3;
while ( 1 )
{
v8 = v7 - 48;
if ( v8 >= 0xA )
{
if ( (unsigned int)v7 - 65 > 5 )
{
result = 0xFFFFFFFFLL;
if ( v7 < 0x57u || (unsigned int)v7 - 103 < 0xFFFFFFFA )
return result;
v9 = v7 - 87;
}
else
{
v9 = v7 - 55;
}
v8 = v9;
}
v6 = v8 | (16 * v6);
if ( v6 > 0x10FFFF )
return 0xFFFFFFFFLL;
v7 = *v3++;
if ( v7 == 125 )
goto LABEL_58;
}
}
v13 = 2 * (v4 != 120) + 2;
v14 = 0LL;
v6 = 0;
break;
case 'v':
v6 = 11;
goto LABEL_58;
default:
if ( v4 == 98 )
{
v6 = 8;
}
else
{
if ( v4 != 102 )
return result;
v6 = 12;
}
goto LABEL_58;
}
do
{
v15 = *v3;
v16 = v15 - 48;
if ( (unsigned int)(v15 - 48) >= 0xA )
{
if ( (unsigned int)(v15 - 65) > 5 )
{
result = 0xFFFFFFFFLL;
if ( (unsigned __int8)v15 < 0x57u || (unsigned int)(v15 - 103) < 0xFFFFFFFA )
return result;
v17 = v15 - 87;
}
else
{
v17 = v15 - 55;
}
v16 = v17;
}
++v3;
v6 = v16 | (16 * v6);
--v14;
--v13;
}
while ( v13 );
if ( a2 != 2 || (v6 & 0xFFFFFC00) != 0xD800 || *v3 != 92 || v3[1] != 117 )
goto LABEL_58;
v18 = &v2[-v14];
v19 = v18 + 3;
v20 = 0;
v21 = 4LL;
do
{
v22 = *v19;
v23 = v22 - 48;
if ( (unsigned int)(v22 - 48) >= 0xA )
{
if ( (unsigned int)(v22 - 65) > 5 )
{
if ( (unsigned __int8)v22 < 0x57u || (unsigned int)(v22 - 103) < 0xFFFFFFFA )
goto LABEL_58;
v24 = v22 - 87;
}
else
{
v24 = v22 - 55;
}
v23 = v24;
}
v20 = v23 | (16 * v20);
++v19;
--v21;
}
while ( v21 );
if ( (v20 & 0xFFFFFC00) != 0xDC00 )
goto LABEL_58;
v12 = v18 + 7;
v6 = (v20 & 0x3FF) + ((v6 << 10) & 0xFFC00) + 0x10000;
LABEL_25:
v3 = v12;
LABEL_58:
*a1 = v3;
return v6;
}
v6 = v4 - 48;
if ( v6 >= 8 )
return result;
if ( a2 != 2 )
{
v10 = *v3 - 48;
if ( v10 > 7 )
goto LABEL_58;
v6 = v10 + 8 * v6;
v3 = v2 + 2;
if ( v6 > 0x1F )
goto LABEL_58;
v11 = *v3 - 48;
if ( v11 > 7 )
goto LABEL_58;
v6 = v11 + 8 * v6;
v12 = v2 + 3;
goto LABEL_25;
}
result = 0xFFFFFFFFLL;
if ( !v6 )
{
v6 = 0;
if ( (unsigned int)*v3 - 58 < 0xFFFFFFF6 )
goto LABEL_58;
}
return result;
}
| lre_parse_escape:
PUSH RBX
MOV R8,qword ptr [RDI]
LEA RCX,[R8 + 0x1]
MOVZX EDX,byte ptr [R8]
MOV EAX,0xfffffffe
CMP EDX,0x61
JG 0x0019b0d5
ADD EDX,-0x30
CMP EDX,0x8
JNC 0x0019b305
CMP ESI,0x2
JNZ 0x0019b173
MOV EAX,0xffffffff
TEST EDX,EDX
JNZ 0x0019b305
MOVZX ESI,byte ptr [RCX]
ADD ESI,-0x3a
XOR EDX,EDX
CMP ESI,-0xa
JC 0x0019b300
JMP 0x0019b305
LAB_0019b0d5:
LEA R9D,[RDX + -0x6e]
CMP R9D,0xa
JA 0x0019b1b0
LEA R10,[0x1aa350]
MOVSXD R9,dword ptr [R10 + R9*0x4]
ADD R9,R10
switchD:
JMP R9
caseD_75:
TEST ESI,ESI
JZ 0x0019b1cc
CMP byte ptr [RCX],0x7b
JNZ 0x0019b1cc
MOV SIL,byte ptr [R8 + 0x2]
ADD R8,0x3
XOR EDX,EDX
MOV RCX,R8
LAB_0019b112:
MOVZX R8D,SIL
LEA EAX,[R8 + -0x30]
CMP EAX,0xa
JC 0x0019b151
LEA EAX,[R8 + -0x41]
CMP EAX,0x5
JA 0x0019b12e
ADD R8D,-0x37
JMP 0x0019b14e
LAB_0019b12e:
MOV EAX,0xffffffff
CMP SIL,0x57
JC 0x0019b305
LEA ESI,[R8 + -0x67]
CMP ESI,-0x6
JC 0x0019b305
ADD R8D,-0x57
LAB_0019b14e:
MOV EAX,R8D
LAB_0019b151:
SHL EDX,0x4
OR EDX,EAX
CMP EDX,0x10ffff
JA 0x0019b307
MOV SIL,byte ptr [RCX]
INC RCX
CMP SIL,0x7d
JNZ 0x0019b112
JMP 0x0019b300
LAB_0019b173:
MOVZX EAX,byte ptr [RCX]
ADD EAX,-0x30
CMP EAX,0x7
JA 0x0019b300
LEA EDX,[RAX + RDX*0x8]
LEA RCX,[R8 + 0x2]
CMP EDX,0x1f
JA 0x0019b300
MOVZX EAX,byte ptr [RCX]
ADD EAX,-0x30
CMP EAX,0x7
JA 0x0019b300
LEA EDX,[RAX + RDX*0x8]
ADD R8,0x3
LAB_0019b1a8:
MOV RCX,R8
JMP 0x0019b300
default:
CMP EDX,0x62
JZ 0x0019b2fb
CMP EDX,0x66
JNZ 0x0019b305
MOV EDX,0xc
JMP 0x0019b300
LAB_0019b1cc:
XOR EAX,EAX
CMP EDX,0x78
SETNZ AL
LEA R10D,[0x2 + RAX*0x2]
XOR R9D,R9D
XOR EDX,EDX
LAB_0019b1e1:
MOVZX R11D,byte ptr [RCX]
LEA EAX,[R11 + -0x30]
CMP EAX,0xa
JC 0x0019b220
LEA EAX,[R11 + -0x41]
CMP EAX,0x5
JA 0x0019b1fd
ADD R11D,-0x37
JMP 0x0019b21d
LAB_0019b1fd:
MOV EAX,0xffffffff
CMP R11B,0x57
JC 0x0019b305
LEA EBX,[R11 + -0x67]
CMP EBX,-0x6
JC 0x0019b305
ADD R11D,-0x57
LAB_0019b21d:
MOV EAX,R11D
LAB_0019b220:
INC RCX
SHL EDX,0x4
OR EDX,EAX
DEC R9
DEC R10D
JNZ 0x0019b1e1
CMP ESI,0x2
JNZ 0x0019b300
MOV EAX,EDX
AND EAX,0xfffffc00
CMP EAX,0xd800
JNZ 0x0019b300
CMP byte ptr [RCX],0x5c
JNZ 0x0019b300
CMP byte ptr [RCX + 0x1],0x75
JNZ 0x0019b300
SUB R8,R9
LEA RSI,[R8 + 0x3]
XOR EAX,EAX
MOV R9D,0x4
LAB_0019b26d:
MOVZX R10D,byte ptr [RSI]
LEA R11D,[R10 + -0x30]
CMP R11D,0xa
JC 0x0019b2a2
LEA R11D,[R10 + -0x41]
CMP R11D,0x5
JA 0x0019b28b
ADD R10D,-0x37
JMP 0x0019b29f
LAB_0019b28b:
CMP R10B,0x57
JC 0x0019b300
LEA R11D,[R10 + -0x67]
CMP R11D,-0x6
JC 0x0019b300
ADD R10D,-0x57
LAB_0019b29f:
MOV R11D,R10D
LAB_0019b2a2:
SHL EAX,0x4
OR EAX,R11D
INC RSI
DEC R9
JNZ 0x0019b26d
MOV ESI,EAX
AND ESI,0xfffffc00
CMP ESI,0xdc00
JNZ 0x0019b300
ADD R8,0x7
SHL EDX,0xa
AND EDX,0xffc00
AND EAX,0x3ff
ADD EDX,EAX
ADD EDX,0x10000
JMP 0x0019b1a8
caseD_72:
MOV EDX,0xd
JMP 0x0019b300
caseD_74:
MOV EDX,0x9
JMP 0x0019b300
caseD_6e:
MOV EDX,0xa
JMP 0x0019b300
caseD_76:
MOV EDX,0xb
JMP 0x0019b300
LAB_0019b2fb:
MOV EDX,0x8
LAB_0019b300:
MOV qword ptr [RDI],RCX
MOV EAX,EDX
caseD_6f:
POP RBX
RET
LAB_0019b307:
MOV EAX,0xffffffff
JMP 0x0019b305
|
uint lre_parse_escape(long *param_1,int param_2)
{
byte *pbVar1;
uint uVar2;
uint uVar3;
byte bVar4;
byte *pbVar5;
byte *pbVar6;
long lVar7;
long lVar8;
int iVar9;
uint uVar10;
pbVar1 = (byte *)*param_1;
pbVar6 = pbVar1 + 1;
bVar4 = *pbVar1;
uVar3 = 0xfffffffe;
uVar2 = (uint)bVar4;
if (bVar4 < 0x62) {
uVar3 = uVar2 - 0x30;
if (7 < uVar3) {
return 0xfffffffe;
}
if (param_2 == 2) {
if (uVar3 != 0) {
return 0xffffffff;
}
uVar3 = 0;
if (0xfffffff5 < *pbVar6 - 0x3a) {
return 0xffffffff;
}
}
else if (*pbVar6 - 0x30 < 8) {
uVar3 = (*pbVar6 - 0x30) + uVar3 * 8;
pbVar6 = pbVar1 + 2;
if ((uVar3 < 0x20) && (*pbVar6 - 0x30 < 8)) {
uVar3 = (*pbVar6 - 0x30) + uVar3 * 8;
pbVar6 = pbVar1 + 3;
}
}
}
else {
switch(bVar4) {
case 0x6e:
uVar3 = 10;
break;
case 0x6f:
case 0x70:
case 0x71:
case 0x73:
case 0x77:
goto switchD_0019b0f1_caseD_6f;
case 0x72:
uVar3 = 0xd;
break;
case 0x74:
uVar3 = 9;
break;
case 0x75:
case 0x78:
if ((param_2 == 0) || (*pbVar6 != 0x7b)) {
iVar9 = (uint)(uVar2 != 0x78) * 2 + 2;
lVar7 = 0;
uVar3 = 0;
do {
pbVar5 = pbVar6;
bVar4 = *pbVar5;
uVar2 = bVar4 - 0x30;
if (9 < uVar2) {
if (bVar4 - 0x41 < 6) {
uVar2 = bVar4 - 0x37;
}
else {
if (bVar4 < 0x57) {
return 0xffffffff;
}
if (bVar4 - 0x67 < 0xfffffffa) {
return 0xffffffff;
}
uVar2 = bVar4 - 0x57;
}
}
pbVar6 = pbVar5 + 1;
uVar3 = uVar3 << 4 | uVar2;
lVar7 = lVar7 + -1;
iVar9 = iVar9 + -1;
} while (iVar9 != 0);
if ((((param_2 == 2) && ((uVar3 & 0xfffffc00) == 0xd800)) && (*pbVar6 == 0x5c)) &&
(pbVar5[2] == 0x75)) {
pbVar5 = pbVar1 + (3 - lVar7);
uVar2 = 0;
lVar8 = 4;
do {
bVar4 = *pbVar5;
uVar10 = bVar4 - 0x30;
if (9 < uVar10) {
if (bVar4 - 0x41 < 6) {
uVar10 = bVar4 - 0x37;
}
else {
if ((bVar4 < 0x57) || (bVar4 - 0x67 < 0xfffffffa)) goto LAB_0019b300;
uVar10 = bVar4 - 0x57;
}
}
uVar2 = uVar2 << 4 | uVar10;
pbVar5 = pbVar5 + 1;
lVar8 = lVar8 + -1;
} while (lVar8 != 0);
if ((uVar2 & 0xfffffc00) == 0xdc00) {
pbVar6 = pbVar1 + (7 - lVar7);
uVar3 = (uVar3 & 0x3ff) * 0x400 + (uVar2 & 0x3ff) + 0x10000;
}
}
}
else {
bVar4 = pbVar1[2];
pbVar6 = pbVar1 + 3;
uVar3 = 0;
do {
uVar2 = bVar4 - 0x30;
if (9 < uVar2) {
if (bVar4 - 0x41 < 6) {
uVar2 = bVar4 - 0x37;
}
else {
if (bVar4 < 0x57) {
return 0xffffffff;
}
if (bVar4 - 0x67 < 0xfffffffa) {
return 0xffffffff;
}
uVar2 = bVar4 - 0x57;
}
}
uVar3 = uVar3 << 4 | uVar2;
if (0x10ffff < uVar3) {
return 0xffffffff;
}
bVar4 = *pbVar6;
pbVar6 = pbVar6 + 1;
} while (bVar4 != 0x7d);
}
break;
case 0x76:
uVar3 = 0xb;
break;
default:
if (bVar4 == 0x62) {
uVar3 = 8;
}
else {
if (uVar2 != 0x66) {
return 0xfffffffe;
}
uVar3 = 0xc;
}
}
}
LAB_0019b300:
*param_1 = (long)pbVar6;
switchD_0019b0f1_caseD_6f:
return uVar3;
}
| |
48,386 | translog_next_LSN | eloqsql/storage/maria/ma_loghandler.c | LSN translog_next_LSN(TRANSLOG_ADDRESS addr, TRANSLOG_ADDRESS horizon)
{
TRANSLOG_SCANNER_DATA scanner;
LSN result;
DBUG_ENTER("translog_next_LSN");
if (horizon == LSN_IMPOSSIBLE)
horizon= translog_get_horizon();
if (addr == horizon)
DBUG_RETURN(LSN_IMPOSSIBLE);
translog_scanner_init(addr, 0, &scanner, 1);
/*
addr can point not to a chunk beginning but page end so next
page beginning.
*/
if (addr % TRANSLOG_PAGE_SIZE == 0)
{
/*
We are emulating the page end which cased such horizon value to
trigger translog_scanner_eop().
We can't just increase addr on page header overhead because it
can be file end so we allow translog_get_next_chunk() to skip
to the next page in correct way
*/
scanner.page_addr-= TRANSLOG_PAGE_SIZE;
scanner.page_offset= TRANSLOG_PAGE_SIZE;
#ifndef DBUG_OFF
scanner.page= NULL; /* prevent using incorrect page content */
#endif
}
/* addr can point not to a chunk beginning but to a page end */
if (translog_scanner_eop(&scanner))
{
if (translog_get_next_chunk(&scanner))
{
result= LSN_ERROR;
goto out;
}
if (scanner.page == END_OF_LOG)
{
result= LSN_IMPOSSIBLE;
goto out;
}
}
while (!translog_is_LSN_chunk(scanner.page[scanner.page_offset]) &&
scanner.page[scanner.page_offset] != TRANSLOG_FILLER)
{
if (translog_get_next_chunk(&scanner))
{
result= LSN_ERROR;
goto out;
}
if (scanner.page == END_OF_LOG)
{
result= LSN_IMPOSSIBLE;
goto out;
}
}
if (scanner.page[scanner.page_offset] == TRANSLOG_FILLER)
result= LSN_IMPOSSIBLE; /* reached page filler */
else
result= scanner.page_addr + scanner.page_offset;
out:
translog_destroy_scanner(&scanner);
DBUG_RETURN(result);
} | O3 | c | translog_next_LSN:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x2038, %rsp # imm = 0x2038
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x20(%rbp)
testq %rsi, %rsi
jne 0x4d8fc
callq 0x4bf54
movq %rax, %rsi
cmpq %rbx, %rsi
jne 0x4d908
xorl %ebx, %ebx
jmp 0x4d9ee
leaq -0x2050(%rbp), %rdx
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %ecx
callq 0x4ac5b
testl $0x1fff, %ebx # imm = 0x1FFF
je 0x4d93d
movl -0x28(%rbp), %eax
cmpq $0x1fff, %rax # imm = 0x1FFF
ja 0x4d94c
movq -0x38(%rbp), %rcx
cmpb $-0x1, (%rcx,%rax)
jne 0x4d975
jmp 0x4d94c
addq $-0x2000, -0x50(%rbp) # imm = 0xE000
movl $0x2000, -0x28(%rbp) # imm = 0x2000
leaq -0x2050(%rbp), %rdi
callq 0x4ad02
movl $0x1, %ebx
testb %al, %al
jne 0x4d9e5
movq -0x38(%rbp), %rcx
leaq 0xbb1d70(%rip), %rax # 0xbff6e0
cmpq %rax, %rcx
je 0x4d9dc
xorl %ebx, %ebx
leaq -0x2050(%rbp), %r14
leaq 0xbb1d5b(%rip), %r15 # 0xbff6e0
movl -0x28(%rbp), %eax
movzbl (%rcx,%rax), %ecx
movl %ecx, %edx
andl $-0x40, %edx
cmpl $0x40, %edx
je 0x4d9cb
testl %edx, %edx
sete %dl
movl %ecx, %esi
notl %esi
testb $0x3f, %sil
setne %sil
testb %sil, %dl
jne 0x4d9cb
cmpl $0xff, %ecx
je 0x4d9e5
movq %r14, %rdi
callq 0x4ad02
testb %al, %al
jne 0x4d9e0
movq -0x38(%rbp), %rcx
cmpq %r15, %rcx
jne 0x4d985
jmp 0x4d9e5
cmpl $0xff, %ecx
je 0x4d9dc
addq -0x50(%rbp), %rax
movq %rax, %rbx
jmp 0x4d9e5
xorl %ebx, %ebx
jmp 0x4d9e5
movl $0x1, %ebx
movq -0x30(%rbp), %rdi
callq 0x4c00e
movq %fs:0x28, %rax
cmpq -0x20(%rbp), %rax
jne 0x4da0e
movq %rbx, %rax
addq $0x2038, %rsp # imm = 0x2038
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x29270
| translog_next_LSN:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 2038h
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_20], rax
test rsi, rsi
jnz short loc_4D8FC
call translog_get_horizon
mov rsi, rax
loc_4D8FC:
cmp rsi, rbx
jnz short loc_4D908
xor ebx, ebx
jmp loc_4D9EE
loc_4D908:
lea rdx, [rbp+var_2050]
mov rdi, rbx
xor esi, esi
mov ecx, 1
call translog_scanner_init
test ebx, 1FFFh
jz short loc_4D93D
mov eax, [rbp+var_28]
cmp rax, 1FFFh
ja short loc_4D94C
mov rcx, [rbp+var_38]
cmp byte ptr [rcx+rax], 0FFh
jnz short loc_4D975
jmp short loc_4D94C
loc_4D93D:
add [rbp+var_50], 0FFFFFFFFFFFFE000h
mov [rbp+var_28], 2000h
loc_4D94C:
lea rdi, [rbp+var_2050]
call translog_get_next_chunk
mov ebx, 1
test al, al
jnz loc_4D9E5
mov rcx, [rbp+var_38]
lea rax, end_of_log
cmp rcx, rax
jz short loc_4D9DC
loc_4D975:
xor ebx, ebx
lea r14, [rbp+var_2050]
lea r15, end_of_log
loc_4D985:
mov eax, [rbp+var_28]
movzx ecx, byte ptr [rcx+rax]
mov edx, ecx
and edx, 0FFFFFFC0h
cmp edx, 40h ; '@'
jz short loc_4D9CB
test edx, edx
setz dl
mov esi, ecx
not esi
test sil, 3Fh
setnz sil
test dl, sil
jnz short loc_4D9CB
cmp ecx, 0FFh
jz short loc_4D9E5
mov rdi, r14
call translog_get_next_chunk
test al, al
jnz short loc_4D9E0
mov rcx, [rbp+var_38]
cmp rcx, r15
jnz short loc_4D985
jmp short loc_4D9E5
loc_4D9CB:
cmp ecx, 0FFh
jz short loc_4D9DC
add rax, [rbp+var_50]
mov rbx, rax
jmp short loc_4D9E5
loc_4D9DC:
xor ebx, ebx
jmp short loc_4D9E5
loc_4D9E0:
mov ebx, 1
loc_4D9E5:
mov rdi, [rbp+var_30]
call translog_free_link
loc_4D9EE:
mov rax, fs:28h
cmp rax, [rbp+var_20]
jnz short loc_4DA0E
mov rax, rbx
add rsp, 2038h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_4DA0E:
call ___stack_chk_fail
| long long translog_next_LSN(long long a1, long long horizon)
{
long long v2; // rbx
_BYTE *v3; // rcx
int v4; // ecx
_BYTE v6[8192]; // [rsp+0h] [rbp-2050h] BYREF
long long v7; // [rsp+2000h] [rbp-50h]
_BYTE *v8; // [rsp+2018h] [rbp-38h]
long long v9; // [rsp+2020h] [rbp-30h]
unsigned int v10; // [rsp+2028h] [rbp-28h]
unsigned long long v11; // [rsp+2030h] [rbp-20h]
v11 = __readfsqword(0x28u);
if ( !horizon )
horizon = translog_get_horizon();
if ( horizon != a1 )
{
translog_scanner_init(a1, 0, (long long)v6, 1);
if ( (a1 & 0x1FFF) != 0 )
{
if ( v10 <= 0x1FFFuLL )
{
v3 = v8;
if ( v8[v10] != 0xFF )
{
LABEL_12:
v2 = 0LL;
while ( 1 )
{
v4 = (unsigned __int8)v3[v10];
if ( (v4 & 0xFFFFFFC0) == 0x40 || (~(_BYTE)v4 & 0x3F) != 0 && (v4 & 0xFFFFFFC0) == 0 )
break;
if ( v4 == 255 )
goto LABEL_23;
if ( translog_get_next_chunk((long long)v6) )
{
v2 = 1LL;
goto LABEL_23;
}
v3 = v8;
if ( v8 == (_BYTE *)&end_of_log )
goto LABEL_23;
}
if ( v4 == 255 )
goto LABEL_21;
v2 = v7 + v10;
goto LABEL_23;
}
}
}
else
{
v7 -= 0x2000LL;
v10 = 0x2000;
}
v2 = 1LL;
if ( !translog_get_next_chunk((long long)v6) )
{
v3 = v8;
if ( v8 != (_BYTE *)&end_of_log )
goto LABEL_12;
LABEL_21:
v2 = 0LL;
}
LABEL_23:
translog_free_link(v9);
return v2;
}
return 0LL;
}
| translog_next_LSN:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x2038
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x20],RAX
TEST RSI,RSI
JNZ 0x0014d8fc
CALL 0x0014bf54
MOV RSI,RAX
LAB_0014d8fc:
CMP RSI,RBX
JNZ 0x0014d908
XOR EBX,EBX
JMP 0x0014d9ee
LAB_0014d908:
LEA RDX,[RBP + -0x2050]
MOV RDI,RBX
XOR ESI,ESI
MOV ECX,0x1
CALL 0x0014ac5b
TEST EBX,0x1fff
JZ 0x0014d93d
MOV EAX,dword ptr [RBP + -0x28]
CMP RAX,0x1fff
JA 0x0014d94c
MOV RCX,qword ptr [RBP + -0x38]
CMP byte ptr [RCX + RAX*0x1],0xff
JNZ 0x0014d975
JMP 0x0014d94c
LAB_0014d93d:
ADD qword ptr [RBP + -0x50],-0x2000
MOV dword ptr [RBP + -0x28],0x2000
LAB_0014d94c:
LEA RDI,[RBP + -0x2050]
CALL 0x0014ad02
MOV EBX,0x1
TEST AL,AL
JNZ 0x0014d9e5
MOV RCX,qword ptr [RBP + -0x38]
LEA RAX,[0xcff6e0]
CMP RCX,RAX
JZ 0x0014d9dc
LAB_0014d975:
XOR EBX,EBX
LEA R14,[RBP + -0x2050]
LEA R15,[0xcff6e0]
LAB_0014d985:
MOV EAX,dword ptr [RBP + -0x28]
MOVZX ECX,byte ptr [RCX + RAX*0x1]
MOV EDX,ECX
AND EDX,0xffffffc0
CMP EDX,0x40
JZ 0x0014d9cb
TEST EDX,EDX
SETZ DL
MOV ESI,ECX
NOT ESI
TEST SIL,0x3f
SETNZ SIL
TEST DL,SIL
JNZ 0x0014d9cb
CMP ECX,0xff
JZ 0x0014d9e5
MOV RDI,R14
CALL 0x0014ad02
TEST AL,AL
JNZ 0x0014d9e0
MOV RCX,qword ptr [RBP + -0x38]
CMP RCX,R15
JNZ 0x0014d985
JMP 0x0014d9e5
LAB_0014d9cb:
CMP ECX,0xff
JZ 0x0014d9dc
ADD RAX,qword ptr [RBP + -0x50]
MOV RBX,RAX
JMP 0x0014d9e5
LAB_0014d9dc:
XOR EBX,EBX
JMP 0x0014d9e5
LAB_0014d9e0:
MOV EBX,0x1
LAB_0014d9e5:
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x0014c00e
LAB_0014d9ee:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x0014da0e
MOV RAX,RBX
ADD RSP,0x2038
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0014da0e:
CALL 0x00129270
|
long translog_next_LSN(ulong param_1,ulong param_2)
{
byte bVar1;
char cVar2;
long lVar3;
long in_FS_OFFSET;
int1 local_2058 [8192];
long local_58;
int1 *local_40;
int8 local_38;
uint local_30;
long local_28;
local_28 = *(long *)(in_FS_OFFSET + 0x28);
if (param_2 == 0) {
param_2 = translog_get_horizon();
}
if (param_2 == param_1) {
lVar3 = 0;
goto LAB_0014d9ee;
}
translog_scanner_init(param_1,0,local_2058,1);
if ((param_1 & 0x1fff) == 0) {
local_58 = local_58 + -0x2000;
local_30 = 0x2000;
LAB_0014d94c:
cVar2 = translog_get_next_chunk(local_2058);
lVar3 = 1;
if (cVar2 == '\0') {
if (local_40 != &end_of_log) goto LAB_0014d975;
LAB_0014d9dc:
lVar3 = 0;
}
}
else {
if ((0x1fff < (ulong)local_30) || (local_40[local_30] == -1)) goto LAB_0014d94c;
LAB_0014d975:
lVar3 = 0;
do {
bVar1 = local_40[local_30];
if (((bVar1 & 0xc0) == 0x40) || ((bVar1 & 0xc0) == 0 && (~bVar1 & 0x3f) != 0)) {
if (bVar1 == 0xff) goto LAB_0014d9dc;
lVar3 = (ulong)local_30 + local_58;
break;
}
if (bVar1 == 0xff) break;
cVar2 = translog_get_next_chunk(local_2058);
if (cVar2 != '\0') {
lVar3 = 1;
break;
}
} while (local_40 != &end_of_log);
}
translog_free_link(local_38);
LAB_0014d9ee:
if (*(long *)(in_FS_OFFSET + 0x28) != local_28) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return lVar3;
}
| |
48,387 | my_weight_utf32_general_ci | eloqsql/strings/ctype-ucs2.c | static inline int my_weight_utf32_general_ci(uchar b0, uchar b1,
uchar b2, uchar b3)
{
my_wc_t wc= MY_UTF32_WC4(b0, b1, b2, b3);
if (wc <= 0xFFFF)
{
MY_UNICASE_CHARACTER *page= my_unicase_default_pages[wc >> 8];
return (int) (page ? page[wc & 0xFF].sort : wc);
}
return MY_CS_REPLACEMENT_CHARACTER;
} | O0 | c | my_weight_utf32_general_ci:
pushq %rbp
movq %rsp, %rbp
movb %cl, %al
movb %dl, %cl
movb %sil, %dl
movb %dil, %sil
movb %sil, -0x5(%rbp)
movb %dl, -0x6(%rbp)
movb %cl, -0x7(%rbp)
movb %al, -0x8(%rbp)
movzbl -0x5(%rbp), %eax
shlq $0x18, %rax
movzbl -0x6(%rbp), %ecx
shll $0x10, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movzbl -0x7(%rbp), %ecx
shll $0x8, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movzbl -0x8(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
cmpq $0xffff, -0x10(%rbp) # imm = 0xFFFF
ja 0x6fc00
movq -0x10(%rbp), %rcx
shrq $0x8, %rcx
leaq 0x30cd6f(%rip), %rax # 0x37c930
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6fbef
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
andq $0xff, %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movq %rax, -0x20(%rbp)
jmp 0x6fbf7
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0x6fc07
movl $0xfffd, -0x4(%rbp) # imm = 0xFFFD
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
| my_weight_utf32_general_ci:
push rbp
mov rbp, rsp
mov al, cl
mov cl, dl
mov dl, sil
mov sil, dil
mov [rbp+var_5], sil
mov [rbp+var_6], dl
mov [rbp+var_7], cl
mov [rbp+var_8], al
movzx eax, [rbp+var_5]
shl rax, 18h
movzx ecx, [rbp+var_6]
shl ecx, 10h
movsxd rcx, ecx
add rax, rcx
movzx ecx, [rbp+var_7]
shl ecx, 8
movsxd rcx, ecx
add rax, rcx
movzx ecx, [rbp+var_8]
add rax, rcx
mov [rbp+var_10], rax
cmp [rbp+var_10], 0FFFFh
ja short loc_6FC00
mov rcx, [rbp+var_10]
shr rcx, 8
lea rax, my_unicase_default_pages
mov rax, [rax+rcx*8]
mov [rbp+var_18], rax
cmp [rbp+var_18], 0
jz short loc_6FBEF
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
and rcx, 0FFh
imul rcx, 0Ch
add rax, rcx
mov eax, [rax+8]
mov [rbp+var_20], rax
jmp short loc_6FBF7
loc_6FBEF:
mov rax, [rbp+var_10]
mov [rbp+var_20], rax
loc_6FBF7:
mov rax, [rbp+var_20]
mov [rbp+var_4], eax
jmp short loc_6FC07
loc_6FC00:
mov [rbp+var_4], 0FFFDh
loc_6FC07:
mov eax, [rbp+var_4]
pop rbp
retn
| long long my_weight_utf32_general_ci(
unsigned __int8 a1,
unsigned __int8 a2,
unsigned __int8 a3,
unsigned __int8 a4)
{
long long v6; // [rsp+8h] [rbp-18h]
unsigned long long v7; // [rsp+10h] [rbp-10h]
v7 = a4 + (a3 << 8) + (a2 << 16) + ((unsigned long long)a1 << 24);
if ( v7 > 0xFFFF )
{
return 65533;
}
else
{
v6 = (long long)*(&my_unicase_default_pages + (v7 >> 8));
if ( v6 )
return *(unsigned int *)(12LL * a4 + v6 + 8);
else
return (unsigned int)(a4 + (a3 << 8) + (a2 << 16) + (a1 << 24));
}
}
| my_weight_utf32_general_ci:
PUSH RBP
MOV RBP,RSP
MOV AL,CL
MOV CL,DL
MOV DL,SIL
MOV SIL,DIL
MOV byte ptr [RBP + -0x5],SIL
MOV byte ptr [RBP + -0x6],DL
MOV byte ptr [RBP + -0x7],CL
MOV byte ptr [RBP + -0x8],AL
MOVZX EAX,byte ptr [RBP + -0x5]
SHL RAX,0x18
MOVZX ECX,byte ptr [RBP + -0x6]
SHL ECX,0x10
MOVSXD RCX,ECX
ADD RAX,RCX
MOVZX ECX,byte ptr [RBP + -0x7]
SHL ECX,0x8
MOVSXD RCX,ECX
ADD RAX,RCX
MOVZX ECX,byte ptr [RBP + -0x8]
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
CMP qword ptr [RBP + -0x10],0xffff
JA 0x0016fc00
MOV RCX,qword ptr [RBP + -0x10]
SHR RCX,0x8
LEA RAX,[0x47c930]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x18],RAX
CMP qword ptr [RBP + -0x18],0x0
JZ 0x0016fbef
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
AND RCX,0xff
IMUL RCX,RCX,0xc
ADD RAX,RCX
MOV EAX,dword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0016fbf7
LAB_0016fbef:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x20],RAX
LAB_0016fbf7:
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0016fc07
LAB_0016fc00:
MOV dword ptr [RBP + -0x4],0xfffd
LAB_0016fc07:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 my_weight_utf32_general_ci(byte param_1,byte param_2,byte param_3,byte param_4)
{
ulong local_28;
int4 local_c;
local_28 = (ulong)param_1 * 0x1000000 + (long)(int)((uint)param_2 << 0x10) +
(long)(int)((uint)param_3 << 8) + (ulong)param_4;
if (local_28 < 0x10000) {
if (*(long *)(my_unicase_default_pages + (local_28 >> 8) * 8) != 0) {
local_28 = (ulong)*(uint *)(*(long *)(my_unicase_default_pages + (local_28 >> 8) * 8) +
(local_28 & 0xff) * 0xc + 8);
}
local_c = (int4)local_28;
}
else {
local_c = 0xfffd;
}
return local_c;
}
| |
48,388 | my_numchars_utf16 | eloqsql/strings/ctype-ucs2.c | static size_t
my_numchars_utf16(CHARSET_INFO *cs,
const char *b, const char *e)
{
size_t nchars= 0;
for ( ; ; nchars++)
{
size_t charlen= my_ismbchar(cs, b, e);
if (!charlen)
break;
b+= charlen;
}
return nchars;
} | O3 | c | my_numchars_utf16:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0xb8(%rdi), %rax
callq *0xc0(%rax)
xorl %r12d, %r12d
cmpl $0x2, %eax
jl 0x7e0ee
movl %eax, %eax
addq %rax, %r14
incq %r12
movq 0xb8(%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *0xc0(%rax)
cmpl $0x1, %eax
jg 0x7e0cb
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| my_numchars_utf16:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov rbx, rdx
mov r14, rsi
mov r15, rdi
mov rax, [rdi+0B8h]
call qword ptr [rax+0C0h]
xor r12d, r12d
cmp eax, 2
jl short loc_7E0EE
loc_7E0CB:
mov eax, eax
add r14, rax
inc r12
mov rax, [r15+0B8h]
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call qword ptr [rax+0C0h]
cmp eax, 1
jg short loc_7E0CB
loc_7E0EE:
mov rax, r12
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long my_numchars_utf16(long long a1, long long a2, long long a3)
{
int v5; // eax
long long v6; // r12
v5 = (*(long long (**)(void))(*(_QWORD *)(a1 + 184) + 192LL))();
v6 = 0LL;
if ( v5 >= 2 )
{
do
{
a2 += (unsigned int)v5;
++v6;
v5 = (*(long long ( **)(long long, long long, long long))(*(_QWORD *)(a1 + 184) + 192LL))(a1, a2, a3);
}
while ( v5 > 1 );
}
return v6;
}
| my_numchars_utf16:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
MOV RAX,qword ptr [RDI + 0xb8]
CALL qword ptr [RAX + 0xc0]
XOR R12D,R12D
CMP EAX,0x2
JL 0x0017e0ee
LAB_0017e0cb:
MOV EAX,EAX
ADD R14,RAX
INC R12
MOV RAX,qword ptr [R15 + 0xb8]
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL qword ptr [RAX + 0xc0]
CMP EAX,0x1
JG 0x0017e0cb
LAB_0017e0ee:
MOV RAX,R12
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
long my_numchars_utf16(long param_1,long param_2,int8 param_3)
{
uint uVar1;
long lVar2;
uVar1 = (**(code **)(*(long *)(param_1 + 0xb8) + 0xc0))();
lVar2 = 0;
while (1 < (int)uVar1) {
param_2 = param_2 + (ulong)uVar1;
lVar2 = lVar2 + 1;
uVar1 = (**(code **)(*(long *)(param_1 + 0xb8) + 0xc0))(param_1,param_2,param_3);
}
return lVar2;
}
| |
48,389 | minja::CallExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const | monkey531[P]llama/common/minja.hpp | Value do_evaluate(const std::shared_ptr<Context> & context) const override {
if (!object) throw std::runtime_error("CallExpr.object is null");
auto obj = object->evaluate(context);
if (!obj.is_callable()) {
throw std::runtime_error("Object is not callable: " + obj.dump(2));
}
auto vargs = args.evaluate(context);
return obj.call(context, vargs);
} | O3 | cpp | minja::CallExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r15
movq 0x20(%rsi), %rsi
testq %rsi, %rsi
je 0x94d3a
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x50(%rsp), %r12
movq %r12, %rdi
callq 0x85d64
cmpq $0x0, 0x30(%r12)
je 0x94d6c
addq $0x30, %r15
movq %rsp, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x922de
leaq 0x50(%rsp), %rsi
movq %rsp, %rcx
movq %rbx, %rdi
movq %r14, %rdx
callq 0x9365e
leaq 0x18(%rsp), %rdi
callq 0x949a6
movq %rsp, %rdi
callq 0x8d838
leaq 0x90(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x586c0
movq %r14, %rdi
callq 0x5dbae
movq -0x8(%r14), %rdi
testq %rdi, %rdi
je 0x94cd3
callq 0x6d59a
movq 0x78(%rsp), %rdi
testq %rdi, %rdi
je 0x94ce2
callq 0x6d59a
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x94cf1
callq 0x6d59a
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x94d27
movq 0x97286(%rip), %rax # 0x12bf88
cmpb $0x0, (%rax)
je 0x94d12
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x94d1c
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x94d27
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rax
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x1a450
movq %rax, %rbx
leaq 0x5b816(%rip), %rsi # 0xf0564
movq %rax, %rdi
callq 0x1a330
movq 0x97293(%rip), %rsi # 0x12bff0
movq 0x971fc(%rip), %rdx # 0x12bf60
movq %rbx, %rdi
callq 0x1af40
movl $0x10, %edi
callq 0x1a450
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rsi
movl $0x2, %edx
xorl %ecx, %ecx
callq 0x86378
leaq 0x5ba69(%rip), %rsi # 0xf07ff
movq %rsp, %rdi
leaq 0x30(%rsp), %rdx
callq 0x78b0d
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1ae50
xorl %ebp, %ebp
movq 0x97236(%rip), %rsi # 0x12bff0
movq 0x9719f(%rip), %rdx # 0x12bf60
movq %rbx, %rdi
callq 0x1af40
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x94de7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a8d0
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x94e02
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1a8d0
testb %bpl, %bpl
jne 0x94e2c
jmp 0x94e5d
movq %rax, %r14
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x94e2c
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1a8d0
jmp 0x94e2c
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a680
jmp 0x94e5d
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a680
jmp 0x94e67
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x949a6
movq %rsp, %rdi
callq 0x8d838
jmp 0x94e5d
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0x86056
movq %r14, %rdi
callq 0x1afc0
nop
| _ZNK5minja8CallExpr11do_evaluateERKSt10shared_ptrINS_7ContextEE:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 0A0h
mov r15, rsi
mov rsi, [rsi+20h]
test rsi, rsi
jz loc_94D3A
mov r14, rdx
mov rbx, rdi
lea r12, [rsp+0C8h+var_78]
mov rdi, r12
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
cmp qword ptr [r12+30h], 0
jz loc_94D6C
add r15, 30h ; '0'
mov rdi, rsp
mov rsi, r15
mov rdx, r14
call _ZNK5minja19ArgumentsExpression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::ArgumentsExpression::evaluate(std::shared_ptr<minja::Context> const&)
lea rsi, [rsp+0C8h+var_78]
mov rcx, rsp
mov rdi, rbx
mov rdx, r14
call _ZNK5minja5Value4callERKSt10shared_ptrINS_7ContextEERNS_14ArgumentsValueE; minja::Value::call(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)
lea rdi, [rsp+0C8h+var_B0]
call _ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN5minja5ValueEESaIS9_EED2Ev; std::vector<std::pair<std::string,minja::Value>>::~vector()
mov rdi, rsp
call _ZNSt6vectorIN5minja5ValueESaIS1_EED2Ev; std::vector<minja::Value>::~vector()
lea r14, [rsp+0C8h+var_38]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [r14-8]
test rdi, rdi
jz short loc_94CD3
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_94CD3:
mov rdi, [rsp+0C8h+var_50]
test rdi, rdi
jz short loc_94CE2
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_94CE2:
mov rdi, [rsp+0C8h+var_60]
test rdi, rdi
jz short loc_94CF1
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_94CF1:
mov rdi, [rsp+0C8h+var_70]
test rdi, rdi
jz short loc_94D27
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_94D12
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_94D1C
loc_94D12:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_94D1C:
cmp eax, 1
jnz short loc_94D27
mov rax, [rdi]
call qword ptr [rax+18h]
loc_94D27:
mov rax, rbx
add rsp, 0A0h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_94D3A:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aMethodcallexpr+6; char *
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_94D6C:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+0C8h+var_98]
lea rsi, [rsp+0C8h+var_78]
mov edx, 2
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aObjectIsNotCal; "Object is not callable: "
mov rdi, rsp
lea rdx, [rsp+0C8h+var_98]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
mov rsi, rsp
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+0C8h+var_B8]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_94DE7
mov rsi, [rsp+0C8h+var_B8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_94DE7:
lea rax, [rsp+0C8h+var_88]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_94E02
mov rsi, [rsp+0C8h+var_88]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_94E02:
test bpl, bpl
jnz short loc_94E2C
jmp short loc_94E5D
mov r14, rax
lea rax, [rsp+0C8h+var_88]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_94E2C
mov rsi, [rsp+0C8h+var_88]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_94E2C
mov r14, rax
loc_94E2C:
mov rdi, rbx; void *
call ___cxa_free_exception
jmp short loc_94E5D
mov r14, rax
mov rdi, rbx; void *
call ___cxa_free_exception
jmp short loc_94E67
mov r14, rax
lea rdi, [rsp+0C8h+var_B0]
call _ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN5minja5ValueEESaIS9_EED2Ev; std::vector<std::pair<std::string,minja::Value>>::~vector()
mov rdi, rsp
call _ZNSt6vectorIN5minja5ValueESaIS1_EED2Ev; std::vector<minja::Value>::~vector()
jmp short loc_94E5D
mov r14, rax
loc_94E5D:
lea rdi, [rsp+0C8h+var_78]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_94E67:
mov rdi, r14
call __Unwind_Resume
| long long minja::CallExpr::do_evaluate(long long a1, long long a2, long long a3)
{
void (***v4)(void); // rsi
long long v7; // rdi
signed __int32 v8; // eax
std::runtime_error *exception; // rbx
void *v11; // rbx
__int128 v12; // [rsp+0h] [rbp-C8h] BYREF
char *v13; // [rsp+18h] [rbp-B0h] BYREF
_BYTE v14[16]; // [rsp+30h] [rbp-98h] BYREF
_BYTE v15[8]; // [rsp+50h] [rbp-78h] BYREF
long long v16; // [rsp+58h] [rbp-70h]
volatile signed __int32 *v17; // [rsp+68h] [rbp-60h]
volatile signed __int32 *v18; // [rsp+78h] [rbp-50h]
long long v19; // [rsp+80h] [rbp-48h]
volatile signed __int32 *v20; // [rsp+88h] [rbp-40h]
char v21[56]; // [rsp+90h] [rbp-38h] BYREF
v4 = *(void (****)(void))(a2 + 32);
if ( !v4 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "CallExpr.object is null");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
minja::Expression::evaluate((long long)v15, v4);
if ( !v19 )
{
v11 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v14, (long long)v15, 2u, 0);
std::operator+<char>((long long)&v12, (long long)"Object is not callable: ", (long long)v14);
std::runtime_error::runtime_error(v11, &v12);
__cxa_throw(
v11,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
minja::ArgumentsExpression::evaluate(&v12, (_QWORD *)(a2 + 48), a3);
minja::Value::call(a1, (long long)v15);
std::vector<std::pair<std::string,minja::Value>>::~vector(&v13);
std::vector<minja::Value>::~vector(&v12);
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(v21);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v21);
if ( v20 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v20);
if ( v18 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v18);
if ( v17 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v17);
v7 = v16;
if ( v16 )
{
if ( _libc_single_threaded )
{
v8 = *(_DWORD *)(v16 + 12);
*(_DWORD *)(v16 + 12) = v8 - 1;
}
else
{
v8 = _InterlockedExchangeAdd((volatile signed __int32 *)(v16 + 12), 0xFFFFFFFF);
}
if ( v8 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v7 + 24LL))(v7, 0LL);
}
return a1;
}
| do_evaluate:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0xa0
MOV R15,RSI
MOV RSI,qword ptr [RSI + 0x20]
TEST RSI,RSI
JZ 0x00194d3a
MOV R14,RDX
MOV RBX,RDI
LEA R12,[RSP + 0x50]
MOV RDI,R12
CALL 0x00185d64
CMP qword ptr [R12 + 0x30],0x0
JZ 0x00194d6c
ADD R15,0x30
LAB_00194c78:
MOV RDI,RSP
MOV RSI,R15
MOV RDX,R14
CALL 0x001922de
LAB_00194c86:
LEA RSI,[RSP + 0x50]
MOV RCX,RSP
MOV RDI,RBX
MOV RDX,R14
CALL 0x0019365e
LAB_00194c99:
LEA RDI,[RSP + 0x18]
CALL 0x001949a6
MOV RDI,RSP
CALL 0x0018d838
LEA R14,[RSP + 0x90]
MOV RDI,R14
XOR ESI,ESI
CALL 0x001586c0
MOV RDI,R14
CALL 0x0015dbae
MOV RDI,qword ptr [R14 + -0x8]
TEST RDI,RDI
JZ 0x00194cd3
CALL 0x0016d59a
LAB_00194cd3:
MOV RDI,qword ptr [RSP + 0x78]
TEST RDI,RDI
JZ 0x00194ce2
CALL 0x0016d59a
LAB_00194ce2:
MOV RDI,qword ptr [RSP + 0x68]
TEST RDI,RDI
JZ 0x00194cf1
CALL 0x0016d59a
LAB_00194cf1:
MOV RDI,qword ptr [RSP + 0x58]
TEST RDI,RDI
JZ 0x00194d27
MOV RAX,qword ptr [0x0022bf88]
CMP byte ptr [RAX],0x0
JZ 0x00194d12
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x00194d1c
LAB_00194d12:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_00194d1c:
CMP EAX,0x1
JNZ 0x00194d27
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_00194d27:
MOV RAX,RBX
ADD RSP,0xa0
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00194d3a:
MOV EDI,0x10
CALL 0x0011a450
MOV RBX,RAX
LAB_00194d47:
LEA RSI,[0x1f0564]
MOV RDI,RAX
CALL 0x0011a330
LAB_00194d56:
MOV RSI,qword ptr [0x0022bff0]
MOV RDX,qword ptr [0x0022bf60]
MOV RDI,RBX
CALL 0x0011af40
LAB_00194d6c:
MOV EDI,0x10
CALL 0x0011a450
MOV RBX,RAX
LAB_00194d79:
LEA RDI,[RSP + 0x30]
LEA RSI,[RSP + 0x50]
MOV EDX,0x2
XOR ECX,ECX
CALL 0x00186378
LAB_00194d8f:
LEA RSI,[0x1f07ff]
MOV RDI,RSP
LEA RDX,[RSP + 0x30]
CALL 0x00178b0d
MOV BPL,0x1
LAB_00194da6:
MOV RSI,RSP
MOV RDI,RBX
CALL 0x0011ae50
XOR EBP,EBP
MOV RSI,qword ptr [0x0022bff0]
MOV RDX,qword ptr [0x0022bf60]
MOV RDI,RBX
CALL 0x0011af40
|
/* minja::CallExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const */
CallExpr * __thiscall minja::CallExpr::do_evaluate(CallExpr *this,shared_ptr *param_1)
{
int *piVar1;
int iVar2;
runtime_error *prVar3;
shared_ptr asStack_c8 [24];
vector<std::pair<std::__cxx11::string,minja::Value>,std::allocator<std::pair<std::__cxx11::string,minja::Value>>>
local_b0 [24];
int1 local_98 [32];
Expression local_78 [8];
long *local_70;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_60;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_50;
long local_48;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_40;
data local_38 [16];
if (*(shared_ptr **)(param_1 + 0x20) == (shared_ptr *)0x0) {
prVar3 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00194d47 to 00194d55 has its CatchHandler @ 00194e36 */
std::runtime_error::runtime_error(prVar3,"CallExpr.object is null");
/* WARNING: Subroutine does not return */
__cxa_throw(prVar3,PTR_typeinfo_0022bff0,PTR__runtime_error_0022bf60);
}
Expression::evaluate(local_78,*(shared_ptr **)(param_1 + 0x20));
if (local_48 != 0) {
/* try { // try from 00194c78 to 00194c85 has its CatchHandler @ 00194e5a */
ArgumentsExpression::evaluate(asStack_c8);
/* try { // try from 00194c86 to 00194c98 has its CatchHandler @ 00194e43 */
Value::call((shared_ptr *)this,(ArgumentsValue *)local_78);
std::
vector<std::pair<std::__cxx11::string,minja::Value>,std::allocator<std::pair<std::__cxx11::string,minja::Value>>>
::~vector(local_b0);
std::vector<minja::Value,std::allocator<minja::Value>>::~vector
((vector<minja::Value,std::allocator<minja::Value>> *)asStack_c8);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_38,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_38);
if (local_40 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_40);
}
if (local_50 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_50);
}
if (local_60 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_60);
}
if (local_70 != (long *)0x0) {
if (*PTR___libc_single_threaded_0022bf88 == '\0') {
LOCK();
piVar1 = (int *)((long)local_70 + 0xc);
iVar2 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar2 = *(int *)((long)local_70 + 0xc);
*(int *)((long)local_70 + 0xc) = iVar2 + -1;
}
if (iVar2 == 1) {
(**(code **)(*local_70 + 0x18))();
}
}
return this;
}
prVar3 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00194d79 to 00194d8e has its CatchHandler @ 00194e29 */
Value::dump_abi_cxx11_((int)local_98,SUB81(local_78,0));
/* try { // try from 00194d8f to 00194da2 has its CatchHandler @ 00194e09 */
std::operator+((char *)asStack_c8,(string *)"Object is not callable: ");
/* try { // try from 00194da6 to 00194dc8 has its CatchHandler @ 00194dc9 */
std::runtime_error::runtime_error(prVar3,(string *)asStack_c8);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar3,PTR_typeinfo_0022bff0,PTR__runtime_error_0022bf60);
}
| |
48,390 | coro::detail::make_task_self_deleting(coro::task<void>) | AlayaLite/build_O3/_deps/libcoro-src/src/detail/task_self_deleting.cpp | auto make_task_self_deleting(coro::task<void> user_task) -> task_self_deleting
{
co_await user_task;
co_return;
} | O3 | cpp | coro::detail::make_task_self_deleting(coro::task<void>):
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x0, 0x28(%rdi)
je 0x4a55
movq 0x18(%rbx), %rdi
jmp 0x4a78
movq 0x20(%rbx), %rdi
movq %rdi, 0x18(%rbx)
cmpq $0x0, (%rdi)
je 0x4a78
movb $0x1, 0x28(%rbx)
movq %rbx, 0x10(%rdi)
movq 0x18(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *(%rdi)
addq $0x10, %rdi
callq 0x343e
leaq 0x10(%rbx), %rdi
movq (%rdi), %rax
testq %rax, %rax
je 0x4a91
lock
decq (%rax)
movq 0x20(%rbx), %r14
callq 0x4938
testq %r14, %r14
je 0x4aa6
movq 0x20(%rbx), %rdi
callq *0x8(%rdi)
movl $0x30, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2170
movq %rax, %rdi
callq 0x2d32
movq %rax, %rdi
callq 0x2090
callq 0x2210
jmp 0x4a81
movq $0x0, (%rbx)
movq %rax, %rdi
callq 0x2250
| _ZN4coro6detail23make_task_self_deletingENS_4taskIvEE_resume:
push r14
push rbx
push rax
mov rbx, rdi
cmp byte ptr [rdi+28h], 0
jz short loc_4A55
mov rdi, [rbx+18h]
jmp short loc_4A78
loc_4A55:
mov rdi, [rbx+20h]
mov [rbx+18h], rdi
cmp qword ptr [rdi], 0
jz short loc_4A78
mov byte ptr [rbx+28h], 1
mov [rdi+10h], rbx
mov rdi, [rbx+18h]
add rsp, 8
pop rbx
pop r14
jmp qword ptr [rdi]
loc_4A78:
add rdi, 10h
call _ZN4coro6detail7promiseIvE6resultEv; coro::detail::promise<void>::result(void)
loc_4A81:
lea rdi, [rbx+10h]; this
mov rax, [rdi]
test rax, rax
jz short loc_4A91
lock dec qword ptr [rax]
loc_4A91:
mov r14, [rbx+20h]
call _ZN4coro6detail21promise_self_deletingD2Ev; coro::detail::promise_self_deleting::~promise_self_deleting()
test r14, r14
jz short loc_4AA6
mov rdi, [rbx+20h]
call qword ptr [rdi+8]
loc_4AA6:
mov esi, 30h ; '0'; unsigned __int64
mov rdi, rbx; void *
add rsp, 8
pop rbx
pop r14
jmp __ZdlPvm; operator delete(void *,ulong)
mov rdi, rax
call __clang_call_terminate
mov rdi, rax; void *
call ___cxa_begin_catch
call ___cxa_end_catch
jmp short loc_4A81
mov qword ptr [rbx], 0
mov rdi, rax
call __Unwind_Resume
| void coro::detail::make_task_self_deleting(_QWORD *a1)
{
_QWORD *v2; // rdi
volatile signed long long *v3; // rax
long long v4; // r14
if ( *((_BYTE *)a1 + 40) )
{
v2 = (_QWORD *)a1[3];
}
else
{
v2 = (_QWORD *)a1[4];
a1[3] = v2;
if ( *v2 )
{
*((_BYTE *)a1 + 40) = 1;
v2[2] = a1;
(*(void (**)(void))a1[3])();
return;
}
}
coro::detail::promise<void>::result((long long)(v2 + 2));
v3 = (volatile signed long long *)a1[2];
if ( v3 )
_InterlockedDecrement64(v3);
v4 = a1[4];
coro::detail::promise_self_deleting::~promise_self_deleting((coro::detail::promise_self_deleting *)(a1 + 2));
if ( v4 )
(*(void ( **)(_QWORD))(a1[4] + 8LL))(a1[4]);
operator delete(a1, 0x30uLL);
}
| make_task_self_deleting:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
CMP byte ptr [RDI + 0x28],0x0
JZ 0x00104a55
MOV RDI,qword ptr [RBX + 0x18]
JMP 0x00104a78
LAB_00104a55:
MOV RDI,qword ptr [RBX + 0x20]
MOV qword ptr [RBX + 0x18],RDI
CMP qword ptr [RDI],0x0
JZ 0x00104a78
MOV byte ptr [RBX + 0x28],0x1
MOV qword ptr [RDI + 0x10],RBX
MOV RDI,qword ptr [RBX + 0x18]
ADD RSP,0x8
POP RBX
POP R14
JMP qword ptr [RDI]
LAB_00104a78:
ADD RDI,0x10
LAB_00104a7c:
CALL 0x0010343e
LAB_00104a81:
LEA RDI,[RBX + 0x10]
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x00104a91
DEC.LOCK qword ptr [RAX]
LAB_00104a91:
MOV R14,qword ptr [RBX + 0x20]
CALL 0x00104938
TEST R14,R14
JZ 0x00104aa6
MOV RDI,qword ptr [RBX + 0x20]
LAB_00104aa3:
CALL qword ptr [RDI + 0x8]
LAB_00104aa6:
MOV ESI,0x30
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R14
JMP 0x00102170
|
/* coro::detail::make_task_self_deleting(coro::task<void>) [clone .resume] */
void coro::detail::make_task_self_deleting(void *param_1)
{
long lVar1;
long *plVar2;
if (*(char *)((long)param_1 + 0x28) == '\0') {
plVar2 = *(long **)((long)param_1 + 0x20);
*(long **)((long)param_1 + 0x18) = plVar2;
if (*plVar2 != 0) {
*(int1 *)((long)param_1 + 0x28) = 1;
plVar2[2] = (long)param_1;
/* WARNING: Could not recover jumptable at 0x00104a76. Too many branches */
/* WARNING: Treating indirect jump as call */
(*(code *)**(int8 **)((long)param_1 + 0x18))();
return;
}
}
else {
plVar2 = *(long **)((long)param_1 + 0x18);
}
/* try { // try from 00104a7c to 00104a80 has its CatchHandler @ 00104ac2 */
promise<void>::result((promise<void> *)(plVar2 + 2));
plVar2 = *(long **)((long)param_1 + 0x10);
if (plVar2 != (long *)0x0) {
LOCK();
*plVar2 = *plVar2 + -1;
UNLOCK();
}
lVar1 = *(long *)((long)param_1 + 0x20);
promise_self_deleting::~promise_self_deleting((promise_self_deleting *)((long)param_1 + 0x10));
if (lVar1 != 0) {
/* try { // try from 00104aa3 to 00104aa5 has its CatchHandler @ 00104aba */
(**(code **)(*(long *)((long)param_1 + 0x20) + 8))();
}
operator_delete(param_1,0x30);
return;
}
| |
48,391 | common_sampler_print[abi:cxx11](common_sampler const*) | monkey531[P]llama/common/sampling.cpp | std::string common_sampler_print(const struct common_sampler * gsmpl) {
std::string result = "logits ";
for (int i = 0; i < llama_sampler_chain_n(gsmpl->chain); i++) {
const auto * smpl = llama_sampler_chain_get(gsmpl->chain, i);
result += std::string("-> ") + llama_sampler_name(smpl) + " ";
}
return result;
} | O2 | cpp | common_sampler_print[abi:cxx11](common_sampler const*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
leaq 0x19e89(%rip), %rsi # 0xb1d2e
leaq 0x58(%rsp), %r15
movq %rdi, 0x10(%rsp)
movq %r15, %rdx
callq 0x2746a
xorl %ebp, %ebp
leaq 0x18(%rsp), %r13
leaq 0x38(%rsp), %r12
movq 0x140(%r14), %rdi
callq 0x23f60
cmpl %eax, %ebp
jge 0x97f4c
movq 0x140(%r14), %rdi
movl %ebp, %esi
callq 0x239d0
movq %rax, %rbx
movq %r13, %rdi
leaq 0x20596(%rip), %rsi # 0xb8484
leaq 0xf(%rsp), %rdx
callq 0x2746a
movq %rbx, %rdi
callq 0x23350
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x380bc
movq %r15, %rdi
movq %r12, %rsi
leaq 0x1a632(%rip), %rdx # 0xb254d
callq 0x380bc
movq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x24120
movq %r15, %rdi
callq 0x241b8
movq %r12, %rdi
callq 0x241b8
movq %r13, %rdi
callq 0x241b8
incl %ebp
jmp 0x97ec3
movq 0x10(%rsp), %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x97f82
movq %rax, %r14
leaq 0x58(%rsp), %rdi
callq 0x241b8
jmp 0x97f74
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x241b8
jmp 0x97f8a
jmp 0x97f82
movq %rax, %r14
jmp 0x97f94
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x241b8
movq 0x10(%rsp), %rdi
callq 0x241b8
movq %r14, %rdi
callq 0x23f80
| _Z20common_sampler_printB5cxx11PK14common_sampler:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 78h
mov r14, rsi
lea rsi, aLogits+2; "logits "
lea r15, [rsp+0A8h+var_50]
mov [rsp+0A8h+var_98], rdi
mov rdx, r15
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
xor ebp, ebp
lea r13, [rsp+0A8h+var_90]
lea r12, [rsp+0A8h+var_70]
loc_97EC3:
mov rdi, [r14+140h]
call _llama_sampler_chain_n
cmp ebp, eax
jge short loc_97F4C
mov rdi, [r14+140h]
mov esi, ebp
call _llama_sampler_chain_get
mov rbx, rax
mov rdi, r13
lea rsi, asc_B8484; "-> "
lea rdx, [rsp+0A8h+var_99]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
mov rdi, rbx
call _llama_sampler_name
mov rdi, r12
mov rsi, r13
mov rdx, rax
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
mov rdi, r15
mov rsi, r12
lea rdx, aForMessageInMe+144h; " "
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
mov rdi, [rsp+0A8h+var_98]
mov rsi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendERKS4_; std::string::append(std::string const&)
mov rdi, r15; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r12; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r13; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
inc ebp
jmp loc_97EC3
loc_97F4C:
mov rax, [rsp+0A8h+var_98]
add rsp, 78h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_97F82
mov r14, rax
lea rdi, [rsp+arg_50]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_97F74
mov r14, rax
loc_97F74:
lea rdi, [rsp+arg_30]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_97F8A
jmp short $+2
loc_97F82:
mov r14, rax
jmp short loc_97F94
mov r14, rax
loc_97F8A:
lea rdi, [rsp+arg_10]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_97F94:
mov rdi, [rsp+arg_8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r14
call __Unwind_Resume
| _QWORD * common_sampler_print[abi:cxx11](_QWORD *a1, long long a2)
{
int i; // ebp
long long v3; // rbx
long long v4; // rax
_QWORD v6[4]; // [rsp+18h] [rbp-90h] BYREF
_BYTE v7[32]; // [rsp+38h] [rbp-70h] BYREF
_BYTE v8[80]; // [rsp+58h] [rbp-50h] BYREF
std::string::basic_string<std::allocator<char>>(a1, (long long)"logits ");
for ( i = 0; i < (int)llama_sampler_chain_n(*(_QWORD *)(a2 + 320)); ++i )
{
v3 = llama_sampler_chain_get(*(_QWORD *)(a2 + 320), (unsigned int)i);
std::string::basic_string<std::allocator<char>>(v6, (long long)"-> ");
v4 = llama_sampler_name(v3);
std::operator+<char>((long long)v7, (long long)v6, v4);
std::operator+<char>((long long)v8, (long long)v7, (long long)" ");
std::string::append(a1, v8);
std::string::~string(v8);
std::string::~string(v7);
std::string::~string(v6);
}
return a1;
}
| common_sampler_print[abi:cxx11]:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x78
MOV R14,RSI
LEA RSI,[0x1b1d2e]
LEA R15,[RSP + 0x58]
MOV qword ptr [RSP + 0x10],RDI
MOV RDX,R15
CALL 0x0012746a
XOR EBP,EBP
LEA R13,[RSP + 0x18]
LEA R12,[RSP + 0x38]
LAB_00197ec3:
MOV RDI,qword ptr [R14 + 0x140]
LAB_00197eca:
CALL 0x00123f60
CMP EBP,EAX
JGE 0x00197f4c
MOV RDI,qword ptr [R14 + 0x140]
LAB_00197eda:
MOV ESI,EBP
CALL 0x001239d0
LAB_00197ee1:
MOV RBX,RAX
MOV RDI,R13
LEA RSI,[0x1b8484]
LEA RDX,[RSP + 0xf]
CALL 0x0012746a
LAB_00197ef8:
MOV RDI,RBX
CALL 0x00123350
MOV RDI,R12
MOV RSI,R13
MOV RDX,RAX
CALL 0x001380bc
LAB_00197f0e:
MOV RDI,R15
MOV RSI,R12
LEA RDX,[0x1b254d]
CALL 0x001380bc
LAB_00197f20:
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,R15
CALL 0x00124120
LAB_00197f2d:
MOV RDI,R15
CALL 0x001241b8
MOV RDI,R12
CALL 0x001241b8
MOV RDI,R13
CALL 0x001241b8
INC EBP
JMP 0x00197ec3
LAB_00197f4c:
MOV RAX,qword ptr [RSP + 0x10]
ADD RSP,0x78
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* common_sampler_print[abi:cxx11](common_sampler const*) */
common_sampler * common_sampler_print_abi_cxx11_(common_sampler *param_1)
{
int iVar1;
int8 uVar2;
int iVar3;
long in_RSI;
allocator local_99;
common_sampler *local_98;
string local_90 [32];
string local_70 [32];
string local_50 [32];
local_98 = param_1;
std::__cxx11::string::string<std::allocator<char>>
((string *)param_1,"logits ",(allocator *)local_50);
iVar3 = 0;
while( true ) {
/* try { // try from 00197eca to 00197ece has its CatchHandler @ 00197f82 */
iVar1 = llama_sampler_chain_n(*(int8 *)(in_RSI + 0x140));
if (iVar1 <= iVar3) break;
/* try { // try from 00197eda to 00197ee0 has its CatchHandler @ 00197f60 */
uVar2 = llama_sampler_chain_get(*(int8 *)(in_RSI + 0x140),iVar3);
/* try { // try from 00197ee1 to 00197ef7 has its CatchHandler @ 00197f80 */
std::__cxx11::string::string<std::allocator<char>>(local_90,"-> ",&local_99);
/* try { // try from 00197ef8 to 00197f0d has its CatchHandler @ 00197f87 */
llama_sampler_name(uVar2);
std::operator+(local_70,(char *)local_90);
/* try { // try from 00197f0e to 00197f1f has its CatchHandler @ 00197f71 */
std::operator+(local_50,(char *)local_70);
/* try { // try from 00197f20 to 00197f2c has its CatchHandler @ 00197f62 */
std::__cxx11::string::append((string *)local_98);
std::__cxx11::string::~string(local_50);
std::__cxx11::string::~string(local_70);
std::__cxx11::string::~string(local_90);
iVar3 = iVar3 + 1;
}
return local_98;
}
| |
48,392 | common_sampler_print[abi:cxx11](common_sampler const*) | monkey531[P]llama/common/sampling.cpp | std::string common_sampler_print(const struct common_sampler * gsmpl) {
std::string result = "logits ";
for (int i = 0; i < llama_sampler_chain_n(gsmpl->chain); i++) {
const auto * smpl = llama_sampler_chain_get(gsmpl->chain, i);
result += std::string("-> ") + llama_sampler_name(smpl) + " ";
}
return result;
} | O3 | cpp | common_sampler_print[abi:cxx11](common_sampler const*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
leaq 0x10(%rdi), %rax
movq %rax, 0x8(%rsp)
movq %rax, (%rdi)
leaq 0x2067a(%rip), %rsi # 0xedd4e
leaq 0x2067a(%rip), %rdx # 0xedd55
movq %rdi, 0x10(%rsp)
callq 0x21b26
leaq 0x48(%rsp), %rbx
xorl %ebp, %ebp
leaq 0x28(%rsp), %r12
leaq 0x58(%rsp), %r13
movq 0x140(%r14), %rdi
callq 0x1af70
cmpl %eax, %ebp
jge 0xcd848
movq 0x140(%r14), %rdi
movl %ebp, %esi
callq 0x1a9a0
movq %rax, %r15
leaq 0x68(%rsp), %rax
movq %rax, 0x58(%rsp)
movq %r13, %rdi
leaq 0x26d71(%rip), %rsi # 0xf44a0
leaq 0x26d6d(%rip), %rdx # 0xf44a3
callq 0x21b26
movq %r15, %rdi
callq 0x1a350
movq %r13, %rdi
movq %rax, %rsi
callq 0x1b0d0
movq %rbx, 0x38(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xcd771
movq %rdx, 0x38(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x48(%rsp)
jmp 0xcd777
movups (%rcx), %xmm0
movups %xmm0, (%rbx)
movq 0x8(%rax), %rdx
movq %rdx, 0x40(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x38(%rsp), %rdi
leaq 0x20dd2(%rip), %rsi # 0xee56d
callq 0x1b0d0
movq %r12, 0x18(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xcd7c3
movq %rdx, 0x18(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x28(%rsp)
jmp 0xcd7cb
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
movq %rdx, 0x20(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x10(%rsp), %rdi
callq 0x1a250
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0xcd80e
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x1a8c0
movq 0x38(%rsp), %rdi
cmpq %rbx, %rdi
je 0xcd825
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x1a8c0
movq 0x58(%rsp), %rdi
leaq 0x68(%rsp), %rax
cmpq %rax, %rdi
je 0xcd841
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x1a8c0
incl %ebp
jmp 0xcd6f6
movq 0x10(%rsp), %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xcd898
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0xcd87d
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x1a8c0
jmp 0xcd87d
movq %rax, %r14
movq 0x38(%rsp), %rdi
cmpq %rbx, %rdi
je 0xcd8a0
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x1a8c0
jmp 0xcd8a0
jmp 0xcd898
movq %rax, %r14
jmp 0xcd8bc
movq %rax, %r14
movq 0x58(%rsp), %rdi
leaq 0x68(%rsp), %rax
cmpq %rax, %rdi
je 0xcd8bc
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x1a8c0
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rcx), %rdi
cmpq %rax, %rdi
je 0xcd8d9
movq (%rax), %rsi
incq %rsi
callq 0x1a8c0
movq %r14, %rdi
callq 0x1af80
| _Z20common_sampler_printB5cxx11PK14common_sampler:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 78h
mov r14, rsi
lea rax, [rdi+10h]
mov [rsp+0A8h+var_A0], rax
mov [rdi], rax
lea rsi, aLogits+2; "logits "
lea rdx, aLogits+9; ""
mov [rsp+0A8h+var_98], rdi
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 rbx, [rsp+0A8h+var_60]
xor ebp, ebp
lea r12, [rsp+0A8h+var_80]
lea r13, [rsp+0A8h+var_50]
loc_CD6F6:
mov rdi, [r14+140h]
call _llama_sampler_chain_n
cmp ebp, eax
jge loc_CD848
mov rdi, [r14+140h]
mov esi, ebp
call _llama_sampler_chain_get
mov r15, rax
lea rax, [rsp+0A8h+var_40]
mov [rsp+0A8h+var_50], rax
mov rdi, r13
lea rsi, asc_F44A0; "-> "
lea rdx, asc_F44A0+3; ""
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 rdi, r15
call _llama_sampler_name
mov rdi, r13
mov rsi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov [rsp+0A8h+var_70], rbx
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_CD771
mov [rsp+0A8h+var_70], rdx
mov rdx, [rcx]
mov [rsp+0A8h+var_60], rdx
jmp short loc_CD777
loc_CD771:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [rbx], xmm0
loc_CD777:
mov rdx, [rax+8]
mov [rsp+0A8h+var_68], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
lea rdi, [rsp+0A8h+var_70]
lea rsi, aForMessageInMe+144h; " "
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov [rsp+0A8h+var_90], r12
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_CD7C3
mov [rsp+0A8h+var_90], rdx
mov rdx, [rcx]
mov [rsp+0A8h+var_80], rdx
jmp short loc_CD7CB
loc_CD7C3:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r12], xmm0
loc_CD7CB:
mov rdx, [rax+8]
mov [rsp+0A8h+var_88], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
mov rsi, [rsp+0A8h+var_90]
mov rdx, [rsp+0A8h+var_88]
mov rdi, [rsp+0A8h+var_98]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
mov rdi, [rsp+0A8h+var_90]; void *
cmp rdi, r12
jz short loc_CD80E
mov rsi, [rsp+0A8h+var_80]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_CD80E:
mov rdi, [rsp+0A8h+var_70]; void *
cmp rdi, rbx
jz short loc_CD825
mov rsi, [rsp+0A8h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_CD825:
mov rdi, [rsp+0A8h+var_50]; void *
lea rax, [rsp+0A8h+var_40]
cmp rdi, rax
jz short loc_CD841
mov rsi, [rsp+0A8h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_CD841:
inc ebp
jmp loc_CD6F6
loc_CD848:
mov rax, [rsp+0A8h+var_98]
add rsp, 78h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_CD898
mov r14, rax
mov rdi, [rsp+arg_10]; void *
cmp rdi, r12
jz short loc_CD87D
mov rsi, [rsp+arg_20]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_CD87D
mov r14, rax
loc_CD87D:
mov rdi, [rsp+arg_30]; void *
cmp rdi, rbx
jz short loc_CD8A0
mov rsi, [rsp+arg_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_CD8A0
jmp short $+2
loc_CD898:
mov r14, rax
jmp short loc_CD8BC
mov r14, rax
loc_CD8A0:
mov rdi, [rsp+arg_50]; void *
lea rax, [rsp+arg_60]
cmp rdi, rax
jz short loc_CD8BC
mov rsi, [rsp+arg_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_CD8BC:
mov rax, [rsp+arg_0]
mov rcx, [rsp+arg_8]
mov rdi, [rcx]; void *
cmp rdi, rax
jz short loc_CD8D9
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_CD8D9:
mov rdi, r14
call __Unwind_Resume
| _QWORD * common_sampler_print[abi:cxx11](_QWORD *a1, long long a2)
{
int i; // ebp
long long v3; // r15
long long v4; // rax
long long v5; // rax
__int128 *v6; // rcx
long long v7; // rax
__int128 *v8; // rcx
__int128 *v10; // [rsp+18h] [rbp-90h]
long long v11; // [rsp+20h] [rbp-88h]
__int128 v12; // [rsp+28h] [rbp-80h] BYREF
void *v13[2]; // [rsp+38h] [rbp-70h] BYREF
__int128 v14; // [rsp+48h] [rbp-60h] BYREF
void *v15[2]; // [rsp+58h] [rbp-50h] BYREF
_QWORD v16[8]; // [rsp+68h] [rbp-40h] BYREF
*a1 = a1 + 2;
std::string::_M_construct<char const*>((long long)a1, "logits ", (long long)"");
for ( i = 0; i < (int)llama_sampler_chain_n(*(_QWORD *)(a2 + 320)); ++i )
{
v3 = llama_sampler_chain_get(*(_QWORD *)(a2 + 320), (unsigned int)i);
v15[0] = v16;
std::string::_M_construct<char const*>((long long)v15, "-> ", (long long)"");
v4 = llama_sampler_name(v3);
v5 = std::string::append(v15, v4);
v13[0] = &v14;
v6 = (__int128 *)(v5 + 16);
if ( *(_QWORD *)v5 == v5 + 16 )
{
v14 = *v6;
}
else
{
v13[0] = *(void **)v5;
*(_QWORD *)&v14 = *(_QWORD *)v6;
}
v13[1] = *(void **)(v5 + 8);
*(_QWORD *)v5 = v6;
*(_QWORD *)(v5 + 8) = 0LL;
*(_BYTE *)(v5 + 16) = 0;
v7 = std::string::append(v13, " ");
v10 = &v12;
v8 = (__int128 *)(v7 + 16);
if ( *(_QWORD *)v7 == v7 + 16 )
{
v12 = *v8;
}
else
{
v10 = *(__int128 **)v7;
*(_QWORD *)&v12 = *(_QWORD *)v8;
}
v11 = *(_QWORD *)(v7 + 8);
*(_QWORD *)v7 = v8;
*(_QWORD *)(v7 + 8) = 0LL;
*(_BYTE *)(v7 + 16) = 0;
std::string::_M_append(a1, v10, v11);
if ( v10 != &v12 )
operator delete(v10, v12 + 1);
if ( v13[0] != &v14 )
operator delete(v13[0], v14 + 1);
if ( v15[0] != v16 )
operator delete(v15[0], v16[0] + 1LL);
}
return a1;
}
| common_sampler_print[abi:cxx11]:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x78
MOV R14,RSI
LEA RAX,[RDI + 0x10]
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RDI],RAX
LEA RSI,[0x1edd4e]
LEA RDX,[0x1edd55]
MOV qword ptr [RSP + 0x10],RDI
CALL 0x00121b26
LEA RBX,[RSP + 0x48]
XOR EBP,EBP
LEA R12,[RSP + 0x28]
LEA R13,[RSP + 0x58]
LAB_001cd6f6:
MOV RDI,qword ptr [R14 + 0x140]
LAB_001cd6fd:
CALL 0x0011af70
CMP EBP,EAX
JGE 0x001cd848
MOV RDI,qword ptr [R14 + 0x140]
LAB_001cd711:
MOV ESI,EBP
CALL 0x0011a9a0
MOV R15,RAX
LEA RAX,[RSP + 0x68]
MOV qword ptr [RSP + 0x58],RAX
LAB_001cd725:
MOV RDI,R13
LEA RSI,[0x1f44a0]
LEA RDX,[0x1f44a3]
CALL 0x00121b26
LAB_001cd73b:
MOV RDI,R15
CALL 0x0011a350
MOV RDI,R13
MOV RSI,RAX
CALL 0x0011b0d0
MOV qword ptr [RSP + 0x38],RBX
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x001cd771
MOV qword ptr [RSP + 0x38],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x48],RDX
JMP 0x001cd777
LAB_001cd771:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RBX],XMM0
LAB_001cd777:
MOV RDX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x40],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
LAB_001cd78f:
LEA RDI,[RSP + 0x38]
LEA RSI,[0x1ee56d]
CALL 0x0011b0d0
MOV qword ptr [RSP + 0x18],R12
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x001cd7c3
MOV qword ptr [RSP + 0x18],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x28],RDX
JMP 0x001cd7cb
LAB_001cd7c3:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [R12],XMM0
LAB_001cd7cb:
MOV RDX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x20],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
MOV RSI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x20]
LAB_001cd7ed:
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x0011a250
LAB_001cd7f7:
MOV RDI,qword ptr [RSP + 0x18]
CMP RDI,R12
JZ 0x001cd80e
MOV RSI,qword ptr [RSP + 0x28]
INC RSI
CALL 0x0011a8c0
LAB_001cd80e:
MOV RDI,qword ptr [RSP + 0x38]
CMP RDI,RBX
JZ 0x001cd825
MOV RSI,qword ptr [RSP + 0x48]
INC RSI
CALL 0x0011a8c0
LAB_001cd825:
MOV RDI,qword ptr [RSP + 0x58]
LEA RAX,[RSP + 0x68]
CMP RDI,RAX
JZ 0x001cd841
MOV RSI,qword ptr [RSP + 0x68]
INC RSI
CALL 0x0011a8c0
LAB_001cd841:
INC EBP
JMP 0x001cd6f6
LAB_001cd848:
MOV RAX,qword ptr [RSP + 0x10]
ADD RSP,0x78
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* common_sampler_print[abi:cxx11](common_sampler const*) */
common_sampler * common_sampler_print_abi_cxx11_(common_sampler *param_1)
{
int iVar1;
int8 uVar2;
long *plVar3;
long *plVar4;
int iVar5;
long in_RSI;
long *local_90;
long local_80;
long lStack_78;
long *local_70;
long local_68;
long local_60;
long lStack_58;
long *local_50 [2];
long local_40 [2];
*(common_sampler **)param_1 = param_1 + 0x10;
std::__cxx11::string::_M_construct<char_const*>(param_1,"logits ","");
iVar5 = 0;
while( true ) {
/* try { // try from 001cd6fd to 001cd701 has its CatchHandler @ 001cd898 */
iVar1 = llama_sampler_chain_n(*(int8 *)(in_RSI + 0x140));
if (iVar1 <= iVar5) break;
/* try { // try from 001cd711 to 001cd717 has its CatchHandler @ 001cd85c */
uVar2 = llama_sampler_chain_get(*(int8 *)(in_RSI + 0x140),iVar5);
local_50[0] = local_40;
/* try { // try from 001cd725 to 001cd73a has its CatchHandler @ 001cd896 */
std::__cxx11::string::_M_construct<char_const*>(local_50,&DAT_001f44a0,&DAT_001f44a3);
/* try { // try from 001cd73b to 001cd74d has its CatchHandler @ 001cd89d */
llama_sampler_name(uVar2);
plVar3 = (long *)std::__cxx11::string::append((char *)local_50);
plVar4 = plVar3 + 2;
if ((long *)*plVar3 == plVar4) {
local_60 = *plVar4;
lStack_58 = plVar3[3];
local_70 = &local_60;
}
else {
local_60 = *plVar4;
local_70 = (long *)*plVar3;
}
local_68 = plVar3[1];
*plVar3 = (long)plVar4;
plVar3[1] = 0;
*(int1 *)(plVar3 + 2) = 0;
/* try { // try from 001cd78f to 001cd79f has its CatchHandler @ 001cd87a */
plVar3 = (long *)std::__cxx11::string::append((char *)&local_70);
plVar4 = plVar3 + 2;
if ((long *)*plVar3 == plVar4) {
local_80 = *plVar4;
lStack_78 = plVar3[3];
local_90 = &local_80;
}
else {
local_80 = *plVar4;
local_90 = (long *)*plVar3;
}
*plVar3 = (long)plVar4;
plVar3[1] = 0;
*(int1 *)(plVar3 + 2) = 0;
/* try { // try from 001cd7ed to 001cd7f6 has its CatchHandler @ 001cd85e */
std::__cxx11::string::_M_append((char *)param_1,(ulong)local_90);
if (local_90 != &local_80) {
operator_delete(local_90,local_80 + 1);
}
if (local_70 != &local_60) {
operator_delete(local_70,local_60 + 1);
}
if (local_50[0] != local_40) {
operator_delete(local_50[0],local_40[0] + 1);
}
iVar5 = iVar5 + 1;
}
return param_1;
}
| |
48,393 | get_charset_name | eloqsql/mysys/charset.c | const char *get_charset_name(uint charset_number)
{
my_pthread_once(&charsets_initialized, init_available_charsets);
if (charset_number < array_elements(all_charsets))
{
CHARSET_INFO *cs= all_charsets[charset_number];
if (cs && (cs->number == charset_number) && cs->coll_name.str)
return cs->coll_name.str;
}
return "?"; /* this mimics find_type() */
} | O0 | c | get_charset_name:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
leaq 0xbb0572(%rip), %rdi # 0xc8d694
leaq -0x479(%rip), %rsi # 0xdccb0
callq 0x2a240
cmpl $0x800, -0xc(%rbp) # imm = 0x800
jae 0xdd178
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0xba84dd(%rip), %rax # 0xc85620
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xdd176
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0xdd176
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xdd176
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xdd183
jmp 0xdd178
leaq 0x7f642(%rip), %rax # 0x15c7c1
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| get_charset_name:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_C], edi
lea rdi, charsets_initialized
lea rsi, init_available_charsets
call _pthread_once
cmp [rbp+var_C], 800h
jnb short loc_DD178
mov eax, [rbp+var_C]
mov ecx, eax
lea rax, all_charsets
mov rax, [rax+rcx*8]
mov [rbp+var_18], rax
cmp [rbp+var_18], 0
jz short loc_DD176
mov rax, [rbp+var_18]
mov eax, [rax]
cmp eax, [rbp+var_C]
jnz short loc_DD176
mov rax, [rbp+var_18]
cmp qword ptr [rax+20h], 0
jz short loc_DD176
mov rax, [rbp+var_18]
mov rax, [rax+20h]
mov [rbp+var_8], rax
jmp short loc_DD183
loc_DD176:
jmp short $+2
loc_DD178:
lea rax, asc_15C7C1; "?"
mov [rbp+var_8], rax
loc_DD183:
mov rax, [rbp+var_8]
add rsp, 20h
pop rbp
retn
| const char * get_charset_name(unsigned int a1)
{
long long v2; // [rsp+8h] [rbp-18h]
pthread_once(&charsets_initialized, init_available_charsets);
if ( a1 < 0x800 && (v2 = all_charsets[a1]) != 0 && *(_DWORD *)v2 == a1 && *(_QWORD *)(v2 + 32) )
return *(const char **)(v2 + 32);
else
return "?";
}
| get_charset_name:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0xc],EDI
LEA RDI,[0xd8d694]
LEA RSI,[0x1dccb0]
CALL 0x0012a240
CMP dword ptr [RBP + -0xc],0x800
JNC 0x001dd178
MOV EAX,dword ptr [RBP + -0xc]
MOV ECX,EAX
LEA RAX,[0xd85620]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x18],RAX
CMP qword ptr [RBP + -0x18],0x0
JZ 0x001dd176
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
CMP EAX,dword ptr [RBP + -0xc]
JNZ 0x001dd176
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x20],0x0
JZ 0x001dd176
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x20]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001dd183
LAB_001dd176:
JMP 0x001dd178
LAB_001dd178:
LEA RAX,[0x25c7c1]
MOV qword ptr [RBP + -0x8],RAX
LAB_001dd183:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x20
POP RBP
RET
|
int * get_charset_name(uint param_1)
{
uint *puVar1;
int *local_10;
pthread_once(&charsets_initialized,init_available_charsets);
if ((((param_1 < 0x800) && (puVar1 = (uint *)(&all_charsets)[param_1], puVar1 != (uint *)0x0)) &&
(*puVar1 == param_1)) && (*(long *)(puVar1 + 8) != 0)) {
local_10 = *(int **)(puVar1 + 8);
}
else {
local_10 = &DAT_0025c7c1;
}
return local_10;
}
| |
48,394 | int2str | eloqsql/strings/int2str.c | char *
int2str(register long int val, register char *dst, register int radix,
int upcase)
{
char buffer[65];
register char *p;
long int new_val;
const char *dig_vec= upcase ? _dig_vec_upper : _dig_vec_lower;
ulong uval= (ulong) val;
if (radix < 0)
{
if (radix < -36 || radix > -2)
return NullS;
if (val < 0)
{
*dst++ = '-';
/* Avoid integer overflow in (-val) for LONGLONG_MIN (BUG#31799). */
uval = (ulong)0 - uval;
}
radix = -radix;
}
else if (radix > 36 || radix < 2)
return NullS;
/*
The slightly contorted code which follows is due to the fact that
few machines directly support unsigned long / and %. Certainly
the VAX C compiler generates a subroutine call. In the interests
of efficiency (hollow laugh) I let this happen for the first digit
only; after that "val" will be in range so that signed integer
division will do. Sorry 'bout that. CHECK THE CODE PRODUCED BY
YOUR C COMPILER. The first % and / should be unsigned, the second
% and / signed, but C compilers tend to be extraordinarily
sensitive to minor details of style. This works on a VAX, that's
all I claim for it.
*/
p = &buffer[sizeof(buffer)-1];
*p = '\0';
new_val= uval / (ulong) radix;
*--p = dig_vec[(uchar) (uval- (ulong) new_val*(ulong) radix)];
val = new_val;
#ifdef HAVE_LDIV
while (val != 0)
{
ldiv_t res;
res=ldiv(val,radix);
*--p = dig_vec[res.rem];
val= res.quot;
}
#else
while (val != 0)
{
new_val=val/radix;
*--p = dig_vec[(uchar) (val-new_val*radix)];
val= new_val;
}
#endif
while ((*dst++ = *p++) != 0) ;
return dst-1;
} | O0 | c | int2str:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x60(%rbp)
movq %rsi, -0x68(%rbp)
movl %edx, -0x6c(%rbp)
movl %ecx, -0x70(%rbp)
movl -0x70(%rbp), %edx
leaq 0x142800(%rip), %rax # 0x1b61c0
leaq 0x1427c9(%rip), %rcx # 0x1b6190
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x88(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x90(%rbp)
cmpl $0x0, -0x6c(%rbp)
jge 0x73a32
cmpl $-0x24, -0x6c(%rbp)
jl 0x739f2
cmpl $-0x2, -0x6c(%rbp)
jle 0x739ff
movq $0x0, -0x58(%rbp)
jmp 0x73b59
cmpq $0x0, -0x60(%rbp)
jge 0x73a28
movq -0x68(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x68(%rbp)
movb $0x2d, (%rax)
xorl %eax, %eax
subq -0x90(%rbp), %rax
movq %rax, -0x90(%rbp)
xorl %eax, %eax
subl -0x6c(%rbp), %eax
movl %eax, -0x6c(%rbp)
jmp 0x73a4d
cmpl $0x24, -0x6c(%rbp)
jg 0x73a3e
cmpl $0x2, -0x6c(%rbp)
jge 0x73a4b
movq $0x0, -0x58(%rbp)
jmp 0x73b59
jmp 0x73a4d
leaq -0x50(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movb $0x0, (%rax)
movq -0x90(%rbp), %rax
movslq -0x6c(%rbp), %rcx
xorl %edx, %edx
divq %rcx
movq %rax, -0x80(%rbp)
movq -0x88(%rbp), %rax
movq -0x90(%rbp), %rcx
movq -0x80(%rbp), %rdx
movslq -0x6c(%rbp), %rsi
imulq %rsi, %rdx
subq %rdx, %rcx
movzbl %cl, %ecx
movb (%rax,%rcx), %cl
movq -0x78(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x78(%rbp)
movb %cl, -0x1(%rax)
movq -0x80(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x60(%rbp)
je 0x73b1f
movq -0x60(%rbp), %rdi
movslq -0x6c(%rbp), %rsi
callq 0x24140
movq %rax, -0xb0(%rbp)
movq %rdx, -0xa8(%rbp)
movq -0xb0(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0xa8(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x88(%rbp), %rax
movq -0x98(%rbp), %rcx
movb (%rax,%rcx), %cl
movq -0x78(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x78(%rbp)
movb %cl, -0x1(%rax)
movq -0xa0(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x73ab1
jmp 0x73b21
movq -0x78(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x78(%rbp)
movb (%rax), %al
movq -0x68(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x68(%rbp)
movb %al, (%rcx)
movsbl %al, %eax
cmpl $0x0, %eax
je 0x73b4d
jmp 0x73b21
movq -0x68(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x73b86
movq -0xb8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
callq 0x24340
nopl (%rax,%rax)
| int2str:
push rbp
mov rbp, rsp
sub rsp, 0C0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_60], rdi
mov [rbp+var_68], rsi
mov [rbp+var_6C], edx
mov [rbp+var_70], ecx
mov edx, [rbp+var_70]
lea rax, _dig_vec_lower; "0123456789abcdefghijklmnopqrstuvwxyz"
lea rcx, _dig_vec_upper; "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
cmp edx, 0
cmovnz rax, rcx
mov [rbp+var_88], rax
mov rax, [rbp+var_60]
mov [rbp+var_90], rax
cmp [rbp+var_6C], 0
jge short loc_73A32
cmp [rbp+var_6C], 0FFFFFFDCh
jl short loc_739F2
cmp [rbp+var_6C], 0FFFFFFFEh
jle short loc_739FF
loc_739F2:
mov [rbp+var_58], 0
jmp loc_73B59
loc_739FF:
cmp [rbp+var_60], 0
jge short loc_73A28
mov rax, [rbp+var_68]
mov rcx, rax
add rcx, 1
mov [rbp+var_68], rcx
mov byte ptr [rax], 2Dh ; '-'
xor eax, eax
sub rax, [rbp+var_90]
mov [rbp+var_90], rax
loc_73A28:
xor eax, eax
sub eax, [rbp+var_6C]
mov [rbp+var_6C], eax
jmp short loc_73A4D
loc_73A32:
cmp [rbp+var_6C], 24h ; '$'
jg short loc_73A3E
cmp [rbp+var_6C], 2
jge short loc_73A4B
loc_73A3E:
mov [rbp+var_58], 0
jmp loc_73B59
loc_73A4B:
jmp short $+2
loc_73A4D:
lea rax, [rbp+var_50]
add rax, 40h ; '@'
mov [rbp+var_78], rax
mov rax, [rbp+var_78]
mov byte ptr [rax], 0
mov rax, [rbp+var_90]
movsxd rcx, [rbp+var_6C]
xor edx, edx
div rcx
mov [rbp+var_80], rax
mov rax, [rbp+var_88]
mov rcx, [rbp+var_90]
mov rdx, [rbp+var_80]
movsxd rsi, [rbp+var_6C]
imul rdx, rsi
sub rcx, rdx
movzx ecx, cl
mov cl, [rax+rcx]
mov rax, [rbp+var_78]
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_78], rdx
mov [rax-1], cl
mov rax, [rbp+var_80]
mov [rbp+var_60], rax
loc_73AB1:
cmp [rbp+var_60], 0
jz short loc_73B1F
mov rdi, [rbp+var_60]
movsxd rsi, [rbp+var_6C]
call _ldiv
mov [rbp+var_B0], rax
mov [rbp+var_A8], rdx
mov rax, [rbp+var_B0]
mov [rbp+var_A0], rax
mov rax, [rbp+var_A8]
mov [rbp+var_98], rax
mov rax, [rbp+var_88]
mov rcx, [rbp+var_98]
mov cl, [rax+rcx]
mov rax, [rbp+var_78]
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_78], rdx
mov [rax-1], cl
mov rax, [rbp+var_A0]
mov [rbp+var_60], rax
jmp short loc_73AB1
loc_73B1F:
jmp short $+2
loc_73B21:
mov rax, [rbp+var_78]
mov rcx, rax
add rcx, 1
mov [rbp+var_78], rcx
mov al, [rax]
mov rcx, [rbp+var_68]
mov rdx, rcx
add rdx, 1
mov [rbp+var_68], rdx
mov [rcx], al
movsx eax, al
cmp eax, 0
jz short loc_73B4D
jmp short loc_73B21
loc_73B4D:
mov rax, [rbp+var_68]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_58], rax
loc_73B59:
mov rax, [rbp+var_58]
mov [rbp+var_B8], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_73B86
mov rax, [rbp+var_B8]
add rsp, 0C0h
pop rbp
retn
loc_73B86:
call ___stack_chk_fail
| _BYTE * int2str(long long a1, _BYTE *a2, int a3, int a4)
{
const char *v4; // rax
long long v5; // rdx
_BYTE *v6; // rax
_BYTE *v7; // rax
_BYTE *v8; // rcx
long long v10; // [rsp+10h] [rbp-B0h]
unsigned long long v11; // [rsp+30h] [rbp-90h]
const char *v12; // [rsp+38h] [rbp-88h]
_BYTE *v13; // [rsp+48h] [rbp-78h]
int v14; // [rsp+54h] [rbp-6Ch]
_BYTE *v15; // [rsp+58h] [rbp-68h]
unsigned long long i; // [rsp+60h] [rbp-60h]
_BYTE v18[9]; // [rsp+AFh] [rbp-11h] BYREF
unsigned long long v19; // [rsp+B8h] [rbp-8h]
v19 = __readfsqword(0x28u);
v15 = a2;
v14 = a3;
v4 = "0123456789abcdefghijklmnopqrstuvwxyz";
if ( a4 )
v4 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
v12 = v4;
v11 = a1;
if ( a3 >= 0 )
{
if ( a3 > 36 || a3 < 2 )
return 0LL;
}
else
{
if ( a3 < -36 || a3 > -2 )
return 0LL;
if ( a1 < 0 )
{
v15 = a2 + 1;
*a2 = 45;
v11 = -a1;
}
v14 = -a3;
}
v18[1] = 0;
v13 = v18;
v18[0] = v4[(unsigned __int8)(v11 % v14)];
for ( i = v11 / v14; i; i = v10 )
{
v10 = ldiv(i, v14);
v6 = v13--;
*(v6 - 1) = v12[v5];
}
do
{
v7 = v13++;
LOBYTE(v7) = *v7;
v8 = v15++;
*v8 = (_BYTE)v7;
}
while ( (_BYTE)v7 );
return v15 - 1;
}
| int2str:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xc0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x60],RDI
MOV qword ptr [RBP + -0x68],RSI
MOV dword ptr [RBP + -0x6c],EDX
MOV dword ptr [RBP + -0x70],ECX
MOV EDX,dword ptr [RBP + -0x70]
LEA RAX,[0x2b61c0]
LEA RCX,[0x2b6190]
CMP EDX,0x0
CMOVNZ RAX,RCX
MOV qword ptr [RBP + -0x88],RAX
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x90],RAX
CMP dword ptr [RBP + -0x6c],0x0
JGE 0x00173a32
CMP dword ptr [RBP + -0x6c],-0x24
JL 0x001739f2
CMP dword ptr [RBP + -0x6c],-0x2
JLE 0x001739ff
LAB_001739f2:
MOV qword ptr [RBP + -0x58],0x0
JMP 0x00173b59
LAB_001739ff:
CMP qword ptr [RBP + -0x60],0x0
JGE 0x00173a28
MOV RAX,qword ptr [RBP + -0x68]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x68],RCX
MOV byte ptr [RAX],0x2d
XOR EAX,EAX
SUB RAX,qword ptr [RBP + -0x90]
MOV qword ptr [RBP + -0x90],RAX
LAB_00173a28:
XOR EAX,EAX
SUB EAX,dword ptr [RBP + -0x6c]
MOV dword ptr [RBP + -0x6c],EAX
JMP 0x00173a4d
LAB_00173a32:
CMP dword ptr [RBP + -0x6c],0x24
JG 0x00173a3e
CMP dword ptr [RBP + -0x6c],0x2
JGE 0x00173a4b
LAB_00173a3e:
MOV qword ptr [RBP + -0x58],0x0
JMP 0x00173b59
LAB_00173a4b:
JMP 0x00173a4d
LAB_00173a4d:
LEA RAX,[RBP + -0x50]
ADD RAX,0x40
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,qword ptr [RBP + -0x78]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x90]
MOVSXD RCX,dword ptr [RBP + -0x6c]
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x80],RAX
MOV RAX,qword ptr [RBP + -0x88]
MOV RCX,qword ptr [RBP + -0x90]
MOV RDX,qword ptr [RBP + -0x80]
MOVSXD RSI,dword ptr [RBP + -0x6c]
IMUL RDX,RSI
SUB RCX,RDX
MOVZX ECX,CL
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RBP + -0x78]
MOV RDX,RAX
ADD RDX,-0x1
MOV qword ptr [RBP + -0x78],RDX
MOV byte ptr [RAX + -0x1],CL
MOV RAX,qword ptr [RBP + -0x80]
MOV qword ptr [RBP + -0x60],RAX
LAB_00173ab1:
CMP qword ptr [RBP + -0x60],0x0
JZ 0x00173b1f
MOV RDI,qword ptr [RBP + -0x60]
MOVSXD RSI,dword ptr [RBP + -0x6c]
CALL 0x00124140
MOV qword ptr [RBP + -0xb0],RAX
MOV qword ptr [RBP + -0xa8],RDX
MOV RAX,qword ptr [RBP + -0xb0]
MOV qword ptr [RBP + -0xa0],RAX
MOV RAX,qword ptr [RBP + -0xa8]
MOV qword ptr [RBP + -0x98],RAX
MOV RAX,qword ptr [RBP + -0x88]
MOV RCX,qword ptr [RBP + -0x98]
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RBP + -0x78]
MOV RDX,RAX
ADD RDX,-0x1
MOV qword ptr [RBP + -0x78],RDX
MOV byte ptr [RAX + -0x1],CL
MOV RAX,qword ptr [RBP + -0xa0]
MOV qword ptr [RBP + -0x60],RAX
JMP 0x00173ab1
LAB_00173b1f:
JMP 0x00173b21
LAB_00173b21:
MOV RAX,qword ptr [RBP + -0x78]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x78],RCX
MOV AL,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x68]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x68],RDX
MOV byte ptr [RCX],AL
MOVSX EAX,AL
CMP EAX,0x0
JZ 0x00173b4d
JMP 0x00173b21
LAB_00173b4d:
MOV RAX,qword ptr [RBP + -0x68]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x58],RAX
LAB_00173b59:
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0xb8],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00173b86
MOV RAX,qword ptr [RBP + -0xb8]
ADD RSP,0xc0
POP RBP
RET
LAB_00173b86:
CALL 0x00124340
|
char * int2str(ulong param_1,char *param_2,int param_3,int param_4)
{
char cVar1;
char *pcVar2;
char *pcVar3;
long in_FS_OFFSET;
ldiv_t lVar4;
ulong local_b8;
long local_b0;
ulong local_98;
char *local_80;
int local_74;
char *local_70;
ulong local_68;
char *local_60;
char local_19 [9];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
pcVar3 = "0123456789abcdefghijklmnopqrstuvwxyz";
if (param_4 != 0) {
pcVar3 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
}
local_98 = param_1;
local_70 = param_2;
if (param_3 < 0) {
if ((param_3 < -0x24) || (-2 < param_3)) {
local_60 = (char *)0x0;
goto LAB_00173b59;
}
if ((long)param_1 < 0) {
local_70 = param_2 + 1;
*param_2 = '-';
local_98 = -param_1;
}
local_74 = -param_3;
}
else if ((0x24 < param_3) || (local_74 = param_3, param_3 < 2)) {
local_60 = (char *)0x0;
goto LAB_00173b59;
}
local_19[1] = 0;
local_68 = local_98 / (ulong)(long)local_74;
local_19[0] = pcVar3[(byte)((char)local_98 - (char)local_68 * (char)local_74)];
local_80 = local_19;
while (pcVar2 = local_70, local_68 != 0) {
lVar4 = ldiv(local_68,(long)local_74);
local_b8 = lVar4.quot;
local_b0 = lVar4.rem;
local_80[-1] = pcVar3[local_b0];
local_80 = local_80 + -1;
local_68 = local_b8;
}
do {
local_70 = pcVar2;
cVar1 = *local_80;
*local_70 = cVar1;
local_80 = local_80 + 1;
pcVar2 = local_70 + 1;
} while (cVar1 != '\0');
local_60 = local_70;
LAB_00173b59:
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_60;
}
| |
48,395 | Catch::Clara::Opt::Opt(bool&) | AlayaLite/build_O3/_deps/libcoro-src/test/catch_amalgamated.cpp | Opt::Opt(bool& ref) :
ParserRefImpl(std::make_shared<Detail::BoundFlagRef>(ref)) {} | O3 | cpp | Catch::Clara::Opt::Opt(bool&):
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x20, %edi
callq 0x171f0
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0xd6b14(%rip), %rcx # 0x1307e0
addq $0x10, %rcx
movq %rcx, (%rax)
leaq 0x10(%rax), %rcx
leaq 0xd4452(%rip), %rdx # 0x12e130
addq $0x10, %rdx
movq %rdx, 0x10(%rax)
movq %r14, 0x18(%rax)
leaq 0x8(%rsp), %r14
movq %rcx, (%r14)
movq %rax, 0x8(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x777d2
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x59d0f
callq 0x33e7c
leaq 0xd37b2(%rip), %rax # 0x12d4c8
addq $0x10, %rax
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rbx)
movq $0x0, 0x70(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
| _ZN5Catch5Clara3OptC2ERb:
push r14
push rbx
sub rsp, 18h
mov r14, rsi
mov rbx, rdi
mov edi, 20h ; ' '; unsigned __int64
call __Znwm; operator new(ulong)
mov rcx, 100000001h
mov [rax+8], rcx
lea rcx, _ZTVSt23_Sp_counted_ptr_inplaceIN5Catch5Clara6Detail12BoundFlagRefESaIS3_ELN9__gnu_cxx12_Lock_policyE2EE; `vtable for'std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundFlagRef,std::allocator<Catch::Clara::Detail::BoundFlagRef>,(__gnu_cxx::_Lock_policy)2>
add rcx, 10h
mov [rax], rcx
lea rcx, [rax+10h]
lea rdx, _ZTVN5Catch5Clara6Detail12BoundFlagRefE; `vtable for'Catch::Clara::Detail::BoundFlagRef
add rdx, 10h
mov [rax+10h], rdx
mov [rax+18h], r14
lea r14, [rsp+28h+var_20]
mov [r14], rcx
mov [r14+8], rax
mov rdi, rbx
mov rsi, r14
call _ZN5Catch5Clara6Detail13ParserRefImplINS0_3OptEEC2ERKSt10shared_ptrINS1_8BoundRefEE; Catch::Clara::Detail::ParserRefImpl<Catch::Clara::Opt>::ParserRefImpl(std::shared_ptr<Catch::Clara::Detail::BoundRef> const&)
mov rdi, [r14+8]
test rdi, rdi
jz short loc_59D0F
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_59D0F:
lea rax, _ZTVN5Catch5Clara3OptE; `vtable for'Catch::Clara::Opt
add rax, 10h
mov [rbx], rax
xorps xmm0, xmm0
movups xmmword ptr [rbx+60h], xmm0
mov qword ptr [rbx+70h], 0
add rsp, 18h
pop rbx
pop r14
retn
| long long * Catch::Clara::Opt::Opt(Catch::Clara::Opt *this, bool *a2)
{
long long v2; // rax
long long *result; // rax
long long v4; // [rsp+8h] [rbp-20h] BYREF
volatile signed __int32 *v5; // [rsp+10h] [rbp-18h]
v2 = operator new(0x20uLL);
*(_QWORD *)(v2 + 8) = 0x100000001LL;
*(_QWORD *)v2 = &`vtable for'std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundFlagRef,std::allocator<Catch::Clara::Detail::BoundFlagRef>,(__gnu_cxx::_Lock_policy)2>
+ 2;
*(_QWORD *)(v2 + 16) = &`vtable for'Catch::Clara::Detail::BoundFlagRef + 2;
*(_QWORD *)(v2 + 24) = a2;
v4 = v2 + 16;
v5 = (volatile signed __int32 *)v2;
Catch::Clara::Detail::ParserRefImpl<Catch::Clara::Opt>::ParserRefImpl(this, &v4);
if ( v5 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v5);
result = &`vtable for'Catch::Clara::Opt + 2;
*(_QWORD *)this = &`vtable for'Catch::Clara::Opt + 2;
*((_OWORD *)this + 6) = 0LL;
*((_QWORD *)this + 14) = 0LL;
return result;
}
| Opt:
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV R14,RSI
MOV RBX,RDI
MOV EDI,0x20
CALL 0x001171f0
MOV RCX,0x100000001
MOV qword ptr [RAX + 0x8],RCX
LEA RCX,[0x2307e0]
ADD RCX,0x10
MOV qword ptr [RAX],RCX
LEA RCX,[RAX + 0x10]
LEA RDX,[0x22e130]
ADD RDX,0x10
MOV qword ptr [RAX + 0x10],RDX
MOV qword ptr [RAX + 0x18],R14
LEA R14,[RSP + 0x8]
MOV qword ptr [R14],RCX
MOV qword ptr [R14 + 0x8],RAX
MOV RDI,RBX
MOV RSI,R14
CALL 0x001777d2
MOV RDI,qword ptr [R14 + 0x8]
TEST RDI,RDI
JZ 0x00159d0f
CALL 0x00133e7c
LAB_00159d0f:
LEA RAX,[0x22d4c8]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x60],XMM0
MOV qword ptr [RBX + 0x70],0x0
ADD RSP,0x18
POP RBX
POP R14
RET
|
/* Catch::Clara::Opt::Opt(bool&) */
void __thiscall Catch::Clara::Opt::Opt(Opt *this,bool *param_1)
{
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_20;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_18;
local_18 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)operator_new(0x20);
*(int8 *)(local_18 + 8) = 0x100000001;
*(int ***)local_18 = &PTR___Sp_counted_ptr_inplace_002307f0;
local_20 = local_18 + 0x10;
*(int ***)(local_18 + 0x10) = &PTR__BoundRef_0022e140;
*(bool **)(local_18 + 0x18) = param_1;
Detail::ParserRefImpl<Catch::Clara::Opt>::ParserRefImpl
((ParserRefImpl<Catch::Clara::Opt> *)this,(shared_ptr *)&local_20);
if (local_18 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_18);
}
*(int ***)this = &PTR__Opt_0022d4d8;
*(int8 *)(this + 0x60) = 0;
*(int8 *)(this + 0x68) = 0;
*(int8 *)(this + 0x70) = 0;
return;
}
| |
48,396 | my_ftell | eloqsql/mysys/my_fstream.c | my_off_t my_ftell(FILE *stream, myf MyFlags __attribute__((unused)))
{
long long pos;
DBUG_ENTER("my_ftell");
DBUG_PRINT("my",("stream:%p MyFlags: %lu", stream, MyFlags));
pos=IF_WIN(_ftelli64(stream),ftell(stream));
DBUG_PRINT("exit",("ftell: %lld",pos));
DBUG_RETURN((my_off_t) pos);
} | O0 | c | my_ftell:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x83a12
movq -0x8(%rbp), %rdi
callq 0x29630
movq %rax, -0x18(%rbp)
jmp 0x83a21
jmp 0x83a23
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| my_ftell:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
jmp short $+2
loc_83A12:
mov rdi, [rbp+var_8]
call _ftello64
mov [rbp+var_18], rax
jmp short $+2
loc_83A21:
jmp short $+2
loc_83A23:
mov rax, [rbp+var_18]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
add rsp, 20h
pop rbp
retn
| long long my_ftell(long long a1)
{
return ftello64(a1);
}
| my_ftell:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
JMP 0x00183a12
LAB_00183a12:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00129630
MOV qword ptr [RBP + -0x18],RAX
JMP 0x00183a21
LAB_00183a21:
JMP 0x00183a23
LAB_00183a23:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RSP,0x20
POP RBP
RET
|
__off64_t my_ftell(FILE *param_1)
{
__off64_t _Var1;
_Var1 = ftello64(param_1);
return _Var1;
}
| |
48,397 | mi_read_rnd_static_record | eloqsql/storage/myisam/mi_statrec.c | int _mi_read_rnd_static_record(MI_INFO *info, uchar *buf,
register my_off_t filepos,
my_bool skip_deleted_blocks)
{
int locked,error,cache_read;
uint cache_length;
MYISAM_SHARE *share=info->s;
DBUG_ENTER("_mi_read_rnd_static_record");
cache_read=0;
cache_length=0;
if (info->opt_flag & WRITE_CACHE_USED &&
(info->rec_cache.pos_in_file <= filepos || skip_deleted_blocks) &&
flush_io_cache(&info->rec_cache))
DBUG_RETURN(my_errno);
if (info->opt_flag & READ_CACHE_USED)
{ /* Cache in use */
if (filepos == my_b_tell(&info->rec_cache) &&
(skip_deleted_blocks || !filepos))
{
cache_read=1; /* Read record using cache */
cache_length=(uint) (info->rec_cache.read_end - info->rec_cache.read_pos);
}
else
info->rec_cache.seek_not_done=1; /* Filepos is changed */
}
locked=0;
if (info->lock_type == F_UNLCK)
{
if (filepos >= info->state->data_file_length)
{ /* Test if new records */
if (_mi_readinfo(info,F_RDLCK,0))
DBUG_RETURN(my_errno);
locked=1;
}
else
{ /* We don't nead new info */
#ifndef UNSAFE_LOCKING
if ((! cache_read || share->base.reclength > cache_length) &&
share->tot_locks == 0)
{ /* record not in cache */
if (my_lock(share->kfile,F_RDLCK,0L,F_TO_EOF,
MYF(MY_SEEK_NOT_DONE) | info->lock_wait))
DBUG_RETURN(my_errno);
locked=1;
}
#else
info->tmp_lock_type=F_RDLCK;
#endif
}
}
if (filepos >= info->state->data_file_length)
{
DBUG_PRINT("test",("filepos: %ld (%ld) records: %ld del: %ld",
(long) filepos/share->base.reclength, (long) filepos,
(long) info->state->records, (long) info->state->del));
fast_mi_writeinfo(info);
DBUG_RETURN(my_errno=HA_ERR_END_OF_FILE);
}
info->lastpos= filepos;
info->nextpos= filepos+share->base.pack_reclength;
if (! cache_read) /* No cacheing */
{
if ((error=_mi_read_static_record(info,filepos,buf)))
{
if (error > 0)
error=my_errno=HA_ERR_RECORD_DELETED;
else
error=my_errno;
}
DBUG_RETURN(error);
}
/*
Read record with caching. If my_b_read() returns TRUE, less than the
requested bytes have been read. In this case rec_cache.error is
either -1 for a read error, or contains the number of bytes copied
into the buffer.
*/
error=my_b_read(&info->rec_cache,(uchar*) buf,share->base.reclength);
if (info->s->base.pack_reclength != info->s->base.reclength && !error)
{
char tmp[8]; /* Skill fill bytes */
error=my_b_read(&info->rec_cache,(uchar*) tmp,
info->s->base.pack_reclength - info->s->base.reclength);
}
if (locked)
(void) _mi_writeinfo(info,0); /* Unlock keyfile */
if (!error)
{
if (!buf[0])
{ /* Record is removed */
DBUG_RETURN(my_errno=HA_ERR_RECORD_DELETED);
}
/* Found and may be updated */
info->update|= HA_STATE_AKTIV | HA_STATE_KEY_CHANGED;
DBUG_RETURN(0);
}
/* error is TRUE. my_errno should be set if rec_cache.error == -1 */
if (info->rec_cache.error != -1 || my_errno == 0)
{
/*
If we could not get a full record, we either have a broken record,
or are at end of file.
*/
if (info->rec_cache.error == 0)
my_errno= HA_ERR_END_OF_FILE;
else
my_errno= HA_ERR_WRONG_IN_RECORD;
}
DBUG_RETURN(my_errno); /* Something wrong (EOF?) */
} | O0 | c | mi_read_rnd_static_record:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %cl, %al
movq %fs:0x28, %rcx
movq %rcx, -0x8(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movb %al, -0x31(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movl $0x0, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movq -0x20(%rbp), %rax
movl 0x1c8(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0xc4546
movq -0x20(%rbp), %rax
movq 0x220(%rax), %rax
cmpq -0x30(%rbp), %rax
jbe 0xc451b
movsbl -0x31(%rbp), %eax
cmpl $0x0, %eax
je 0xc4546
movq -0x20(%rbp), %rdi
addq $0x220, %rdi # imm = 0x220
movl $0x1, %esi
callq 0xe0be0
cmpl $0x0, %eax
je 0xc4546
jmp 0xc4537
callq 0xf60c0
movl (%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0xc4862
movq -0x20(%rbp), %rax
movl 0x1c8(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xc45c1
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rdi
addq $0x220, %rdi # imm = 0x220
callq 0xc4890
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jne 0xc45b1
movsbl -0x31(%rbp), %eax
cmpl $0x0, %eax
jne 0xc458c
cmpq $0x0, -0x30(%rbp)
jne 0xc45b1
movl $0x1, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq 0x238(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x230(%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x44(%rbp)
jmp 0xc45bf
movq -0x20(%rbp), %rax
movl $0x1, 0x300(%rax)
jmp 0xc45c1
movl $0x0, -0x38(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x2, 0x1f4(%rax)
jne 0xc4685
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpq 0x28(%rcx), %rax
jb 0xc4617
movq -0x20(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0xb10f0
cmpl $0x0, %eax
je 0xc460e
jmp 0xc45ff
callq 0xf60c0
movl (%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0xc4862
movl $0x1, -0x38(%rbp)
jmp 0xc4683
cmpl $0x0, -0x40(%rbp)
je 0xc4630
movq -0x50(%rbp), %rax
movq 0x140(%rax), %rax
movl -0x44(%rbp), %ecx
cmpq %rcx, %rax
jbe 0xc4681
movq -0x50(%rbp), %rax
cmpl $0x0, 0x368(%rax)
jne 0xc4681
movq -0x50(%rbp), %rax
movl 0x350(%rax), %edi
movq -0x20(%rbp), %rax
movq 0x330(%rax), %r8
orq $0x20, %r8
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0xf3530
cmpl $0x0, %eax
je 0xc467a
jmp 0xc466b
callq 0xf60c0
movl (%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0xc4862
movl $0x1, -0x38(%rbp)
jmp 0xc4683
jmp 0xc4685
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpq 0x28(%rcx), %rax
jb 0xc46cf
jmp 0xc4699
jmp 0xc469b
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x368(%rax)
jne 0xc46b6
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0xb1250
jmp 0xc46b8
callq 0xf60c0
movl $0x89, (%rax)
movl $0x89, -0x14(%rbp)
jmp 0xc4862
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x170(%rax)
movq -0x30(%rbp), %rcx
movq -0x50(%rbp), %rax
addq 0x148(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x178(%rax)
cmpl $0x0, -0x40(%rbp)
jne 0xc474a
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0xc4360
movl %eax, -0x3c(%rbp)
cmpl $0x0, %eax
je 0xc473d
cmpl $0x0, -0x3c(%rbp)
jle 0xc4731
callq 0xf60c0
movl $0x86, (%rax)
movl $0x86, -0x3c(%rbp)
jmp 0xc473b
callq 0xf60c0
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
jmp 0xc473d
jmp 0xc473f
movl -0x3c(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0xc4862
movq -0x20(%rbp), %rdi
addq $0x220, %rdi # imm = 0x220
movq -0x28(%rbp), %rsi
movq -0x50(%rbp), %rax
movq 0x140(%rax), %rdx
callq 0xc48f0
movl %eax, -0x3c(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x148(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
cmpq 0x140(%rcx), %rax
je 0xc47c3
cmpl $0x0, -0x3c(%rbp)
jne 0xc47c3
movq -0x20(%rbp), %rdi
addq $0x220, %rdi # imm = 0x220
leaq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x148(%rax), %rdx
movq -0x20(%rbp), %rax
movq (%rax), %rax
subq 0x140(%rax), %rdx
callq 0xc48f0
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x38(%rbp)
je 0xc47d4
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0xb1250
cmpl $0x0, -0x3c(%rbp)
jne 0xc4818
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
jne 0xc47f9
jmp 0xc47e5
callq 0xf60c0
movl $0x86, (%rax)
movl $0x86, -0x14(%rbp)
jmp 0xc4862
movq -0x20(%rbp), %rax
movl 0x1d0(%rax), %ecx
orl $0x82, %ecx
movl %ecx, 0x1d0(%rax)
movl $0x0, -0x14(%rbp)
jmp 0xc4862
movq -0x20(%rbp), %rax
cmpl $-0x1, 0x304(%rax)
jne 0xc482f
callq 0xf60c0
cmpl $0x0, (%rax)
jne 0xc4856
movq -0x20(%rbp), %rax
cmpl $0x0, 0x304(%rax)
jne 0xc4849
callq 0xf60c0
movl $0x89, (%rax)
jmp 0xc4854
callq 0xf60c0
movl $0x7f, (%rax)
jmp 0xc4856
jmp 0xc4858
callq 0xf60c0
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x5c(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xc4883
movl -0x5c(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
callq 0x2a270
nopl (%rax,%rax)
| _mi_read_rnd_static_record:
push rbp
mov rbp, rsp
sub rsp, 60h
mov al, cl
mov rcx, fs:28h
mov [rbp+var_8], rcx
mov [rbp+var_20], rdi
mov [rbp+var_28], rsi
mov [rbp+var_30], rdx
mov [rbp+var_31], al
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_50], rax
mov [rbp+var_40], 0
mov [rbp+var_44], 0
mov rax, [rbp+var_20]
mov eax, [rax+1C8h]
and eax, 10h
cmp eax, 0
jz short loc_C4546
mov rax, [rbp+var_20]
mov rax, [rax+220h]
cmp rax, [rbp+var_30]
jbe short loc_C451B
movsx eax, [rbp+var_31]
cmp eax, 0
jz short loc_C4546
loc_C451B:
mov rdi, [rbp+var_20]
add rdi, 220h
mov esi, 1
call my_b_flush_io_cache
cmp eax, 0
jz short loc_C4546
jmp short $+2
loc_C4537:
call _my_thread_var
mov eax, [rax]
mov [rbp+var_14], eax
jmp loc_C4862
loc_C4546:
mov rax, [rbp+var_20]
mov eax, [rax+1C8h]
and eax, 2
cmp eax, 0
jz short loc_C45C1
mov rax, [rbp+var_30]
mov [rbp+var_58], rax
mov rdi, [rbp+var_20]
add rdi, 220h
call my_b_tell_0
mov rcx, rax
mov rax, [rbp+var_58]
cmp rax, rcx
jnz short loc_C45B1
movsx eax, [rbp+var_31]
cmp eax, 0
jnz short loc_C458C
cmp [rbp+var_30], 0
jnz short loc_C45B1
loc_C458C:
mov [rbp+var_40], 1
mov rax, [rbp+var_20]
mov rax, [rax+238h]
mov rcx, [rbp+var_20]
mov rcx, [rcx+230h]
sub rax, rcx
mov [rbp+var_44], eax
jmp short loc_C45BF
loc_C45B1:
mov rax, [rbp+var_20]
mov dword ptr [rax+300h], 1
loc_C45BF:
jmp short $+2
loc_C45C1:
mov [rbp+var_38], 0
mov rax, [rbp+var_20]
cmp dword ptr [rax+1F4h], 2
jnz loc_C4685
mov rax, [rbp+var_30]
mov rcx, [rbp+var_20]
mov rcx, [rcx+8]
cmp rax, [rcx+28h]
jb short loc_C4617
mov rdi, [rbp+var_20]
xor edx, edx
mov esi, edx
call _mi_readinfo
cmp eax, 0
jz short loc_C460E
jmp short $+2
loc_C45FF:
call _my_thread_var
mov eax, [rax]
mov [rbp+var_14], eax
jmp loc_C4862
loc_C460E:
mov [rbp+var_38], 1
jmp short loc_C4683
loc_C4617:
cmp [rbp+var_40], 0
jz short loc_C4630
mov rax, [rbp+var_50]
mov rax, [rax+140h]
mov ecx, [rbp+var_44]
cmp rax, rcx
jbe short loc_C4681
loc_C4630:
mov rax, [rbp+var_50]
cmp dword ptr [rax+368h], 0
jnz short loc_C4681
mov rax, [rbp+var_50]
mov edi, [rax+350h]
mov rax, [rbp+var_20]
mov r8, [rax+330h]
or r8, 20h
xor esi, esi
xor eax, eax
mov ecx, eax
mov rdx, rcx
call my_lock
cmp eax, 0
jz short loc_C467A
jmp short $+2
loc_C466B:
call _my_thread_var
mov eax, [rax]
mov [rbp+var_14], eax
jmp loc_C4862
loc_C467A:
mov [rbp+var_38], 1
loc_C4681:
jmp short $+2
loc_C4683:
jmp short $+2
loc_C4685:
mov rax, [rbp+var_30]
mov rcx, [rbp+var_20]
mov rcx, [rcx+8]
cmp rax, [rcx+28h]
jb short loc_C46CF
jmp short $+2
loc_C4699:
jmp short $+2
loc_C469B:
mov rax, [rbp+var_20]
mov rax, [rax]
cmp dword ptr [rax+368h], 0
jnz short loc_C46B6
mov rdi, [rbp+var_20]
xor esi, esi
call _mi_writeinfo
loc_C46B6:
jmp short $+2
loc_C46B8:
call _my_thread_var
mov dword ptr [rax], 89h
mov [rbp+var_14], 89h
jmp loc_C4862
loc_C46CF:
mov rcx, [rbp+var_30]
mov rax, [rbp+var_20]
mov [rax+170h], rcx
mov rcx, [rbp+var_30]
mov rax, [rbp+var_50]
add rcx, [rax+148h]
mov rax, [rbp+var_20]
mov [rax+178h], rcx
cmp [rbp+var_40], 0
jnz short loc_C474A
mov rdi, [rbp+var_20]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_28]
call _mi_read_static_record
mov [rbp+var_3C], eax
cmp eax, 0
jz short loc_C473D
cmp [rbp+var_3C], 0
jle short loc_C4731
call _my_thread_var
mov dword ptr [rax], 86h
mov [rbp+var_3C], 86h
jmp short loc_C473B
loc_C4731:
call _my_thread_var
mov eax, [rax]
mov [rbp+var_3C], eax
loc_C473B:
jmp short $+2
loc_C473D:
jmp short $+2
loc_C473F:
mov eax, [rbp+var_3C]
mov [rbp+var_14], eax
jmp loc_C4862
loc_C474A:
mov rdi, [rbp+var_20]
add rdi, 220h
mov rsi, [rbp+var_28]
mov rax, [rbp+var_50]
mov rdx, [rax+140h]
call my_b_read_0
mov [rbp+var_3C], eax
mov rax, [rbp+var_20]
mov rax, [rax]
mov rax, [rax+148h]
mov rcx, [rbp+var_20]
mov rcx, [rcx]
cmp rax, [rcx+140h]
jz short loc_C47C3
cmp [rbp+var_3C], 0
jnz short loc_C47C3
mov rdi, [rbp+var_20]
add rdi, 220h
lea rsi, [rbp+var_10]
mov rax, [rbp+var_20]
mov rax, [rax]
mov rdx, [rax+148h]
mov rax, [rbp+var_20]
mov rax, [rax]
sub rdx, [rax+140h]
call my_b_read_0
mov [rbp+var_3C], eax
loc_C47C3:
cmp [rbp+var_38], 0
jz short loc_C47D4
mov rdi, [rbp+var_20]
xor esi, esi
call _mi_writeinfo
loc_C47D4:
cmp [rbp+var_3C], 0
jnz short loc_C4818
mov rax, [rbp+var_28]
cmp byte ptr [rax], 0
jnz short loc_C47F9
jmp short $+2
loc_C47E5:
call _my_thread_var
mov dword ptr [rax], 86h
mov [rbp+var_14], 86h
jmp short loc_C4862
loc_C47F9:
mov rax, [rbp+var_20]
mov ecx, [rax+1D0h]
or ecx, 82h
mov [rax+1D0h], ecx
mov [rbp+var_14], 0
jmp short loc_C4862
loc_C4818:
mov rax, [rbp+var_20]
cmp dword ptr [rax+304h], 0FFFFFFFFh
jnz short loc_C482F
call _my_thread_var
cmp dword ptr [rax], 0
jnz short loc_C4856
loc_C482F:
mov rax, [rbp+var_20]
cmp dword ptr [rax+304h], 0
jnz short loc_C4849
call _my_thread_var
mov dword ptr [rax], 89h
jmp short loc_C4854
loc_C4849:
call _my_thread_var
mov dword ptr [rax], 7Fh
loc_C4854:
jmp short $+2
loc_C4856:
jmp short $+2
loc_C4858:
call _my_thread_var
mov eax, [rax]
mov [rbp+var_14], eax
loc_C4862:
mov eax, [rbp+var_14]
mov [rbp+var_5C], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_C4883
mov eax, [rbp+var_5C]
add rsp, 60h
pop rbp
retn
loc_C4883:
call ___stack_chk_fail
| long long mi_read_rnd_static_record(long long a1, const char *a2, const char *a3, char a4)
{
long long v4; // rdi
const char *v5; // rsi
long long v7; // [rsp+10h] [rbp-50h]
unsigned int v8; // [rsp+1Ch] [rbp-44h]
int v9; // [rsp+20h] [rbp-40h]
int static_record; // [rsp+24h] [rbp-3Ch]
int v11; // [rsp+24h] [rbp-3Ch]
int v12; // [rsp+28h] [rbp-38h]
char *v15; // [rsp+38h] [rbp-28h]
long long v16; // [rsp+40h] [rbp-20h]
_BYTE v18[8]; // [rsp+50h] [rbp-10h] BYREF
unsigned long long v19; // [rsp+58h] [rbp-8h]
v19 = __readfsqword(0x28u);
v16 = a1;
v15 = (char *)a2;
v7 = *(_QWORD *)a1;
v9 = 0;
v8 = 0;
if ( (*(_DWORD *)(a1 + 456) & 0x10) != 0 && (*(_QWORD *)(a1 + 544) <= (unsigned long long)a3 || a4) )
{
a1 += 544LL;
a2 = (_BYTE *)(&dword_0 + 1);
if ( (unsigned int)my_b_flush_io_cache(v16 + 544, 1LL) )
return *(unsigned int *)my_thread_var(a1, a2);
}
if ( (*(_DWORD *)(v16 + 456) & 2) != 0 )
{
a1 = v16 + 544;
if ( a3 == (const char *)my_b_tell_0(v16 + 544) && (a4 || !a3) )
{
v9 = 1;
v8 = *(_QWORD *)(v16 + 568) - *(_QWORD *)(v16 + 560);
}
else
{
*(_DWORD *)(v16 + 768) = 1;
}
}
v12 = 0;
if ( *(_DWORD *)(v16 + 500) == 2 )
{
if ( (unsigned long long)a3 >= *(_QWORD *)(*(_QWORD *)(v16 + 8) + 40LL) )
{
a1 = v16;
a2 = 0LL;
if ( !(unsigned int)mi_readinfo((long long *)v16, 0LL, 0) )
{
v12 = 1;
goto LABEL_22;
}
return *(unsigned int *)my_thread_var(a1, a2);
}
if ( (!v9 || *(_QWORD *)(v7 + 320) > (unsigned long long)v8) && !*(_DWORD *)(v7 + 872) )
{
a1 = *(unsigned int *)(v7 + 848);
a2 = 0LL;
if ( (unsigned int)my_lock(a1, 0LL, 0LL, 0LL, *(_QWORD *)(v16 + 816) | 0x20LL) )
return *(unsigned int *)my_thread_var(a1, a2);
v12 = 1;
}
}
LABEL_22:
if ( (unsigned long long)a3 < *(_QWORD *)(*(_QWORD *)(v16 + 8) + 40LL) )
{
*(_QWORD *)(v16 + 368) = a3;
*(_QWORD *)(v16 + 376) = &a3[*(_QWORD *)(v7 + 328)];
if ( v9 )
{
v4 = v16 + 544;
v5 = v15;
v11 = my_b_read_0(v16 + 544, v15, *(_QWORD *)(v7 + 320));
if ( *(_QWORD *)(*(_QWORD *)v16 + 328LL) != *(_QWORD *)(*(_QWORD *)v16 + 320LL) && !v11 )
{
v4 = v16 + 544;
v5 = v18;
v11 = my_b_read_0(v16 + 544, v18, *(_QWORD *)(*(_QWORD *)v16 + 328LL) - *(_QWORD *)(*(_QWORD *)v16 + 320LL));
}
if ( v12 )
{
v4 = v16;
v5 = 0LL;
mi_writeinfo((_QWORD *)v16, 0LL);
}
if ( v11 )
{
if ( *(_DWORD *)(v16 + 772) != -1 || !*(_DWORD *)my_thread_var(v4, v5) )
{
if ( *(_DWORD *)(v16 + 772) )
*(_DWORD *)my_thread_var(v4, v5) = 127;
else
*(_DWORD *)my_thread_var(v4, v5) = 137;
}
return *(unsigned int *)my_thread_var(v4, v5);
}
else if ( *v15 )
{
*(_DWORD *)(v16 + 464) |= 0x82u;
return 0;
}
else
{
*(_DWORD *)my_thread_var(v4, v5) = 134;
return 134;
}
}
else
{
static_record = mi_read_static_record(v16, (unsigned long long)a3, v15);
if ( static_record )
{
if ( static_record <= 0 )
{
return *(unsigned int *)my_thread_var(v16, a3);
}
else
{
*(_DWORD *)my_thread_var(v16, a3) = 134;
return 134;
}
}
return (unsigned int)static_record;
}
}
else
{
if ( !*(_DWORD *)(*(_QWORD *)v16 + 872LL) )
{
a1 = v16;
a2 = 0LL;
mi_writeinfo((_QWORD *)v16, 0LL);
}
*(_DWORD *)my_thread_var(a1, a2) = 137;
return 137;
}
}
| _mi_read_rnd_static_record:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV AL,CL
MOV RCX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RCX
MOV qword ptr [RBP + -0x20],RDI
MOV qword ptr [RBP + -0x28],RSI
MOV qword ptr [RBP + -0x30],RDX
MOV byte ptr [RBP + -0x31],AL
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x50],RAX
MOV dword ptr [RBP + -0x40],0x0
MOV dword ptr [RBP + -0x44],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0x1c8]
AND EAX,0x10
CMP EAX,0x0
JZ 0x001c4546
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x220]
CMP RAX,qword ptr [RBP + -0x30]
JBE 0x001c451b
MOVSX EAX,byte ptr [RBP + -0x31]
CMP EAX,0x0
JZ 0x001c4546
LAB_001c451b:
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x220
MOV ESI,0x1
CALL 0x001e0be0
CMP EAX,0x0
JZ 0x001c4546
JMP 0x001c4537
LAB_001c4537:
CALL 0x001f60c0
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x14],EAX
JMP 0x001c4862
LAB_001c4546:
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0x1c8]
AND EAX,0x2
CMP EAX,0x0
JZ 0x001c45c1
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x58],RAX
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x220
CALL 0x001c4890
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x58]
CMP RAX,RCX
JNZ 0x001c45b1
MOVSX EAX,byte ptr [RBP + -0x31]
CMP EAX,0x0
JNZ 0x001c458c
CMP qword ptr [RBP + -0x30],0x0
JNZ 0x001c45b1
LAB_001c458c:
MOV dword ptr [RBP + -0x40],0x1
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x238]
MOV RCX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RCX + 0x230]
SUB RAX,RCX
MOV dword ptr [RBP + -0x44],EAX
JMP 0x001c45bf
LAB_001c45b1:
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x300],0x1
LAB_001c45bf:
JMP 0x001c45c1
LAB_001c45c1:
MOV dword ptr [RBP + -0x38],0x0
MOV RAX,qword ptr [RBP + -0x20]
CMP dword ptr [RAX + 0x1f4],0x2
JNZ 0x001c4685
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RCX + 0x8]
CMP RAX,qword ptr [RCX + 0x28]
JC 0x001c4617
MOV RDI,qword ptr [RBP + -0x20]
XOR EDX,EDX
MOV ESI,EDX
CALL 0x001b10f0
CMP EAX,0x0
JZ 0x001c460e
JMP 0x001c45ff
LAB_001c45ff:
CALL 0x001f60c0
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x14],EAX
JMP 0x001c4862
LAB_001c460e:
MOV dword ptr [RBP + -0x38],0x1
JMP 0x001c4683
LAB_001c4617:
CMP dword ptr [RBP + -0x40],0x0
JZ 0x001c4630
MOV RAX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RAX + 0x140]
MOV ECX,dword ptr [RBP + -0x44]
CMP RAX,RCX
JBE 0x001c4681
LAB_001c4630:
MOV RAX,qword ptr [RBP + -0x50]
CMP dword ptr [RAX + 0x368],0x0
JNZ 0x001c4681
MOV RAX,qword ptr [RBP + -0x50]
MOV EDI,dword ptr [RAX + 0x350]
MOV RAX,qword ptr [RBP + -0x20]
MOV R8,qword ptr [RAX + 0x330]
OR R8,0x20
XOR ESI,ESI
XOR EAX,EAX
MOV ECX,EAX
MOV RDX,RCX
CALL 0x001f3530
CMP EAX,0x0
JZ 0x001c467a
JMP 0x001c466b
LAB_001c466b:
CALL 0x001f60c0
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x14],EAX
JMP 0x001c4862
LAB_001c467a:
MOV dword ptr [RBP + -0x38],0x1
LAB_001c4681:
JMP 0x001c4683
LAB_001c4683:
JMP 0x001c4685
LAB_001c4685:
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RCX + 0x8]
CMP RAX,qword ptr [RCX + 0x28]
JC 0x001c46cf
JMP 0x001c4699
LAB_001c4699:
JMP 0x001c469b
LAB_001c469b:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
CMP dword ptr [RAX + 0x368],0x0
JNZ 0x001c46b6
MOV RDI,qword ptr [RBP + -0x20]
XOR ESI,ESI
CALL 0x001b1250
LAB_001c46b6:
JMP 0x001c46b8
LAB_001c46b8:
CALL 0x001f60c0
MOV dword ptr [RAX],0x89
MOV dword ptr [RBP + -0x14],0x89
JMP 0x001c4862
LAB_001c46cf:
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x170],RCX
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x50]
ADD RCX,qword ptr [RAX + 0x148]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x178],RCX
CMP dword ptr [RBP + -0x40],0x0
JNZ 0x001c474a
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x28]
CALL 0x001c4360
MOV dword ptr [RBP + -0x3c],EAX
CMP EAX,0x0
JZ 0x001c473d
CMP dword ptr [RBP + -0x3c],0x0
JLE 0x001c4731
CALL 0x001f60c0
MOV dword ptr [RAX],0x86
MOV dword ptr [RBP + -0x3c],0x86
JMP 0x001c473b
LAB_001c4731:
CALL 0x001f60c0
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x3c],EAX
LAB_001c473b:
JMP 0x001c473d
LAB_001c473d:
JMP 0x001c473f
LAB_001c473f:
MOV EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x14],EAX
JMP 0x001c4862
LAB_001c474a:
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x220
MOV RSI,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x50]
MOV RDX,qword ptr [RAX + 0x140]
CALL 0x001c48f0
MOV dword ptr [RBP + -0x3c],EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x148]
MOV RCX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RCX]
CMP RAX,qword ptr [RCX + 0x140]
JZ 0x001c47c3
CMP dword ptr [RBP + -0x3c],0x0
JNZ 0x001c47c3
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x220
LEA RSI,[RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x148]
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
SUB RDX,qword ptr [RAX + 0x140]
CALL 0x001c48f0
MOV dword ptr [RBP + -0x3c],EAX
LAB_001c47c3:
CMP dword ptr [RBP + -0x38],0x0
JZ 0x001c47d4
MOV RDI,qword ptr [RBP + -0x20]
XOR ESI,ESI
CALL 0x001b1250
LAB_001c47d4:
CMP dword ptr [RBP + -0x3c],0x0
JNZ 0x001c4818
MOV RAX,qword ptr [RBP + -0x28]
CMP byte ptr [RAX],0x0
JNZ 0x001c47f9
JMP 0x001c47e5
LAB_001c47e5:
CALL 0x001f60c0
MOV dword ptr [RAX],0x86
MOV dword ptr [RBP + -0x14],0x86
JMP 0x001c4862
LAB_001c47f9:
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x1d0]
OR ECX,0x82
MOV dword ptr [RAX + 0x1d0],ECX
MOV dword ptr [RBP + -0x14],0x0
JMP 0x001c4862
LAB_001c4818:
MOV RAX,qword ptr [RBP + -0x20]
CMP dword ptr [RAX + 0x304],-0x1
JNZ 0x001c482f
CALL 0x001f60c0
CMP dword ptr [RAX],0x0
JNZ 0x001c4856
LAB_001c482f:
MOV RAX,qword ptr [RBP + -0x20]
CMP dword ptr [RAX + 0x304],0x0
JNZ 0x001c4849
CALL 0x001f60c0
MOV dword ptr [RAX],0x89
JMP 0x001c4854
LAB_001c4849:
CALL 0x001f60c0
MOV dword ptr [RAX],0x7f
LAB_001c4854:
JMP 0x001c4856
LAB_001c4856:
JMP 0x001c4858
LAB_001c4858:
CALL 0x001f60c0
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x14],EAX
LAB_001c4862:
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x5c],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001c4883
MOV EAX,dword ptr [RBP + -0x5c]
ADD RSP,0x60
POP RBP
RET
LAB_001c4883:
CALL 0x0012a270
|
int _mi_read_rnd_static_record(long *param_1,char *param_2,ulong param_3,char param_4)
{
long lVar1;
bool bVar2;
bool bVar3;
int iVar4;
int *piVar5;
ulong uVar6;
int4 *puVar7;
long in_FS_OFFSET;
uint local_4c;
int local_44;
int local_1c;
int1 local_18 [8];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
lVar1 = *param_1;
bVar3 = false;
local_4c = 0;
if (((*(uint *)(param_1 + 0x39) & 0x10) == 0) ||
(((param_3 < (ulong)param_1[0x44] && (param_4 == '\0')) ||
(iVar4 = my_b_flush_io_cache(param_1 + 0x44,1), iVar4 == 0)))) {
if ((*(uint *)(param_1 + 0x39) & 2) != 0) {
uVar6 = my_b_tell(param_1 + 0x44);
if ((param_3 == uVar6) && ((param_4 != '\0' || (param_3 == 0)))) {
bVar3 = true;
local_4c = (int)param_1[0x47] - (int)param_1[0x46];
}
else {
*(int4 *)(param_1 + 0x60) = 1;
}
}
bVar2 = false;
if (*(int *)((long)param_1 + 500) == 2) {
if (param_3 < *(ulong *)(param_1[1] + 0x28)) {
if (((!bVar3) || ((ulong)local_4c < *(ulong *)(lVar1 + 0x140))) &&
(*(int *)(lVar1 + 0x368) == 0)) {
iVar4 = my_lock(*(int4 *)(lVar1 + 0x350),0,0,0,param_1[0x66] | 0x20);
if (iVar4 != 0) {
piVar5 = (int *)_my_thread_var();
local_1c = *piVar5;
goto LAB_001c4862;
}
bVar2 = true;
}
}
else {
iVar4 = _mi_readinfo(param_1,0);
if (iVar4 != 0) {
piVar5 = (int *)_my_thread_var();
local_1c = *piVar5;
goto LAB_001c4862;
}
bVar2 = true;
}
}
if (param_3 < *(ulong *)(param_1[1] + 0x28)) {
param_1[0x2e] = param_3;
param_1[0x2f] = param_3 + *(long *)(lVar1 + 0x148);
if (bVar3) {
local_44 = my_b_read(param_1 + 0x44,param_2,*(int8 *)(lVar1 + 0x140));
if ((*(long *)(*param_1 + 0x148) != *(long *)(*param_1 + 0x140)) && (local_44 == 0)) {
local_44 = my_b_read(param_1 + 0x44,local_18,
*(long *)(*param_1 + 0x148) - *(long *)(*param_1 + 0x140));
}
if (bVar2) {
_mi_writeinfo(param_1,0);
}
if (local_44 == 0) {
if (*param_2 == '\0') {
puVar7 = (int4 *)_my_thread_var();
*puVar7 = 0x86;
local_1c = 0x86;
}
else {
*(uint *)(param_1 + 0x3a) = *(uint *)(param_1 + 0x3a) | 0x82;
local_1c = 0;
}
}
else {
if ((*(int *)((long)param_1 + 0x304) != -1) ||
(piVar5 = (int *)_my_thread_var(), *piVar5 == 0)) {
if (*(int *)((long)param_1 + 0x304) == 0) {
puVar7 = (int4 *)_my_thread_var();
*puVar7 = 0x89;
}
else {
puVar7 = (int4 *)_my_thread_var();
*puVar7 = 0x7f;
}
}
piVar5 = (int *)_my_thread_var();
local_1c = *piVar5;
}
}
else {
local_44 = _mi_read_static_record(param_1,param_3,param_2);
if (local_44 != 0) {
if (local_44 < 1) {
piVar5 = (int *)_my_thread_var();
local_44 = *piVar5;
}
else {
puVar7 = (int4 *)_my_thread_var();
*puVar7 = 0x86;
local_44 = 0x86;
}
}
local_1c = local_44;
}
}
else {
if (*(int *)(*param_1 + 0x368) == 0) {
_mi_writeinfo(param_1,0);
}
puVar7 = (int4 *)_my_thread_var();
*puVar7 = 0x89;
local_1c = 0x89;
}
}
else {
piVar5 = (int *)_my_thread_var();
local_1c = *piVar5;
}
LAB_001c4862:
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_1c;
}
| |
48,398 | strxnmov | eloqsql/strings/strxnmov.c | char *strxnmov(char *dst, size_t len, const char *src, ...)
{
va_list pvar;
char *end_of_dst=dst+len;
va_start(pvar,src);
while (src != NullS)
{
do
{
if (dst == end_of_dst)
goto end;
}
while ((*dst++ = *src++));
dst--;
src = va_arg(pvar, char *);
}
end:
*dst=0;
va_end(pvar);
return dst;
} | O0 | c | strxnmov:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
testb %al, %al
je 0x8081b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0x80927
jmp 0x80879
movq -0x8(%rbp), %rax
cmpq -0x38(%rbp), %rax
jne 0x80888
jmp 0x80929
jmp 0x8088a
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb (%rax), %al
movq -0x8(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %al, (%rcx)
cmpb $0x0, %al
jne 0x80879
movq -0x8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x100(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0xf4(%rbp)
cmpl $0x28, %eax
ja 0x808f7
movq -0x100(%rbp), %rcx
movl -0xf4(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x108(%rbp)
jmp 0x80914
movq -0x100(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x108(%rbp)
movq -0x108(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x8086c
jmp 0x80929
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
| strxnmov:
push rbp
mov rbp, rsp
sub rsp, 90h
test al, al
jz short loc_8081B
movaps [rbp+var_C0], xmm0
movaps [rbp+var_B0], xmm1
movaps [rbp+var_A0], xmm2
movaps [rbp+var_90], xmm3
movaps [rbp+var_80], xmm4
movaps [rbp+var_70], xmm5
movaps [rbp+var_60], xmm6
movaps [rbp+var_50], xmm7
loc_8081B:
mov [rbp+var_C8], r9
mov [rbp+var_D0], r8
mov [rbp+var_D8], rcx
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_8]
add rax, [rbp+var_10]
mov [rbp+var_38], rax
lea rax, [rbp+var_30]
lea rcx, [rbp+var_F0]
mov [rax+10h], rcx
lea rcx, [rbp+arg_0]
mov [rax+8], rcx
mov dword ptr [rax+4], 30h ; '0'
mov dword ptr [rax], 18h
loc_8086C:
cmp [rbp+var_18], 0
jz loc_80927
jmp short $+2
loc_80879:
mov rax, [rbp+var_8]
cmp rax, [rbp+var_38]
jnz short loc_80888
jmp loc_80929
loc_80888:
jmp short $+2
loc_8088A:
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 1
mov [rbp+var_18], rcx
mov al, [rax]
mov rcx, [rbp+var_8]
mov rdx, rcx
add rdx, 1
mov [rbp+var_8], rdx
mov [rcx], al
cmp al, 0
jnz short loc_80879
mov rax, [rbp+var_8]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_8], rax
lea rax, [rbp+var_30]
mov [rbp+var_100], rax
mov eax, [rbp+var_30]
mov [rbp+var_F4], eax
cmp eax, 28h ; '('
ja short loc_808F7
mov rcx, [rbp+var_100]
mov edx, [rbp+var_F4]
movsxd rax, edx
add rax, [rcx+10h]
add edx, 8
mov [rcx], edx
mov [rbp+var_108], rax
jmp short loc_80914
loc_808F7:
mov rcx, [rbp+var_100]
mov rax, [rcx+8]
mov rdx, rax
add rdx, 8
mov [rcx+8], rdx
mov [rbp+var_108], rax
loc_80914:
mov rax, [rbp+var_108]
mov rax, [rax]
mov [rbp+var_18], rax
jmp loc_8086C
loc_80927:
jmp short $+2
loc_80929:
mov rax, [rbp+var_8]
mov byte ptr [rax], 0
mov rax, [rbp+var_8]
add rsp, 90h
pop rbp
retn
| _BYTE * strxnmov(
_BYTE *a1,
long long a2,
_BYTE *a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
_BYTE *v15; // rax
_BYTE *v16; // rcx
char *v17; // rax
char v19; // [rsp+18h] [rbp-F0h] BYREF
long long v20; // [rsp+30h] [rbp-D8h]
long long v21; // [rsp+38h] [rbp-D0h]
long long v22; // [rsp+40h] [rbp-C8h]
__m128 v23; // [rsp+48h] [rbp-C0h]
__m128 v24; // [rsp+58h] [rbp-B0h]
__m128 v25; // [rsp+68h] [rbp-A0h]
__m128 v26; // [rsp+78h] [rbp-90h]
__m128 v27; // [rsp+88h] [rbp-80h]
__m128 v28; // [rsp+98h] [rbp-70h]
__m128 v29; // [rsp+A8h] [rbp-60h]
__m128 v30; // [rsp+B8h] [rbp-50h]
_BYTE *v31; // [rsp+D0h] [rbp-38h]
int v32; // [rsp+D8h] [rbp-30h]
int v33; // [rsp+DCh] [rbp-2Ch]
char *v34; // [rsp+E0h] [rbp-28h]
char *v35; // [rsp+E8h] [rbp-20h]
_BYTE *v36; // [rsp+F0h] [rbp-18h]
long long v37; // [rsp+F8h] [rbp-10h]
_BYTE *v38; // [rsp+100h] [rbp-8h]
v23 = a7;
v24 = a8;
v25 = a9;
v26 = a10;
v27 = a11;
v28 = a12;
v29 = a13;
v30 = a14;
v22 = a6;
v21 = a5;
v20 = a4;
v38 = a1;
v37 = a2;
v36 = a3;
v31 = &a1[a2];
v35 = &v19;
v34 = &a15;
v33 = 48;
v32 = 24;
LABEL_2:
if ( v36 )
{
while ( v38 != v31 )
{
v15 = v36++;
LOBYTE(v15) = *v15;
v16 = v38++;
*v16 = (_BYTE)v15;
if ( !(_BYTE)v15 )
{
--v38;
if ( (unsigned int)v32 > 0x28 )
{
v17 = v34;
v34 += 8;
}
else
{
v17 = &v35[v32];
v32 += 8;
}
v36 = *(_BYTE **)v17;
goto LABEL_2;
}
}
}
*v38 = 0;
return v38;
}
| strxnmov:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
TEST AL,AL
JZ 0x0018081b
MOVAPS xmmword ptr [RBP + -0xc0],XMM0
MOVAPS xmmword ptr [RBP + -0xb0],XMM1
MOVAPS xmmword ptr [RBP + -0xa0],XMM2
MOVAPS xmmword ptr [RBP + -0x90],XMM3
MOVAPS xmmword ptr [RBP + -0x80],XMM4
MOVAPS xmmword ptr [RBP + -0x70],XMM5
MOVAPS xmmword ptr [RBP + -0x60],XMM6
MOVAPS xmmword ptr [RBP + -0x50],XMM7
LAB_0018081b:
MOV qword ptr [RBP + -0xc8],R9
MOV qword ptr [RBP + -0xd0],R8
MOV qword ptr [RBP + -0xd8],RCX
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x38],RAX
LEA RAX,[RBP + -0x30]
LEA RCX,[RBP + -0xf0]
MOV qword ptr [RAX + 0x10],RCX
LEA RCX,[RBP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RAX + 0x4],0x30
MOV dword ptr [RAX],0x18
LAB_0018086c:
CMP qword ptr [RBP + -0x18],0x0
JZ 0x00180927
JMP 0x00180879
LAB_00180879:
MOV RAX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RBP + -0x38]
JNZ 0x00180888
JMP 0x00180929
LAB_00180888:
JMP 0x0018088a
LAB_0018088a:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x18],RCX
MOV AL,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x8]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x8],RDX
MOV byte ptr [RCX],AL
CMP AL,0x0
JNZ 0x00180879
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x8],RAX
LEA RAX,[RBP + -0x30]
MOV qword ptr [RBP + -0x100],RAX
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0xf4],EAX
CMP EAX,0x28
JA 0x001808f7
MOV RCX,qword ptr [RBP + -0x100]
MOV EDX,dword ptr [RBP + -0xf4]
MOVSXD RAX,EDX
ADD RAX,qword ptr [RCX + 0x10]
ADD EDX,0x8
MOV dword ptr [RCX],EDX
MOV qword ptr [RBP + -0x108],RAX
JMP 0x00180914
LAB_001808f7:
MOV RCX,qword ptr [RBP + -0x100]
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RCX + 0x8],RDX
MOV qword ptr [RBP + -0x108],RAX
LAB_00180914:
MOV RAX,qword ptr [RBP + -0x108]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0018086c
LAB_00180927:
JMP 0x00180929
LAB_00180929:
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x90
POP RBP
RET
|
/* WARNING: Restarted to delay deadcode elimination for space: stack */
char * strxnmov(char *param_1,long param_2,char *param_3)
{
char cVar1;
char *pcVar2;
int8 *local_110;
int8 local_f8 [24];
uint local_38;
int8 *local_30;
char *local_20;
char *local_10;
local_30 = (int8 *)&stack0x00000008;
local_38 = 0x18;
local_20 = param_3;
local_10 = param_1;
while (pcVar2 = local_10, local_20 != (char *)0x0) {
do {
local_10 = pcVar2;
if (local_10 == param_1 + param_2) goto LAB_00180929;
cVar1 = *local_20;
*local_10 = cVar1;
local_20 = local_20 + 1;
pcVar2 = local_10 + 1;
} while (cVar1 != '\0');
if (local_38 < 0x29) {
local_110 = (int8 *)((long)local_f8 + (long)(int)local_38);
local_38 = local_38 + 8;
}
else {
local_110 = local_30;
local_30 = local_30 + 1;
}
local_20 = (char *)*local_110;
}
LAB_00180929:
*local_10 = '\0';
return local_10;
}
| |
48,399 | my_hash_delete | eloqsql/mysys/hash.c | my_bool my_hash_delete(HASH *hash, uchar *record)
{
uint pos2,idx,empty_index;
my_hash_value_type pos_hashnr, lastpos_hashnr;
size_t blength;
HASH_LINK *data,*lastpos,*gpos,*pos,*pos3,*empty;
DBUG_ENTER("my_hash_delete");
if (!hash->records)
DBUG_RETURN(1);
blength=hash->blength;
data=dynamic_element(&hash->array,0,HASH_LINK*);
/* Search after record with key */
pos= data + my_hash_mask(rec_hashnr(hash, record), blength, hash->records);
gpos = 0;
while (pos->data != record)
{
gpos=pos;
if (pos->next == NO_RECORD)
DBUG_RETURN(1); /* Key not found */
pos=data+pos->next;
}
if ( --(hash->records) < hash->blength >> 1) hash->blength>>=1;
lastpos=data+hash->records;
/* Remove link to record */
empty=pos; empty_index=(uint) (empty-data);
if (gpos)
gpos->next=pos->next; /* unlink current ptr */
else if (pos->next != NO_RECORD)
{
empty=data+(empty_index=pos->next);
pos[0]= empty[0];
}
if (empty == lastpos) /* last key at wrong pos or no next link */
goto exit;
/* Move the last key (lastpos) */
lastpos_hashnr= lastpos->hash_nr;
/* pos is where lastpos should be */
pos= data + my_hash_mask(lastpos_hashnr, hash->blength, hash->records);
if (pos == empty) /* Move to empty position. */
{
empty[0]=lastpos[0];
goto exit;
}
pos_hashnr= pos->hash_nr;
/* pos3 is where the pos should be */
pos3= data + my_hash_mask(pos_hashnr, hash->blength, hash->records);
if (pos != pos3)
{ /* pos is on wrong posit */
empty[0]=pos[0]; /* Save it here */
pos[0]=lastpos[0]; /* This should be here */
movelink(data,(uint) (pos-data),(uint) (pos3-data),empty_index);
goto exit;
}
pos2= my_hash_mask(lastpos_hashnr, blength, hash->records + 1);
if (pos2 == my_hash_mask(pos_hashnr, blength, hash->records + 1))
{ /* Identical key-positions */
if (pos2 != hash->records)
{
empty[0]=lastpos[0];
movelink(data,(uint) (lastpos-data),(uint) (pos-data),empty_index);
goto exit;
}
idx= (uint) (pos-data); /* Link pos->next after lastpos */
}
else idx= NO_RECORD; /* Different positions merge */
empty[0]=lastpos[0];
movelink(data,idx,empty_index,pos->next);
pos->next=empty_index;
exit:
(void) pop_dynamic(&hash->array);
if (hash->free)
(*hash->free)((uchar*) record);
DBUG_RETURN(0);
} | O0 | c | my_hash_delete:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x82239
jmp 0x82230
movb $0x1, -0x1(%rbp)
jmp 0x825b2
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x825c0
movl %eax, %edi
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0x81a40
movl %eax, %ecx
movq -0x70(%rbp), %rax
movl %ecx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x58(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x58(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
je 0x822d5
movq -0x58(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
cmpl $-0x1, (%rax)
jne 0x822be
jmp 0x822b5
movb $0x1, -0x1(%rbp)
jmp 0x825b2
movq -0x40(%rbp), %rax
movq -0x58(%rbp), %rcx
movl (%rcx), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x58(%rbp)
jmp 0x82294
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rax
addq $-0x1, %rax
movq %rax, 0x18(%rcx)
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
shrq %rcx
cmpq %rcx, %rax
jae 0x82304
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
shrq %rcx
movq %rcx, 0x10(%rax)
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq -0x40(%rbp), %rcx
subq %rcx, %rax
sarq $0x4, %rax
movl %eax, -0x24(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0x8234a
movq -0x58(%rbp), %rax
movl (%rax), %ecx
movq -0x50(%rbp), %rax
movl %ecx, (%rax)
jmp 0x82385
movq -0x58(%rbp), %rax
cmpl $-0x1, (%rax)
je 0x82383
movq -0x40(%rbp), %rax
movq -0x58(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, -0x24(%rbp)
movl %ecx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x68(%rbp)
movq -0x58(%rbp), %rax
movq -0x68(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
jmp 0x82385
movq -0x68(%rbp), %rax
cmpq -0x48(%rbp), %rax
jne 0x82394
jmp 0x82586
movq -0x48(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x78(%rbp)
movl -0x2c(%rbp), %edi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0x81a40
movl %eax, %ecx
movq -0x78(%rbp), %rax
movl %ecx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
cmpq -0x68(%rbp), %rax
jne 0x823f6
movq -0x68(%rbp), %rax
movq -0x48(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
jmp 0x82586
movq -0x58(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x80(%rbp)
movl -0x28(%rbp), %edi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0x81a40
movl %eax, %ecx
movq -0x80(%rbp), %rax
movl %ecx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rax
cmpq -0x60(%rbp), %rax
je 0x8249c
movq -0x68(%rbp), %rax
movq -0x58(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x58(%rbp), %rax
movq -0x48(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rdi
movq -0x58(%rbp), %rax
movq -0x40(%rbp), %rcx
subq %rcx, %rax
sarq $0x4, %rax
movl %eax, %esi
movq -0x60(%rbp), %rax
movq -0x40(%rbp), %rcx
subq %rcx, %rax
sarq $0x4, %rax
movl %eax, %edx
movl -0x24(%rbp), %ecx
callq 0x821d0
jmp 0x82586
movl -0x2c(%rbp), %edi
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
addq $0x1, %rdx
callq 0x81a40
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x84(%rbp)
movl -0x28(%rbp), %edi
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
addq $0x1, %rdx
callq 0x81a40
movl %eax, %ecx
movl -0x84(%rbp), %eax
cmpl %ecx, %eax
jne 0x8254b
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
je 0x82537
movq -0x68(%rbp), %rax
movq -0x48(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rcx
subq %rcx, %rax
sarq $0x4, %rax
movl %eax, %esi
movq -0x58(%rbp), %rax
movq -0x40(%rbp), %rcx
subq %rcx, %rax
sarq $0x4, %rax
movl %eax, %edx
movl -0x24(%rbp), %ecx
callq 0x821d0
jmp 0x82586
movq -0x58(%rbp), %rax
movq -0x40(%rbp), %rcx
subq %rcx, %rax
sarq $0x4, %rax
movl %eax, -0x20(%rbp)
jmp 0x82552
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movq -0x68(%rbp), %rax
movq -0x48(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x24(%rbp), %edx
movq -0x58(%rbp), %rax
movl (%rax), %ecx
callq 0x821d0
movl -0x24(%rbp), %ecx
movq -0x58(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x8fd90
movq -0x10(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x825ac
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
jmp 0x825ae
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x90, %rsp
popq %rbp
retq
nop
| my_hash_delete:
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
cmp qword ptr [rax+18h], 0
jnz short loc_82239
jmp short $+2
loc_82230:
mov [rbp+var_1], 1
jmp loc_825B2
loc_82239:
mov rax, [rbp+var_10]
mov rax, [rax+10h]
mov [rbp+var_38], rax
mov rax, [rbp+var_10]
mov rax, [rax+28h]
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
mov [rbp+var_70], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call rec_hashnr_0
mov edi, eax
mov rsi, [rbp+var_38]
mov rax, [rbp+var_10]
mov rdx, [rax+18h]
call my_hash_mask
mov ecx, eax
mov rax, [rbp+var_70]
mov ecx, ecx
shl rcx, 4
add rax, rcx
mov [rbp+var_58], rax
mov [rbp+var_50], 0
loc_82294:
mov rax, [rbp+var_58]
mov rax, [rax+8]
cmp rax, [rbp+var_18]
jz short loc_822D5
mov rax, [rbp+var_58]
mov [rbp+var_50], rax
mov rax, [rbp+var_58]
cmp dword ptr [rax], 0FFFFFFFFh
jnz short loc_822BE
jmp short $+2
loc_822B5:
mov [rbp+var_1], 1
jmp loc_825B2
loc_822BE:
mov rax, [rbp+var_40]
mov rcx, [rbp+var_58]
mov ecx, [rcx]
shl rcx, 4
add rax, rcx
mov [rbp+var_58], rax
jmp short loc_82294
loc_822D5:
mov rcx, [rbp+var_10]
mov rax, [rcx+18h]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rcx+18h], rax
mov rcx, [rbp+var_10]
mov rcx, [rcx+10h]
shr rcx, 1
cmp rax, rcx
jnb short loc_82304
mov rax, [rbp+var_10]
mov rcx, [rax+10h]
shr rcx, 1
mov [rax+10h], rcx
loc_82304:
mov rax, [rbp+var_40]
mov rcx, [rbp+var_10]
mov rcx, [rcx+18h]
shl rcx, 4
add rax, rcx
mov [rbp+var_48], rax
mov rax, [rbp+var_58]
mov [rbp+var_68], rax
mov rax, [rbp+var_68]
mov rcx, [rbp+var_40]
sub rax, rcx
sar rax, 4
mov [rbp+var_24], eax
cmp [rbp+var_50], 0
jz short loc_8234A
mov rax, [rbp+var_58]
mov ecx, [rax]
mov rax, [rbp+var_50]
mov [rax], ecx
jmp short loc_82385
loc_8234A:
mov rax, [rbp+var_58]
cmp dword ptr [rax], 0FFFFFFFFh
jz short loc_82383
mov rax, [rbp+var_40]
mov rcx, [rbp+var_58]
mov ecx, [rcx]
mov [rbp+var_24], ecx
mov ecx, ecx
shl rcx, 4
add rax, rcx
mov [rbp+var_68], rax
mov rax, [rbp+var_58]
mov rcx, [rbp+var_68]
mov rdx, [rcx]
mov [rax], rdx
mov rcx, [rcx+8]
mov [rax+8], rcx
loc_82383:
jmp short $+2
loc_82385:
mov rax, [rbp+var_68]
cmp rax, [rbp+var_48]
jnz short loc_82394
jmp loc_82586
loc_82394:
mov rax, [rbp+var_48]
mov eax, [rax+4]
mov [rbp+var_2C], eax
mov rax, [rbp+var_40]
mov [rbp+var_78], rax
mov edi, [rbp+var_2C]
mov rax, [rbp+var_10]
mov rsi, [rax+10h]
mov rax, [rbp+var_10]
mov rdx, [rax+18h]
call my_hash_mask
mov ecx, eax
mov rax, [rbp+var_78]
mov ecx, ecx
shl rcx, 4
add rax, rcx
mov [rbp+var_58], rax
mov rax, [rbp+var_58]
cmp rax, [rbp+var_68]
jnz short loc_823F6
mov rax, [rbp+var_68]
mov rcx, [rbp+var_48]
mov rdx, [rcx]
mov [rax], rdx
mov rcx, [rcx+8]
mov [rax+8], rcx
jmp loc_82586
loc_823F6:
mov rax, [rbp+var_58]
mov eax, [rax+4]
mov [rbp+var_28], eax
mov rax, [rbp+var_40]
mov [rbp+var_80], rax
mov edi, [rbp+var_28]
mov rax, [rbp+var_10]
mov rsi, [rax+10h]
mov rax, [rbp+var_10]
mov rdx, [rax+18h]
call my_hash_mask
mov ecx, eax
mov rax, [rbp+var_80]
mov ecx, ecx
shl rcx, 4
add rax, rcx
mov [rbp+var_60], rax
mov rax, [rbp+var_58]
cmp rax, [rbp+var_60]
jz short loc_8249C
mov rax, [rbp+var_68]
mov rcx, [rbp+var_58]
mov rdx, [rcx]
mov [rax], rdx
mov rcx, [rcx+8]
mov [rax+8], rcx
mov rax, [rbp+var_58]
mov rcx, [rbp+var_48]
mov rdx, [rcx]
mov [rax], rdx
mov rcx, [rcx+8]
mov [rax+8], rcx
mov rdi, [rbp+var_40]
mov rax, [rbp+var_58]
mov rcx, [rbp+var_40]
sub rax, rcx
sar rax, 4
mov esi, eax
mov rax, [rbp+var_60]
mov rcx, [rbp+var_40]
sub rax, rcx
sar rax, 4
mov edx, eax
mov ecx, [rbp+var_24]
call movelink_0
jmp loc_82586
loc_8249C:
mov edi, [rbp+var_2C]
mov rsi, [rbp+var_38]
mov rax, [rbp+var_10]
mov rdx, [rax+18h]
add rdx, 1
call my_hash_mask
mov [rbp+var_1C], eax
mov eax, [rbp+var_1C]
mov [rbp+var_84], eax
mov edi, [rbp+var_28]
mov rsi, [rbp+var_38]
mov rax, [rbp+var_10]
mov rdx, [rax+18h]
add rdx, 1
call my_hash_mask
mov ecx, eax
mov eax, [rbp+var_84]
cmp eax, ecx
jnz short loc_8254B
mov eax, [rbp+var_1C]
mov rcx, [rbp+var_10]
cmp rax, [rcx+18h]
jz short loc_82537
mov rax, [rbp+var_68]
mov rcx, [rbp+var_48]
mov rdx, [rcx]
mov [rax], rdx
mov rcx, [rcx+8]
mov [rax+8], rcx
mov rdi, [rbp+var_40]
mov rax, [rbp+var_48]
mov rcx, [rbp+var_40]
sub rax, rcx
sar rax, 4
mov esi, eax
mov rax, [rbp+var_58]
mov rcx, [rbp+var_40]
sub rax, rcx
sar rax, 4
mov edx, eax
mov ecx, [rbp+var_24]
call movelink_0
jmp short loc_82586
loc_82537:
mov rax, [rbp+var_58]
mov rcx, [rbp+var_40]
sub rax, rcx
sar rax, 4
mov [rbp+var_20], eax
jmp short loc_82552
loc_8254B:
mov [rbp+var_20], 0FFFFFFFFh
loc_82552:
mov rax, [rbp+var_68]
mov rcx, [rbp+var_48]
mov rdx, [rcx]
mov [rax], rdx
mov rcx, [rcx+8]
mov [rax+8], rcx
mov rdi, [rbp+var_40]
mov esi, [rbp+var_20]
mov edx, [rbp+var_24]
mov rax, [rbp+var_58]
mov ecx, [rax]
call movelink_0
mov ecx, [rbp+var_24]
mov rax, [rbp+var_58]
mov [rax], ecx
loc_82586:
mov rdi, [rbp+var_10]
add rdi, 28h ; '('
call pop_dynamic
mov rax, [rbp+var_10]
cmp qword ptr [rax+60h], 0
jz short loc_825AC
mov rax, [rbp+var_10]
mov rax, [rax+60h]
mov rdi, [rbp+var_18]
call rax
loc_825AC:
jmp short $+2
loc_825AE:
mov [rbp+var_1], 0
loc_825B2:
mov al, [rbp+var_1]
add rsp, 90h
pop rbp
retn
| char my_hash_delete(long long a1, long long a2)
{
unsigned int v2; // eax
unsigned long long v3; // rax
_QWORD *v5; // [rsp+28h] [rbp-68h]
long long v6; // [rsp+30h] [rbp-60h]
unsigned int *v7; // [rsp+38h] [rbp-58h]
long long v8; // [rsp+38h] [rbp-58h]
_DWORD *v9; // [rsp+40h] [rbp-50h]
long long v10; // [rsp+48h] [rbp-48h]
long long v11; // [rsp+50h] [rbp-40h]
unsigned long long v12; // [rsp+58h] [rbp-38h]
unsigned int v13; // [rsp+64h] [rbp-2Ch]
unsigned int v14; // [rsp+68h] [rbp-28h]
unsigned int v15; // [rsp+6Ch] [rbp-24h]
int v16; // [rsp+70h] [rbp-20h]
int v17; // [rsp+74h] [rbp-1Ch]
if ( !*(_QWORD *)(a1 + 24) )
return 1;
v12 = *(_QWORD *)(a1 + 16);
v11 = *(_QWORD *)(a1 + 40);
v2 = rec_hashnr_0(a1, a2);
v7 = (unsigned int *)(16LL * (unsigned int)my_hash_mask(v2, v12, *(_QWORD *)(a1 + 24)) + v11);
v9 = 0LL;
while ( *((_QWORD *)v7 + 1) != a2 )
{
v9 = v7;
if ( *v7 == -1 )
return 1;
v7 = (unsigned int *)(16LL * *v7 + v11);
}
v3 = *(_QWORD *)(a1 + 24) - 1LL;
*(_QWORD *)(a1 + 24) = v3;
if ( v3 < *(_QWORD *)(a1 + 16) >> 1 )
*(_QWORD *)(a1 + 16) >>= 1;
v10 = 16LL * *(_QWORD *)(a1 + 24) + v11;
v5 = v7;
v15 = ((long long)v7 - v11) >> 4;
if ( v9 )
{
*v9 = *v7;
}
else if ( *v7 != -1 )
{
v15 = *v7;
v5 = (_QWORD *)(16LL * *v7 + v11);
*(_QWORD *)v7 = *v5;
*((_QWORD *)v7 + 1) = v5[1];
}
if ( v5 != (_QWORD *)v10 )
{
v13 = *(_DWORD *)(v10 + 4);
v8 = 16LL * (unsigned int)my_hash_mask(v13, *(_QWORD *)(a1 + 16), *(_QWORD *)(a1 + 24)) + v11;
if ( (_QWORD *)v8 == v5 )
{
*v5 = *(_QWORD *)v10;
v5[1] = *(_QWORD *)(v10 + 8);
}
else
{
v14 = *(_DWORD *)(v8 + 4);
v6 = 16LL * (unsigned int)my_hash_mask(v14, *(_QWORD *)(a1 + 16), *(_QWORD *)(a1 + 24)) + v11;
if ( v8 == v6 )
{
v17 = my_hash_mask(v13, v12, *(_QWORD *)(a1 + 24) + 1LL);
if ( v17 == (unsigned int)my_hash_mask(v14, v12, *(_QWORD *)(a1 + 24) + 1LL) )
{
if ( v17 != *(_QWORD *)(a1 + 24) )
{
*v5 = *(_QWORD *)v10;
v5[1] = *(_QWORD *)(v10 + 8);
movelink_0(v11, (v10 - v11) >> 4, (v8 - v11) >> 4, v15);
goto LABEL_25;
}
v16 = (v8 - v11) >> 4;
}
else
{
v16 = -1;
}
*v5 = *(_QWORD *)v10;
v5[1] = *(_QWORD *)(v10 + 8);
movelink_0(v11, v16, v15, *(_DWORD *)v8);
*(_DWORD *)v8 = v15;
goto LABEL_25;
}
*v5 = *(_QWORD *)v8;
v5[1] = *(_QWORD *)(v8 + 8);
*(_QWORD *)v8 = *(_QWORD *)v10;
*(_QWORD *)(v8 + 8) = *(_QWORD *)(v10 + 8);
movelink_0(v11, (v8 - v11) >> 4, (v6 - v11) >> 4, v15);
}
}
LABEL_25:
pop_dynamic(a1 + 40);
if ( *(_QWORD *)(a1 + 96) )
(*(void ( **)(long long))(a1 + 96))(a2);
return 0;
}
| my_hash_delete:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x18],0x0
JNZ 0x00182239
JMP 0x00182230
LAB_00182230:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001825b2
LAB_00182239:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x70],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x001825c0
MOV EDI,EAX
MOV RSI,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x18]
CALL 0x00181a40
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x70]
MOV ECX,ECX
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RBP + -0x58],RAX
MOV qword ptr [RBP + -0x50],0x0
LAB_00182294:
MOV RAX,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RAX + 0x8]
CMP RAX,qword ptr [RBP + -0x18]
JZ 0x001822d5
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x58]
CMP dword ptr [RAX],-0x1
JNZ 0x001822be
JMP 0x001822b5
LAB_001822b5:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001825b2
LAB_001822be:
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RCX]
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RBP + -0x58],RAX
JMP 0x00182294
LAB_001822d5:
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RCX + 0x18]
ADD RAX,-0x1
MOV qword ptr [RCX + 0x18],RAX
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x10]
SHR RCX,0x1
CMP RAX,RCX
JNC 0x00182304
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x10]
SHR RCX,0x1
MOV qword ptr [RAX + 0x10],RCX
LAB_00182304:
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x18]
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x68]
MOV RCX,qword ptr [RBP + -0x40]
SUB RAX,RCX
SAR RAX,0x4
MOV dword ptr [RBP + -0x24],EAX
CMP qword ptr [RBP + -0x50],0x0
JZ 0x0018234a
MOV RAX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x50]
MOV dword ptr [RAX],ECX
JMP 0x00182385
LAB_0018234a:
MOV RAX,qword ptr [RBP + -0x58]
CMP dword ptr [RAX],-0x1
JZ 0x00182383
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RCX]
MOV dword ptr [RBP + -0x24],ECX
MOV ECX,ECX
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x68]
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX],RDX
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
LAB_00182383:
JMP 0x00182385
LAB_00182385:
MOV RAX,qword ptr [RBP + -0x68]
CMP RAX,qword ptr [RBP + -0x48]
JNZ 0x00182394
JMP 0x00182586
LAB_00182394:
MOV RAX,qword ptr [RBP + -0x48]
MOV EAX,dword ptr [RAX + 0x4]
MOV dword ptr [RBP + -0x2c],EAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x78],RAX
MOV EDI,dword ptr [RBP + -0x2c]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x18]
CALL 0x00181a40
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x78]
MOV ECX,ECX
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x58]
CMP RAX,qword ptr [RBP + -0x68]
JNZ 0x001823f6
MOV RAX,qword ptr [RBP + -0x68]
MOV RCX,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX],RDX
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
JMP 0x00182586
LAB_001823f6:
MOV RAX,qword ptr [RBP + -0x58]
MOV EAX,dword ptr [RAX + 0x4]
MOV dword ptr [RBP + -0x28],EAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x80],RAX
MOV EDI,dword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x18]
CALL 0x00181a40
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x80]
MOV ECX,ECX
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x58]
CMP RAX,qword ptr [RBP + -0x60]
JZ 0x0018249c
MOV RAX,qword ptr [RBP + -0x68]
MOV RCX,qword ptr [RBP + -0x58]
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX],RDX
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX],RDX
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV RDI,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x40]
SUB RAX,RCX
SAR RAX,0x4
MOV ESI,EAX
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x40]
SUB RAX,RCX
SAR RAX,0x4
MOV EDX,EAX
MOV ECX,dword ptr [RBP + -0x24]
CALL 0x001821d0
JMP 0x00182586
LAB_0018249c:
MOV EDI,dword ptr [RBP + -0x2c]
MOV RSI,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x18]
ADD RDX,0x1
CALL 0x00181a40
MOV dword ptr [RBP + -0x1c],EAX
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x84],EAX
MOV EDI,dword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x18]
ADD RDX,0x1
CALL 0x00181a40
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x84]
CMP EAX,ECX
JNZ 0x0018254b
MOV EAX,dword ptr [RBP + -0x1c]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x18]
JZ 0x00182537
MOV RAX,qword ptr [RBP + -0x68]
MOV RCX,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX],RDX
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV RDI,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RBP + -0x40]
SUB RAX,RCX
SAR RAX,0x4
MOV ESI,EAX
MOV RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x40]
SUB RAX,RCX
SAR RAX,0x4
MOV EDX,EAX
MOV ECX,dword ptr [RBP + -0x24]
CALL 0x001821d0
JMP 0x00182586
LAB_00182537:
MOV RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x40]
SUB RAX,RCX
SAR RAX,0x4
MOV dword ptr [RBP + -0x20],EAX
JMP 0x00182552
LAB_0018254b:
MOV dword ptr [RBP + -0x20],0xffffffff
LAB_00182552:
MOV RAX,qword ptr [RBP + -0x68]
MOV RCX,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX],RDX
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV RDI,qword ptr [RBP + -0x40]
MOV ESI,dword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x24]
MOV RAX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RAX]
CALL 0x001821d0
MOV ECX,dword ptr [RBP + -0x24]
MOV RAX,qword ptr [RBP + -0x58]
MOV dword ptr [RAX],ECX
LAB_00182586:
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x28
CALL 0x0018fd90
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x60],0x0
JZ 0x001825ac
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x60]
MOV RDI,qword ptr [RBP + -0x18]
CALL RAX
LAB_001825ac:
JMP 0x001825ae
LAB_001825ae:
MOV byte ptr [RBP + -0x1],0x0
LAB_001825b2:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x90
POP RBP
RET
|
int1 my_hash_delete(long param_1,long param_2)
{
int8 uVar1;
long lVar2;
int4 uVar3;
uint uVar4;
uint uVar5;
uint uVar6;
ulong uVar7;
uint *puVar8;
uint *puVar9;
uint *puVar10;
uint *local_70;
uint *local_60;
uint *local_58;
uint local_2c;
int4 local_28;
if (*(long *)(param_1 + 0x18) == 0) {
return 1;
}
uVar1 = *(int8 *)(param_1 + 0x10);
lVar2 = *(long *)(param_1 + 0x28);
uVar3 = rec_hashnr(param_1,param_2);
uVar4 = my_hash_mask(uVar3,uVar1,*(int8 *)(param_1 + 0x18));
local_58 = (uint *)0x0;
while (local_60 = (uint *)(lVar2 + (ulong)uVar4 * 0x10), *(long *)(local_60 + 2) != param_2) {
local_58 = local_60;
if (*local_60 == 0xffffffff) {
return 1;
}
uVar4 = *local_60;
}
uVar7 = *(long *)(param_1 + 0x18) - 1;
*(ulong *)(param_1 + 0x18) = uVar7;
if (uVar7 < *(ulong *)(param_1 + 0x10) >> 1) {
*(ulong *)(param_1 + 0x10) = *(ulong *)(param_1 + 0x10) >> 1;
}
puVar8 = (uint *)(lVar2 + *(long *)(param_1 + 0x18) * 0x10);
local_70 = local_60;
local_2c = (uint)((long)local_60 - lVar2 >> 4);
if (local_58 == (uint *)0x0) {
if (*local_60 != 0xffffffff) {
local_2c = *local_60;
local_70 = (uint *)(lVar2 + (ulong)local_2c * 0x10);
*(int8 *)local_60 = *(int8 *)local_70;
*(int8 *)(local_60 + 2) = *(int8 *)(local_70 + 2);
}
}
else {
*local_58 = *local_60;
}
if (local_70 != puVar8) {
uVar4 = puVar8[1];
uVar5 = my_hash_mask(uVar4,*(int8 *)(param_1 + 0x10),*(int8 *)(param_1 + 0x18));
puVar9 = (uint *)(lVar2 + (ulong)uVar5 * 0x10);
if (puVar9 == local_70) {
*(int8 *)local_70 = *(int8 *)puVar8;
*(int8 *)(local_70 + 2) = *(int8 *)(puVar8 + 2);
}
else {
uVar5 = puVar9[1];
uVar6 = my_hash_mask(uVar5,*(int8 *)(param_1 + 0x10),*(int8 *)(param_1 + 0x18));
puVar10 = (uint *)(lVar2 + (ulong)uVar6 * 0x10);
if (puVar9 == puVar10) {
uVar4 = my_hash_mask(uVar4,uVar1,*(long *)(param_1 + 0x18) + 1);
uVar5 = my_hash_mask(uVar5,uVar1,*(long *)(param_1 + 0x18) + 1);
if (uVar4 == uVar5) {
if ((ulong)uVar4 != *(ulong *)(param_1 + 0x18)) {
*(int8 *)local_70 = *(int8 *)puVar8;
*(int8 *)(local_70 + 2) = *(int8 *)(puVar8 + 2);
movelink(lVar2,(long)puVar8 - lVar2 >> 4 & 0xffffffff,
(long)puVar9 - lVar2 >> 4 & 0xffffffff,local_2c);
goto LAB_00182586;
}
local_28 = (int4)((long)puVar9 - lVar2 >> 4);
}
else {
local_28 = 0xffffffff;
}
*(int8 *)local_70 = *(int8 *)puVar8;
*(int8 *)(local_70 + 2) = *(int8 *)(puVar8 + 2);
movelink(lVar2,local_28,local_2c,*puVar9);
*puVar9 = local_2c;
}
else {
*(int8 *)local_70 = *(int8 *)puVar9;
*(int8 *)(local_70 + 2) = *(int8 *)(puVar9 + 2);
*(int8 *)puVar9 = *(int8 *)puVar8;
*(int8 *)(puVar9 + 2) = *(int8 *)(puVar8 + 2);
movelink(lVar2,(long)puVar9 - lVar2 >> 4 & 0xffffffff,
(long)puVar10 - lVar2 >> 4 & 0xffffffff,local_2c);
}
}
}
LAB_00182586:
pop_dynamic(param_1 + 0x28);
if (*(long *)(param_1 + 0x60) != 0) {
(**(code **)(param_1 + 0x60))(param_2);
}
return 0;
}
|
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.