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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
60,600
|
verify_storage
|
corpus-core[P]colibri-stateless/src/chains/eth/verifier/eth_account.c
|
static bool verify_storage(verify_ctx_t* ctx, ssz_ob_t storage_proofs, bytes32_t storage_hash, bytes_t values) {
if (values.data) memset(values.data, 0, 32);
int len = ssz_len(storage_proofs);
if (len != 0 && memcmp(storage_hash, EMPTY_ROOT_HASH, 32) == 0) RETURN_VERIFY_ERROR(ctx, "invalid storage proof because an empty storage hash can not have values!");
for (int i = 0; i < len; i++) {
bytes32_t path = {0};
bytes32_t root = {0};
ssz_ob_t storage = ssz_at(storage_proofs, i);
ssz_ob_t proof = ssz_get(&storage, "proof");
ssz_ob_t key = ssz_get(&storage, "key");
bytes_t leaf = {0};
keccak(key.bytes, path);
if (patricia_verify(root, bytes(path, 32), proof, &leaf) == PATRICIA_INVALID) RETURN_VERIFY_ERROR(ctx, "invalid storage proof!");
if (memcmp(root, storage_hash, 32) != 0) RETURN_VERIFY_ERROR(ctx, "invalid storage root!");
if (values.data && values.len >= (i + 1) * 32 && rlp_decode(&leaf, 0, &leaf) == RLP_ITEM)
memcpy(values.data + (i + 1) * 32 - leaf.len, leaf.data, leaf.len);
}
return true;
}
|
O0
|
c
|
verify_storage:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
leaq 0x10(%rbp), %rax
movq %rax, -0xe0(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x31cdc
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x23140
movq -0xe0(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x9f1e0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x31d4b
movq -0x28(%rbp), %rdi
movq 0x1056c3(%rip), %rsi # 0x1373d8
movl $0x20, %edx
callq 0x23100
cmpl $0x0, %eax
jne 0x31d4b
jmp 0x31d26
movq -0x20(%rbp), %rdi
addq $0x70, %rdi
leaq 0xa9f78(%rip), %rsi # 0xdbcad
callq 0xa6370
movq -0x20(%rbp), %rax
movb $0x0, 0x68(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x31f3a
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x31f36
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x23140
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x23140
movq -0xe0(%rbp), %rax
movl -0x30(%rbp), %esi
leaq -0x88(%rbp), %rdi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x9ef30
leaq -0xa0(%rbp), %rdi
leaq -0x88(%rbp), %rsi
leaq 0xa83f6(%rip), %rdx # 0xda1b8
callq 0xa05c0
leaq -0xb8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
leaq 0xa9787(%rip), %rdx # 0xdb563
callq 0xa05c0
leaq -0xc8(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x23140
leaq -0x50(%rbp), %rdx
movl -0xb8(%rbp), %edi
movq -0xb0(%rbp), %rsi
callq 0xa3340
leaq -0x70(%rbp), %rdi
movl $0x20, -0xd8(%rbp)
leaq -0x50(%rbp), %rax
movq %rax, -0xd0(%rbp)
movl -0xd8(%rbp), %esi
movq -0xd0(%rbp), %rdx
leaq -0xa0(%rbp), %rax
leaq -0xc8(%rbp), %rcx
movq (%rax), %r8
movq %r8, (%rsp)
movq 0x8(%rax), %r8
movq %r8, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x34300
cmpl $0x0, %eax
jne 0x31e88
jmp 0x31e63
movq -0x20(%rbp), %rdi
addq $0x70, %rdi
leaq 0xa9d1b(%rip), %rsi # 0xdbb8d
callq 0xa6370
movq -0x20(%rbp), %rax
movb $0x0, 0x68(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x31f3a
leaq -0x70(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x20, %edx
callq 0x23100
cmpl $0x0, %eax
je 0x31ec3
jmp 0x31ea1
movq -0x20(%rbp), %rdi
addq $0x70, %rdi
leaq 0xa9e46(%rip), %rsi # 0xdbcf6
callq 0xa6370
movq -0x20(%rbp), %rax
movb $0x0, 0x68(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x31f3a
cmpq $0x0, -0x10(%rbp)
je 0x31f26
movl -0x18(%rbp), %eax
movl -0x30(%rbp), %ecx
addl $0x1, %ecx
shll $0x5, %ecx
cmpl %ecx, %eax
jb 0x31f26
leaq -0xc8(%rbp), %rdx
xorl %esi, %esi
movq %rdx, %rdi
callq 0x34c30
cmpl $0x1, %eax
jne 0x31f26
movq -0x10(%rbp), %rdi
movl -0x30(%rbp), %eax
addl $0x1, %eax
shll $0x5, %eax
cltq
addq %rax, %rdi
movl -0xc8(%rbp), %eax
movl %eax, %ecx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rdi
movq -0xc0(%rbp), %rsi
movl -0xc8(%rbp), %eax
movl %eax, %edx
callq 0x231c0
jmp 0x31f28
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x31d52
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x100, %rsp # imm = 0x100
popq %rbp
retq
nopl (%rax,%rax)
|
verify_storage:
push rbp
mov rbp, rsp
sub rsp, 100h
lea rax, [rbp+arg_0]
mov [rbp+var_E0], rax
mov [rbp+var_18], edx
mov [rbp+var_10], rcx
mov [rbp+var_20], rdi
mov [rbp+var_28], rsi
cmp [rbp+var_10], 0
jz short loc_31CDC
mov rdi, [rbp+var_10]
xor esi, esi
mov edx, 20h ; ' '
call _memset
loc_31CDC:
mov rax, [rbp+var_E0]
mov rcx, [rax]
mov [rsp+100h+var_100], rcx
mov rcx, [rax+8]
mov [rsp+100h+var_F8], rcx
mov rax, [rax+10h]
mov [rsp+100h+var_F0], rax
call ssz_len
mov [rbp+var_2C], eax
cmp [rbp+var_2C], 0
jz short loc_31D4B
mov rdi, [rbp+var_28]
mov rsi, cs:EMPTY_ROOT_HASH
mov edx, 20h ; ' '
call _memcmp
cmp eax, 0
jnz short loc_31D4B
jmp short $+2
loc_31D26:
mov rdi, [rbp+var_20]
add rdi, 70h ; 'p'
lea rsi, aInvalidStorage_0; "invalid storage proof because an empty "...
call c4_state_add_error
mov rax, [rbp+var_20]
mov byte ptr [rax+68h], 0
mov [rbp+var_1], 0
jmp loc_31F3A
loc_31D4B:
mov [rbp+var_30], 0
loc_31D52:
mov eax, [rbp+var_30]
cmp eax, [rbp+var_2C]
jge loc_31F36
lea rdi, [rbp+var_50]
xor esi, esi
mov edx, 20h ; ' '
call _memset
lea rdi, [rbp+var_70]
xor esi, esi
mov edx, 20h ; ' '
call _memset
mov rax, [rbp+var_E0]
mov esi, [rbp+var_30]
lea rdi, [rbp+var_88]
mov rcx, [rax]
mov [rsp+100h+var_100], rcx
mov rcx, [rax+8]
mov [rsp+100h+var_F8], rcx
mov rax, [rax+10h]
mov [rsp+100h+var_F0], rax
call ssz_at
lea rdi, [rbp+var_A0]
lea rsi, [rbp+var_88]
lea rdx, aChainTypeDoesN+1Eh; "proof"
call ssz_get
lea rdi, [rbp+var_B8]
lea rsi, [rbp+var_88]
lea rdx, aAccessStorageK+0Fh; "key"
call ssz_get
lea rdi, [rbp+var_C8]
xor esi, esi
mov edx, 10h
call _memset
lea rdx, [rbp+var_50]
mov edi, [rbp+var_B8]
mov rsi, [rbp+var_B0]
call keccak
lea rdi, [rbp+var_70]
mov [rbp+var_D8], 20h ; ' '
lea rax, [rbp+var_50]
mov [rbp+var_D0], rax
mov esi, [rbp+var_D8]
mov rdx, [rbp+var_D0]
lea rax, [rbp+var_A0]
lea rcx, [rbp+var_C8]
mov r8, [rax]
mov [rsp+100h+var_100], r8
mov r8, [rax+8]
mov [rsp+100h+var_F8], r8
mov rax, [rax+10h]
mov [rsp+100h+var_F0], rax
call patricia_verify
cmp eax, 0
jnz short loc_31E88
jmp short $+2
loc_31E63:
mov rdi, [rbp+var_20]
add rdi, 70h ; 'p'
lea rsi, aInvalidStorage; "invalid storage proof!"
call c4_state_add_error
mov rax, [rbp+var_20]
mov byte ptr [rax+68h], 0
mov [rbp+var_1], 0
jmp loc_31F3A
loc_31E88:
lea rdi, [rbp+var_70]
mov rsi, [rbp+var_28]
mov edx, 20h ; ' '
call _memcmp
cmp eax, 0
jz short loc_31EC3
jmp short $+2
loc_31EA1:
mov rdi, [rbp+var_20]
add rdi, 70h ; 'p'
lea rsi, aInvalidStorage_1; "invalid storage root!"
call c4_state_add_error
mov rax, [rbp+var_20]
mov byte ptr [rax+68h], 0
mov [rbp+var_1], 0
jmp short loc_31F3A
loc_31EC3:
cmp [rbp+var_10], 0
jz short loc_31F26
mov eax, [rbp+var_18]
mov ecx, [rbp+var_30]
add ecx, 1
shl ecx, 5
cmp eax, ecx
jb short loc_31F26
lea rdx, [rbp+var_C8]
xor esi, esi
mov rdi, rdx
call rlp_decode
cmp eax, 1
jnz short loc_31F26
mov rdi, [rbp+var_10]
mov eax, [rbp+var_30]
add eax, 1
shl eax, 5
cdqe
add rdi, rax
mov eax, [rbp+var_C8]
mov ecx, eax
xor eax, eax
sub rax, rcx
add rdi, rax
mov rsi, [rbp+var_C0]
mov eax, [rbp+var_C8]
mov edx, eax
call _memcpy
loc_31F26:
jmp short $+2
loc_31F28:
mov eax, [rbp+var_30]
add eax, 1
mov [rbp+var_30], eax
jmp loc_31D52
loc_31F36:
mov [rbp+var_1], 1
loc_31F3A:
mov al, [rbp+var_1]
and al, 1
add rsp, 100h
pop rbp
retn
|
char verify_storage(
long long a1,
long long a2,
unsigned int a3,
long long a4,
int a5,
int a6,
long long a7,
long long a8,
long long a9)
{
int v9; // edx
int v10; // r8d
int v11; // r9d
int v12; // r9d
unsigned int v14; // [rsp+38h] [rbp-C8h] BYREF
long long v15; // [rsp+40h] [rbp-C0h]
unsigned int v16; // [rsp+48h] [rbp-B8h] BYREF
long long v17; // [rsp+50h] [rbp-B0h]
long long v18; // [rsp+60h] [rbp-A0h] BYREF
long long v19; // [rsp+68h] [rbp-98h]
long long v20; // [rsp+70h] [rbp-90h]
_BYTE v21[24]; // [rsp+78h] [rbp-88h] BYREF
_BYTE v22[32]; // [rsp+90h] [rbp-70h] BYREF
_BYTE v23[32]; // [rsp+B0h] [rbp-50h] BYREF
int i; // [rsp+D0h] [rbp-30h]
int v25; // [rsp+D4h] [rbp-2Ch]
long long v26; // [rsp+D8h] [rbp-28h]
long long v27; // [rsp+E0h] [rbp-20h]
unsigned int v28; // [rsp+E8h] [rbp-18h]
long long v29; // [rsp+F0h] [rbp-10h]
v28 = a3;
v29 = a4;
v27 = a1;
v26 = a2;
if ( a4 )
{
LODWORD(a1) = v29;
LODWORD(a2) = 0;
memset(v29, 0LL, 32LL);
}
v25 = ssz_len(a1, a2, a3, a8, a5, a6, a7, a8, a9);
if ( v25 && !(unsigned int)memcmp(v26, EMPTY_ROOT_HASH, 32LL) )
{
c4_state_add_error(v27 + 112, "invalid storage proof because an empty storage hash can not have values!");
*(_BYTE *)(v27 + 104) = 0;
return 0;
}
else
{
for ( i = 0; i < v25; ++i )
{
memset(v23, 0LL, sizeof(v23));
memset(v22, 0LL, sizeof(v22));
ssz_at((unsigned int)v21, i, v9, a8, v10, v11, a7, a8, a9);
ssz_get(&v18, v21, "proof");
ssz_get(&v16, v21, "key");
memset(&v14, 0LL, 16LL);
keccak(v16, v17, v23);
if ( !(unsigned int)patricia_verify(
(unsigned int)v22,
32,
(unsigned int)v23,
(unsigned int)&v14,
v19,
v12,
v18,
v19,
v20) )
{
c4_state_add_error(v27 + 112, "invalid storage proof!");
*(_BYTE *)(v27 + 104) = 0;
return 0;
}
if ( (unsigned int)memcmp(v22, v26, 32LL) )
{
c4_state_add_error(v27 + 112, "invalid storage root!");
*(_BYTE *)(v27 + 104) = 0;
return 0;
}
if ( v29 && v28 >= 32 * (i + 1) && (unsigned int)rlp_decode(&v14, 0LL) == 1 )
memcpy(32 * (i + 1) + v29 - v14, v15, v14);
}
return 1;
}
}
|
verify_storage:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x100
LEA RAX,[RBP + 0x10]
MOV qword ptr [RBP + -0xe0],RAX
MOV dword ptr [RBP + -0x18],EDX
MOV qword ptr [RBP + -0x10],RCX
MOV qword ptr [RBP + -0x20],RDI
MOV qword ptr [RBP + -0x28],RSI
CMP qword ptr [RBP + -0x10],0x0
JZ 0x00131cdc
MOV RDI,qword ptr [RBP + -0x10]
XOR ESI,ESI
MOV EDX,0x20
CALL 0x00123140
LAB_00131cdc:
MOV RAX,qword ptr [RBP + -0xe0]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RSP],RCX
MOV RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x8],RCX
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RSP + 0x10],RAX
CALL 0x0019f1e0
MOV dword ptr [RBP + -0x2c],EAX
CMP dword ptr [RBP + -0x2c],0x0
JZ 0x00131d4b
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [0x002373d8]
MOV EDX,0x20
CALL 0x00123100
CMP EAX,0x0
JNZ 0x00131d4b
JMP 0x00131d26
LAB_00131d26:
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x70
LEA RSI,[0x1dbcad]
CALL 0x001a6370
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x68],0x0
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00131f3a
LAB_00131d4b:
MOV dword ptr [RBP + -0x30],0x0
LAB_00131d52:
MOV EAX,dword ptr [RBP + -0x30]
CMP EAX,dword ptr [RBP + -0x2c]
JGE 0x00131f36
LEA RDI,[RBP + -0x50]
XOR ESI,ESI
MOV EDX,0x20
CALL 0x00123140
LEA RDI,[RBP + -0x70]
XOR ESI,ESI
MOV EDX,0x20
CALL 0x00123140
MOV RAX,qword ptr [RBP + -0xe0]
MOV ESI,dword ptr [RBP + -0x30]
LEA RDI,[RBP + -0x88]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RSP],RCX
MOV RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x8],RCX
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RSP + 0x10],RAX
CALL 0x0019ef30
LEA RDI,[RBP + -0xa0]
LEA RSI,[RBP + -0x88]
LEA RDX,[0x1da1b8]
CALL 0x001a05c0
LEA RDI,[RBP + -0xb8]
LEA RSI,[RBP + -0x88]
LEA RDX,[0x1db563]
CALL 0x001a05c0
LEA RDI,[RBP + -0xc8]
XOR ESI,ESI
MOV EDX,0x10
CALL 0x00123140
LEA RDX,[RBP + -0x50]
MOV EDI,dword ptr [RBP + -0xb8]
MOV RSI,qword ptr [RBP + -0xb0]
CALL 0x001a3340
LEA RDI,[RBP + -0x70]
MOV dword ptr [RBP + -0xd8],0x20
LEA RAX,[RBP + -0x50]
MOV qword ptr [RBP + -0xd0],RAX
MOV ESI,dword ptr [RBP + -0xd8]
MOV RDX,qword ptr [RBP + -0xd0]
LEA RAX,[RBP + -0xa0]
LEA RCX,[RBP + -0xc8]
MOV R8,qword ptr [RAX]
MOV qword ptr [RSP],R8
MOV R8,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x8],R8
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RSP + 0x10],RAX
CALL 0x00134300
CMP EAX,0x0
JNZ 0x00131e88
JMP 0x00131e63
LAB_00131e63:
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x70
LEA RSI,[0x1dbb8d]
CALL 0x001a6370
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x68],0x0
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00131f3a
LAB_00131e88:
LEA RDI,[RBP + -0x70]
MOV RSI,qword ptr [RBP + -0x28]
MOV EDX,0x20
CALL 0x00123100
CMP EAX,0x0
JZ 0x00131ec3
JMP 0x00131ea1
LAB_00131ea1:
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x70
LEA RSI,[0x1dbcf6]
CALL 0x001a6370
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x68],0x0
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00131f3a
LAB_00131ec3:
CMP qword ptr [RBP + -0x10],0x0
JZ 0x00131f26
MOV EAX,dword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x30]
ADD ECX,0x1
SHL ECX,0x5
CMP EAX,ECX
JC 0x00131f26
LEA RDX,[RBP + -0xc8]
XOR ESI,ESI
MOV RDI,RDX
CALL 0x00134c30
CMP EAX,0x1
JNZ 0x00131f26
MOV RDI,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x30]
ADD EAX,0x1
SHL EAX,0x5
CDQE
ADD RDI,RAX
MOV EAX,dword ptr [RBP + -0xc8]
MOV ECX,EAX
XOR EAX,EAX
SUB RAX,RCX
ADD RDI,RAX
MOV RSI,qword ptr [RBP + -0xc0]
MOV EAX,dword ptr [RBP + -0xc8]
MOV EDX,EAX
CALL 0x001231c0
LAB_00131f26:
JMP 0x00131f28
LAB_00131f28:
MOV EAX,dword ptr [RBP + -0x30]
ADD EAX,0x1
MOV dword ptr [RBP + -0x30],EAX
JMP 0x00131d52
LAB_00131f36:
MOV byte ptr [RBP + -0x1],0x1
LAB_00131f3a:
MOV AL,byte ptr [RBP + -0x1]
AND AL,0x1
ADD RSP,0x100
POP RBP
RET
|
int1
verify_storage(long param_1,void *param_2,uint param_3,void *param_4,int8 param_5,
int8 param_6)
{
int iVar1;
uint local_d0 [2];
void *local_c8;
int4 local_c0 [2];
int8 local_b8;
int8 local_a8;
int8 local_a0;
int8 local_98;
int1 local_90 [24];
int1 local_78 [32];
int1 local_58 [32];
int local_38;
int local_34;
void *local_30;
long local_28;
uint local_20;
void *local_18;
local_30 = param_2;
local_28 = param_1;
local_20 = param_3;
local_18 = param_4;
if (param_4 != (void *)0x0) {
memset(param_4,0,0x20);
}
local_34 = ssz_len();
if ((local_34 != 0) && (iVar1 = memcmp(local_30,EMPTY_ROOT_HASH,0x20), iVar1 == 0)) {
c4_state_add_error(local_28 + 0x70,
"invalid storage proof because an empty storage hash can not have values!");
*(int1 *)(local_28 + 0x68) = 0;
return 0;
}
local_38 = 0;
while( true ) {
if (local_34 <= local_38) {
return 1;
}
memset(local_58,0,0x20);
memset(local_78,0,0x20);
ssz_at(local_90,local_38);
ssz_get(&local_a8,local_90,"proof");
ssz_get(local_c0,local_90,"key");
memset(local_d0,0,0x10);
keccak(local_c0[0],local_b8,local_58);
iVar1 = patricia_verify(local_78,0x20,local_58,local_d0,local_a0,param_6,local_a8,local_a0,
local_98);
if (iVar1 == 0) break;
iVar1 = memcmp(local_78,local_30,0x20);
if (iVar1 != 0) {
c4_state_add_error(local_28 + 0x70,"invalid storage root!");
*(int1 *)(local_28 + 0x68) = 0;
return 0;
}
if (((local_18 != (void *)0x0) && ((uint)((local_38 + 1) * 0x20) <= local_20)) &&
(iVar1 = rlp_decode(local_d0), iVar1 == 1)) {
memcpy((void *)((long)local_18 + ((long)((local_38 + 1) * 0x20) - (ulong)local_d0[0])),
local_c8,(ulong)local_d0[0]);
}
local_38 = local_38 + 1;
}
c4_state_add_error(local_28 + 0x70,"invalid storage proof!");
*(int1 *)(local_28 + 0x68) = 0;
return 0;
}
|
|
60,601
|
void testing::internal::PrintWithFallback<unsigned long>(unsigned long const&, std::ostream*)
|
AlayaLite/build_O0/_deps/googletest-src/googletest/include/gtest/gtest-printers.h
|
void PrintWithFallback(const T& value, ::std::ostream* os) {
using Printer = typename FindFirstPrinter<
T, void, ContainerPrinter, FunctionPointerPrinter, PointerPrinter,
ProtobufPrinter,
#ifdef GTEST_HAS_ABSL
ConvertibleToAbslStringifyPrinter,
#endif // GTEST_HAS_ABSL
internal_stream_operator_without_lexical_name_lookup::StreamPrinter,
ConvertibleToIntegerPrinter, ConvertibleToStringViewPrinter,
RawBytesPrinter, FallbackPrinter>::type;
Printer::PrintValue(value, os);
}
|
O0
|
c
|
void testing::internal::PrintWithFallback<unsigned long>(unsigned long const&, std::ostream*):
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x66a10
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
|
_ZN7testing8internal17PrintWithFallbackIiEEvRKT_PSo:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov [rsp+18h+var_10], rsi
mov rdi, [rsp+18h+var_8]
mov rsi, [rsp+18h+var_10]
call _ZN7testing8internal52internal_stream_operator_without_lexical_name_lookup13StreamPrinter10PrintValueIivEEDTcvvlsdefp0_fp_ERKT_PSo
add rsp, 18h
retn
|
long long testing::internal::PrintWithFallback<int>(long long a1, long long a2)
{
return testing::internal::internal_stream_operator_without_lexical_name_lookup::StreamPrinter::PrintValue<int,void>(
a1,
a2);
}
|
PrintWithFallback<int>:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV qword ptr [RSP + 0x8],RSI
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP + 0x8]
CALL 0x00166a10
ADD RSP,0x18
RET
|
/* void testing::internal::PrintWithFallback<int>(int const&, std::ostream*) */
void testing::internal::PrintWithFallback<int>(int *param_1,ostream *param_2)
{
((void)((*{parm#2})<<{parm#1}))testing::internal::
internal_stream_operator_without_lexical_name_lookup::StreamPrinter::PrintValue<int,void>
(param_1,param_2);
return;
}
|
|
60,602
|
ma_hashtbl_init
|
eloqsql/libmariadb/libmariadb/ma_hashtbl.c
|
my_bool _ma_hashtbl_init(MA_HASHTBL *hash,uint size,uint key_offset,uint key_length,
hash_get_key get_key,
void (*free_element)(void*),uint flags CALLER_INFO_PROTO)
{
hash->records=0;
if (ma_init_dynamic_array_ci(&hash->array,sizeof(MA_HASHTBL_LINK),size,0))
{
hash->free=0; /* Allow call to hash_free */
return(TRUE);
}
hash->key_offset=key_offset;
hash->key_length=key_length;
hash->blength=1;
hash->current_record= NO_RECORD; /* For the future */
hash->get_key=get_key;
hash->free=free_element;
hash->flags=flags;
if (flags & MA_HASHTBL_CASE_INSENSITIVE)
hash->calc_hashnr=calc_hashnr_caseup;
else
hash->calc_hashnr=calc_hashnr;
return(0);
}
|
O3
|
c
|
ma_hashtbl_init:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %r15
movl %ecx, %r12d
movl %edx, %r13d
movl %esi, %edx
movq %rdi, %rbx
movl $0x0, 0x8(%rdi)
addq $0x18, %rdi
movl $0x10, %esi
xorl %ecx, %ecx
callq 0x2f81c
testb %al, %al
je 0x30512
movq $0x0, 0x38(%rbx)
movb $0x1, %al
jmp 0x3054f
movl 0x10(%rbp), %eax
movl %r13d, (%rbx)
movl %r12d, 0x4(%rbx)
movabsq $-0xffffffff, %rcx # imm = 0xFFFFFFFF00000001
movq %rcx, 0xc(%rbx)
movq %r15, 0x30(%rbx)
movq %r14, 0x38(%rbx)
movl %eax, 0x14(%rbx)
testb $0x1, %al
jne 0x30542
leaq 0x80(%rip), %rax # 0x305c0
jmp 0x30549
leaq 0x15(%rip), %rax # 0x3055e
movq %rax, 0x40(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_ma_hashtbl_init:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, r9
mov r15, r8
mov r12d, ecx
mov r13d, edx
mov edx, esi
mov rbx, rdi
mov dword ptr [rdi+8], 0
add rdi, 18h
mov esi, 10h
xor ecx, ecx
call ma_init_dynamic_array
test al, al
jz short loc_30512
mov qword ptr [rbx+38h], 0
mov al, 1
jmp short loc_3054F
loc_30512:
mov eax, [rbp+arg_0]
mov [rbx], r13d
mov [rbx+4], r12d
mov rcx, 0FFFFFFFF00000001h
mov [rbx+0Ch], rcx
mov [rbx+30h], r15
mov [rbx+38h], r14
mov [rbx+14h], eax
test al, 1
jnz short loc_30542
lea rax, calc_hashnr
jmp short loc_30549
loc_30542:
lea rax, calc_hashnr_caseup
loc_30549:
mov [rbx+40h], rax
xor eax, eax
loc_3054F:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
char ma_hashtbl_init(long long a1, unsigned int a2, int a3, int a4, long long a5, long long a6, int a7)
{
long long ( *v12)(); // rax
*(_DWORD *)(a1 + 8) = 0;
if ( (unsigned __int8)ma_init_dynamic_array(a1 + 24, 0x10u, a2, 0) )
{
*(_QWORD *)(a1 + 56) = 0LL;
return 1;
}
else
{
*(_DWORD *)a1 = a3;
*(_DWORD *)(a1 + 4) = a4;
*(_QWORD *)(a1 + 12) = 0xFFFFFFFF00000001LL;
*(_QWORD *)(a1 + 48) = a5;
*(_QWORD *)(a1 + 56) = a6;
*(_DWORD *)(a1 + 20) = a7;
if ( (a7 & 1) != 0 )
v12 = calc_hashnr_caseup;
else
v12 = calc_hashnr;
*(_QWORD *)(a1 + 64) = v12;
return 0;
}
}
|
_ma_hashtbl_init:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,R9
MOV R15,R8
MOV R12D,ECX
MOV R13D,EDX
MOV EDX,ESI
MOV RBX,RDI
MOV dword ptr [RDI + 0x8],0x0
ADD RDI,0x18
MOV ESI,0x10
XOR ECX,ECX
CALL 0x0012f81c
TEST AL,AL
JZ 0x00130512
MOV qword ptr [RBX + 0x38],0x0
MOV AL,0x1
JMP 0x0013054f
LAB_00130512:
MOV EAX,dword ptr [RBP + 0x10]
MOV dword ptr [RBX],R13D
MOV dword ptr [RBX + 0x4],R12D
MOV RCX,-0xffffffff
MOV qword ptr [RBX + 0xc],RCX
MOV qword ptr [RBX + 0x30],R15
MOV qword ptr [RBX + 0x38],R14
MOV dword ptr [RBX + 0x14],EAX
TEST AL,0x1
JNZ 0x00130542
LEA RAX,[0x1305c0]
JMP 0x00130549
LAB_00130542:
LEA RAX,[0x13055e]
LAB_00130549:
MOV qword ptr [RBX + 0x40],RAX
XOR EAX,EAX
LAB_0013054f:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8
_ma_hashtbl_init(int4 *param_1,int4 param_2,int4 param_3,int4 param_4,
int8 param_5,int8 param_6,uint param_7)
{
char cVar1;
int8 uVar2;
code *pcVar3;
param_1[2] = 0;
cVar1 = ma_init_dynamic_array(param_1 + 6,0x10,param_2,0);
if (cVar1 == '\0') {
*param_1 = param_3;
param_1[1] = param_4;
*(int8 *)(param_1 + 3) = 0xffffffff00000001;
*(int8 *)(param_1 + 0xc) = param_5;
*(int8 *)(param_1 + 0xe) = param_6;
param_1[5] = param_7;
if ((param_7 & 1) == 0) {
pcVar3 = calc_hashnr;
}
else {
pcVar3 = calc_hashnr_caseup;
}
*(code **)(param_1 + 0x10) = pcVar3;
uVar2 = 0;
}
else {
*(int8 *)(param_1 + 0xe) = 0;
uVar2 = 1;
}
return uVar2;
}
|
|
60,603
|
nlohmann::json_abi_v3_11_3::detail::iteration_proxy<nlohmann::json_abi_v3_11_3::detail::iter_impl<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>>>::begin() const
|
monkey531[P]llama/common/./json.hpp
|
iteration_proxy_value<IteratorType> begin() const noexcept
{
return iteration_proxy_value<IteratorType>(container->begin());
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::iteration_proxy<nlohmann::json_abi_v3_11_3::detail::iter_impl<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>>>::begin() const:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, (%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rsp)
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
movq %rcx, 0x18(%rsp)
movzbl (%rax), %ecx
testl %ecx, %ecx
je 0x949f1
cmpl $0x2, %ecx
je 0x949e3
cmpl $0x1, %ecx
jne 0x949fc
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x94a05
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x94a05
movq $0x1, 0x18(%rsp)
jmp 0x94a05
movq $0x0, 0x18(%rsp)
movq %rsp, %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x70d92
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
retq
nop
|
_ZNK8nlohmann16json_abi_v3_11_36detail15iteration_proxyINS1_9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEEEEE5beginEv:
push rbx
sub rsp, 20h
mov rbx, rdi
mov rax, [rsi]
mov [rsp+28h+var_28], rax
xorps xmm0, xmm0
movups [rsp+28h+var_20], xmm0
mov rcx, 8000000000000000h
mov [rsp+28h+var_10], rcx
movzx ecx, byte ptr [rax]
test ecx, ecx
jz short loc_949F1
cmp ecx, 2
jz short loc_949E3
cmp ecx, 1
jnz short loc_949FC
mov rax, [rax+8]
mov rax, [rax]
mov qword ptr [rsp+28h+var_20], rax
jmp short loc_94A05
loc_949E3:
mov rax, [rax+8]
mov rax, [rax]
mov qword ptr [rsp+28h+var_20+8], rax
jmp short loc_94A05
loc_949F1:
mov [rsp+28h+var_10], 1
jmp short loc_94A05
loc_949FC:
mov [rsp+28h+var_10], 0
loc_94A05:
mov rsi, rsp
mov rdi, rbx
xor edx, edx
call _ZN8nlohmann16json_abi_v3_11_36detail21iteration_proxy_valueINS1_9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEEEEEC2ESH_m; nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<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>>>::iteration_proxy_value(nlohmann::json_abi_v3_11_3::detail::iter_impl<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>>,ulong)
mov rax, rbx
add rsp, 20h
pop rbx
retn
|
long long nlohmann::json_abi_v3_11_3::detail::iteration_proxy<nlohmann::json_abi_v3_11_3::detail::iter_impl<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>>>::begin(
long long a1,
unsigned __int8 **a2)
{
unsigned __int8 *v2; // rax
int v3; // ecx
unsigned __int8 *v5; // [rsp+0h] [rbp-28h] BYREF
__int128 v6; // [rsp+8h] [rbp-20h]
long long v7; // [rsp+18h] [rbp-10h]
v2 = *a2;
v5 = v2;
v6 = 0LL;
v7 = 0x8000000000000000LL;
v3 = *v2;
if ( *v2 )
{
if ( v3 == 2 )
{
*((_QWORD *)&v6 + 1) = **((_QWORD **)v2 + 1);
}
else if ( v3 == 1 )
{
*(_QWORD *)&v6 = **((_QWORD **)v2 + 1);
}
else
{
v7 = 0LL;
}
}
else
{
v7 = 1LL;
}
nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<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>>>::iteration_proxy_value(
a1,
(__int128 *)&v5,
0LL);
return a1;
}
|
begin:
PUSH RBX
SUB RSP,0x20
MOV RBX,RDI
MOV RAX,qword ptr [RSI]
MOV qword ptr [RSP],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSP + 0x8],XMM0
MOV RCX,-0x8000000000000000
MOV qword ptr [RSP + 0x18],RCX
MOVZX ECX,byte ptr [RAX]
TEST ECX,ECX
JZ 0x001949f1
CMP ECX,0x2
JZ 0x001949e3
CMP ECX,0x1
JNZ 0x001949fc
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP + 0x8],RAX
JMP 0x00194a05
LAB_001949e3:
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP + 0x10],RAX
JMP 0x00194a05
LAB_001949f1:
MOV qword ptr [RSP + 0x18],0x1
JMP 0x00194a05
LAB_001949fc:
MOV qword ptr [RSP + 0x18],0x0
LAB_00194a05:
MOV RSI,RSP
MOV RDI,RBX
XOR EDX,EDX
CALL 0x00170d92
MOV RAX,RBX
ADD RSP,0x20
POP RBX
RET
|
/* nlohmann::json_abi_v3_11_3::detail::iteration_proxy<nlohmann::json_abi_v3_11_3::detail::iter_impl<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> > >::begin() const */
void nlohmann::json_abi_v3_11_3::detail::
iteration_proxy<nlohmann::json_abi_v3_11_3::detail::iter_impl<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>>>
::begin(void)
{
iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<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>>>
::iteration_proxy_value();
return;
}
|
|
60,604
|
bitmap_intersect
|
eloqsql/mysys/my_bitmap.c
|
void bitmap_intersect(MY_BITMAP *map, const MY_BITMAP *map2)
{
my_bitmap_map *to= map->bitmap, *from= map2->bitmap, *end;
uint len= no_words_in_map(map), len2 = no_words_in_map(map2);
DBUG_ASSERT(map->bitmap);
DBUG_ASSERT(map2->bitmap);
end= to+MY_MIN(len,len2);
while (to < end)
*to++ &= *from++;
if (len2 <= len)
{
to[-1]&= ~map2->last_word_mask; /* Clear last not relevant bits */
end+= len-len2;
while (to < end)
*to++= 0;
}
}
|
O3
|
c
|
bitmap_intersect:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movq (%rdi), %rax
movl 0x1c(%rdi), %ecx
addl $0x1f, %ecx
shrl $0x5, %ecx
movl 0x1c(%rsi), %r9d
addl $0x1f, %r9d
shrl $0x5, %r9d
cmpl %r9d, %ecx
movl %r9d, %r8d
cmovbl %ecx, %r8d
leaq (%rax,%r8,4), %r10
testl %r8d, %r8d
je 0x9d59f
movq (%rsi), %r11
movq %rax, %rdx
movq %rax, %rdi
movl (%r11), %ebx
andl %ebx, (%rdi)
addq $0x4, %r11
addq $0x4, %rdi
addq $0x4, %rdx
cmpq %r10, %rdi
jb 0x9d587
jmp 0x9d5a5
movq %rax, %rdx
movq %rax, %rdi
subl %r9d, %ecx
jb 0x9d5e4
movl 0x18(%rsi), %esi
notl %esi
andl %esi, -0x4(%rdi)
leaq (%r10,%rcx,4), %rsi
cmpq %rsi, %rdi
jae 0x9d5e4
addq %r8, %rcx
leaq (%rax,%rcx,4), %rax
leaq 0x4(%rdx), %rcx
cmpq %rcx, %rax
cmovaq %rax, %rcx
notq %rdx
addq %rcx, %rdx
andq $-0x4, %rdx
addq $0x4, %rdx
xorl %esi, %esi
popq %rbx
popq %rbp
jmp 0x292a0
popq %rbx
popq %rbp
retq
|
bitmap_intersect:
push rbp
mov rbp, rsp
push rbx
mov rax, [rdi]
mov ecx, [rdi+1Ch]
add ecx, 1Fh
shr ecx, 5
mov r9d, [rsi+1Ch]
add r9d, 1Fh
shr r9d, 5
cmp ecx, r9d
mov r8d, r9d
cmovb r8d, ecx
lea r10, [rax+r8*4]
test r8d, r8d
jz short loc_9D59F
mov r11, [rsi]
mov rdx, rax
mov rdi, rax
loc_9D587:
mov ebx, [r11]
and [rdi], ebx
add r11, 4
add rdi, 4
add rdx, 4
cmp rdi, r10
jb short loc_9D587
jmp short loc_9D5A5
loc_9D59F:
mov rdx, rax
mov rdi, rax
loc_9D5A5:
sub ecx, r9d
jb short loc_9D5E4
mov esi, [rsi+18h]
not esi
and [rdi-4], esi
lea rsi, [r10+rcx*4]
cmp rdi, rsi
jnb short loc_9D5E4
add rcx, r8
lea rax, [rax+rcx*4]
lea rcx, [rdx+4]
cmp rax, rcx
cmova rcx, rax
not rdx
add rdx, rcx
and rdx, 0FFFFFFFFFFFFFFFCh
add rdx, 4
xor esi, esi
pop rbx
pop rbp
jmp _memset
loc_9D5E4:
pop rbx
pop rbp
retn
|
long long bitmap_intersect(long long a1, long long a2)
{
long long result; // rax
unsigned int v3; // ecx
unsigned int v4; // r9d
long long v5; // r8
unsigned long long v6; // r10
_DWORD *v7; // r11
long long v8; // rdx
_DWORD *v9; // rdi
bool v10; // cf
unsigned int v11; // ecx
unsigned long long v12; // rax
unsigned long long v13; // rcx
result = *(_QWORD *)a1;
v3 = (unsigned int)(*(_DWORD *)(a1 + 28) + 31) >> 5;
v4 = (unsigned int)(*(_DWORD *)(a2 + 28) + 31) >> 5;
v5 = v4;
if ( v3 < v4 )
v5 = v3;
v6 = result + 4 * v5;
if ( (_DWORD)v5 )
{
v7 = *(_DWORD **)a2;
v8 = *(_QWORD *)a1;
v9 = *(_DWORD **)a1;
do
{
*v9++ &= *v7++;
v8 += 4LL;
}
while ( (unsigned long long)v9 < v6 );
}
else
{
v8 = *(_QWORD *)a1;
v9 = *(_DWORD **)a1;
}
v10 = v3 < v4;
v11 = v3 - v4;
if ( !v10 )
{
*(v9 - 1) &= ~*(_DWORD *)(a2 + 24);
if ( (unsigned long long)v9 < v6 + 4LL * v11 )
{
v12 = result + 4 * (v5 + v11);
v13 = v8 + 4;
if ( v12 > v8 + 4 )
v13 = v12;
return memset(v9, 0LL, ((v13 + ~v8) & 0xFFFFFFFFFFFFFFFCLL) + 4);
}
}
return result;
}
|
bitmap_intersect:
PUSH RBP
MOV RBP,RSP
PUSH RBX
MOV RAX,qword ptr [RDI]
MOV ECX,dword ptr [RDI + 0x1c]
ADD ECX,0x1f
SHR ECX,0x5
MOV R9D,dword ptr [RSI + 0x1c]
ADD R9D,0x1f
SHR R9D,0x5
CMP ECX,R9D
MOV R8D,R9D
CMOVC R8D,ECX
LEA R10,[RAX + R8*0x4]
TEST R8D,R8D
JZ 0x0019d59f
MOV R11,qword ptr [RSI]
MOV RDX,RAX
MOV RDI,RAX
LAB_0019d587:
MOV EBX,dword ptr [R11]
AND dword ptr [RDI],EBX
ADD R11,0x4
ADD RDI,0x4
ADD RDX,0x4
CMP RDI,R10
JC 0x0019d587
JMP 0x0019d5a5
LAB_0019d59f:
MOV RDX,RAX
MOV RDI,RAX
LAB_0019d5a5:
SUB ECX,R9D
JC 0x0019d5e4
MOV ESI,dword ptr [RSI + 0x18]
NOT ESI
AND dword ptr [RDI + -0x4],ESI
LEA RSI,[R10 + RCX*0x4]
CMP RDI,RSI
JNC 0x0019d5e4
ADD RCX,R8
LEA RAX,[RAX + RCX*0x4]
LEA RCX,[RDX + 0x4]
CMP RAX,RCX
CMOVA RCX,RAX
NOT RDX
ADD RDX,RCX
AND RDX,-0x4
ADD RDX,0x4
XOR ESI,ESI
POP RBX
POP RBP
JMP 0x001292a0
LAB_0019d5e4:
POP RBX
POP RBP
RET
|
void bitmap_intersect(int8 *param_1,int8 *param_2)
{
uint *puVar1;
uint uVar2;
uint uVar3;
uint *puVar4;
uint *puVar5;
uint *__s;
uint uVar6;
puVar1 = (uint *)*param_1;
uVar3 = *(int *)((long)param_1 + 0x1c) + 0x1fU >> 5;
uVar6 = *(int *)((long)param_2 + 0x1c) + 0x1fU >> 5;
uVar2 = uVar6;
if (uVar3 < uVar6) {
uVar2 = uVar3;
}
puVar5 = puVar1;
__s = puVar1;
if (uVar2 != 0) {
puVar4 = (uint *)*param_2;
do {
*__s = *__s & *puVar4;
puVar4 = puVar4 + 1;
__s = __s + 1;
puVar5 = puVar5 + 1;
} while (__s < puVar1 + uVar2);
}
if ((uVar6 <= uVar3) &&
(__s[-1] = __s[-1] & ~*(uint *)(param_2 + 3), __s < puVar1 + uVar2 + (uVar3 - uVar6))) {
puVar4 = puVar5 + 1;
if (puVar5 + 1 < puVar1 + (ulong)(uVar3 - uVar6) + (ulong)uVar2) {
puVar4 = puVar1 + (ulong)(uVar3 - uVar6) + (ulong)uVar2;
}
memset(__s,0,(~(ulong)puVar5 + (long)puVar4 & 0xfffffffffffffffc) + 4);
return;
}
return;
}
|
|
60,605
|
my_multi_malloc_large
|
eloqsql/mysys/mulalloc.c
|
void *my_multi_malloc_large(PSI_memory_key key, myf myFlags, ...)
{
va_list args;
char **ptr,*start,*res;
ulonglong tot_length,length;
DBUG_ENTER("my_multi_malloc");
va_start(args,myFlags);
tot_length=0;
while ((ptr=va_arg(args, char **)))
{
length=va_arg(args,ulonglong);
tot_length+=ALIGN_SIZE(length);
}
va_end(args);
if (!(start=(char *) my_malloc(key, (size_t) tot_length, myFlags)))
DBUG_RETURN(0); /* purecov: inspected */
va_start(args,myFlags);
res=start;
while ((ptr=va_arg(args, char **)))
{
*ptr=res;
length=va_arg(args,ulonglong);
res+=ALIGN_SIZE(length);
}
va_end(args);
DBUG_RETURN((void*) start);
}
|
O3
|
c
|
my_multi_malloc_large:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdx, %r10
movq %rsi, %rdx
leaq -0xe0(%rbp), %rbx
movq %r10, 0x10(%rbx)
movq %rcx, 0x18(%rbx)
movq %r8, 0x20(%rbx)
movq %r9, 0x28(%rbx)
testb %al, %al
je 0xbdd95
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %rbx, -0x20(%rbp)
leaq 0x10(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movabsq $0x3000000010, %r14 # imm = 0x3000000010
movq %r14, -0x30(%rbp)
movl $0x10, %eax
xorl %esi, %esi
cmpl $0x28, %eax
ja 0xbddcb
movq %rcx, %r8
movl %eax, %ecx
addq %rbx, %rcx
addl $0x8, %eax
movl %eax, -0x30(%rbp)
jmp 0xbddd3
leaq 0x8(%rcx), %r8
movq %r8, -0x28(%rbp)
cmpq $0x0, (%rcx)
je 0xbde07
cmpl $0x28, %eax
ja 0xbddef
movq %r8, %rcx
movl %eax, %r8d
addq %rbx, %r8
addl $0x8, %eax
movl %eax, -0x30(%rbp)
jmp 0xbddf7
leaq 0x8(%r8), %rcx
movq %rcx, -0x28(%rbp)
movq (%r8), %r8
addq $0x7, %r8
andq $-0x8, %r8
addq %r8, %rsi
jmp 0xbddb6
callq 0xc3acd
testq %rax, %rax
je 0xbde87
movq %rbx, -0x20(%rbp)
leaq 0x10(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq %r14, -0x30(%rbp)
movl $0x10, %edx
movq %rax, %rcx
cmpl $0x28, %edx
ja 0xbde3c
movl %edx, %esi
addq -0x20(%rbp), %rsi
addl $0x8, %edx
movl %edx, -0x30(%rbp)
jmp 0xbde48
movq -0x28(%rbp), %rsi
leaq 0x8(%rsi), %rdx
movq %rdx, -0x28(%rbp)
movq (%rsi), %rdx
testq %rdx, %rdx
je 0xbde87
movq %rcx, (%rdx)
movl -0x30(%rbp), %edx
cmpq $0x28, %rdx
ja 0xbde6b
movq %rdx, %rsi
addq -0x20(%rbp), %rsi
addl $0x8, %edx
movl %edx, -0x30(%rbp)
jmp 0xbde77
movq -0x28(%rbp), %rsi
leaq 0x8(%rsi), %rdi
movq %rdi, -0x28(%rbp)
movq (%rsi), %rsi
addq $0x7, %rsi
andq $-0x8, %rsi
addq %rsi, %rcx
jmp 0xbde29
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
|
my_multi_malloc_large:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 0D0h
mov r10, rdx
mov rdx, rsi
lea rbx, [rbp+var_E0]
mov [rbx+10h], r10
mov [rbx+18h], rcx
mov [rbx+20h], r8
mov [rbx+28h], r9
test al, al
jz short loc_BDD95
movaps [rbp+var_B0], xmm0
movaps [rbp+var_A0], xmm1
movaps [rbp+var_90], xmm2
movaps [rbp+var_80], xmm3
movaps [rbp+var_70], xmm4
movaps [rbp+var_60], xmm5
movaps [rbp+var_50], xmm6
movaps [rbp+var_40], xmm7
loc_BDD95:
mov [rbp+var_20], rbx
lea rcx, [rbp+arg_0]
mov [rbp+var_28], rcx
mov r14, 3000000010h
mov [rbp+var_30], r14
mov eax, 10h
xor esi, esi
loc_BDDB6:
cmp eax, 28h ; '('
ja short loc_BDDCB
mov r8, rcx
mov ecx, eax
add rcx, rbx
add eax, 8
mov dword ptr [rbp+var_30], eax
jmp short loc_BDDD3
loc_BDDCB:
lea r8, [rcx+8]
mov [rbp+var_28], r8
loc_BDDD3:
cmp qword ptr [rcx], 0
jz short loc_BDE07
cmp eax, 28h ; '('
ja short loc_BDDEF
mov rcx, r8
mov r8d, eax
add r8, rbx
add eax, 8
mov dword ptr [rbp+var_30], eax
jmp short loc_BDDF7
loc_BDDEF:
lea rcx, [r8+8]
mov [rbp+var_28], rcx
loc_BDDF7:
mov r8, [r8]
add r8, 7
and r8, 0FFFFFFFFFFFFFFF8h
add rsi, r8
jmp short loc_BDDB6
loc_BDE07:
call my_malloc
test rax, rax
jz short loc_BDE87
mov [rbp+var_20], rbx
lea rcx, [rbp+arg_0]
mov [rbp+var_28], rcx
mov [rbp+var_30], r14
mov edx, 10h
mov rcx, rax
loc_BDE29:
cmp edx, 28h ; '('
ja short loc_BDE3C
mov esi, edx
add rsi, [rbp+var_20]
add edx, 8
mov dword ptr [rbp+var_30], edx
jmp short loc_BDE48
loc_BDE3C:
mov rsi, [rbp+var_28]
lea rdx, [rsi+8]
mov [rbp+var_28], rdx
loc_BDE48:
mov rdx, [rsi]
test rdx, rdx
jz short loc_BDE87
mov [rdx], rcx
mov edx, dword ptr [rbp+var_30]
cmp rdx, 28h ; '('
ja short loc_BDE6B
mov rsi, rdx
add rsi, [rbp+var_20]
add edx, 8
mov dword ptr [rbp+var_30], edx
jmp short loc_BDE77
loc_BDE6B:
mov rsi, [rbp+var_28]
lea rdi, [rsi+8]
mov [rbp+var_28], rdi
loc_BDE77:
mov rsi, [rsi]
add rsi, 7
and rsi, 0FFFFFFFFFFFFFFF8h
add rcx, rsi
jmp short loc_BDE29
loc_BDE87:
add rsp, 0D0h
pop rbx
pop r14
pop rbp
retn
|
long long my_multi_malloc_large(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
char *v17; // rcx
unsigned int v18; // eax
long long i; // rsi
char *v20; // r8
long long result; // rax
unsigned int v22; // edx
long long j; // rcx
char *v24; // rsi
char *v25; // rsi
_BYTE v26[16]; // [rsp+0h] [rbp-E0h] BYREF
long long v27; // [rsp+10h] [rbp-D0h]
long long v28; // [rsp+18h] [rbp-C8h]
long long v29; // [rsp+20h] [rbp-C0h]
long long v30; // [rsp+28h] [rbp-B8h]
__m128 v31; // [rsp+30h] [rbp-B0h]
__m128 v32; // [rsp+40h] [rbp-A0h]
__m128 v33; // [rsp+50h] [rbp-90h]
__m128 v34; // [rsp+60h] [rbp-80h]
__m128 v35; // [rsp+70h] [rbp-70h]
__m128 v36; // [rsp+80h] [rbp-60h]
__m128 v37; // [rsp+90h] [rbp-50h]
__m128 v38; // [rsp+A0h] [rbp-40h]
long long v39; // [rsp+B0h] [rbp-30h]
char *v40; // [rsp+B8h] [rbp-28h]
_BYTE *v41; // [rsp+C0h] [rbp-20h]
v31 = a7;
v32 = a8;
v33 = a9;
v34 = a10;
v35 = a11;
v36 = a12;
v37 = a13;
v38 = a14;
v27 = a3;
v28 = a4;
v29 = a5;
v30 = a6;
v41 = v26;
v17 = &a15;
v40 = &a15;
v39 = 0x3000000010LL;
v18 = 16;
for ( i = 0LL; ; i += (*(_QWORD *)v20 + 7LL) & 0xFFFFFFFFFFFFFFF8LL )
{
if ( v18 > 0x28 )
{
v20 = v17 + 8;
v40 = v17 + 8;
}
else
{
v20 = v17;
v17 = &v26[v18];
v18 += 8;
LODWORD(v39) = v18;
}
if ( !*(_QWORD *)v17 )
break;
if ( v18 > 0x28 )
{
v17 = v20 + 8;
v40 = v20 + 8;
}
else
{
v17 = v20;
v20 = &v26[v18];
v18 += 8;
LODWORD(v39) = v18;
}
}
result = my_malloc(a1, i, a2);
if ( result )
{
v41 = v26;
v40 = &a15;
v39 = 0x3000000010LL;
v22 = 16;
for ( j = result; ; j += (*(_QWORD *)v25 + 7LL) & 0xFFFFFFFFFFFFFFF8LL )
{
if ( v22 > 0x28 )
{
v24 = v40;
v40 += 8;
}
else
{
v24 = &v41[v22];
LODWORD(v39) = v22 + 8;
}
if ( !*(_QWORD *)v24 )
break;
**(_QWORD **)v24 = j;
v22 = v39;
if ( (unsigned int)v39 > 0x28uLL )
{
v25 = v40;
v40 += 8;
}
else
{
v25 = &v41[(unsigned int)v39];
v22 = v39 + 8;
LODWORD(v39) = v39 + 8;
}
}
}
return result;
}
|
my_multi_malloc_large:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0xd0
MOV R10,RDX
MOV RDX,RSI
LEA RBX,[RBP + -0xe0]
MOV qword ptr [RBX + 0x10],R10
MOV qword ptr [RBX + 0x18],RCX
MOV qword ptr [RBX + 0x20],R8
MOV qword ptr [RBX + 0x28],R9
TEST AL,AL
JZ 0x001bdd95
MOVAPS xmmword ptr [RBP + -0xb0],XMM0
MOVAPS xmmword ptr [RBP + -0xa0],XMM1
MOVAPS xmmword ptr [RBP + -0x90],XMM2
MOVAPS xmmword ptr [RBP + -0x80],XMM3
MOVAPS xmmword ptr [RBP + -0x70],XMM4
MOVAPS xmmword ptr [RBP + -0x60],XMM5
MOVAPS xmmword ptr [RBP + -0x50],XMM6
MOVAPS xmmword ptr [RBP + -0x40],XMM7
LAB_001bdd95:
MOV qword ptr [RBP + -0x20],RBX
LEA RCX,[RBP + 0x10]
MOV qword ptr [RBP + -0x28],RCX
MOV R14,0x3000000010
MOV qword ptr [RBP + -0x30],R14
MOV EAX,0x10
XOR ESI,ESI
LAB_001bddb6:
CMP EAX,0x28
JA 0x001bddcb
MOV R8,RCX
MOV ECX,EAX
ADD RCX,RBX
ADD EAX,0x8
MOV dword ptr [RBP + -0x30],EAX
JMP 0x001bddd3
LAB_001bddcb:
LEA R8,[RCX + 0x8]
MOV qword ptr [RBP + -0x28],R8
LAB_001bddd3:
CMP qword ptr [RCX],0x0
JZ 0x001bde07
CMP EAX,0x28
JA 0x001bddef
MOV RCX,R8
MOV R8D,EAX
ADD R8,RBX
ADD EAX,0x8
MOV dword ptr [RBP + -0x30],EAX
JMP 0x001bddf7
LAB_001bddef:
LEA RCX,[R8 + 0x8]
MOV qword ptr [RBP + -0x28],RCX
LAB_001bddf7:
MOV R8,qword ptr [R8]
ADD R8,0x7
AND R8,-0x8
ADD RSI,R8
JMP 0x001bddb6
LAB_001bde07:
CALL 0x001c3acd
TEST RAX,RAX
JZ 0x001bde87
MOV qword ptr [RBP + -0x20],RBX
LEA RCX,[RBP + 0x10]
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R14
MOV EDX,0x10
MOV RCX,RAX
LAB_001bde29:
CMP EDX,0x28
JA 0x001bde3c
MOV ESI,EDX
ADD RSI,qword ptr [RBP + -0x20]
ADD EDX,0x8
MOV dword ptr [RBP + -0x30],EDX
JMP 0x001bde48
LAB_001bde3c:
MOV RSI,qword ptr [RBP + -0x28]
LEA RDX,[RSI + 0x8]
MOV qword ptr [RBP + -0x28],RDX
LAB_001bde48:
MOV RDX,qword ptr [RSI]
TEST RDX,RDX
JZ 0x001bde87
MOV qword ptr [RDX],RCX
MOV EDX,dword ptr [RBP + -0x30]
CMP RDX,0x28
JA 0x001bde6b
MOV RSI,RDX
ADD RSI,qword ptr [RBP + -0x20]
ADD EDX,0x8
MOV dword ptr [RBP + -0x30],EDX
JMP 0x001bde77
LAB_001bde6b:
MOV RSI,qword ptr [RBP + -0x28]
LEA RDI,[RSI + 0x8]
MOV qword ptr [RBP + -0x28],RDI
LAB_001bde77:
MOV RSI,qword ptr [RSI]
ADD RSI,0x7
AND RSI,-0x8
ADD RCX,RSI
JMP 0x001bde29
LAB_001bde87:
ADD RSP,0xd0
POP RBX
POP R14
POP RBP
RET
|
void my_multi_malloc_large
(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
int8 param_9,int8 param_10,int8 param_11,int8 param_12,
int8 param_13,int8 param_14)
{
char in_AL;
uint uVar1;
long *plVar2;
ulong uVar3;
long lVar4;
long *plVar5;
long *plVar6;
long local_e8 [4];
int8 local_c8;
int8 local_c0;
int8 local_b8;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
int8 local_58;
int8 local_48;
uint local_38;
int4 uStack_34;
long *local_30;
long *local_28;
local_e8[2] = param_11;
local_e8[3] = param_12;
local_c8 = param_13;
local_c0 = param_14;
if (in_AL != '\0') {
local_b8 = param_1;
local_a8 = param_2;
local_98 = param_3;
local_88 = param_4;
local_78 = param_5;
local_68 = param_6;
local_58 = param_7;
local_48 = param_8;
}
local_28 = local_e8;
plVar5 = (long *)&stack0x00000008;
local_30 = plVar5;
local_38 = 0x10;
uStack_34 = 0x30;
uVar1 = 0x10;
lVar4 = 0;
while( true ) {
if (uVar1 < 0x29) {
uVar3 = (ulong)uVar1;
uVar1 = uVar1 + 8;
local_38 = uVar1;
plVar2 = (long *)((long)local_e8 + uVar3);
plVar6 = plVar5;
}
else {
plVar6 = plVar5 + 1;
local_30 = plVar6;
plVar2 = plVar5;
}
if (*plVar2 == 0) break;
if (uVar1 < 0x29) {
uVar3 = (ulong)uVar1;
uVar1 = uVar1 + 8;
local_38 = uVar1;
plVar5 = plVar6;
plVar6 = (long *)((long)local_e8 + uVar3);
}
else {
plVar5 = plVar6 + 1;
local_30 = plVar5;
}
lVar4 = lVar4 + (*plVar6 + 7U & 0xfffffffffffffff8);
}
lVar4 = my_malloc(param_9,lVar4,param_10);
if (lVar4 != 0) {
local_30 = (long *)&stack0x00000008;
uVar1 = 0x10;
uVar3 = 0x10;
while( true ) {
if ((uint)uVar3 < 0x29) {
uVar1 = (uint)uVar3 + 8;
plVar5 = (long *)((long)local_e8 + uVar3);
}
else {
plVar5 = local_30;
local_30 = local_30 + 1;
}
if ((long *)*plVar5 == (long *)0x0) break;
*(long *)*plVar5 = lVar4;
uVar3 = (ulong)uVar1;
if (uVar3 < 0x29) {
plVar5 = (long *)((long)local_e8 + uVar3);
uVar1 = uVar1 + 8;
uVar3 = (ulong)uVar1;
}
else {
plVar5 = local_30;
local_30 = local_30 + 1;
}
lVar4 = lVar4 + (*plVar5 + 7U & 0xfffffffffffffff8);
}
}
return;
}
|
|
60,606
|
mp_mul_basecase
|
bluesky950520[P]quickjs/libbf.c
|
static void mp_mul_basecase(limb_t *result,
const limb_t *op1, limb_t op1_size,
const limb_t *op2, limb_t op2_size)
{
limb_t i, r;
result[op1_size] = mp_mul1(result, op1, op1_size, op2[0], 0);
for(i=1;i<op2_size;i++) {
r = mp_add_mul1(result + i, op1, op1_size, op2[i]);
result[i + op1_size] = r;
}
}
|
O1
|
c
|
mp_mul_basecase:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r9
testq %rdx, %rdx
je 0x85cab
movq (%rcx), %r10
xorl %ebx, %ebx
xorl %r11d, %r11d
movq %r10, %rax
mulq (%rsi,%r11,8)
addq %rbx, %rax
adcq $0x0, %rdx
movq %rax, (%rdi,%r11,8)
incq %r11
movq %rdx, %rbx
cmpq %r11, %r9
jne 0x85c8c
jmp 0x85cad
xorl %edx, %edx
movq %rdx, (%rdi,%r9,8)
cmpq $0x2, %r8
jb 0x85d08
leaq 0x8(%rdi), %r11
movl $0x1, %ebx
testq %r9, %r9
je 0x85cf2
movq (%rcx,%rbx,8), %r10
xorl %r14d, %r14d
xorl %r15d, %r15d
movq %r10, %rax
mulq (%rsi,%r14,8)
addq %r15, %rax
adcq $0x0, %rdx
addq %rax, (%r11,%r14,8)
adcq $0x0, %rdx
incq %r14
movq %rdx, %r15
cmpq %r14, %r9
jne 0x85ccf
jmp 0x85cf4
xorl %edx, %edx
leaq (%rdi,%rbx,8), %rax
movq %rdx, (%rax,%r9,8)
incq %rbx
addq $0x8, %r11
cmpq %r8, %rbx
jne 0x85cc0
popq %rbx
popq %r14
popq %r15
retq
|
mp_mul_basecase:
push r15
push r14
push rbx
mov r9, rdx
test rdx, rdx
jz short loc_85CAB
mov r10, [rcx]
xor ebx, ebx
xor r11d, r11d
loc_85C8C:
mov rax, r10
mul qword ptr [rsi+r11*8]
add rax, rbx
adc rdx, 0
mov [rdi+r11*8], rax
inc r11
mov rbx, rdx
cmp r9, r11
jnz short loc_85C8C
jmp short loc_85CAD
loc_85CAB:
xor edx, edx
loc_85CAD:
mov [rdi+r9*8], rdx
cmp r8, 2
jb short loc_85D08
lea r11, [rdi+8]
mov ebx, 1
loc_85CC0:
test r9, r9
jz short loc_85CF2
mov r10, [rcx+rbx*8]
xor r14d, r14d
xor r15d, r15d
loc_85CCF:
mov rax, r10
mul qword ptr [rsi+r14*8]
add rax, r15
adc rdx, 0
add [r11+r14*8], rax
adc rdx, 0
inc r14
mov r15, rdx
cmp r9, r14
jnz short loc_85CCF
jmp short loc_85CF4
loc_85CF2:
xor edx, edx
loc_85CF4:
lea rax, [rdi+rbx*8]
mov [rax+r9*8], rdx
inc rbx
add r11, 8
cmp rbx, r8
jnz short loc_85CC0
loc_85D08:
pop rbx
pop r14
pop r15
retn
|
long long mp_mul_basecase(long long a1, long long a2, long long a3, unsigned long long *a4, unsigned long long a5)
{
unsigned long long v6; // r10
unsigned long long v7; // rbx
long long i; // r11
unsigned __int128 v9; // rax
long long v10; // r11
long long j; // rbx
unsigned long long v12; // r10
long long v13; // r14
unsigned long long v14; // r15
bool v15; // cf
if ( a3 )
{
v6 = *a4;
v7 = 0LL;
for ( i = 0LL; i != a3; ++i )
{
v9 = v7 + *(unsigned long long *)(a2 + 8 * i) * (unsigned __int128)v6;
*(_QWORD *)(a1 + 8 * i) = v9;
v7 = *((_QWORD *)&v9 + 1);
}
}
else
{
*((_QWORD *)&v9 + 1) = 0LL;
}
*(_QWORD *)(a1 + 8 * a3) = *((_QWORD *)&v9 + 1);
if ( a5 >= 2 )
{
v10 = a1 + 8;
for ( j = 1LL; j != a5; ++j )
{
if ( a3 )
{
v12 = a4[j];
v13 = 0LL;
v14 = 0LL;
do
{
v9 = v14 + *(unsigned long long *)(a2 + 8 * v13) * (unsigned __int128)v12;
v15 = __CFADD__((_QWORD)v9, *(_QWORD *)(v10 + 8 * v13));
*(_QWORD *)(v10 + 8 * v13) += v9;
*((_QWORD *)&v9 + 1) += v15;
++v13;
v14 = *((_QWORD *)&v9 + 1);
}
while ( a3 != v13 );
}
else
{
*((_QWORD *)&v9 + 1) = 0LL;
}
*(_QWORD *)&v9 = a1 + 8 * j;
*(_QWORD *)(v9 + 8 * a3) = *((_QWORD *)&v9 + 1);
v10 += 8LL;
}
}
return v9;
}
|
mp_mul_basecase:
PUSH R15
PUSH R14
PUSH RBX
MOV R9,RDX
TEST RDX,RDX
JZ 0x00185cab
MOV R10,qword ptr [RCX]
XOR EBX,EBX
XOR R11D,R11D
LAB_00185c8c:
MOV RAX,R10
MUL qword ptr [RSI + R11*0x8]
ADD RAX,RBX
ADC RDX,0x0
MOV qword ptr [RDI + R11*0x8],RAX
INC R11
MOV RBX,RDX
CMP R9,R11
JNZ 0x00185c8c
JMP 0x00185cad
LAB_00185cab:
XOR EDX,EDX
LAB_00185cad:
MOV qword ptr [RDI + R9*0x8],RDX
CMP R8,0x2
JC 0x00185d08
LEA R11,[RDI + 0x8]
MOV EBX,0x1
LAB_00185cc0:
TEST R9,R9
JZ 0x00185cf2
MOV R10,qword ptr [RCX + RBX*0x8]
XOR R14D,R14D
XOR R15D,R15D
LAB_00185ccf:
MOV RAX,R10
MUL qword ptr [RSI + R14*0x8]
ADD RAX,R15
ADC RDX,0x0
ADD qword ptr [R11 + R14*0x8],RAX
ADC RDX,0x0
INC R14
MOV R15,RDX
CMP R9,R14
JNZ 0x00185ccf
JMP 0x00185cf4
LAB_00185cf2:
XOR EDX,EDX
LAB_00185cf4:
LEA RAX,[RDI + RBX*0x8]
MOV qword ptr [RAX + R9*0x8],RDX
INC RBX
ADD R11,0x8
CMP RBX,R8
JNZ 0x00185cc0
LAB_00185d08:
POP RBX
POP R14
POP R15
RET
|
void mp_mul_basecase(long param_1,long param_2,long param_3,ulong *param_4,ulong param_5)
{
ulong *puVar1;
ulong uVar2;
int1 auVar3 [16];
int1 auVar4 [16];
int1 auVar5 [16];
int1 auVar6 [16];
int1 auVar7 [16];
int1 auVar8 [16];
ulong uVar9;
ulong uVar10;
ulong uVar11;
long lVar12;
long lVar13;
if (param_3 == 0) {
uVar10 = 0;
}
else {
uVar11 = *param_4;
uVar10 = 0;
lVar12 = 0;
do {
auVar7._8_8_ = 0;
auVar7._0_8_ = uVar10;
auVar3._8_8_ = 0;
auVar3._0_8_ = uVar11;
auVar5._8_8_ = 0;
auVar5._0_8_ = *(ulong *)(param_2 + lVar12 * 8);
auVar7 = auVar3 * auVar5 + auVar7;
uVar10 = auVar7._8_8_;
*(long *)(param_1 + lVar12 * 8) = auVar7._0_8_;
lVar12 = lVar12 + 1;
} while (param_3 != lVar12);
}
*(ulong *)(param_1 + param_3 * 8) = uVar10;
if (1 < param_5) {
lVar12 = param_1 + 8;
uVar10 = 1;
do {
if (param_3 == 0) {
uVar11 = 0;
}
else {
uVar2 = param_4[uVar10];
lVar13 = 0;
uVar11 = 0;
do {
auVar8._8_8_ = 0;
auVar8._0_8_ = uVar11;
auVar4._8_8_ = 0;
auVar4._0_8_ = uVar2;
auVar6._8_8_ = 0;
auVar6._0_8_ = *(ulong *)(param_2 + lVar13 * 8);
auVar8 = auVar4 * auVar6 + auVar8;
uVar9 = auVar8._0_8_;
puVar1 = (ulong *)(lVar12 + lVar13 * 8);
uVar11 = *puVar1;
*puVar1 = *puVar1 + uVar9;
uVar11 = auVar8._8_8_ + (ulong)CARRY8(uVar11,uVar9);
lVar13 = lVar13 + 1;
} while (param_3 != lVar13);
}
*(ulong *)(param_1 + uVar10 * 8 + param_3 * 8) = uVar11;
uVar10 = uVar10 + 1;
lVar12 = lVar12 + 8;
} while (uVar10 != param_5);
}
return;
}
|
|
60,607
|
mp_mul_basecase
|
bluesky950520[P]quickjs/libbf.c
|
static void mp_mul_basecase(limb_t *result,
const limb_t *op1, limb_t op1_size,
const limb_t *op2, limb_t op2_size)
{
limb_t i, r;
result[op1_size] = mp_mul1(result, op1, op1_size, op2[0], 0);
for(i=1;i<op2_size;i++) {
r = mp_add_mul1(result + i, op1, op1_size, op2[i]);
result[i + op1_size] = r;
}
}
|
O3
|
c
|
mp_mul_basecase:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r9
testq %rdx, %rdx
je 0x886ed
movq (%rcx), %r10
xorl %ebx, %ebx
xorl %r11d, %r11d
movq %r10, %rax
mulq (%rsi,%r11,8)
addq %rbx, %rax
adcq $0x0, %rdx
movq %rax, (%rdi,%r11,8)
incq %r11
movq %rdx, %rbx
cmpq %r11, %r9
jne 0x886ce
jmp 0x886ef
xorl %edx, %edx
movq %rdx, (%rdi,%r9,8)
cmpq $0x2, %r8
jb 0x8874a
leaq 0x8(%rdi), %r11
movl $0x1, %ebx
testq %r9, %r9
je 0x88734
movq (%rcx,%rbx,8), %r10
xorl %r14d, %r14d
xorl %r15d, %r15d
movq %r10, %rax
mulq (%rsi,%r14,8)
addq %r15, %rax
adcq $0x0, %rdx
addq %rax, (%r11,%r14,8)
adcq $0x0, %rdx
incq %r14
movq %rdx, %r15
cmpq %r14, %r9
jne 0x88711
jmp 0x88736
xorl %edx, %edx
leaq (%rdi,%rbx,8), %rax
movq %rdx, (%rax,%r9,8)
incq %rbx
addq $0x8, %r11
cmpq %r8, %rbx
jne 0x88702
popq %rbx
popq %r14
popq %r15
retq
|
mp_mul_basecase:
push r15
push r14
push rbx
mov r9, rdx
test rdx, rdx
jz short loc_886ED
mov r10, [rcx]
xor ebx, ebx
xor r11d, r11d
loc_886CE:
mov rax, r10
mul qword ptr [rsi+r11*8]
add rax, rbx
adc rdx, 0
mov [rdi+r11*8], rax
inc r11
mov rbx, rdx
cmp r9, r11
jnz short loc_886CE
jmp short loc_886EF
loc_886ED:
xor edx, edx
loc_886EF:
mov [rdi+r9*8], rdx
cmp r8, 2
jb short loc_8874A
lea r11, [rdi+8]
mov ebx, 1
loc_88702:
test r9, r9
jz short loc_88734
mov r10, [rcx+rbx*8]
xor r14d, r14d
xor r15d, r15d
loc_88711:
mov rax, r10
mul qword ptr [rsi+r14*8]
add rax, r15
adc rdx, 0
add [r11+r14*8], rax
adc rdx, 0
inc r14
mov r15, rdx
cmp r9, r14
jnz short loc_88711
jmp short loc_88736
loc_88734:
xor edx, edx
loc_88736:
lea rax, [rdi+rbx*8]
mov [rax+r9*8], rdx
inc rbx
add r11, 8
cmp rbx, r8
jnz short loc_88702
loc_8874A:
pop rbx
pop r14
pop r15
retn
|
long long mp_mul_basecase(long long a1, long long a2, long long a3, unsigned long long *a4, unsigned long long a5)
{
unsigned long long v6; // r10
unsigned long long v7; // rbx
long long i; // r11
unsigned __int128 v9; // rax
long long v10; // r11
long long j; // rbx
unsigned long long v12; // r10
long long v13; // r14
unsigned long long v14; // r15
bool v15; // cf
if ( a3 )
{
v6 = *a4;
v7 = 0LL;
for ( i = 0LL; i != a3; ++i )
{
v9 = v7 + *(unsigned long long *)(a2 + 8 * i) * (unsigned __int128)v6;
*(_QWORD *)(a1 + 8 * i) = v9;
v7 = *((_QWORD *)&v9 + 1);
}
}
else
{
*((_QWORD *)&v9 + 1) = 0LL;
}
*(_QWORD *)(a1 + 8 * a3) = *((_QWORD *)&v9 + 1);
if ( a5 >= 2 )
{
v10 = a1 + 8;
for ( j = 1LL; j != a5; ++j )
{
if ( a3 )
{
v12 = a4[j];
v13 = 0LL;
v14 = 0LL;
do
{
v9 = v14 + *(unsigned long long *)(a2 + 8 * v13) * (unsigned __int128)v12;
v15 = __CFADD__((_QWORD)v9, *(_QWORD *)(v10 + 8 * v13));
*(_QWORD *)(v10 + 8 * v13) += v9;
*((_QWORD *)&v9 + 1) += v15;
++v13;
v14 = *((_QWORD *)&v9 + 1);
}
while ( a3 != v13 );
}
else
{
*((_QWORD *)&v9 + 1) = 0LL;
}
*(_QWORD *)&v9 = a1 + 8 * j;
*(_QWORD *)(v9 + 8 * a3) = *((_QWORD *)&v9 + 1);
v10 += 8LL;
}
}
return v9;
}
|
mp_mul_basecase:
PUSH R15
PUSH R14
PUSH RBX
MOV R9,RDX
TEST RDX,RDX
JZ 0x001886ed
MOV R10,qword ptr [RCX]
XOR EBX,EBX
XOR R11D,R11D
LAB_001886ce:
MOV RAX,R10
MUL qword ptr [RSI + R11*0x8]
ADD RAX,RBX
ADC RDX,0x0
MOV qword ptr [RDI + R11*0x8],RAX
INC R11
MOV RBX,RDX
CMP R9,R11
JNZ 0x001886ce
JMP 0x001886ef
LAB_001886ed:
XOR EDX,EDX
LAB_001886ef:
MOV qword ptr [RDI + R9*0x8],RDX
CMP R8,0x2
JC 0x0018874a
LEA R11,[RDI + 0x8]
MOV EBX,0x1
LAB_00188702:
TEST R9,R9
JZ 0x00188734
MOV R10,qword ptr [RCX + RBX*0x8]
XOR R14D,R14D
XOR R15D,R15D
LAB_00188711:
MOV RAX,R10
MUL qword ptr [RSI + R14*0x8]
ADD RAX,R15
ADC RDX,0x0
ADD qword ptr [R11 + R14*0x8],RAX
ADC RDX,0x0
INC R14
MOV R15,RDX
CMP R9,R14
JNZ 0x00188711
JMP 0x00188736
LAB_00188734:
XOR EDX,EDX
LAB_00188736:
LEA RAX,[RDI + RBX*0x8]
MOV qword ptr [RAX + R9*0x8],RDX
INC RBX
ADD R11,0x8
CMP RBX,R8
JNZ 0x00188702
LAB_0018874a:
POP RBX
POP R14
POP R15
RET
|
void mp_mul_basecase(long param_1,long param_2,long param_3,ulong *param_4,ulong param_5)
{
ulong *puVar1;
ulong uVar2;
int1 auVar3 [16];
int1 auVar4 [16];
int1 auVar5 [16];
int1 auVar6 [16];
int1 auVar7 [16];
int1 auVar8 [16];
ulong uVar9;
ulong uVar10;
ulong uVar11;
long lVar12;
long lVar13;
if (param_3 == 0) {
uVar10 = 0;
}
else {
uVar11 = *param_4;
uVar10 = 0;
lVar12 = 0;
do {
auVar7._8_8_ = 0;
auVar7._0_8_ = uVar10;
auVar3._8_8_ = 0;
auVar3._0_8_ = uVar11;
auVar5._8_8_ = 0;
auVar5._0_8_ = *(ulong *)(param_2 + lVar12 * 8);
auVar7 = auVar3 * auVar5 + auVar7;
uVar10 = auVar7._8_8_;
*(long *)(param_1 + lVar12 * 8) = auVar7._0_8_;
lVar12 = lVar12 + 1;
} while (param_3 != lVar12);
}
*(ulong *)(param_1 + param_3 * 8) = uVar10;
if (1 < param_5) {
lVar12 = param_1 + 8;
uVar10 = 1;
do {
if (param_3 == 0) {
uVar11 = 0;
}
else {
uVar2 = param_4[uVar10];
lVar13 = 0;
uVar11 = 0;
do {
auVar8._8_8_ = 0;
auVar8._0_8_ = uVar11;
auVar4._8_8_ = 0;
auVar4._0_8_ = uVar2;
auVar6._8_8_ = 0;
auVar6._0_8_ = *(ulong *)(param_2 + lVar13 * 8);
auVar8 = auVar4 * auVar6 + auVar8;
uVar9 = auVar8._0_8_;
puVar1 = (ulong *)(lVar12 + lVar13 * 8);
uVar11 = *puVar1;
*puVar1 = *puVar1 + uVar9;
uVar11 = auVar8._8_8_ + (ulong)CARRY8(uVar11,uVar9);
lVar13 = lVar13 + 1;
} while (param_3 != lVar13);
}
*(ulong *)(param_1 + uVar10 * 8 + param_3 * 8) = uVar11;
uVar10 = uVar10 + 1;
lVar12 = lVar12 + 8;
} while (uVar10 != param_5);
}
return;
}
|
|
60,608
|
spdlog::pattern_formatter::~pattern_formatter()
|
AlayaLite/build_O0/_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);
}
|
O0
|
c
|
spdlog::pattern_formatter::~pattern_formatter():
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0xa8, %rdi
callq 0x7da90
movq 0x8(%rsp), %rdi
addq $0x90, %rdi
callq 0x7daa0
movq 0x8(%rsp), %rdi
addq $0x28, %rdi
callq 0x1c160
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0x1c160
movq 0x8(%rsp), %rdi
callq 0x86bd0
addq $0x18, %rsp
retq
nopl (%rax,%rax)
|
_ZN6spdlog17pattern_formatterD2Ev:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov rdi, [rsp+18h+var_8]
mov [rsp+18h+var_10], rdi
add rdi, 0A8h
call _ZNSt13unordered_mapIcSt10unique_ptrIN6spdlog21custom_flag_formatterESt14default_deleteIS2_EESt4hashIcESt8equal_toIcESaISt4pairIKcS5_EEED2Ev; std::unordered_map<char,std::unique_ptr<spdlog::custom_flag_formatter>>::~unordered_map()
mov rdi, [rsp+18h+var_10]
add rdi, 90h
call _ZNSt6vectorISt10unique_ptrIN6spdlog7details14flag_formatterESt14default_deleteIS3_EESaIS6_EED2Ev; std::vector<std::unique_ptr<spdlog::details::flag_formatter>>::~vector()
mov rdi, [rsp+18h+var_10]
add rdi, 28h ; '('; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, [rsp+18h+var_10]
add rdi, 8; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, [rsp+18h+var_10]; this
call _ZN6spdlog9formatterD2Ev; spdlog::formatter::~formatter()
add rsp, 18h
retn
|
void spdlog::pattern_formatter::~pattern_formatter(spdlog::pattern_formatter *this)
{
std::unordered_map<char,std::unique_ptr<spdlog::custom_flag_formatter>>::~unordered_map((long long)this + 168);
std::vector<std::unique_ptr<spdlog::details::flag_formatter>>::~vector((long long *)this + 18);
std::string::~string((char *)this + 40);
std::string::~string((char *)this + 8);
spdlog::formatter::~formatter(this);
}
|
~pattern_formatter:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV RDI,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x8],RDI
ADD RDI,0xa8
CALL 0x0017da90
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x90
CALL 0x0017daa0
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x28
CALL 0x0011c160
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x8
CALL 0x0011c160
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x00186bd0
ADD RSP,0x18
RET
|
/* spdlog::pattern_formatter::~pattern_formatter() */
void __thiscall spdlog::pattern_formatter::~pattern_formatter(pattern_formatter *this)
{
std::
unordered_map<char,std::unique_ptr<spdlog::custom_flag_formatter,std::default_delete<spdlog::custom_flag_formatter>>,std::hash<char>,std::equal_to<char>,std::allocator<std::pair<char_const,std::unique_ptr<spdlog::custom_flag_formatter,std::default_delete<spdlog::custom_flag_formatter>>>>>
::~unordered_map((unordered_map<char,std::unique_ptr<spdlog::custom_flag_formatter,std::default_delete<spdlog::custom_flag_formatter>>,std::hash<char>,std::equal_to<char>,std::allocator<std::pair<char_const,std::unique_ptr<spdlog::custom_flag_formatter,std::default_delete<spdlog::custom_flag_formatter>>>>>
*)(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));
std::__cxx11::string::~string((string *)(this + 0x28));
std::__cxx11::string::~string((string *)(this + 8));
formatter::~formatter((formatter *)this);
return;
}
|
|
60,609
|
mi_keyseg_write
|
eloqsql/storage/myisam/mi_open.c
|
int mi_keyseg_write(File file, const HA_KEYSEG *keyseg)
{
uchar buff[HA_KEYSEG_SIZE];
uchar *ptr=buff;
ulong pos;
*ptr++= keyseg->type;
*ptr++= keyseg->language & 0xFF; /* Collation ID, low byte */
*ptr++= keyseg->null_bit;
*ptr++= keyseg->bit_start;
*ptr++= keyseg->language >> 8; /* Collation ID, high byte */
*ptr++= keyseg->bit_length;
mi_int2store(ptr,keyseg->flag); ptr+=2;
mi_int2store(ptr,keyseg->length); ptr+=2;
mi_int4store(ptr,keyseg->start); ptr+=4;
pos= keyseg->null_bit ? keyseg->null_pos : keyseg->bit_pos;
mi_int4store(ptr, pos);
ptr+=4;
return mysql_file_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
}
|
O3
|
c
|
mi_keyseg_write:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movl %edi, %ebx
movq %fs:0x28, %rax
movq %rax, -0x18(%rbp)
movb 0x18(%rsi), %al
movb %al, -0x30(%rbp)
movzwl 0x16(%rsi), %eax
movb %al, -0x2f(%rbp)
movb 0x19(%rsi), %cl
movb %cl, -0x2e(%rbp)
movb 0x1a(%rsi), %dl
movb %dl, -0x2d(%rbp)
movb %ah, -0x2c(%rbp)
movb 0x1b(%rsi), %al
movb %al, -0x2b(%rbp)
movzwl 0x12(%rsi), %eax
rolw $0x8, %ax
movw %ax, -0x2a(%rbp)
movzwl 0x14(%rsi), %eax
rolw $0x8, %ax
movw %ax, -0x28(%rbp)
movl 0x8(%rsi), %eax
bswapl %eax
movl %eax, -0x26(%rbp)
testb %cl, %cl
je 0x80581
movl 0xc(%rsi), %eax
jmp 0x80585
movzwl 0x10(%rsi), %eax
bswapl %eax
movl %eax, -0x22(%rbp)
leaq 0x305a7f(%rip), %rax # 0x386010
movq (%rax), %rax
leaq -0x80(%rbp), %rdi
movl %ebx, %esi
movl $0x7, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x805e4
leaq -0x30(%rbp), %rsi
movl $0x12, %edx
movl $0x4, %ecx
movl %ebx, %edi
callq 0x2efe4
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
setne %cl
movq %fs:0x28, %rdx
cmpq -0x18(%rbp), %rdx
jne 0x805fe
movb %cl, %al
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x30(%rbp), %rdx
leaq -0x38(%rbp), %r14
movq %rax, %rdi
movl %ebx, %esi
movq %r14, %rcx
callq 0x2e263
movq (%r14), %rcx
jmp 0x805c2
callq 0x29250
|
mi_keyseg_write:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 70h
mov ebx, edi
mov rax, fs:28h
mov [rbp+var_18], rax
mov al, [rsi+18h]
mov [rbp+var_30], al
movzx eax, word ptr [rsi+16h]
mov [rbp+var_2F], al
mov cl, [rsi+19h]
mov [rbp+var_2E], cl
mov dl, [rsi+1Ah]
mov [rbp+var_2D], dl
mov [rbp+var_2C], ah
mov al, [rsi+1Bh]
mov [rbp+var_2B], al
movzx eax, word ptr [rsi+12h]
rol ax, 8
mov [rbp+var_2A], ax
movzx eax, word ptr [rsi+14h]
rol ax, 8
mov [rbp+var_28], ax
mov eax, [rsi+8]
bswap eax
mov [rbp+var_26], eax
test cl, cl
jz short loc_80581
mov eax, [rsi+0Ch]
jmp short loc_80585
loc_80581:
movzx eax, word ptr [rsi+10h]
loc_80585:
bswap eax
mov [rbp+var_22], eax
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_80]
mov esi, ebx
mov edx, 7
call qword ptr [rax+158h]
test rax, rax
jnz short loc_805E4
lea rsi, [rbp+var_30]
mov edx, 12h
mov ecx, 4
mov edi, ebx
call my_write
mov rcx, rax
loc_805C2:
xor eax, eax
test rcx, rcx
setnz cl
mov rdx, fs:28h
cmp rdx, [rbp+var_18]
jnz short loc_805FE
mov al, cl
add rsp, 70h
pop rbx
pop r14
pop rbp
retn
loc_805E4:
lea rdx, [rbp+var_30]
lea r14, [rbp+var_38]
mov rdi, rax
mov esi, ebx
mov rcx, r14
call mi_keyseg_write_cold_1
mov rcx, [r14]
jmp short loc_805C2
loc_805FE:
call ___stack_chk_fail
|
bool mi_keyseg_write(unsigned int a1, long long a2)
{
__int16 v2; // ax
unsigned int v3; // eax
long long v4; // rax
long long v5; // rcx
_BYTE v8[72]; // [rsp+0h] [rbp-80h] BYREF
long long v9; // [rsp+48h] [rbp-38h] BYREF
_BYTE v10[2]; // [rsp+50h] [rbp-30h] BYREF
char v11; // [rsp+52h] [rbp-2Eh]
char v12; // [rsp+53h] [rbp-2Dh]
char v13; // [rsp+54h] [rbp-2Ch]
char v14; // [rsp+55h] [rbp-2Bh]
__int16 v15; // [rsp+56h] [rbp-2Ah]
__int16 v16; // [rsp+58h] [rbp-28h]
unsigned __int32 v17; // [rsp+5Ah] [rbp-26h]
unsigned __int32 v18; // [rsp+5Eh] [rbp-22h]
unsigned long long v19; // [rsp+68h] [rbp-18h]
v19 = __readfsqword(0x28u);
v10[0] = *(_BYTE *)(a2 + 24);
v2 = *(_WORD *)(a2 + 22);
v10[1] = v2;
v11 = *(_BYTE *)(a2 + 25);
v12 = *(_BYTE *)(a2 + 26);
v13 = HIBYTE(v2);
v14 = *(_BYTE *)(a2 + 27);
v15 = __ROL2__(*(_WORD *)(a2 + 18), 8);
v16 = __ROL2__(*(_WORD *)(a2 + 20), 8);
v17 = _byteswap_ulong(*(_DWORD *)(a2 + 8));
if ( v11 )
v3 = *(_DWORD *)(a2 + 12);
else
v3 = *(unsigned __int16 *)(a2 + 16);
v18 = _byteswap_ulong(v3);
v4 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v8, a1, 7LL);
if ( v4 )
{
mi_keyseg_write_cold_1(v4, a1, (long long)v10, &v9);
v5 = v9;
}
else
{
v5 = my_write(a1, (long long)v10, 18LL, 4LL);
}
return v5 != 0;
}
|
mi_keyseg_write:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x70
MOV EBX,EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
MOV AL,byte ptr [RSI + 0x18]
MOV byte ptr [RBP + -0x30],AL
MOVZX EAX,word ptr [RSI + 0x16]
MOV byte ptr [RBP + -0x2f],AL
MOV CL,byte ptr [RSI + 0x19]
MOV byte ptr [RBP + -0x2e],CL
MOV DL,byte ptr [RSI + 0x1a]
MOV byte ptr [RBP + -0x2d],DL
MOV byte ptr [RBP + -0x2c],AH
MOV AL,byte ptr [RSI + 0x1b]
MOV byte ptr [RBP + -0x2b],AL
MOVZX EAX,word ptr [RSI + 0x12]
ROL AX,0x8
MOV word ptr [RBP + -0x2a],AX
MOVZX EAX,word ptr [RSI + 0x14]
ROL AX,0x8
MOV word ptr [RBP + -0x28],AX
MOV EAX,dword ptr [RSI + 0x8]
BSWAP EAX
MOV dword ptr [RBP + -0x26],EAX
TEST CL,CL
JZ 0x00180581
MOV EAX,dword ptr [RSI + 0xc]
JMP 0x00180585
LAB_00180581:
MOVZX EAX,word ptr [RSI + 0x10]
LAB_00180585:
BSWAP EAX
MOV dword ptr [RBP + -0x22],EAX
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x80]
MOV ESI,EBX
MOV EDX,0x7
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x001805e4
LEA RSI,[RBP + -0x30]
MOV EDX,0x12
MOV ECX,0x4
MOV EDI,EBX
CALL 0x0012efe4
MOV RCX,RAX
LAB_001805c2:
XOR EAX,EAX
TEST RCX,RCX
SETNZ CL
MOV RDX,qword ptr FS:[0x28]
CMP RDX,qword ptr [RBP + -0x18]
JNZ 0x001805fe
MOV AL,CL
ADD RSP,0x70
POP RBX
POP R14
POP RBP
RET
LAB_001805e4:
LEA RDX,[RBP + -0x30]
LEA R14,[RBP + -0x38]
MOV RDI,RAX
MOV ESI,EBX
MOV RCX,R14
CALL 0x0012e263
MOV RCX,qword ptr [R14]
JMP 0x001805c2
LAB_001805fe:
CALL 0x00129250
|
bool mi_keyseg_write(int4 param_1,long param_2)
{
uint uVar1;
long lVar2;
long in_FS_OFFSET;
int1 local_88 [72];
long local_40;
int1 local_38;
int1 local_37;
char local_36;
int1 local_35;
int1 local_34;
int1 local_33;
ushort local_32;
ushort local_30;
uint local_2e;
uint local_2a;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_38 = *(int1 *)(param_2 + 0x18);
local_37 = (int1)*(int2 *)(param_2 + 0x16);
local_36 = *(char *)(param_2 + 0x19);
local_35 = *(int1 *)(param_2 + 0x1a);
local_34 = (int1)((ushort)*(int2 *)(param_2 + 0x16) >> 8);
local_33 = *(int1 *)(param_2 + 0x1b);
local_32 = *(ushort *)(param_2 + 0x12) << 8 | *(ushort *)(param_2 + 0x12) >> 8;
local_30 = *(ushort *)(param_2 + 0x14) << 8 | *(ushort *)(param_2 + 0x14) >> 8;
uVar1 = *(uint *)(param_2 + 8);
local_2e = uVar1 >> 0x18 | (uVar1 & 0xff0000) >> 8 | (uVar1 & 0xff00) << 8 | uVar1 << 0x18;
if (local_36 == '\0') {
uVar1 = (uint)*(ushort *)(param_2 + 0x10);
}
else {
uVar1 = *(uint *)(param_2 + 0xc);
}
local_2a = uVar1 >> 0x18 | (uVar1 & 0xff0000) >> 8 | (uVar1 & 0xff00) << 8 | uVar1 << 0x18;
lVar2 = (**(code **)(PSI_server + 0x158))(local_88,param_1,7);
if (lVar2 == 0) {
local_40 = my_write(param_1,&local_38,0x12,4);
}
else {
mi_keyseg_write_cold_1(lVar2,param_1,&local_38,&local_40);
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_20) {
return local_40 != 0;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
60,610
|
my_dirend
|
eloqsql/mysys/my_lib.c
|
void my_dirend(MY_DIR *dir)
{
MY_DIR_HANDLE *dirh= (MY_DIR_HANDLE*) dir;
DBUG_ENTER("my_dirend");
if (dirh)
{
delete_dynamic(&dirh->array);
free_root(&dirh->root, MYF(0));
my_free(dirh);
}
DBUG_VOID_RETURN;
}
|
O3
|
c
|
my_dirend:
testq %rdi, %rdi
je 0x9c34c
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x10, %rdi
callq 0x91618
leaq 0x38(%rbx), %rdi
xorl %esi, %esi
callq 0x986f7
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9c92a
retq
|
my_dirend:
test rdi, rdi
jz short locret_9C34C
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
add rdi, 10h
call delete_dynamic
lea rdi, [rbx+38h]
xor esi, esi
call free_root
mov rdi, rbx
add rsp, 8
pop rbx
pop rbp
jmp my_free
locret_9C34C:
retn
|
long long my_dirend(long long a1)
{
long long result; // rax
if ( a1 )
{
delete_dynamic((long long *)(a1 + 16));
free_root((_QWORD *)(a1 + 56), 0);
return my_free(a1);
}
return result;
}
|
my_dirend:
TEST RDI,RDI
JZ 0x0019c34c
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
ADD RDI,0x10
CALL 0x00191618
LEA RDI,[RBX + 0x38]
XOR ESI,ESI
CALL 0x001986f7
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x0019c92a
LAB_0019c34c:
RET
|
void my_dirend(long param_1)
{
if (param_1 != 0) {
delete_dynamic(param_1 + 0x10);
free_root(param_1 + 0x38,0);
my_free(param_1);
return;
}
return;
}
|
|
60,611
|
testing::operator<<(std::ostream&, testing::TestPartResult const&)
|
AlayaLite/build_O0/_deps/googletest-src/googletest/src/gtest-test-part.cc
|
std::ostream& operator<<(std::ostream& os, const TestPartResult& result) {
return os << internal::FormatFileLocation(result.file_name(),
result.line_number())
<< " "
<< (result.type() == TestPartResult::kSuccess ? "Success"
: result.type() == TestPartResult::kSkip ? "Skipped"
: result.type() == TestPartResult::kFatalFailure
? "Fatal failure"
: "Non-fatal failure")
<< ":\n"
<< result.message() << std::endl;
}
|
O0
|
cpp
|
testing::operator<<(std::ostream&, testing::TestPartResult const&):
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0xa8(%rsp), %rdi
callq 0xeceb0
movq %rax, 0x58(%rsp)
movq 0xa8(%rsp), %rdi
callq 0xecf00
movq 0x58(%rsp), %rsi
movl %eax, %edx
leaq 0x88(%rsp), %rdi
movq %rdi, 0x68(%rsp)
callq 0xc13f0
movq 0x60(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x16620
movq %rax, 0x70(%rsp)
jmp 0xc3cc2
movq 0x70(%rsp), %rdi
leaq 0x59435(%rip), %rsi # 0x11d103
callq 0x166e0
movq %rax, 0x50(%rsp)
jmp 0xc3cda
movq 0xa8(%rsp), %rdi
callq 0xecf10
movl %eax, 0x4c(%rsp)
jmp 0xc3ced
movl 0x4c(%rsp), %eax
cmpl $0x0, %eax
jne 0xc3d04
leaq 0x58de8(%rip), %rax # 0x11cae5
movq %rax, 0x40(%rsp)
jmp 0xc3d69
movq 0xa8(%rsp), %rdi
callq 0xecf10
movl %eax, 0x3c(%rsp)
jmp 0xc3d17
movl 0x3c(%rsp), %eax
cmpl $0x3, %eax
jne 0xc3d2e
leaq 0x58dc6(%rip), %rax # 0x11caed
movq %rax, 0x30(%rsp)
jmp 0xc3d5f
movq 0xa8(%rsp), %rdi
callq 0xecf10
movl %eax, 0x2c(%rsp)
jmp 0xc3d41
movl 0x2c(%rsp), %edx
leaq 0x58db7(%rip), %rax # 0x11cb03
leaq 0x58da2(%rip), %rcx # 0x11caf5
cmpl $0x2, %edx
cmoveq %rcx, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x166e0
movq %rax, 0x20(%rsp)
jmp 0xc3d7f
movq 0x20(%rsp), %rdi
leaq 0x58a16(%rip), %rsi # 0x11c7a1
callq 0x166e0
movq %rax, 0x18(%rsp)
jmp 0xc3d97
movq 0xa8(%rsp), %rdi
callq 0xecf20
movq %rax, 0x10(%rsp)
jmp 0xc3dab
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdi
callq 0x166e0
movq %rax, 0x8(%rsp)
jmp 0xc3dc1
movq 0x8(%rsp), %rdi
movq 0xc1153(%rip), %rsi # 0x184f20
callq 0x16760
movq %rax, (%rsp)
jmp 0xc3dd8
leaq 0x88(%rsp), %rdi
callq 0x1dfd0
movq (%rsp), %rax
addq $0xb8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x1dfd0
movq 0x80(%rsp), %rdi
callq 0x16cf0
nopl (%rax)
|
_ZN7testinglsERSoRKNS_14TestPartResultE:
sub rsp, 0B8h
mov qword ptr [rsp+0B8h+var_8], rdi
mov [rsp+0B8h+var_10], rsi
mov rax, qword ptr [rsp+0B8h+var_8]
mov qword ptr [rsp+0B8h+var_58], rax; char
mov rdi, [rsp+0B8h+var_10]; this
call _ZNK7testing14TestPartResult9file_nameEv; testing::TestPartResult::file_name(void)
mov qword ptr [rsp+0B8h+var_60], rax; int
mov rdi, [rsp+0B8h+var_10]; this
call _ZNK7testing14TestPartResult11line_numberEv; testing::TestPartResult::line_number(void)
mov rsi, qword ptr [rsp+0B8h+var_60]
mov edx, eax
lea rdi, [rsp+0B8h+var_30]; __int64
mov qword ptr [rsp+0B8h+var_50], rdi; int
call _ZN7testing8internal18FormatFileLocationB5cxx11EPKci; testing::internal::FormatFileLocation(char const*,int)
mov rdi, qword ptr [rsp+0B8h+var_58]
mov rsi, qword ptr [rsp+0B8h+var_50]
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
mov [rsp+0B8h+var_48], rax
jmp short $+2
loc_C3CC2:
mov rdi, [rsp+0B8h+var_48]
lea rsi, asc_11D101+2; " "
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rsp+0B8h+var_68], rax
jmp short $+2
loc_C3CDA:
mov rdi, [rsp+0B8h+var_10]; this
call _ZNK7testing14TestPartResult4typeEv; testing::TestPartResult::type(void)
mov [rsp+0B8h+var_6C], eax
jmp short $+2
loc_C3CED:
mov eax, [rsp+0B8h+var_6C]
cmp eax, 0
jnz short loc_C3D04
lea rax, aSuccess; "Success"
mov [rsp+0B8h+var_78], rax
jmp short loc_C3D69
loc_C3D04:
mov rdi, [rsp+0B8h+var_10]; this
call _ZNK7testing14TestPartResult4typeEv; testing::TestPartResult::type(void)
mov [rsp+0B8h+var_7C], eax
jmp short $+2
loc_C3D17:
mov eax, [rsp+0B8h+var_7C]
cmp eax, 3
jnz short loc_C3D2E
lea rax, aSkipped; "Skipped"
mov [rsp+0B8h+var_88], rax
jmp short loc_C3D5F
loc_C3D2E:
mov rdi, [rsp+0B8h+var_10]; this
call _ZNK7testing14TestPartResult4typeEv; testing::TestPartResult::type(void)
mov [rsp+0B8h+var_8C], eax
jmp short $+2
loc_C3D41:
mov edx, [rsp+0B8h+var_8C]
lea rax, aNonFatalFailur; "Non-fatal failure"
lea rcx, aFatalFailure; "Fatal failure"
cmp edx, 2
cmovz rax, rcx
mov [rsp+0B8h+var_88], rax
loc_C3D5F:
mov rax, [rsp+0B8h+var_88]
mov [rsp+0B8h+var_78], rax
loc_C3D69:
mov rdi, [rsp+0B8h+var_68]
mov rsi, [rsp+0B8h+var_78]
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rsp+0B8h+var_98], rax
jmp short $+2
loc_C3D7F:
mov rdi, [rsp+0B8h+var_98]
lea rsi, aResultDiedButN_0+30h; ":\n"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rsp+0B8h+var_A0], rax
jmp short $+2
loc_C3D97:
mov rdi, [rsp+0B8h+var_10]; this
call _ZNK7testing14TestPartResult7messageEv; testing::TestPartResult::message(void)
mov [rsp+0B8h+var_A8], rax
jmp short $+2
loc_C3DAB:
mov rsi, [rsp+0B8h+var_A8]
mov rdi, [rsp+0B8h+var_A0]
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rsp+0B8h+var_B0], rax
jmp short $+2
loc_C3DC1:
mov rdi, [rsp+0B8h+var_B0]
mov rsi, cs:_ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6__ptr
call __ZNSolsEPFRSoS_E; std::ostream::operator<<(std::ostream & (*)(std::ostream &))
mov [rsp+0B8h+var_B8], rax
jmp short $+2
loc_C3DD8:
lea rdi, [rsp+0B8h+var_30]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rax, [rsp+0B8h+var_B8]
add rsp, 0B8h
retn
mov rcx, rax
mov eax, edx
mov [rsp+arg_78], rcx
mov [rsp+arg_74], eax
lea rdi, [rsp+arg_80]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, [rsp+arg_78]
call __Unwind_Resume
|
long long testing::operator<<(long long a1, testing::TestPartResult *a2)
{
int v2; // eax
long long v3; // rax
const char *v4; // rax
long long v6; // [rsp+0h] [rbp-B8h]
long long v7; // [rsp+8h] [rbp-B0h]
long long v8; // [rsp+10h] [rbp-A8h]
long long v9; // [rsp+18h] [rbp-A0h]
int v10; // [rsp+2Ch] [rbp-8Ch]
const char *v11; // [rsp+30h] [rbp-88h]
long long v12; // [rsp+50h] [rbp-68h]
long long v13; // [rsp+58h] [rbp-60h]
long long v14; // [rsp+70h] [rbp-48h]
long long v15[4]; // [rsp+88h] [rbp-30h] BYREF
testing::TestPartResult *v16; // [rsp+A8h] [rbp-10h]
char v17[8]; // [rsp+B0h] [rbp-8h]
*(_QWORD *)v17 = a1;
v16 = a2;
v13 = testing::TestPartResult::file_name(a2);
v2 = testing::TestPartResult::line_number(a2);
testing::internal::FormatFileLocation[abi:cxx11](v15, v13, v2);
v14 = std::operator<<<char>(a1, v15);
v12 = std::operator<<<std::char_traits<char>>(v14, " ");
if ( (unsigned int)testing::TestPartResult::type(v16) )
{
if ( (unsigned int)testing::TestPartResult::type(v16) == 3 )
{
v11 = "Skipped";
}
else
{
v10 = testing::TestPartResult::type(v16);
v4 = "Non-fatal failure";
if ( v10 == 2 )
v4 = "Fatal failure";
v11 = v4;
}
v3 = std::operator<<<std::char_traits<char>>(v12, v11);
}
else
{
v3 = std::operator<<<std::char_traits<char>>(v12, "Success");
}
v9 = std::operator<<<std::char_traits<char>>(v3, ":\n");
v8 = testing::TestPartResult::message(v16);
v7 = std::operator<<<std::char_traits<char>>(v9, v8);
v6 = std::ostream::operator<<(v7, &std::endl<char,std::char_traits<char>>);
std::string::~string(v15);
return v6;
}
|
operator<<:
SUB RSP,0xb8
MOV qword ptr [RSP + 0xb0],RDI
MOV qword ptr [RSP + 0xa8],RSI
MOV RAX,qword ptr [RSP + 0xb0]
MOV qword ptr [RSP + 0x60],RAX
MOV RDI,qword ptr [RSP + 0xa8]
CALL 0x001eceb0
MOV qword ptr [RSP + 0x58],RAX
MOV RDI,qword ptr [RSP + 0xa8]
CALL 0x001ecf00
MOV RSI,qword ptr [RSP + 0x58]
MOV EDX,EAX
LEA RDI,[RSP + 0x88]
MOV qword ptr [RSP + 0x68],RDI
CALL 0x001c13f0
MOV RDI,qword ptr [RSP + 0x60]
MOV RSI,qword ptr [RSP + 0x68]
LAB_001c3cb6:
CALL 0x00116620
MOV qword ptr [RSP + 0x70],RAX
JMP 0x001c3cc2
LAB_001c3cc2:
MOV RDI,qword ptr [RSP + 0x70]
LEA RSI,[0x21d103]
CALL 0x001166e0
MOV qword ptr [RSP + 0x50],RAX
JMP 0x001c3cda
LAB_001c3cda:
MOV RDI,qword ptr [RSP + 0xa8]
CALL 0x001ecf10
MOV dword ptr [RSP + 0x4c],EAX
JMP 0x001c3ced
LAB_001c3ced:
MOV EAX,dword ptr [RSP + 0x4c]
CMP EAX,0x0
JNZ 0x001c3d04
LEA RAX,[0x21cae5]
MOV qword ptr [RSP + 0x40],RAX
JMP 0x001c3d69
LAB_001c3d04:
MOV RDI,qword ptr [RSP + 0xa8]
CALL 0x001ecf10
MOV dword ptr [RSP + 0x3c],EAX
JMP 0x001c3d17
LAB_001c3d17:
MOV EAX,dword ptr [RSP + 0x3c]
CMP EAX,0x3
JNZ 0x001c3d2e
LEA RAX,[0x21caed]
MOV qword ptr [RSP + 0x30],RAX
JMP 0x001c3d5f
LAB_001c3d2e:
MOV RDI,qword ptr [RSP + 0xa8]
CALL 0x001ecf10
MOV dword ptr [RSP + 0x2c],EAX
JMP 0x001c3d41
LAB_001c3d41:
MOV EDX,dword ptr [RSP + 0x2c]
LEA RAX,[0x21cb03]
LEA RCX,[0x21caf5]
CMP EDX,0x2
CMOVZ RAX,RCX
MOV qword ptr [RSP + 0x30],RAX
LAB_001c3d5f:
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x40],RAX
LAB_001c3d69:
MOV RDI,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RSP + 0x40]
CALL 0x001166e0
MOV qword ptr [RSP + 0x20],RAX
JMP 0x001c3d7f
LAB_001c3d7f:
MOV RDI,qword ptr [RSP + 0x20]
LEA RSI,[0x21c7a1]
CALL 0x001166e0
MOV qword ptr [RSP + 0x18],RAX
JMP 0x001c3d97
LAB_001c3d97:
MOV RDI,qword ptr [RSP + 0xa8]
CALL 0x001ecf20
MOV qword ptr [RSP + 0x10],RAX
JMP 0x001c3dab
LAB_001c3dab:
MOV RSI,qword ptr [RSP + 0x10]
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x001166e0
MOV qword ptr [RSP + 0x8],RAX
JMP 0x001c3dc1
LAB_001c3dc1:
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [0x00284f20]
CALL 0x00116760
LAB_001c3dd2:
MOV qword ptr [RSP],RAX
JMP 0x001c3dd8
LAB_001c3dd8:
LEA RDI,[RSP + 0x88]
CALL 0x0011dfd0
MOV RAX,qword ptr [RSP]
ADD RSP,0xb8
RET
|
/* testing::TEMPNAMEPLACEHOLDERVALUE(std::ostream&, testing::TestPartResult const&) */
int8 testing::operator<<(ostream *param_1,TestPartResult *param_2)
{
int iVar1;
char *pcVar2;
ostream *poVar3;
int8 uVar4;
char *local_88;
char *local_78;
internal local_30 [32];
TestPartResult *local_10;
ostream *local_8;
local_10 = param_2;
local_8 = param_1;
pcVar2 = (char *)TestPartResult::file_name(param_2);
iVar1 = TestPartResult::line_number(local_10);
internal::FormatFileLocation_abi_cxx11_(local_30,pcVar2,iVar1);
/* try { // try from 001c3cb6 to 001c3dd1 has its CatchHandler @ 001c3df1 */
poVar3 = std::operator<<(param_1,(string *)local_30);
poVar3 = std::operator<<(poVar3," ");
iVar1 = TestPartResult::type(local_10);
if (iVar1 == 0) {
local_78 = "Success";
}
else {
iVar1 = TestPartResult::type(local_10);
if (iVar1 == 3) {
local_88 = "Skipped";
}
else {
iVar1 = TestPartResult::type(local_10);
local_88 = "Non-fatal failure";
if (iVar1 == 2) {
local_88 = "Fatal failure";
}
}
local_78 = local_88;
}
poVar3 = std::operator<<(poVar3,local_78);
poVar3 = std::operator<<(poVar3,":\n");
pcVar2 = (char *)TestPartResult::message(local_10);
poVar3 = std::operator<<(poVar3,pcVar2);
uVar4 = std::ostream::operator<<
(poVar3,(_func_ostream_ptr_ostream_ptr *)
PTR_endl<char,std_char_traits<char>>_00284f20);
std::__cxx11::string::~string((string *)local_30);
return uVar4;
}
|
|
60,612
|
l_find(LF_SLIST**, charset_info_st const*, unsigned int, unsigned char const*, unsigned long, CURSOR*, LF_PINS*, char (*)(void*, void*))
|
eloqsql/mysys/lf_hash.cc
|
static int l_find(LF_SLIST **head, CHARSET_INFO *cs, uint32 hashnr,
const uchar *key, size_t keylen, CURSOR *cursor, LF_PINS *pins,
my_hash_walk_action callback)
{
uint32 cur_hashnr;
const uchar *cur_key;
size_t cur_keylen;
intptr link;
DBUG_ASSERT(!cs || !callback); /* should not be set both */
DBUG_ASSERT(!keylen || !callback); /* should not be set both */
retry:
cursor->prev= (intptr *) my_assume_aligned<sizeof(intptr)>(head);
do { /* PTR() isn't necessary below, head is a dummy node */
cursor->curr= my_assume_aligned<sizeof(LF_SLIST *)>((LF_SLIST *)(*cursor->prev));
lf_pin(pins, 1, cursor->curr);
} while (my_atomic_loadptr(
(void **)my_assume_aligned<sizeof(LF_SLIST *)>(cursor->prev))
!= cursor->curr && LF_BACKOFF());
for (;;)
{
if (unlikely(!cursor->curr))
return 0; /* end of the list */
cur_hashnr= cursor->curr->hashnr;
cur_keylen= cursor->curr->keylen;
/* The key element needs to be aligned, not necessary what it points to */
my_assume_aligned<sizeof(const uchar *)>(&cursor->curr->key);
cur_key= (const uchar *) my_atomic_loadptr_explicit((void **) &cursor->curr->key,
MY_MEMORY_ORDER_ACQUIRE);
do {
/* attempting to my_assume_aligned onlink below broke the implementation */
link= (intptr) my_atomic_loadptr_explicit((void **) &cursor->curr->link,
MY_MEMORY_ORDER_RELAXED);
cursor->next= my_assume_aligned<sizeof(LF_SLIST *)>(PTR(link));
lf_pin(pins, 0, cursor->next);
} while (link != (intptr) my_atomic_loadptr((void *volatile *) &cursor->curr->link)
&& LF_BACKOFF());
if (!DELETED(link))
{
if (unlikely(callback))
{
if (cur_hashnr & 1 && callback(cursor->curr + 1, (void*)key))
return 1;
}
else if (cur_hashnr >= hashnr)
{
int r= 1;
if (cur_hashnr > hashnr ||
(r= my_strnncoll(cs, cur_key, cur_keylen, key, keylen)) >= 0)
return !r;
}
cursor->prev= &(cursor->curr->link);
if (!(cur_hashnr & 1)) /* dummy node */
head= (LF_SLIST **)cursor->prev;
lf_pin(pins, 2, cursor->curr);
}
else
{
/*
we found a deleted node - be nice, help the other thread
and remove this deleted node
*/
if (my_atomic_casptr((void **) cursor->prev,
(void **) &cursor->curr, cursor->next) && LF_BACKOFF())
lf_alloc_free(pins, cursor->curr);
else
goto retry;
}
cursor->curr= cursor->next;
lf_pin(pins, 1, cursor->curr);
}
}
|
O0
|
cpp
|
l_find(LF_SLIST**, charset_info_st const*, unsigned int, unsigned char const*, unsigned long, CURSOR*, LF_PINS*, char (*)(void*, void*)):
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
jmp 0xfe1dc
jmp 0xfe1de
jmp 0xfe1e0
jmp 0xfe1e2
movq -0x10(%rbp), %rdi
callq 0xfe610
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0xfe620
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xfe211
jmp 0xfe213
movq 0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
xchgq %rax, 0x8(%rcx)
jmp 0xfe22d
movq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0xfe630
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rcx
movq -0x38(%rbp), %rdx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, -0xb1(%rbp)
je 0xfe267
callq 0xfe640
cmpl $0x0, %eax
setne %al
movb %al, -0xb1(%rbp)
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0xfe1f5
jmp 0xfe273
movq -0x38(%rbp), %rax
cmpq $0x0, 0x8(%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0xfe297
movl $0x0, -0x4(%rbp)
jmp 0xfe541
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x18(%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
addq $0x8, %rdi
callq 0xfe680
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
andq $-0x2, %rdi
callq 0xfe620
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0xfe30f
jmp 0xfe311
movq 0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
xchgq %rax, (%rcx)
jmp 0xfe32a
movq -0x58(%rbp), %rcx
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0xb2(%rbp)
je 0xfe365
callq 0xfe640
cmpl $0x0, %eax
setne %al
movb %al, -0xb2(%rbp)
movb -0xb2(%rbp), %al
testb $0x1, %al
jne 0xfe2de
movq -0x58(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0xfe477
cmpq $0x0, 0x18(%rbp)
je 0xfe3bf
movl -0x3c(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xfe3bd
movq 0x18(%rbp), %rax
movq -0x38(%rbp), %rcx
movq 0x8(%rcx), %rdi
addq $0x20, %rdi
movq -0x28(%rbp), %rsi
callq *%rax
cmpb $0x0, %al
je 0xfe3bd
movl $0x1, -0x4(%rbp)
jmp 0xfe541
jmp 0xfe429
movl -0x3c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jb 0xfe427
movl $0x1, -0x8c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
ja 0xfe40c
movq -0x18(%rbp), %rax
movq 0xc0(%rax), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
xorl %r9d, %r9d
callq *%rax
movl %eax, -0x8c(%rbp)
cmpl $0x0, %eax
jl 0xfe425
cmpl $0x0, -0x8c(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0xfe541
jmp 0xfe427
jmp 0xfe429
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movl -0x3c(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0xfe44e
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xfe450
jmp 0xfe452
jmp 0xfe454
movq 0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rax
xchgq %rax, 0x10(%rcx)
jmp 0xfe50a
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0xd0(%rbp)
movq (%rax), %rcx
movq 0x10(%rax), %rdx
movq %rdx, -0xa0(%rbp)
movq 0x8(%rax), %rax
movq -0xa0(%rbp), %rdx
lock
cmpxchgq %rdx, (%rcx)
movq %rax, %rcx
sete %al
movb %al, -0xc1(%rbp)
movq %rcx, -0xc0(%rbp)
testb $0x1, %al
jne 0xfe4cf
movq -0xd0(%rbp), %rax
movq -0xc0(%rbp), %rcx
movq %rcx, (%rax)
movb -0xc1(%rbp), %al
andb $0x1, %al
movb %al, -0xa1(%rbp)
testb $0x1, -0xa1(%rbp)
je 0xfe503
callq 0xfe640
cmpl $0x0, %eax
je 0xfe503
movq 0x10(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xfc740
jmp 0xfe508
jmp 0xfe1e2
jmp 0xfe50a
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xfe51c
jmp 0xfe51e
movq 0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rax
xchgq %rax, 0x8(%rcx)
jmp 0xfe273
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax)
|
_ZL6l_findPP8LF_SLISTPK15charset_info_stjPKhmP6CURSORP7LF_PINSPFcPvSB_E:
push rbp
mov rbp, rsp
sub rsp, 0D0h
mov rax, [rbp+arg_8]
mov rax, [rbp+arg_0]
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov [rbp+var_38], r9
jmp short $+2
loc_FE1DC:
jmp short $+2
loc_FE1DE:
jmp short $+2
loc_FE1E0:
jmp short $+2
loc_FE1E2:
mov rdi, [rbp+var_10]
call _ZL17my_assume_alignedILm8EPP8LF_SLISTET0_S3_; my_assume_aligned<8ul,LF_SLIST **>(LF_SLIST **)
mov rcx, rax
mov rax, [rbp+var_38]
mov [rax], rcx
loc_FE1F5:
mov rax, [rbp+var_38]
mov rax, [rax]
mov rdi, [rax]
call _ZL17my_assume_alignedILm8EP8LF_SLISTET0_S2_; my_assume_aligned<8ul,LF_SLIST *>(LF_SLIST *)
mov rcx, rax
mov rax, [rbp+var_38]
mov [rax+8], rcx
jmp short $+2
loc_FE211:
jmp short $+2
loc_FE213:
mov rcx, [rbp+arg_0]
mov rax, [rbp+var_38]
mov rax, [rax+8]
mov [rbp+var_60], rax
mov rax, [rbp+var_60]
xchg rax, [rcx+8]
jmp short $+2
loc_FE22D:
mov rax, [rbp+var_38]
mov rdi, [rax]
call _ZL17my_assume_alignedILm8EPmET0_S1_; my_assume_aligned<8ul,ulong *>(ulong *)
mov rax, [rax]
mov [rbp+var_68], rax
mov rcx, [rbp+var_68]
mov rdx, [rbp+var_38]
xor eax, eax
cmp rcx, [rdx+8]
mov [rbp+var_B1], al
jz short loc_FE267
call _ZL10LF_BACKOFFv; LF_BACKOFF(void)
cmp eax, 0
setnz al
mov [rbp+var_B1], al
loc_FE267:
mov al, [rbp+var_B1]
test al, 1
jnz short loc_FE1F5
jmp short $+2
loc_FE273:
mov rax, [rbp+var_38]
cmp qword ptr [rax+8], 0
setnz al
xor al, 0FFh
and al, 1
movzx eax, al
cmp eax, 0
jz short loc_FE297
mov [rbp+var_4], 0
jmp loc_FE541
loc_FE297:
mov rax, [rbp+var_38]
mov rax, [rax+8]
mov eax, [rax+18h]
mov [rbp+var_3C], eax
mov rax, [rbp+var_38]
mov rax, [rax+8]
mov rax, [rax+10h]
mov [rbp+var_50], rax
mov rax, [rbp+var_38]
mov rdi, [rax+8]
add rdi, 8
call _ZL17my_assume_alignedILm8EPPKhET0_S3_; my_assume_aligned<8ul,uchar const**>(uchar const**)
mov rax, [rbp+var_38]
mov rax, [rax+8]
mov rax, [rax+8]
mov [rbp+var_70], rax
mov rax, [rbp+var_70]
mov [rbp+var_48], rax
loc_FE2DE:
mov rax, [rbp+var_38]
mov rax, [rax+8]
mov rax, [rax]
mov [rbp+var_78], rax
mov rax, [rbp+var_78]
mov [rbp+var_58], rax
mov rdi, [rbp+var_58]
and rdi, 0FFFFFFFFFFFFFFFEh
call _ZL17my_assume_alignedILm8EP8LF_SLISTET0_S2_; my_assume_aligned<8ul,LF_SLIST *>(LF_SLIST *)
mov rcx, rax
mov rax, [rbp+var_38]
mov [rax+10h], rcx
jmp short $+2
loc_FE30F:
jmp short $+2
loc_FE311:
mov rcx, [rbp+arg_0]
mov rax, [rbp+var_38]
mov rax, [rax+10h]
mov [rbp+var_80], rax
mov rax, [rbp+var_80]
xchg rax, [rcx]
jmp short $+2
loc_FE32A:
mov rcx, [rbp+var_58]
mov rax, [rbp+var_38]
mov rax, [rax+8]
mov rax, [rax]
mov [rbp+var_88], rax
mov rdx, [rbp+var_88]
xor eax, eax
cmp rcx, rdx
mov [rbp+var_B2], al
jz short loc_FE365
call _ZL10LF_BACKOFFv; LF_BACKOFF(void)
cmp eax, 0
setnz al
mov [rbp+var_B2], al
loc_FE365:
mov al, [rbp+var_B2]
test al, 1
jnz loc_FE2DE
mov rax, [rbp+var_58]
and rax, 1
cmp rax, 0
jnz loc_FE477
cmp [rbp+arg_8], 0
jz short loc_FE3BF
mov eax, [rbp+var_3C]
and eax, 1
cmp eax, 0
jz short loc_FE3BD
mov rax, [rbp+arg_8]
mov rcx, [rbp+var_38]
mov rdi, [rcx+8]
add rdi, 20h ; ' '
mov rsi, [rbp+var_28]
call rax
cmp al, 0
jz short loc_FE3BD
mov [rbp+var_4], 1
jmp loc_FE541
loc_FE3BD:
jmp short loc_FE429
loc_FE3BF:
mov eax, [rbp+var_3C]
cmp eax, [rbp+var_1C]
jb short loc_FE427
mov [rbp+var_8C], 1
mov eax, [rbp+var_3C]
cmp eax, [rbp+var_1C]
ja short loc_FE40C
mov rax, [rbp+var_18]
mov rax, [rax+0C0h]
mov rax, [rax+8]
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_48]
mov rdx, [rbp+var_50]
mov rcx, [rbp+var_28]
mov r8, [rbp+var_30]
xor r9d, r9d
call rax
mov [rbp+var_8C], eax
cmp eax, 0
jl short loc_FE425
loc_FE40C:
cmp [rbp+var_8C], 0
setnz al
xor al, 0FFh
and al, 1
movzx eax, al
mov [rbp+var_4], eax
jmp loc_FE541
loc_FE425:
jmp short $+2
loc_FE427:
jmp short $+2
loc_FE429:
mov rax, [rbp+var_38]
mov rcx, [rax+8]
mov rax, [rbp+var_38]
mov [rax], rcx
mov eax, [rbp+var_3C]
and eax, 1
cmp eax, 0
jnz short loc_FE44E
mov rax, [rbp+var_38]
mov rax, [rax]
mov [rbp+var_10], rax
loc_FE44E:
jmp short $+2
loc_FE450:
jmp short $+2
loc_FE452:
jmp short $+2
loc_FE454:
mov rcx, [rbp+arg_0]
mov rax, [rbp+var_38]
mov rax, [rax+8]
mov [rbp+var_98], rax
mov rax, [rbp+var_98]
xchg rax, [rcx+10h]
jmp loc_FE50A
loc_FE477:
mov rax, [rbp+var_38]
mov rcx, rax
add rcx, 8
mov [rbp+var_D0], rcx
mov rcx, [rax]
mov rdx, [rax+10h]
mov [rbp+var_A0], rdx
mov rax, [rax+8]
mov rdx, [rbp+var_A0]
lock cmpxchg [rcx], rdx
mov rcx, rax
setz al
mov [rbp+var_C1], al
mov [rbp+var_C0], rcx
test al, 1
jnz short loc_FE4CF
mov rax, [rbp+var_D0]
mov rcx, [rbp+var_C0]
mov [rax], rcx
loc_FE4CF:
mov al, [rbp+var_C1]
and al, 1
mov [rbp+var_A1], al
test [rbp+var_A1], 1
jz short loc_FE503
call _ZL10LF_BACKOFFv; LF_BACKOFF(void)
cmp eax, 0
jz short loc_FE503
mov rdi, [rbp+arg_0]
mov rax, [rbp+var_38]
mov rsi, [rax+8]
call lf_pinbox_free
jmp short loc_FE508
loc_FE503:
jmp loc_FE1E2
loc_FE508:
jmp short $+2
loc_FE50A:
mov rax, [rbp+var_38]
mov rcx, [rax+10h]
mov rax, [rbp+var_38]
mov [rax+8], rcx
jmp short $+2
loc_FE51C:
jmp short $+2
loc_FE51E:
mov rcx, [rbp+arg_0]
mov rax, [rbp+var_38]
mov rax, [rax+8]
mov [rbp+var_B0], rax
mov rax, [rbp+var_B0]
xchg rax, [rcx+8]
jmp loc_FE273
loc_FE541:
mov eax, [rbp+var_4]
add rsp, 0D0h
pop rbp
retn
|
_BOOL8 l_find(
volatile signed long long *a1,
long long a2,
unsigned int a3,
long long a4,
long long a5,
volatile signed long long **a6,
volatile long long *a7,
unsigned __int8 ( *a8)(volatile signed long long *, long long))
{
signed long long v8; // rtt
signed long long v9; // rcx
bool v11; // [rsp+Fh] [rbp-C1h]
bool v12; // [rsp+1Eh] [rbp-B2h]
bool v13; // [rsp+1Fh] [rbp-B1h]
int v14; // [rsp+44h] [rbp-8Ch]
long long v15; // [rsp+78h] [rbp-58h]
long long v16; // [rsp+80h] [rbp-50h]
long long v17; // [rsp+88h] [rbp-48h]
unsigned int v18; // [rsp+94h] [rbp-3Ch]
LABEL_1:
*a6 = (volatile signed long long *)my_assume_aligned<8ul,LF_SLIST **>(a1);
do
{
a6[1] = (volatile signed long long *)my_assume_aligned<8ul,LF_SLIST *>(**a6);
_InterlockedExchange64(a7 + 1, (long long)a6[1]);
v13 = 0;
if ( *(volatile signed long long **)my_assume_aligned<8ul,unsigned long *>(*a6) != a6[1] )
v13 = (unsigned int)LF_BACKOFF() != 0;
}
while ( v13 );
while ( 1 )
{
if ( !a6[1] )
return 0;
v18 = *((_DWORD *)a6[1] + 6);
v16 = *((_QWORD *)a6[1] + 2);
my_assume_aligned<8ul,unsigned char const**>(a6[1] + 1);
v17 = *((_QWORD *)a6[1] + 1);
do
{
v15 = *a6[1];
a6[2] = (volatile signed long long *)my_assume_aligned<8ul,LF_SLIST *>(v15 & 0xFFFFFFFFFFFFFFFELL);
_InterlockedExchange64(a7, (long long)a6[2]);
v12 = 0;
if ( v15 != *a6[1] )
v12 = (unsigned int)LF_BACKOFF() != 0;
}
while ( v12 );
if ( (v15 & 1) == 0 )
break;
v8 = (signed long long)a6[1];
v9 = _InterlockedCompareExchange64(*a6, (signed long long)a6[2], v8);
v11 = v8 == v9;
if ( v8 != v9 )
a6[1] = (volatile signed long long *)v9;
if ( !v11 || !(unsigned int)LF_BACKOFF() )
goto LABEL_1;
lf_pinbox_free((long long)a7, (const char *)a6[1]);
LABEL_30:
a6[1] = a6[2];
_InterlockedExchange64(a7 + 1, (long long)a6[1]);
}
if ( a8 )
{
if ( (v18 & 1) != 0 && a8(a6[1] + 4, a4) )
return 1;
goto LABEL_21;
}
if ( v18 < a3
|| (v14 = 1, v18 <= a3)
&& (v14 = (*(long long ( **)(long long, long long, long long, long long, long long, _QWORD))(*(_QWORD *)(a2 + 192)
+ 8LL))(
a2,
v17,
v16,
a4,
a5,
0LL),
v14 < 0) )
{
LABEL_21:
*a6 = a6[1];
if ( (v18 & 1) == 0 )
a1 = *a6;
_InterlockedExchange64(a7 + 2, (long long)a6[1]);
goto LABEL_30;
}
return v14 == 0;
}
|
l_find:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xd0
MOV RAX,qword ptr [RBP + 0x18]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV qword ptr [RBP + -0x38],R9
JMP 0x001fe1dc
LAB_001fe1dc:
JMP 0x001fe1de
LAB_001fe1de:
JMP 0x001fe1e0
LAB_001fe1e0:
JMP 0x001fe1e2
LAB_001fe1e2:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001fe610
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX],RCX
LAB_001fe1f5:
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX]
CALL 0x001fe620
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x8],RCX
JMP 0x001fe211
LAB_001fe211:
JMP 0x001fe213
LAB_001fe213:
MOV RCX,qword ptr [RBP + 0x10]
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x60]
XCHG qword ptr [RCX + 0x8],RAX
JMP 0x001fe22d
LAB_001fe22d:
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,qword ptr [RAX]
CALL 0x001fe630
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x68],RAX
MOV RCX,qword ptr [RBP + -0x68]
MOV RDX,qword ptr [RBP + -0x38]
XOR EAX,EAX
CMP RCX,qword ptr [RDX + 0x8]
MOV byte ptr [RBP + -0xb1],AL
JZ 0x001fe267
CALL 0x001fe640
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0xb1],AL
LAB_001fe267:
MOV AL,byte ptr [RBP + -0xb1]
TEST AL,0x1
JNZ 0x001fe1f5
JMP 0x001fe273
LAB_001fe273:
MOV RAX,qword ptr [RBP + -0x38]
CMP qword ptr [RAX + 0x8],0x0
SETNZ AL
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x001fe297
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001fe541
LAB_001fe297:
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
MOV EAX,dword ptr [RAX + 0x18]
MOV dword ptr [RBP + -0x3c],EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,qword ptr [RAX + 0x8]
ADD RDI,0x8
CALL 0x001fe680
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x70],RAX
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RBP + -0x48],RAX
LAB_001fe2de:
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,qword ptr [RBP + -0x78]
MOV qword ptr [RBP + -0x58],RAX
MOV RDI,qword ptr [RBP + -0x58]
AND RDI,-0x2
CALL 0x001fe620
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x10],RCX
JMP 0x001fe30f
LAB_001fe30f:
JMP 0x001fe311
LAB_001fe311:
MOV RCX,qword ptr [RBP + 0x10]
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x80],RAX
MOV RAX,qword ptr [RBP + -0x80]
XCHG qword ptr [RCX],RAX
JMP 0x001fe32a
LAB_001fe32a:
MOV RCX,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x88],RAX
MOV RDX,qword ptr [RBP + -0x88]
XOR EAX,EAX
CMP RCX,RDX
MOV byte ptr [RBP + -0xb2],AL
JZ 0x001fe365
CALL 0x001fe640
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0xb2],AL
LAB_001fe365:
MOV AL,byte ptr [RBP + -0xb2]
TEST AL,0x1
JNZ 0x001fe2de
MOV RAX,qword ptr [RBP + -0x58]
AND RAX,0x1
CMP RAX,0x0
JNZ 0x001fe477
CMP qword ptr [RBP + 0x18],0x0
JZ 0x001fe3bf
MOV EAX,dword ptr [RBP + -0x3c]
AND EAX,0x1
CMP EAX,0x0
JZ 0x001fe3bd
MOV RAX,qword ptr [RBP + 0x18]
MOV RCX,qword ptr [RBP + -0x38]
MOV RDI,qword ptr [RCX + 0x8]
ADD RDI,0x20
MOV RSI,qword ptr [RBP + -0x28]
CALL RAX
CMP AL,0x0
JZ 0x001fe3bd
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001fe541
LAB_001fe3bd:
JMP 0x001fe429
LAB_001fe3bf:
MOV EAX,dword ptr [RBP + -0x3c]
CMP EAX,dword ptr [RBP + -0x1c]
JC 0x001fe427
MOV dword ptr [RBP + -0x8c],0x1
MOV EAX,dword ptr [RBP + -0x3c]
CMP EAX,dword ptr [RBP + -0x1c]
JA 0x001fe40c
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0xc0]
MOV RAX,qword ptr [RAX + 0x8]
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RBP + -0x50]
MOV RCX,qword ptr [RBP + -0x28]
MOV R8,qword ptr [RBP + -0x30]
XOR R9D,R9D
CALL RAX
MOV dword ptr [RBP + -0x8c],EAX
CMP EAX,0x0
JL 0x001fe425
LAB_001fe40c:
CMP dword ptr [RBP + -0x8c],0x0
SETNZ AL
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001fe541
LAB_001fe425:
JMP 0x001fe427
LAB_001fe427:
JMP 0x001fe429
LAB_001fe429:
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX],RCX
MOV EAX,dword ptr [RBP + -0x3c]
AND EAX,0x1
CMP EAX,0x0
JNZ 0x001fe44e
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x10],RAX
LAB_001fe44e:
JMP 0x001fe450
LAB_001fe450:
JMP 0x001fe452
LAB_001fe452:
JMP 0x001fe454
LAB_001fe454:
MOV RCX,qword ptr [RBP + 0x10]
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x98],RAX
MOV RAX,qword ptr [RBP + -0x98]
XCHG qword ptr [RCX + 0x10],RAX
JMP 0x001fe50a
LAB_001fe477:
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,RAX
ADD RCX,0x8
MOV qword ptr [RBP + -0xd0],RCX
MOV RCX,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0xa0],RDX
MOV RAX,qword ptr [RAX + 0x8]
MOV RDX,qword ptr [RBP + -0xa0]
CMPXCHG.LOCK qword ptr [RCX],RDX
MOV RCX,RAX
SETZ AL
MOV byte ptr [RBP + -0xc1],AL
MOV qword ptr [RBP + -0xc0],RCX
TEST AL,0x1
JNZ 0x001fe4cf
MOV RAX,qword ptr [RBP + -0xd0]
MOV RCX,qword ptr [RBP + -0xc0]
MOV qword ptr [RAX],RCX
LAB_001fe4cf:
MOV AL,byte ptr [RBP + -0xc1]
AND AL,0x1
MOV byte ptr [RBP + -0xa1],AL
TEST byte ptr [RBP + -0xa1],0x1
JZ 0x001fe503
CALL 0x001fe640
CMP EAX,0x0
JZ 0x001fe503
MOV RDI,qword ptr [RBP + 0x10]
MOV RAX,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RAX + 0x8]
CALL 0x001fc740
JMP 0x001fe508
LAB_001fe503:
JMP 0x001fe1e2
LAB_001fe508:
JMP 0x001fe50a
LAB_001fe50a:
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x8],RCX
JMP 0x001fe51c
LAB_001fe51c:
JMP 0x001fe51e
LAB_001fe51e:
MOV RCX,qword ptr [RBP + 0x10]
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0xb0],RAX
MOV RAX,qword ptr [RBP + -0xb0]
XCHG qword ptr [RCX + 0x8],RAX
JMP 0x001fe273
LAB_001fe541:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0xd0
POP RBP
RET
|
/* l_find(LF_SLIST**, charset_info_st const*, unsigned int, unsigned char const*, unsigned long,
CURSOR*, LF_PINS*, char (*)(void*, void*)) */
byte l_find(LF_SLIST **param_1,charset_info_st *param_2,uint param_3,uchar *param_4,ulong param_5,
CURSOR *param_6,LF_PINS *param_7,_func_char_void_ptr_void_ptr *param_8)
{
uint uVar1;
int8 uVar2;
int8 uVar3;
ulong uVar4;
long lVar5;
char cVar6;
int iVar7;
LF_SLIST **ppLVar8;
LF_SLIST *pLVar9;
ulong *puVar10;
long lVar11;
bool bVar12;
int local_94;
LF_SLIST **local_18;
local_18 = param_1;
LAB_001fe1e2:
ppLVar8 = my_assume_aligned<8ul,LF_SLIST**>(local_18);
*(LF_SLIST ***)param_6 = ppLVar8;
do {
pLVar9 = my_assume_aligned<8ul,LF_SLIST*>((LF_SLIST *)**(int8 **)param_6);
*(LF_SLIST **)(param_6 + 8) = pLVar9;
LOCK();
*(int8 *)(param_7 + 8) = *(int8 *)(param_6 + 8);
UNLOCK();
puVar10 = my_assume_aligned<8ul,unsigned_long*>(*(ulong **)param_6);
bVar12 = false;
if (*puVar10 != *(ulong *)(param_6 + 8)) {
iVar7 = LF_BACKOFF();
bVar12 = iVar7 != 0;
}
} while (bVar12);
do {
if (*(long *)(param_6 + 8) == 0) {
return 0;
}
uVar1 = *(uint *)(*(long *)(param_6 + 8) + 0x18);
uVar2 = *(int8 *)(*(long *)(param_6 + 8) + 0x10);
my_assume_aligned<8ul,unsigned_char_const**>((uchar **)(*(long *)(param_6 + 8) + 8));
uVar3 = *(int8 *)(*(long *)(param_6 + 8) + 8);
do {
uVar4 = **(ulong **)(param_6 + 8);
pLVar9 = my_assume_aligned<8ul,LF_SLIST*>((LF_SLIST *)(uVar4 & 0xfffffffffffffffe));
*(LF_SLIST **)(param_6 + 0x10) = pLVar9;
LOCK();
*(int8 *)param_7 = *(int8 *)(param_6 + 0x10);
UNLOCK();
bVar12 = false;
if (uVar4 != **(ulong **)(param_6 + 8)) {
iVar7 = LF_BACKOFF();
bVar12 = iVar7 != 0;
}
} while (bVar12);
if ((uVar4 & 1) == 0) {
if (param_8 == (_func_char_void_ptr_void_ptr *)0x0) {
if ((param_3 <= uVar1) &&
((local_94 = 1, param_3 < uVar1 ||
(local_94 = (**(code **)(*(long *)(param_2 + 0xc0) + 8))
(param_2,uVar3,uVar2,param_4,param_5,0), -1 < local_94)))) {
return (local_94 != 0 ^ 0xffU) & 1;
}
}
else if (((uVar1 & 1) != 0) &&
(cVar6 = (*param_8)((void *)(*(long *)(param_6 + 8) + 0x20),param_4), cVar6 != '\0'))
{
return 1;
}
*(int8 *)param_6 = *(int8 *)(param_6 + 8);
if ((uVar1 & 1) == 0) {
local_18 = *(LF_SLIST ***)param_6;
}
LOCK();
*(int8 *)(param_7 + 0x10) = *(int8 *)(param_6 + 8);
UNLOCK();
}
else {
lVar5 = *(long *)(param_6 + 8);
LOCK();
lVar11 = **(long **)param_6;
bVar12 = lVar5 == lVar11;
if (bVar12) {
**(long **)param_6 = *(long *)(param_6 + 0x10);
lVar11 = lVar5;
}
UNLOCK();
if (!bVar12) {
*(long *)(param_6 + 8) = lVar11;
goto LAB_001fe1e2;
}
iVar7 = LF_BACKOFF();
if (iVar7 == 0) goto LAB_001fe1e2;
lf_pinbox_free(param_7,*(int8 *)(param_6 + 8));
}
*(int8 *)(param_6 + 8) = *(int8 *)(param_6 + 0x10);
LOCK();
*(int8 *)(param_7 + 8) = *(int8 *)(param_6 + 8);
UNLOCK();
} while( true );
}
|
|
60,613
|
l_find(LF_SLIST**, charset_info_st const*, unsigned int, unsigned char const*, unsigned long, CURSOR*, LF_PINS*, char (*)(void*, void*))
|
eloqsql/mysys/lf_hash.cc
|
static int l_find(LF_SLIST **head, CHARSET_INFO *cs, uint32 hashnr,
const uchar *key, size_t keylen, CURSOR *cursor, LF_PINS *pins,
my_hash_walk_action callback)
{
uint32 cur_hashnr;
const uchar *cur_key;
size_t cur_keylen;
intptr link;
DBUG_ASSERT(!cs || !callback); /* should not be set both */
DBUG_ASSERT(!keylen || !callback); /* should not be set both */
retry:
cursor->prev= (intptr *) my_assume_aligned<sizeof(intptr)>(head);
do { /* PTR() isn't necessary below, head is a dummy node */
cursor->curr= my_assume_aligned<sizeof(LF_SLIST *)>((LF_SLIST *)(*cursor->prev));
lf_pin(pins, 1, cursor->curr);
} while (my_atomic_loadptr(
(void **)my_assume_aligned<sizeof(LF_SLIST *)>(cursor->prev))
!= cursor->curr && LF_BACKOFF());
for (;;)
{
if (unlikely(!cursor->curr))
return 0; /* end of the list */
cur_hashnr= cursor->curr->hashnr;
cur_keylen= cursor->curr->keylen;
/* The key element needs to be aligned, not necessary what it points to */
my_assume_aligned<sizeof(const uchar *)>(&cursor->curr->key);
cur_key= (const uchar *) my_atomic_loadptr_explicit((void **) &cursor->curr->key,
MY_MEMORY_ORDER_ACQUIRE);
do {
/* attempting to my_assume_aligned onlink below broke the implementation */
link= (intptr) my_atomic_loadptr_explicit((void **) &cursor->curr->link,
MY_MEMORY_ORDER_RELAXED);
cursor->next= my_assume_aligned<sizeof(LF_SLIST *)>(PTR(link));
lf_pin(pins, 0, cursor->next);
} while (link != (intptr) my_atomic_loadptr((void *volatile *) &cursor->curr->link)
&& LF_BACKOFF());
if (!DELETED(link))
{
if (unlikely(callback))
{
if (cur_hashnr & 1 && callback(cursor->curr + 1, (void*)key))
return 1;
}
else if (cur_hashnr >= hashnr)
{
int r= 1;
if (cur_hashnr > hashnr ||
(r= my_strnncoll(cs, cur_key, cur_keylen, key, keylen)) >= 0)
return !r;
}
cursor->prev= &(cursor->curr->link);
if (!(cur_hashnr & 1)) /* dummy node */
head= (LF_SLIST **)cursor->prev;
lf_pin(pins, 2, cursor->curr);
}
else
{
/*
we found a deleted node - be nice, help the other thread
and remove this deleted node
*/
if (my_atomic_casptr((void **) cursor->prev,
(void **) &cursor->curr, cursor->next) && LF_BACKOFF())
lf_alloc_free(pins, cursor->curr);
else
goto retry;
}
cursor->curr= cursor->next;
lf_pin(pins, 1, cursor->curr);
}
}
|
O3
|
cpp
|
l_find(LF_SLIST**, charset_info_st const*, unsigned int, unsigned char const*, unsigned long, CURSOR*, LF_PINS*, char (*)(void*, void*)):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rbx
movq %r8, -0x48(%rbp)
movq %rcx, -0x38(%rbp)
movl %edx, -0x2c(%rbp)
movq %rsi, -0x40(%rbp)
movq %rdi, %r14
movq 0x10(%rbp), %r15
leaq 0x35650d(%rip), %r13 # 0x386018
movq %r14, (%rbx)
movq (%r14), %rax
movq %rax, 0x8(%rbx)
xchgq %rax, 0x8(%r15)
movq (%rbx), %rax
movq (%rax), %rcx
movq 0x8(%rbx), %rax
cmpq %rcx, %rax
je 0x2fb8c
movl (%r13), %eax
testl %eax, %eax
je 0x2fb36
pause
decl %eax
jne 0x2fb30
movq (%rbx), %rax
movq (%rax), %rax
jmp 0x2fb11
movl (%r13), %eax
testl %eax, %eax
je 0x2fb4c
pause
decl %eax
jne 0x2fb46
movq 0x8(%rbx), %rsi
movq %r15, %rdi
callq 0xa569b
movq 0x10(%rbx), %rax
movq %rax, 0x8(%rbx)
xchgq %rax, 0x8(%r15)
movq 0x8(%rbx), %rax
jmp 0x2fb8c
testb $0x1, %r12b
je 0x2fc02
movq 0x8(%rbx), %rdi
addq $0x20, %rdi
movq -0x38(%rbp), %rsi
callq *0x18(%rbp)
testb %al, %al
je 0x2fc02
jmp 0x2fc5a
testq %rax, %rax
je 0x2fc56
movl 0x18(%rax), %r12d
movq 0x10(%rax), %rdx
movq 0x8(%rax), %rsi
movq 0x8(%rbx), %rax
movq (%rax), %rax
movq %rax, %rcx
andq $-0x2, %rcx
movq %rcx, 0x10(%rbx)
xchgq %rcx, (%r15)
movq 0x8(%rbx), %rcx
movq (%rcx), %rcx
cmpq %rcx, %rax
je 0x2fbd2
movl (%r13), %eax
testl %eax, %eax
je 0x2fba1
pause
decl %eax
jne 0x2fbca
jmp 0x2fba1
testb $0x1, %al
jne 0x2fc1a
cmpq $0x0, 0x18(%rbp)
jne 0x2fb6a
cmpl -0x2c(%rbp), %r12d
jb 0x2fc02
ja 0x2fc39
movq -0x40(%rbp), %rdi
movq 0xc0(%rdi), %rax
movq -0x38(%rbp), %rcx
movq -0x48(%rbp), %r8
xorl %r9d, %r9d
callq *0x8(%rax)
testl %eax, %eax
jns 0x2fc3e
movq 0x8(%rbx), %rax
testb $0x1, %r12b
cmoveq %rax, %r14
movq %rax, (%rbx)
xchgq %rax, 0x10(%r15)
jmp 0x2fb58
movq 0x10(%rbx), %rcx
movq (%rbx), %rdx
movq 0x8(%rbx), %rax
lock
cmpxchgq %rcx, (%rdx)
je 0x2fb3e
movq %rax, 0x8(%rbx)
jmp 0x2fb0b
pushq $0x1
popq %rcx
jmp 0x2fc40
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x2fc47
pushq $0x1
popq %rax
jmp 0x2fc47
|
_ZL6l_findPP8LF_SLISTPK15charset_info_stjPKhmP6CURSORP7LF_PINSPFcPvSB_E:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rbx, r9
mov [rbp+var_48], r8
mov [rbp+var_38], rcx
mov [rbp+var_2C], edx
mov [rbp+var_40], rsi
mov r14, rdi
mov r15, [rbp+arg_0]
lea r13, my_cpu_relax_multiplier
loc_2FB0B:
mov [rbx], r14
mov rax, [r14]
loc_2FB11:
mov [rbx+8], rax
xchg rax, [r15+8]
mov rax, [rbx]
mov rcx, [rax]
mov rax, [rbx+8]
cmp rax, rcx
jz short loc_2FB8C
mov eax, [r13+0]
test eax, eax
jz short loc_2FB36
loc_2FB30:
pause
dec eax
jnz short loc_2FB30
loc_2FB36:
mov rax, [rbx]
mov rax, [rax]
jmp short loc_2FB11
loc_2FB3E:
mov eax, [r13+0]
test eax, eax
jz short loc_2FB4C
loc_2FB46:
pause
dec eax
jnz short loc_2FB46
loc_2FB4C:
mov rsi, [rbx+8]
mov rdi, r15
call lf_pinbox_free
loc_2FB58:
mov rax, [rbx+10h]
mov [rbx+8], rax
xchg rax, [r15+8]
mov rax, [rbx+8]
jmp short loc_2FB8C
loc_2FB6A:
test r12b, 1
jz loc_2FC02
mov rdi, [rbx+8]
add rdi, 20h ; ' '
mov rsi, [rbp+var_38]
call [rbp+arg_8]
test al, al
jz short loc_2FC02
jmp loc_2FC5A
loc_2FB8C:
test rax, rax
jz loc_2FC56
mov r12d, [rax+18h]
mov rdx, [rax+10h]
mov rsi, [rax+8]
loc_2FBA1:
mov rax, [rbx+8]
mov rax, [rax]
mov rcx, rax
and rcx, 0FFFFFFFFFFFFFFFEh
mov [rbx+10h], rcx
xchg rcx, [r15]
mov rcx, [rbx+8]
mov rcx, [rcx]
cmp rax, rcx
jz short loc_2FBD2
mov eax, [r13+0]
test eax, eax
jz short loc_2FBA1
loc_2FBCA:
pause
dec eax
jnz short loc_2FBCA
jmp short loc_2FBA1
loc_2FBD2:
test al, 1
jnz short loc_2FC1A
cmp [rbp+arg_8], 0
jnz short loc_2FB6A
cmp r12d, [rbp+var_2C]
jb short loc_2FC02
ja short loc_2FC39
mov rdi, [rbp+var_40]
mov rax, [rdi+0C0h]
mov rcx, [rbp+var_38]
mov r8, [rbp+var_48]
xor r9d, r9d
call qword ptr [rax+8]
test eax, eax
jns short loc_2FC3E
loc_2FC02:
mov rax, [rbx+8]
test r12b, 1
cmovz r14, rax
mov [rbx], rax
xchg rax, [r15+10h]
jmp loc_2FB58
loc_2FC1A:
mov rcx, [rbx+10h]
mov rdx, [rbx]
mov rax, [rbx+8]
lock cmpxchg [rdx], rcx
jz loc_2FB3E
mov [rbx+8], rax
jmp loc_2FB0B
loc_2FC39:
push 1
pop rcx
jmp short loc_2FC40
loc_2FC3E:
mov ecx, eax
loc_2FC40:
xor eax, eax
test ecx, ecx
setz al
loc_2FC47:
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_2FC56:
xor eax, eax
jmp short loc_2FC47
loc_2FC5A:
push 1
pop rax
jmp short loc_2FC47
|
long long l_find(
long long *a1,
long long a2,
unsigned int a3,
long long a4,
long long a5,
long long a6,
volatile long long *a7,
unsigned __int8 ( *a8)(long long, long long))
{
long long i; // rax
long long v11; // rax
int j; // eax
int m; // eax
long long v14; // rax
unsigned int v15; // r12d
long long v16; // rdx
long long v17; // rsi
long long v18; // rax
int k; // eax
int v20; // eax
long long v21; // rax
signed long long v22; // rax
signed long long v23; // rtt
int v24; // ecx
LABEL_1:
*(_QWORD *)a6 = a1;
for ( i = *a1; ; i = **(_QWORD **)a6 )
{
*(_QWORD *)(a6 + 8) = i;
_InterlockedExchange64(a7 + 1, i);
v11 = *(_QWORD *)(a6 + 8);
if ( v11 == **(_QWORD **)a6 )
break;
for ( j = my_cpu_relax_multiplier; j; --j )
_mm_pause();
}
while ( v11 )
{
v15 = *(_DWORD *)(v11 + 24);
v16 = *(_QWORD *)(v11 + 16);
v17 = *(_QWORD *)(v11 + 8);
while ( 1 )
{
v18 = **(_QWORD **)(a6 + 8);
*(_QWORD *)(a6 + 16) = v18 & 0xFFFFFFFFFFFFFFFELL;
_InterlockedExchange64(a7, v18 & 0xFFFFFFFFFFFFFFFELL);
if ( v18 == **(_QWORD **)(a6 + 8) )
break;
for ( k = my_cpu_relax_multiplier; k; --k )
_mm_pause();
}
if ( (v18 & 1) != 0 )
{
v23 = *(_QWORD *)(a6 + 8);
v22 = _InterlockedCompareExchange64(*(volatile signed long long **)a6, *(_QWORD *)(a6 + 16), v23);
if ( v23 != v22 )
{
*(_QWORD *)(a6 + 8) = v22;
goto LABEL_1;
}
for ( m = my_cpu_relax_multiplier; m; --m )
_mm_pause();
lf_pinbox_free(a7, *(_QWORD *)(a6 + 8));
}
else
{
if ( a8 )
{
if ( (v15 & 1) != 0 && a8(*(_QWORD *)(a6 + 8) + 32LL, a4) )
return 1LL;
}
else if ( v15 >= a3 )
{
if ( v15 > a3 )
{
v24 = 1;
return v24 == 0;
}
v20 = (*(long long ( **)(long long, long long, long long, long long, long long, _QWORD))(*(_QWORD *)(a2 + 192)
+ 8LL))(
a2,
v17,
v16,
a4,
a5,
0LL);
if ( v20 >= 0 )
{
v24 = v20;
return v24 == 0;
}
}
v21 = *(_QWORD *)(a6 + 8);
if ( (v15 & 1) == 0 )
a1 = *(long long **)(a6 + 8);
*(_QWORD *)a6 = v21;
_InterlockedExchange64(a7 + 2, v21);
}
v14 = *(_QWORD *)(a6 + 16);
*(_QWORD *)(a6 + 8) = v14;
_InterlockedExchange64(a7 + 1, v14);
v11 = *(_QWORD *)(a6 + 8);
}
return 0LL;
}
|
l_find:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RBX,R9
MOV qword ptr [RBP + -0x48],R8
MOV qword ptr [RBP + -0x38],RCX
MOV dword ptr [RBP + -0x2c],EDX
MOV qword ptr [RBP + -0x40],RSI
MOV R14,RDI
MOV R15,qword ptr [RBP + 0x10]
LEA R13,[0x486018]
LAB_0012fb0b:
MOV qword ptr [RBX],R14
MOV RAX,qword ptr [R14]
LAB_0012fb11:
MOV qword ptr [RBX + 0x8],RAX
XCHG qword ptr [R15 + 0x8],RAX
MOV RAX,qword ptr [RBX]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBX + 0x8]
CMP RAX,RCX
JZ 0x0012fb8c
MOV EAX,dword ptr [R13]
TEST EAX,EAX
JZ 0x0012fb36
LAB_0012fb30:
PAUSE
DEC EAX
JNZ 0x0012fb30
LAB_0012fb36:
MOV RAX,qword ptr [RBX]
MOV RAX,qword ptr [RAX]
JMP 0x0012fb11
LAB_0012fb3e:
MOV EAX,dword ptr [R13]
TEST EAX,EAX
JZ 0x0012fb4c
LAB_0012fb46:
PAUSE
DEC EAX
JNZ 0x0012fb46
LAB_0012fb4c:
MOV RSI,qword ptr [RBX + 0x8]
MOV RDI,R15
CALL 0x001a569b
LAB_0012fb58:
MOV RAX,qword ptr [RBX + 0x10]
MOV qword ptr [RBX + 0x8],RAX
XCHG qword ptr [R15 + 0x8],RAX
MOV RAX,qword ptr [RBX + 0x8]
JMP 0x0012fb8c
LAB_0012fb6a:
TEST R12B,0x1
JZ 0x0012fc02
MOV RDI,qword ptr [RBX + 0x8]
ADD RDI,0x20
MOV RSI,qword ptr [RBP + -0x38]
CALL qword ptr [RBP + 0x18]
TEST AL,AL
JZ 0x0012fc02
JMP 0x0012fc5a
LAB_0012fb8c:
TEST RAX,RAX
JZ 0x0012fc56
MOV R12D,dword ptr [RAX + 0x18]
MOV RDX,qword ptr [RAX + 0x10]
MOV RSI,qword ptr [RAX + 0x8]
LAB_0012fba1:
MOV RAX,qword ptr [RBX + 0x8]
MOV RAX,qword ptr [RAX]
MOV RCX,RAX
AND RCX,-0x2
MOV qword ptr [RBX + 0x10],RCX
XCHG qword ptr [R15],RCX
MOV RCX,qword ptr [RBX + 0x8]
MOV RCX,qword ptr [RCX]
CMP RAX,RCX
JZ 0x0012fbd2
MOV EAX,dword ptr [R13]
TEST EAX,EAX
JZ 0x0012fba1
LAB_0012fbca:
PAUSE
DEC EAX
JNZ 0x0012fbca
JMP 0x0012fba1
LAB_0012fbd2:
TEST AL,0x1
JNZ 0x0012fc1a
CMP qword ptr [RBP + 0x18],0x0
JNZ 0x0012fb6a
CMP R12D,dword ptr [RBP + -0x2c]
JC 0x0012fc02
JA 0x0012fc39
MOV RDI,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RDI + 0xc0]
MOV RCX,qword ptr [RBP + -0x38]
MOV R8,qword ptr [RBP + -0x48]
XOR R9D,R9D
CALL qword ptr [RAX + 0x8]
TEST EAX,EAX
JNS 0x0012fc3e
LAB_0012fc02:
MOV RAX,qword ptr [RBX + 0x8]
TEST R12B,0x1
CMOVZ R14,RAX
MOV qword ptr [RBX],RAX
XCHG qword ptr [R15 + 0x10],RAX
JMP 0x0012fb58
LAB_0012fc1a:
MOV RCX,qword ptr [RBX + 0x10]
MOV RDX,qword ptr [RBX]
MOV RAX,qword ptr [RBX + 0x8]
CMPXCHG.LOCK qword ptr [RDX],RCX
JZ 0x0012fb3e
MOV qword ptr [RBX + 0x8],RAX
JMP 0x0012fb0b
LAB_0012fc39:
PUSH 0x1
POP RCX
JMP 0x0012fc40
LAB_0012fc3e:
MOV ECX,EAX
LAB_0012fc40:
XOR EAX,EAX
TEST ECX,ECX
SETZ AL
LAB_0012fc47:
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0012fc56:
XOR EAX,EAX
JMP 0x0012fc47
LAB_0012fc5a:
PUSH 0x1
POP RAX
JMP 0x0012fc47
|
/* l_find(LF_SLIST**, charset_info_st const*, unsigned int, unsigned char const*, unsigned long,
CURSOR*, LF_PINS*, char (*)(void*, void*)) */
bool l_find(LF_SLIST **param_1,charset_info_st *param_2,uint param_3,uchar *param_4,ulong param_5,
CURSOR *param_6,LF_PINS *param_7,_func_char_void_ptr_void_ptr *param_8)
{
uint uVar1;
int8 uVar2;
int8 uVar3;
ulong uVar4;
LF_SLIST **ppLVar5;
long lVar6;
char cVar7;
int iVar8;
LF_SLIST *pLVar9;
long lVar10;
bool bVar11;
LAB_0012fb0b:
*(LF_SLIST ***)param_6 = param_1;
pLVar9 = *param_1;
while( true ) {
*(LF_SLIST **)(param_6 + 8) = pLVar9;
LOCK();
*(LF_SLIST **)(param_7 + 8) = pLVar9;
UNLOCK();
lVar10 = *(long *)(param_6 + 8);
iVar8 = my_cpu_relax_multiplier;
if (lVar10 == **(long **)param_6) break;
for (; iVar8 != 0; iVar8 = iVar8 + -1) {
}
pLVar9 = (LF_SLIST *)**(int8 **)param_6;
}
do {
if (lVar10 == 0) {
return false;
}
uVar1 = *(uint *)(lVar10 + 0x18);
uVar2 = *(int8 *)(lVar10 + 0x10);
uVar3 = *(int8 *)(lVar10 + 8);
while( true ) {
uVar4 = **(ulong **)(param_6 + 8);
*(ulong *)(param_6 + 0x10) = uVar4 & 0xfffffffffffffffe;
LOCK();
*(ulong *)param_7 = uVar4 & 0xfffffffffffffffe;
UNLOCK();
iVar8 = my_cpu_relax_multiplier;
if (uVar4 == **(ulong **)(param_6 + 8)) break;
for (; iVar8 != 0; iVar8 = iVar8 + -1) {
}
}
if ((uVar4 & 1) == 0) {
if (param_8 == (_func_char_void_ptr_void_ptr *)0x0) {
if (param_3 <= uVar1) {
if (param_3 < uVar1) {
iVar8 = 1;
LAB_0012fc40:
return iVar8 == 0;
}
iVar8 = (**(code **)(*(long *)(param_2 + 0xc0) + 8))
(param_2,uVar3,uVar2,param_4,param_5,0);
if (-1 < iVar8) goto LAB_0012fc40;
}
}
else if (((uVar1 & 1) != 0) &&
(cVar7 = (*param_8)((void *)(*(long *)(param_6 + 8) + 0x20),param_4), cVar7 != '\0'))
{
return true;
}
ppLVar5 = *(LF_SLIST ***)(param_6 + 8);
if ((uVar1 & 1) == 0) {
param_1 = ppLVar5;
}
*(LF_SLIST ***)param_6 = ppLVar5;
LOCK();
*(LF_SLIST ***)(param_7 + 0x10) = ppLVar5;
UNLOCK();
}
else {
lVar6 = *(long *)(param_6 + 8);
LOCK();
lVar10 = **(long **)param_6;
bVar11 = lVar6 == lVar10;
if (bVar11) {
**(long **)param_6 = *(long *)(param_6 + 0x10);
lVar10 = lVar6;
}
UNLOCK();
iVar8 = my_cpu_relax_multiplier;
if (!bVar11) break;
for (; iVar8 != 0; iVar8 = iVar8 + -1) {
}
lf_pinbox_free(param_7,*(int8 *)(param_6 + 8));
}
*(int8 *)(param_6 + 8) = *(int8 *)(param_6 + 0x10);
LOCK();
*(int8 *)(param_7 + 8) = *(int8 *)(param_6 + 0x10);
UNLOCK();
lVar10 = *(long *)(param_6 + 8);
} while( true );
*(long *)(param_6 + 8) = lVar10;
goto LAB_0012fb0b;
}
|
|
60,614
|
nglog::tools::GetHex(char const*, char const*, unsigned long*)
|
ng-log[P]ng-log/src/symbolize.cc
|
static char* GetHex(const char* start, const char* end, uint64_t* hex) {
*hex = 0;
const char* p;
for (p = start; p < end; ++p) {
int ch = *p;
if ((ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'F') ||
(ch >= 'a' && ch <= 'f')) {
*hex = (*hex << 4U) |
(ch < 'A' ? static_cast<uint64_t>(ch - '0') : (ch & 0xF) + 9U);
} else { // Encountered the first non-hex character.
break;
}
}
NGLOG_SAFE_ASSERT(p <= end);
return const_cast<char*>(p);
}
|
O2
|
cpp
|
nglog::tools::GetHex(char const*, char const*, unsigned long*):
pushq %rax
andq $0x0, (%rdx)
xorl %eax, %eax
movabsq $0x3f0000003f, %rcx # imm = 0x3F0000003F
cmpq %rsi, %rdi
jae 0x1d286
movb (%rdi), %r8b
leal -0x30(%r8), %r9d
cmpb $0xa, %r9b
jb 0x1d25c
movzbl %r8b, %r9d
addl $-0x41, %r9d
cmpl $0x25, %r9d
ja 0x1d286
btq %r9, %rcx
jae 0x1d286
movsbl %r8b, %r9d
shlq $0x4, %rax
leal -0x30(%r9), %r10d
andl $0xf, %r9d
addl $0x9, %r9d
cmpb $0x41, %r8b
movslq %r10d, %r8
cmovbq %r8, %r9
orq %r9, %rax
movq %rax, (%rdx)
incq %rdi
jmp 0x1d236
cmpq %rsi, %rdi
ja 0x1d290
movq %rdi, %rax
popq %rcx
retq
callq 0x7320
nop
|
_ZN5nglog5toolsL6GetHexEPKcS2_Pm:
push rax
and qword ptr [rdx], 0
xor eax, eax
mov rcx, 3F0000003Fh
loc_1D236:
cmp rdi, rsi
jnb short loc_1D286
mov r8b, [rdi]
lea r9d, [r8-30h]
cmp r9b, 0Ah
jb short loc_1D25C
movzx r9d, r8b
add r9d, 0FFFFFFBFh
cmp r9d, 25h ; '%'
ja short loc_1D286
bt rcx, r9
jnb short loc_1D286
loc_1D25C:
movsx r9d, r8b
shl rax, 4
lea r10d, [r9-30h]
and r9d, 0Fh
add r9d, 9
cmp r8b, 41h ; 'A'
movsxd r8, r10d
cmovb r9, r8
or rax, r9
mov [rdx], rax
inc rdi
jmp short loc_1D236
loc_1D286:
cmp rdi, rsi
ja short loc_1D290
mov rax, rdi
pop rcx
retn
loc_1D290:
call _abort
|
nglog::tools * nglog::tools::GetHex(nglog::tools *this, nglog::tools *a2, char *a3, unsigned long long *a4)
{
long long v4; // rax
long long v5; // rcx
unsigned __int8 v6; // r8
unsigned long long v7; // r9
long long v8; // rax
long long v9; // r9
*(_QWORD *)a3 = 0LL;
v4 = 0LL;
v5 = 0x3F0000003FLL;
while ( this < a2 )
{
v6 = *(_BYTE *)this;
if ( (unsigned __int8)(*(_BYTE *)this - 48) >= 0xAu )
{
v7 = (unsigned int)v6 - 65;
if ( (unsigned int)v7 > 0x25 || !_bittest64(&v5, v7) )
break;
}
v8 = 16 * v4;
v9 = ((char)v6 & 0xFu) + 9;
if ( v6 < 0x41u )
v9 = (char)v6 - 48;
v4 = v9 | v8;
*(_QWORD *)a3 = v4;
this = (nglog::tools *)((char *)this + 1);
}
if ( this > a2 )
abort(this);
return this;
}
|
GetHex:
PUSH RAX
AND qword ptr [RDX],0x0
XOR EAX,EAX
MOV RCX,0x3f0000003f
LAB_0011d236:
CMP RDI,RSI
JNC 0x0011d286
MOV R8B,byte ptr [RDI]
LEA R9D,[R8 + -0x30]
CMP R9B,0xa
JC 0x0011d25c
MOVZX R9D,R8B
ADD R9D,-0x41
CMP R9D,0x25
JA 0x0011d286
BT RCX,R9
JNC 0x0011d286
LAB_0011d25c:
MOVSX R9D,R8B
SHL RAX,0x4
LEA R10D,[R9 + -0x30]
AND R9D,0xf
ADD R9D,0x9
CMP R8B,0x41
MOVSXD R8,R10D
CMOVC R9,R8
OR RAX,R9
MOV qword ptr [RDX],RAX
INC RDI
JMP 0x0011d236
LAB_0011d286:
CMP RDI,RSI
JA 0x0011d290
MOV RAX,RDI
POP RCX
RET
LAB_0011d290:
CALL 0x00107320
|
/* nglog::tools::GetHex(char const*, char const*, unsigned long*) */
byte * nglog::tools::GetHex(char *param_1,char *param_2,ulong *param_3)
{
byte bVar1;
ulong uVar2;
ulong uVar3;
*param_3 = 0;
uVar2 = 0;
while ((param_1 < param_2 &&
((bVar1 = *param_1, (byte)(bVar1 - 0x30) < 10 ||
((bVar1 - 0x41 < 0x26 && ((0x3f0000003fU >> ((ulong)(bVar1 - 0x41) & 0x3f) & 1) != 0))))))
) {
uVar3 = (ulong)(((int)(char)bVar1 & 0xfU) + 9);
if (bVar1 < 0x41) {
uVar3 = (long)(int)((int)(char)bVar1 - 0x30);
}
uVar2 = uVar2 << 4 | uVar3;
*param_3 = uVar2;
param_1 = (char *)((byte *)param_1 + 1);
}
if (param_1 <= param_2) {
return (byte *)param_1;
}
/* WARNING: Subroutine does not return */
abort();
}
|
|
60,615
|
ggml_graph_compute_poll_for_work
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c
|
static inline bool ggml_graph_compute_poll_for_work(struct ggml_compute_state * state) {
struct ggml_threadpool * threadpool = state->threadpool;
// Skip polling for unused threads
if (!ggml_graph_compute_thread_active(state)) {
return state->pending;
}
// This seems to make 0 ... 100 a decent range for polling level across modern processors.
// Perhaps, we can adjust it dynamically based on load and things.
const uint64_t n_rounds = 1024UL * 128 * threadpool->poll;
for (uint64_t i=0; !ggml_graph_compute_thread_ready(state) && i < n_rounds; i++) {
// No new work. Keep polling.
ggml_thread_cpu_relax();
}
return state->pending;
}
|
O0
|
c
|
ggml_graph_compute_poll_for_work:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x210(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x13680
testb $0x1, %al
jne 0x13549
movq -0x10(%rbp), %rax
movb 0x20c(%rax), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x135b1
movq -0x18(%rbp), %rax
movl 0xe4(%rax), %eax
shlq $0x11, %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x135d0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x29(%rbp)
jne 0x13586
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
setb %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x1358f
jmp 0x135a2
callq 0xe980
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x13563
movq -0x10(%rbp), %rax
movb 0x20c(%rax), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
|
ggml_graph_compute_poll_for_work:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov rax, [rax+210h]
mov [rbp+var_18], rax
mov rdi, [rbp+var_10]
call ggml_graph_compute_thread_active
test al, 1
jnz short loc_13549
mov rax, [rbp+var_10]
mov al, [rax+20Ch]
and al, 1
mov [rbp+var_1], al
jmp short loc_135B1
loc_13549:
mov rax, [rbp+var_18]
mov eax, [rax+0E4h]
shl rax, 11h
mov [rbp+var_20], rax
mov [rbp+var_28], 0
loc_13563:
mov rdi, [rbp+var_10]
call ggml_graph_compute_thread_ready
mov cl, al
xor eax, eax
test cl, 1
mov [rbp+var_29], al
jnz short loc_13586
mov rax, [rbp+var_28]
cmp rax, [rbp+var_20]
setb al
mov [rbp+var_29], al
loc_13586:
mov al, [rbp+var_29]
test al, 1
jnz short loc_1358F
jmp short loc_135A2
loc_1358F:
call ggml_thread_cpu_relax
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
jmp short loc_13563
loc_135A2:
mov rax, [rbp+var_10]
mov al, [rax+20Ch]
and al, 1
mov [rbp+var_1], al
loc_135B1:
mov al, [rbp+var_1]
and al, 1
add rsp, 30h
pop rbp
retn
|
char ggml_graph_compute_poll_for_work(long long a1)
{
bool v2; // [rsp+7h] [rbp-29h]
unsigned long long i; // [rsp+8h] [rbp-28h]
unsigned long long v4; // [rsp+10h] [rbp-20h]
long long v5; // [rsp+18h] [rbp-18h]
v5 = *(_QWORD *)(a1 + 528);
if ( (ggml_graph_compute_thread_active(a1) & 1) == 0 )
return *(_BYTE *)(a1 + 524) & 1;
v4 = (unsigned long long)*(unsigned int *)(v5 + 228) << 17;
for ( i = 0LL; ; ++i )
{
v2 = 0;
if ( (ggml_graph_compute_thread_ready(a1) & 1) == 0 )
v2 = i < v4;
if ( !v2 )
break;
ggml_thread_cpu_relax();
}
return *(_BYTE *)(a1 + 524) & 1;
}
|
ggml_graph_compute_poll_for_work:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x210]
MOV qword ptr [RBP + -0x18],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00113680
TEST AL,0x1
JNZ 0x00113549
MOV RAX,qword ptr [RBP + -0x10]
MOV AL,byte ptr [RAX + 0x20c]
AND AL,0x1
MOV byte ptr [RBP + -0x1],AL
JMP 0x001135b1
LAB_00113549:
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0xe4]
SHL RAX,0x11
MOV qword ptr [RBP + -0x20],RAX
MOV qword ptr [RBP + -0x28],0x0
LAB_00113563:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001135d0
MOV CL,AL
XOR EAX,EAX
TEST CL,0x1
MOV byte ptr [RBP + -0x29],AL
JNZ 0x00113586
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x20]
SETC AL
MOV byte ptr [RBP + -0x29],AL
LAB_00113586:
MOV AL,byte ptr [RBP + -0x29]
TEST AL,0x1
JNZ 0x0011358f
JMP 0x001135a2
LAB_0011358f:
CALL 0x0010e980
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00113563
LAB_001135a2:
MOV RAX,qword ptr [RBP + -0x10]
MOV AL,byte ptr [RAX + 0x20c]
AND AL,0x1
MOV byte ptr [RBP + -0x1],AL
LAB_001135b1:
MOV AL,byte ptr [RBP + -0x1]
AND AL,0x1
ADD RSP,0x30
POP RBP
RET
|
int8 ggml_graph_compute_poll_for_work(long param_1)
{
uint uVar1;
long lVar2;
uint uVar3;
ulong uVar4;
int7 uVar5;
ulong local_30;
int1 local_9;
lVar2 = *(long *)(param_1 + 0x210);
uVar4 = ggml_graph_compute_thread_active(param_1);
uVar5 = (int7)((ulong)param_1 >> 8);
if ((uVar4 & 1) == 0) {
uVar4 = CONCAT71(uVar5,*(int1 *)(param_1 + 0x20c)) & 0xffffffffffffff01;
local_9 = (int1)uVar4;
}
else {
uVar1 = *(uint *)(lVar2 + 0xe4);
for (local_30 = 0; uVar3 = ggml_graph_compute_thread_ready(param_1),
(uVar3 & 1) == 0 && local_30 < (ulong)uVar1 << 0x11; local_30 = local_30 + 1) {
ggml_thread_cpu_relax();
}
uVar4 = CONCAT71(uVar5,*(int1 *)(param_1 + 0x20c)) & 0xffffffffffffff01;
local_9 = (int1)uVar4;
}
return CONCAT71((int7)(uVar4 >> 8),local_9);
}
|
|
60,616
|
ma_ft_convert_to_ft2
|
eloqsql/storage/maria/ma_ft_update.c
|
my_bool _ma_ft_convert_to_ft2(MARIA_HA *info, MARIA_KEY *key)
{
MARIA_SHARE *share= info->s;
my_off_t root;
DYNAMIC_ARRAY *da=info->ft1_to_ft2;
MARIA_KEYDEF *keyinfo=&share->ft2_keyinfo;
uchar *key_ptr= (uchar*) dynamic_array_ptr(da, 0), *end;
uint length, key_length;
MARIA_PINNED_PAGE tmp_page_link, *page_link= &tmp_page_link;
MARIA_KEY tmp_key;
MARIA_PAGE page;
DBUG_ENTER("_ma_ft_convert_to_ft2");
/* we'll generate one pageful at once, and insert the rest one-by-one */
/* calculating the length of this page ...*/
length=(keyinfo->block_length-2) / keyinfo->keylength;
set_if_smaller(length, da->elements);
length=length * keyinfo->keylength;
get_key_full_length_rdonly(key_length, key->data);
while (_ma_ck_delete(info, key) == 0)
{
/*
nothing to do here.
_ma_ck_delete() will populate info->ft1_to_ft2 with deleted keys
*/
}
/* creating pageful of keys */
bzero(info->buff, share->keypage_header);
_ma_store_keynr(share, info->buff, keyinfo->key_nr);
_ma_store_page_used(share, info->buff, length + share->keypage_header);
memcpy(info->buff + share->keypage_header, key_ptr, length);
info->keyread_buff_used= info->page_changed=1; /* info->buff is used */
/**
@todo RECOVERY BUG this is not logged yet. Ok as this code is never
called, but soon it will be.
*/
if ((root= _ma_new(info, DFLT_INIT_HITS, &page_link)) == HA_OFFSET_ERROR)
DBUG_RETURN(1);
_ma_page_setup(&page, info, keyinfo, root, info->buff);
if (_ma_write_keypage(&page, page_link->write_lock, DFLT_INIT_HITS))
DBUG_RETURN(1);
/* inserting the rest of key values */
end= (uchar*) dynamic_array_ptr(da, da->elements);
tmp_key.keyinfo= keyinfo;
tmp_key.data_length= keyinfo->keylength;
tmp_key.ref_length= 0;
tmp_key.flag= 0;
for (key_ptr+=length; key_ptr < end; key_ptr+=keyinfo->keylength)
{
tmp_key.data= key_ptr;
if (_ma_ck_real_write_btree(info, &tmp_key, &root, SEARCH_SAME))
DBUG_RETURN(1);
}
/* now, writing the word key entry */
ft_intXstore(key->data + key_length, - (int) da->elements);
_ma_dpointer(share, key->data + key_length + HA_FT_WLEN, root);
DBUG_RETURN(_ma_ck_real_write_btree(info, key,
&share->state.key_root[key->keyinfo->
key_nr],
SEARCH_SAME));
}
|
O3
|
c
|
ma_ft_convert_to_ft2:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x320(%rdi), %rdi
movq (%rdi), %r12
leaq -0x90(%rbp), %rax
movq %rax, -0x40(%rbp)
movzwl 0x4fe(%r14), %eax
addl $-0x2, %eax
movzwl 0x502(%r14), %ecx
cltd
idivl %ecx
movq %rdi, -0x38(%rbp)
movl 0x8(%rdi), %r13d
cmpl %r13d, %eax
cmovbl %eax, %r13d
movq %rsi, %r15
movq (%rsi), %rax
movzbl (%rax), %edx
cmpq $0xff, %rdx
je 0x6ac04
incq %rdx
movq %rdx, -0x30(%rbp)
jmp 0x6ac17
movzwl 0x1(%rax), %eax
rolw $0x8, %ax
movzwl %ax, %eax
addq $0x3, %rax
movq %rax, -0x30(%rbp)
leaq 0x458(%r14), %rax
movq %rax, -0x58(%rbp)
imull %ecx, %r13d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6752d
testb %al, %al
je 0x6ac26
movq 0x378(%rbx), %rdi
movl 0x744(%r14), %edx
xorl %esi, %esi
callq 0x292c0
movb 0x4fd(%r14), %al
movq 0x378(%rbx), %rcx
movl 0x744(%r14), %edx
addl $-0x4, %edx
movb %al, (%rcx,%rdx)
movl 0x744(%r14), %eax
leal (%rax,%r13), %ecx
movq 0x378(%rbx), %rdx
movb %cl, -0x1(%rdx,%rax)
movq 0x378(%rbx), %rax
movl 0x744(%r14), %edx
movb %ch, -0x2(%rax,%rdx)
movl 0x744(%r14), %edi
addq 0x378(%rbx), %rdi
movl %r13d, %r13d
movq %r12, %rsi
movq %r13, %rdx
callq 0x29080
movw $0x101, 0x684(%rbx) # imm = 0x101
leaq -0x40(%rbp), %rdx
movq %rbx, %rdi
movl $0x3, %esi
callq 0x59327
movq %rax, -0x48(%rbp)
movb $0x1, %cl
cmpq $-0x1, %rax
je 0x6ade9
movq %r13, -0x50(%rbp)
movq 0x378(%rbx), %r8
leaq -0xc8(%rbp), %rdi
movq %rbx, %rsi
movq -0x58(%rbp), %r13
movq %r13, %rdx
movq %rax, %rcx
callq 0x58eac
movq -0x40(%rbp), %rax
movl 0xc(%rax), %esi
leaq -0xc8(%rbp), %rdi
movl $0x3, %edx
callq 0x5903d
testb %al, %al
je 0x6ad1a
movb $0x1, %cl
jmp 0x6ade9
movq -0x38(%rbp), %rcx
movl 0x8(%rcx), %eax
movq %r13, %rdx
movl 0x14(%rcx), %r13d
imull %eax, %r13d
addq (%rcx), %r13
movq %rdx, -0x70(%rbp)
movzwl 0x502(%r14), %ecx
movl %ecx, -0x68(%rbp)
movq $0x0, -0x64(%rbp)
addq -0x50(%rbp), %r12
cmpq %r13, %r12
jae 0x6ad83
movq %r12, -0x78(%rbp)
movq %rbx, %rdi
leaq -0x78(%rbp), %rsi
leaq -0x48(%rbp), %rdx
movl $0x4, %ecx
callq 0x64a48
testb %al, %al
jne 0x6ad13
movzwl 0x502(%r14), %eax
addq %rax, %r12
cmpq %r13, %r12
jb 0x6ad4f
movq -0x38(%rbp), %rax
movl 0x8(%rax), %eax
negl %eax
movq (%r15), %rcx
movq -0x30(%rbp), %rsi
movb %al, 0x3(%rcx,%rsi)
movq (%r15), %rcx
movb %ah, 0x2(%rcx,%rsi)
movl %eax, %ecx
shrl $0x10, %ecx
movq (%r15), %rdx
movb %cl, 0x1(%rdx,%rsi)
shrl $0x18, %eax
movq (%r15), %rcx
movb %al, (%rcx,%rsi)
movq (%r15), %rax
addq %rax, %rsi
addq $0x4, %rsi
movq -0x48(%rbp), %rdx
movq %r14, %rdi
callq 0x57258
movq 0x8(%r15), %rax
movzbl 0xa5(%rax), %edx
shll $0x3, %edx
addq 0x118(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movl $0x4, %ecx
callq 0x64a48
movl %eax, %ecx
movl %ecx, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
|
_ma_ft_convert_to_ft2:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0A8h
mov rbx, rdi
mov r14, [rdi]
mov rdi, [rdi+320h]
mov r12, [rdi]
lea rax, [rbp+var_90]
mov [rbp+var_40], rax
movzx eax, word ptr [r14+4FEh]
add eax, 0FFFFFFFEh
movzx ecx, word ptr [r14+502h]
cdq
idiv ecx
mov [rbp+var_38], rdi
mov r13d, [rdi+8]
cmp eax, r13d
cmovb r13d, eax
mov r15, rsi
mov rax, [rsi]
movzx edx, byte ptr [rax]
cmp rdx, 0FFh
jz short loc_6AC04
inc rdx
mov [rbp+var_30], rdx
jmp short loc_6AC17
loc_6AC04:
movzx eax, word ptr [rax+1]
rol ax, 8
movzx eax, ax
add rax, 3
mov [rbp+var_30], rax
loc_6AC17:
lea rax, [r14+458h]
mov [rbp+var_58], rax
imul r13d, ecx
loc_6AC26:
mov rdi, rbx
mov rsi, r15
call _ma_ck_delete
test al, al
jz short loc_6AC26
mov rdi, [rbx+378h]
mov edx, [r14+744h]
xor esi, esi
call _memset
mov al, [r14+4FDh]
mov rcx, [rbx+378h]
mov edx, [r14+744h]
add edx, 0FFFFFFFCh
mov [rcx+rdx], al
mov eax, [r14+744h]
lea ecx, [rax+r13]
mov rdx, [rbx+378h]
mov [rdx+rax-1], cl
mov rax, [rbx+378h]
mov edx, [r14+744h]
mov [rax+rdx-2], ch
mov edi, [r14+744h]
add rdi, [rbx+378h]
mov r13d, r13d
mov rsi, r12
mov rdx, r13
call _memcpy
mov word ptr [rbx+684h], 101h
lea rdx, [rbp+var_40]
mov rdi, rbx
mov esi, 3
call _ma_new
mov [rbp+var_48], rax
mov cl, 1
cmp rax, 0FFFFFFFFFFFFFFFFh
jz loc_6ADE9
mov [rbp+var_50], r13
mov r8, [rbx+378h]
lea rdi, [rbp+var_C8]
mov rsi, rbx
mov r13, [rbp+var_58]
mov rdx, r13
mov rcx, rax
call _ma_page_setup
mov rax, [rbp+var_40]
mov esi, [rax+0Ch]
lea rdi, [rbp+var_C8]
mov edx, 3
call _ma_write_keypage
test al, al
jz short loc_6AD1A
loc_6AD13:
mov cl, 1
jmp loc_6ADE9
loc_6AD1A:
mov rcx, [rbp+var_38]
mov eax, [rcx+8]
mov rdx, r13
mov r13d, [rcx+14h]
imul r13d, eax
add r13, [rcx]
mov [rbp+var_70], rdx
movzx ecx, word ptr [r14+502h]
mov [rbp+var_68], ecx
mov [rbp+var_64], 0
add r12, [rbp+var_50]
cmp r12, r13
jnb short loc_6AD83
loc_6AD4F:
mov [rbp+var_78], r12
mov rdi, rbx
lea rsi, [rbp+var_78]
lea rdx, [rbp+var_48]
mov ecx, 4
call _ma_ck_real_write_btree
test al, al
jnz short loc_6AD13
movzx eax, word ptr [r14+502h]
add r12, rax
cmp r12, r13
jb short loc_6AD4F
mov rax, [rbp+var_38]
mov eax, [rax+8]
loc_6AD83:
neg eax
mov rcx, [r15]
mov rsi, [rbp+var_30]
mov [rcx+rsi+3], al
mov rcx, [r15]
mov [rcx+rsi+2], ah
mov ecx, eax
shr ecx, 10h
mov rdx, [r15]
mov [rdx+rsi+1], cl
shr eax, 18h
mov rcx, [r15]
mov [rcx+rsi], al
mov rax, [r15]
add rsi, rax
add rsi, 4
mov rdx, [rbp+var_48]
mov rdi, r14
call _ma_dpointer
mov rax, [r15+8]
movzx edx, byte ptr [rax+0A5h]
shl edx, 3
add rdx, [r14+118h]
mov rdi, rbx
mov rsi, r15
mov ecx, 4
call _ma_ck_real_write_btree
mov ecx, eax
loc_6ADE9:
mov eax, ecx
add rsp, 0A8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long ma_ft_convert_to_ft2(long long a1, long long *a2)
{
_QWORD *v3; // r14
long long *v4; // rdi
long long v5; // r12
int v6; // ecx
unsigned int v7; // eax
unsigned int v8; // r13d
long long v10; // rdx
unsigned int v11; // r13d
long long v12; // rax
long long v13; // rax
unsigned int v14; // ecx
long long v15; // r13
int v16; // eax
long long v17; // rdx
unsigned long long v18; // r13
unsigned long long v19; // r12
int v20; // eax
long long v21; // rsi
unsigned int v22; // eax
long long *v24[7]; // [rsp+8h] [rbp-C8h] BYREF
char v25; // [rsp+40h] [rbp-90h] BYREF
_QWORD v26[2]; // [rsp+58h] [rbp-78h] BYREF
int v27; // [rsp+68h] [rbp-68h]
long long v28; // [rsp+6Ch] [rbp-64h]
_QWORD *v29; // [rsp+78h] [rbp-58h]
long long v30; // [rsp+80h] [rbp-50h]
long long v31; // [rsp+88h] [rbp-48h] BYREF
char *v32; // [rsp+90h] [rbp-40h] BYREF
long long *v33; // [rsp+98h] [rbp-38h]
long long v34; // [rsp+A0h] [rbp-30h]
v3 = *(_QWORD **)a1;
v4 = *(long long **)(a1 + 800);
v5 = *v4;
v32 = &v25;
v6 = *((unsigned __int16 *)v3 + 641);
v7 = (*((unsigned __int16 *)v3 + 639) - 2) / v6;
v33 = v4;
v8 = *((_DWORD *)v4 + 2);
if ( v7 < v8 )
v8 = v7;
v10 = *(unsigned __int8 *)*a2;
if ( v10 == 255 )
v34 = (unsigned __int16)__ROL2__(*(_WORD *)(*a2 + 1), 8) + 3LL;
else
v34 = v10 + 1;
v29 = v3 + 139;
v11 = v6 * v8;
while ( !ma_ck_delete((_QWORD **)a1, a2) )
;
memset(*(_QWORD *)(a1 + 888), 0LL, *((unsigned int *)v3 + 465));
*(_BYTE *)(*(_QWORD *)(a1 + 888) + (unsigned int)(*((_DWORD *)v3 + 465) - 4)) = *((_BYTE *)v3 + 1277);
v12 = *((unsigned int *)v3 + 465);
*(_BYTE *)(*(_QWORD *)(a1 + 888) + v12 - 1) = v12 + v11;
*(_BYTE *)(*(_QWORD *)(a1 + 888) + *((unsigned int *)v3 + 465) - 2LL) = (unsigned __int16)(v12 + v11) >> 8;
memcpy(*(_QWORD *)(a1 + 888) + *((unsigned int *)v3 + 465), v5, v11);
*(_WORD *)(a1 + 1668) = 257;
v13 = ma_new((long long *)a1, 3, &v32);
v31 = v13;
LOBYTE(v14) = 1;
if ( v13 != -1 )
{
v30 = v11;
v15 = (long long)v29;
ma_page_setup((long long)v24, (long long *)a1, (long long)v29, v13, *(_QWORD *)(a1 + 888));
if ( !(unsigned __int8)ma_write_keypage(v24, *((_DWORD *)v32 + 3), 3) )
{
v16 = *((_DWORD *)v33 + 2);
v17 = v15;
v18 = *v33 + (unsigned int)(v16 * *((_DWORD *)v33 + 5));
v26[1] = v17;
v27 = *((unsigned __int16 *)v3 + 641);
v28 = 0LL;
v19 = v30 + v5;
if ( v19 >= v18 )
{
LABEL_15:
v20 = -v16;
v21 = v34;
*(_BYTE *)(*a2 + v34 + 3) = v20;
*(_BYTE *)(*a2 + v21 + 2) = BYTE1(v20);
*(_BYTE *)(*a2 + v21 + 1) = BYTE2(v20);
*(_BYTE *)(*a2 + v21) = HIBYTE(v20);
ma_dpointer((long long)v3, *a2 + v21 + 4, v31);
LOBYTE(v22) = ma_ck_real_write_btree(
a1,
(long long)a2,
(_QWORD *)(v3[35] + 8 * (unsigned int)*(unsigned __int8 *)(a2[1] + 165)),
4);
return v22;
}
while ( 1 )
{
v26[0] = v19;
if ( ma_ck_real_write_btree(a1, (long long)v26, &v31, 4) )
break;
v19 += *((unsigned __int16 *)v3 + 641);
if ( v19 >= v18 )
{
v16 = *((_DWORD *)v33 + 2);
goto LABEL_15;
}
}
}
LOBYTE(v14) = 1;
}
return v14;
}
|
_ma_ft_convert_to_ft2:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xa8
MOV RBX,RDI
MOV R14,qword ptr [RDI]
MOV RDI,qword ptr [RDI + 0x320]
MOV R12,qword ptr [RDI]
LEA RAX,[RBP + -0x90]
MOV qword ptr [RBP + -0x40],RAX
MOVZX EAX,word ptr [R14 + 0x4fe]
ADD EAX,-0x2
MOVZX ECX,word ptr [R14 + 0x502]
CDQ
IDIV ECX
MOV qword ptr [RBP + -0x38],RDI
MOV R13D,dword ptr [RDI + 0x8]
CMP EAX,R13D
CMOVC R13D,EAX
MOV R15,RSI
MOV RAX,qword ptr [RSI]
MOVZX EDX,byte ptr [RAX]
CMP RDX,0xff
JZ 0x0016ac04
INC RDX
MOV qword ptr [RBP + -0x30],RDX
JMP 0x0016ac17
LAB_0016ac04:
MOVZX EAX,word ptr [RAX + 0x1]
ROL AX,0x8
MOVZX EAX,AX
ADD RAX,0x3
MOV qword ptr [RBP + -0x30],RAX
LAB_0016ac17:
LEA RAX,[R14 + 0x458]
MOV qword ptr [RBP + -0x58],RAX
IMUL R13D,ECX
LAB_0016ac26:
MOV RDI,RBX
MOV RSI,R15
CALL 0x0016752d
TEST AL,AL
JZ 0x0016ac26
MOV RDI,qword ptr [RBX + 0x378]
MOV EDX,dword ptr [R14 + 0x744]
XOR ESI,ESI
CALL 0x001292c0
MOV AL,byte ptr [R14 + 0x4fd]
MOV RCX,qword ptr [RBX + 0x378]
MOV EDX,dword ptr [R14 + 0x744]
ADD EDX,-0x4
MOV byte ptr [RCX + RDX*0x1],AL
MOV EAX,dword ptr [R14 + 0x744]
LEA ECX,[RAX + R13*0x1]
MOV RDX,qword ptr [RBX + 0x378]
MOV byte ptr [RDX + RAX*0x1 + -0x1],CL
MOV RAX,qword ptr [RBX + 0x378]
MOV EDX,dword ptr [R14 + 0x744]
MOV byte ptr [RAX + RDX*0x1 + -0x2],CH
MOV EDI,dword ptr [R14 + 0x744]
ADD RDI,qword ptr [RBX + 0x378]
MOV R13D,R13D
MOV RSI,R12
MOV RDX,R13
CALL 0x00129080
MOV word ptr [RBX + 0x684],0x101
LEA RDX,[RBP + -0x40]
MOV RDI,RBX
MOV ESI,0x3
CALL 0x00159327
MOV qword ptr [RBP + -0x48],RAX
MOV CL,0x1
CMP RAX,-0x1
JZ 0x0016ade9
MOV qword ptr [RBP + -0x50],R13
MOV R8,qword ptr [RBX + 0x378]
LEA RDI,[RBP + -0xc8]
MOV RSI,RBX
MOV R13,qword ptr [RBP + -0x58]
MOV RDX,R13
MOV RCX,RAX
CALL 0x00158eac
MOV RAX,qword ptr [RBP + -0x40]
MOV ESI,dword ptr [RAX + 0xc]
LEA RDI,[RBP + -0xc8]
MOV EDX,0x3
CALL 0x0015903d
TEST AL,AL
JZ 0x0016ad1a
LAB_0016ad13:
MOV CL,0x1
JMP 0x0016ade9
LAB_0016ad1a:
MOV RCX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RCX + 0x8]
MOV RDX,R13
MOV R13D,dword ptr [RCX + 0x14]
IMUL R13D,EAX
ADD R13,qword ptr [RCX]
MOV qword ptr [RBP + -0x70],RDX
MOVZX ECX,word ptr [R14 + 0x502]
MOV dword ptr [RBP + -0x68],ECX
MOV qword ptr [RBP + -0x64],0x0
ADD R12,qword ptr [RBP + -0x50]
CMP R12,R13
JNC 0x0016ad83
LAB_0016ad4f:
MOV qword ptr [RBP + -0x78],R12
MOV RDI,RBX
LEA RSI,[RBP + -0x78]
LEA RDX,[RBP + -0x48]
MOV ECX,0x4
CALL 0x00164a48
TEST AL,AL
JNZ 0x0016ad13
MOVZX EAX,word ptr [R14 + 0x502]
ADD R12,RAX
CMP R12,R13
JC 0x0016ad4f
MOV RAX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RAX + 0x8]
LAB_0016ad83:
NEG EAX
MOV RCX,qword ptr [R15]
MOV RSI,qword ptr [RBP + -0x30]
MOV byte ptr [RCX + RSI*0x1 + 0x3],AL
MOV RCX,qword ptr [R15]
MOV byte ptr [RCX + RSI*0x1 + 0x2],AH
MOV ECX,EAX
SHR ECX,0x10
MOV RDX,qword ptr [R15]
MOV byte ptr [RDX + RSI*0x1 + 0x1],CL
SHR EAX,0x18
MOV RCX,qword ptr [R15]
MOV byte ptr [RCX + RSI*0x1],AL
MOV RAX,qword ptr [R15]
ADD RSI,RAX
ADD RSI,0x4
MOV RDX,qword ptr [RBP + -0x48]
MOV RDI,R14
CALL 0x00157258
MOV RAX,qword ptr [R15 + 0x8]
MOVZX EDX,byte ptr [RAX + 0xa5]
SHL EDX,0x3
ADD RDX,qword ptr [R14 + 0x118]
MOV RDI,RBX
MOV RSI,R15
MOV ECX,0x4
CALL 0x00164a48
MOV ECX,EAX
LAB_0016ade9:
MOV EAX,ECX
ADD RSP,0xa8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong _ma_ft_convert_to_ft2(long *param_1,long *param_2)
{
ushort uVar1;
long lVar2;
void *__src;
char cVar3;
uint uVar4;
int iVar5;
long lVar6;
ulong uVar7;
uint uVar8;
ulong uVar9;
int1 local_d0 [56];
int1 local_98 [24];
ulong local_80;
long local_78;
uint local_70;
int8 local_6c;
long local_60;
ulong local_58;
long local_50;
int1 *local_48;
long *local_40;
long local_38;
lVar2 = *param_1;
local_40 = (long *)param_1[100];
__src = (void *)*local_40;
local_48 = local_98;
uVar4 = (int)(*(ushort *)(lVar2 + 0x4fe) - 2) / (int)(uint)*(ushort *)(lVar2 + 0x502);
uVar8 = *(uint *)(local_40 + 1);
if (uVar4 < *(uint *)(local_40 + 1)) {
uVar8 = uVar4;
}
uVar7 = (ulong)*(byte *)*param_2;
if (uVar7 == 0xff) {
uVar1 = *(ushort *)((byte *)*param_2 + 1);
local_38 = (ulong)(ushort)(uVar1 << 8 | uVar1 >> 8) + 3;
}
else {
local_38 = uVar7 + 1;
}
local_60 = lVar2 + 0x458;
uVar8 = uVar8 * *(ushort *)(lVar2 + 0x502);
do {
cVar3 = _ma_ck_delete(param_1);
} while (cVar3 == '\0');
memset((void *)param_1[0x6f],0,(ulong)*(uint *)(lVar2 + 0x744));
*(int1 *)(param_1[0x6f] + (ulong)(*(int *)(lVar2 + 0x744) - 4)) =
*(int1 *)(lVar2 + 0x4fd);
uVar4 = *(uint *)(lVar2 + 0x744) + uVar8;
uVar7 = (ulong)uVar4;
*(char *)(param_1[0x6f] + -1 + (ulong)*(uint *)(lVar2 + 0x744)) = (char)uVar4;
*(char *)(param_1[0x6f] + -2 + (ulong)*(uint *)(lVar2 + 0x744)) = (char)(uVar4 >> 8);
memcpy((void *)((ulong)*(uint *)(lVar2 + 0x744) + param_1[0x6f]),__src,(ulong)uVar8);
*(int2 *)((long)param_1 + 0x684) = 0x101;
lVar6 = _ma_new(param_1,3,&local_48);
local_78 = local_60;
uVar7 = CONCAT71((int7)(uVar7 >> 8),1);
if (lVar6 != -1) {
local_58 = (ulong)uVar8;
local_50 = lVar6;
_ma_page_setup(local_d0,param_1,local_60,lVar6,param_1[0x6f]);
cVar3 = _ma_write_keypage(local_d0,*(int4 *)(local_48 + 0xc),3);
if (cVar3 == '\0') {
iVar5 = (int)local_40[1];
uVar9 = (ulong)(uint)(*(int *)((long)local_40 + 0x14) * iVar5) + *local_40;
local_70 = (uint)*(ushort *)(lVar2 + 0x502);
local_6c = 0;
uVar7 = (long)__src + local_58;
if (uVar7 < uVar9) {
do {
lVar6 = 0;
local_80 = uVar7;
cVar3 = _ma_ck_real_write_btree(param_1,&local_80,&local_50,4);
if (cVar3 != '\0') goto LAB_0016ad13;
uVar7 = uVar7 + *(ushort *)(lVar2 + 0x502);
} while (uVar7 < uVar9);
iVar5 = (int)local_40[1];
}
iVar5 = -iVar5;
*(char *)(*param_2 + 3 + local_38) = (char)iVar5;
*(char *)(*param_2 + 2 + local_38) = (char)((uint)iVar5 >> 8);
*(char *)(*param_2 + 1 + local_38) = (char)((uint)iVar5 >> 0x10);
*(char *)(*param_2 + local_38) = (char)((uint)iVar5 >> 0x18);
_ma_dpointer(lVar2,local_38 + *param_2 + 4,local_50);
uVar8 = _ma_ck_real_write_btree
(param_1,param_2,
(ulong)*(byte *)(param_2[1] + 0xa5) * 8 + *(long *)(lVar2 + 0x118),4);
uVar7 = (ulong)uVar8;
}
else {
LAB_0016ad13:
uVar7 = CONCAT71((int7)((ulong)lVar6 >> 8),1);
}
}
return uVar7 & 0xffffffff;
}
|
|
60,617
|
partition_ft_find_relevance(st_ft_info*, unsigned char*, unsigned int)
|
eloqsql/sql/ha_partition.cc
|
float partition_ft_find_relevance(FT_INFO *handler,
uchar *record, uint length)
{
st_partition_ft_info *info= (st_partition_ft_info *)handler;
uint m_last_part= ((ha_partition*) info->file)->last_part();
FT_INFO *m_handler= info->part_ft_info[m_last_part];
DBUG_ENTER("partition_ft_find_relevance");
if (!m_handler)
DBUG_RETURN((float)-1.0);
DBUG_RETURN(m_handler->please->find_relevance(m_handler, record, length));
}
|
O0
|
cpp
|
partition_ft_find_relevance(st_ft_info*, unsigned char*, unsigned int):
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xf50fc0
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x2c(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0xf4af76
jmp 0xf4af67
movss 0x4970b5(%rip), %xmm0 # 0x13e2024
movss %xmm0, -0x4(%rbp)
jmp 0xf4af95
jmp 0xf4af78
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq *%rax
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
|
_Z27partition_ft_find_relevanceP10st_ft_infoPhj:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov rax, [rbp+var_10]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
mov rdi, [rax+10h]; this
call _ZN12ha_partition9last_partEv; ha_partition::last_part(void)
mov [rbp+var_2C], eax
mov rax, [rbp+var_28]
mov rax, [rax+18h]
mov ecx, [rbp+var_2C]
mov rax, [rax+rcx*8]
mov [rbp+var_38], rax
cmp [rbp+var_38], 0
jnz short loc_F4AF76
jmp short $+2
loc_F4AF67:
movss xmm0, cs:dword_13E2024
movss [rbp+var_4], xmm0
jmp short loc_F4AF95
loc_F4AF76:
jmp short $+2
loc_F4AF78:
mov rax, [rbp+var_38]
mov rax, [rax]
mov rax, [rax+8]
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_18]
mov edx, [rbp+var_1C]
call rax
movss [rbp+var_4], xmm0
loc_F4AF95:
movss xmm0, [rbp+var_4]
add rsp, 40h
pop rbp
retn
|
float partition_ft_find_relevance(long long a1, long long a2, unsigned int a3)
{
long long v4; // [rsp+8h] [rbp-38h]
v4 = *(_QWORD *)(*(_QWORD *)(a1 + 24) + 8LL * (unsigned int)ha_partition::last_part(*(ha_partition **)(a1 + 16)));
if ( v4 )
return (*(float ( **)(long long, long long, _QWORD))(*(_QWORD *)v4 + 8LL))(v4, a2, a3);
else
return -1.0;
}
|
do_sub:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV EAX,dword ptr [RBP + -0xc]
SUB EAX,0x1
MOV dword ptr [RBP + -0x24],EAX
MOV dword ptr [RBP + -0x28],0x0
LAB_00f4af43:
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RCX,dword ptr [RBP + -0x24]
MOV EAX,dword ptr [RAX + RCX*0x4]
ADD EAX,dword ptr [RBP + -0x28]
MOV dword ptr [RBP + -0x2c],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOVSXD RCX,dword ptr [RBP + -0x24]
MOV EAX,dword ptr [RAX + RCX*0x4]
MOV dword ptr [RBP + -0x30],EAX
MOV EAX,dword ptr [RBP + -0x30]
CMP EAX,dword ptr [RBP + -0x2c]
JNC 0x00f4af89
MOV dword ptr [RBP + -0x28],0x1
MOV EDX,0x3b9aca00
SUB EDX,dword ptr [RBP + -0x2c]
ADD EDX,dword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RBP + -0x24]
MOV dword ptr [RAX + RCX*0x4],EDX
JMP 0x00f4afa1
LAB_00f4af89:
MOV dword ptr [RBP + -0x28],0x0
MOV EDX,dword ptr [RBP + -0x30]
SUB EDX,dword ptr [RBP + -0x2c]
MOV RAX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RBP + -0x24]
MOV dword ptr [RAX + RCX*0x4],EDX
LAB_00f4afa1:
JMP 0x00f4afa3
LAB_00f4afa3:
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x24],EAX
CMP EAX,0x0
JNZ 0x00f4af43
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX]
AND EAX,0x7fffffff
SUB ECX,EAX
SUB ECX,dword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX],ECX
JMP 0x00f4afcf
LAB_00f4afcf:
JMP 0x00f4afd1
LAB_00f4afd1:
JMP 0x00f4afd3
LAB_00f4afd3:
POP RBP
RET
|
/* do_sub(unsigned int*, int, unsigned int const*, unsigned int const*) */
void do_sub(uint *param_1,int param_2,uint *param_3,uint *param_4)
{
uint uVar1;
uint local_30;
int local_2c;
local_2c = param_2 + -1;
local_30 = 0;
do {
local_30 = param_4[local_2c] + local_30;
uVar1 = param_3[local_2c];
if (local_30 <= uVar1) {
param_1[local_2c] = uVar1 - local_30;
}
else {
param_1[local_2c] = (1000000000 - local_30) + uVar1;
}
local_30 = (uint)(local_30 > uVar1);
local_2c = local_2c + -1;
} while (local_2c != 0);
*param_1 = (*param_3 - (*param_4 & 0x7fffffff)) - local_30;
return;
}
|
|
60,618
|
partition_ft_find_relevance(st_ft_info*, unsigned char*, unsigned int)
|
eloqsql/sql/ha_partition.cc
|
float partition_ft_find_relevance(FT_INFO *handler,
uchar *record, uint length)
{
st_partition_ft_info *info= (st_partition_ft_info *)handler;
uint m_last_part= ((ha_partition*) info->file)->last_part();
FT_INFO *m_handler= info->part_ft_info[m_last_part];
DBUG_ENTER("partition_ft_find_relevance");
if (!m_handler)
DBUG_RETURN((float)-1.0);
DBUG_RETURN(m_handler->please->find_relevance(m_handler, record, length));
}
|
O3
|
cpp
|
partition_ft_find_relevance(st_ft_info*, unsigned char*, unsigned int):
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rcx
movl 0x614(%rax), %eax
movq (%rcx,%rax,8), %rdi
testq %rdi, %rdi
je 0xaeb43b
movq (%rdi), %rax
movq 0x8(%rax), %rax
popq %rbp
jmpq *%rax
movss 0x277bed(%rip), %xmm0 # 0xd63030
popq %rbp
retq
|
_Z27partition_ft_find_relevanceP10st_ft_infoPhj:
push rbp
mov rbp, rsp
mov rax, [rdi+10h]
mov rcx, [rdi+18h]
mov eax, [rax+614h]
mov rdi, [rcx+rax*8]
test rdi, rdi
jz short loc_AEB43B
mov rax, [rdi]
mov rax, [rax+8]
pop rbp
jmp rax
loc_AEB43B:
movss xmm0, cs:dword_D63030
pop rbp
retn
|
float partition_ft_find_relevance(long long a1)
{
long long v1; // rdi
float result; // xmm0_4
v1 = *(_QWORD *)(*(_QWORD *)(a1 + 24) + 8LL * *(unsigned int *)(*(_QWORD *)(a1 + 16) + 1556LL));
if ( !v1 )
return -1.0;
(*(void ( **)(long long))(*(_QWORD *)v1 + 8LL))(v1);
return result;
}
| |||
60,619
|
enough_free_entries_on_page
|
eloqsql/storage/maria/ma_blockrec.c
|
my_bool enough_free_entries_on_page(MARIA_SHARE *share,
uchar *page_buff)
{
enum en_page_type page_type;
page_type= (enum en_page_type) (page_buff[PAGE_TYPE_OFFSET] &
~(uchar) PAGE_CAN_BE_COMPACTED);
if (page_type == HEAD_PAGE)
{
uint row_count= (uint) page_buff[DIR_COUNT_OFFSET];
return !(row_count == MAX_ROWS_PER_PAGE &&
page_buff[DIR_FREE_OFFSET] == END_OF_DIR_FREE_LIST);
}
return enough_free_entries(page_buff, share->block_size,
1 + share->base.blobs);
}
|
O3
|
c
|
enough_free_entries_on_page:
pushq %rbp
movq %rsp, %rbp
movb 0x7(%rsi), %al
andb $0x7f, %al
cmpb $0x1, %al
jne 0x4d474
movb $0x1, %al
cmpb $-0x1, 0x8(%rsi)
jne 0x4d4c0
cmpb $-0x1, 0x9(%rsi)
setne %al
jmp 0x4d4c0
movl 0x3f0(%rdi), %eax
movzbl 0x8(%rsi), %ecx
addl %eax, %ecx
incl %ecx
movb $0x1, %al
cmpl $0x100, %ecx # imm = 0x100
jb 0x4d4c0
movb 0x9(%rsi), %dl
cmpb $-0x1, %dl
je 0x4d4be
movl 0x7bc(%rdi), %edi
addl $0xffffff01, %ecx # imm = 0xFFFFFF01
addq %rdi, %rsi
addq $-0x5, %rsi
decl %ecx
je 0x4d4c0
movzbl %dl, %edx
shll $0x2, %edx
movq %rsi, %rdi
subq %rdx, %rdi
movb (%rdi), %dl
cmpb $-0x1, %dl
jne 0x4d4a7
xorl %eax, %eax
popq %rbp
retq
|
enough_free_entries_on_page:
push rbp
mov rbp, rsp
mov al, [rsi+7]
and al, 7Fh
cmp al, 1
jnz short loc_4D474
mov al, 1
cmp byte ptr [rsi+8], 0FFh
jnz short loc_4D4C0
cmp byte ptr [rsi+9], 0FFh
setnz al
jmp short loc_4D4C0
loc_4D474:
mov eax, [rdi+3F0h]
movzx ecx, byte ptr [rsi+8]
add ecx, eax
inc ecx
mov al, 1
cmp ecx, 100h
jb short loc_4D4C0
mov dl, [rsi+9]
cmp dl, 0FFh
jz short loc_4D4BE
mov edi, [rdi+7BCh]
add ecx, 0FFFFFF01h
add rsi, rdi
add rsi, 0FFFFFFFFFFFFFFFBh
loc_4D4A7:
dec ecx
jz short loc_4D4C0
movzx edx, dl
shl edx, 2
mov rdi, rsi
sub rdi, rdx
mov dl, [rdi]
cmp dl, 0FFh
jnz short loc_4D4A7
loc_4D4BE:
xor eax, eax
loc_4D4C0:
pop rbp
retn
|
bool enough_free_entries_on_page(long long a1, _BYTE *a2)
{
bool result; // al
unsigned __int8 v3; // dl
int v4; // ecx
long long v5; // rsi
if ( (a2[7] & 0x7F) == 1 )
{
result = 1;
if ( a2[8] == 0xFF )
return a2[9] != 0xFF;
}
else
{
result = 1;
if ( *(_DWORD *)(a1 + 1008) + (unsigned int)(unsigned __int8)a2[8] + 1 >= 0x100 )
{
v3 = a2[9];
if ( v3 == 0xFF )
{
return 0;
}
else
{
v4 = *(_DWORD *)(a1 + 1008) + (unsigned __int8)a2[8] - 254;
v5 = (long long)&a2[*(unsigned int *)(a1 + 1980) - 5];
while ( --v4 )
{
v3 = *(_BYTE *)(v5 - 4 * (unsigned int)v3);
if ( v3 == 0xFF )
return 0;
}
}
}
}
return result;
}
|
enough_free_entries_on_page:
PUSH RBP
MOV RBP,RSP
MOV AL,byte ptr [RSI + 0x7]
AND AL,0x7f
CMP AL,0x1
JNZ 0x0014d474
MOV AL,0x1
CMP byte ptr [RSI + 0x8],0xff
JNZ 0x0014d4c0
CMP byte ptr [RSI + 0x9],0xff
SETNZ AL
JMP 0x0014d4c0
LAB_0014d474:
MOV EAX,dword ptr [RDI + 0x3f0]
MOVZX ECX,byte ptr [RSI + 0x8]
ADD ECX,EAX
INC ECX
MOV AL,0x1
CMP ECX,0x100
JC 0x0014d4c0
MOV DL,byte ptr [RSI + 0x9]
CMP DL,0xff
JZ 0x0014d4be
MOV EDI,dword ptr [RDI + 0x7bc]
ADD ECX,0xffffff01
ADD RSI,RDI
ADD RSI,-0x5
LAB_0014d4a7:
DEC ECX
JZ 0x0014d4c0
MOVZX EDX,DL
SHL EDX,0x2
MOV RDI,RSI
SUB RDI,RDX
MOV DL,byte ptr [RDI]
CMP DL,0xff
JNZ 0x0014d4a7
LAB_0014d4be:
XOR EAX,EAX
LAB_0014d4c0:
POP RBP
RET
|
int8 enough_free_entries_on_page(long param_1,long param_2)
{
int8 in_RAX;
ulong uVar1;
int8 uVar2;
int iVar4;
byte bVar5;
int7 uVar3;
uVar1 = CONCAT71((int7)((ulong)in_RAX >> 8),*(int1 *)(param_2 + 7)) & 0xffffffffffffff7f;
if ((char)uVar1 == '\x01') {
uVar3 = (int7)(uVar1 >> 8);
uVar2 = CONCAT71(uVar3,1);
if (*(char *)(param_2 + 8) == -1) {
uVar2 = CONCAT71(uVar3,*(char *)(param_2 + 9) != -1);
}
}
else {
iVar4 = (uint)*(byte *)(param_2 + 8) + *(int *)(param_1 + 0x3f0);
uVar2 = CONCAT71((uint7)(uint3)((uint)*(int *)(param_1 + 0x3f0) >> 8),1);
if (0xff < iVar4 + 1U) {
bVar5 = *(byte *)(param_2 + 9);
if (bVar5 != 0xff) {
iVar4 = iVar4 + -0xfe;
do {
iVar4 = iVar4 + -1;
if (iVar4 == 0) {
return uVar2;
}
bVar5 = *(byte *)(param_2 + (ulong)*(uint *)(param_1 + 0x7bc) + -5 + (ulong)bVar5 * -4);
} while (bVar5 != 0xff);
}
uVar2 = 0;
}
}
return uVar2;
}
|
|
60,620
|
mysql_local_infile_end
|
eloqsql/libmariadb/libmariadb/ma_loaddata.c
|
static
void mysql_local_infile_end(void *ptr)
{
MYSQL_INFILE_INFO *info = (MYSQL_INFILE_INFO *)ptr;
if (info)
{
if (info->fp)
ma_close(info->fp);
free(ptr);
}
return;
}
|
O3
|
c
|
mysql_local_infile_end:
testq %rdi, %rdi
je 0x298ad
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x2989f
callq 0x2e9e0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x135a0
retq
|
mysql_local_infile_end:
test rdi, rdi
jz short locret_298AD
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
mov rdi, [rdi]
test rdi, rdi
jz short loc_2989F
call ma_close
loc_2989F:
mov rdi, rbx
add rsp, 8
pop rbx
pop rbp
jmp _free
locret_298AD:
retn
|
long long mysql_local_infile_end(long long *a1)
{
long long v2; // rdi
long long result; // rax
if ( a1 )
{
v2 = *a1;
if ( v2 )
ma_close(v2);
return free(a1);
}
return result;
}
|
mysql_local_infile_end:
TEST RDI,RDI
JZ 0x001298ad
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV RDI,qword ptr [RDI]
TEST RDI,RDI
JZ 0x0012989f
CALL 0x0012e9e0
LAB_0012989f:
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x001135a0
LAB_001298ad:
RET
|
void mysql_local_infile_end(long *param_1)
{
if (param_1 != (long *)0x0) {
if (*param_1 != 0) {
ma_close();
}
free(param_1);
return;
}
return;
}
|
|
60,621
|
mysql_load_plugin_v
|
eloqsql/build_O3/libmariadb/libmariadb/ma_client_plugin.c
|
struct st_mysql_client_plugin * STDCALL
mysql_load_plugin_v(MYSQL *mysql, const char *name, int type,
int argc, va_list args)
{
const char *errmsg;
#ifdef _WIN32
char errbuf[1024];
#endif
char dlpath[FN_REFLEN+1];
void *sym, *dlhandle = NULL;
struct st_mysql_client_plugin *plugin;
char *env_plugin_dir= getenv("MARIADB_PLUGIN_DIR");
CLEAR_CLIENT_ERROR(mysql);
if (is_not_initialized(mysql, name))
return NULL;
pthread_mutex_lock(&LOCK_load_client_plugin);
/* make sure the plugin wasn't loaded meanwhile */
if (type >= 0 && find_plugin(name, type))
{
errmsg= "it is already loaded";
goto err;
}
/* Compile dll path */
#ifndef WIN32
snprintf(dlpath, sizeof(dlpath) - 1, "%s/%s%s",
mysql->options.extension && mysql->options.extension->plugin_dir ?
mysql->options.extension->plugin_dir : (env_plugin_dir) ? env_plugin_dir :
MARIADB_PLUGINDIR, name, SO_EXT);
#else
{
char *p= (mysql->options.extension && mysql->options.extension->plugin_dir) ?
mysql->options.extension->plugin_dir : env_plugin_dir;
snprintf(dlpath, sizeof(dlpath), "%s%s%s%s", p ? p : "", p ? "\\" : "", name, SO_EXT);
}
#endif
if (strpbrk(name, "()[]!@#$%^&/*;.,'?\\"))
{
errmsg= "invalid plugin name";
goto err;
}
/* Open new dll handle */
if (!(dlhandle= dlopen((const char *)dlpath, RTLD_NOW)))
{
#ifdef _WIN32
char winmsg[255];
size_t len;
winmsg[0] = 0;
FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM,
NULL,
GetLastError(),
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
winmsg, 255, NULL);
len= strlen(winmsg);
while (len > 0 && (winmsg[len - 1] == '\n' || winmsg[len - 1] == '\r'))
len--;
if (len)
winmsg[len] = 0;
snprintf(errbuf, sizeof(errbuf), "%s Library path is '%s'", winmsg, dlpath);
errmsg= errbuf;
#else
errmsg= dlerror();
#endif
goto err;
}
if (!(sym= dlsym(dlhandle, plugin_declarations_sym)))
{
errmsg= "not a plugin";
(void)dlclose(dlhandle);
goto err;
}
plugin= (struct st_mysql_client_plugin*)sym;
if (type >=0 && type != plugin->type)
{
errmsg= "type mismatch";
goto err;
}
if (strcmp(name, plugin->name))
{
errmsg= "name mismatch";
goto err;
}
if (type < 0 && find_plugin(name, plugin->type))
{
errmsg= "it is already loaded";
goto err;
}
plugin= add_plugin(mysql, plugin, dlhandle, argc, args);
pthread_mutex_unlock(&LOCK_load_client_plugin);
return plugin;
err:
if (dlhandle)
dlclose(dlhandle);
pthread_mutex_unlock(&LOCK_load_client_plugin);
my_set_error(mysql, CR_AUTH_PLUGIN_CANNOT_LOAD, SQLSTATE_UNKNOWN,
ER(CR_AUTH_PLUGIN_CANNOT_LOAD), name, errmsg);
return NULL;
}
|
O3
|
c
|
mysql_load_plugin_v:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp # imm = 0x238
movq %r8, -0x258(%rbp)
movl %ecx, %r12d
movl %edx, %r13d
movq %rsi, %rbx
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
leaq 0x52312(%rip), %rdi # 0xbdb74
callq 0x3a8c0
movq %rax, %r15
movl $0x0, 0x90(%r14)
movl $0x30303030, 0x297(%r14) # imm = 0x30303030
movw $0x30, 0x29b(%r14)
movb $0x0, 0x97(%r14)
movq 0x2a0(%r14), %rax
testq %rax, %rax
je 0x6b8a5
movl $0x0, 0x4(%rax)
cmpb $0x0, 0x37cc44(%rip) # 0x3e84f0
je 0x6b8db
leaq 0x37cc43(%rip), %rdi # 0x3e84f8
callq 0x3a310
testl %r13d, %r13d
js 0x6b90d
movq %rbx, %rdi
movl %r13d, %esi
callq 0x6b7b7
testq %rax, %rax
je 0x6b90d
leaq 0x522b1(%rip), %r15 # 0xbdb87
jmp 0x6ba17
leaq 0x3021ce(%rip), %rax # 0x36dab0
movq (%rax), %rdx
leaq 0x3021d4(%rip), %rax # 0x36dac0
movq 0x1d8(%rax), %rcx
leaq 0x5239d(%rip), %r9 # 0xbdc97
xorl %r12d, %r12d
movq %r14, %rdi
movl $0x80b, %esi # imm = 0x80B
movq %rbx, %r8
jmp 0x6ba4c
movq 0x480(%r14), %rax
testq %rax, %rax
je 0x6b921
movq (%rax), %r9
testq %r9, %r9
jne 0x6b92f
testq %r15, %r15
leaq 0x52279(%rip), %r9 # 0xbdba4
cmovneq %r15, %r9
leaq 0x5228c(%rip), %r10 # 0xbdbc2
leaq 0x5225f(%rip), %r8 # 0xbdb9c
leaq -0x240(%rbp), %rdi
movl $0x200, %esi # imm = 0x200
movl $0x201, %ecx # imm = 0x201
movl $0x1, %edx
xorl %eax, %eax
pushq %r10
pushq %rbx
callq 0x3ae10
addq $0x10, %rsp
leaq 0x5225e(%rip), %rsi # 0xbdbc6
movq %rbx, %rdi
callq 0x3a640
testq %rax, %rax
je 0x6b981
leaq 0x5225e(%rip), %r15 # 0xbdbda
jmp 0x6ba17
leaq -0x240(%rbp), %rdi
movl $0x2, %esi
callq 0x3aa30
testq %rax, %rax
je 0x6b9e6
movl %r12d, -0x24c(%rbp)
leaq 0x52249(%rip), %rsi # 0xbdbee
movq %rax, %r12
movq %rax, %rdi
callq 0x3a220
testq %rax, %rax
je 0x6b9f0
movq %rax, %r15
movq %r12, -0x248(%rbp)
testl %r13d, %r13d
js 0x6b9c9
cmpl %r13d, (%r15)
jne 0x6ba01
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0x3a9c0
testl %eax, %eax
je 0x6ba77
leaq 0x52247(%rip), %r15 # 0xbdc2b
jmp 0x6ba08
callq 0x3a3f0
movq %rax, %r15
jmp 0x6ba17
movq %r12, %rdi
callq 0x3ac50
leaq 0x52211(%rip), %r15 # 0xbdc10
jmp 0x6ba0f
leaq 0x52215(%rip), %r15 # 0xbdc1d
movq -0x248(%rbp), %r12
movq %r12, %rdi
callq 0x3ac50
leaq 0x37cada(%rip), %rdi # 0x3e84f8
callq 0x3a2d0
leaq 0x302086(%rip), %rax # 0x36dab0
movq (%rax), %rdx
leaq 0x30208c(%rip), %rax # 0x36dac0
movq 0x1d8(%rax), %rcx
xorl %r12d, %r12d
movq %r14, %rdi
movl $0x80b, %esi # imm = 0x80B
movq %rbx, %r8
movq %r15, %r9
xorl %eax, %eax
callq 0x5986d
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x6bac8
movq %r12, %rax
addq $0x238, %rsp # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %r13d, %r13d
js 0x6baac
movq %r14, %rdi
movq %r15, %rsi
movq -0x248(%rbp), %rdx
movl -0x24c(%rbp), %ecx
movq -0x258(%rbp), %r8
callq 0x6b528
movq %rax, %r12
leaq 0x37ca53(%rip), %rdi # 0x3e84f8
callq 0x3a2d0
jmp 0x6ba53
movl (%r15), %esi
movq %rbx, %rdi
callq 0x6b7b7
testq %rax, %rax
je 0x6ba7c
leaq 0x520c4(%rip), %r15 # 0xbdb87
jmp 0x6ba08
callq 0x3a340
|
mysql_load_plugin_v:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 238h
mov [rbp+var_258], r8
mov r12d, ecx
mov r13d, edx
mov rbx, rsi
mov r14, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
lea rdi, aMariadbPluginD; "MARIADB_PLUGIN_DIR"
call _getenv
mov r15, rax
mov dword ptr [r14+90h], 0
mov dword ptr [r14+297h], 30303030h
mov word ptr [r14+29Bh], 30h ; '0'
mov byte ptr [r14+97h], 0
mov rax, [r14+2A0h]
test rax, rax
jz short loc_6B8A5
mov dword ptr [rax+4], 0
loc_6B8A5:
cmp cs:initialized, 0
jz short loc_6B8DB
lea rdi, LOCK_load_client_plugin
call _pthread_mutex_lock
test r13d, r13d
js short loc_6B90D
mov rdi, rbx
mov esi, r13d
call find_plugin
test rax, rax
jz short loc_6B90D
lea r15, aItIsAlreadyLoa; "it is already loaded"
jmp loc_6BA17
loc_6B8DB:
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
lea rax, client_errors
mov rcx, [rax+1D8h]
lea r9, aNotInitialized; "not initialized"
xor r12d, r12d
mov rdi, r14
mov esi, 80Bh
mov r8, rbx
jmp loc_6BA4C
loc_6B90D:
mov rax, [r14+480h]
test rax, rax
jz short loc_6B921
mov r9, [rax]
test r9, r9
jnz short loc_6B92F
loc_6B921:
test r15, r15
lea r9, aHomeMonoInstal; "/home/mono/install/lib/plugin"
cmovnz r9, r15
loc_6B92F:
lea r10, aSo; ".so"
lea r8, aSSS_2; "%s/%s%s"
lea rdi, [rbp+var_240]
mov esi, 200h
mov ecx, 201h
mov edx, 1
xor eax, eax
push r10
push rbx
call ___snprintf_chk
add rsp, 10h
lea rsi, asc_BDBC6; "()[]!@#$%^&/*;.,'?\\"
mov rdi, rbx
call _strpbrk
test rax, rax
jz short loc_6B981
lea r15, aInvalidPluginN; "invalid plugin name"
jmp loc_6BA17
loc_6B981:
lea rdi, [rbp+var_240]
mov esi, 2
call _dlopen
test rax, rax
jz short loc_6B9E6
mov [rbp+var_24C], r12d
lea rsi, aMysqlClientPlu; "_mysql_client_plugin_declaration_"
mov r12, rax
mov rdi, rax
call _dlsym
test rax, rax
jz short loc_6B9F0
mov r15, rax
mov [rbp+var_248], r12
test r13d, r13d
js short loc_6B9C9
cmp [r15], r13d
jnz short loc_6BA01
loc_6B9C9:
mov rsi, [r15+8]
mov rdi, rbx
call _strcmp
test eax, eax
jz loc_6BA77
lea r15, aNameMismatch; "name mismatch"
jmp short loc_6BA08
loc_6B9E6:
call _dlerror
mov r15, rax
jmp short loc_6BA17
loc_6B9F0:
mov rdi, r12
call _dlclose
lea r15, aNotAPlugin; "not a plugin"
jmp short loc_6BA0F
loc_6BA01:
lea r15, aTypeMismatch; "type mismatch"
loc_6BA08:
mov r12, [rbp+var_248]
loc_6BA0F:
mov rdi, r12
call _dlclose
loc_6BA17:
lea rdi, LOCK_load_client_plugin
call _pthread_mutex_unlock
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
lea rax, client_errors
mov rcx, [rax+1D8h]
xor r12d, r12d
mov rdi, r14
mov esi, 80Bh
mov r8, rbx
mov r9, r15
loc_6BA4C:
xor eax, eax
call my_set_error
loc_6BA53:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_6BAC8
mov rax, r12
add rsp, 238h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_6BA77:
test r13d, r13d
js short loc_6BAAC
loc_6BA7C:
mov rdi, r14
mov rsi, r15
mov rdx, [rbp+var_248]
mov ecx, [rbp+var_24C]
mov r8, [rbp+var_258]
call add_plugin
mov r12, rax
lea rdi, LOCK_load_client_plugin
call _pthread_mutex_unlock
jmp short loc_6BA53
loc_6BAAC:
mov esi, [r15]
mov rdi, rbx
call find_plugin
test rax, rax
jz short loc_6BA7C
lea r15, aItIsAlreadyLoa; "it is already loaded"
jmp loc_6BA08
loc_6BAC8:
call ___stack_chk_fail
|
long long mysql_load_plugin_v(long long a1, const char *a2, int a3, unsigned int a4, long long a5)
{
long long v7; // r15
long long v8; // rax
const char *v9; // r15
long long v10; // r12
const char **v11; // rax
const char *v12; // r9
double v13; // xmm0_8
long long v14; // rax
long long v15; // r12
long long v16; // rax
int *v17; // r15
unsigned int v20; // [rsp+14h] [rbp-24Ch]
_BYTE v21[528]; // [rsp+20h] [rbp-240h] BYREF
unsigned long long v22; // [rsp+230h] [rbp-30h]
v22 = __readfsqword(0x28u);
v7 = getenv("MARIADB_PLUGIN_DIR");
*(_DWORD *)(a1 + 144) = 0;
strcpy((char *)(a1 + 663), "00000");
*(_BYTE *)(a1 + 151) = 0;
v8 = *(_QWORD *)(a1 + 672);
if ( v8 )
*(_DWORD *)(v8 + 4) = 0;
if ( initialized )
{
pthread_mutex_lock(&LOCK_load_client_plugin);
if ( a3 >= 0 && find_plugin((long long)a2, a3) )
{
v9 = "it is already loaded";
}
else
{
v11 = *(const char ***)(a1 + 1152);
if ( !v11 || (v12 = *v11) == 0LL )
{
v12 = "/home/mono/install/lib/plugin";
if ( v7 )
v12 = (const char *)v7;
}
v13 = __snprintf_chk(v21, 512LL, 1LL, 513LL, "%s/%s%s", v12, a2, ".so");
if ( strpbrk(a2, "()[]!@#$%^&/*;.,'?\\", v13) )
{
v9 = "invalid plugin name";
}
else
{
v14 = dlopen(v21, 2LL);
if ( v14 )
{
v20 = a4;
v15 = v14;
v16 = dlsym(v14, "_mysql_client_plugin_declaration_");
if ( v16 )
{
v17 = (int *)v16;
if ( a3 < 0 || *(_DWORD *)v16 == a3 )
{
if ( !(unsigned int)strcmp(a2, *(_QWORD *)(v16 + 8)) )
{
if ( a3 >= 0 || !find_plugin((long long)a2, *v17) )
{
v10 = add_plugin(a1, (long long)v17, v15, v20, a5);
pthread_mutex_unlock(&LOCK_load_client_plugin);
return v10;
}
v9 = "it is already loaded";
}
else
{
v9 = "name mismatch";
}
}
else
{
v9 = "type mismatch";
}
}
else
{
dlclose(v15);
v9 = "not a plugin";
}
dlclose(v15);
}
else
{
v9 = (const char *)dlerror();
}
}
}
pthread_mutex_unlock(&LOCK_load_client_plugin);
v10 = 0LL;
my_set_error(a1, 2059, (long long)SQLSTATE_UNKNOWN, client_errors[59], a2, v9);
}
else
{
v10 = 0LL;
my_set_error(a1, 2059, (long long)SQLSTATE_UNKNOWN, client_errors[59], a2, "not initialized");
}
return v10;
}
|
mysql_load_plugin_v:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x238
MOV qword ptr [RBP + -0x258],R8
MOV R12D,ECX
MOV R13D,EDX
MOV RBX,RSI
MOV R14,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
LEA RDI,[0x1bdb74]
CALL 0x0013a8c0
MOV R15,RAX
MOV dword ptr [R14 + 0x90],0x0
MOV dword ptr [R14 + 0x297],0x30303030
MOV word ptr [R14 + 0x29b],0x30
MOV byte ptr [R14 + 0x97],0x0
MOV RAX,qword ptr [R14 + 0x2a0]
TEST RAX,RAX
JZ 0x0016b8a5
MOV dword ptr [RAX + 0x4],0x0
LAB_0016b8a5:
CMP byte ptr [0x004e84f0],0x0
JZ 0x0016b8db
LEA RDI,[0x4e84f8]
CALL 0x0013a310
TEST R13D,R13D
JS 0x0016b90d
MOV RDI,RBX
MOV ESI,R13D
CALL 0x0016b7b7
TEST RAX,RAX
JZ 0x0016b90d
LEA R15,[0x1bdb87]
JMP 0x0016ba17
LAB_0016b8db:
LEA RAX,[0x46dab0]
MOV RDX,qword ptr [RAX]
LEA RAX,[0x46dac0]
MOV RCX,qword ptr [RAX + 0x1d8]
LEA R9,[0x1bdc97]
XOR R12D,R12D
MOV RDI,R14
MOV ESI,0x80b
MOV R8,RBX
JMP 0x0016ba4c
LAB_0016b90d:
MOV RAX,qword ptr [R14 + 0x480]
TEST RAX,RAX
JZ 0x0016b921
MOV R9,qword ptr [RAX]
TEST R9,R9
JNZ 0x0016b92f
LAB_0016b921:
TEST R15,R15
LEA R9,[0x1bdba4]
CMOVNZ R9,R15
LAB_0016b92f:
LEA R10,[0x1bdbc2]
LEA R8,[0x1bdb9c]
LEA RDI,[RBP + -0x240]
MOV ESI,0x200
MOV ECX,0x201
MOV EDX,0x1
XOR EAX,EAX
PUSH R10
PUSH RBX
CALL 0x0013ae10
ADD RSP,0x10
LEA RSI,[0x1bdbc6]
MOV RDI,RBX
CALL 0x0013a640
TEST RAX,RAX
JZ 0x0016b981
LEA R15,[0x1bdbda]
JMP 0x0016ba17
LAB_0016b981:
LEA RDI,[RBP + -0x240]
MOV ESI,0x2
CALL 0x0013aa30
TEST RAX,RAX
JZ 0x0016b9e6
MOV dword ptr [RBP + -0x24c],R12D
LEA RSI,[0x1bdbee]
MOV R12,RAX
MOV RDI,RAX
CALL 0x0013a220
TEST RAX,RAX
JZ 0x0016b9f0
MOV R15,RAX
MOV qword ptr [RBP + -0x248],R12
TEST R13D,R13D
JS 0x0016b9c9
CMP dword ptr [R15],R13D
JNZ 0x0016ba01
LAB_0016b9c9:
MOV RSI,qword ptr [R15 + 0x8]
MOV RDI,RBX
CALL 0x0013a9c0
TEST EAX,EAX
JZ 0x0016ba77
LEA R15,[0x1bdc2b]
JMP 0x0016ba08
LAB_0016b9e6:
CALL 0x0013a3f0
MOV R15,RAX
JMP 0x0016ba17
LAB_0016b9f0:
MOV RDI,R12
CALL 0x0013ac50
LEA R15,[0x1bdc10]
JMP 0x0016ba0f
LAB_0016ba01:
LEA R15,[0x1bdc1d]
LAB_0016ba08:
MOV R12,qword ptr [RBP + -0x248]
LAB_0016ba0f:
MOV RDI,R12
CALL 0x0013ac50
LAB_0016ba17:
LEA RDI,[0x4e84f8]
CALL 0x0013a2d0
LEA RAX,[0x46dab0]
MOV RDX,qword ptr [RAX]
LEA RAX,[0x46dac0]
MOV RCX,qword ptr [RAX + 0x1d8]
XOR R12D,R12D
MOV RDI,R14
MOV ESI,0x80b
MOV R8,RBX
MOV R9,R15
LAB_0016ba4c:
XOR EAX,EAX
CALL 0x0015986d
LAB_0016ba53:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0016bac8
MOV RAX,R12
ADD RSP,0x238
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0016ba77:
TEST R13D,R13D
JS 0x0016baac
LAB_0016ba7c:
MOV RDI,R14
MOV RSI,R15
MOV RDX,qword ptr [RBP + -0x248]
MOV ECX,dword ptr [RBP + -0x24c]
MOV R8,qword ptr [RBP + -0x258]
CALL 0x0016b528
MOV R12,RAX
LEA RDI,[0x4e84f8]
CALL 0x0013a2d0
JMP 0x0016ba53
LAB_0016baac:
MOV ESI,dword ptr [R15]
MOV RDI,RBX
CALL 0x0016b7b7
TEST RAX,RAX
JZ 0x0016ba7c
LEA R15,[0x1bdb87]
JMP 0x0016ba08
LAB_0016bac8:
CALL 0x0013a340
|
int8
mysql_load_plugin_v(long param_1,char *param_2,int param_3,int4 param_4,int8 param_5)
{
int iVar1;
char *pcVar2;
long lVar3;
int *piVar4;
int8 uVar5;
long lVar6;
char *pcVar7;
long in_FS_OFFSET;
int1 local_248 [528];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
pcVar2 = getenv("MARIADB_PLUGIN_DIR");
*(int4 *)(param_1 + 0x90) = 0;
*(int4 *)(param_1 + 0x297) = 0x30303030;
*(int2 *)(param_1 + 0x29b) = 0x30;
*(int1 *)(param_1 + 0x97) = 0;
if (*(long *)(param_1 + 0x2a0) != 0) {
*(int4 *)(*(long *)(param_1 + 0x2a0) + 4) = 0;
}
if (initialized == '\0') {
pcVar2 = "not initialized";
}
else {
pthread_mutex_lock((pthread_mutex_t *)LOCK_load_client_plugin);
if ((param_3 < 0) || (lVar3 = find_plugin(param_2,param_3), lVar3 == 0)) {
if (((*(long **)(param_1 + 0x480) == (long *)0x0) ||
(pcVar7 = (char *)**(long **)(param_1 + 0x480), pcVar7 == (char *)0x0)) &&
(pcVar7 = "/home/mono/install/lib/plugin", pcVar2 != (char *)0x0)) {
pcVar7 = pcVar2;
}
__snprintf_chk(local_248,0x200,1,0x201,"%s/%s%s",pcVar7,param_2,&DAT_001bdbc2);
pcVar2 = strpbrk(param_2,"()[]!@#$%^&/*;.,\'?\\");
if (pcVar2 == (char *)0x0) {
lVar3 = dlopen(local_248,2);
if (lVar3 == 0) {
pcVar2 = (char *)dlerror();
}
else {
piVar4 = (int *)dlsym(lVar3,"_mysql_client_plugin_declaration_");
if (piVar4 == (int *)0x0) {
dlclose(lVar3);
pcVar2 = "not a plugin";
}
else if ((param_3 < 0) || (*piVar4 == param_3)) {
iVar1 = strcmp(param_2,*(char **)(piVar4 + 2));
if (iVar1 == 0) {
if ((-1 < param_3) || (lVar6 = find_plugin(param_2,*piVar4), lVar6 == 0)) {
uVar5 = add_plugin(param_1,piVar4,lVar3,param_4,param_5);
pthread_mutex_unlock((pthread_mutex_t *)LOCK_load_client_plugin);
goto LAB_0016ba53;
}
pcVar2 = "it is already loaded";
}
else {
pcVar2 = "name mismatch";
}
}
else {
pcVar2 = "type mismatch";
}
dlclose(lVar3);
}
}
else {
pcVar2 = "invalid plugin name";
}
}
else {
pcVar2 = "it is already loaded";
}
pthread_mutex_unlock((pthread_mutex_t *)LOCK_load_client_plugin);
}
uVar5 = 0;
my_set_error(param_1,0x80b,SQLSTATE_UNKNOWN,PTR_s_Plugin__s_could_not_be_loaded____0046dc98,
param_2,pcVar2);
LAB_0016ba53:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar5;
}
|
|
60,622
|
my_strxfrm_pad_nweights_unicode
|
eloqsql/strings/ctype-utf8.c
|
size_t
my_strxfrm_pad_nweights_unicode(uchar *str, uchar *strend, size_t nweights)
{
uchar *str0;
DBUG_ASSERT(str && str <= strend);
for (str0= str; str < strend && nweights; nweights--)
{
*str++= 0x00;
if (str < strend)
*str++= 0x20;
}
return str - str0;
}
|
O0
|
c
|
my_strxfrm_pad_nweights_unicode:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0x147542
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x21(%rbp)
jae 0x147564
cmpq $0x0, -0x18(%rbp)
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x14756d
jmp 0x1475ab
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x14759b
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0x20, (%rax)
jmp 0x14759d
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x14754a
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
popq %rbp
retq
nopl (%rax,%rax)
|
my_strxfrm_pad_nweights_unicode:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
jmp short $+2
loc_147542:
mov rax, [rbp+var_8]
mov [rbp+var_20], rax
loc_14754A:
mov rcx, [rbp+var_8]
xor eax, eax
cmp rcx, [rbp+var_10]
mov [rbp+var_21], al
jnb short loc_147564
cmp [rbp+var_18], 0
setnz al
mov [rbp+var_21], al
loc_147564:
mov al, [rbp+var_21]
test al, 1
jnz short loc_14756D
jmp short loc_1475AB
loc_14756D:
mov rax, [rbp+var_8]
mov rcx, rax
add rcx, 1
mov [rbp+var_8], rcx
mov byte ptr [rax], 0
mov rax, [rbp+var_8]
cmp rax, [rbp+var_10]
jnb short loc_14759B
mov rax, [rbp+var_8]
mov rcx, rax
add rcx, 1
mov [rbp+var_8], rcx
mov byte ptr [rax], 20h ; ' '
loc_14759B:
jmp short $+2
loc_14759D:
mov rax, [rbp+var_18]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_18], rax
jmp short loc_14754A
loc_1475AB:
mov rax, [rbp+var_8]
mov rcx, [rbp+var_20]
sub rax, rcx
pop rbp
retn
|
_BYTE * my_strxfrm_pad_nweights_unicode(_BYTE *a1, unsigned long long a2, long long a3)
{
_BYTE *v3; // rax
_BYTE *v4; // rax
bool v6; // [rsp+1h] [rbp-21h]
_BYTE *v8; // [rsp+1Ah] [rbp-8h]
v8 = a1;
while ( 1 )
{
v6 = 0;
if ( (unsigned long long)v8 < a2 )
v6 = a3 != 0;
if ( !v6 )
break;
v3 = v8++;
*v3 = 0;
if ( (unsigned long long)v8 < a2 )
{
v4 = v8++;
*v4 = 32;
}
--a3;
}
return (_BYTE *)(v8 - a1);
}
|
_ma_delete_static_record:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x20],RDI
MOV qword ptr [RBP + -0x28],RSI
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x20]
MOV RCX,qword ptr [RAX + 0x8]
INC RCX
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x20]
MOV RDX,qword ptr [RCX + 0x3a0]
MOV RCX,qword ptr [RAX + 0x10]
ADD RCX,RDX
MOV qword ptr [RAX + 0x10],RCX
MOV byte ptr [RBP + -0x11],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,qword ptr [RAX]
LEA RSI,[RBP + -0x10]
MOV RDX,qword ptr [RDI + 0xc8]
CALL 0x0013be80
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RCX]
MOV RCX,qword ptr [RCX + 0x98]
MOV qword ptr [RAX + 0xc8],RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x598],0x1
MOV RDI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RDI]
MOV RCX,qword ptr [RDI + 0x98]
MOV RAX,qword ptr [RDX + 0x6e8]
MOV EDX,dword ptr [RDX + 0x740]
INC EDX
LEA RSI,[RBP + -0x11]
MOV R8D,0x4
CALL RAX
TEST RAX,RAX
SETNZ AL
MOV byte ptr [RBP + -0x29],AL
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00147608
MOV AL,byte ptr [RBP + -0x29]
ADD RSP,0x30
POP RBP
RET
LAB_00147608:
CALL 0x0012a250
|
int8 _ma_delete_static_record(long *param_1)
{
long lVar1;
long in_FS_OFFSET;
int1 local_19;
int1 local_18 [8];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
*(long *)(param_1[4] + 8) = *(long *)(param_1[4] + 8) + 1;
*(long *)(param_1[4] + 0x10) = *(long *)(param_1[4] + 0x10) + *(long *)(*param_1 + 0x3a0);
local_19 = 0;
_ma_dpointer(*param_1,local_18,*(int8 *)(*param_1 + 200));
*(long *)(*param_1 + 200) = param_1[0x13];
*(int4 *)(param_1 + 0xb3) = 1;
lVar1 = (**(code **)(*param_1 + 0x6e8))
(param_1,&local_19,*(int *)(*param_1 + 0x740) + 1,param_1[0x13],4);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return CONCAT71((int7)((ulong)*(long *)(in_FS_OFFSET + 0x28) >> 8),lVar1 != 0);
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
60,623
|
JS_NewClass1
|
bluesky950520[P]quickjs/quickjs.c
|
static int JS_NewClass1(JSRuntime *rt, JSClassID class_id,
const JSClassDef *class_def, JSAtom name)
{
int new_size, i;
JSClass *cl, *new_class_array;
struct list_head *el;
if (class_id >= (1 << 16))
return -1;
if (class_id < rt->class_count &&
rt->class_array[class_id].class_id != 0)
return -1;
if (class_id >= rt->class_count) {
new_size = max_int(JS_CLASS_INIT_COUNT,
max_int(class_id + 1, rt->class_count * 3 / 2));
/* reallocate the context class prototype array, if any */
list_for_each(el, &rt->context_list) {
JSContext *ctx = list_entry(el, JSContext, link);
JSValue *new_tab;
new_tab = js_realloc_rt(rt, ctx->class_proto,
sizeof(ctx->class_proto[0]) * new_size);
if (!new_tab)
return -1;
for(i = rt->class_count; i < new_size; i++)
new_tab[i] = JS_NULL;
ctx->class_proto = new_tab;
}
/* reallocate the class array */
new_class_array = js_realloc_rt(rt, rt->class_array,
sizeof(JSClass) * new_size);
if (!new_class_array)
return -1;
memset(new_class_array + rt->class_count, 0,
(new_size - rt->class_count) * sizeof(JSClass));
rt->class_array = new_class_array;
rt->class_count = new_size;
}
cl = &rt->class_array[class_id];
cl->class_id = class_id;
cl->class_name = JS_DupAtomRT(rt, name);
cl->finalizer = class_def->finalizer;
cl->gc_mark = class_def->gc_mark;
cl->call = class_def->call;
cl->exotic = class_def->exotic;
return 0;
}
|
O0
|
c
|
JS_NewClass1:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movl %esi, 0x54(%rsp)
movq %rdx, 0x48(%rsp)
movl %ecx, 0x44(%rsp)
cmpl $0x10000, 0x54(%rsp) # imm = 0x10000
jb 0x293ed
movl $0xffffffff, 0x64(%rsp) # imm = 0xFFFFFFFF
jmp 0x2965c
movl 0x54(%rsp), %eax
movq 0x58(%rsp), %rcx
cmpl 0x78(%rcx), %eax
jae 0x29424
movq 0x58(%rsp), %rax
movq 0x80(%rax), %rax
movl 0x54(%rsp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, (%rax)
je 0x29424
movl $0xffffffff, 0x64(%rsp) # imm = 0xFFFFFFFF
jmp 0x2965c
movl 0x54(%rsp), %eax
movq 0x58(%rsp), %rcx
cmpl 0x78(%rcx), %eax
jb 0x295cd
movl 0x54(%rsp), %edi
addl $0x1, %edi
movq 0x58(%rsp), %rax
imull $0x3, 0x78(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %esi
callq 0x5d310
movl %eax, %esi
movl $0x3d, %edi
callq 0x5d310
movl %eax, 0x40(%rsp)
movq 0x58(%rsp), %rax
movq 0x90(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x58(%rsp), %rcx
addq $0x88, %rcx
cmpq %rcx, %rax
je 0x29549
movq 0x20(%rsp), %rax
addq $-0x20, %rax
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rsi
movslq 0x40(%rsp), %rdx
shlq $0x4, %rdx
callq 0x219e0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x294d4
movl $0xffffffff, 0x64(%rsp) # imm = 0xFFFFFFFF
jmp 0x2965c
movq 0x58(%rsp), %rax
movl 0x78(%rax), %eax
movl %eax, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
cmpl 0x40(%rsp), %eax
jge 0x29528
movq 0x10(%rsp), %rax
movslq 0x3c(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl $0x0, (%rsp)
movq $0x2, 0x8(%rsp)
movq (%rsp), %rcx
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x294e0
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x40(%rax)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x29476
movq 0x58(%rsp), %rdi
movq 0x58(%rsp), %rax
movq 0x80(%rax), %rsi
movslq 0x40(%rsp), %rax
imulq $0x28, %rax, %rdx
callq 0x219e0
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x29582
movl $0xffffffff, 0x64(%rsp) # imm = 0xFFFFFFFF
jmp 0x2965c
movq 0x28(%rsp), %rdi
movq 0x58(%rsp), %rax
movslq 0x78(%rax), %rax
imulq $0x28, %rax, %rax
addq %rax, %rdi
movl 0x40(%rsp), %eax
movq 0x58(%rsp), %rcx
subl 0x78(%rcx), %eax
cltq
imulq $0x28, %rax, %rdx
xorl %esi, %esi
callq 0xe350
movq 0x28(%rsp), %rcx
movq 0x58(%rsp), %rax
movq %rcx, 0x80(%rax)
movl 0x40(%rsp), %ecx
movq 0x58(%rsp), %rax
movl %ecx, 0x78(%rax)
movq 0x58(%rsp), %rax
movq 0x80(%rax), %rax
movl 0x54(%rsp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x30(%rsp)
movl 0x54(%rsp), %ecx
movq 0x30(%rsp), %rax
movl %ecx, (%rax)
movq 0x58(%rsp), %rdi
movl 0x44(%rsp), %esi
callq 0x5d640
movl %eax, %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x48(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x48(%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x48(%rsp), %rax
movq 0x20(%rax), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x20(%rax)
movl $0x0, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
|
JS_NewClass1:
sub rsp, 68h
mov [rsp+68h+var_10], rdi
mov [rsp+68h+var_14], esi
mov [rsp+68h+var_20], rdx
mov [rsp+68h+var_24], ecx
cmp [rsp+68h+var_14], 10000h
jb short loc_293ED
mov [rsp+68h+var_4], 0FFFFFFFFh
jmp loc_2965C
loc_293ED:
mov eax, [rsp+68h+var_14]
mov rcx, [rsp+68h+var_10]
cmp eax, [rcx+78h]
jnb short loc_29424
mov rax, [rsp+68h+var_10]
mov rax, [rax+80h]
mov ecx, [rsp+68h+var_14]
imul rcx, 28h ; '('
add rax, rcx
cmp dword ptr [rax], 0
jz short loc_29424
mov [rsp+68h+var_4], 0FFFFFFFFh
jmp loc_2965C
loc_29424:
mov eax, [rsp+68h+var_14]
mov rcx, [rsp+68h+var_10]
cmp eax, [rcx+78h]
jb loc_295CD
mov edi, [rsp+68h+var_14]
add edi, 1
mov rax, [rsp+68h+var_10]
imul eax, [rax+78h], 3
mov ecx, 2
cdq
idiv ecx
mov esi, eax
call max_int_0
mov esi, eax
mov edi, 3Dh ; '='
call max_int_0
mov [rsp+68h+var_28], eax
mov rax, [rsp+68h+var_10]
mov rax, [rax+90h]
mov [rsp+68h+var_48], rax
loc_29476:
mov rax, [rsp+68h+var_48]
mov rcx, [rsp+68h+var_10]
add rcx, 88h
cmp rax, rcx
jz loc_29549
mov rax, [rsp+68h+var_48]
add rax, 0FFFFFFFFFFFFFFE0h
mov [rsp+68h+var_50], rax
mov rdi, [rsp+68h+var_10]
mov rax, [rsp+68h+var_50]
mov rsi, [rax+40h]
movsxd rdx, [rsp+68h+var_28]
shl rdx, 4
call js_realloc_rt
mov [rsp+68h+var_58], rax
cmp [rsp+68h+var_58], 0
jnz short loc_294D4
mov [rsp+68h+var_4], 0FFFFFFFFh
jmp loc_2965C
loc_294D4:
mov rax, [rsp+68h+var_10]
mov eax, [rax+78h]
mov [rsp+68h+var_2C], eax
loc_294E0:
mov eax, [rsp+68h+var_2C]
cmp eax, [rsp+68h+var_28]
jge short loc_29528
mov rax, [rsp+68h+var_58]
movsxd rcx, [rsp+68h+var_2C]
shl rcx, 4
add rax, rcx
mov dword ptr [rsp+68h+var_68], 0
mov [rsp+68h+var_60], 2
mov rcx, [rsp+68h+var_68]
mov [rax], rcx
mov rcx, [rsp+68h+var_60]
mov [rax+8], rcx
mov eax, [rsp+68h+var_2C]
add eax, 1
mov [rsp+68h+var_2C], eax
jmp short loc_294E0
loc_29528:
mov rcx, [rsp+68h+var_58]
mov rax, [rsp+68h+var_50]
mov [rax+40h], rcx
mov rax, [rsp+68h+var_48]
mov rax, [rax+8]
mov [rsp+68h+var_48], rax
jmp loc_29476
loc_29549:
mov rdi, [rsp+68h+var_10]
mov rax, [rsp+68h+var_10]
mov rsi, [rax+80h]
movsxd rax, [rsp+68h+var_28]
imul rdx, rax, 28h ; '('
call js_realloc_rt
mov [rsp+68h+var_40], rax
cmp [rsp+68h+var_40], 0
jnz short loc_29582
mov [rsp+68h+var_4], 0FFFFFFFFh
jmp loc_2965C
loc_29582:
mov rdi, [rsp+68h+var_40]
mov rax, [rsp+68h+var_10]
movsxd rax, dword ptr [rax+78h]
imul rax, 28h ; '('
add rdi, rax
mov eax, [rsp+68h+var_28]
mov rcx, [rsp+68h+var_10]
sub eax, [rcx+78h]
cdqe
imul rdx, rax, 28h ; '('
xor esi, esi
call _memset
mov rcx, [rsp+68h+var_40]
mov rax, [rsp+68h+var_10]
mov [rax+80h], rcx
mov ecx, [rsp+68h+var_28]
mov rax, [rsp+68h+var_10]
mov [rax+78h], ecx
loc_295CD:
mov rax, [rsp+68h+var_10]
mov rax, [rax+80h]
mov ecx, [rsp+68h+var_14]
imul rcx, 28h ; '('
add rax, rcx
mov [rsp+68h+var_38], rax
mov ecx, [rsp+68h+var_14]
mov rax, [rsp+68h+var_38]
mov [rax], ecx
mov rdi, [rsp+68h+var_10]
mov esi, [rsp+68h+var_24]
call JS_DupAtomRT
mov ecx, eax
mov rax, [rsp+68h+var_38]
mov [rax+4], ecx
mov rax, [rsp+68h+var_20]
mov rcx, [rax+8]
mov rax, [rsp+68h+var_38]
mov [rax+8], rcx
mov rax, [rsp+68h+var_20]
mov rcx, [rax+10h]
mov rax, [rsp+68h+var_38]
mov [rax+10h], rcx
mov rax, [rsp+68h+var_20]
mov rcx, [rax+18h]
mov rax, [rsp+68h+var_38]
mov [rax+18h], rcx
mov rax, [rsp+68h+var_20]
mov rcx, [rax+20h]
mov rax, [rsp+68h+var_38]
mov [rax+20h], rcx
mov [rsp+68h+var_4], 0
loc_2965C:
mov eax, [rsp+68h+var_4]
add rsp, 68h
retn
|
long long JS_NewClass1(long long a1, unsigned int a2, _QWORD *a3, unsigned int a4)
{
long long v4; // rdx
unsigned int v5; // eax
long long v6; // rdx
_QWORD *v7; // rax
long long v9; // [rsp+0h] [rbp-68h]
long long v10; // [rsp+10h] [rbp-58h]
long long i; // [rsp+20h] [rbp-48h]
long long v12; // [rsp+28h] [rbp-40h]
long long v13; // [rsp+30h] [rbp-38h]
int j; // [rsp+3Ch] [rbp-2Ch]
int v15; // [rsp+40h] [rbp-28h]
if ( a2 < 0x10000 )
{
if ( a2 >= *(_DWORD *)(a1 + 120) || !*(_DWORD *)(40LL * a2 + *(_QWORD *)(a1 + 128)) )
{
if ( a2 >= *(_DWORD *)(a1 + 120) )
{
v4 = (unsigned int)((3 * *(_DWORD *)(a1 + 120)) >> 31);
LODWORD(v4) = 3 * *(_DWORD *)(a1 + 120) % 2;
v5 = max_int_0(a2 + 1, (unsigned int)(3 * *(_DWORD *)(a1 + 120) / 2), v4);
v15 = max_int_0(61LL, v5, v6);
for ( i = *(_QWORD *)(a1 + 144); i != a1 + 136; i = *(_QWORD *)(i + 8) )
{
v10 = js_realloc_rt(a1, *(_QWORD *)(i - 32 + 64), 16LL * v15);
if ( !v10 )
return (unsigned int)-1;
for ( j = *(_DWORD *)(a1 + 120); j < v15; ++j )
{
v7 = (_QWORD *)(16LL * j + v10);
LODWORD(v9) = 0;
*v7 = v9;
v7[1] = 2LL;
}
*(_QWORD *)(i - 32 + 64) = v10;
}
v12 = js_realloc_rt(a1, *(_QWORD *)(a1 + 128), 40LL * v15);
if ( !v12 )
return (unsigned int)-1;
memset(40LL * *(int *)(a1 + 120) + v12, 0LL, 40LL * (v15 - *(_DWORD *)(a1 + 120)));
*(_QWORD *)(a1 + 128) = v12;
*(_DWORD *)(a1 + 120) = v15;
}
v13 = 40LL * a2 + *(_QWORD *)(a1 + 128);
*(_DWORD *)v13 = a2;
*(_DWORD *)(v13 + 4) = JS_DupAtomRT(a1, a4);
*(_QWORD *)(v13 + 8) = a3[1];
*(_QWORD *)(v13 + 16) = a3[2];
*(_QWORD *)(v13 + 24) = a3[3];
*(_QWORD *)(v13 + 32) = a3[4];
return 0;
}
return (unsigned int)-1;
}
else
{
return (unsigned int)-1;
}
}
|
JS_NewClass1:
SUB RSP,0x68
MOV qword ptr [RSP + 0x58],RDI
MOV dword ptr [RSP + 0x54],ESI
MOV qword ptr [RSP + 0x48],RDX
MOV dword ptr [RSP + 0x44],ECX
CMP dword ptr [RSP + 0x54],0x10000
JC 0x001293ed
MOV dword ptr [RSP + 0x64],0xffffffff
JMP 0x0012965c
LAB_001293ed:
MOV EAX,dword ptr [RSP + 0x54]
MOV RCX,qword ptr [RSP + 0x58]
CMP EAX,dword ptr [RCX + 0x78]
JNC 0x00129424
MOV RAX,qword ptr [RSP + 0x58]
MOV RAX,qword ptr [RAX + 0x80]
MOV ECX,dword ptr [RSP + 0x54]
IMUL RCX,RCX,0x28
ADD RAX,RCX
CMP dword ptr [RAX],0x0
JZ 0x00129424
MOV dword ptr [RSP + 0x64],0xffffffff
JMP 0x0012965c
LAB_00129424:
MOV EAX,dword ptr [RSP + 0x54]
MOV RCX,qword ptr [RSP + 0x58]
CMP EAX,dword ptr [RCX + 0x78]
JC 0x001295cd
MOV EDI,dword ptr [RSP + 0x54]
ADD EDI,0x1
MOV RAX,qword ptr [RSP + 0x58]
IMUL EAX,dword ptr [RAX + 0x78],0x3
MOV ECX,0x2
CDQ
IDIV ECX
MOV ESI,EAX
CALL 0x0015d310
MOV ESI,EAX
MOV EDI,0x3d
CALL 0x0015d310
MOV dword ptr [RSP + 0x40],EAX
MOV RAX,qword ptr [RSP + 0x58]
MOV RAX,qword ptr [RAX + 0x90]
MOV qword ptr [RSP + 0x20],RAX
LAB_00129476:
MOV RAX,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [RSP + 0x58]
ADD RCX,0x88
CMP RAX,RCX
JZ 0x00129549
MOV RAX,qword ptr [RSP + 0x20]
ADD RAX,-0x20
MOV qword ptr [RSP + 0x18],RAX
MOV RDI,qword ptr [RSP + 0x58]
MOV RAX,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RAX + 0x40]
MOVSXD RDX,dword ptr [RSP + 0x40]
SHL RDX,0x4
CALL 0x001219e0
MOV qword ptr [RSP + 0x10],RAX
CMP qword ptr [RSP + 0x10],0x0
JNZ 0x001294d4
MOV dword ptr [RSP + 0x64],0xffffffff
JMP 0x0012965c
LAB_001294d4:
MOV RAX,qword ptr [RSP + 0x58]
MOV EAX,dword ptr [RAX + 0x78]
MOV dword ptr [RSP + 0x3c],EAX
LAB_001294e0:
MOV EAX,dword ptr [RSP + 0x3c]
CMP EAX,dword ptr [RSP + 0x40]
JGE 0x00129528
MOV RAX,qword ptr [RSP + 0x10]
MOVSXD RCX,dword ptr [RSP + 0x3c]
SHL RCX,0x4
ADD RAX,RCX
MOV dword ptr [RSP],0x0
MOV qword ptr [RSP + 0x8],0x2
MOV RCX,qword ptr [RSP]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RSP + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV EAX,dword ptr [RSP + 0x3c]
ADD EAX,0x1
MOV dword ptr [RSP + 0x3c],EAX
JMP 0x001294e0
LAB_00129528:
MOV RCX,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RAX + 0x40],RCX
MOV RAX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x20],RAX
JMP 0x00129476
LAB_00129549:
MOV RDI,qword ptr [RSP + 0x58]
MOV RAX,qword ptr [RSP + 0x58]
MOV RSI,qword ptr [RAX + 0x80]
MOVSXD RAX,dword ptr [RSP + 0x40]
IMUL RDX,RAX,0x28
CALL 0x001219e0
MOV qword ptr [RSP + 0x28],RAX
CMP qword ptr [RSP + 0x28],0x0
JNZ 0x00129582
MOV dword ptr [RSP + 0x64],0xffffffff
JMP 0x0012965c
LAB_00129582:
MOV RDI,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x58]
MOVSXD RAX,dword ptr [RAX + 0x78]
IMUL RAX,RAX,0x28
ADD RDI,RAX
MOV EAX,dword ptr [RSP + 0x40]
MOV RCX,qword ptr [RSP + 0x58]
SUB EAX,dword ptr [RCX + 0x78]
CDQE
IMUL RDX,RAX,0x28
XOR ESI,ESI
CALL 0x0010e350
MOV RCX,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RAX + 0x80],RCX
MOV ECX,dword ptr [RSP + 0x40]
MOV RAX,qword ptr [RSP + 0x58]
MOV dword ptr [RAX + 0x78],ECX
LAB_001295cd:
MOV RAX,qword ptr [RSP + 0x58]
MOV RAX,qword ptr [RAX + 0x80]
MOV ECX,dword ptr [RSP + 0x54]
IMUL RCX,RCX,0x28
ADD RAX,RCX
MOV qword ptr [RSP + 0x30],RAX
MOV ECX,dword ptr [RSP + 0x54]
MOV RAX,qword ptr [RSP + 0x30]
MOV dword ptr [RAX],ECX
MOV RDI,qword ptr [RSP + 0x58]
MOV ESI,dword ptr [RSP + 0x44]
CALL 0x0015d640
MOV ECX,EAX
MOV RAX,qword ptr [RSP + 0x30]
MOV dword ptr [RAX + 0x4],ECX
MOV RAX,qword ptr [RSP + 0x48]
MOV RCX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RSP + 0x48]
MOV RCX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RSP + 0x48]
MOV RCX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RAX + 0x18],RCX
MOV RAX,qword ptr [RSP + 0x48]
MOV RCX,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RAX + 0x20],RCX
MOV dword ptr [RSP + 0x64],0x0
LAB_0012965c:
MOV EAX,dword ptr [RSP + 0x64]
ADD RSP,0x68
RET
|
int4 JS_NewClass1(long param_1,uint param_2,long param_3,int4 param_4)
{
int4 uVar1;
int iVar2;
uint uVar3;
long lVar4;
long *plVar5;
uint *puVar6;
uint uStack_64;
long local_48;
int local_2c;
int4 local_4;
if (param_2 < 0x10000) {
if ((param_2 < *(uint *)(param_1 + 0x78)) &&
(*(int *)(*(long *)(param_1 + 0x80) + (ulong)param_2 * 0x28) != 0)) {
local_4 = 0xffffffff;
}
else {
if (*(uint *)(param_1 + 0x78) <= param_2) {
lVar4 = (long)(*(int *)(param_1 + 0x78) * 3);
uVar1 = max_int(param_2 + 1,lVar4 / 2 & 0xffffffff,lVar4 % 2 & 0xffffffff);
iVar2 = max_int(0x3d,uVar1);
for (local_48 = *(long *)(param_1 + 0x90); local_48 != param_1 + 0x88;
local_48 = *(long *)(local_48 + 8)) {
lVar4 = js_realloc_rt(param_1,*(int8 *)(local_48 + 0x20),(long)iVar2 << 4);
if (lVar4 == 0) {
return 0xffffffff;
}
for (local_2c = *(int *)(param_1 + 0x78); local_2c < iVar2; local_2c = local_2c + 1) {
plVar5 = (long *)(lVar4 + (long)local_2c * 0x10);
*plVar5 = (ulong)uStack_64 << 0x20;
plVar5[1] = 2;
}
*(long *)(local_48 + 0x20) = lVar4;
}
lVar4 = js_realloc_rt(param_1,*(int8 *)(param_1 + 0x80),(long)iVar2 * 0x28);
if (lVar4 == 0) {
return 0xffffffff;
}
memset((void *)(lVar4 + (long)*(int *)(param_1 + 0x78) * 0x28),0,
(long)(iVar2 - *(int *)(param_1 + 0x78)) * 0x28);
*(long *)(param_1 + 0x80) = lVar4;
*(int *)(param_1 + 0x78) = iVar2;
}
puVar6 = (uint *)(*(long *)(param_1 + 0x80) + (ulong)param_2 * 0x28);
*puVar6 = param_2;
uVar3 = JS_DupAtomRT(param_1,param_4);
puVar6[1] = uVar3;
*(int8 *)(puVar6 + 2) = *(int8 *)(param_3 + 8);
*(int8 *)(puVar6 + 4) = *(int8 *)(param_3 + 0x10);
*(int8 *)(puVar6 + 6) = *(int8 *)(param_3 + 0x18);
*(int8 *)(puVar6 + 8) = *(int8 *)(param_3 + 0x20);
local_4 = 0;
}
}
else {
local_4 = 0xffffffff;
}
return local_4;
}
|
|
60,624
|
JS_NewClass1
|
bluesky950520[P]quickjs/quickjs.c
|
static int JS_NewClass1(JSRuntime *rt, JSClassID class_id,
const JSClassDef *class_def, JSAtom name)
{
int new_size, i;
JSClass *cl, *new_class_array;
struct list_head *el;
if (class_id >= (1 << 16))
return -1;
if (class_id < rt->class_count &&
rt->class_array[class_id].class_id != 0)
return -1;
if (class_id >= rt->class_count) {
new_size = max_int(JS_CLASS_INIT_COUNT,
max_int(class_id + 1, rt->class_count * 3 / 2));
/* reallocate the context class prototype array, if any */
list_for_each(el, &rt->context_list) {
JSContext *ctx = list_entry(el, JSContext, link);
JSValue *new_tab;
new_tab = js_realloc_rt(rt, ctx->class_proto,
sizeof(ctx->class_proto[0]) * new_size);
if (!new_tab)
return -1;
for(i = rt->class_count; i < new_size; i++)
new_tab[i] = JS_NULL;
ctx->class_proto = new_tab;
}
/* reallocate the class array */
new_class_array = js_realloc_rt(rt, rt->class_array,
sizeof(JSClass) * new_size);
if (!new_class_array)
return -1;
memset(new_class_array + rt->class_count, 0,
(new_size - rt->class_count) * sizeof(JSClass));
rt->class_array = new_class_array;
rt->class_count = new_size;
}
cl = &rt->class_array[class_id];
cl->class_id = class_id;
cl->class_name = JS_DupAtomRT(rt, name);
cl->finalizer = class_def->finalizer;
cl->gc_mark = class_def->gc_mark;
cl->call = class_def->call;
cl->exotic = class_def->exotic;
return 0;
}
|
O1
|
c
|
JS_NewClass1:
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpl $0xffff, %esi # imm = 0xFFFF
ja 0x20adc
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movl 0x78(%rdi), %r9d
cmpl %esi, %r9d
jbe 0x20981
movq 0x80(%r14), %rdi
movl %esi, %r8d
leaq (%r8,%r8,4), %r8
cmpl $0x0, (%rdi,%r8,8)
jne 0x20ace
cmpl %esi, %r9d
ja 0x20a8b
movl %ecx, 0x4(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
leal 0x1(%rsi), %ecx
movl %r9d, %edx
shrl %edx
addl %r9d, %edx
cmpl %edx, %ecx
cmovgl %ecx, %edx
cmpl $0x3e, %edx
movl $0x3d, %ebx
cmovgel %edx, %ebx
leaq 0x88(%r14), %r12
movq 0x90(%r14), %r15
movl %ebx, %ebp
cmpq %r12, %r15
je 0x20a1b
movq %rbp, %r13
shlq $0x4, %r13
movq 0x20(%r15), %rsi
movq %r14, %rdi
movq %r13, %rdx
callq 0x1cac2
testq %rax, %rax
je 0x20ac9
movslq 0x78(%r14), %rdx
cmpl %ebx, %edx
jge 0x20a0e
movq %rbp, %rcx
subq %rdx, %rcx
shlq $0x4, %rdx
addq %rax, %rdx
addq $0x8, %rdx
movl $0x0, -0x8(%rdx)
movq $0x2, (%rdx)
addq $0x10, %rdx
decq %rcx
jne 0x209f7
movq %rax, 0x20(%r15)
movq 0x8(%r15), %r15
cmpq %r12, %r15
jne 0x209c6
movq 0x80(%r14), %rsi
shlq $0x3, %rbp
leaq (,%rbp,4), %rdx
addq %rbp, %rdx
movq %r14, %rdi
callq 0x1cac2
movq %rax, %r13
testq %rax, %rax
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
je 0x20ace
movslq 0x78(%r14), %rax
leaq (%rax,%rax,4), %rcx
leaq (,%rcx,8), %rdi
addq %r13, %rdi
movslq %ebx, %rcx
subq %rax, %rcx
shlq $0x3, %rcx
leaq (%rcx,%rcx,4), %rdx
xorl %esi, %esi
callq 0xe350
movq %r13, 0x80(%r14)
movl %ebx, 0x78(%r14)
movq 0x10(%rsp), %rdx
movl 0x4(%rsp), %ecx
movq 0x8(%rsp), %rsi
movq 0x80(%r14), %rax
movl %esi, %edi
leaq (%rdi,%rdi,4), %rdi
leaq (%rax,%rdi,8), %rax
movl %esi, (%rax)
cmpl $0xe0, %ecx
jl 0x20ab2
movq 0x68(%r14), %rdi
movl %ecx, %esi
movq (%rdi,%rsi,8), %rsi
incl (%rsi)
movl %ecx, 0x4(%rax)
movups 0x8(%rdx), %xmm0
movups %xmm0, 0x8(%rax)
movups 0x18(%rdx), %xmm0
movups %xmm0, 0x18(%rax)
xorl %eax, %eax
jmp 0x20ace
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
JS_NewClass1:
mov eax, 0FFFFFFFFh
cmp esi, 0FFFFh
ja locret_20ADC
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r14, rdi
mov r9d, [rdi+78h]
cmp r9d, esi
jbe short loc_20981
mov rdi, [r14+80h]
mov r8d, esi
lea r8, [r8+r8*4]
cmp dword ptr [rdi+r8*8], 0
jnz loc_20ACE
cmp r9d, esi
ja loc_20A8B
loc_20981:
mov [rsp+48h+var_44], ecx
mov [rsp+48h+var_38], rdx
mov [rsp+48h+var_40], rsi
lea ecx, [rsi+1]
mov edx, r9d
shr edx, 1
add edx, r9d
cmp ecx, edx
cmovg edx, ecx
cmp edx, 3Eh ; '>'
mov ebx, 3Dh ; '='
cmovge ebx, edx
lea r12, [r14+88h]
mov r15, [r14+90h]
mov ebp, ebx
cmp r15, r12
jz short loc_20A1B
mov r13, rbp
shl r13, 4
loc_209C6:
mov rsi, [r15+20h]
mov rdi, r14
mov rdx, r13
call js_realloc_rt
test rax, rax
jz loc_20AC9
movsxd rdx, dword ptr [r14+78h]
cmp edx, ebx
jge short loc_20A0E
mov rcx, rbp
sub rcx, rdx
shl rdx, 4
add rdx, rax
add rdx, 8
loc_209F7:
mov dword ptr [rdx-8], 0
mov qword ptr [rdx], 2
add rdx, 10h
dec rcx
jnz short loc_209F7
loc_20A0E:
mov [r15+20h], rax
mov r15, [r15+8]
cmp r15, r12
jnz short loc_209C6
loc_20A1B:
mov rsi, [r14+80h]
shl rbp, 3
lea rdx, ds:0[rbp*4]
add rdx, rbp
mov rdi, r14
call js_realloc_rt
mov r13, rax
test rax, rax
mov eax, 0FFFFFFFFh
jz loc_20ACE
movsxd rax, dword ptr [r14+78h]
lea rcx, [rax+rax*4]
lea rdi, ds:0[rcx*8]
add rdi, r13
movsxd rcx, ebx
sub rcx, rax
shl rcx, 3
lea rdx, [rcx+rcx*4]
xor esi, esi
call _memset
mov [r14+80h], r13
mov [r14+78h], ebx
mov rdx, [rsp+48h+var_38]
mov ecx, [rsp+48h+var_44]
mov rsi, [rsp+48h+var_40]
loc_20A8B:
mov rax, [r14+80h]
mov edi, esi
lea rdi, [rdi+rdi*4]
lea rax, [rax+rdi*8]
mov [rax], esi
cmp ecx, 0E0h
jl short loc_20AB2
mov rdi, [r14+68h]
mov esi, ecx
mov rsi, [rdi+rsi*8]
inc dword ptr [rsi]
loc_20AB2:
mov [rax+4], ecx
movups xmm0, xmmword ptr [rdx+8]
movups xmmword ptr [rax+8], xmm0
movups xmm0, xmmword ptr [rdx+18h]
movups xmmword ptr [rax+18h], xmm0
xor eax, eax
jmp short loc_20ACE
loc_20AC9:
mov eax, 0FFFFFFFFh
loc_20ACE:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
locret_20ADC:
retn
|
long long JS_NewClass1(long long a1, unsigned int a2, long long a3, int a4)
{
long long result; // rax
unsigned int v5; // r9d
int v6; // edx
unsigned int v7; // ebx
long long v8; // r15
long long v9; // rax
long long v10; // rdx
long long v11; // rcx
_QWORD *v12; // rdx
long long v13; // r13
long long v14; // rax
_DWORD *v15; // rsi
int v16; // [rsp+0h] [rbp-44h]
long long v17; // [rsp+Ch] [rbp-38h]
result = 0xFFFFFFFFLL;
if ( a2 > 0xFFFF )
return result;
v5 = *(_DWORD *)(a1 + 120);
if ( v5 > a2 )
{
if ( *(_DWORD *)(*(_QWORD *)(a1 + 128) + 40LL * a2) )
return result;
if ( v5 > a2 )
goto LABEL_17;
}
v16 = a4;
v17 = a3;
v6 = v5 + (v5 >> 1);
if ( (int)(a2 + 1) > v6 )
v6 = a2 + 1;
v7 = 61;
if ( v6 >= 62 )
v7 = v6;
v8 = *(_QWORD *)(a1 + 144);
if ( v8 == a1 + 136 )
{
LABEL_15:
v13 = js_realloc_rt(a1, *(_QWORD *)(a1 + 128), 40LL * v7);
result = 0xFFFFFFFFLL;
if ( !v13 )
return result;
memset(v13 + 40LL * *(int *)(a1 + 120), 0LL, 40 * ((int)v7 - (long long)*(int *)(a1 + 120)));
*(_QWORD *)(a1 + 128) = v13;
*(_DWORD *)(a1 + 120) = v7;
a3 = v17;
a4 = v16;
LABEL_17:
v14 = *(_QWORD *)(a1 + 128) + 40LL * a2;
*(_DWORD *)v14 = a2;
if ( a4 >= 224 )
{
v15 = *(_DWORD **)(*(_QWORD *)(a1 + 104) + 8LL * (unsigned int)a4);
++*v15;
}
*(_DWORD *)(v14 + 4) = a4;
*(_OWORD *)(v14 + 8) = *(_OWORD *)(a3 + 8);
*(_OWORD *)(v14 + 24) = *(_OWORD *)(a3 + 24);
return 0LL;
}
while ( 1 )
{
v9 = js_realloc_rt(a1, *(_QWORD *)(v8 + 32), 16LL * v7);
if ( !v9 )
return 0xFFFFFFFFLL;
v10 = *(int *)(a1 + 120);
if ( (int)v10 < (int)v7 )
{
v11 = v7 - v10;
v12 = (_QWORD *)(v9 + 16 * v10 + 8);
do
{
*((_DWORD *)v12 - 2) = 0;
*v12 = 2LL;
v12 += 2;
--v11;
}
while ( v11 );
}
*(_QWORD *)(v8 + 32) = v9;
v8 = *(_QWORD *)(v8 + 8);
if ( v8 == a1 + 136 )
goto LABEL_15;
}
}
|
JS_NewClass1:
MOV EAX,0xffffffff
CMP ESI,0xffff
JA 0x00120adc
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R14,RDI
MOV R9D,dword ptr [RDI + 0x78]
CMP R9D,ESI
JBE 0x00120981
MOV RDI,qword ptr [R14 + 0x80]
MOV R8D,ESI
LEA R8,[R8 + R8*0x4]
CMP dword ptr [RDI + R8*0x8],0x0
JNZ 0x00120ace
CMP R9D,ESI
JA 0x00120a8b
LAB_00120981:
MOV dword ptr [RSP + 0x4],ECX
MOV qword ptr [RSP + 0x10],RDX
MOV qword ptr [RSP + 0x8],RSI
LEA ECX,[RSI + 0x1]
MOV EDX,R9D
SHR EDX,0x1
ADD EDX,R9D
CMP ECX,EDX
CMOVG EDX,ECX
CMP EDX,0x3e
MOV EBX,0x3d
CMOVGE EBX,EDX
LEA R12,[R14 + 0x88]
MOV R15,qword ptr [R14 + 0x90]
MOV EBP,EBX
CMP R15,R12
JZ 0x00120a1b
MOV R13,RBP
SHL R13,0x4
LAB_001209c6:
MOV RSI,qword ptr [R15 + 0x20]
MOV RDI,R14
MOV RDX,R13
CALL 0x0011cac2
TEST RAX,RAX
JZ 0x00120ac9
MOVSXD RDX,dword ptr [R14 + 0x78]
CMP EDX,EBX
JGE 0x00120a0e
MOV RCX,RBP
SUB RCX,RDX
SHL RDX,0x4
ADD RDX,RAX
ADD RDX,0x8
LAB_001209f7:
MOV dword ptr [RDX + -0x8],0x0
MOV qword ptr [RDX],0x2
ADD RDX,0x10
DEC RCX
JNZ 0x001209f7
LAB_00120a0e:
MOV qword ptr [R15 + 0x20],RAX
MOV R15,qword ptr [R15 + 0x8]
CMP R15,R12
JNZ 0x001209c6
LAB_00120a1b:
MOV RSI,qword ptr [R14 + 0x80]
SHL RBP,0x3
LEA RDX,[RBP*0x4]
ADD RDX,RBP
MOV RDI,R14
CALL 0x0011cac2
MOV R13,RAX
TEST RAX,RAX
MOV EAX,0xffffffff
JZ 0x00120ace
MOVSXD RAX,dword ptr [R14 + 0x78]
LEA RCX,[RAX + RAX*0x4]
LEA RDI,[RCX*0x8]
ADD RDI,R13
MOVSXD RCX,EBX
SUB RCX,RAX
SHL RCX,0x3
LEA RDX,[RCX + RCX*0x4]
XOR ESI,ESI
CALL 0x0010e350
MOV qword ptr [R14 + 0x80],R13
MOV dword ptr [R14 + 0x78],EBX
MOV RDX,qword ptr [RSP + 0x10]
MOV ECX,dword ptr [RSP + 0x4]
MOV RSI,qword ptr [RSP + 0x8]
LAB_00120a8b:
MOV RAX,qword ptr [R14 + 0x80]
MOV EDI,ESI
LEA RDI,[RDI + RDI*0x4]
LEA RAX,[RAX + RDI*0x8]
MOV dword ptr [RAX],ESI
CMP ECX,0xe0
JL 0x00120ab2
MOV RDI,qword ptr [R14 + 0x68]
MOV ESI,ECX
MOV RSI,qword ptr [RDI + RSI*0x8]
INC dword ptr [RSI]
LAB_00120ab2:
MOV dword ptr [RAX + 0x4],ECX
MOVUPS XMM0,xmmword ptr [RDX + 0x8]
MOVUPS xmmword ptr [RAX + 0x8],XMM0
MOVUPS XMM0,xmmword ptr [RDX + 0x18]
MOVUPS xmmword ptr [RAX + 0x18],XMM0
XOR EAX,EAX
JMP 0x00120ace
LAB_00120ac9:
MOV EAX,0xffffffff
LAB_00120ace:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
LAB_00120adc:
RET
|
int8 JS_NewClass1(long param_1,uint param_2,long param_3,uint param_4)
{
uint *puVar1;
int iVar2;
int *piVar3;
int8 uVar4;
long lVar5;
long lVar6;
long lVar7;
uint uVar8;
int8 *puVar9;
uint uVar10;
ulong uVar11;
if (0xffff < param_2) {
return 0xffffffff;
}
uVar8 = *(uint *)(param_1 + 0x78);
if (param_2 < uVar8) {
if (*(int *)(*(long *)(param_1 + 0x80) + (ulong)param_2 * 0x28) != 0) {
return 0xffffffff;
}
if (param_2 < uVar8) goto LAB_00120a8b;
}
uVar8 = (uVar8 >> 1) + uVar8;
if ((int)uVar8 < (int)(param_2 + 1)) {
uVar8 = param_2 + 1;
}
uVar10 = 0x3d;
if (0x3d < (int)uVar8) {
uVar10 = uVar8;
}
lVar6 = *(long *)(param_1 + 0x90);
uVar11 = (ulong)uVar10;
if (lVar6 != param_1 + 0x88) {
do {
lVar5 = js_realloc_rt(param_1,*(int8 *)(lVar6 + 0x20),uVar11 << 4);
if (lVar5 == 0) {
return 0xffffffff;
}
iVar2 = *(int *)(param_1 + 0x78);
if (iVar2 < (int)uVar10) {
lVar7 = uVar11 - (long)iVar2;
puVar9 = (int8 *)((long)iVar2 * 0x10 + lVar5 + 8);
do {
*(int4 *)(puVar9 + -1) = 0;
*puVar9 = 2;
puVar9 = puVar9 + 2;
lVar7 = lVar7 + -1;
} while (lVar7 != 0);
}
*(long *)(lVar6 + 0x20) = lVar5;
lVar6 = *(long *)(lVar6 + 8);
} while (lVar6 != param_1 + 0x88);
}
lVar6 = js_realloc_rt(param_1,*(int8 *)(param_1 + 0x80),uVar11 * 0x28);
if (lVar6 == 0) {
return 0xffffffff;
}
memset((void *)((long)*(int *)(param_1 + 0x78) * 0x28 + lVar6),0,
((long)(int)uVar10 - (long)*(int *)(param_1 + 0x78)) * 0x28);
*(long *)(param_1 + 0x80) = lVar6;
*(uint *)(param_1 + 0x78) = uVar10;
LAB_00120a8b:
puVar1 = (uint *)(*(long *)(param_1 + 0x80) + (ulong)param_2 * 0x28);
*puVar1 = param_2;
if (0xdf < (int)param_4) {
piVar3 = *(int **)(*(long *)(param_1 + 0x68) + (ulong)param_4 * 8);
*piVar3 = *piVar3 + 1;
}
puVar1[1] = param_4;
uVar4 = *(int8 *)(param_3 + 0x10);
*(int8 *)(puVar1 + 2) = *(int8 *)(param_3 + 8);
*(int8 *)(puVar1 + 4) = uVar4;
uVar4 = *(int8 *)(param_3 + 0x20);
*(int8 *)(puVar1 + 6) = *(int8 *)(param_3 + 0x18);
*(int8 *)(puVar1 + 8) = uVar4;
return 0;
}
|
|
60,625
|
JS_NewClass1
|
bluesky950520[P]quickjs/quickjs.c
|
static int JS_NewClass1(JSRuntime *rt, JSClassID class_id,
const JSClassDef *class_def, JSAtom name)
{
int new_size, i;
JSClass *cl, *new_class_array;
struct list_head *el;
if (class_id >= (1 << 16))
return -1;
if (class_id < rt->class_count &&
rt->class_array[class_id].class_id != 0)
return -1;
if (class_id >= rt->class_count) {
new_size = max_int(JS_CLASS_INIT_COUNT,
max_int(class_id + 1, rt->class_count * 3 / 2));
/* reallocate the context class prototype array, if any */
list_for_each(el, &rt->context_list) {
JSContext *ctx = list_entry(el, JSContext, link);
JSValue *new_tab;
new_tab = js_realloc_rt(rt, ctx->class_proto,
sizeof(ctx->class_proto[0]) * new_size);
if (!new_tab)
return -1;
for(i = rt->class_count; i < new_size; i++)
new_tab[i] = JS_NULL;
ctx->class_proto = new_tab;
}
/* reallocate the class array */
new_class_array = js_realloc_rt(rt, rt->class_array,
sizeof(JSClass) * new_size);
if (!new_class_array)
return -1;
memset(new_class_array + rt->class_count, 0,
(new_size - rt->class_count) * sizeof(JSClass));
rt->class_array = new_class_array;
rt->class_count = new_size;
}
cl = &rt->class_array[class_id];
cl->class_id = class_id;
cl->class_name = JS_DupAtomRT(rt, name);
cl->finalizer = class_def->finalizer;
cl->gc_mark = class_def->gc_mark;
cl->call = class_def->call;
cl->exotic = class_def->exotic;
return 0;
}
|
O2
|
c
|
JS_NewClass1:
pushq $-0x1
popq %rax
cmpl $0xffff, %esi # imm = 0xFFFF
ja 0x1acb2
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbp
movl %esi, %r15d
movq %rdi, %r14
movl 0x78(%rdi), %esi
cmpl %r15d, %esi
jbe 0x1ab86
movq 0x80(%r14), %rbx
movl %r15d, %esi
imulq $0x28, %rsi, %rdx
cmpl $0x0, (%rbx,%rdx)
jne 0x1aca4
jmp 0x1ac6a
movl %ecx, 0xc(%rsp)
movq %rbp, 0x10(%rsp)
leal 0x1(%r15), %ecx
movl %esi, %edx
shrl %edx
addl %esi, %edx
cmpl %edx, %ecx
cmoval %ecx, %edx
cmpl $0x3e, %edx
pushq $0x3d
popq %r13
cmovael %edx, %r13d
leaq 0x88(%r14), %rbp
leaq 0x90(%r14), %r12
movq %r13, %rbx
shlq $0x4, %rbx
movq (%r12), %r12
cmpq %rbp, %r12
je 0x1ac16
movq 0x20(%r12), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x17109
testq %rax, %rax
je 0x1aca1
movslq 0x78(%r14), %rcx
movq %rcx, %rdx
shlq $0x4, %rdx
addq %rax, %rdx
addq $0x8, %rdx
cmpq %r13, %rcx
jge 0x1ac0b
andl $0x0, -0x8(%rdx)
movq $0x2, (%rdx)
incq %rcx
addq $0x10, %rdx
jmp 0x1abf2
movq %rax, 0x20(%r12)
addq $0x8, %r12
jmp 0x1abbe
movq 0x80(%r14), %rsi
imulq $0x28, %r13, %rdx
movq %r14, %rdi
callq 0x17109
movq %rax, %rbx
testq %rax, %rax
movq 0x10(%rsp), %rbp
pushq $-0x1
popq %rax
je 0x1aca4
movslq 0x78(%r14), %rax
imulq $0x28, %rax, %rdi
addq %rbx, %rdi
movslq %r13d, %r12
movq %r12, %rcx
subq %rax, %rcx
imulq $0x28, %rcx, %rdx
xorl %esi, %esi
callq 0xe360
movq %rbx, 0x80(%r14)
movl %r12d, 0x78(%r14)
movl 0xc(%rsp), %ecx
movl %r15d, %esi
imulq $0x28, %rsi, %rdx
leaq (%rbx,%rdx), %rax
movl %r15d, (%rbx,%rdx)
cmpl $0xe0, %ecx
jl 0x1ac8a
movq 0x68(%r14), %rsi
movl %ecx, %edx
movq (%rsi,%rdx,8), %rdx
incl (%rdx)
movl %ecx, 0x4(%rax)
movups 0x8(%rbp), %xmm0
movups %xmm0, 0x8(%rax)
movups 0x18(%rbp), %xmm0
movups %xmm0, 0x18(%rax)
xorl %eax, %eax
jmp 0x1aca4
pushq $-0x1
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
JS_NewClass1:
push 0FFFFFFFFFFFFFFFFh
pop rax
cmp esi, 0FFFFh
ja locret_1ACB2
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbp, rdx
mov r15d, esi
mov r14, rdi
mov esi, [rdi+78h]
cmp esi, r15d
jbe short loc_1AB86
mov rbx, [r14+80h]
mov esi, r15d
imul rdx, rsi, 28h ; '('
cmp dword ptr [rbx+rdx], 0
jnz loc_1ACA4
jmp loc_1AC6A
loc_1AB86:
mov [rsp+48h+var_3C], ecx
mov [rsp+48h+var_38], rbp
lea ecx, [r15+1]
mov edx, esi
shr edx, 1
add edx, esi
cmp ecx, edx
cmova edx, ecx
cmp edx, 3Eh ; '>'
push 3Dh ; '='
pop r13
cmovnb r13d, edx
lea rbp, [r14+88h]
lea r12, [r14+90h]
mov rbx, r13
shl rbx, 4
loc_1ABBE:
mov r12, [r12]
cmp r12, rbp
jz short loc_1AC16
mov rsi, [r12+20h]
mov rdi, r14
mov rdx, rbx
call js_realloc_rt
test rax, rax
jz loc_1ACA1
movsxd rcx, dword ptr [r14+78h]
mov rdx, rcx
shl rdx, 4
add rdx, rax
add rdx, 8
loc_1ABF2:
cmp rcx, r13
jge short loc_1AC0B
and dword ptr [rdx-8], 0
mov qword ptr [rdx], 2
inc rcx
add rdx, 10h
jmp short loc_1ABF2
loc_1AC0B:
mov [r12+20h], rax
add r12, 8
jmp short loc_1ABBE
loc_1AC16:
mov rsi, [r14+80h]
imul rdx, r13, 28h ; '('
mov rdi, r14
call js_realloc_rt
mov rbx, rax
test rax, rax
mov rbp, [rsp+48h+var_38]
push 0FFFFFFFFFFFFFFFFh
pop rax
jz short loc_1ACA4
movsxd rax, dword ptr [r14+78h]
imul rdi, rax, 28h ; '('
add rdi, rbx
movsxd r12, r13d
mov rcx, r12
sub rcx, rax
imul rdx, rcx, 28h ; '('
xor esi, esi
call _memset
mov [r14+80h], rbx
mov [r14+78h], r12d
mov ecx, [rsp+48h+var_3C]
mov esi, r15d
loc_1AC6A:
imul rdx, rsi, 28h ; '('
lea rax, [rbx+rdx]
mov [rbx+rdx], r15d
cmp ecx, 0E0h
jl short loc_1AC8A
mov rsi, [r14+68h]
mov edx, ecx
mov rdx, [rsi+rdx*8]
inc dword ptr [rdx]
loc_1AC8A:
mov [rax+4], ecx
movups xmm0, xmmword ptr [rbp+8]
movups xmmword ptr [rax+8], xmm0
movups xmm0, xmmword ptr [rbp+18h]
movups xmmword ptr [rax+18h], xmm0
xor eax, eax
jmp short loc_1ACA4
loc_1ACA1:
push 0FFFFFFFFFFFFFFFFh
pop rax
loc_1ACA4:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
locret_1ACB2:
retn
|
long long JS_NewClass1(long long a1, unsigned int a2, long long a3, int a4)
{
long long result; // rax
long long v5; // rbp
unsigned int v7; // esi
long long v8; // rbx
long long v9; // rsi
unsigned int v10; // edx
long long v11; // r13
long long *i; // r12
long long v13; // r12
long long v14; // rax
long long v15; // rcx
_QWORD *v16; // rdx
long long v17; // rax
_DWORD *v18; // rdx
int v19; // [rsp+0h] [rbp-3Ch]
result = -1LL;
if ( a2 <= 0xFFFF )
{
v5 = a3;
v7 = *(_DWORD *)(a1 + 120);
if ( v7 <= a2 )
{
v19 = a4;
v10 = v7 + (v7 >> 1);
if ( a2 + 1 > v10 )
v10 = a2 + 1;
v11 = 61LL;
if ( v10 >= 0x3E )
v11 = v10;
for ( i = (long long *)(a1 + 144); ; i = (long long *)(v13 + 8) )
{
v13 = *i;
if ( v13 == a1 + 136 )
break;
v14 = js_realloc_rt(a1, *(_QWORD *)(v13 + 32), 16 * v11);
if ( !v14 )
return -1LL;
v15 = *(int *)(a1 + 120);
v16 = (_QWORD *)(v14 + 16 * v15 + 8);
while ( v15 < v11 )
{
*((_DWORD *)v16 - 2) = 0;
*v16 = 2LL;
++v15;
v16 += 2;
}
*(_QWORD *)(v13 + 32) = v14;
}
v8 = js_realloc_rt(a1, *(_QWORD *)(a1 + 128), 40 * v11);
v5 = a3;
result = -1LL;
if ( !v8 )
return result;
memset(v8 + 40LL * *(int *)(a1 + 120), 0LL, 40 * ((int)v11 - (long long)*(int *)(a1 + 120)));
*(_QWORD *)(a1 + 128) = v8;
*(_DWORD *)(a1 + 120) = v11;
a4 = v19;
v9 = a2;
}
else
{
v8 = *(_QWORD *)(a1 + 128);
v9 = a2;
if ( *(_DWORD *)(v8 + 40LL * a2) )
return result;
}
v17 = v8 + 40 * v9;
*(_DWORD *)v17 = a2;
if ( a4 >= 224 )
{
v18 = *(_DWORD **)(*(_QWORD *)(a1 + 104) + 8LL * (unsigned int)a4);
++*v18;
}
*(_DWORD *)(v17 + 4) = a4;
*(_OWORD *)(v17 + 8) = *(_OWORD *)(v5 + 8);
*(_OWORD *)(v17 + 24) = *(_OWORD *)(v5 + 24);
return 0LL;
}
return result;
}
|
JS_NewClass1:
PUSH -0x1
POP RAX
CMP ESI,0xffff
JA 0x0011acb2
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBP,RDX
MOV R15D,ESI
MOV R14,RDI
MOV ESI,dword ptr [RDI + 0x78]
CMP ESI,R15D
JBE 0x0011ab86
MOV RBX,qword ptr [R14 + 0x80]
MOV ESI,R15D
IMUL RDX,RSI,0x28
CMP dword ptr [RBX + RDX*0x1],0x0
JNZ 0x0011aca4
JMP 0x0011ac6a
LAB_0011ab86:
MOV dword ptr [RSP + 0xc],ECX
MOV qword ptr [RSP + 0x10],RBP
LEA ECX,[R15 + 0x1]
MOV EDX,ESI
SHR EDX,0x1
ADD EDX,ESI
CMP ECX,EDX
CMOVA EDX,ECX
CMP EDX,0x3e
PUSH 0x3d
POP R13
CMOVNC R13D,EDX
LEA RBP,[R14 + 0x88]
LEA R12,[R14 + 0x90]
MOV RBX,R13
SHL RBX,0x4
LAB_0011abbe:
MOV R12,qword ptr [R12]
CMP R12,RBP
JZ 0x0011ac16
MOV RSI,qword ptr [R12 + 0x20]
MOV RDI,R14
MOV RDX,RBX
CALL 0x00117109
TEST RAX,RAX
JZ 0x0011aca1
MOVSXD RCX,dword ptr [R14 + 0x78]
MOV RDX,RCX
SHL RDX,0x4
ADD RDX,RAX
ADD RDX,0x8
LAB_0011abf2:
CMP RCX,R13
JGE 0x0011ac0b
AND dword ptr [RDX + -0x8],0x0
MOV qword ptr [RDX],0x2
INC RCX
ADD RDX,0x10
JMP 0x0011abf2
LAB_0011ac0b:
MOV qword ptr [R12 + 0x20],RAX
ADD R12,0x8
JMP 0x0011abbe
LAB_0011ac16:
MOV RSI,qword ptr [R14 + 0x80]
IMUL RDX,R13,0x28
MOV RDI,R14
CALL 0x00117109
MOV RBX,RAX
TEST RAX,RAX
MOV RBP,qword ptr [RSP + 0x10]
PUSH -0x1
POP RAX
JZ 0x0011aca4
MOVSXD RAX,dword ptr [R14 + 0x78]
IMUL RDI,RAX,0x28
ADD RDI,RBX
MOVSXD R12,R13D
MOV RCX,R12
SUB RCX,RAX
IMUL RDX,RCX,0x28
XOR ESI,ESI
CALL 0x0010e360
MOV qword ptr [R14 + 0x80],RBX
MOV dword ptr [R14 + 0x78],R12D
MOV ECX,dword ptr [RSP + 0xc]
MOV ESI,R15D
LAB_0011ac6a:
IMUL RDX,RSI,0x28
LEA RAX,[RBX + RDX*0x1]
MOV dword ptr [RBX + RDX*0x1],R15D
CMP ECX,0xe0
JL 0x0011ac8a
MOV RSI,qword ptr [R14 + 0x68]
MOV EDX,ECX
MOV RDX,qword ptr [RSI + RDX*0x8]
INC dword ptr [RDX]
LAB_0011ac8a:
MOV dword ptr [RAX + 0x4],ECX
MOVUPS XMM0,xmmword ptr [RBP + 0x8]
MOVUPS xmmword ptr [RAX + 0x8],XMM0
MOVUPS XMM0,xmmword ptr [RBP + 0x18]
MOVUPS xmmword ptr [RAX + 0x18],XMM0
XOR EAX,EAX
JMP 0x0011aca4
LAB_0011aca1:
PUSH -0x1
POP RAX
LAB_0011aca4:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
LAB_0011acb2:
RET
|
int8 JS_NewClass1(long param_1,uint param_2,long param_3,uint param_4)
{
int *piVar1;
long lVar2;
long lVar3;
int8 uVar4;
long lVar5;
uint uVar6;
int8 *puVar7;
long *plVar8;
ulong uVar9;
uVar4 = 0xffffffffffffffff;
if (param_2 < 0x10000) {
uVar6 = *(uint *)(param_1 + 0x78);
if (param_2 < uVar6) {
lVar3 = *(long *)(param_1 + 0x80);
if (*(int *)(lVar3 + (ulong)param_2 * 0x28) != 0) {
return 0xffffffffffffffff;
}
}
else {
uVar6 = (uVar6 >> 1) + uVar6;
if (uVar6 < param_2 + 1) {
uVar6 = param_2 + 1;
}
uVar9 = 0x3d;
if (0x3d < uVar6) {
uVar9 = (ulong)uVar6;
}
plVar8 = (long *)(param_1 + 0x90);
while (lVar3 = *plVar8, lVar3 != param_1 + 0x88) {
lVar2 = js_realloc_rt(param_1,*(int8 *)(lVar3 + 0x20),uVar9 << 4);
if (lVar2 == 0) {
return 0xffffffffffffffff;
}
lVar5 = (long)*(int *)(param_1 + 0x78);
puVar7 = (int8 *)(lVar5 * 0x10 + lVar2 + 8);
for (; lVar5 < (long)uVar9; lVar5 = lVar5 + 1) {
*(int4 *)(puVar7 + -1) = 0;
*puVar7 = 2;
puVar7 = puVar7 + 2;
}
*(long *)(lVar3 + 0x20) = lVar2;
plVar8 = (long *)(lVar3 + 8);
}
lVar3 = js_realloc_rt(param_1,*(int8 *)(param_1 + 0x80),uVar9 * 0x28);
if (lVar3 == 0) {
return 0xffffffffffffffff;
}
memset((void *)((long)*(int *)(param_1 + 0x78) * 0x28 + lVar3),0,
((long)(int)uVar9 - (long)*(int *)(param_1 + 0x78)) * 0x28);
*(long *)(param_1 + 0x80) = lVar3;
*(int *)(param_1 + 0x78) = (int)uVar9;
}
lVar2 = lVar3 + (ulong)param_2 * 0x28;
*(uint *)(lVar3 + (ulong)param_2 * 0x28) = param_2;
if (0xdf < (int)param_4) {
piVar1 = *(int **)(*(long *)(param_1 + 0x68) + (ulong)param_4 * 8);
*piVar1 = *piVar1 + 1;
}
*(uint *)(lVar2 + 4) = param_4;
uVar4 = *(int8 *)(param_3 + 0x10);
*(int8 *)(lVar2 + 8) = *(int8 *)(param_3 + 8);
*(int8 *)(lVar2 + 0x10) = uVar4;
uVar4 = *(int8 *)(param_3 + 0x20);
*(int8 *)(lVar2 + 0x18) = *(int8 *)(param_3 + 0x18);
*(int8 *)(lVar2 + 0x20) = uVar4;
uVar4 = 0;
}
return uVar4;
}
|
|
60,626
|
JS_NewClass1
|
bluesky950520[P]quickjs/quickjs.c
|
static int JS_NewClass1(JSRuntime *rt, JSClassID class_id,
const JSClassDef *class_def, JSAtom name)
{
int new_size, i;
JSClass *cl, *new_class_array;
struct list_head *el;
if (class_id >= (1 << 16))
return -1;
if (class_id < rt->class_count &&
rt->class_array[class_id].class_id != 0)
return -1;
if (class_id >= rt->class_count) {
new_size = max_int(JS_CLASS_INIT_COUNT,
max_int(class_id + 1, rt->class_count * 3 / 2));
/* reallocate the context class prototype array, if any */
list_for_each(el, &rt->context_list) {
JSContext *ctx = list_entry(el, JSContext, link);
JSValue *new_tab;
new_tab = js_realloc_rt(rt, ctx->class_proto,
sizeof(ctx->class_proto[0]) * new_size);
if (!new_tab)
return -1;
for(i = rt->class_count; i < new_size; i++)
new_tab[i] = JS_NULL;
ctx->class_proto = new_tab;
}
/* reallocate the class array */
new_class_array = js_realloc_rt(rt, rt->class_array,
sizeof(JSClass) * new_size);
if (!new_class_array)
return -1;
memset(new_class_array + rt->class_count, 0,
(new_size - rt->class_count) * sizeof(JSClass));
rt->class_array = new_class_array;
rt->class_count = new_size;
}
cl = &rt->class_array[class_id];
cl->class_id = class_id;
cl->class_name = JS_DupAtomRT(rt, name);
cl->finalizer = class_def->finalizer;
cl->gc_mark = class_def->gc_mark;
cl->call = class_def->call;
cl->exotic = class_def->exotic;
return 0;
}
|
O3
|
c
|
JS_NewClass1:
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpl $0xffff, %esi # imm = 0xFFFF
ja 0x2122b
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movq %rdx, %r12
movl %esi, %r15d
movq %rdi, %r14
movl 0x78(%rdi), %esi
cmpl %r15d, %esi
jbe 0x210e6
movq 0x80(%r14), %rbx
movl %r15d, %edx
leaq (%rdx,%rdx,4), %rcx
cmpl $0x0, (%rbx,%rcx,8)
jne 0x2121d
jmp 0x211de
movl %ebp, 0xc(%rsp)
movq %r12, 0x10(%rsp)
leal 0x1(%r15), %ecx
movl %esi, %edx
shrl %edx
addl %esi, %edx
cmpl %edx, %ecx
cmoval %ecx, %edx
cmpl $0x3e, %edx
movl $0x3d, %r13d
cmovael %edx, %r13d
leaq 0x88(%r14), %rbp
movq 0x90(%r14), %r12
cmpq %rbp, %r12
je 0x2117e
movq %r13, %rbx
shlq $0x4, %rbx
movq 0x20(%r12), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1d3aa
testq %rax, %rax
je 0x21218
movslq 0x78(%r14), %rdx
cmpl %r13d, %edx
jge 0x2116f
movq %r13, %rcx
subq %rdx, %rcx
shlq $0x4, %rdx
addq %rax, %rdx
addq $0x8, %rdx
movl $0x0, -0x8(%rdx)
movq $0x2, (%rdx)
addq $0x10, %rdx
decq %rcx
jne 0x21158
movq %rax, 0x20(%r12)
movq 0x8(%r12), %r12
cmpq %rbp, %r12
jne 0x21125
movq 0x80(%r14), %rsi
leaq (,%r13,8), %rax
leaq (%rax,%rax,4), %rdx
movq %r14, %rdi
callq 0x1d3aa
movq %rax, %rbx
testq %rax, %rax
movq 0x10(%rsp), %r12
movl 0xc(%rsp), %ebp
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
je 0x2121d
movslq 0x78(%r14), %rax
leaq (%rax,%rax,4), %rcx
leaq (%rbx,%rcx,8), %rdi
movslq %r13d, %rcx
subq %rax, %rcx
shlq $0x3, %rcx
leaq (%rcx,%rcx,4), %rdx
xorl %esi, %esi
callq 0xe350
movq %rbx, 0x80(%r14)
movl %r13d, 0x78(%r14)
movl %r15d, %edx
leaq (%rdx,%rdx,4), %rax
leaq (%rbx,%rax,8), %rax
movl %r15d, (%rax)
cmpl $0xe0, %ebp
jl 0x211fd
movq 0x68(%r14), %rcx
movl %ebp, %edx
movq (%rcx,%rdx,8), %rcx
incl (%rcx)
movl %ebp, 0x4(%rax)
movups 0x8(%r12), %xmm0
movups %xmm0, 0x8(%rax)
movups 0x18(%r12), %xmm0
movups %xmm0, 0x18(%rax)
xorl %eax, %eax
jmp 0x2121d
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
JS_NewClass1:
mov eax, 0FFFFFFFFh
cmp esi, 0FFFFh
ja locret_2122B
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov ebp, ecx
mov r12, rdx
mov r15d, esi
mov r14, rdi
mov esi, [rdi+78h]
cmp esi, r15d
jbe short loc_210E6
mov rbx, [r14+80h]
mov edx, r15d
lea rcx, [rdx+rdx*4]
cmp dword ptr [rbx+rcx*8], 0
jnz loc_2121D
jmp loc_211DE
loc_210E6:
mov [rsp+48h+var_3C], ebp
mov [rsp+48h+var_38], r12
lea ecx, [r15+1]
mov edx, esi
shr edx, 1
add edx, esi
cmp ecx, edx
cmova edx, ecx
cmp edx, 3Eh ; '>'
mov r13d, 3Dh ; '='
cmovnb r13d, edx
lea rbp, [r14+88h]
mov r12, [r14+90h]
cmp r12, rbp
jz short loc_2117E
mov rbx, r13
shl rbx, 4
loc_21125:
mov rsi, [r12+20h]
mov rdi, r14
mov rdx, rbx
call js_realloc_rt
test rax, rax
jz loc_21218
movsxd rdx, dword ptr [r14+78h]
cmp edx, r13d
jge short loc_2116F
mov rcx, r13
sub rcx, rdx
shl rdx, 4
add rdx, rax
add rdx, 8
loc_21158:
mov dword ptr [rdx-8], 0
mov qword ptr [rdx], 2
add rdx, 10h
dec rcx
jnz short loc_21158
loc_2116F:
mov [r12+20h], rax
mov r12, [r12+8]
cmp r12, rbp
jnz short loc_21125
loc_2117E:
mov rsi, [r14+80h]
lea rax, ds:0[r13*8]
lea rdx, [rax+rax*4]
mov rdi, r14
call js_realloc_rt
mov rbx, rax
test rax, rax
mov r12, [rsp+48h+var_38]
mov ebp, [rsp+48h+var_3C]
mov eax, 0FFFFFFFFh
jz short loc_2121D
movsxd rax, dword ptr [r14+78h]
lea rcx, [rax+rax*4]
lea rdi, [rbx+rcx*8]
movsxd rcx, r13d
sub rcx, rax
shl rcx, 3
lea rdx, [rcx+rcx*4]
xor esi, esi
call _memset
mov [r14+80h], rbx
mov [r14+78h], r13d
mov edx, r15d
loc_211DE:
lea rax, [rdx+rdx*4]
lea rax, [rbx+rax*8]
mov [rax], r15d
cmp ebp, 0E0h
jl short loc_211FD
mov rcx, [r14+68h]
mov edx, ebp
mov rcx, [rcx+rdx*8]
inc dword ptr [rcx]
loc_211FD:
mov [rax+4], ebp
movups xmm0, xmmword ptr [r12+8]
movups xmmword ptr [rax+8], xmm0
movups xmm0, xmmword ptr [r12+18h]
movups xmmword ptr [rax+18h], xmm0
xor eax, eax
jmp short loc_2121D
loc_21218:
mov eax, 0FFFFFFFFh
loc_2121D:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
locret_2122B:
retn
|
long long JS_NewClass1(long long a1, unsigned int a2, long long a3, int a4)
{
long long result; // rax
long long v6; // r12
unsigned int v8; // esi
long long v9; // rbx
long long v10; // rdx
unsigned int v11; // edx
long long v12; // r13
long long v13; // r12
long long v14; // rax
long long v15; // rdx
long long v16; // rcx
_QWORD *v17; // rdx
long long v18; // rax
_DWORD *v19; // rcx
result = 0xFFFFFFFFLL;
if ( a2 > 0xFFFF )
return result;
v6 = a3;
v8 = *(_DWORD *)(a1 + 120);
if ( v8 > a2 )
{
v9 = *(_QWORD *)(a1 + 128);
v10 = a2;
if ( *(_DWORD *)(v9 + 40LL * a2) )
return result;
LABEL_17:
v18 = v9 + 40 * v10;
*(_DWORD *)v18 = a2;
if ( a4 >= 224 )
{
v19 = *(_DWORD **)(*(_QWORD *)(a1 + 104) + 8LL * (unsigned int)a4);
++*v19;
}
*(_DWORD *)(v18 + 4) = a4;
*(_OWORD *)(v18 + 8) = *(_OWORD *)(v6 + 8);
*(_OWORD *)(v18 + 24) = *(_OWORD *)(v6 + 24);
return 0LL;
}
v11 = v8 + (v8 >> 1);
if ( a2 + 1 > v11 )
v11 = a2 + 1;
v12 = 61LL;
if ( v11 >= 0x3E )
v12 = v11;
v13 = *(_QWORD *)(a1 + 144);
if ( v13 == a1 + 136 )
{
LABEL_15:
v9 = js_realloc_rt(a1, *(_QWORD *)(a1 + 128), 40 * v12);
v6 = a3;
result = 0xFFFFFFFFLL;
if ( !v9 )
return result;
memset(v9 + 40LL * *(int *)(a1 + 120), 0LL, 40 * ((int)v12 - (long long)*(int *)(a1 + 120)));
*(_QWORD *)(a1 + 128) = v9;
*(_DWORD *)(a1 + 120) = v12;
v10 = a2;
goto LABEL_17;
}
while ( 1 )
{
v14 = js_realloc_rt(a1, *(_QWORD *)(v13 + 32), 16 * v12);
if ( !v14 )
return 0xFFFFFFFFLL;
v15 = *(int *)(a1 + 120);
if ( (int)v15 < (int)v12 )
{
v16 = v12 - v15;
v17 = (_QWORD *)(v14 + 16 * v15 + 8);
do
{
*((_DWORD *)v17 - 2) = 0;
*v17 = 2LL;
v17 += 2;
--v16;
}
while ( v16 );
}
*(_QWORD *)(v13 + 32) = v14;
v13 = *(_QWORD *)(v13 + 8);
if ( v13 == a1 + 136 )
goto LABEL_15;
}
}
|
JS_NewClass1:
MOV EAX,0xffffffff
CMP ESI,0xffff
JA 0x0012122b
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV EBP,ECX
MOV R12,RDX
MOV R15D,ESI
MOV R14,RDI
MOV ESI,dword ptr [RDI + 0x78]
CMP ESI,R15D
JBE 0x001210e6
MOV RBX,qword ptr [R14 + 0x80]
MOV EDX,R15D
LEA RCX,[RDX + RDX*0x4]
CMP dword ptr [RBX + RCX*0x8],0x0
JNZ 0x0012121d
JMP 0x001211de
LAB_001210e6:
MOV dword ptr [RSP + 0xc],EBP
MOV qword ptr [RSP + 0x10],R12
LEA ECX,[R15 + 0x1]
MOV EDX,ESI
SHR EDX,0x1
ADD EDX,ESI
CMP ECX,EDX
CMOVA EDX,ECX
CMP EDX,0x3e
MOV R13D,0x3d
CMOVNC R13D,EDX
LEA RBP,[R14 + 0x88]
MOV R12,qword ptr [R14 + 0x90]
CMP R12,RBP
JZ 0x0012117e
MOV RBX,R13
SHL RBX,0x4
LAB_00121125:
MOV RSI,qword ptr [R12 + 0x20]
MOV RDI,R14
MOV RDX,RBX
CALL 0x0011d3aa
TEST RAX,RAX
JZ 0x00121218
MOVSXD RDX,dword ptr [R14 + 0x78]
CMP EDX,R13D
JGE 0x0012116f
MOV RCX,R13
SUB RCX,RDX
SHL RDX,0x4
ADD RDX,RAX
ADD RDX,0x8
LAB_00121158:
MOV dword ptr [RDX + -0x8],0x0
MOV qword ptr [RDX],0x2
ADD RDX,0x10
DEC RCX
JNZ 0x00121158
LAB_0012116f:
MOV qword ptr [R12 + 0x20],RAX
MOV R12,qword ptr [R12 + 0x8]
CMP R12,RBP
JNZ 0x00121125
LAB_0012117e:
MOV RSI,qword ptr [R14 + 0x80]
LEA RAX,[R13*0x8]
LEA RDX,[RAX + RAX*0x4]
MOV RDI,R14
CALL 0x0011d3aa
MOV RBX,RAX
TEST RAX,RAX
MOV R12,qword ptr [RSP + 0x10]
MOV EBP,dword ptr [RSP + 0xc]
MOV EAX,0xffffffff
JZ 0x0012121d
MOVSXD RAX,dword ptr [R14 + 0x78]
LEA RCX,[RAX + RAX*0x4]
LEA RDI,[RBX + RCX*0x8]
MOVSXD RCX,R13D
SUB RCX,RAX
SHL RCX,0x3
LEA RDX,[RCX + RCX*0x4]
XOR ESI,ESI
CALL 0x0010e350
MOV qword ptr [R14 + 0x80],RBX
MOV dword ptr [R14 + 0x78],R13D
MOV EDX,R15D
LAB_001211de:
LEA RAX,[RDX + RDX*0x4]
LEA RAX,[RBX + RAX*0x8]
MOV dword ptr [RAX],R15D
CMP EBP,0xe0
JL 0x001211fd
MOV RCX,qword ptr [R14 + 0x68]
MOV EDX,EBP
MOV RCX,qword ptr [RCX + RDX*0x8]
INC dword ptr [RCX]
LAB_001211fd:
MOV dword ptr [RAX + 0x4],EBP
MOVUPS XMM0,xmmword ptr [R12 + 0x8]
MOVUPS xmmword ptr [RAX + 0x8],XMM0
MOVUPS XMM0,xmmword ptr [R12 + 0x18]
MOVUPS xmmword ptr [RAX + 0x18],XMM0
XOR EAX,EAX
JMP 0x0012121d
LAB_00121218:
MOV EAX,0xffffffff
LAB_0012121d:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
LAB_0012122b:
RET
|
int8 JS_NewClass1(long param_1,uint param_2,long param_3,uint param_4)
{
uint *puVar1;
int iVar2;
int *piVar3;
int8 uVar4;
long lVar5;
long lVar6;
long lVar7;
uint uVar8;
int8 *puVar9;
int iVar10;
ulong uVar11;
uVar4 = 0xffffffff;
if (param_2 < 0x10000) {
uVar8 = *(uint *)(param_1 + 0x78);
if (param_2 < uVar8) {
lVar6 = *(long *)(param_1 + 0x80);
if (*(int *)(lVar6 + (ulong)param_2 * 0x28) != 0) {
return 0xffffffff;
}
}
else {
uVar8 = (uVar8 >> 1) + uVar8;
if (uVar8 < param_2 + 1) {
uVar8 = param_2 + 1;
}
uVar11 = 0x3d;
if (0x3d < uVar8) {
uVar11 = (ulong)uVar8;
}
lVar6 = *(long *)(param_1 + 0x90);
iVar10 = (int)uVar11;
if (lVar6 != param_1 + 0x88) {
do {
lVar5 = js_realloc_rt(param_1,*(int8 *)(lVar6 + 0x20),uVar11 << 4);
if (lVar5 == 0) {
return 0xffffffff;
}
iVar2 = *(int *)(param_1 + 0x78);
if (iVar2 < iVar10) {
lVar7 = uVar11 - (long)iVar2;
puVar9 = (int8 *)((long)iVar2 * 0x10 + lVar5 + 8);
do {
*(int4 *)(puVar9 + -1) = 0;
*puVar9 = 2;
puVar9 = puVar9 + 2;
lVar7 = lVar7 + -1;
} while (lVar7 != 0);
}
*(long *)(lVar6 + 0x20) = lVar5;
lVar6 = *(long *)(lVar6 + 8);
} while (lVar6 != param_1 + 0x88);
}
lVar6 = js_realloc_rt(param_1,*(int8 *)(param_1 + 0x80),uVar11 * 0x28);
if (lVar6 == 0) {
return 0xffffffff;
}
memset((void *)(lVar6 + (long)*(int *)(param_1 + 0x78) * 0x28),0,
((long)iVar10 - (long)*(int *)(param_1 + 0x78)) * 0x28);
*(long *)(param_1 + 0x80) = lVar6;
*(int *)(param_1 + 0x78) = iVar10;
}
puVar1 = (uint *)(lVar6 + (ulong)param_2 * 0x28);
*puVar1 = param_2;
if (0xdf < (int)param_4) {
piVar3 = *(int **)(*(long *)(param_1 + 0x68) + (ulong)param_4 * 8);
*piVar3 = *piVar3 + 1;
}
puVar1[1] = param_4;
uVar4 = *(int8 *)(param_3 + 0x10);
*(int8 *)(puVar1 + 2) = *(int8 *)(param_3 + 8);
*(int8 *)(puVar1 + 4) = uVar4;
uVar4 = *(int8 *)(param_3 + 0x20);
*(int8 *)(puVar1 + 6) = *(int8 *)(param_3 + 0x18);
*(int8 *)(puVar1 + 8) = uVar4;
uVar4 = 0;
}
return uVar4;
}
|
|
60,627
|
lf_alloc_init
|
eloqsql/mysys/lf_alloc-pin.c
|
void lf_alloc_init(LF_ALLOCATOR *allocator, uint size, uint free_ptr_offset)
{
lf_pinbox_init(&allocator->pinbox, free_ptr_offset,
(lf_pinbox_free_func *)alloc_free, allocator);
allocator->top= 0;
allocator->mallocs= 0;
allocator->element_size= size;
allocator->constructor= 0;
allocator->destructor= 0;
DBUG_ASSERT(size >= sizeof(void*) + free_ptr_offset);
}
|
O3
|
c
|
lf_alloc_init:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
movl $0x78, %esi
callq 0xad334
xorl %eax, %eax
movl %eax, 0x3c(%r15)
movl %eax, 0x40(%r15)
movl %ebx, 0x38(%r15)
leaq 0x2b(%rip), %rcx # 0xad142
movq %rcx, 0x28(%r15)
movq %r15, 0x30(%r15)
movq $0x0, 0x48(%r15)
movl %eax, 0x54(%r15)
movl %r14d, 0x50(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
lf_alloc_init:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov ebx, edx
mov r14d, esi
mov r15, rdi
mov esi, 78h ; 'x'
call lf_dynarray_init
xor eax, eax
mov [r15+3Ch], eax
mov [r15+40h], eax
mov [r15+38h], ebx
lea rcx, alloc_free
mov [r15+28h], rcx
mov [r15+30h], r15
mov qword ptr [r15+48h], 0
mov [r15+54h], eax
mov [r15+50h], r14d
xorps xmm0, xmm0
movups xmmword ptr [r15+58h], xmm0
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
long long lf_alloc_init(long long a1, int a2, int a3)
{
long long result; // rax
lf_dynarray_init(a1, 120LL);
result = 0LL;
*(_DWORD *)(a1 + 60) = 0;
*(_DWORD *)(a1 + 64) = 0;
*(_DWORD *)(a1 + 56) = a3;
*(_QWORD *)(a1 + 40) = alloc_free;
*(_QWORD *)(a1 + 48) = a1;
*(_QWORD *)(a1 + 72) = 0LL;
*(_DWORD *)(a1 + 84) = 0;
*(_DWORD *)(a1 + 80) = a2;
*(_OWORD *)(a1 + 88) = 0LL;
return result;
}
|
lf_alloc_init:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV EBX,EDX
MOV R14D,ESI
MOV R15,RDI
MOV ESI,0x78
CALL 0x001ad334
XOR EAX,EAX
MOV dword ptr [R15 + 0x3c],EAX
MOV dword ptr [R15 + 0x40],EAX
MOV dword ptr [R15 + 0x38],EBX
LEA RCX,[0x1ad142]
MOV qword ptr [R15 + 0x28],RCX
MOV qword ptr [R15 + 0x30],R15
MOV qword ptr [R15 + 0x48],0x0
MOV dword ptr [R15 + 0x54],EAX
MOV dword ptr [R15 + 0x50],R14D
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R15 + 0x58],XMM0
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
void lf_alloc_init(long param_1,int4 param_2,int4 param_3)
{
lf_dynarray_init(param_1,0x78);
*(int4 *)(param_1 + 0x3c) = 0;
*(int4 *)(param_1 + 0x40) = 0;
*(int4 *)(param_1 + 0x38) = param_3;
*(code **)(param_1 + 0x28) = alloc_free;
*(long *)(param_1 + 0x30) = param_1;
*(int8 *)(param_1 + 0x48) = 0;
*(int4 *)(param_1 + 0x54) = 0;
*(int4 *)(param_1 + 0x50) = param_2;
*(int8 *)(param_1 + 0x58) = 0;
*(int8 *)(param_1 + 0x60) = 0;
return;
}
|
|
60,628
|
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>::cbegin() const
|
monkey531[P]llama/common/json.hpp
|
const_iterator cbegin() const noexcept
{
const_iterator result(this);
result.set_begin();
return result;
}
|
O1
|
cpp
|
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::cbegin() const:
pushq %rbx
movq %rdi, %rbx
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rsi, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq %rax, 0x18(%rdi)
movzbl (%rsi), %ecx
cmpl $0x2, %ecx
je 0x4e614
cmpl $0x1, %ecx
jne 0x4e61e
leaq 0x8(%rbx), %rax
movq $0x0, (%rax)
jmp 0x4e622
movq $0x0, 0x10(%rbx)
jmp 0x4e622
movq %rax, 0x18(%rbx)
movq %rbx, %rdi
callq 0x4e630
movq %rbx, %rax
popq %rbx
retq
nop
|
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6cbeginEv:
push rbx
mov rbx, rdi
mov rax, 8000000000000000h
mov [rdi], rsi
xorps xmm0, xmm0
movups xmmword ptr [rdi+8], xmm0
mov [rdi+18h], rax
movzx ecx, byte ptr [rsi]
cmp ecx, 2
jz short loc_4E614
cmp ecx, 1
jnz short loc_4E61E
lea rax, [rbx+8]
mov qword ptr [rax], 0
jmp short loc_4E622
loc_4E614:
mov qword ptr [rbx+10h], 0
jmp short loc_4E622
loc_4E61E:
mov [rbx+18h], rax
loc_4E622:
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE9set_beginEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::set_begin(void)
mov rax, rbx
pop rbx
retn
|
long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::cbegin(
long long a1,
unsigned __int8 *a2)
{
int v2; // ecx
*(_QWORD *)a1 = a2;
*(_OWORD *)(a1 + 8) = 0LL;
*(_QWORD *)(a1 + 24) = 0x8000000000000000LL;
v2 = *a2;
if ( v2 == 2 )
{
*(_QWORD *)(a1 + 16) = 0LL;
}
else if ( v2 == 1 )
{
*(_QWORD *)(a1 + 8) = 0LL;
}
else
{
*(_QWORD *)(a1 + 24) = 0x8000000000000000LL;
}
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::set_begin(a1);
return a1;
}
|
cbegin:
PUSH RBX
MOV RBX,RDI
MOV RAX,-0x8000000000000000
MOV qword ptr [RDI],RSI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x8],XMM0
MOV qword ptr [RDI + 0x18],RAX
MOVZX ECX,byte ptr [RSI]
CMP ECX,0x2
JZ 0x0014e614
CMP ECX,0x1
JNZ 0x0014e61e
LEA RAX,[RBX + 0x8]
MOV qword ptr [RAX],0x0
JMP 0x0014e622
LAB_0014e614:
MOV qword ptr [RBX + 0x10],0x0
JMP 0x0014e622
LAB_0014e61e:
MOV qword ptr [RBX + 0x18],RAX
LAB_0014e622:
MOV RDI,RBX
CALL 0x0014e630
MOV RAX,RBX
POP RBX
RET
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>::cbegin() const */
void nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::cbegin(void)
{
char *in_RSI;
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*in_RDI;
*(char **)in_RDI = in_RSI;
*(int8 *)(in_RDI + 8) = 0;
*(int8 *)(in_RDI + 0x10) = 0;
*(int8 *)(in_RDI + 0x18) = 0x8000000000000000;
if (*in_RSI == '\x02') {
*(int8 *)(in_RDI + 0x10) = 0;
}
else if (*in_RSI == '\x01') {
*(int8 *)(in_RDI + 8) = 0;
}
else {
*(int8 *)(in_RDI + 0x18) = 0x8000000000000000;
}
detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::set_begin(in_RDI);
return;
}
|
|
60,629
|
end_key_cache_internal
|
eloqsql/mysys/mf_keycache.c
|
static
void end_key_cache_internal(KEY_CACHE *keycache, my_bool cleanup,
my_bool use_op_lock)
{
if (keycache->key_cache_inited)
{
keycache->interface_funcs->end(keycache->keycache_cb, cleanup);
if (cleanup)
{
if (keycache->keycache_cb)
{
my_free(keycache->keycache_cb);
keycache->keycache_cb= 0;
}
/*
We do not destroy op_lock if we are going to reuse the same key cache.
This happens if we are called from repartition_key_cache_internal().
*/
if (use_op_lock)
pthread_mutex_destroy(&keycache->op_lock);
keycache->key_cache_inited= 0;
}
keycache->can_be_used= 0;
}
}
|
O0
|
c
|
end_key_cache_internal:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
movb %cl, -0x9(%rbp)
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, 0x48(%rax)
je 0xe4af8
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
movsbl -0x9(%rbp), %esi
callq *%rax
cmpb $0x0, -0x9(%rbp)
je 0xe4af0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xe4ad5
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xf3be0
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
cmpb $0x0, -0xa(%rbp)
je 0xe4ae8
movq -0x8(%rbp), %rdi
addq $0x58, %rdi
callq 0x2a0d0
movq -0x8(%rbp), %rax
movb $0x0, 0x48(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x49(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
|
end_key_cache_internal:
push rbp
mov rbp, rsp
sub rsp, 10h
mov al, dl
mov cl, sil
mov [rbp+var_8], rdi
mov [rbp+var_9], cl
mov [rbp+var_A], al
mov rax, [rbp+var_8]
cmp byte ptr [rax+48h], 0
jz short loc_E4AF8
mov rax, [rbp+var_8]
mov rax, [rax+10h]
mov rax, [rax+40h]
mov rcx, [rbp+var_8]
mov rdi, [rcx+8]
movsx esi, [rbp+var_9]
call rax
cmp [rbp+var_9], 0
jz short loc_E4AF0
mov rax, [rbp+var_8]
cmp qword ptr [rax+8], 0
jz short loc_E4AD5
mov rax, [rbp+var_8]
mov rdi, [rax+8]
call my_free
mov rax, [rbp+var_8]
mov qword ptr [rax+8], 0
loc_E4AD5:
cmp [rbp+var_A], 0
jz short loc_E4AE8
mov rdi, [rbp+var_8]
add rdi, 58h ; 'X'
call _pthread_mutex_destroy
loc_E4AE8:
mov rax, [rbp+var_8]
mov byte ptr [rax+48h], 0
loc_E4AF0:
mov rax, [rbp+var_8]
mov byte ptr [rax+49h], 0
loc_E4AF8:
add rsp, 10h
pop rbp
retn
|
long long end_key_cache_internal(long long a1, char a2, char a3)
{
long long result; // rax
result = a1;
if ( *(_BYTE *)(a1 + 72) )
{
(*(void ( **)(_QWORD, _QWORD))(*(_QWORD *)(a1 + 16) + 64LL))(*(_QWORD *)(a1 + 8), (unsigned int)a2);
if ( a2 )
{
if ( *(_QWORD *)(a1 + 8) )
{
my_free(*(_QWORD *)(a1 + 8));
*(_QWORD *)(a1 + 8) = 0LL;
}
if ( a3 )
pthread_mutex_destroy(a1 + 88);
*(_BYTE *)(a1 + 72) = 0;
}
result = a1;
*(_BYTE *)(a1 + 73) = 0;
}
return result;
}
|
end_key_cache_internal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV AL,DL
MOV CL,SIL
MOV qword ptr [RBP + -0x8],RDI
MOV byte ptr [RBP + -0x9],CL
MOV byte ptr [RBP + -0xa],AL
MOV RAX,qword ptr [RBP + -0x8]
CMP byte ptr [RAX + 0x48],0x0
JZ 0x001e4af8
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RCX + 0x8]
MOVSX ESI,byte ptr [RBP + -0x9]
CALL RAX
CMP byte ptr [RBP + -0x9],0x0
JZ 0x001e4af0
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x8],0x0
JZ 0x001e4ad5
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x8]
CALL 0x001f3be0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x8],0x0
LAB_001e4ad5:
CMP byte ptr [RBP + -0xa],0x0
JZ 0x001e4ae8
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x58
CALL 0x0012a0d0
LAB_001e4ae8:
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x48],0x0
LAB_001e4af0:
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x49],0x0
LAB_001e4af8:
ADD RSP,0x10
POP RBP
RET
|
void end_key_cache_internal(long param_1,char param_2,char param_3)
{
if (*(char *)(param_1 + 0x48) != '\0') {
(**(code **)(*(long *)(param_1 + 0x10) + 0x40))(*(int8 *)(param_1 + 8),(int)param_2);
if (param_2 != '\0') {
if (*(long *)(param_1 + 8) != 0) {
my_free(*(int8 *)(param_1 + 8));
*(int8 *)(param_1 + 8) = 0;
}
if (param_3 != '\0') {
pthread_mutex_destroy((pthread_mutex_t *)(param_1 + 0x58));
}
*(int1 *)(param_1 + 0x48) = 0;
}
*(int1 *)(param_1 + 0x49) = 0;
}
return;
}
|
|
60,630
|
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;
}
|
O0
|
c
|
my_mb_wc_sjis:
pushq %rbp
movq %rsp, %rbp
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 0x4fbfa
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0x4fd58
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x80, %eax
jge 0x4fc22
movslq -0x2c(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x4fd58
cmpl $0xa1, -0x2c(%rbp)
jl 0x4fc58
cmpl $0xdf, -0x2c(%rbp)
jg 0x4fc58
movslq -0x2c(%rbp), %rcx
leaq 0x2341c1(%rip), %rax # 0x283e00
movzwl (%rax,%rcx,2), %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x4fd58
movq -0x20(%rbp), %rax
addq $0x2, %rax
cmpq -0x28(%rbp), %rax
jbe 0x4fc72
movl $0xffffff9a, -0x4(%rbp) # imm = 0xFFFFFF9A
jmp 0x4fd58
movl -0x2c(%rbp), %eax
shll $0x8, %eax
movq -0x20(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x234174(%rip), %rax # 0x283e00
movzwl (%rax,%rcx,2), %eax
movq -0x18(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x4fd51
movl -0x2c(%rbp), %eax
movzbl %al, %ecx
movl $0x81, %eax
cmpl %ecx, %eax
jg 0x4fcbd
movl -0x2c(%rbp), %eax
movzbl %al, %eax
cmpl $0x9f, %eax
jle 0x4fce4
movl -0x2c(%rbp), %eax
movzbl %al, %edx
xorl %eax, %eax
movl $0xe0, %ecx
cmpl %edx, %ecx
movb %al, -0x2d(%rbp)
jg 0x4fd3c
movl -0x2c(%rbp), %eax
movzbl %al, %ecx
xorl %eax, %eax
cmpl $0xfc, %ecx
movb %al, -0x2d(%rbp)
jg 0x4fd3c
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %ecx
movl $0x40, %eax
cmpl %ecx, %eax
jg 0x4fd07
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %ecx
movb $0x1, %al
cmpl $0x7e, %ecx
movb %al, -0x2e(%rbp)
jle 0x4fd36
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %edx
xorl %eax, %eax
movl $0x80, %ecx
cmpl %edx, %ecx
movb %al, -0x2f(%rbp)
jg 0x4fd30
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0xfc, %eax
setle %al
movb %al, -0x2f(%rbp)
movb -0x2f(%rbp), %al
movb %al, -0x2e(%rbp)
movb -0x2e(%rbp), %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %dl
xorl %eax, %eax
movl $0xfffffffe, %ecx # imm = 0xFFFFFFFE
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x4fd58
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
|
my_mb_wc_sjis:
push rbp
mov rbp, rsp
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_4FBFA
mov [rbp+var_4], 0FFFFFF9Bh
jmp loc_4FD58
loc_4FBFA:
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax]
mov [rbp+var_2C], eax
cmp eax, 80h
jge short loc_4FC22
movsxd rcx, [rbp+var_2C]
mov rax, [rbp+var_18]
mov [rax], rcx
mov [rbp+var_4], 1
jmp loc_4FD58
loc_4FC22:
cmp [rbp+var_2C], 0A1h
jl short loc_4FC58
cmp [rbp+var_2C], 0DFh
jg short loc_4FC58
movsxd rcx, [rbp+var_2C]
lea rax, sjis_to_unicode
movzx eax, word ptr [rax+rcx*2]
mov ecx, eax
mov rax, [rbp+var_18]
mov [rax], rcx
mov [rbp+var_4], 1
jmp loc_4FD58
loc_4FC58:
mov rax, [rbp+var_20]
add rax, 2
cmp rax, [rbp+var_28]
jbe short loc_4FC72
mov [rbp+var_4], 0FFFFFF9Ah
jmp loc_4FD58
loc_4FC72:
mov eax, [rbp+var_2C]
shl eax, 8
mov rcx, [rbp+var_20]
movzx ecx, byte ptr [rcx+1]
add eax, ecx
movsxd rcx, eax
lea rax, sjis_to_unicode
movzx eax, word ptr [rax+rcx*2]
mov rcx, [rbp+var_18]
mov [rcx], rax
cmp rax, 0
jnz loc_4FD51
mov eax, [rbp+var_2C]
movzx ecx, al
mov eax, 81h
cmp eax, ecx
jg short loc_4FCBD
mov eax, [rbp+var_2C]
movzx eax, al
cmp eax, 9Fh
jle short loc_4FCE4
loc_4FCBD:
mov eax, [rbp+var_2C]
movzx edx, al
xor eax, eax
mov ecx, 0E0h
cmp ecx, edx
mov [rbp+var_2D], al
jg short loc_4FD3C
mov eax, [rbp+var_2C]
movzx ecx, al
xor eax, eax
cmp ecx, 0FCh
mov [rbp+var_2D], al
jg short loc_4FD3C
loc_4FCE4:
mov rax, [rbp+var_20]
movzx ecx, byte ptr [rax+1]
mov eax, 40h ; '@'
cmp eax, ecx
jg short loc_4FD07
mov rax, [rbp+var_20]
movzx ecx, byte ptr [rax+1]
mov al, 1
cmp ecx, 7Eh ; '~'
mov [rbp+var_2E], al
jle short loc_4FD36
loc_4FD07:
mov rax, [rbp+var_20]
movzx edx, byte ptr [rax+1]
xor eax, eax
mov ecx, 80h
cmp ecx, edx
mov [rbp+var_2F], al
jg short loc_4FD30
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
cmp eax, 0FCh
setle al
mov [rbp+var_2F], al
loc_4FD30:
mov al, [rbp+var_2F]
mov [rbp+var_2E], al
loc_4FD36:
mov al, [rbp+var_2E]
mov [rbp+var_2D], al
loc_4FD3C:
mov dl, [rbp+var_2D]
xor eax, eax
mov ecx, 0FFFFFFFEh
test dl, 1
cmovnz eax, ecx
mov [rbp+var_4], eax
jmp short loc_4FD58
loc_4FD51:
mov [rbp+var_4], 2
loc_4FD58:
mov eax, [rbp+var_4]
pop rbp
retn
|
long long my_mb_wc_sjis(long long a1, _QWORD *a2, unsigned __int8 *a3, unsigned long long a4)
{
long long v4; // rax
unsigned int v5; // eax
bool v7; // [rsp+1h] [rbp-2Fh]
char v8; // [rsp+2h] [rbp-2Eh]
char v9; // [rsp+3h] [rbp-2Dh]
unsigned int v10; // [rsp+4h] [rbp-2Ch]
if ( (unsigned long long)a3 < a4 )
{
v10 = *a3;
if ( v10 >= 0x80 )
{
if ( *a3 < 0xA1u || *a3 > 0xDFu )
{
if ( (unsigned long long)(a3 + 2) <= a4 )
{
v4 = sjis_to_unicode[a3[1] + (v10 << 8)];
*a2 = v4;
if ( v4 )
{
return 2;
}
else
{
if ( (unsigned __int8)v10 >= 0x81u && (unsigned __int8)v10 <= 0x9Fu
|| (v9 = 0, (unsigned __int8)v10 >= 0xE0u) && (v9 = 0, (unsigned __int8)v10 <= 0xFCu) )
{
if ( a3[1] < 0x40u || (v8 = 1, a3[1] > 0x7Eu) )
{
v7 = 0;
if ( a3[1] >= 0x80u )
v7 = a3[1] <= 0xFCu;
v8 = v7;
}
v9 = v8;
}
v5 = 0;
if ( (v9 & 1) != 0 )
return (unsigned int)-2;
return v5;
}
}
else
{
return (unsigned int)-102;
}
}
else
{
*a2 = sjis_to_unicode[*a3];
return 1;
}
}
else
{
*a2 = *a3;
return 1;
}
}
else
{
return (unsigned int)-101;
}
}
|
my_mb_wc_sjis:
PUSH RBP
MOV RBP,RSP
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 0x0014fbfa
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x0014fd58
LAB_0014fbfa:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX]
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x80
JGE 0x0014fc22
MOVSXD RCX,dword ptr [RBP + -0x2c]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0014fd58
LAB_0014fc22:
CMP dword ptr [RBP + -0x2c],0xa1
JL 0x0014fc58
CMP dword ptr [RBP + -0x2c],0xdf
JG 0x0014fc58
MOVSXD RCX,dword ptr [RBP + -0x2c]
LEA RAX,[0x383e00]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0014fd58
LAB_0014fc58:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x0014fc72
MOV dword ptr [RBP + -0x4],0xffffff9a
JMP 0x0014fd58
LAB_0014fc72:
MOV EAX,dword ptr [RBP + -0x2c]
SHL EAX,0x8
MOV RCX,qword ptr [RBP + -0x20]
MOVZX ECX,byte ptr [RCX + 0x1]
ADD EAX,ECX
MOVSXD RCX,EAX
LEA RAX,[0x383e00]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV RCX,qword ptr [RBP + -0x18]
MOV qword ptr [RCX],RAX
CMP RAX,0x0
JNZ 0x0014fd51
MOV EAX,dword ptr [RBP + -0x2c]
MOVZX ECX,AL
MOV EAX,0x81
CMP EAX,ECX
JG 0x0014fcbd
MOV EAX,dword ptr [RBP + -0x2c]
MOVZX EAX,AL
CMP EAX,0x9f
JLE 0x0014fce4
LAB_0014fcbd:
MOV EAX,dword ptr [RBP + -0x2c]
MOVZX EDX,AL
XOR EAX,EAX
MOV ECX,0xe0
CMP ECX,EDX
MOV byte ptr [RBP + -0x2d],AL
JG 0x0014fd3c
MOV EAX,dword ptr [RBP + -0x2c]
MOVZX ECX,AL
XOR EAX,EAX
CMP ECX,0xfc
MOV byte ptr [RBP + -0x2d],AL
JG 0x0014fd3c
LAB_0014fce4:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX ECX,byte ptr [RAX + 0x1]
MOV EAX,0x40
CMP EAX,ECX
JG 0x0014fd07
MOV RAX,qword ptr [RBP + -0x20]
MOVZX ECX,byte ptr [RAX + 0x1]
MOV AL,0x1
CMP ECX,0x7e
MOV byte ptr [RBP + -0x2e],AL
JLE 0x0014fd36
LAB_0014fd07:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EDX,byte ptr [RAX + 0x1]
XOR EAX,EAX
MOV ECX,0x80
CMP ECX,EDX
MOV byte ptr [RBP + -0x2f],AL
JG 0x0014fd30
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0xfc
SETLE AL
MOV byte ptr [RBP + -0x2f],AL
LAB_0014fd30:
MOV AL,byte ptr [RBP + -0x2f]
MOV byte ptr [RBP + -0x2e],AL
LAB_0014fd36:
MOV AL,byte ptr [RBP + -0x2e]
MOV byte ptr [RBP + -0x2d],AL
LAB_0014fd3c:
MOV DL,byte ptr [RBP + -0x2d]
XOR EAX,EAX
MOV ECX,0xfffffffe
TEST DL,0x1
CMOVNZ EAX,ECX
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0014fd58
LAB_0014fd51:
MOV dword ptr [RBP + -0x4],0x2
LAB_0014fd58:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 my_mb_wc_sjis(int8 param_1,ulong *param_2,byte *param_3,byte *param_4)
{
ushort uVar1;
bool bVar2;
uint uVar3;
int4 local_c;
if (param_3 < param_4) {
uVar3 = (uint)*param_3;
if (uVar3 < 0x80) {
*param_2 = (long)(int)uVar3;
local_c = 1;
}
else if ((uVar3 < 0xa1) || (0xdf < uVar3)) {
if (param_4 < param_3 + 2) {
local_c = 0xffffff9a;
}
else {
uVar1 = *(ushort *)(sjis_to_unicode + (long)(int)(uVar3 * 0x100 + (uint)param_3[1]) * 2);
*param_2 = (ulong)uVar1;
if ((ulong)uVar1 == 0) {
if ((((0x80 < uVar3) && (uVar3 < 0xa0)) ||
((bVar2 = false, 0xdf < uVar3 && (bVar2 = false, uVar3 < 0xfd)))) &&
(((param_3[1] < 0x40 || (bVar2 = true, 0x7e < param_3[1])) &&
(bVar2 = false, 0x7f < param_3[1])))) {
bVar2 = param_3[1] < 0xfd;
}
local_c = 0;
if (bVar2) {
local_c = 0xfffffffe;
}
}
else {
local_c = 2;
}
}
}
else {
*param_2 = (ulong)*(ushort *)(sjis_to_unicode + (long)(int)uVar3 * 2);
local_c = 1;
}
}
else {
local_c = 0xffffff9b;
}
return local_c;
}
|
|
60,631
|
minja::FilterTemplateToken::~FilterTemplateToken()
|
monkey531[P]llama/common/minja.hpp
|
FilterTemplateToken(const Location & location, SpaceHandling pre, SpaceHandling post, std::shared_ptr<Expression> && filter)
: TemplateToken(Type::Filter, location, pre, post), filter(std::move(filter)) {}
|
O1
|
cpp
|
minja::FilterTemplateToken::~FilterTemplateToken():
pushq %rbx
movq %rdi, %rbx
leaq 0x84143(%rip), %rax # 0xe3e68
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x5fd3a
callq 0x3503e
leaq 0x83487(%rip), %rax # 0xe31c8
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x5fd56
callq 0x3503e
movl $0x40, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x196e0
|
_ZN5minja19FilterTemplateTokenD0Ev:
push rbx
mov rbx, rdi
lea rax, _ZTVN5minja19FilterTemplateTokenE; `vtable for'minja::FilterTemplateToken
add rax, 10h
mov [rdi], rax
mov rdi, [rdi+38h]
test rdi, rdi
jz short loc_5FD3A
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_5FD3A:
lea rax, _ZTVN5minja13TemplateTokenE; `vtable for'minja::TemplateToken
add rax, 10h
mov [rbx], rax
mov rdi, [rbx+18h]
test rdi, rdi
jz short loc_5FD56
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_5FD56:
mov esi, 40h ; '@'; unsigned __int64
mov rdi, rbx; void *
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
|
void minja::FilterTemplateToken::~FilterTemplateToken(minja::FilterTemplateToken *this)
{
volatile signed __int32 *v2; // rdi
volatile signed __int32 *v3; // rdi
*(_QWORD *)this = &`vtable for'minja::FilterTemplateToken + 2;
v2 = (volatile signed __int32 *)*((_QWORD *)this + 7);
if ( v2 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v2);
*(_QWORD *)this = &`vtable for'minja::TemplateToken + 2;
v3 = (volatile signed __int32 *)*((_QWORD *)this + 3);
if ( v3 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v3);
operator delete(this, 0x40uLL);
}
|
~FilterTemplateToken:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x1e3e68]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x38]
TEST RDI,RDI
JZ 0x0015fd3a
CALL 0x0013503e
LAB_0015fd3a:
LEA RAX,[0x1e31c8]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
MOV RDI,qword ptr [RBX + 0x18]
TEST RDI,RDI
JZ 0x0015fd56
CALL 0x0013503e
LAB_0015fd56:
MOV ESI,0x40
MOV RDI,RBX
POP RBX
JMP 0x001196e0
|
/* minja::FilterTemplateToken::~FilterTemplateToken() */
void __thiscall minja::FilterTemplateToken::~FilterTemplateToken(FilterTemplateToken *this)
{
*(int ***)this = &PTR__FilterTemplateToken_001e3e78;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x38) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x38));
}
*(int ***)this = &PTR__TemplateToken_001e31d8;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x18) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x18));
}
operator_delete(this,0x40);
return;
}
|
|
60,632
|
minja::FilterTemplateToken::~FilterTemplateToken()
|
monkey531[P]llama/common/minja.hpp
|
FilterTemplateToken(const Location & location, SpaceHandling pre, SpaceHandling post, std::shared_ptr<Expression> && filter)
: TemplateToken(Type::Filter, location, pre, post), filter(std::move(filter)) {}
|
O3
|
cpp
|
minja::FilterTemplateToken::~FilterTemplateToken():
pushq %rbx
movq %rdi, %rbx
leaq 0x82895(%rip), %rax # 0xdfe68
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x5d5e8
callq 0x32e06
leaq 0x81bd9(%rip), %rax # 0xdf1c8
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x5d604
callq 0x32e06
movl $0x40, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x186e0
|
_ZN5minja19FilterTemplateTokenD0Ev:
push rbx
mov rbx, rdi
lea rax, _ZTVN5minja19FilterTemplateTokenE; `vtable for'minja::FilterTemplateToken
add rax, 10h
mov [rdi], rax
mov rdi, [rdi+38h]
test rdi, rdi
jz short loc_5D5E8
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_5D5E8:
lea rax, _ZTVN5minja13TemplateTokenE; `vtable for'minja::TemplateToken
add rax, 10h
mov [rbx], rax
mov rdi, [rbx+18h]
test rdi, rdi
jz short loc_5D604
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_5D604:
mov esi, 40h ; '@'; unsigned __int64
mov rdi, rbx; void *
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
|
void minja::FilterTemplateToken::~FilterTemplateToken(minja::FilterTemplateToken *this)
{
volatile signed __int32 *v2; // rdi
volatile signed __int32 *v3; // rdi
*(_QWORD *)this = &`vtable for'minja::FilterTemplateToken + 2;
v2 = (volatile signed __int32 *)*((_QWORD *)this + 7);
if ( v2 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v2);
*(_QWORD *)this = &`vtable for'minja::TemplateToken + 2;
v3 = (volatile signed __int32 *)*((_QWORD *)this + 3);
if ( v3 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v3);
operator delete(this, 0x40uLL);
}
|
~FilterTemplateToken:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x1dfe68]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x38]
TEST RDI,RDI
JZ 0x0015d5e8
CALL 0x00132e06
LAB_0015d5e8:
LEA RAX,[0x1df1c8]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
MOV RDI,qword ptr [RBX + 0x18]
TEST RDI,RDI
JZ 0x0015d604
CALL 0x00132e06
LAB_0015d604:
MOV ESI,0x40
MOV RDI,RBX
POP RBX
JMP 0x001186e0
|
/* minja::FilterTemplateToken::~FilterTemplateToken() */
void __thiscall minja::FilterTemplateToken::~FilterTemplateToken(FilterTemplateToken *this)
{
*(int ***)this = &PTR__FilterTemplateToken_001dfe78;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x38) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x38));
}
*(int ***)this = &PTR__TemplateToken_001df1d8;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x18) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x18));
}
operator_delete(this,0x40);
return;
}
|
|
60,633
|
calc_daynr
|
eloqsql/client/../sql-common/my_time.c
|
long calc_daynr(uint year,uint month,uint day)
{
long delsum;
int temp;
int y= year; /* may be < 0 temporarily */
DBUG_ENTER("calc_daynr");
if (y == 0 && month == 0)
DBUG_RETURN(0); /* Skip errors */
/* Cast to int to be able to handle month == 0 */
delsum= (long) (365 * y + 31 *((int) month - 1) + (int) day);
if (month <= 2)
y--;
else
delsum-= (long) ((int) month * 4 + 23) / 10;
temp=(int) ((y/100+1)*3)/4;
DBUG_PRINT("exit",("year: %d month: %d day: %d -> daynr: %ld",
y+(month <= 2),month,day,delsum+y/4-temp));
DBUG_ASSERT(delsum+(int) y/4-temp >= 0);
DBUG_RETURN(delsum+(int) y/4-temp);
}
|
O3
|
c
|
calc_daynr:
pushq %rbp
movq %rsp, %rbp
movl %esi, %eax
orl %edi, %eax
je 0x462f5
imull $0x16d, %edi, %eax # imm = 0x16D
movl %esi, %ecx
shll $0x5, %ecx
subl %esi, %ecx
addl %eax, %ecx
leal (%rdx,%rcx), %eax
addl $-0x1f, %eax
cltq
cmpl $0x2, %esi
ja 0x462f9
decl %edi
jmp 0x4631d
xorl %eax, %eax
jmp 0x46361
leal 0x17(,%rsi,4), %ecx
movslq %ecx, %rcx
imulq $0x66666667, %rcx, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x22, %rcx
addl %edx, %ecx
movslq %ecx, %rcx
subq %rcx, %rax
movslq %edi, %rcx
imulq $0x51eb851f, %rcx, %rdx # imm = 0x51EB851F
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x25, %rdx
addl %esi, %edx
leal (%rdx,%rdx,2), %esi
addl $0x3, %esi
leal (%rdx,%rdx,2), %edx
addl $0x6, %edx
testl %esi, %esi
cmovnsl %esi, %edx
sarl $0x2, %edx
negl %edx
leal 0x3(%rcx), %esi
testl %ecx, %ecx
cmovnsl %ecx, %esi
sarl $0x2, %esi
movslq %esi, %rcx
addq %rax, %rcx
movslq %edx, %rax
addq %rcx, %rax
popq %rbp
retq
|
calc_daynr:
push rbp
mov rbp, rsp
mov eax, esi
or eax, edi
jz short loc_462F5
imul eax, edi, 16Dh
mov ecx, esi
shl ecx, 5
sub ecx, esi
add ecx, eax
lea eax, [rdx+rcx]
add eax, 0FFFFFFE1h
cdqe
cmp esi, 2
ja short loc_462F9
dec edi
jmp short loc_4631D
loc_462F5:
xor eax, eax
jmp short loc_46361
loc_462F9:
lea ecx, ds:17h[rsi*4]
movsxd rcx, ecx
imul rcx, 66666667h
mov rdx, rcx
shr rdx, 3Fh
sar rcx, 22h
add ecx, edx
movsxd rcx, ecx
sub rax, rcx
loc_4631D:
movsxd rcx, edi
imul rdx, rcx, 51EB851Fh
mov rsi, rdx
shr rsi, 3Fh
sar rdx, 25h
add edx, esi
lea esi, [rdx+rdx*2]
add esi, 3
lea edx, [rdx+rdx*2]
add edx, 6
test esi, esi
cmovns edx, esi
sar edx, 2
neg edx
lea esi, [rcx+3]
test ecx, ecx
cmovns esi, ecx
sar esi, 2
movsxd rcx, esi
add rcx, rax
movsxd rax, edx
add rax, rcx
loc_46361:
pop rbp
retn
|
long long calc_daynr(int a1, unsigned int a2, int a3)
{
long long v3; // rax
int v5; // edx
if ( !(a1 | a2) )
return 0LL;
v3 = (int)(a3 + 365 * a1 + 31 * a2 - 31);
if ( a2 > 2 )
v3 -= (int)(4 * a2 + 23) / 10;
else
--a1;
v5 = 3 * (a1 / 100) + 6;
if ( 3 * (a1 / 100) + 3 >= 0 )
v5 = 3 * (a1 / 100) + 3;
return v3 + a1 / 4 + -(v5 >> 2);
}
|
calc_daynr:
PUSH RBP
MOV RBP,RSP
MOV EAX,ESI
OR EAX,EDI
JZ 0x001462f5
IMUL EAX,EDI,0x16d
MOV ECX,ESI
SHL ECX,0x5
SUB ECX,ESI
ADD ECX,EAX
LEA EAX,[RDX + RCX*0x1]
ADD EAX,-0x1f
CDQE
CMP ESI,0x2
JA 0x001462f9
DEC EDI
JMP 0x0014631d
LAB_001462f5:
XOR EAX,EAX
JMP 0x00146361
LAB_001462f9:
LEA ECX,[0x17 + RSI*0x4]
MOVSXD RCX,ECX
IMUL RCX,RCX,0x66666667
MOV RDX,RCX
SHR RDX,0x3f
SAR RCX,0x22
ADD ECX,EDX
MOVSXD RCX,ECX
SUB RAX,RCX
LAB_0014631d:
MOVSXD RCX,EDI
IMUL RDX,RCX,0x51eb851f
MOV RSI,RDX
SHR RSI,0x3f
SAR RDX,0x25
ADD EDX,ESI
LEA ESI,[RDX + RDX*0x2]
ADD ESI,0x3
LEA EDX,[RDX + RDX*0x2]
ADD EDX,0x6
TEST ESI,ESI
CMOVNS EDX,ESI
SAR EDX,0x2
NEG EDX
LEA ESI,[RCX + 0x3]
TEST ECX,ECX
CMOVNS ESI,ECX
SAR ESI,0x2
MOVSXD RCX,ESI
ADD RCX,RAX
MOVSXD RAX,EDX
ADD RAX,RCX
LAB_00146361:
POP RBP
RET
|
long calc_daynr(int param_1,uint param_2,int param_3)
{
long lVar1;
int iVar2;
int iVar3;
if (param_2 == 0 && param_1 == 0) {
lVar1 = 0;
}
else {
lVar1 = (long)(int)(param_3 + param_2 * 0x1f + param_1 * 0x16d + -0x1f);
if (param_2 < 3) {
param_1 = param_1 + -1;
}
else {
lVar1 = lVar1 - (int)(param_2 * 4 + 0x17) / 10;
}
iVar3 = (param_1 / 100) * 3 + 3;
iVar2 = (param_1 / 100) * 3 + 6;
if (-1 < iVar3) {
iVar2 = iVar3;
}
iVar3 = param_1 + 3;
if (-1 < param_1) {
iVar3 = param_1;
}
lVar1 = (long)-(iVar2 >> 2) + (iVar3 >> 2) + lVar1;
}
return lVar1;
}
|
|
60,634
|
release_configuration_dirs
|
eloqsql/libmariadb/libmariadb/ma_default.c
|
void release_configuration_dirs()
{
if (configuration_dirs)
{
int i= 0;
while (configuration_dirs[i])
free(configuration_dirs[i++]);
free(configuration_dirs);
}
}
|
O0
|
c
|
release_configuration_dirs:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x3a6fd1(%rip), %rax # 0x4477c0
cmpq $0x0, (%rax)
je 0xa0843
movl $0x0, -0x4(%rbp)
leaq 0x3a6fbd(%rip), %rax # 0x4477c0
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xa0834
leaq 0x3a6fa8(%rip), %rax # 0x4477c0
movq (%rax), %rax
movl -0x4(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x4(%rbp)
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3b220
jmp 0xa07fc
leaq 0x3a6f85(%rip), %rax # 0x4477c0
movq (%rax), %rdi
callq 0x3b220
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
|
release_configuration_dirs:
push rbp
mov rbp, rsp
sub rsp, 10h
lea rax, configuration_dirs
cmp qword ptr [rax], 0
jz short loc_A0843
mov [rbp+var_4], 0
loc_A07FC:
lea rax, configuration_dirs
mov rax, [rax]
movsxd rcx, [rbp+var_4]
cmp qword ptr [rax+rcx*8], 0
jz short loc_A0834
lea rax, configuration_dirs
mov rax, [rax]
mov ecx, [rbp+var_4]
mov edx, ecx
add edx, 1
mov [rbp+var_4], edx
movsxd rcx, ecx
mov rdi, [rax+rcx*8]
call _free
jmp short loc_A07FC
loc_A0834:
lea rax, configuration_dirs
mov rdi, [rax]
call _free
loc_A0843:
add rsp, 10h
pop rbp
retn
|
_QWORD *release_configuration_dirs()
{
_QWORD *result; // rax
int v1; // ecx
int i; // [rsp+Ch] [rbp-4h]
result = configuration_dirs;
if ( configuration_dirs[0] )
{
for ( i = 0; *(_QWORD *)(configuration_dirs[0] + 8LL * i); ++i )
{
v1 = i;
free(*(_QWORD *)(configuration_dirs[0] + 8LL * v1));
}
return (_QWORD *)free(configuration_dirs[0]);
}
return result;
}
|
release_configuration_dirs:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
LEA RAX,[0x5477c0]
CMP qword ptr [RAX],0x0
JZ 0x001a0843
MOV dword ptr [RBP + -0x4],0x0
LAB_001a07fc:
LEA RAX,[0x5477c0]
MOV RAX,qword ptr [RAX]
MOVSXD RCX,dword ptr [RBP + -0x4]
CMP qword ptr [RAX + RCX*0x8],0x0
JZ 0x001a0834
LEA RAX,[0x5477c0]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x4]
MOV EDX,ECX
ADD EDX,0x1
MOV dword ptr [RBP + -0x4],EDX
MOVSXD RCX,ECX
MOV RDI,qword ptr [RAX + RCX*0x8]
CALL 0x0013b220
JMP 0x001a07fc
LAB_001a0834:
LEA RAX,[0x5477c0]
MOV RDI,qword ptr [RAX]
CALL 0x0013b220
LAB_001a0843:
ADD RSP,0x10
POP RBP
RET
|
void release_configuration_dirs(void)
{
int4 local_c;
if (configuration_dirs != (void *)0x0) {
local_c = 0;
while (*(long *)((long)configuration_dirs + (long)local_c * 8) != 0) {
free(*(void **)((long)configuration_dirs + (long)local_c * 8));
local_c = local_c + 1;
}
free(configuration_dirs);
}
return;
}
|
|
60,635
|
minja::MacroTemplateToken::MacroTemplateToken(minja::Location const&, minja::SpaceHandling, minja::SpaceHandling, std::shared_ptr<minja::VariableExpr>&&, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<minja::Expression>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<minja::Expression>>>>&&)
|
monkey531[P]llama/common/minja.hpp
|
MacroTemplateToken(const Location & location, SpaceHandling pre, SpaceHandling post, std::shared_ptr<VariableExpr> && n, Expression::Parameters && p)
: TemplateToken(Type::Macro, location, pre, post), name(std::move(n)), params(std::move(p)) {}
|
O2
|
cpp
|
minja::MacroTemplateToken::MacroTemplateToken(minja::Location const&, minja::SpaceHandling, minja::SpaceHandling, std::shared_ptr<minja::VariableExpr>&&, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<minja::Expression>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<minja::Expression>>>>&&):
pushq %r15
pushq %r14
pushq %rbx
movq %r9, %rbx
movq %r8, %r14
movl %ecx, %r8d
movl %edx, %ecx
movq %rsi, %rdx
movq %rdi, %r15
pushq $0xd
popq %rsi
callq 0x7dc06
leaq 0x91e89(%rip), %rax # 0x11fdd8
addq $0x10, %rax
movq %rax, (%r15)
andq $0x0, 0x38(%r15)
movups (%r14), %xmm0
andq $0x0, 0x8(%r14)
movups %xmm0, 0x30(%r15)
andq $0x0, (%r14)
movups (%rbx), %xmm0
movups %xmm0, 0x40(%r15)
movq 0x10(%rbx), %rax
movq %rax, 0x50(%r15)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
|
_ZN5minja18MacroTemplateTokenC2ERKNS_8LocationENS_13SpaceHandlingES4_OSt10shared_ptrINS_12VariableExprEEOSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_INS_10ExpressionEEESaISJ_EE:
push r15
push r14
push rbx
mov rbx, r9
mov r14, r8
mov r8d, ecx
mov ecx, edx
mov rdx, rsi
mov r15, rdi
push 0Dh
pop rsi
call _ZN5minja13TemplateTokenC2ENS0_4TypeERKNS_8LocationENS_13SpaceHandlingES5_; minja::TemplateToken::TemplateToken(minja::TemplateToken::Type,minja::Location const&,minja::SpaceHandling,minja::SpaceHandling)
lea rax, _ZTVN5minja18MacroTemplateTokenE; `vtable for'minja::MacroTemplateToken
add rax, 10h
mov [r15], rax
and qword ptr [r15+38h], 0
movups xmm0, xmmword ptr [r14]
and qword ptr [r14+8], 0
movups xmmword ptr [r15+30h], xmm0
and qword ptr [r14], 0
movups xmm0, xmmword ptr [rbx]
movups xmmword ptr [r15+40h], xmm0
mov rax, [rbx+10h]
mov [r15+50h], rax
xorps xmm0, xmm0
movups xmmword ptr [rbx], xmm0
and qword ptr [rbx+10h], 0
pop rbx
pop r14
pop r15
retn
|
long long minja::MacroTemplateToken::MacroTemplateToken(
long long a1,
long long a2,
int a3,
int a4,
__int128 *a5,
long long a6)
{
__int128 v8; // xmm0
long long result; // rax
minja::TemplateToken::TemplateToken(a1, 13, a2, a3, a4);
*(_QWORD *)a1 = &`vtable for'minja::MacroTemplateToken + 2;
*(_QWORD *)(a1 + 56) = 0LL;
v8 = *a5;
*((_QWORD *)a5 + 1) = 0LL;
*(_OWORD *)(a1 + 48) = v8;
*(_QWORD *)a5 = 0LL;
*(_OWORD *)(a1 + 64) = *(_OWORD *)a6;
result = *(_QWORD *)(a6 + 16);
*(_QWORD *)(a1 + 80) = result;
*(_OWORD *)a6 = 0LL;
*(_QWORD *)(a6 + 16) = 0LL;
return result;
}
|
MacroTemplateToken:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,R9
MOV R14,R8
MOV R8D,ECX
MOV ECX,EDX
MOV RDX,RSI
MOV R15,RDI
PUSH 0xd
POP RSI
CALL 0x0017dc06
LEA RAX,[0x21fdd8]
ADD RAX,0x10
MOV qword ptr [R15],RAX
AND qword ptr [R15 + 0x38],0x0
MOVUPS XMM0,xmmword ptr [R14]
AND qword ptr [R14 + 0x8],0x0
MOVUPS xmmword ptr [R15 + 0x30],XMM0
AND qword ptr [R14],0x0
MOVUPS XMM0,xmmword ptr [RBX]
MOVUPS xmmword ptr [R15 + 0x40],XMM0
MOV RAX,qword ptr [RBX + 0x10]
MOV qword ptr [R15 + 0x50],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
AND qword ptr [RBX + 0x10],0x0
POP RBX
POP R14
POP R15
RET
|
/* minja::MacroTemplateToken::MacroTemplateToken(minja::Location const&, minja::SpaceHandling,
minja::SpaceHandling, std::shared_ptr<minja::VariableExpr>&&,
std::vector<std::pair<std::__cxx11::string, std::shared_ptr<minja::Expression> >,
std::allocator<std::pair<std::__cxx11::string, std::shared_ptr<minja::Expression> > > >&&) */
void __thiscall
minja::MacroTemplateToken::MacroTemplateToken
(MacroTemplateToken *this,int8 param_1,int4 param_3,int4 param_4,
int8 *param_5,int8 *param_6)
{
int8 uVar1;
TemplateToken::TemplateToken((TemplateToken *)this,0xd,param_1,param_3,param_4);
*(int ***)this = &PTR__MacroTemplateToken_0021fde8;
*(int8 *)(this + 0x38) = 0;
uVar1 = param_5[1];
param_5[1] = 0;
*(int8 *)(this + 0x30) = *param_5;
*(int8 *)(this + 0x38) = uVar1;
*param_5 = 0;
uVar1 = param_6[1];
*(int8 *)(this + 0x40) = *param_6;
*(int8 *)(this + 0x48) = uVar1;
*(int8 *)(this + 0x50) = param_6[2];
*param_6 = 0;
param_6[1] = 0;
param_6[2] = 0;
return;
}
|
|
60,636
|
pagecache_delete
|
eloqsql/storage/maria/ma_pagecache.c
|
my_bool pagecache_delete(PAGECACHE *pagecache,
PAGECACHE_FILE *file,
pgcache_page_no_t pageno,
enum pagecache_page_lock lock,
my_bool flush)
{
my_bool error= 0;
enum pagecache_page_pin pin= lock_to_pin_one_phase[lock];
DBUG_ENTER("pagecache_delete");
DBUG_PRINT("enter", ("fd: %u page: %lu %s %s",
(uint) file->file, (ulong) pageno,
page_cache_page_lock_str[lock],
page_cache_page_pin_str[pin]));
DBUG_ASSERT(lock == PAGECACHE_LOCK_WRITE ||
lock == PAGECACHE_LOCK_LEFT_WRITELOCKED);
DBUG_ASSERT(pin == PAGECACHE_PIN ||
pin == PAGECACHE_PIN_LEFT_PINNED);
restart:
DBUG_ASSERT(pageno < ((1ULL) << 40));
if (pagecache->can_be_used)
{
/* Key cache is used */
reg1 PAGECACHE_BLOCK_LINK *block;
PAGECACHE_HASH_LINK **unused_start, *page_link;
pagecache_pthread_mutex_lock(&pagecache->cache_lock);
if (!pagecache->can_be_used)
goto end;
inc_counter_for_resize_op(pagecache);
page_link= get_present_hash_link(pagecache, file, pageno, &unused_start);
if (!page_link)
{
DBUG_PRINT("info", ("There is no such page in the cache"));
dec_counter_for_resize_op(pagecache);
pagecache_pthread_mutex_unlock(&pagecache->cache_lock);
DBUG_RETURN(0);
}
block= page_link->block;
if (block->status & (PCBLOCK_REASSIGNED | PCBLOCK_IN_SWITCH))
{
DBUG_PRINT("info", ("Block %p already is %s",
block,
((block->status & PCBLOCK_REASSIGNED) ?
"reassigned" : "in switch")));
PCBLOCK_INFO(block);
page_link->requests--;
dec_counter_for_resize_op(pagecache);
goto end;
}
/* See NOTE for pagecache_unlock about registering requests. */
if (pin == PAGECACHE_PIN)
reg_requests(pagecache, block, 1);
if (make_lock_and_pin(pagecache, block, lock, pin, FALSE))
{
/*
We failed to writelock the block, cache is unlocked, and last write
lock is released, we will try to get the block again.
*/
if (pin == PAGECACHE_PIN)
unreg_request(pagecache, block, 1);
dec_counter_for_resize_op(pagecache);
pagecache_pthread_mutex_unlock(&pagecache->cache_lock);
dec_counter_for_resize_op(pagecache);
DBUG_PRINT("info", ("restarting..."));
goto restart;
}
/* we can't delete with opened direct link for write */
DBUG_ASSERT((block->status & PCBLOCK_DIRECT_W) == 0);
error= pagecache_delete_internal(pagecache, block, page_link, flush);
end:
pagecache_pthread_mutex_unlock(&pagecache->cache_lock);
}
DBUG_RETURN(error);
}
|
O0
|
c
|
pagecache_delete:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movb %al, -0x25(%rbp)
movb $0x0, -0x26(%rbp)
movl -0x24(%rbp), %eax
movl %eax, %ecx
leaq 0x27fcc3(%rip), %rax # 0x2be060
movl (%rax,%rcx,4), %eax
movl %eax, -0x2c(%rbp)
jmp 0x3e3a5
jmp 0x3e3a7
jmp 0x3e3a9
jmp 0x3e3ab
jmp 0x3e3ad
jmp 0x3e3af
jmp 0x3e3b1
jmp 0x3e3b3
movq -0x10(%rbp), %rax
cmpb $0x0, 0x1aa(%rax)
je 0x3e51f
movq -0x10(%rbp), %rdi
addq $0xc8, %rdi
leaq 0x113d9c(%rip), %rsi # 0x152172
movl $0x107a, %edx # imm = 0x107A
callq 0x3bb40
movq -0x10(%rbp), %rax
cmpb $0x0, 0x1aa(%rax)
jne 0x3e3f2
jmp 0x3e50f
movq -0x10(%rbp), %rdi
callq 0x3bef0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x3e530
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x3e441
jmp 0x3e41d
jmp 0x3e41f
movq -0x10(%rbp), %rdi
callq 0x3cc20
movq -0x10(%rbp), %rdi
addq $0xc8, %rdi
callq 0x3bbb0
movb $0x0, -0x1(%rbp)
jmp 0x3e527
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movzwl 0x74(%rax), %eax
andl $0xc, %eax
cmpl $0x0, %eax
je 0x3e480
jmp 0x3e45f
jmp 0x3e461
jmp 0x3e463
jmp 0x3e465
movq -0x48(%rbp), %rax
movl 0x68(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x68(%rax)
movq -0x10(%rbp), %rdi
callq 0x3cc20
jmp 0x3e50f
cmpl $0x2, -0x2c(%rbp)
jne 0x3e498
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl $0x1, %edx
callq 0x3e610
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl -0x24(%rbp), %edx
movl -0x2c(%rbp), %ecx
xorl %r8d, %r8d
callq 0x3c900
cmpb $0x0, %al
je 0x3e4f3
cmpl $0x2, -0x2c(%rbp)
jne 0x3e4ca
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl $0x1, %edx
callq 0x3caa0
movq -0x10(%rbp), %rdi
callq 0x3cc20
movq -0x10(%rbp), %rdi
addq $0xc8, %rdi
callq 0x3bbb0
movq -0x10(%rbp), %rdi
callq 0x3cc20
jmp 0x3e4ee
jmp 0x3e3af
jmp 0x3e4f5
jmp 0x3e4f7
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdx
movsbl -0x25(%rbp), %ecx
callq 0x3e0b0
movb %al, -0x26(%rbp)
movq -0x10(%rbp), %rdi
addq $0xc8, %rdi
callq 0x3bbb0
jmp 0x3e521
movb -0x26(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x50, %rsp
popq %rbp
retq
|
pagecache_delete:
push rbp
mov rbp, rsp
sub rsp, 50h
mov al, r8b
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_24], ecx
mov [rbp+var_25], al
mov [rbp+var_26], 0
mov eax, [rbp+var_24]
mov ecx, eax
lea rax, lock_to_pin_one_phase
mov eax, [rax+rcx*4]
mov [rbp+var_2C], eax
jmp short $+2
loc_3E3A5:
jmp short $+2
loc_3E3A7:
jmp short $+2
loc_3E3A9:
jmp short $+2
loc_3E3AB:
jmp short $+2
loc_3E3AD:
jmp short $+2
loc_3E3AF:
jmp short $+2
loc_3E3B1:
jmp short $+2
loc_3E3B3:
mov rax, [rbp+var_10]
cmp byte ptr [rax+1AAh], 0
jz loc_3E51F
mov rdi, [rbp+var_10]
add rdi, 0C8h
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 107Ah
call inline_mysql_mutex_lock_0
mov rax, [rbp+var_10]
cmp byte ptr [rax+1AAh], 0
jnz short loc_3E3F2
jmp loc_3E50F
loc_3E3F2:
mov rdi, [rbp+var_10]
call inc_counter_for_resize_op
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
lea rcx, [rbp+var_40]
call get_present_hash_link
mov [rbp+var_48], rax
cmp [rbp+var_48], 0
jnz short loc_3E441
jmp short $+2
loc_3E41D:
jmp short $+2
loc_3E41F:
mov rdi, [rbp+var_10]
call dec_counter_for_resize_op
mov rdi, [rbp+var_10]
add rdi, 0C8h
call inline_mysql_mutex_unlock_0
mov [rbp+var_1], 0
jmp loc_3E527
loc_3E441:
mov rax, [rbp+var_48]
mov rax, [rax+10h]
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
movzx eax, word ptr [rax+74h]
and eax, 0Ch
cmp eax, 0
jz short loc_3E480
jmp short $+2
loc_3E45F:
jmp short $+2
loc_3E461:
jmp short $+2
loc_3E463:
jmp short $+2
loc_3E465:
mov rax, [rbp+var_48]
mov ecx, [rax+68h]
add ecx, 0FFFFFFFFh
mov [rax+68h], ecx
mov rdi, [rbp+var_10]
call dec_counter_for_resize_op
jmp loc_3E50F
loc_3E480:
cmp [rbp+var_2C], 2
jnz short loc_3E498
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_38]
mov edx, 1
call reg_requests
loc_3E498:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_38]
mov edx, [rbp+var_24]
mov ecx, [rbp+var_2C]
xor r8d, r8d
call make_lock_and_pin
cmp al, 0
jz short loc_3E4F3
cmp [rbp+var_2C], 2
jnz short loc_3E4CA
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_38]
mov edx, 1
call unreg_request
loc_3E4CA:
mov rdi, [rbp+var_10]
call dec_counter_for_resize_op
mov rdi, [rbp+var_10]
add rdi, 0C8h
call inline_mysql_mutex_unlock_0
mov rdi, [rbp+var_10]
call dec_counter_for_resize_op
jmp short $+2
loc_3E4EE:
jmp loc_3E3AF
loc_3E4F3:
jmp short $+2
loc_3E4F5:
jmp short $+2
loc_3E4F7:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_38]
mov rdx, [rbp+var_48]
movsx ecx, [rbp+var_25]
call pagecache_delete_internal
mov [rbp+var_26], al
loc_3E50F:
mov rdi, [rbp+var_10]
add rdi, 0C8h
call inline_mysql_mutex_unlock_0
loc_3E51F:
jmp short $+2
loc_3E521:
mov al, [rbp+var_26]
mov [rbp+var_1], al
loc_3E527:
mov al, [rbp+var_1]
add rsp, 50h
pop rbp
retn
|
char pagecache_delete(_QWORD *a1, long long a2, long long a3, unsigned int a4, bool a5)
{
long long present_hash_link; // [rsp+8h] [rbp-48h]
_BYTE v7[8]; // [rsp+10h] [rbp-40h] BYREF
long long v8; // [rsp+18h] [rbp-38h]
int v9; // [rsp+24h] [rbp-2Ch]
char v10; // [rsp+2Ah] [rbp-26h]
bool v11; // [rsp+2Bh] [rbp-25h]
unsigned int v12; // [rsp+2Ch] [rbp-24h]
long long v13; // [rsp+30h] [rbp-20h]
long long v14; // [rsp+38h] [rbp-18h]
_QWORD *v15; // [rsp+40h] [rbp-10h]
v15 = a1;
v14 = a2;
v13 = a3;
v12 = a4;
v11 = a5;
v10 = 0;
v9 = lock_to_pin_one_phase[a4];
while ( *((_BYTE *)v15 + 426) )
{
inline_mysql_mutex_lock_0(
(long long)(v15 + 25),
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",
0x107Au);
if ( !*((_BYTE *)v15 + 426) )
goto LABEL_15;
inc_counter_for_resize_op((long long)v15);
present_hash_link = get_present_hash_link(v15, v14, v13, v7);
if ( !present_hash_link )
{
dec_counter_for_resize_op((long long)v15);
inline_mysql_mutex_unlock_0((long long)(v15 + 25));
return 0;
}
v8 = *(_QWORD *)(present_hash_link + 16);
if ( (*(_WORD *)(v8 + 116) & 0xC) != 0 )
{
--*(_DWORD *)(present_hash_link + 104);
dec_counter_for_resize_op((long long)v15);
LABEL_15:
inline_mysql_mutex_unlock_0((long long)(v15 + 25));
return v10;
}
if ( v9 == 2 )
reg_requests(v15, v8, 1LL);
if ( !make_lock_and_pin((long long)v15, v8, v12, v9, 0) )
{
v10 = pagecache_delete_internal(v15, v8, present_hash_link, v11);
goto LABEL_15;
}
if ( v9 == 2 )
unreg_request(v15, v8, 1);
dec_counter_for_resize_op((long long)v15);
inline_mysql_mutex_unlock_0((long long)(v15 + 25));
dec_counter_for_resize_op((long long)v15);
}
return v10;
}
|
pagecache_delete:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV AL,R8B
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV dword ptr [RBP + -0x24],ECX
MOV byte ptr [RBP + -0x25],AL
MOV byte ptr [RBP + -0x26],0x0
MOV EAX,dword ptr [RBP + -0x24]
MOV ECX,EAX
LEA RAX,[0x3be060]
MOV EAX,dword ptr [RAX + RCX*0x4]
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x0013e3a5
LAB_0013e3a5:
JMP 0x0013e3a7
LAB_0013e3a7:
JMP 0x0013e3a9
LAB_0013e3a9:
JMP 0x0013e3ab
LAB_0013e3ab:
JMP 0x0013e3ad
LAB_0013e3ad:
JMP 0x0013e3af
LAB_0013e3af:
JMP 0x0013e3b1
LAB_0013e3b1:
JMP 0x0013e3b3
LAB_0013e3b3:
MOV RAX,qword ptr [RBP + -0x10]
CMP byte ptr [RAX + 0x1aa],0x0
JZ 0x0013e51f
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0xc8
LEA RSI,[0x252172]
MOV EDX,0x107a
CALL 0x0013bb40
MOV RAX,qword ptr [RBP + -0x10]
CMP byte ptr [RAX + 0x1aa],0x0
JNZ 0x0013e3f2
JMP 0x0013e50f
LAB_0013e3f2:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0013bef0
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
LEA RCX,[RBP + -0x40]
CALL 0x0013e530
MOV qword ptr [RBP + -0x48],RAX
CMP qword ptr [RBP + -0x48],0x0
JNZ 0x0013e441
JMP 0x0013e41d
LAB_0013e41d:
JMP 0x0013e41f
LAB_0013e41f:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0013cc20
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0xc8
CALL 0x0013bbb0
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0013e527
LAB_0013e441:
MOV RAX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOVZX EAX,word ptr [RAX + 0x74]
AND EAX,0xc
CMP EAX,0x0
JZ 0x0013e480
JMP 0x0013e45f
LAB_0013e45f:
JMP 0x0013e461
LAB_0013e461:
JMP 0x0013e463
LAB_0013e463:
JMP 0x0013e465
LAB_0013e465:
MOV RAX,qword ptr [RBP + -0x48]
MOV ECX,dword ptr [RAX + 0x68]
ADD ECX,-0x1
MOV dword ptr [RAX + 0x68],ECX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0013cc20
JMP 0x0013e50f
LAB_0013e480:
CMP dword ptr [RBP + -0x2c],0x2
JNZ 0x0013e498
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x38]
MOV EDX,0x1
CALL 0x0013e610
LAB_0013e498:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x38]
MOV EDX,dword ptr [RBP + -0x24]
MOV ECX,dword ptr [RBP + -0x2c]
XOR R8D,R8D
CALL 0x0013c900
CMP AL,0x0
JZ 0x0013e4f3
CMP dword ptr [RBP + -0x2c],0x2
JNZ 0x0013e4ca
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x38]
MOV EDX,0x1
CALL 0x0013caa0
LAB_0013e4ca:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0013cc20
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0xc8
CALL 0x0013bbb0
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0013cc20
JMP 0x0013e4ee
LAB_0013e4ee:
JMP 0x0013e3af
LAB_0013e4f3:
JMP 0x0013e4f5
LAB_0013e4f5:
JMP 0x0013e4f7
LAB_0013e4f7:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x48]
MOVSX ECX,byte ptr [RBP + -0x25]
CALL 0x0013e0b0
MOV byte ptr [RBP + -0x26],AL
LAB_0013e50f:
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0xc8
CALL 0x0013bbb0
LAB_0013e51f:
JMP 0x0013e521
LAB_0013e521:
MOV AL,byte ptr [RBP + -0x26]
MOV byte ptr [RBP + -0x1],AL
LAB_0013e527:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x50
POP RBP
RET
|
int8
pagecache_delete(long param_1,int8 param_2,int8 param_3,uint param_4,char param_5)
{
char cVar1;
long lVar2;
int7 extraout_var;
int7 uVar3;
int1 local_48 [8];
long local_40;
int local_34;
int1 local_2e;
char local_2d;
uint local_2c;
int8 local_28;
int8 local_20;
long local_18;
int1 local_9;
local_2e = 0;
local_34 = *(int *)(lock_to_pin_one_phase + (ulong)param_4 * 4);
local_2d = param_5;
local_2c = param_4;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
do {
if (*(char *)(local_18 + 0x1aa) == '\0') {
LAB_0013e51f:
uVar3 = (int7)((ulong)local_18 >> 8);
local_9 = local_2e;
LAB_0013e527:
return CONCAT71(uVar3,local_9);
}
inline_mysql_mutex_lock
(local_18 + 200,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",0x107a);
if (*(char *)(local_18 + 0x1aa) == '\0') goto LAB_0013e50f;
inc_counter_for_resize_op(local_18);
lVar2 = get_present_hash_link(local_18,local_20,local_28,local_48);
if (lVar2 == 0) {
dec_counter_for_resize_op(local_18);
inline_mysql_mutex_unlock(local_18 + 200);
local_9 = 0;
uVar3 = extraout_var;
goto LAB_0013e527;
}
local_40 = *(long *)(lVar2 + 0x10);
if ((*(ushort *)(local_40 + 0x74) & 0xc) != 0) {
*(int *)(lVar2 + 0x68) = *(int *)(lVar2 + 0x68) + -1;
dec_counter_for_resize_op(local_18);
LAB_0013e50f:
local_18 = inline_mysql_mutex_unlock(local_18 + 200);
goto LAB_0013e51f;
}
if (local_34 == 2) {
reg_requests(local_18,local_40,1);
}
cVar1 = make_lock_and_pin(local_18,local_40,local_2c,local_34,0);
if (cVar1 == '\0') {
local_2e = pagecache_delete_internal(local_18,local_40,lVar2,(int)local_2d);
goto LAB_0013e50f;
}
if (local_34 == 2) {
unreg_request(local_18,local_40,1);
}
dec_counter_for_resize_op(local_18);
inline_mysql_mutex_unlock(local_18 + 200);
dec_counter_for_resize_op(local_18);
} while( true );
}
|
|
60,637
|
my_wc_mb_euc_kr
|
eloqsql/strings/ctype-euc_kr.c
|
static int
my_wc_mb_euc_kr(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
int code;
if (s >= e)
return MY_CS_TOOSMALL;
if ((uint) wc < 0x80)
{
s[0]= (uchar) wc;
return 1;
}
if (!(code=func_uni_ksc5601_onechar(wc)))
return MY_CS_ILUNI;
if (s+2>e)
return MY_CS_TOOSMALL2;
s[0]=code>>8;
s[1]=code&0xFF;
return 2;
}
|
O3
|
c
|
my_wc_mb_euc_kr:
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0x5472e
cmpl $0x7f, %esi
ja 0x5472f
movb %sil, (%rdx)
movl $0x1, %eax
retq
leal -0xa1(%rsi), %eax
cmpl $0xc6, %eax
ja 0x5474a
movl %eax, %eax
leaq 0x9889b(%rip), %rsi # 0xecfe0
jmp 0x54842
leal -0x2c7(%rsi), %eax
cmpl $0x18a, %eax # imm = 0x18A
ja 0x54765
movl %eax, %eax
leaq 0x98a10(%rip), %rsi # 0xed170
jmp 0x54842
leal -0x2015(%rsi), %eax
cmpl $0x2fd, %eax # imm = 0x2FD
ja 0x54780
movl %eax, %eax
leaq 0x98d15(%rip), %rsi # 0xed490
jmp 0x54842
leal -0x2460(%rsi), %eax
cmpl $0x20d, %eax # imm = 0x20D
ja 0x5479b
movl %eax, %eax
leaq 0x992fa(%rip), %rsi # 0xeda90
jmp 0x54842
leal -0x3000(%rsi), %eax
cmpl $0x27f, %eax # imm = 0x27F
ja 0x547b6
movl %eax, %eax
leaq 0x996ff(%rip), %rsi # 0xedeb0
jmp 0x54842
leal -0x3380(%rsi), %eax
cmpl $0x5d, %eax
ja 0x547cc
movl %eax, %eax
leaq 0x99be6(%rip), %rsi # 0xee3b0
jmp 0x54842
leal -0x4e00(%rsi), %eax
cmpl $0x467f, %eax # imm = 0x467F
ja 0x547e4
movl %eax, %eax
leaq 0x99c8e(%rip), %rsi # 0xee470
jmp 0x54842
leal -0x9577(%rsi), %eax
cmpl $0xa25, %eax # imm = 0xA25
ja 0x547fc
movl %eax, %eax
leaq 0xa2976(%rip), %rsi # 0xf7170
jmp 0x54842
leal -0xac00(%rsi), %eax
cmpl $0x2ba3, %eax # imm = 0x2BA3
ja 0x54814
movl %eax, %eax
leaq 0xa3dae(%rip), %rsi # 0xf85c0
jmp 0x54842
leal -0xf900(%rsi), %eax
cmpl $0x10b, %eax # imm = 0x10B
ja 0x5482c
movl %eax, %eax
leaq 0xa94e6(%rip), %rsi # 0xfdd10
jmp 0x54842
leal -0xff01(%rsi), %eax
cmpl $0xe5, %eax
ja 0x54872
movl %eax, %eax
leaq 0xa96ee(%rip), %rsi # 0xfdf30
leaq (%rsi,%rax,2), %rax
pushq %rbp
movq %rsp, %rbp
movzwl (%rax), %esi
testw %si, %si
je 0x5486e
leaq 0x2(%rdx), %rdi
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %rdi
ja 0x54870
rolw $0x8, %si
movw %si, (%rdx)
movl $0x2, %eax
jmp 0x54870
xorl %eax, %eax
popq %rbp
retq
xorl %eax, %eax
retq
|
my_wc_mb_euc_kr:
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short locret_5472E
cmp esi, 7Fh
ja short loc_5472F
mov [rdx], sil
mov eax, 1
locret_5472E:
retn
loc_5472F:
lea eax, [rsi-0A1h]
cmp eax, 0C6h
ja short loc_5474A
mov eax, eax
lea rsi, tab_uni_ksc56010
jmp loc_54842
loc_5474A:
lea eax, [rsi-2C7h]
cmp eax, 18Ah
ja short loc_54765
mov eax, eax
lea rsi, tab_uni_ksc56011
jmp loc_54842
loc_54765:
lea eax, [rsi-2015h]
cmp eax, 2FDh
ja short loc_54780
mov eax, eax
lea rsi, tab_uni_ksc56012
jmp loc_54842
loc_54780:
lea eax, [rsi-2460h]
cmp eax, 20Dh
ja short loc_5479B
mov eax, eax
lea rsi, tab_uni_ksc56013
jmp loc_54842
loc_5479B:
lea eax, [rsi-3000h]
cmp eax, 27Fh
ja short loc_547B6
mov eax, eax
lea rsi, tab_uni_ksc56014
jmp loc_54842
loc_547B6:
lea eax, [rsi-3380h]
cmp eax, 5Dh ; ']'
ja short loc_547CC
mov eax, eax
lea rsi, tab_uni_ksc56015
jmp short loc_54842
loc_547CC:
lea eax, [rsi-4E00h]
cmp eax, 467Fh
ja short loc_547E4
mov eax, eax
lea rsi, tab_uni_ksc56016
jmp short loc_54842
loc_547E4:
lea eax, [rsi-9577h]
cmp eax, 0A25h
ja short loc_547FC
mov eax, eax
lea rsi, tab_uni_ksc56017
jmp short loc_54842
loc_547FC:
lea eax, [rsi-0AC00h]
cmp eax, 2BA3h
ja short loc_54814
mov eax, eax
lea rsi, tab_uni_ksc56018
jmp short loc_54842
loc_54814:
lea eax, [rsi-0F900h]
cmp eax, 10Bh
ja short loc_5482C
mov eax, eax
lea rsi, tab_uni_ksc56019
jmp short loc_54842
loc_5482C:
lea eax, [rsi-0FF01h]
cmp eax, 0E5h
ja short loc_54872
mov eax, eax
lea rsi, tab_uni_ksc560110
loc_54842:
lea rax, [rsi+rax*2]
push rbp
mov rbp, rsp
movzx esi, word ptr [rax]
test si, si
jz short loc_5486E
lea rdi, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp rdi, rcx
ja short loc_54870
rol si, 8
mov [rdx], si
mov eax, 2
jmp short loc_54870
loc_5486E:
xor eax, eax
loc_54870:
pop rbp
retn
loc_54872:
xor eax, eax
retn
|
long long my_wc_mb_euc_kr(long long a1, unsigned int a2, _WORD *a3, unsigned long long a4)
{
long long result; // rax
long long v5; // rax
_WORD *v6; // rsi
__int16 v7; // si
result = 4294967195LL;
if ( (unsigned long long)a3 < a4 )
{
if ( a2 > 0x7F )
{
LODWORD(v5) = a2 - 161;
if ( a2 - 161 > 0xC6 )
{
LODWORD(v5) = a2 - 711;
if ( a2 - 711 > 0x18A )
{
LODWORD(v5) = a2 - 8213;
if ( a2 - 8213 > 0x2FD )
{
LODWORD(v5) = a2 - 9312;
if ( a2 - 9312 > 0x20D )
{
LODWORD(v5) = a2 - 12288;
if ( a2 - 12288 > 0x27F )
{
LODWORD(v5) = a2 - 13184;
if ( a2 - 13184 > 0x5D )
{
LODWORD(v5) = a2 - 19968;
if ( a2 - 19968 > 0x467F )
{
LODWORD(v5) = a2 - 38263;
if ( a2 - 38263 > 0xA25 )
{
LODWORD(v5) = a2 - 44032;
if ( a2 - 44032 > 0x2BA3 )
{
LODWORD(v5) = a2 - 63744;
if ( a2 - 63744 > 0x10B )
{
LODWORD(v5) = a2 - 65281;
if ( a2 - 65281 > 0xE5 )
return 0LL;
v5 = (unsigned int)v5;
v6 = &tab_uni_ksc560110;
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_ksc56019;
}
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_ksc56018;
}
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_ksc56017;
}
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_ksc56016;
}
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_ksc56015;
}
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_ksc56014;
}
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_ksc56013;
}
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_ksc56012;
}
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_ksc56011;
}
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_ksc56010;
}
v7 = v6[v5];
if ( v7 )
{
result = 4294967194LL;
if ( (unsigned long long)(a3 + 1) <= a4 )
{
*a3 = __ROL2__(v7, 8);
return 2LL;
}
}
else
{
return 0LL;
}
}
else
{
*(_BYTE *)a3 = a2;
return 1LL;
}
}
return result;
}
|
my_wc_mb_euc_kr:
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x0015472e
CMP ESI,0x7f
JA 0x0015472f
MOV byte ptr [RDX],SIL
MOV EAX,0x1
LAB_0015472e:
RET
LAB_0015472f:
LEA EAX,[RSI + -0xa1]
CMP EAX,0xc6
JA 0x0015474a
MOV EAX,EAX
LEA RSI,[0x1ecfe0]
JMP 0x00154842
LAB_0015474a:
LEA EAX,[RSI + -0x2c7]
CMP EAX,0x18a
JA 0x00154765
MOV EAX,EAX
LEA RSI,[0x1ed170]
JMP 0x00154842
LAB_00154765:
LEA EAX,[RSI + -0x2015]
CMP EAX,0x2fd
JA 0x00154780
MOV EAX,EAX
LEA RSI,[0x1ed490]
JMP 0x00154842
LAB_00154780:
LEA EAX,[RSI + -0x2460]
CMP EAX,0x20d
JA 0x0015479b
MOV EAX,EAX
LEA RSI,[0x1eda90]
JMP 0x00154842
LAB_0015479b:
LEA EAX,[RSI + -0x3000]
CMP EAX,0x27f
JA 0x001547b6
MOV EAX,EAX
LEA RSI,[0x1edeb0]
JMP 0x00154842
LAB_001547b6:
LEA EAX,[RSI + -0x3380]
CMP EAX,0x5d
JA 0x001547cc
MOV EAX,EAX
LEA RSI,[0x1ee3b0]
JMP 0x00154842
LAB_001547cc:
LEA EAX,[RSI + -0x4e00]
CMP EAX,0x467f
JA 0x001547e4
MOV EAX,EAX
LEA RSI,[0x1ee470]
JMP 0x00154842
LAB_001547e4:
LEA EAX,[RSI + -0x9577]
CMP EAX,0xa25
JA 0x001547fc
MOV EAX,EAX
LEA RSI,[0x1f7170]
JMP 0x00154842
LAB_001547fc:
LEA EAX,[RSI + -0xac00]
CMP EAX,0x2ba3
JA 0x00154814
MOV EAX,EAX
LEA RSI,[0x1f85c0]
JMP 0x00154842
LAB_00154814:
LEA EAX,[RSI + -0xf900]
CMP EAX,0x10b
JA 0x0015482c
MOV EAX,EAX
LEA RSI,[0x1fdd10]
JMP 0x00154842
LAB_0015482c:
LEA EAX,[RSI + -0xff01]
CMP EAX,0xe5
JA 0x00154872
MOV EAX,EAX
LEA RSI,[0x1fdf30]
LAB_00154842:
LEA RAX,[RSI + RAX*0x2]
PUSH RBP
MOV RBP,RSP
MOVZX ESI,word ptr [RAX]
TEST SI,SI
JZ 0x0015486e
LEA RDI,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP RDI,RCX
JA 0x00154870
ROL SI,0x8
MOV word ptr [RDX],SI
MOV EAX,0x2
JMP 0x00154870
LAB_0015486e:
XOR EAX,EAX
LAB_00154870:
POP RBP
RET
LAB_00154872:
XOR EAX,EAX
RET
|
int8 my_wc_mb_euc_kr(int8 param_1,uint param_2,ushort *param_3,ushort *param_4)
{
ushort uVar1;
int8 uVar2;
ulong uVar3;
int1 *puVar4;
uVar2 = 0xffffff9b;
if (param_3 < param_4) {
if (0x7f < param_2) {
if (param_2 - 0xa1 < 199) {
uVar3 = (ulong)(param_2 - 0xa1);
puVar4 = tab_uni_ksc56010;
}
else if (param_2 - 0x2c7 < 0x18b) {
uVar3 = (ulong)(param_2 - 0x2c7);
puVar4 = tab_uni_ksc56011;
}
else if (param_2 - 0x2015 < 0x2fe) {
uVar3 = (ulong)(param_2 - 0x2015);
puVar4 = tab_uni_ksc56012;
}
else if (param_2 - 0x2460 < 0x20e) {
uVar3 = (ulong)(param_2 - 0x2460);
puVar4 = tab_uni_ksc56013;
}
else if (param_2 - 0x3000 < 0x280) {
uVar3 = (ulong)(param_2 - 0x3000);
puVar4 = tab_uni_ksc56014;
}
else if (param_2 - 0x3380 < 0x5e) {
uVar3 = (ulong)(param_2 - 0x3380);
puVar4 = tab_uni_ksc56015;
}
else if (param_2 - 0x4e00 < 0x4680) {
uVar3 = (ulong)(param_2 - 0x4e00);
puVar4 = tab_uni_ksc56016;
}
else if (param_2 - 0x9577 < 0xa26) {
uVar3 = (ulong)(param_2 - 0x9577);
puVar4 = tab_uni_ksc56017;
}
else if (param_2 - 0xac00 < 0x2ba4) {
uVar3 = (ulong)(param_2 - 0xac00);
puVar4 = tab_uni_ksc56018;
}
else if (param_2 - 0xf900 < 0x10c) {
uVar3 = (ulong)(param_2 - 0xf900);
puVar4 = tab_uni_ksc56019;
}
else {
uVar3 = (ulong)(param_2 - 0xff01);
if (0xe5 < param_2 - 0xff01) {
return 0;
}
puVar4 = tab_uni_ksc560110;
}
uVar1 = *(ushort *)(puVar4 + uVar3 * 2);
if (uVar1 == 0) {
uVar2 = 0;
}
else {
uVar2 = 0xffffff9a;
if (param_3 + 1 <= param_4) {
*param_3 = uVar1 << 8 | uVar1 >> 8;
uVar2 = 2;
}
}
return uVar2;
}
*(char *)param_3 = (char)param_2;
uVar2 = 1;
}
return uVar2;
}
|
|
60,638
|
translog_wait_for_writers
|
eloqsql/storage/maria/ma_loghandler.c
|
static void translog_wait_for_writers(struct st_translog_buffer *buffer)
{
DBUG_ENTER("translog_wait_for_writers");
DBUG_PRINT("enter", ("Buffer #%u %p copies in progress: %u "
"is closing %u File: %d size: %lu",
(uint) buffer->buffer_no, buffer,
(uint) buffer->copy_to_buffer_in_progress,
(uint) buffer->is_closing_buffer,
(buffer->file ? buffer->file->handler.file : -1),
(ulong) buffer->size));
translog_buffer_lock_assert_owner(buffer);
while (buffer->copy_to_buffer_in_progress)
{
DBUG_PRINT("info", ("wait for writers... buffer: #%u %p",
(uint) buffer->buffer_no, buffer));
DBUG_ASSERT(buffer->file != NULL);
mysql_cond_wait(&buffer->waiting_filling_buffer, &buffer->mutex);
DBUG_PRINT("info", ("wait for writers done buffer: #%u %p",
(uint) buffer->buffer_no, buffer));
}
DBUG_VOID_RETURN;
}
|
O3
|
c
|
translog_wait_for_writers:
cmpl $0x0, 0x100078(%rdi)
je 0x38eb5
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x100040(%rdi), %r14
leaq 0x100090(%rdi), %r15
leaq 0xa0cec(%rip), %r12 # 0xd9b64
cmpq $0x0, 0x100070(%rbx)
jne 0x38e98
movq %r14, %rdi
movq %r15, %rsi
callq 0x29430
cmpl $0x0, 0x100078(%rbx)
jne 0x38e78
jmp 0x38ead
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movl $0x806, %ecx # imm = 0x806
callq 0x2eec0
jmp 0x38e8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
translog_wait_for_writers:
cmp ds:dword_100078[rdi], 0
jz short locret_38EB5
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov rbx, rdi
lea r14, unk_100040[rdi]
lea r15, unk_100090[rdi]
lea r12, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
loc_38E78:
cmp ds:qword_100070[rbx], 0
jnz short loc_38E98
mov rdi, r14
mov rsi, r15
call _pthread_cond_wait
loc_38E8D:
cmp ds:dword_100078[rbx], 0
jnz short loc_38E78
jmp short loc_38EAD
loc_38E98:
mov rdi, r14
mov rsi, r15
mov rdx, r12
mov ecx, 806h
call psi_cond_wait
jmp short loc_38E8D
loc_38EAD:
pop rbx
pop r12
pop r14
pop r15
pop rbp
locret_38EB5:
retn
|
long long translog_wait_for_writers(long long a1)
{
char *v1; // r14
char *v2; // r15
long long result; // rax
if ( *(int *)((char *)&dword_100078 + a1) )
{
v1 = (char *)&unk_100040 + a1;
v2 = (char *)&unk_100090 + a1;
do
{
if ( *(long long *)((char *)&qword_100070 + a1) )
result = psi_cond_wait(
(long long)v1,
(long long)v2,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
0x806u);
else
result = pthread_cond_wait(v1, v2);
}
while ( *(int *)((char *)&dword_100078 + a1) );
}
return result;
}
|
translog_wait_for_writers:
CMP dword ptr [RDI + 0x100078],0x0
JZ 0x00138eb5
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RBX,RDI
LEA R14,[RDI + 0x100040]
LEA R15,[RDI + 0x100090]
LEA R12,[0x1d9b64]
LAB_00138e78:
CMP qword ptr [RBX + 0x100070],0x0
JNZ 0x00138e98
MOV RDI,R14
MOV RSI,R15
CALL 0x00129430
LAB_00138e8d:
CMP dword ptr [RBX + 0x100078],0x0
JNZ 0x00138e78
JMP 0x00138ead
LAB_00138e98:
MOV RDI,R14
MOV RSI,R15
MOV RDX,R12
MOV ECX,0x806
CALL 0x0012eec0
JMP 0x00138e8d
LAB_00138ead:
POP RBX
POP R12
POP R14
POP R15
POP RBP
LAB_00138eb5:
RET
|
void translog_wait_for_writers(long param_1)
{
pthread_cond_t *__cond;
pthread_mutex_t *__mutex;
if (*(int *)((long)&Elf64_Phdr_ARRAY_00100040[1].p_type + param_1) != 0) {
__cond = (pthread_cond_t *)((long)&Elf64_Phdr_ARRAY_00100040[0].p_type + param_1);
__mutex = (pthread_mutex_t *)((long)&Elf64_Phdr_ARRAY_00100040[1].p_paddr + param_1);
do {
if (*(long *)((long)&Elf64_Phdr_ARRAY_00100040[0].p_align + param_1) == 0) {
pthread_cond_wait(__cond,__mutex);
}
else {
psi_cond_wait(__cond,__mutex,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",0x806
);
}
} while (*(int *)((long)&Elf64_Phdr_ARRAY_00100040[1].p_type + param_1) != 0);
}
return;
}
|
|
60,639
|
bf_normalize_and_round
|
bluesky950520[P]quickjs/libbf.c
|
int bf_normalize_and_round(bf_t *r, limb_t prec1, bf_flags_t flags)
{
limb_t l, v, a;
int shift, ret;
slimb_t i;
// bf_print_str("bf_renorm", r);
l = r->len;
while (l > 0 && r->tab[l - 1] == 0)
l--;
if (l == 0) {
/* zero */
r->expn = BF_EXP_ZERO;
bf_resize(r, 0); /* cannot fail */
ret = 0;
} else {
r->expn -= (r->len - l) * LIMB_BITS;
/* shift to have the MSB set to '1' */
v = r->tab[l - 1];
shift = clz(v);
if (shift != 0) {
v = 0;
for(i = 0; i < l; i++) {
a = r->tab[i];
r->tab[i] = (a << shift) | (v >> (LIMB_BITS - shift));
v = a;
}
r->expn -= shift;
}
ret = __bf_round(r, prec1, flags, l, 0);
}
// bf_print_str("r_final", r);
return ret;
}
|
O1
|
c
|
bf_normalize_and_round:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rcx
testq %rcx, %rcx
je 0x84d87
movq 0x20(%rbx), %r9
xorl %edi, %edi
movq %rcx, %rax
cmpq $0x0, -0x8(%r9,%rax,8)
jne 0x84dbd
addq $0x40, %rdi
decq %rax
jne 0x84d76
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x10(%rbx)
testq %rcx, %rcx
je 0x84db5
movq (%rbx), %rax
movq 0x20(%rbx), %rsi
movq (%rax), %rdi
xorl %edx, %edx
callq *0x8(%rax)
movq %rax, 0x20(%rbx)
movq $0x0, 0x18(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
subq %rdi, 0x10(%rbx)
movq -0x8(%r9,%rax,8), %rcx
testq %rcx, %rcx
je 0x84dd5
bsrq %rcx, %rdi
xorq $0x3f, %rdi
jmp 0x84dda
movl $0x40, %edi
testq %rdi, %rdi
je 0x84e16
movl $0x40, %r8d
subq %rdi, %r8
xorl %r10d, %r10d
xorl %r11d, %r11d
movq (%r9,%r10,8), %r14
movq %r14, %r15
movl %edi, %ecx
shlq %cl, %r15
movl %r8d, %ecx
shrq %cl, %r11
orq %r15, %r11
movq %r11, (%r9,%r10,8)
incq %r10
movq %r14, %r11
cmpq %rax, %r10
jb 0x84dee
subq %rdi, 0x10(%rbx)
movq %rbx, %rdi
movq %rax, %rcx
xorl %r8d, %r8d
popq %rbx
popq %r14
popq %r15
jmp 0x84e26
|
bf_normalize_and_round:
push r15
push r14
push rbx
mov rbx, rdi
mov rcx, [rdi+18h]
test rcx, rcx
jz short loc_84D87
mov r9, [rbx+20h]
xor edi, edi
mov rax, rcx
loc_84D76:
cmp qword ptr [r9+rax*8-8], 0
jnz short loc_84DBD
add rdi, 40h ; '@'
dec rax
jnz short loc_84D76
loc_84D87:
mov rax, 8000000000000000h
mov [rbx+10h], rax
test rcx, rcx
jz short loc_84DB5
mov rax, [rbx]
mov rsi, [rbx+20h]
mov rdi, [rax]
xor edx, edx
call qword ptr [rax+8]
mov [rbx+20h], rax
mov qword ptr [rbx+18h], 0
loc_84DB5:
xor eax, eax
pop rbx
pop r14
pop r15
retn
loc_84DBD:
sub [rbx+10h], rdi
mov rcx, [r9+rax*8-8]
test rcx, rcx
jz short loc_84DD5
bsr rdi, rcx
xor rdi, 3Fh
jmp short loc_84DDA
loc_84DD5:
mov edi, 40h ; '@'
loc_84DDA:
test rdi, rdi
jz short loc_84E16
mov r8d, 40h ; '@'
sub r8, rdi
xor r10d, r10d
xor r11d, r11d
loc_84DEE:
mov r14, [r9+r10*8]
mov r15, r14
mov ecx, edi
shl r15, cl
mov ecx, r8d
shr r11, cl
or r11, r15
mov [r9+r10*8], r11
inc r10
mov r11, r14
cmp r10, rax
jb short loc_84DEE
sub [rbx+10h], rdi
loc_84E16:
mov rdi, rbx
mov rcx, rax
xor r8d, r8d
pop rbx
pop r14
pop r15
jmp short $+2
|
long long bf_normalize_and_round(_QWORD *a1, long long a2, long long a3)
{
unsigned long long v4; // rcx
long long v5; // r9
long long v6; // rdi
unsigned long long v7; // rax
unsigned long long v9; // rcx
unsigned long long v10; // rdi
unsigned long long v11; // rdi
unsigned long long v12; // r10
unsigned long long v13; // r11
unsigned long long v14; // r14
v4 = a1[3];
if ( v4 )
{
v5 = a1[4];
v6 = 0LL;
v7 = v4;
while ( !*(_QWORD *)(v5 + 8 * v7 - 8) )
{
v6 += 64LL;
if ( !--v7 )
goto LABEL_5;
}
a1[2] -= v6;
v9 = *(_QWORD *)(v5 + 8 * v7 - 8);
if ( v9 )
{
_BitScanReverse64(&v10, v9);
v11 = v10 ^ 0x3F;
}
else
{
v11 = 64LL;
}
if ( v11 )
{
v12 = 0LL;
v13 = 0LL;
do
{
v14 = *(_QWORD *)(v5 + 8 * v12);
*(_QWORD *)(v5 + 8 * v12++) = (v14 << v11) | (v13 >> (64 - (unsigned __int8)v11));
v13 = v14;
}
while ( v12 < v7 );
a1[2] -= v11;
}
return _bf_round(a1, a2, a3, v7, 0LL);
}
else
{
LABEL_5:
a1[2] = 0x8000000000000000LL;
if ( v4 )
{
a1[4] = (*(long long ( **)(_QWORD, _QWORD, _QWORD))(*a1 + 8LL))(*(_QWORD *)*a1, a1[4], 0LL);
a1[3] = 0LL;
}
return 0LL;
}
}
|
bf_normalize_and_round:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDI
MOV RCX,qword ptr [RDI + 0x18]
TEST RCX,RCX
JZ 0x00184d87
MOV R9,qword ptr [RBX + 0x20]
XOR EDI,EDI
MOV RAX,RCX
LAB_00184d76:
CMP qword ptr [R9 + RAX*0x8 + -0x8],0x0
JNZ 0x00184dbd
ADD RDI,0x40
DEC RAX
JNZ 0x00184d76
LAB_00184d87:
MOV RAX,-0x8000000000000000
MOV qword ptr [RBX + 0x10],RAX
TEST RCX,RCX
JZ 0x00184db5
MOV RAX,qword ptr [RBX]
MOV RSI,qword ptr [RBX + 0x20]
MOV RDI,qword ptr [RAX]
XOR EDX,EDX
CALL qword ptr [RAX + 0x8]
MOV qword ptr [RBX + 0x20],RAX
MOV qword ptr [RBX + 0x18],0x0
LAB_00184db5:
XOR EAX,EAX
POP RBX
POP R14
POP R15
RET
LAB_00184dbd:
SUB qword ptr [RBX + 0x10],RDI
MOV RCX,qword ptr [R9 + RAX*0x8 + -0x8]
TEST RCX,RCX
JZ 0x00184dd5
BSR RDI,RCX
XOR RDI,0x3f
JMP 0x00184dda
LAB_00184dd5:
MOV EDI,0x40
LAB_00184dda:
TEST RDI,RDI
JZ 0x00184e16
MOV R8D,0x40
SUB R8,RDI
XOR R10D,R10D
XOR R11D,R11D
LAB_00184dee:
MOV R14,qword ptr [R9 + R10*0x8]
MOV R15,R14
MOV ECX,EDI
SHL R15,CL
MOV ECX,R8D
SHR R11,CL
OR R11,R15
MOV qword ptr [R9 + R10*0x8],R11
INC R10
MOV R11,R14
CMP R10,RAX
JC 0x00184dee
SUB qword ptr [RBX + 0x10],RDI
LAB_00184e16:
MOV RDI,RBX
MOV RCX,RAX
XOR R8D,R8D
POP RBX
POP R14
POP R15
JMP 0x00184e26
|
int8 bf_normalize_and_round(long *param_1,int8 param_2,int8 param_3)
{
ulong uVar1;
ulong uVar2;
long lVar3;
int8 uVar4;
long lVar5;
ulong uVar6;
ulong uVar7;
ulong uVar8;
uVar8 = param_1[3];
if (uVar8 != 0) {
lVar3 = param_1[4];
lVar5 = 0;
uVar2 = uVar8;
do {
if (*(long *)(lVar3 + -8 + uVar2 * 8) != 0) {
param_1[2] = param_1[2] - lVar5;
uVar8 = *(ulong *)(lVar3 + -8 + uVar2 * 8);
if (uVar8 == 0) {
uVar6 = 0x40;
}
else {
uVar6 = 0x3f;
if (uVar8 != 0) {
for (; uVar8 >> uVar6 == 0; uVar6 = uVar6 - 1) {
}
}
uVar6 = uVar6 ^ 0x3f;
}
if (uVar6 != 0) {
uVar7 = 0;
uVar8 = 0;
do {
uVar1 = *(ulong *)(lVar3 + uVar7 * 8);
*(ulong *)(lVar3 + uVar7 * 8) =
uVar8 >> (0x40 - (byte)uVar6 & 0x3f) | uVar1 << ((byte)uVar6 & 0x3f);
uVar7 = uVar7 + 1;
uVar8 = uVar1;
} while (uVar7 < uVar2);
param_1[2] = param_1[2] - uVar6;
}
uVar4 = __bf_round(param_1,param_2,param_3,uVar2,0);
return uVar4;
}
lVar5 = lVar5 + 0x40;
uVar2 = uVar2 - 1;
} while (uVar2 != 0);
}
param_1[2] = -0x8000000000000000;
if (uVar8 != 0) {
lVar3 = (*(code *)((int8 *)*param_1)[1])(*(int8 *)*param_1,param_1[4],0);
param_1[4] = lVar3;
param_1[3] = 0;
}
return 0;
}
|
|
60,640
|
bf_normalize_and_round
|
bluesky950520[P]quickjs/libbf.c
|
int bf_normalize_and_round(bf_t *r, limb_t prec1, bf_flags_t flags)
{
limb_t l, v, a;
int shift, ret;
slimb_t i;
// bf_print_str("bf_renorm", r);
l = r->len;
while (l > 0 && r->tab[l - 1] == 0)
l--;
if (l == 0) {
/* zero */
r->expn = BF_EXP_ZERO;
bf_resize(r, 0); /* cannot fail */
ret = 0;
} else {
r->expn -= (r->len - l) * LIMB_BITS;
/* shift to have the MSB set to '1' */
v = r->tab[l - 1];
shift = clz(v);
if (shift != 0) {
v = 0;
for(i = 0; i < l; i++) {
a = r->tab[i];
r->tab[i] = (a << shift) | (v >> (LIMB_BITS - shift));
v = a;
}
r->expn -= shift;
}
ret = __bf_round(r, prec1, flags, l, 0);
}
// bf_print_str("r_final", r);
return ret;
}
|
O2
|
c
|
bf_normalize_and_round:
pushq %r15
pushq %r14
pushq %rbx
movq 0x18(%rdi), %rax
xorl %ecx, %ecx
movq %rax, %r8
subq $0x1, %r8
jb 0x6f72f
movq 0x20(%rdi), %r10
cmpq $0x0, (%r10,%r8,8)
jne 0x6f74c
addq $0x40, %rcx
movq %r8, %rax
jmp 0x6f715
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x10(%rdi)
xorl %esi, %esi
callq 0x6f50f
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
subq %rcx, 0x10(%rdi)
movq (%r10,%r8,8), %rcx
testq %rcx, %rcx
je 0x6f763
bsrq %rcx, %r8
xorq $0x3f, %r8
jmp 0x6f767
pushq $0x40
popq %r8
testq %r8, %r8
je 0x6f7a3
pushq $0x40
popq %r9
subq %r8, %r9
xorl %r11d, %r11d
xorl %ebx, %ebx
cmpq %rbx, %rax
je 0x6f79f
movq (%r10,%rbx,8), %r14
movq %r14, %r15
movl %r8d, %ecx
shlq %cl, %r15
movl %r9d, %ecx
shrq %cl, %r11
orq %r15, %r11
movq %r11, (%r10,%rbx,8)
incq %rbx
movq %r14, %r11
jmp 0x6f778
subq %r8, 0x10(%rdi)
movq %rax, %rcx
xorl %r8d, %r8d
popq %rbx
popq %r14
popq %r15
jmp 0x6f7b0
|
bf_normalize_and_round:
push r15
push r14
push rbx
mov rax, [rdi+18h]
xor ecx, ecx
mov r8, rax
loc_6F715:
sub r8, 1
jb short loc_6F72F
mov r10, [rdi+20h]
cmp qword ptr [r10+r8*8], 0
jnz short loc_6F74C
add rcx, 40h ; '@'
mov rax, r8
jmp short loc_6F715
loc_6F72F:
mov rax, 8000000000000000h
mov [rdi+10h], rax
xor esi, esi
call bf_resize
xor eax, eax
pop rbx
pop r14
pop r15
retn
loc_6F74C:
sub [rdi+10h], rcx
mov rcx, [r10+r8*8]
test rcx, rcx
jz short loc_6F763
bsr r8, rcx
xor r8, 3Fh
jmp short loc_6F767
loc_6F763:
push 40h ; '@'
pop r8
loc_6F767:
test r8, r8
jz short loc_6F7A3
push 40h ; '@'
pop r9
sub r9, r8
xor r11d, r11d
xor ebx, ebx
loc_6F778:
cmp rax, rbx
jz short loc_6F79F
mov r14, [r10+rbx*8]
mov r15, r14
mov ecx, r8d
shl r15, cl
mov ecx, r9d
shr r11, cl
or r11, r15
mov [r10+rbx*8], r11
inc rbx
mov r11, r14
jmp short loc_6F778
loc_6F79F:
sub [rdi+10h], r8
loc_6F7A3:
mov rcx, rax
xor r8d, r8d
pop rbx
pop r14
pop r15
jmp short $+2
|
long long bf_normalize_and_round(_QWORD *a1, long long a2, long long a3)
{
long long v3; // rax
long long v4; // rcx
long long i; // r8
long long v7; // r10
unsigned long long v9; // rcx
unsigned long long v10; // r8
unsigned long long v11; // r8
unsigned long long v12; // r11
long long j; // rbx
unsigned long long v14; // r14
v3 = a1[3];
v4 = 0LL;
for ( i = v3; ; v3 = i )
{
if ( i-- == 0 )
{
a1[2] = 0x8000000000000000LL;
bf_resize((long long)a1, 0LL);
return 0LL;
}
v7 = a1[4];
if ( *(_QWORD *)(v7 + 8 * i) )
break;
v4 += 64LL;
}
a1[2] -= v4;
v9 = *(_QWORD *)(v7 + 8 * i);
if ( v9 )
{
_BitScanReverse64(&v10, v9);
v11 = v10 ^ 0x3F;
}
else
{
v11 = 64LL;
}
if ( v11 )
{
v12 = 0LL;
for ( j = 0LL; v3 != j; ++j )
{
v14 = *(_QWORD *)(v7 + 8 * j);
*(_QWORD *)(v7 + 8 * j) = (v14 << v11) | (v12 >> (64 - (unsigned __int8)v11));
v12 = v14;
}
a1[2] -= v11;
}
return _bf_round(a1, a2, a3, v3, 0LL);
}
|
bf_normalize_and_round:
PUSH R15
PUSH R14
PUSH RBX
MOV RAX,qword ptr [RDI + 0x18]
XOR ECX,ECX
MOV R8,RAX
LAB_0016f715:
SUB R8,0x1
JC 0x0016f72f
MOV R10,qword ptr [RDI + 0x20]
CMP qword ptr [R10 + R8*0x8],0x0
JNZ 0x0016f74c
ADD RCX,0x40
MOV RAX,R8
JMP 0x0016f715
LAB_0016f72f:
MOV RAX,-0x8000000000000000
MOV qword ptr [RDI + 0x10],RAX
XOR ESI,ESI
CALL 0x0016f50f
XOR EAX,EAX
POP RBX
POP R14
POP R15
RET
LAB_0016f74c:
SUB qword ptr [RDI + 0x10],RCX
MOV RCX,qword ptr [R10 + R8*0x8]
TEST RCX,RCX
JZ 0x0016f763
BSR R8,RCX
XOR R8,0x3f
JMP 0x0016f767
LAB_0016f763:
PUSH 0x40
POP R8
LAB_0016f767:
TEST R8,R8
JZ 0x0016f7a3
PUSH 0x40
POP R9
SUB R9,R8
XOR R11D,R11D
XOR EBX,EBX
LAB_0016f778:
CMP RAX,RBX
JZ 0x0016f79f
MOV R14,qword ptr [R10 + RBX*0x8]
MOV R15,R14
MOV ECX,R8D
SHL R15,CL
MOV ECX,R9D
SHR R11,CL
OR R11,R15
MOV qword ptr [R10 + RBX*0x8],R11
INC RBX
MOV R11,R14
JMP 0x0016f778
LAB_0016f79f:
SUB qword ptr [RDI + 0x10],R8
LAB_0016f7a3:
MOV RCX,RAX
XOR R8D,R8D
POP RBX
POP R14
POP R15
JMP 0x0016f7b0
|
int8 bf_normalize_and_round(long param_1)
{
long lVar1;
ulong uVar2;
int8 uVar3;
long lVar4;
long lVar5;
ulong uVar7;
ulong uVar8;
long lVar6;
lVar4 = 0;
lVar6 = *(long *)(param_1 + 0x18);
while( true ) {
lVar5 = lVar6 + -1;
if (lVar6 == 0) {
*(int8 *)(param_1 + 0x10) = 0x8000000000000000;
bf_resize(param_1,0);
return 0;
}
lVar1 = *(long *)(param_1 + 0x20);
if (*(long *)(lVar1 + lVar5 * 8) != 0) break;
lVar4 = lVar4 + 0x40;
lVar6 = lVar5;
}
*(long *)(param_1 + 0x10) = *(long *)(param_1 + 0x10) - lVar4;
uVar8 = *(ulong *)(lVar1 + lVar5 * 8);
if (uVar8 == 0) {
uVar7 = 0x40;
}
else {
uVar7 = 0x3f;
if (uVar8 != 0) {
for (; uVar8 >> uVar7 == 0; uVar7 = uVar7 - 1) {
}
}
uVar7 = uVar7 ^ 0x3f;
}
if (uVar7 != 0) {
uVar8 = 0;
for (lVar4 = 0; lVar6 != lVar4; lVar4 = lVar4 + 1) {
uVar2 = *(ulong *)(lVar1 + lVar4 * 8);
*(ulong *)(lVar1 + lVar4 * 8) =
uVar8 >> (0x40 - (byte)uVar7 & 0x3f) | uVar2 << ((byte)uVar7 & 0x3f);
uVar8 = uVar2;
}
*(long *)(param_1 + 0x10) = *(long *)(param_1 + 0x10) - uVar7;
}
uVar3 = __bf_round();
return uVar3;
}
|
|
60,641
|
testing::InitGoogleTest()
|
giladroyz[P]FindPeaks/build_O3/_deps/googletest-src/googletest/src/gtest.cc
|
void InitGoogleTest() {
// Since Arduino doesn't have a command line, fake out the argc/argv arguments
int argc = 1;
const auto arg0 = "dummy";
char* argv0 = const_cast<char*>(arg0);
char** argv = &argv0;
#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(&argc, argv);
#else // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
internal::InitGoogleTestImpl(&argc, argv);
#endif // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
}
|
O3
|
cpp
|
testing::InitGoogleTest():
subq $0x18, %rsp
leaq 0xc(%rsp), %rdi
movl $0x1, (%rdi)
leaq 0x148df(%rip), %rax # 0x43b3e
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
callq 0x35550
addq $0x18, %rsp
retq
|
_ZN7testing14InitGoogleTestEv:
sub rsp, 18h
lea rdi, [rsp+18h+var_C]; this
mov dword ptr [rdi], 1
lea rax, aDummy; "dummy"
lea rsi, [rsp+18h+var_8]; void *
mov [rsi], rax
call _ZN7testing8internal18InitGoogleTestImplIcEEvPiPPT_; testing::internal::InitGoogleTestImpl<char>(int *,char **)
add rsp, 18h
retn
|
long long testing::InitGoogleTest(testing *this)
{
void *v2; // [rsp+0h] [rbp-18h]
int v3; // [rsp+8h] [rbp-10h]
_BYTE v4[4]; // [rsp+Ch] [rbp-Ch] BYREF
_BYTE v5[8]; // [rsp+10h] [rbp-8h] BYREF
return testing::internal::InitGoogleTestImpl<char>((testing::UnitTest *)v4, v5, v2, v3, (long long)"dummy");
}
|
InitGoogleTest:
SUB RSP,0x18
LEA RDI,[RSP + 0xc]
MOV dword ptr [RDI],0x1
LEA RAX,[0x143b3e]
LEA RSI,[RSP + 0x10]
MOV qword ptr [RSI],RAX
CALL 0x00135550
ADD RSP,0x18
RET
|
/* testing::InitGoogleTest() */
void testing::InitGoogleTest(void)
{
int local_c;
char *local_8;
local_c = 1;
local_8 = "dummy";
internal::InitGoogleTestImpl<char>(&local_c,&local_8);
return;
}
|
|
60,642
|
FTB_WORD_cmp
|
eloqsql/storage/myisam/ft_boolean_search.c
|
static int FTB_WORD_cmp(my_off_t *v, FTB_WORD *a, FTB_WORD *b)
{
int i;
/* if a==curdoc, take it as a < b */
if (v && a->docid[0] == *v)
return -1;
/* ORDER BY docid, ndepth DESC */
i=CMP_NUM(a->docid[0], b->docid[0]);
if (!i)
i=CMP_NUM(b->ndepth,a->ndepth);
return i;
}
|
O3
|
c
|
FTB_WORD_cmp:
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rsi), %rcx
testq %rdi, %rdi
je 0x5aa81
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpq (%rdi), %rcx
je 0x5aaa4
xorl %eax, %eax
cmpq 0x10(%rdx), %rcx
setne %al
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
cmovbl %ecx, %eax
testl %eax, %eax
jne 0x5aaa4
movl 0x44(%rdx), %edx
xorl %eax, %eax
cmpl 0x44(%rsi), %edx
setne %al
cmovbl %ecx, %eax
popq %rbp
retq
|
FTB_WORD_cmp:
push rbp
mov rbp, rsp
mov rcx, [rsi+10h]
test rdi, rdi
jz short loc_5AA81
mov eax, 0FFFFFFFFh
cmp rcx, [rdi]
jz short loc_5AAA4
loc_5AA81:
xor eax, eax
cmp rcx, [rdx+10h]
setnz al
mov ecx, 0FFFFFFFFh
cmovb eax, ecx
test eax, eax
jnz short loc_5AAA4
mov edx, [rdx+44h]
xor eax, eax
cmp edx, [rsi+44h]
setnz al
cmovb eax, ecx
loc_5AAA4:
pop rbp
retn
|
long long FTB_WORD_cmp(_QWORD *a1, long long a2, long long a3)
{
unsigned long long v3; // rcx
long long result; // rax
unsigned int v5; // edx
v3 = *(_QWORD *)(a2 + 16);
if ( !a1 || (result = 0xFFFFFFFFLL, v3 != *a1) )
{
result = v3 != *(_QWORD *)(a3 + 16);
if ( v3 < *(_QWORD *)(a3 + 16) )
result = 0xFFFFFFFFLL;
if ( !(_DWORD)result )
{
v5 = *(_DWORD *)(a3 + 68);
result = v5 != *(_DWORD *)(a2 + 68);
if ( v5 < *(_DWORD *)(a2 + 68) )
return 0xFFFFFFFFLL;
}
}
return result;
}
|
FTB_WORD_cmp:
PUSH RBP
MOV RBP,RSP
MOV RCX,qword ptr [RSI + 0x10]
TEST RDI,RDI
JZ 0x0015aa81
MOV EAX,0xffffffff
CMP RCX,qword ptr [RDI]
JZ 0x0015aaa4
LAB_0015aa81:
XOR EAX,EAX
CMP RCX,qword ptr [RDX + 0x10]
SETNZ AL
MOV ECX,0xffffffff
CMOVC EAX,ECX
TEST EAX,EAX
JNZ 0x0015aaa4
MOV EDX,dword ptr [RDX + 0x44]
XOR EAX,EAX
CMP EDX,dword ptr [RSI + 0x44]
SETNZ AL
CMOVC EAX,ECX
LAB_0015aaa4:
POP RBP
RET
|
uint FTB_WORD_cmp(ulong *param_1,long param_2,long param_3)
{
ulong uVar1;
uint uVar2;
uVar1 = *(ulong *)(param_2 + 0x10);
if ((param_1 == (ulong *)0x0) || (uVar2 = 0xffffffff, uVar1 != *param_1)) {
uVar2 = (uint)(uVar1 != *(ulong *)(param_3 + 0x10));
if (uVar1 < *(ulong *)(param_3 + 0x10)) {
uVar2 = 0xffffffff;
}
if ((uVar2 == 0) &&
(uVar2 = (uint)(*(uint *)(param_3 + 0x44) != *(uint *)(param_2 + 0x44)),
*(uint *)(param_3 + 0x44) < *(uint *)(param_2 + 0x44))) {
uVar2 = 0xffffffff;
}
}
return uVar2;
}
|
|
60,643
|
my_casedn_utf16
|
eloqsql/strings/ctype-ucs2.c
|
static size_t
my_casedn_utf16(CHARSET_INFO *cs, const char *src, size_t srclen,
char *dst, size_t dstlen)
{
my_wc_t wc;
my_charset_conv_mb_wc mb_wc= cs->cset->mb_wc;
my_charset_conv_wc_mb wc_mb= cs->cset->wc_mb;
int res;
const char *srcend= src + srclen;
char *dstend= dst + dstlen;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
DBUG_ASSERT(srclen <= dstlen);
while ((src < srcend) &&
(res= mb_wc(cs, &wc, (uchar *) src, (uchar *) srcend)) > 0)
{
my_tolower_utf16(uni_plane, &wc);
if (res != wc_mb(cs, wc, (uchar *) dst, (uchar *) dstend))
break;
src+= res;
dst+= res;
}
return srclen;
}
|
O0
|
c
|
my_casedn_utf16:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0xb8(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0xb8(%rax), %rax
movq 0x30(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x60(%rbp)
jmp 0x8fde8
jmp 0x8fdea
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x50(%rbp), %rcx
movb %al, -0x61(%rbp)
jae 0x8fe1b
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x50(%rbp), %rcx
leaq -0x30(%rbp), %rsi
callq *%rax
movl %eax, -0x44(%rbp)
cmpl $0x0, %eax
setg %al
movb %al, -0x61(%rbp)
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x8fe24
jmp 0x8fe7f
movq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x932d0
movl -0x44(%rbp), %eax
movl %eax, -0x68(%rbp)
movq -0x40(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x58(%rbp), %rcx
callq *%rax
movl %eax, %ecx
movl -0x68(%rbp), %eax
cmpl %ecx, %eax
je 0x8fe58
jmp 0x8fe7f
movl -0x44(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x44(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0x8fdea
movq -0x18(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
|
my_casedn_utf16:
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_8]
mov rax, [rax+0B8h]
mov rax, [rax+28h]
mov [rbp+var_38], rax
mov rax, [rbp+var_8]
mov rax, [rax+0B8h]
mov rax, [rax+30h]
mov [rbp+var_40], rax
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_50], rax
mov rax, [rbp+var_20]
add rax, [rbp+var_28]
mov [rbp+var_58], rax
mov rax, [rbp+var_8]
mov rax, [rax+78h]
mov [rbp+var_60], rax
jmp short $+2
loc_8FDE8:
jmp short $+2
loc_8FDEA:
mov rcx, [rbp+var_10]
xor eax, eax
cmp rcx, [rbp+var_50]
mov [rbp+var_61], al
jnb short loc_8FE1B
mov rax, [rbp+var_38]
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_50]
lea rsi, [rbp+var_30]
call rax
mov [rbp+var_44], eax
cmp eax, 0
setnle al
mov [rbp+var_61], al
loc_8FE1B:
mov al, [rbp+var_61]
test al, 1
jnz short loc_8FE24
jmp short loc_8FE7F
loc_8FE24:
mov rdi, [rbp+var_60]
lea rsi, [rbp+var_30]
call my_tolower_utf16
mov eax, [rbp+var_44]
mov [rbp+var_68], eax
mov rax, [rbp+var_40]
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_58]
call rax
mov ecx, eax
mov eax, [rbp+var_68]
cmp eax, ecx
jz short loc_8FE58
jmp short loc_8FE7F
loc_8FE58:
mov ecx, [rbp+var_44]
mov rax, [rbp+var_10]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_10], rax
mov ecx, [rbp+var_44]
mov rax, [rbp+var_20]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_20], rax
jmp loc_8FDEA
loc_8FE7F:
mov rax, [rbp+var_18]
add rsp, 70h
pop rbp
retn
|
long long my_casedn_utf16(long long a1, unsigned long long a2, long long a3, long long a4, long long a5)
{
bool v6; // [rsp+Fh] [rbp-61h]
long long v7; // [rsp+10h] [rbp-60h]
long long v8; // [rsp+18h] [rbp-58h]
unsigned long long v9; // [rsp+20h] [rbp-50h]
int v10; // [rsp+2Ch] [rbp-44h]
unsigned int ( *v11)(long long, _QWORD, long long, long long); // [rsp+30h] [rbp-40h]
long long ( *v12)(long long, _QWORD *, unsigned long long, unsigned long long); // [rsp+38h] [rbp-38h]
_QWORD v13[2]; // [rsp+40h] [rbp-30h] BYREF
long long v14; // [rsp+50h] [rbp-20h]
long long v15; // [rsp+58h] [rbp-18h]
unsigned long long v16; // [rsp+60h] [rbp-10h]
long long v17; // [rsp+68h] [rbp-8h]
v17 = a1;
v16 = a2;
v15 = a3;
v14 = a4;
v13[1] = a5;
v12 = *(long long ( **)(long long, _QWORD *, unsigned long long, unsigned long long))(*(_QWORD *)(a1 + 184) + 40LL);
v11 = *(unsigned int ( **)(long long, _QWORD, long long, long long))(*(_QWORD *)(a1 + 184) + 48LL);
v9 = a3 + a2;
v8 = a5 + a4;
v7 = *(_QWORD *)(a1 + 120);
while ( 1 )
{
v6 = 0;
if ( v16 < v9 )
{
v10 = v12(v17, v13, v16, v9);
v6 = v10 > 0;
}
if ( !v6 )
break;
my_tolower_utf16(v7, v13);
if ( v10 != v11(v17, v13[0], v14, v8) )
break;
v16 += v10;
v14 += v10;
}
return v15;
}
|
my_casedn_utf16:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RAX + 0x30]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x78]
MOV qword ptr [RBP + -0x60],RAX
JMP 0x0018fde8
LAB_0018fde8:
JMP 0x0018fdea
LAB_0018fdea:
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x50]
MOV byte ptr [RBP + -0x61],AL
JNC 0x0018fe1b
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x50]
LEA RSI,[RBP + -0x30]
CALL RAX
MOV dword ptr [RBP + -0x44],EAX
CMP EAX,0x0
SETG AL
MOV byte ptr [RBP + -0x61],AL
LAB_0018fe1b:
MOV AL,byte ptr [RBP + -0x61]
TEST AL,0x1
JNZ 0x0018fe24
JMP 0x0018fe7f
LAB_0018fe24:
MOV RDI,qword ptr [RBP + -0x60]
LEA RSI,[RBP + -0x30]
CALL 0x001932d0
MOV EAX,dword ptr [RBP + -0x44]
MOV dword ptr [RBP + -0x68],EAX
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x58]
CALL RAX
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x68]
CMP EAX,ECX
JZ 0x0018fe58
JMP 0x0018fe7f
LAB_0018fe58:
MOV ECX,dword ptr [RBP + -0x44]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
MOV ECX,dword ptr [RBP + -0x44]
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0018fdea
LAB_0018fe7f:
MOV RAX,qword ptr [RBP + -0x18]
ADD RSP,0x70
POP RBP
RET
|
long my_casedn_utf16(long param_1,ulong param_2,long param_3,long param_4,long param_5)
{
code *pcVar1;
code *pcVar2;
int8 uVar3;
bool bVar4;
int iVar5;
int local_4c;
int8 local_38;
long local_30;
long local_28;
long local_20;
ulong local_18;
long local_10;
pcVar1 = *(code **)(*(long *)(param_1 + 0xb8) + 0x28);
pcVar2 = *(code **)(*(long *)(param_1 + 0xb8) + 0x30);
uVar3 = *(int8 *)(param_1 + 0x78);
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
while( true ) {
bVar4 = false;
if (local_18 < param_2 + param_3) {
local_4c = (*pcVar1)(local_10,&local_38,local_18,param_2 + param_3);
bVar4 = 0 < local_4c;
}
if (!bVar4) break;
my_tolower_utf16(uVar3,&local_38);
iVar5 = (*pcVar2)(local_10,local_38,local_28,param_4 + param_5);
if (local_4c != iVar5) {
return local_20;
}
local_18 = local_18 + (long)local_4c;
local_28 = local_28 + local_4c;
}
return local_20;
}
|
|
60,644
|
write_tail
|
eloqsql/storage/maria/ma_blockrec.c
|
static my_bool write_tail(MARIA_HA *info,
MARIA_BITMAP_BLOCK *block,
uchar *row_part, uint org_length)
{
MARIA_SHARE *share= info->s;
MARIA_PINNED_PAGE page_link;
uint block_size= share->block_size, empty_space, length= org_length;
struct st_row_pos_info row_pos;
my_off_t position;
my_bool res, block_is_read;
DBUG_ENTER("write_tail");
DBUG_PRINT("enter", ("page: %lu length: %u",
(ulong) block->page, length));
info->keyread_buff_used= 1;
/*
Don't allocate smaller block than MIN_TAIL_SIZE (we want to give rows
some place to grow in the future)
*/
if (length < MIN_TAIL_SIZE)
length= MIN_TAIL_SIZE;
if (block->page_count == TAIL_PAGE_COUNT_MARKER)
{
/*
Create new tail
page will be pinned & locked by get_head_or_tail_page
*/
if (get_head_or_tail_page(info, block, info->keyread_buff, length,
TAIL_PAGE, PAGECACHE_LOCK_WRITE,
&row_pos))
DBUG_RETURN(1);
}
else
{
/* Write tail on predefined row position */
if (get_rowpos_in_head_or_tail_page(info, block, info->keyread_buff,
length, TAIL_PAGE,
PAGECACHE_LOCK_WRITE,
block->page_count & ~TAIL_BIT,
&row_pos))
DBUG_RETURN(1);
}
DBUG_PRINT("info", ("tailid: %lu (%lu:%u)",
(ulong) ma_recordpos(block->page, row_pos.rownr),
(ulong) block->page, row_pos.rownr));
block_is_read= block->org_bitmap_value != 0;
memcpy(row_pos.data, row_part, org_length);
if (share->now_transactional)
{
/* Log changes in tail block */
uchar log_data[FILEID_STORE_SIZE + PAGE_STORE_SIZE + DIRPOS_STORE_SIZE];
LEX_CUSTRING log_array[TRANSLOG_INTERNAL_PARTS + 2];
LSN lsn;
/*
Log REDO changes of tail page
Note that we have to log length, not org_length, to be sure that
REDO, which doesn't use write_tail, also creates a block of at least
MIN_TAIL_SIZE
*/
page_store(log_data + FILEID_STORE_SIZE, block->page);
dirpos_store(log_data + FILEID_STORE_SIZE + PAGE_STORE_SIZE,
row_pos.rownr);
log_array[TRANSLOG_INTERNAL_PARTS + 0].str= log_data;
log_array[TRANSLOG_INTERNAL_PARTS + 0].length= sizeof(log_data);
log_array[TRANSLOG_INTERNAL_PARTS + 1].str= row_pos.data;
log_array[TRANSLOG_INTERNAL_PARTS + 1].length= length;
if (translog_write_record(&lsn,
(block_is_read ? LOGREC_REDO_INSERT_ROW_TAIL :
LOGREC_REDO_NEW_ROW_TAIL),
info->trn, info,
(translog_size_t) (sizeof(log_data) + length),
TRANSLOG_INTERNAL_PARTS + 2, log_array,
log_data, NULL))
DBUG_RETURN(1);
}
int2store(row_pos.dir + 2, length);
empty_space= row_pos.empty_space - length;
int2store(row_pos.buff + EMPTY_SPACE_OFFSET, empty_space);
block->page_count= row_pos.rownr + TAIL_BIT;
/*
If there is less directory entries free than number of possible tails
we can write for a row, we mark the page full to ensure that we don't
during _ma_bitmap_find_place() allocate more entries on the tail page
than it can hold
*/
block->empty_space= (enough_free_entries(row_pos.buff, share->block_size,
1 + share->base.blobs) ?
empty_space : 0);
/* Keep BLOCKUSED_USE_ORG_BITMAP */
block->used|= BLOCKUSED_USED | BLOCKUSED_TAIL;
if (block_is_read)
{
/* Current page link is last element in pinned_pages */
MARIA_PINNED_PAGE *page_link;
page_link= dynamic_element(&info->pinned_pages,
info->pinned_pages.elements-1,
MARIA_PINNED_PAGE*);
pagecache_unlock_by_link(share->pagecache, page_link->link,
PAGECACHE_LOCK_WRITE_TO_READ,
PAGECACHE_PIN_LEFT_PINNED, LSN_IMPOSSIBLE,
LSN_IMPOSSIBLE, 1, FALSE);
DBUG_ASSERT(page_link->changed);
page_link->unlock= PAGECACHE_LOCK_READ_UNLOCK;
res= 0;
}
else
{
if (!(res= pagecache_write(share->pagecache,
&info->dfile, block->page, 0,
row_pos.buff,share->page_type,
PAGECACHE_LOCK_READ,
PAGECACHE_PIN,
PAGECACHE_WRITE_DELAY, &page_link.link,
LSN_IMPOSSIBLE)))
{
DBUG_ASSERT(page_link.link);
page_link.unlock= PAGECACHE_LOCK_READ_UNLOCK;
page_link.changed= 1;
push_dynamic(&info->pinned_pages, (void*) &page_link);
}
/* Increase data file size, if extended */
position= (my_off_t) block->page * block_size;
if (share->state.state.data_file_length <= position)
{
/*
We are modifying a state member before writing the UNDO; this is a WAL
violation. But for data_file_length this is ok, as long as we change
data_file_length after writing any log record (FILE_ID/REDO/UNDO) (see
collect_tables()).
*/
_ma_set_share_data_file_length(share, position + block_size);
}
}
DBUG_RETURN(res);
}
|
O3
|
c
|
write_tail:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %ecx, %ebx
movq %rdx, -0x60(%rbp)
movq %rsi, %r14
movq %rdi, %r15
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq (%rdi), %rax
movq %rax, -0x50(%rbp)
movl 0x7bc(%rax), %eax
movq %rax, -0x58(%rbp)
cmpl $0x21, %ecx
movl $0x20, %r12d
cmovael %ecx, %r12d
movb $0x1, 0x685(%rdi)
movl 0x8(%rsi), %r9d
movq 0x380(%rdi), %rdx
cmpl $0xffff, %r9d # imm = 0xFFFF
jne 0x632e6
leaq -0x88(%rbp), %r9
movq %r15, %rdi
movq %r14, %rsi
movl %r12d, %ecx
movl $0x2, %r8d
callq 0x62e6c
jmp 0x63311
andl $0xffff7fff, %r9d # imm = 0xFFFF7FFF
subq $0x8, %rsp
leaq -0x88(%rbp), %rax
movq %r15, %rdi
movq %r14, %rsi
movl %r12d, %ecx
movl $0x2, %r8d
pushq %rax
callq 0x610c5
addq $0x10, %rsp
movb $0x1, %r13b
testb %al, %al
je 0x63340
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x63566
movl %r13d, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, -0x48(%rbp)
movb 0x15(%r14), %r14b
movq -0x80(%rbp), %r13
movl %ebx, %edx
movq %r13, %rdi
movq -0x60(%rbp), %rsi
callq 0x29080
movq -0x50(%rbp), %rax
cmpb $0x0, 0x7e7(%rax)
movb %r14b, -0x39(%rbp)
je 0x633ef
xorl %ecx, %ecx
testb %r14b, %r14b
sete %cl
movq -0x48(%rbp), %r14
movq (%r14), %rdx
leaq -0x38(%rbp), %rax
movl %edx, 0x2(%rax)
shrq $0x20, %rdx
movb %dl, 0x6(%rax)
movl -0x6c(%rbp), %ebx
movb %bl, 0x7(%rax)
leaq -0xd0(%rbp), %r10
movq %rax, 0x20(%r10)
movq $0x8, 0x28(%r10)
movq %r13, 0x30(%r10)
movl %r12d, %edx
movq %rdx, 0x38(%r10)
leal 0x2(,%rcx,2), %esi
movq 0x8(%r15), %rdx
leal 0x8(%r12), %r8d
subq $0x8, %rsp
leaq -0x90(%rbp), %rdi
movq %r15, %rcx
movl $0x4, %r9d
pushq $0x0
pushq %rax
pushq %r10
callq 0x2a8ac
addq $0x20, %rsp
movb $0x1, %r13b
testb %al, %al
jne 0x63318
jmp 0x633f6
movl -0x6c(%rbp), %ebx
movq -0x48(%rbp), %r14
movq -0x78(%rbp), %rax
movw %r12w, 0x2(%rax)
movl -0x68(%rbp), %eax
subl %r12d, %eax
movq -0x88(%rbp), %r8
movw %ax, 0xa(%r8)
addl $0x8000, %ebx # imm = 0x8000
movl %ebx, 0x8(%r14)
movq -0x50(%rbp), %r12
movl 0x3f0(%r12), %ecx
movzbl 0x8(%r8), %edx
addl %edx, %ecx
incl %ecx
cmpl $0x100, %ecx # imm = 0x100
jae 0x6343e
movb -0x39(%rbp), %r9b
jmp 0x63479
movb 0x9(%r8), %dl
cmpb $-0x1, %dl
movb -0x39(%rbp), %r9b
je 0x63477
movl 0x7bc(%r12), %esi
addl $0xffffff01, %ecx # imm = 0xFFFFFF01
addq %r8, %rsi
addq $-0x5, %rsi
decl %ecx
je 0x63479
movzbl %dl, %edx
shll $0x2, %edx
movq %rsi, %rdi
subq %rdx, %rdi
movb (%rdi), %dl
cmpb $-0x1, %dl
jne 0x63460
xorl %eax, %eax
orb $0x5, 0x14(%r14)
movl %eax, 0xc(%r14)
testb %r9b, %r9b
je 0x634d2
movq 0x2e8(%r15), %rbx
movl 0x2f0(%r15), %eax
decl %eax
leaq (%rax,%rax,2), %r14
movq 0x600(%r12), %rdi
movq (%rbx,%r14,8), %rsi
xorl %r13d, %r13d
movl $0x7, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq $0x0
pushq $0x1
callq 0x3232d
addq $0x10, %rsp
movl $0x5, 0x8(%rbx,%r14,8)
jmp 0x63318
movq 0x600(%r12), %rdi
leaq 0x470(%r15), %rsi
movq (%r14), %rdx
movl 0x7d4(%r12), %r9d
movl 0x80(%rdi), %eax
subq $0x8, %rsp
xorl %r10d, %r10d
leaq -0xd0(%rbp), %r11
xorl %ecx, %ecx
pushq %rax
pushq %r10
pushq $0x0
pushq %r11
pushq %r10
pushq $0x2
pushq $0x3
callq 0x33a76
addq $0x40, %rsp
movl %eax, %r13d
testb %al, %al
jne 0x63540
leaq -0xd0(%rbp), %rsi
movl $0x5, 0x8(%rsi)
movb $0x1, 0x10(%rsi)
addq $0x2e8, %r15 # imm = 0x2E8
movq %r15, %rdi
callq 0x91b9e
movq (%r14), %rsi
movq -0x58(%rbp), %rax
imulq %rax, %rsi
cmpq %rsi, 0x40(%r12)
ja 0x63318
addq %rax, %rsi
movq %r12, %rdi
callq 0x38cfc
jmp 0x63318
callq 0x29270
|
write_tail:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0A8h
mov ebx, ecx
mov [rbp+var_60], rdx
mov r14, rsi
mov r15, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov rax, [rdi]
mov [rbp+var_50], rax
mov eax, [rax+7BCh]
mov [rbp+var_58], rax
cmp ecx, 21h ; '!'
mov r12d, 20h ; ' '
cmovnb r12d, ecx
mov byte ptr [rdi+685h], 1
mov r9d, [rsi+8]
mov rdx, [rdi+380h]
cmp r9d, 0FFFFh
jnz short loc_632E6
lea r9, [rbp+var_88]
mov rdi, r15
mov rsi, r14
mov ecx, r12d
mov r8d, 2
call get_head_or_tail_page
jmp short loc_63311
loc_632E6:
and r9d, 0FFFF7FFFh
sub rsp, 8
lea rax, [rbp+var_88]
mov rdi, r15
mov rsi, r14
mov ecx, r12d
mov r8d, 2
push rax
call get_rowpos_in_head_or_tail_page
add rsp, 10h
loc_63311:
mov r13b, 1
test al, al
jz short loc_63340
loc_63318:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz loc_63566
mov eax, r13d
add rsp, 0A8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_63340:
mov [rbp+var_48], r14
mov r14b, [r14+15h]
mov r13, [rbp+var_80]
mov edx, ebx
mov rdi, r13
mov rsi, [rbp+var_60]
call _memcpy
mov rax, [rbp+var_50]
cmp byte ptr [rax+7E7h], 0
mov [rbp+var_39], r14b
jz loc_633EF
xor ecx, ecx
test r14b, r14b
setz cl
mov r14, [rbp+var_48]
mov rdx, [r14]
lea rax, [rbp+var_38]
mov [rax+2], edx
shr rdx, 20h
mov [rax+6], dl
mov ebx, [rbp+var_6C]
mov [rax+7], bl
lea r10, [rbp+var_D0]
mov [r10+20h], rax
mov qword ptr [r10+28h], 8
mov [r10+30h], r13
mov edx, r12d
mov [r10+38h], rdx
lea esi, ds:2[rcx*2]
mov rdx, [r15+8]
lea r8d, [r12+8]
sub rsp, 8
lea rdi, [rbp+var_90]
mov rcx, r15
mov r9d, 4
push 0
push rax
push r10
call translog_write_record
add rsp, 20h
mov r13b, 1
test al, al
jnz loc_63318
jmp short loc_633F6
loc_633EF:
mov ebx, [rbp+var_6C]
mov r14, [rbp+var_48]
loc_633F6:
mov rax, [rbp+var_78]
mov [rax+2], r12w
mov eax, [rbp+var_68]
sub eax, r12d
mov r8, [rbp+var_88]
mov [r8+0Ah], ax
add ebx, 8000h
mov [r14+8], ebx
mov r12, [rbp+var_50]
mov ecx, [r12+3F0h]
movzx edx, byte ptr [r8+8]
add ecx, edx
inc ecx
cmp ecx, 100h
jnb short loc_6343E
mov r9b, [rbp+var_39]
jmp short loc_63479
loc_6343E:
mov dl, [r8+9]
cmp dl, 0FFh
mov r9b, [rbp+var_39]
jz short loc_63477
mov esi, [r12+7BCh]
add ecx, 0FFFFFF01h
add rsi, r8
add rsi, 0FFFFFFFFFFFFFFFBh
loc_63460:
dec ecx
jz short loc_63479
movzx edx, dl
shl edx, 2
mov rdi, rsi
sub rdi, rdx
mov dl, [rdi]
cmp dl, 0FFh
jnz short loc_63460
loc_63477:
xor eax, eax
loc_63479:
or byte ptr [r14+14h], 5
mov [r14+0Ch], eax
test r9b, r9b
jz short loc_634D2
mov rbx, [r15+2E8h]
mov eax, [r15+2F0h]
dec eax
lea r14, [rax+rax*2]
mov rdi, [r12+600h]
mov rsi, [rbx+r14*8]
xor r13d, r13d
mov edx, 7
xor ecx, ecx
xor r8d, r8d
xor r9d, r9d
push 0
push 1
call pagecache_unlock_by_link
add rsp, 10h
mov dword ptr [rbx+r14*8+8], 5
jmp loc_63318
loc_634D2:
mov rdi, [r12+600h]
lea rsi, [r15+470h]
mov rdx, [r14]
mov r9d, [r12+7D4h]
mov eax, [rdi+80h]
sub rsp, 8
xor r10d, r10d
lea r11, [rbp+var_D0]
xor ecx, ecx
push rax
push r10
push 0
push r11
push r10
push 2
push 3
call pagecache_write_part
add rsp, 40h
mov r13d, eax
test al, al
jnz short loc_63540
lea rsi, [rbp+var_D0]
mov dword ptr [rsi+8], 5
mov byte ptr [rsi+10h], 1
add r15, 2E8h
mov rdi, r15
call insert_dynamic
loc_63540:
mov rsi, [r14]
mov rax, [rbp+var_58]
imul rsi, rax
cmp [r12+40h], rsi
ja loc_63318
add rsi, rax
mov rdi, r12
call _ma_set_share_data_file_length
jmp loc_63318
loc_63566:
call ___stack_chk_fail
|
long long write_tail(long long a1, long long a2, long long a3, unsigned int a4)
{
long long v4; // r13
unsigned int v6; // r12d
int v7; // r9d
_BYTE *v8; // rdx
char head_or_tail_page; // al
char v11; // r14
bool v12; // zf
BOOL v13; // ecx
_QWORD *v14; // r14
long long v15; // rdx
int v16; // ebx
int v17; // eax
char *v18; // r8
long long v19; // r12
char v20; // r9
unsigned __int8 v21; // dl
int v22; // ecx
long long v23; // rbx
long long v24; // rax
long long v25; // r14
unsigned long long v26; // rsi
__int128 v27; // [rsp+0h] [rbp-D0h] BYREF
char v28; // [rsp+10h] [rbp-C0h]
__int16 *v29; // [rsp+20h] [rbp-B0h]
long long v30; // [rsp+28h] [rbp-A8h]
long long v31; // [rsp+30h] [rbp-A0h]
long long v32; // [rsp+38h] [rbp-98h]
char v33[8]; // [rsp+40h] [rbp-90h] BYREF
long long v34; // [rsp+48h] [rbp-88h] BYREF
long long v35; // [rsp+50h] [rbp-80h]
long long v36; // [rsp+58h] [rbp-78h]
int v37; // [rsp+64h] [rbp-6Ch]
int v38; // [rsp+68h] [rbp-68h]
long long v39; // [rsp+70h] [rbp-60h]
long long v40; // [rsp+78h] [rbp-58h]
long long v41; // [rsp+80h] [rbp-50h]
_QWORD *v42; // [rsp+88h] [rbp-48h]
char v43; // [rsp+97h] [rbp-39h]
__int16 v44; // [rsp+98h] [rbp-38h] BYREF
int v45; // [rsp+9Ah] [rbp-36h]
char v46; // [rsp+9Eh] [rbp-32h]
char v47; // [rsp+9Fh] [rbp-31h]
unsigned long long v48; // [rsp+A0h] [rbp-30h]
v39 = a3;
v48 = __readfsqword(0x28u);
v41 = *(_QWORD *)a1;
v40 = *(unsigned int *)(v41 + 1980);
v6 = 32;
if ( a4 >= 0x21 )
v6 = a4;
*(_BYTE *)(a1 + 1669) = 1;
v7 = *(_DWORD *)(a2 + 8);
v8 = *(_BYTE **)(a1 + 896);
if ( v7 == 0xFFFF )
head_or_tail_page = get_head_or_tail_page((long long *)a1, a2, v8, v6, 2, (long long)&v34);
else
head_or_tail_page = get_rowpos_in_head_or_tail_page((long long *)a1, a2, v8, v6, 2, v7 & 0xFFFF7FFF, (long long)&v34);
LOBYTE(v4) = 1;
if ( !head_or_tail_page )
{
v42 = (_QWORD *)a2;
v11 = *(_BYTE *)(a2 + 21);
v4 = v35;
memcpy(v35, v39, a4);
v12 = *(_BYTE *)(v41 + 2023) == 0;
v43 = v11;
if ( v12 )
{
v16 = v37;
v14 = v42;
}
else
{
v13 = v11 == 0;
v14 = v42;
v15 = *v42;
v45 = *v42;
v46 = BYTE4(v15);
v16 = v37;
v47 = v37;
v29 = &v44;
v30 = 8LL;
v31 = v4;
v32 = v6;
LOBYTE(v4) = 1;
if ( (unsigned __int8)translog_write_record(
(unsigned long long)v33,
(_WORD *)(unsigned int)(2 * v13 + 2),
*(_QWORD *)(a1 + 8),
(_QWORD *)a1,
v6 + 8,
4,
&v27,
&v44,
0LL) )
return (unsigned int)v4;
}
*(_WORD *)(v36 + 2) = v6;
v17 = v38 - v6;
v18 = (char *)v34;
*(_WORD *)(v34 + 10) = v38 - v6;
*((_DWORD *)v14 + 2) = v16 + 0x8000;
v19 = v41;
if ( (unsigned int)(unsigned __int8)v18[8] + *(_DWORD *)(v41 + 1008) + 1 >= 0x100 )
{
v21 = v18[9];
v20 = v43;
if ( v21 == 0xFF )
{
LABEL_18:
v17 = 0;
}
else
{
v22 = (unsigned __int8)v18[8] + *(_DWORD *)(v41 + 1008) - 254;
while ( --v22 )
{
v21 = v18[*(unsigned int *)(v41 + 1980) - 5 + -4 * v21];
if ( v21 == 0xFF )
goto LABEL_18;
}
}
}
else
{
v20 = v43;
}
*((_BYTE *)v14 + 20) |= 5u;
*((_DWORD *)v14 + 3) = v17;
if ( v20 )
{
v23 = *(_QWORD *)(a1 + 744);
v24 = (unsigned int)(*(_DWORD *)(a1 + 752) - 1);
v25 = 3 * v24;
LODWORD(v4) = 0;
pagecache_unlock_by_link(*(_QWORD *)(v19 + 1536), *(_QWORD *)(v23 + 24 * v24), 7, 0, 0LL, 0LL, 1);
*(_DWORD *)(v23 + 8 * v25 + 8) = 5;
}
else
{
LODWORD(v4) = pagecache_write_part(
*(__m128i **)(v19 + 1536),
(char *)(a1 + 1136),
*v14,
0,
v18,
*(_DWORD *)(v19 + 2004),
3u,
2u,
0,
&v27,
0LL,
0,
*(_DWORD *)(*(_QWORD *)(v19 + 1536) + 128LL));
if ( !(_BYTE)v4 )
{
DWORD2(v27) = 5;
v28 = 1;
insert_dynamic(a1 + 744, &v27);
}
v26 = v40 * *v14;
if ( *(_QWORD *)(v19 + 64) <= v26 )
ma_set_share_data_file_length(v19, v40 + v26);
}
}
return (unsigned int)v4;
}
|
write_tail:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xa8
MOV EBX,ECX
MOV qword ptr [RBP + -0x60],RDX
MOV R14,RSI
MOV R15,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RDI]
MOV qword ptr [RBP + -0x50],RAX
MOV EAX,dword ptr [RAX + 0x7bc]
MOV qword ptr [RBP + -0x58],RAX
CMP ECX,0x21
MOV R12D,0x20
CMOVNC R12D,ECX
MOV byte ptr [RDI + 0x685],0x1
MOV R9D,dword ptr [RSI + 0x8]
MOV RDX,qword ptr [RDI + 0x380]
CMP R9D,0xffff
JNZ 0x001632e6
LEA R9,[RBP + -0x88]
MOV RDI,R15
MOV RSI,R14
MOV ECX,R12D
MOV R8D,0x2
CALL 0x00162e6c
JMP 0x00163311
LAB_001632e6:
AND R9D,0xffff7fff
SUB RSP,0x8
LEA RAX,[RBP + -0x88]
MOV RDI,R15
MOV RSI,R14
MOV ECX,R12D
MOV R8D,0x2
PUSH RAX
CALL 0x001610c5
ADD RSP,0x10
LAB_00163311:
MOV R13B,0x1
TEST AL,AL
JZ 0x00163340
LAB_00163318:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00163566
MOV EAX,R13D
ADD RSP,0xa8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00163340:
MOV qword ptr [RBP + -0x48],R14
MOV R14B,byte ptr [R14 + 0x15]
MOV R13,qword ptr [RBP + -0x80]
MOV EDX,EBX
MOV RDI,R13
MOV RSI,qword ptr [RBP + -0x60]
CALL 0x00129080
MOV RAX,qword ptr [RBP + -0x50]
CMP byte ptr [RAX + 0x7e7],0x0
MOV byte ptr [RBP + -0x39],R14B
JZ 0x001633ef
XOR ECX,ECX
TEST R14B,R14B
SETZ CL
MOV R14,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [R14]
LEA RAX,[RBP + -0x38]
MOV dword ptr [RAX + 0x2],EDX
SHR RDX,0x20
MOV byte ptr [RAX + 0x6],DL
MOV EBX,dword ptr [RBP + -0x6c]
MOV byte ptr [RAX + 0x7],BL
LEA R10,[RBP + -0xd0]
MOV qword ptr [R10 + 0x20],RAX
MOV qword ptr [R10 + 0x28],0x8
MOV qword ptr [R10 + 0x30],R13
MOV EDX,R12D
MOV qword ptr [R10 + 0x38],RDX
LEA ESI,[0x2 + RCX*0x2]
MOV RDX,qword ptr [R15 + 0x8]
LEA R8D,[R12 + 0x8]
SUB RSP,0x8
LEA RDI,[RBP + -0x90]
MOV RCX,R15
MOV R9D,0x4
PUSH 0x0
PUSH RAX
PUSH R10
CALL 0x0012a8ac
ADD RSP,0x20
MOV R13B,0x1
TEST AL,AL
JNZ 0x00163318
JMP 0x001633f6
LAB_001633ef:
MOV EBX,dword ptr [RBP + -0x6c]
MOV R14,qword ptr [RBP + -0x48]
LAB_001633f6:
MOV RAX,qword ptr [RBP + -0x78]
MOV word ptr [RAX + 0x2],R12W
MOV EAX,dword ptr [RBP + -0x68]
SUB EAX,R12D
MOV R8,qword ptr [RBP + -0x88]
MOV word ptr [R8 + 0xa],AX
ADD EBX,0x8000
MOV dword ptr [R14 + 0x8],EBX
MOV R12,qword ptr [RBP + -0x50]
MOV ECX,dword ptr [R12 + 0x3f0]
MOVZX EDX,byte ptr [R8 + 0x8]
ADD ECX,EDX
INC ECX
CMP ECX,0x100
JNC 0x0016343e
MOV R9B,byte ptr [RBP + -0x39]
JMP 0x00163479
LAB_0016343e:
MOV DL,byte ptr [R8 + 0x9]
CMP DL,0xff
MOV R9B,byte ptr [RBP + -0x39]
JZ 0x00163477
MOV ESI,dword ptr [R12 + 0x7bc]
ADD ECX,0xffffff01
ADD RSI,R8
ADD RSI,-0x5
LAB_00163460:
DEC ECX
JZ 0x00163479
MOVZX EDX,DL
SHL EDX,0x2
MOV RDI,RSI
SUB RDI,RDX
MOV DL,byte ptr [RDI]
CMP DL,0xff
JNZ 0x00163460
LAB_00163477:
XOR EAX,EAX
LAB_00163479:
OR byte ptr [R14 + 0x14],0x5
MOV dword ptr [R14 + 0xc],EAX
TEST R9B,R9B
JZ 0x001634d2
MOV RBX,qword ptr [R15 + 0x2e8]
MOV EAX,dword ptr [R15 + 0x2f0]
DEC EAX
LEA R14,[RAX + RAX*0x2]
MOV RDI,qword ptr [R12 + 0x600]
MOV RSI,qword ptr [RBX + R14*0x8]
XOR R13D,R13D
MOV EDX,0x7
XOR ECX,ECX
XOR R8D,R8D
XOR R9D,R9D
PUSH 0x0
PUSH 0x1
CALL 0x0013232d
ADD RSP,0x10
MOV dword ptr [RBX + R14*0x8 + 0x8],0x5
JMP 0x00163318
LAB_001634d2:
MOV RDI,qword ptr [R12 + 0x600]
LEA RSI,[R15 + 0x470]
MOV RDX,qword ptr [R14]
MOV R9D,dword ptr [R12 + 0x7d4]
MOV EAX,dword ptr [RDI + 0x80]
SUB RSP,0x8
XOR R10D,R10D
LEA R11,[RBP + -0xd0]
XOR ECX,ECX
PUSH RAX
PUSH R10
PUSH 0x0
PUSH R11
PUSH R10
PUSH 0x2
PUSH 0x3
CALL 0x00133a76
ADD RSP,0x40
MOV R13D,EAX
TEST AL,AL
JNZ 0x00163540
LEA RSI,[RBP + -0xd0]
MOV dword ptr [RSI + 0x8],0x5
MOV byte ptr [RSI + 0x10],0x1
ADD R15,0x2e8
MOV RDI,R15
CALL 0x00191b9e
LAB_00163540:
MOV RSI,qword ptr [R14]
MOV RAX,qword ptr [RBP + -0x58]
IMUL RSI,RAX
CMP qword ptr [R12 + 0x40],RSI
JA 0x00163318
ADD RSI,RAX
MOV RDI,R12
CALL 0x00138cfc
JMP 0x00163318
LAB_00163566:
CALL 0x00129270
|
ulong write_tail(long *param_1,long *param_2,void *param_3,uint param_4)
{
long lVar1;
long *plVar2;
char cVar3;
uint uVar4;
int iVar5;
byte bVar6;
ulong uVar7;
int8 unaff_R13;
ulong uVar8;
long in_FS_OFFSET;
int1 local_d8 [8];
int4 local_d0;
int1 local_c8;
int1 *local_b8;
int8 local_b0;
void *local_a8;
ulong local_a0;
int1 local_98 [8];
long local_90;
void *local_88;
long local_80;
int local_74;
int local_70;
void *local_68;
ulong local_60;
long local_58;
long *local_50;
char local_41;
int1 local_40 [2];
int4 local_3e;
int1 local_3a;
int1 local_39;
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
local_58 = *param_1;
local_60 = (ulong)*(uint *)(local_58 + 0x7bc);
uVar7 = 0x20;
if (0x20 < param_4) {
uVar7 = (ulong)param_4;
}
*(int1 *)((long)param_1 + 0x685) = 1;
local_68 = param_3;
if (*(uint *)(param_2 + 1) == 0xffff) {
cVar3 = get_head_or_tail_page(param_1,param_2,param_1[0x70],uVar7,2,&local_90);
}
else {
cVar3 = get_rowpos_in_head_or_tail_page
(param_1,param_2,param_1[0x70],uVar7,2,*(uint *)(param_2 + 1) & 0xffff7fff,
&local_90);
}
uVar8 = CONCAT71((int7)((ulong)unaff_R13 >> 8),1);
if (cVar3 == '\0') {
cVar3 = *(char *)((long)param_2 + 0x15);
local_50 = param_2;
memcpy(local_88,local_68,(ulong)param_4);
plVar2 = local_50;
local_41 = cVar3;
if (*(char *)(local_58 + 0x7e7) != '\0') {
local_b8 = local_40;
local_3e = (int4)*local_50;
local_3a = (int1)((ulong)*local_50 >> 0x20);
local_39 = (int1)local_74;
local_b0 = 8;
local_a8 = local_88;
local_a0 = uVar7;
cVar3 = translog_write_record
(local_98,(cVar3 == '\0') * '\x02' + '\x02',param_1[1],param_1,
(int)uVar7 + 8,4,local_d8,local_b8,0);
uVar8 = CONCAT71((int7)((ulong)local_88 >> 8),1);
if (cVar3 != '\0') goto LAB_00163318;
}
lVar1 = local_58;
*(short *)(local_80 + 2) = (short)uVar7;
local_70 = local_70 - (int)uVar7;
*(short *)(local_90 + 10) = (short)local_70;
*(int *)(plVar2 + 1) = local_74 + 0x8000;
iVar5 = *(int *)(local_58 + 0x3f0) + (uint)*(byte *)(local_90 + 8);
if (0xff < iVar5 + 1U) {
bVar6 = *(byte *)(local_90 + 9);
if (bVar6 != 0xff) {
iVar5 = iVar5 + -0xfe;
do {
iVar5 = iVar5 + -1;
if (iVar5 == 0) goto LAB_00163479;
bVar6 = *(byte *)((ulong)*(uint *)(local_58 + 0x7bc) + local_90 + -5 + (ulong)bVar6 * -4);
} while (bVar6 != 0xff);
}
local_70 = 0;
}
LAB_00163479:
*(byte *)((long)plVar2 + 0x14) = *(byte *)((long)plVar2 + 0x14) | 5;
*(int *)((long)plVar2 + 0xc) = local_70;
if (local_41 == '\0') {
uVar4 = pagecache_write_part
(*(long *)(local_58 + 0x600),param_1 + 0x8e,*plVar2,0,local_90,
*(int4 *)(local_58 + 0x7d4),3,2,0,local_d8,0,0,
*(int4 *)(*(long *)(local_58 + 0x600) + 0x80));
uVar8 = (ulong)uVar4;
if ((char)uVar4 == '\0') {
local_d0 = 5;
local_c8 = 1;
insert_dynamic(param_1 + 0x5d);
}
if (*(ulong *)(lVar1 + 0x40) <= *plVar2 * local_60) {
_ma_set_share_data_file_length(lVar1,*plVar2 * local_60 + local_60);
}
}
else {
lVar1 = param_1[0x5d];
uVar7 = (ulong)((int)param_1[0x5e] - 1);
uVar8 = 0;
pagecache_unlock_by_link
(*(int8 *)(local_58 + 0x600),*(int8 *)(lVar1 + uVar7 * 0x18),7,0,0,0,1,0
);
*(int4 *)(lVar1 + 8 + uVar7 * 0x18) = 5;
}
}
LAB_00163318:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar8 & 0xffffffff;
}
|
|
60,645
|
minja::Parser::parseConstant()
|
llama.cpp/common/minja/minja.hpp
|
std::shared_ptr<Value> parseConstant() {
auto start = it;
consumeSpaces();
if (it == end) return nullptr;
if (*it == '"' || *it == '\'') {
auto str = parseString();
if (str) return std::make_shared<Value>(*str);
}
static std::regex prim_tok(R"(true\b|True\b|false\b|False\b|None\b)");
auto token = consumeToken(prim_tok);
if (!token.empty()) {
if (token == "true" || token == "True") return std::make_shared<Value>(true);
if (token == "false" || token == "False") return std::make_shared<Value>(false);
if (token == "None") return std::make_shared<Value>(nullptr);
throw std::runtime_error("Unknown constant token: " + token);
}
auto number = parseNumber(it, end);
if (!number.is_null()) return std::make_shared<Value>(number);
it = start;
return nullptr;
}
|
O3
|
cpp
|
minja::Parser::parseConstant():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x20(%rsi), %r14
movq 0x18(%rsi), %r12
movq 0x20(%rsi), %r13
movq %r13, %rbp
cmpq %r12, %r13
je 0xe6563
movq %r13, %rbp
movsbl (%rbp), %edi
callq 0x21e60
testl %eax, %eax
je 0xe6563
incq %rbp
movq %rbp, (%r14)
cmpq %r12, %rbp
jne 0xe654b
cmpq %r12, %rbp
je 0xe65b9
movzbl (%rbp), %eax
cmpl $0x27, %eax
je 0xe6576
cmpl $0x22, %eax
jne 0xe65c4
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xe78ee
movq (%r12), %rdx
testq %rdx, %rdx
je 0xe65c4
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0xe7ee0
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0xe6721
leaq 0x8(%rsp), %rdi
callq 0xe8086
jmp 0xe6721
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0xe6721
leaq 0x801ad(%rip), %rax # 0x166778
movb (%rax), %al
testb %al, %al
je 0xe6733
leaq 0x8017c(%rip), %rdx # 0x166758
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movl $0x1, %ecx
callq 0xe111a
cmpq $0x0, 0x8(%r12)
je 0xe66a0
leaq 0x2ee7f(%rip), %rsi # 0x115483
leaq 0x8(%rsp), %rdi
callq 0x220f0
testl %eax, %eax
je 0xe6689
leaq 0x3b40e(%rip), %rsi # 0x121a27
leaq 0x8(%rsp), %rdi
callq 0x220f0
testl %eax, %eax
je 0xe6689
leaq 0x31d82(%rip), %rsi # 0x1183b0
leaq 0x8(%rsp), %rdi
callq 0x220f0
testl %eax, %eax
je 0xe66cf
leaq 0x3b3e5(%rip), %rsi # 0x121a2c
leaq 0x8(%rsp), %rdi
callq 0x220f0
testl %eax, %eax
je 0xe66cf
leaq 0x3b73b(%rip), %rsi # 0x121d97
leaq 0x8(%rsp), %rdi
callq 0x220f0
testl %eax, %eax
jne 0xe678a
leaq 0x28(%rsp), %rdx
movq $0x0, (%rdx)
leaq 0x7(%rsp), %rsi
movq %rbx, %rdi
callq 0xe81a6
jmp 0xe6706
leaq 0x7(%rsp), %rdx
movb $0x1, (%rdx)
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0xe80b4
jmp 0xe6706
leaq 0x18(%r15), %rcx
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xe796e
cmpb $0x0, 0x28(%rsp)
je 0xe66e6
leaq 0x7(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0xe828e
jmp 0xe66ef
leaq 0x7(%rsp), %rdx
movb $0x0, (%rdx)
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0xe80b4
jmp 0xe6706
movq %r13, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
leaq 0x28(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x875ae
movq %r14, %rdi
callq 0x8bcc8
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe6721
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21190
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8003e(%rip), %rdi # 0x166778
callq 0x215f0
testl %eax, %eax
je 0xe65d5
leaq 0x8000a(%rip), %rdi # 0x166758
leaq 0x3cefe(%rip), %rsi # 0x123653
movl $0x10, %edx
callq 0x68604
leaq -0x7e0b6(%rip), %rdi # 0x686b0
leaq 0x7ffeb(%rip), %rsi # 0x166758
leaq 0x7f414(%rip), %rdx # 0x165b88
callq 0x22060
leaq 0x7fff8(%rip), %rdi # 0x166778
callq 0x21a60
jmp 0xe65d5
movl $0x10, %edi
callq 0x216d0
movq %rax, %r14
leaq 0x3ceda(%rip), %rsi # 0x123678
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x2983c
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x21480
xorl %ebp, %ebp
movq 0x7e7fa(%rip), %rsi # 0x164fc0
movq 0x7e7b3(%rip), %rdx # 0x164f80
movq %r14, %rdi
callq 0x21b60
movq %rax, %rbx
leaq 0x7ff99(%rip), %rdi # 0x166778
callq 0x21780
jmp 0xe6874
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe6807
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21190
testb %bpl, %bpl
jne 0xe6811
jmp 0xe6840
movq %rax, %rbx
movq %r14, %rdi
callq 0x22080
jmp 0xe6840
jmp 0xe683d
jmp 0xe683d
movq %rax, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x875ae
movq %r14, %rdi
callq 0x8bcc8
jmp 0xe6840
jmp 0xe683d
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe6874
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21190
jmp 0xe6874
movq %rax, %rbx
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0xe6874
leaq 0x8(%rsp), %rdi
callq 0xe8086
movq %rbx, %rdi
callq 0x21c20
|
_ZN5minja6Parser13parseConstantEv:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov r15, rsi
mov rbx, rdi
lea r14, [rsi+20h]
mov r12, [rsi+18h]
mov r13, [rsi+20h]
mov rbp, r13
cmp r13, r12
jz short loc_E6563
mov rbp, r13
loc_E654B:
movsx edi, byte ptr [rbp+0]
call _isspace
test eax, eax
jz short loc_E6563
inc rbp
mov [r14], rbp
cmp rbp, r12
jnz short loc_E654B
loc_E6563:
cmp rbp, r12
jz short loc_E65B9
movzx eax, byte ptr [rbp+0]
cmp eax, 27h ; '''
jz short loc_E6576
cmp eax, 22h ; '"'
jnz short loc_E65C4
loc_E6576:
lea r12, [rsp+78h+var_70]
mov rdi, r12; int
mov rsi, r15; void *
call _ZN5minja6Parser11parseStringB5cxx11Ev; minja::Parser::parseString(void)
mov rdx, [r12]
test rdx, rdx
jz short loc_E65C4
lea rsi, [rsp+78h+var_50]
mov rdi, rbx
call _ZNSt12__shared_ptrIN5minja5ValueELN9__gnu_cxx12_Lock_policyE2EEC2ISaIvEJRNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEESt20_Sp_alloc_shared_tagIT_EDpOT0_; std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::__shared_ptr<std::allocator<void>,std::string &>(std::_Sp_alloc_shared_tag<std::allocator<void>>,std::string &)
mov rsi, qword ptr [rsp+78h+var_70]
test rsi, rsi
jz loc_E6721
lea rdi, [rsp+78h+var_70]
call _ZNKSt14default_deleteINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEclEPS5_; std::default_delete<std::string>::operator()(std::string*)
jmp loc_E6721
loc_E65B9:
xorps xmm0, xmm0
movups xmmword ptr [rbx], xmm0
jmp loc_E6721
loc_E65C4:
lea rax, _ZGVZN5minja6Parser13parseConstantEvE8prim_tokB5cxx11; `guard variable for'minja::Parser::parseConstant(void)::prim_tok
mov al, [rax]
test al, al
jz loc_E6733
loc_E65D5:
lea rdx, _ZZN5minja6Parser13parseConstantEvE8prim_tokB5cxx11; int
lea r12, [rsp+78h+var_70]
mov rdi, r12; int
mov rsi, r15; int
mov ecx, 1; int
call _ZN5minja6Parser12consumeTokenERKNSt7__cxx1111basic_regexIcNS1_12regex_traitsIcEEEENS_13SpaceHandlingE; minja::Parser::consumeToken(std::basic_regex<char,std::regex_traits<char>> const&,minja::SpaceHandling)
cmp qword ptr [r12+8], 0
jz loc_E66A0
lea rsi, aTrue; "true"
lea rdi, [rsp+78h+var_70]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_E6689
lea rsi, aTrue_0; "True"
lea rdi, [rsp+78h+var_70]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_E6689
lea rsi, aAdvancedOption+0ABh; "false"
lea rdi, [rsp+78h+var_70]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz loc_E66CF
lea rsi, aFalse; "False"
lea rdi, [rsp+78h+var_70]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_E66CF
lea rsi, aNone_0; "None"
lea rdi, [rsp+78h+var_70]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jnz loc_E678A
lea rdx, [rsp+78h+var_50]
mov qword ptr [rdx], 0
lea rsi, [rsp+78h+var_71]
mov rdi, rbx
call _ZNSt12__shared_ptrIN5minja5ValueELN9__gnu_cxx12_Lock_policyE2EEC2ISaIvEJDnEEESt20_Sp_alloc_shared_tagIT_EDpOT0_; std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::__shared_ptr<std::allocator<void>,decltype(nullptr)>(std::_Sp_alloc_shared_tag<std::allocator<void>>,decltype(nullptr) &&)
jmp short loc_E6706
loc_E6689:
lea rdx, [rsp+78h+var_71]
mov byte ptr [rdx], 1
lea rsi, [rsp+78h+var_50]
mov rdi, rbx
call _ZNSt12__shared_ptrIN5minja5ValueELN9__gnu_cxx12_Lock_policyE2EEC2ISaIvEJbEEESt20_Sp_alloc_shared_tagIT_EDpOT0_; std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::__shared_ptr<std::allocator<void>,bool>(std::_Sp_alloc_shared_tag<std::allocator<void>>,bool &&)
jmp short loc_E6706
loc_E66A0:
lea rcx, [r15+18h]
lea rdi, [rsp+78h+var_50]
mov rsi, r15
mov rdx, r14
call _ZN5minja6Parser11parseNumberERN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEERKSB_; minja::Parser::parseNumber(__gnu_cxx::__normal_iterator<char const*,std::string> &,__gnu_cxx::__normal_iterator<char const*,std::string> const&)
cmp [rsp+78h+var_50], 0
jz short loc_E66E6
lea rsi, [rsp+78h+var_71]
lea rdx, [rsp+78h+var_50]
mov rdi, rbx
call _ZNSt12__shared_ptrIN5minja5ValueELN9__gnu_cxx12_Lock_policyE2EEC2ISaIvEJRN8nlohmann16json_abi_v3_11_310basic_jsonINS8_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS8_14adl_serializerESB_IhSaIhEEvEEEEESt20_Sp_alloc_shared_tagIT_EDpOT0_; std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::__shared_ptr<std::allocator<void>,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &>(std::_Sp_alloc_shared_tag<std::allocator<void>>,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> &)
jmp short loc_E66EF
loc_E66CF:
lea rdx, [rsp+78h+var_71]
mov byte ptr [rdx], 0
lea rsi, [rsp+78h+var_50]
mov rdi, rbx
call _ZNSt12__shared_ptrIN5minja5ValueELN9__gnu_cxx12_Lock_policyE2EEC2ISaIvEJbEEESt20_Sp_alloc_shared_tagIT_EDpOT0_; std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::__shared_ptr<std::allocator<void>,bool>(std::_Sp_alloc_shared_tag<std::allocator<void>>,bool &&)
jmp short loc_E6706
loc_E66E6:
mov [r14], r13
xorps xmm0, xmm0
movups xmmword ptr [rbx], xmm0
loc_E66EF:
lea r14, [rsp+78h+var_50]
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()
loc_E6706:
lea rax, [rsp+78h+var_60]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_E6721
mov rsi, [rsp+78h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_E6721:
mov rax, rbx
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_E6733:
lea rdi, _ZGVZN5minja6Parser13parseConstantEvE8prim_tokB5cxx11; __guard *
call ___cxa_guard_acquire
test eax, eax
jz loc_E65D5
lea rdi, _ZZN5minja6Parser13parseConstantEvE8prim_tokB5cxx11; minja::Parser::parseConstant(void)::prim_tok
lea rsi, aTrueBTrueBFals; "true\\b|True\\b|false\\b|False\\b|None"...
mov edx, 10h
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEEC2EPKcNSt15regex_constants18syntax_option_typeE; std::basic_regex<char,std::regex_traits<char>>::basic_regex(char const*,std::regex_constants::syntax_option_type)
lea rdi, _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; lpfunc
lea rsi, _ZZN5minja6Parser13parseConstantEvE8prim_tokB5cxx11; obj
lea rdx, __dso_handle; lpdso_handle
call ___cxa_atexit
lea rdi, _ZGVZN5minja6Parser13parseConstantEvE8prim_tokB5cxx11; __guard *
call ___cxa_guard_release
jmp loc_E65D5
loc_E678A:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aUnknownConstan; "Unknown constant token: "
lea rdi, [rsp+78h+var_50]
lea rdx, [rsp+78h+var_70]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
mov bpl, 1
lea rsi, [rsp+78h+var_50]
mov rdi, r14
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
mov rbx, rax
lea rdi, _ZGVZN5minja6Parser13parseConstantEvE8prim_tokB5cxx11; __guard *
call ___cxa_guard_abort
jmp loc_E6874
mov rbx, rax
lea rax, [rsp+78h+var_40]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_E6807
mov rsi, [rsp+78h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_E6807:
test bpl, bpl
jnz short loc_E6811
jmp short loc_E6840
mov rbx, rax
loc_E6811:
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_E6840
jmp short loc_E683D
jmp short loc_E683D
mov rbx, rax
lea r14, [rsp+78h+var_50]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
jmp short loc_E6840
jmp short $+2
loc_E683D:
mov rbx, rax
loc_E6840:
lea rax, [rsp+78h+var_60]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_E6874
mov rsi, [rsp+78h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_E6874
mov rbx, rax
mov rsi, qword ptr [rsp+78h+var_70]
test rsi, rsi
jz short loc_E6874
lea rdi, [rsp+78h+var_70]
call _ZNKSt14default_deleteINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEclEPS5_; std::default_delete<std::string>::operator()(std::string*)
loc_E6874:
mov rdi, rbx
call __Unwind_Resume
|
minja::Parser * minja::Parser::parseConstant(minja::Parser *this, unsigned __int8 **a2)
{
unsigned __int8 **v2; // r14
char *v3; // r12
unsigned __int8 *v4; // r13
unsigned __int8 *v5; // rbp
int v6; // eax
void *exception; // r14
char v9; // [rsp+7h] [rbp-71h] BYREF
int v10[2]; // [rsp+8h] [rbp-70h] BYREF
long long v11; // [rsp+10h] [rbp-68h]
long long v12; // [rsp+18h] [rbp-60h] BYREF
_QWORD v13[2]; // [rsp+28h] [rbp-50h] BYREF
v2 = a2 + 4;
v3 = (char *)a2[3];
v4 = a2[4];
v5 = v4;
if ( v4 != (unsigned __int8 *)v3 )
{
v5 = a2[4];
do
{
if ( !(unsigned int)isspace((unsigned int)(char)*v5) )
break;
*v2 = ++v5;
}
while ( v5 != (unsigned __int8 *)v3 );
}
if ( v5 == (unsigned __int8 *)v3 )
{
*(_OWORD *)this = 0LL;
}
else
{
v6 = *v5;
if ( (v6 == 39 || v6 == 34) && (minja::Parser::parseString[abi:cxx11]((int)v10, a2), *(_QWORD *)v10) )
{
std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::__shared_ptr<std::allocator<void>,std::string &>(
this,
v13);
if ( *(_QWORD *)v10 )
std::default_delete<std::string>::operator()(v10);
}
else
{
if ( !(_BYTE)`guard variable for'minja::Parser::parseConstant(void)::prim_tok[abi:cxx11]
&& __cxa_guard_acquire(&`guard variable for'minja::Parser::parseConstant(void)::prim_tok[abi:cxx11]) )
{
std::basic_regex<char,std::regex_traits<char>>::basic_regex(
(long long)&minja::Parser::parseConstant(void)::prim_tok[abi:cxx11],
(long long)"true\\b|True\\b|false\\b|False\\b|None\\b",
0x10u);
__cxa_atexit(
(void (*)(void *))std::basic_regex<char,std::regex_traits<char>>::~basic_regex,
&minja::Parser::parseConstant(void)::prim_tok[abi:cxx11],
&_dso_handle);
__cxa_guard_release(&`guard variable for'minja::Parser::parseConstant(void)::prim_tok[abi:cxx11]);
}
minja::Parser::consumeToken(
v10,
(long long)a2,
(long long)&minja::Parser::parseConstant(void)::prim_tok[abi:cxx11],
1u);
if ( v11 )
{
if ( !(unsigned int)std::string::compare(v10, "true") || !(unsigned int)std::string::compare(v10, "True") )
{
v9 = 1;
std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::__shared_ptr<std::allocator<void>,bool>(
this,
v13,
&v9);
}
else if ( !(unsigned int)std::string::compare(v10, "false") || !(unsigned int)std::string::compare(v10, "False") )
{
v9 = 0;
std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::__shared_ptr<std::allocator<void>,bool>(
this,
v13,
&v9);
}
else
{
if ( (unsigned int)std::string::compare(v10, "None") )
{
exception = __cxa_allocate_exception(0x10uLL);
std::operator+<char>((long long)v13, (long long)"Unknown constant token: ", v10);
std::runtime_error::runtime_error(exception, v13);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v13[0] = 0LL;
std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::__shared_ptr<std::allocator<void>,decltype(nullptr)>(
this,
&v9,
v13);
}
}
else
{
minja::Parser::parseNumber(v13, a2, v2, a2 + 3);
if ( LOBYTE(v13[0]) )
{
std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::__shared_ptr<std::allocator<void>,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> &>(
this,
&v9,
v13);
}
else
{
*v2 = v4;
*(_OWORD *)this = 0LL;
}
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v13);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v13);
}
if ( *(long long **)v10 != &v12 )
operator delete(*(void **)v10, v12 + 1);
}
}
return this;
}
|
parseConstant:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R15,RSI
MOV RBX,RDI
LEA R14,[RSI + 0x20]
MOV R12,qword ptr [RSI + 0x18]
MOV R13,qword ptr [RSI + 0x20]
MOV RBP,R13
CMP R13,R12
JZ 0x001e6563
MOV RBP,R13
LAB_001e654b:
MOVSX EDI,byte ptr [RBP]
CALL 0x00121e60
TEST EAX,EAX
JZ 0x001e6563
INC RBP
MOV qword ptr [R14],RBP
CMP RBP,R12
JNZ 0x001e654b
LAB_001e6563:
CMP RBP,R12
JZ 0x001e65b9
MOVZX EAX,byte ptr [RBP]
CMP EAX,0x27
JZ 0x001e6576
CMP EAX,0x22
JNZ 0x001e65c4
LAB_001e6576:
LEA R12,[RSP + 0x8]
MOV RDI,R12
MOV RSI,R15
CALL 0x001e78ee
MOV RDX,qword ptr [R12]
TEST RDX,RDX
JZ 0x001e65c4
LAB_001e658f:
LEA RSI,[RSP + 0x28]
MOV RDI,RBX
CALL 0x001e7ee0
LAB_001e659c:
MOV RSI,qword ptr [RSP + 0x8]
TEST RSI,RSI
JZ 0x001e6721
LEA RDI,[RSP + 0x8]
CALL 0x001e8086
JMP 0x001e6721
LAB_001e65b9:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
JMP 0x001e6721
LAB_001e65c4:
LEA RAX,[0x266778]
MOV AL,byte ptr [RAX]
TEST AL,AL
JZ 0x001e6733
LAB_001e65d5:
LEA RDX,[0x266758]
LEA R12,[RSP + 0x8]
MOV RDI,R12
MOV RSI,R15
MOV ECX,0x1
CALL 0x001e111a
CMP qword ptr [R12 + 0x8],0x0
JZ 0x001e66a0
LEA RSI,[0x215483]
LEA RDI,[RSP + 0x8]
CALL 0x001220f0
TEST EAX,EAX
JZ 0x001e6689
LEA RSI,[0x221a27]
LEA RDI,[RSP + 0x8]
CALL 0x001220f0
TEST EAX,EAX
JZ 0x001e6689
LEA RSI,[0x2183b0]
LEA RDI,[RSP + 0x8]
CALL 0x001220f0
TEST EAX,EAX
JZ 0x001e66cf
LEA RSI,[0x221a2c]
LEA RDI,[RSP + 0x8]
CALL 0x001220f0
TEST EAX,EAX
JZ 0x001e66cf
LEA RSI,[0x221d97]
LEA RDI,[RSP + 0x8]
CALL 0x001220f0
TEST EAX,EAX
JNZ 0x001e678a
LEA RDX,[RSP + 0x28]
MOV qword ptr [RDX],0x0
LAB_001e667a:
LEA RSI,[RSP + 0x7]
MOV RDI,RBX
CALL 0x001e81a6
JMP 0x001e6706
LAB_001e6689:
LEA RDX,[RSP + 0x7]
MOV byte ptr [RDX],0x1
LAB_001e6691:
LEA RSI,[RSP + 0x28]
MOV RDI,RBX
CALL 0x001e80b4
JMP 0x001e6706
LAB_001e66a0:
LEA RCX,[R15 + 0x18]
LEA RDI,[RSP + 0x28]
MOV RSI,R15
MOV RDX,R14
CALL 0x001e796e
CMP byte ptr [RSP + 0x28],0x0
JZ 0x001e66e6
LAB_001e66bb:
LEA RSI,[RSP + 0x7]
LEA RDX,[RSP + 0x28]
MOV RDI,RBX
CALL 0x001e828e
JMP 0x001e66ef
LAB_001e66cf:
LEA RDX,[RSP + 0x7]
MOV byte ptr [RDX],0x0
LAB_001e66d7:
LEA RSI,[RSP + 0x28]
MOV RDI,RBX
CALL 0x001e80b4
JMP 0x001e6706
LAB_001e66e6:
MOV qword ptr [R14],R13
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
LAB_001e66ef:
LEA R14,[RSP + 0x28]
MOV RDI,R14
XOR ESI,ESI
CALL 0x001875ae
MOV RDI,R14
CALL 0x0018bcc8
LAB_001e6706:
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001e6721
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x00121190
LAB_001e6721:
MOV RAX,RBX
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001e6733:
LEA RDI,[0x266778]
CALL 0x001215f0
TEST EAX,EAX
JZ 0x001e65d5
LAB_001e6747:
LEA RDI,[0x266758]
LEA RSI,[0x223653]
MOV EDX,0x10
CALL 0x00168604
LAB_001e675f:
LEA RDI,[0x1686b0]
LEA RSI,[0x266758]
LEA RDX,[0x265b88]
CALL 0x00122060
LEA RDI,[0x266778]
CALL 0x00121a60
JMP 0x001e65d5
LAB_001e678a:
MOV EDI,0x10
CALL 0x001216d0
MOV R14,RAX
LAB_001e6797:
LEA RSI,[0x223678]
LEA RDI,[RSP + 0x28]
LEA RDX,[RSP + 0x8]
CALL 0x0012983c
MOV BPL,0x1
LAB_001e67b0:
LEA RSI,[RSP + 0x28]
MOV RDI,R14
CALL 0x00121480
XOR EBP,EBP
MOV RSI,qword ptr [0x00264fc0]
MOV RDX,qword ptr [0x00264f80]
MOV RDI,R14
CALL 0x00121b60
|
/* minja::Parser::parseConstant() */
void minja::Parser::parseConstant(void)
{
char *pcVar1;
char *pcVar2;
int iVar3;
runtime_error *this;
char *pcVar4;
__normal_iterator *in_RSI;
int8 *in_RDI;
string *local_70;
long local_68;
long local_60 [2];
int8 local_50 [4];
pcVar1 = *(char **)(in_RSI + 0x18);
pcVar2 = *(char **)(in_RSI + 0x20);
pcVar4 = pcVar2;
while ((pcVar4 != pcVar1 && (iVar3 = isspace((int)*pcVar4), iVar3 != 0))) {
pcVar4 = pcVar4 + 1;
*(char **)(in_RSI + 0x20) = pcVar4;
}
if (pcVar4 == pcVar1) {
*in_RDI = 0;
in_RDI[1] = 0;
}
else if (((*pcVar4 == '\'') || (*pcVar4 == '\"')) &&
(parseString_abi_cxx11_(), local_70 != (string *)0x0)) {
/* try { // try from 001e658f to 001e659b has its CatchHandler @ 001e685d */
std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::
__shared_ptr<std::allocator<void>,std::__cxx11::string&>();
if (local_70 != (string *)0x0) {
std::default_delete<std::__cxx11::string>::operator()
((default_delete<std::__cxx11::string> *)&local_70,local_70);
}
}
else {
if ((parseConstant()::prim_tok_abi_cxx11_ == '\0') &&
(iVar3 = __cxa_guard_acquire(&parseConstant()::prim_tok_abi_cxx11_), iVar3 != 0)) {
/* try { // try from 001e6747 to 001e675e has its CatchHandler @ 001e67d5 */
std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::basic_regex
((basic_regex<char,std::__cxx11::regex_traits<char>> *)
parseConstant()::prim_tok_abi_cxx11_,"true\\b|True\\b|false\\b|False\\b|None\\b",
0x10);
__cxa_atexit(std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::~basic_regex,
parseConstant()::prim_tok_abi_cxx11_,&__dso_handle);
__cxa_guard_release(&parseConstant()::prim_tok_abi_cxx11_);
}
consumeToken(&local_70);
if (local_68 == 0) {
/* try { // try from 001e66a0 to 001e66b3 has its CatchHandler @ 001e683b */
parseNumber((__normal_iterator *)local_50,in_RSI);
if (local_50[0]._0_1_ == (data)0x0) {
*(char **)(in_RSI + 0x20) = pcVar2;
*in_RDI = 0;
in_RDI[1] = 0;
}
else {
/* try { // try from 001e66bb to 001e66cc has its CatchHandler @ 001e681f */
std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::
__shared_ptr<std::allocator<void>,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&>
();
}
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((data *)local_50,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((data *)local_50);
}
else {
iVar3 = std::__cxx11::string::compare((char *)&local_70);
if ((iVar3 == 0) || (iVar3 = std::__cxx11::string::compare((char *)&local_70), iVar3 == 0)) {
/* try { // try from 001e6691 to 001e669d has its CatchHandler @ 001e683d */
std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::
__shared_ptr<std::allocator<void>,bool>();
}
else {
iVar3 = std::__cxx11::string::compare((char *)&local_70);
if ((iVar3 == 0) || (iVar3 = std::__cxx11::string::compare((char *)&local_70), iVar3 == 0))
{
/* try { // try from 001e66d7 to 001e66e3 has its CatchHandler @ 001e681d */
std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::
__shared_ptr<std::allocator<void>,bool>();
}
else {
iVar3 = std::__cxx11::string::compare((char *)&local_70);
if (iVar3 != 0) {
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001e6797 to 001e67ac has its CatchHandler @ 001e680e */
std::operator+((char *)local_50,(string *)"Unknown constant token: ");
/* try { // try from 001e67b0 to 001e67d4 has its CatchHandler @ 001e67e9 */
std::runtime_error::runtime_error(this,(string *)local_50);
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_00264fc0,PTR__runtime_error_00264f80);
}
local_50[0] = 0;
/* try { // try from 001e667a to 001e6686 has its CatchHandler @ 001e681b */
std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::
__shared_ptr<std::allocator<void>,decltype(nullptr)>();
}
}
}
if (local_70 != (string *)local_60) {
operator_delete(local_70,local_60[0] + 1);
}
}
return;
}
|
|
60,646
|
blst_bendian_from_fp12
|
corpus-core[P]colibri-stateless/build_O1/_deps/blst-src/src/fp12_tower.c
|
void blst_bendian_from_fp12(unsigned char ret[48*12], const vec384fp12 a)
{
size_t i, j;
vec384 out;
for (i = 0; i < 3; i++) {
for (j = 0; j < 2; j++) {
from_fp(out, a[j][i][0]);
be_bytes_from_limbs(ret, out, sizeof(vec384)); ret += 48;
from_fp(out, a[j][i][1]);
be_bytes_from_limbs(ret, out, sizeof(vec384)); ret += 48;
}
}
}
|
O1
|
c
|
blst_bendian_from_fp12:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, %r14
xorl %eax, %eax
movq %rax, -0x30(%rbp)
leaq (%rax,%rax,2), %r15
shlq $0x5, %r15
xorl %r12d, %r12d
leaq (%r12,%r12,8), %rbx
shlq $0x5, %rbx
addq -0x38(%rbp), %rbx
addq %r15, %rbx
leaq -0x70(%rbp), %rdi
movq %rbx, %rsi
leaq 0x1f7e2(%rip), %rdx # 0x3fb20
movabsq $-0x760c000300030003, %rcx # imm = 0x89F3FFFCFFFCFFFD
callq 0x34540
movl $0x2f, %eax
movl $0x178, %edx # imm = 0x178
movq %r14, %rsi
movq %rax, %rcx
andq $-0x8, %rcx
movq -0x70(%rbp,%rcx), %rdi
movl %edx, %ecx
andb $0x38, %cl
shrq %cl, %rdi
movb %dil, (%rsi)
incq %rsi
addq $-0x8, %rdx
addq $-0x1, %rax
jb 0x2035a
leaq 0x30(%r14), %r13
addq $0x30, %rbx
leaq -0x70(%rbp), %rdi
movq %rbx, %rsi
leaq 0x1f78c(%rip), %rdx # 0x3fb20
movabsq $-0x760c000300030003, %rcx # imm = 0x89F3FFFCFFFCFFFD
callq 0x34540
movl $0x2f, %eax
movl $0x178, %edx # imm = 0x178
movq %rax, %rcx
andq $-0x8, %rcx
movq -0x70(%rbp,%rcx), %rsi
movl %edx, %ecx
andb $0x38, %cl
shrq %cl, %rsi
movb %sil, (%r13)
incq %r13
addq $-0x8, %rdx
addq $-0x1, %rax
jb 0x203ad
addq $0x60, %r14
leaq 0x1(%r12), %rax
testq %r12, %r12
movq %rax, %r12
je 0x20321
movq -0x30(%rbp), %rax
incq %rax
cmpq $0x3, %rax
jne 0x20312
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
blst_bendian_from_fp12:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov [rbp+var_38], rsi
mov r14, rdi
xor eax, eax
loc_20312:
mov [rbp+var_30], rax
lea r15, [rax+rax*2]
shl r15, 5
xor r12d, r12d
loc_20321:
lea rbx, [r12+r12*8]
shl rbx, 5
add rbx, [rbp+var_38]
add rbx, r15
lea rdi, [rbp+var_70]
mov rsi, rbx
lea rdx, BLS12_381_P
mov rcx, 89F3FFFCFFFCFFFDh
call from_mont_384
mov eax, 2Fh ; '/'
mov edx, 178h
mov rsi, r14
loc_2035A:
mov rcx, rax
and rcx, 0FFFFFFFFFFFFFFF8h
mov rdi, [rbp+rcx+var_70]
mov ecx, edx
and cl, 38h
shr rdi, cl
mov [rsi], dil
inc rsi
add rdx, 0FFFFFFFFFFFFFFF8h
add rax, 0FFFFFFFFFFFFFFFFh
jb short loc_2035A
lea r13, [r14+30h]
add rbx, 30h ; '0'
lea rdi, [rbp+var_70]
mov rsi, rbx
lea rdx, BLS12_381_P
mov rcx, 89F3FFFCFFFCFFFDh
call from_mont_384
mov eax, 2Fh ; '/'
mov edx, 178h
loc_203AD:
mov rcx, rax
and rcx, 0FFFFFFFFFFFFFFF8h
mov rsi, [rbp+rcx+var_70]
mov ecx, edx
and cl, 38h
shr rsi, cl
mov [r13+0], sil
inc r13
add rdx, 0FFFFFFFFFFFFFFF8h
add rax, 0FFFFFFFFFFFFFFFFh
jb short loc_203AD
add r14, 60h ; '`'
lea rax, [r12+1]
test r12, r12
mov r12, rax
jz loc_20321
mov rax, [rbp+var_30]
inc rax
cmp rax, 3
jnz loc_20312
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long blst_bendian_from_fp12(_BYTE *a1, long long a2)
{
long long result; // rax
long long v4; // r15
long long v5; // r12
long long v6; // rbx
long long v7; // rax
long long v8; // rdx
_BYTE *v9; // rsi
bool v10; // cf
_BYTE *v11; // r13
long long v12; // rax
long long v13; // rdx
_QWORD v15[7]; // [rsp+0h] [rbp-70h] BYREF
long long v16; // [rsp+38h] [rbp-38h]
long long v17; // [rsp+40h] [rbp-30h]
v16 = a2;
result = 0LL;
do
{
v17 = result;
v4 = 96 * result;
v5 = 0LL;
do
{
v6 = v4 + v16 + 288 * v5;
from_mont_384(v15, v6, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
v7 = 47LL;
v8 = 376LL;
v9 = a1;
do
{
*v9++ = *(_QWORD *)((char *)v15 + (v7 & 0xFFFFFFFFFFFFFFF8LL)) >> (v8 & 0x38);
v8 -= 8LL;
v10 = v7-- != 0;
}
while ( v10 );
v11 = a1 + 48;
from_mont_384(v15, v6 + 48, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
v12 = 47LL;
v13 = 376LL;
do
{
*v11++ = *(_QWORD *)((char *)v15 + (v12 & 0xFFFFFFFFFFFFFFF8LL)) >> (v13 & 0x38);
v13 -= 8LL;
v10 = v12-- != 0;
}
while ( v10 );
a1 += 96;
}
while ( v5++ == 0 );
result = v17 + 1;
}
while ( v17 != 2 );
return result;
}
|
blst_bendian_from_fp12:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x38],RSI
MOV R14,RDI
XOR EAX,EAX
LAB_00120312:
MOV qword ptr [RBP + -0x30],RAX
LEA R15,[RAX + RAX*0x2]
SHL R15,0x5
XOR R12D,R12D
LAB_00120321:
LEA RBX,[R12 + R12*0x8]
SHL RBX,0x5
ADD RBX,qword ptr [RBP + -0x38]
ADD RBX,R15
LEA RDI,[RBP + -0x70]
MOV RSI,RBX
LEA RDX,[0x13fb20]
MOV RCX,-0x760c000300030003
CALL 0x00134540
MOV EAX,0x2f
MOV EDX,0x178
MOV RSI,R14
LAB_0012035a:
MOV RCX,RAX
AND RCX,-0x8
MOV RDI,qword ptr [RBP + RCX*0x1 + -0x70]
MOV ECX,EDX
AND CL,0x38
SHR RDI,CL
MOV byte ptr [RSI],DIL
INC RSI
ADD RDX,-0x8
ADD RAX,-0x1
JC 0x0012035a
LEA R13,[R14 + 0x30]
ADD RBX,0x30
LEA RDI,[RBP + -0x70]
MOV RSI,RBX
LEA RDX,[0x13fb20]
MOV RCX,-0x760c000300030003
CALL 0x00134540
MOV EAX,0x2f
MOV EDX,0x178
LAB_001203ad:
MOV RCX,RAX
AND RCX,-0x8
MOV RSI,qword ptr [RBP + RCX*0x1 + -0x70]
MOV ECX,EDX
AND CL,0x38
SHR RSI,CL
MOV byte ptr [R13],SIL
INC R13
ADD RDX,-0x8
ADD RAX,-0x1
JC 0x001203ad
ADD R14,0x60
LEA RAX,[R12 + 0x1]
TEST R12,R12
MOV R12,RAX
JZ 0x00120321
MOV RAX,qword ptr [RBP + -0x30]
INC RAX
CMP RAX,0x3
JNZ 0x00120312
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void blst_bendian_from_fp12(int1 *param_1,long param_2)
{
ulong uVar1;
byte bVar2;
long lVar3;
int1 *puVar4;
long lVar5;
long lVar6;
bool bVar7;
ulong local_78 [7];
long local_40;
long local_38;
local_38 = 0;
local_40 = param_2;
do {
lVar6 = local_38 * 0x60;
lVar5 = 0;
do {
lVar3 = lVar5 * 0x120 + local_40 + lVar6;
from_mont_384(local_78,lVar3,BLS12_381_P,0x89f3fffcfffcfffd);
uVar1 = 0x2f;
bVar2 = 0x78;
puVar4 = param_1;
do {
*puVar4 = (char)(*(ulong *)((long)local_78 + (uVar1 & 0xfffffffffffffff8)) >> (bVar2 & 0x38)
);
puVar4 = puVar4 + 1;
bVar2 = bVar2 - 8;
bVar7 = uVar1 != 0;
uVar1 = uVar1 - 1;
} while (bVar7);
puVar4 = param_1 + 0x30;
from_mont_384(local_78,lVar3 + 0x30,BLS12_381_P,0x89f3fffcfffcfffd);
uVar1 = 0x2f;
bVar2 = 0x78;
do {
*puVar4 = (char)(*(ulong *)((long)local_78 + (uVar1 & 0xfffffffffffffff8)) >> (bVar2 & 0x38)
);
puVar4 = puVar4 + 1;
bVar2 = bVar2 - 8;
bVar7 = uVar1 != 0;
uVar1 = uVar1 - 1;
} while (bVar7);
param_1 = param_1 + 0x60;
bVar7 = lVar5 == 0;
lVar5 = lVar5 + 1;
} while (bVar7);
local_38 = local_38 + 1;
} while (local_38 != 3);
return;
}
|
|
60,647
|
nglog::posix_strerror_r(int, char*, unsigned long)
|
ng-log[P]ng-log/src/logging.cc
|
NGLOG_NO_EXPORT
int posix_strerror_r(int err, char* buf, size_t len) {
// Sanity check input parameters
if (buf == nullptr || len <= 0) {
errno = EINVAL;
return -1;
}
// Reset buf and errno, and try calling whatever version of strerror_r()
// is implemented by glibc
buf[0] = '\000';
int old_errno = errno;
errno = 0;
char* rc = reinterpret_cast<char*>(strerror_r(err, buf, len));
// Both versions set errno on failure
if (errno) {
// Should already be there, but better safe than sorry
buf[0] = '\000';
return -1;
}
errno = old_errno;
// POSIX is vague about whether the string will be terminated, although
// is indirectly implies that typically ERANGE will be returned, instead
// of truncating the string. This is different from the GNU implementation.
// We play it safe by always terminating the string explicitly.
buf[len - 1] = '\000';
// If the function succeeded, we can use its exit code to determine the
// semantics implemented by glibc
if (!rc) {
return 0;
} else {
// GNU semantics detected
if (rc == buf) {
return 0;
} else {
buf[0] = '\000';
#if defined(NGLOG_OS_MACOSX) || defined(NGLOG_OS_FREEBSD) || \
defined(NGLOG_OS_OPENBSD)
if (reinterpret_cast<intptr_t>(rc) < sys_nerr) {
// This means an error on MacOSX or FreeBSD.
return -1;
}
#endif
strncat(buf, rc, len - 1);
return 0;
}
}
}
|
O2
|
cpp
|
nglog::posix_strerror_r(int, char*, unsigned long):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rsi, %rsi
setne %al
testq %rdx, %rdx
setne %cl
testb %cl, %al
jne 0x1a5a6
callq 0x8050
movl $0x16, (%rax)
jmp 0x1a5d6
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
movb $0x0, (%rsi)
callq 0x8050
movq %rax, %r15
movl (%rax), %r12d
andl $0x0, (%rax)
movl %ebp, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x8150
cmpl $0x0, (%r15)
je 0x1a5e4
movb $0x0, (%r14)
pushq $-0x1
popq %rbp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %r12d, (%r15)
movb $0x0, -0x1(%r14,%rbx)
testq %rax, %rax
sete %cl
cmpq %r14, %rax
sete %dl
xorl %ebp, %ebp
orb %cl, %dl
jne 0x1a5d9
decq %rbx
movb $0x0, (%r14)
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x8470
jmp 0x1a5d9
|
_ZN5nglog16posix_strerror_rEiPcm:
push rbp
push r15
push r14
push r12
push rbx
test rsi, rsi
setnz al
test rdx, rdx
setnz cl
test al, cl
jnz short loc_1A5A6
call ___errno_location
mov dword ptr [rax], 16h
jmp short loc_1A5D6
loc_1A5A6:
mov rbx, rdx
mov r14, rsi
mov ebp, edi
mov byte ptr [rsi], 0
call ___errno_location
mov r15, rax
mov r12d, [rax]
and dword ptr [rax], 0
mov edi, ebp
mov rsi, r14
mov rdx, rbx
call _strerror_r
cmp dword ptr [r15], 0
jz short loc_1A5E4
mov byte ptr [r14], 0
loc_1A5D6:
push 0FFFFFFFFFFFFFFFFh
pop rbp
loc_1A5D9:
mov eax, ebp
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_1A5E4:
mov [r15], r12d
mov byte ptr [r14+rbx-1], 0
test rax, rax
setz cl
cmp rax, r14
setz dl
xor ebp, ebp
or dl, cl
jnz short loc_1A5D9
dec rbx
mov byte ptr [r14], 0
mov rdi, r14
mov rsi, rax
mov rdx, rbx
call _strncat
jmp short loc_1A5D9
|
long long nglog::posix_strerror_r(nglog *this, _BYTE *a2, char *a3)
{
int *v4; // r15
int v5; // r12d
long long v6; // rax
unsigned int v7; // ebp
if ( a3 == 0LL || a2 == 0LL )
{
*(_DWORD *)__errno_location(this, a2) = 22;
return (unsigned int)-1;
}
*a2 = 0;
v4 = (int *)__errno_location(this, a2);
v5 = *v4;
*v4 = 0;
v6 = strerror_r((unsigned int)this, a2, a3);
if ( *v4 )
{
*a2 = 0;
return (unsigned int)-1;
}
*v4 = v5;
a3[(_QWORD)a2 - 1] = 0;
v7 = 0;
if ( v6 != 0 && v6 != (_QWORD)a2 )
{
*a2 = 0;
strncat(a2, v6, a3 - 1);
}
return v7;
}
|
posix_strerror_r:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
TEST RSI,RSI
SETNZ AL
TEST RDX,RDX
SETNZ CL
TEST AL,CL
JNZ 0x0011a5a6
CALL 0x00108050
MOV dword ptr [RAX],0x16
JMP 0x0011a5d6
LAB_0011a5a6:
MOV RBX,RDX
MOV R14,RSI
MOV EBP,EDI
MOV byte ptr [RSI],0x0
CALL 0x00108050
MOV R15,RAX
MOV R12D,dword ptr [RAX]
AND dword ptr [RAX],0x0
MOV EDI,EBP
MOV RSI,R14
MOV RDX,RBX
CALL 0x00108150
CMP dword ptr [R15],0x0
JZ 0x0011a5e4
MOV byte ptr [R14],0x0
LAB_0011a5d6:
PUSH -0x1
POP RBP
LAB_0011a5d9:
MOV EAX,EBP
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0011a5e4:
MOV dword ptr [R15],R12D
MOV byte ptr [R14 + RBX*0x1 + -0x1],0x0
TEST RAX,RAX
SETZ CL
CMP RAX,R14
SETZ DL
XOR EBP,EBP
OR DL,CL
JNZ 0x0011a5d9
DEC RBX
MOV byte ptr [R14],0x0
MOV RDI,R14
MOV RSI,RAX
MOV RDX,RBX
CALL 0x00108470
JMP 0x0011a5d9
|
/* nglog::posix_strerror_r(int, char*, unsigned long) */
int4 nglog::posix_strerror_r(int param_1,char *param_2,ulong param_3)
{
int iVar1;
int *piVar2;
char *__src;
if (param_2 == (char *)0x0 || param_3 == 0) {
piVar2 = __errno_location();
*piVar2 = 0x16;
}
else {
*param_2 = '\0';
piVar2 = __errno_location();
iVar1 = *piVar2;
*piVar2 = 0;
__src = strerror_r(param_1,param_2,param_3);
if (*piVar2 == 0) {
*piVar2 = iVar1;
param_2[param_3 - 1] = '\0';
if (__src == param_2 || __src == (char *)0x0) {
return 0;
}
*param_2 = '\0';
strncat(param_2,__src,param_3 - 1);
return 0;
}
*param_2 = '\0';
}
return 0xffffffff;
}
|
|
60,648
|
google::protobuf::StrCat[abi:cxx11](google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&)
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/stubs/strutil.cc
|
std::string StrCat(const AlphaNum &a, const AlphaNum &b, const AlphaNum &c,
const AlphaNum &d, const AlphaNum &e, const AlphaNum &f,
const AlphaNum &g) {
std::string result;
result.resize(a.size() + b.size() + c.size() + d.size() + e.size() +
f.size() + g.size());
char *const begin = &*result.begin();
char *out = Append4(begin, a, b, c, d);
out = Append2(out, e, f);
out = Append1(out, g);
GOOGLE_DCHECK_EQ(out, begin + result.size());
return result;
}
|
O0
|
cpp
|
google::protobuf::StrCat[abi:cxx11](google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&):
subq $0x148, %rsp # imm = 0x148
movq %rdi, 0x90(%rsp)
movq %rdi, %rax
movq %rax, 0x98(%rsp)
movq 0x158(%rsp), %rax
movq 0x150(%rsp), %rax
movq %rdi, 0x140(%rsp)
movq %rsi, 0x138(%rsp)
movq %rdx, 0x130(%rsp)
movq %rcx, 0x128(%rsp)
movq %r8, 0x120(%rsp)
movq %r9, 0x118(%rsp)
movb $0x0, 0x117(%rsp)
callq 0x13620
movq 0x138(%rsp), %rdi
callq 0x30a80
movq %rax, 0xa0(%rsp)
jmp 0x2bf6e
movq 0x130(%rsp), %rdi
callq 0x30a80
movq %rax, 0x88(%rsp)
jmp 0x2bf85
movq 0x88(%rsp), %rcx
movq 0xa0(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x78(%rsp)
movq 0x128(%rsp), %rdi
callq 0x30a80
movq %rax, 0x80(%rsp)
jmp 0x2bfb4
movq 0x80(%rsp), %rcx
movq 0x78(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x68(%rsp)
movq 0x120(%rsp), %rdi
callq 0x30a80
movq %rax, 0x70(%rsp)
jmp 0x2bfdd
movq 0x70(%rsp), %rcx
movq 0x68(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x58(%rsp)
movq 0x118(%rsp), %rdi
callq 0x30a80
movq %rax, 0x60(%rsp)
jmp 0x2c003
movq 0x60(%rsp), %rcx
movq 0x58(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x48(%rsp)
movq 0x150(%rsp), %rdi
callq 0x30a80
movq %rax, 0x50(%rsp)
jmp 0x2c029
movq 0x50(%rsp), %rcx
movq 0x48(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x38(%rsp)
movq 0x158(%rsp), %rdi
callq 0x30a80
movq %rax, 0x40(%rsp)
jmp 0x2c04f
movq 0x90(%rsp), %rdi
movq 0x40(%rsp), %rax
movq 0x38(%rsp), %rsi
addq %rax, %rsi
callq 0x13600
jmp 0x2c06b
movq 0x90(%rsp), %rdi
callq 0x133b0
movq %rax, 0xf0(%rsp)
leaq 0xf0(%rsp), %rdi
callq 0x30a90
movq %rax, 0xf8(%rsp)
movq 0xf8(%rsp), %rdi
movq 0x138(%rsp), %rsi
movq 0x130(%rsp), %rdx
movq 0x128(%rsp), %rcx
movq 0x120(%rsp), %r8
callq 0x2b770
movq %rax, 0x30(%rsp)
jmp 0x2c0c9
movq 0x30(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rdi
movq 0x118(%rsp), %rsi
movq 0x150(%rsp), %rdx
callq 0x2b150
movq %rax, 0x28(%rsp)
jmp 0x2c0fa
movq 0x28(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rdi
movq 0x158(%rsp), %rsi
callq 0x2b480
movq %rax, 0x20(%rsp)
jmp 0x2c123
movq 0x20(%rsp), %rax
movq %rax, 0xe8(%rsp)
xorl %eax, %eax
testb $0x1, %al
jne 0x2c13b
jmp 0x2c23d
movq 0x90(%rsp), %rdi
movq 0xe8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0xf8(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x147d0
movq 0x10(%rsp), %rcx
movq %rax, %rdx
movq 0x18(%rsp), %rax
addq %rdx, %rcx
movb $0x0, 0xaf(%rsp)
cmpq %rcx, %rax
jne 0x2c181
jmp 0x2c1da
leaq 0x1c0b08(%rip), %rdx # 0x1ecc90
leaq 0xb0(%rsp), %rdi
movl $0x3, %esi
movl $0x5fe, %ecx # imm = 0x5FE
callq 0x237e0
jmp 0x2c1a1
movb $0x1, 0xaf(%rsp)
leaq 0x1c0d41(%rip), %rsi # 0x1ecef1
leaq 0xb0(%rsp), %rdi
callq 0x230a0
movq %rax, 0x8(%rsp)
jmp 0x2c1c4
movq 0x8(%rsp), %rsi
leaq 0xae(%rsp), %rdi
callq 0x23250
jmp 0x2c1d8
jmp 0x2c1da
testb $0x1, 0xaf(%rsp)
jne 0x2c1e6
jmp 0x2c1f3
leaq 0xb0(%rsp), %rdi
callq 0x23820
jmp 0x2c130
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x108(%rsp)
movl %eax, 0x104(%rsp)
jmp 0x2c26c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x108(%rsp)
movl %eax, 0x104(%rsp)
testb $0x1, 0xaf(%rsp)
jne 0x2c22e
jmp 0x2c23b
leaq 0xb0(%rsp), %rdi
callq 0x23820
jmp 0x2c26c
movb $0x1, 0x117(%rsp)
testb $0x1, 0x117(%rsp)
jne 0x2c25c
movq 0x90(%rsp), %rdi
callq 0x13290
movq 0x98(%rsp), %rax
addq $0x148, %rsp # imm = 0x148
retq
movq 0x90(%rsp), %rdi
callq 0x13290
movq 0x108(%rsp), %rdi
callq 0x13750
nopw %cs:(%rax,%rax)
|
_ZN6google8protobuf6StrCatB5cxx11ERKNS0_7strings8AlphaNumES4_S4_S4_S4_S4_S4_:
sub rsp, 148h
mov [rsp+148h+var_B8], rdi
mov rax, rdi
mov [rsp+148h+var_B0], rax
mov rax, [rsp+148h+arg_8]
mov rax, [rsp+148h+arg_0]
mov [rsp+148h+var_8], rdi
mov [rsp+148h+var_10], rsi
mov [rsp+148h+var_18], rdx
mov [rsp+148h+var_20], rcx
mov [rsp+148h+var_28], r8
mov [rsp+148h+var_30], r9
mov [rsp+148h+var_31], 0
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev; std::string::basic_string(void)
mov rdi, [rsp+148h+var_10]; this
call _ZNK6google8protobuf7strings8AlphaNum4sizeEv; google::protobuf::strings::AlphaNum::size(void)
mov [rsp+148h+var_A8], rax
jmp short $+2
loc_2BF6E:
mov rdi, [rsp+148h+var_18]; this
call _ZNK6google8protobuf7strings8AlphaNum4sizeEv; google::protobuf::strings::AlphaNum::size(void)
mov [rsp+148h+var_C0], rax
jmp short $+2
loc_2BF85:
mov rcx, [rsp+148h+var_C0]
mov rax, [rsp+148h+var_A8]
add rax, rcx
mov [rsp+148h+var_D0], rax
mov rdi, [rsp+148h+var_20]; this
call _ZNK6google8protobuf7strings8AlphaNum4sizeEv; google::protobuf::strings::AlphaNum::size(void)
mov [rsp+148h+var_C8], rax
jmp short $+2
loc_2BFB4:
mov rcx, [rsp+148h+var_C8]
mov rax, [rsp+148h+var_D0]
add rax, rcx
mov [rsp+148h+var_E0], rax
mov rdi, [rsp+148h+var_28]; this
call _ZNK6google8protobuf7strings8AlphaNum4sizeEv; google::protobuf::strings::AlphaNum::size(void)
mov [rsp+148h+var_D8], rax
jmp short $+2
loc_2BFDD:
mov rcx, [rsp+148h+var_D8]
mov rax, [rsp+148h+var_E0]
add rax, rcx
mov [rsp+148h+var_F0], rax
mov rdi, [rsp+148h+var_30]; this
call _ZNK6google8protobuf7strings8AlphaNum4sizeEv; google::protobuf::strings::AlphaNum::size(void)
mov [rsp+148h+var_E8], rax
jmp short $+2
loc_2C003:
mov rcx, [rsp+148h+var_E8]
mov rax, [rsp+148h+var_F0]
add rax, rcx
mov [rsp+148h+var_100], rax
mov rdi, [rsp+148h+arg_0]; this
call _ZNK6google8protobuf7strings8AlphaNum4sizeEv; google::protobuf::strings::AlphaNum::size(void)
mov [rsp+148h+var_F8], rax
jmp short $+2
loc_2C029:
mov rcx, [rsp+148h+var_F8]
mov rax, [rsp+148h+var_100]
add rax, rcx
mov [rsp+148h+var_110], rax
mov rdi, [rsp+148h+arg_8]; this
call _ZNK6google8protobuf7strings8AlphaNum4sizeEv; google::protobuf::strings::AlphaNum::size(void)
mov [rsp+148h+var_108], rax
jmp short $+2
loc_2C04F:
mov rdi, [rsp+148h+var_B8]
mov rax, [rsp+148h+var_108]
mov rsi, [rsp+148h+var_110]
add rsi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6resizeEm; std::string::resize(ulong)
jmp short $+2
loc_2C06B:
mov rdi, [rsp+148h+var_B8]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5beginEv; std::string::begin(void)
mov [rsp+148h+var_58], rax
lea rdi, [rsp+148h+var_58]
call _ZNK9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEdeEv; __gnu_cxx::__normal_iterator<char *,std::string>::operator*(void)
mov [rsp+148h+var_50], rax
mov rdi, [rsp+148h+var_50]; this
mov rsi, [rsp+148h+var_10]; char *
mov rdx, [rsp+148h+var_18]; google::protobuf::strings::AlphaNum *
mov rcx, [rsp+148h+var_20]; google::protobuf::strings::AlphaNum *
mov r8, [rsp+148h+var_28]; google::protobuf::strings::AlphaNum *
call _ZN6google8protobufL7Append4EPcRKNS0_7strings8AlphaNumES5_S5_S5_; google::protobuf::Append4(char *,google::protobuf::strings::AlphaNum const&,google::protobuf::strings::AlphaNum const&,google::protobuf::strings::AlphaNum const&,google::protobuf::strings::AlphaNum const&)
mov [rsp+148h+var_118], rax
jmp short $+2
loc_2C0C9:
mov rax, [rsp+148h+var_118]
mov [rsp+148h+var_60], rax
mov rdi, [rsp+148h+var_60]; this
mov rsi, [rsp+148h+var_30]; char *
mov rdx, [rsp+148h+arg_0]; google::protobuf::strings::AlphaNum *
call _ZN6google8protobufL7Append2EPcRKNS0_7strings8AlphaNumES5_; google::protobuf::Append2(char *,google::protobuf::strings::AlphaNum const&,google::protobuf::strings::AlphaNum const&)
mov [rsp+148h+var_120], rax
jmp short $+2
loc_2C0FA:
mov rax, [rsp+148h+var_120]
mov [rsp+148h+var_60], rax
mov rdi, [rsp+148h+var_60]; this
mov rsi, [rsp+148h+arg_8]; char *
call _ZN6google8protobufL7Append1EPcRKNS0_7strings8AlphaNumE; google::protobuf::Append1(char *,google::protobuf::strings::AlphaNum const&)
mov [rsp+148h+var_128], rax
jmp short $+2
loc_2C123:
mov rax, [rsp+148h+var_128]
mov [rsp+148h+var_60], rax
loc_2C130:
xor eax, eax
test al, 1
jnz short loc_2C13B
jmp loc_2C23D
loc_2C13B:
mov rdi, [rsp+148h+var_B8]
mov rax, [rsp+148h+var_60]
mov [rsp+148h+var_130], rax
mov rax, [rsp+148h+var_50]
mov [rsp+148h+var_138], rax
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4sizeEv; std::string::size(void)
mov rcx, [rsp+148h+var_138]
mov rdx, rax
mov rax, [rsp+148h+var_130]
add rcx, rdx
mov [rsp+148h+var_99], 0
cmp rax, rcx
jnz short loc_2C181
jmp short loc_2C1DA
loc_2C181:
lea rdx, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/aimrt_"...
lea rdi, [rsp+148h+var_98]
mov esi, 3
mov ecx, 5FEh
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
jmp short $+2
loc_2C1A1:
mov [rsp+148h+var_99], 1
lea rsi, aCheckFailedOut; "CHECK failed: (out) == (begin + result."...
lea rdi, [rsp+148h+var_98]
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+148h+var_140], rax
jmp short $+2
loc_2C1C4:
mov rsi, [rsp+148h+var_140]
lea rdi, [rsp+148h+var_9A]
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
jmp short $+2
loc_2C1D8:
jmp short $+2
loc_2C1DA:
test [rsp+148h+var_99], 1
jnz short loc_2C1E6
jmp short loc_2C1F3
loc_2C1E6:
lea rdi, [rsp+148h+var_98]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_2C1F3:
jmp loc_2C130
mov rcx, rax
mov eax, edx
mov [rsp+arg_100], rcx
mov [rsp+arg_FC], eax
jmp short loc_2C26C
mov rcx, rax
mov eax, edx
mov [rsp+arg_100], rcx
mov [rsp+arg_FC], eax
test [rsp+arg_A7], 1
jnz short loc_2C22E
jmp short loc_2C23B
loc_2C22E:
lea rdi, [rsp+arg_A8]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_2C23B:
jmp short loc_2C26C
loc_2C23D:
mov [rsp+148h+var_31], 1
test [rsp+148h+var_31], 1
jnz short loc_2C25C
mov rdi, [rsp+148h+var_B8]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_2C25C:
mov rax, [rsp+148h+var_B0]
add rsp, 148h
retn
loc_2C26C:
mov rdi, [rsp+arg_88]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov rdi, [rsp+arg_100]
call __Unwind_Resume
|
long long google::protobuf::StrCat[abi:cxx11](
long long a1,
google::protobuf::strings::AlphaNum *a2,
google::protobuf::strings::AlphaNum *a3,
google::protobuf::strings::AlphaNum *a4,
google::protobuf::strings::AlphaNum *a5,
google::protobuf::strings::AlphaNum *a6,
google::protobuf::strings::AlphaNum *a7,
google::protobuf::strings::AlphaNum *a8)
{
const google::protobuf::strings::AlphaNum *v8; // r9
const google::protobuf::strings::AlphaNum *v9; // rcx
const google::protobuf::strings::AlphaNum *v10; // rdx
google::protobuf *v12; // [rsp+28h] [rbp-120h]
google::protobuf *v13; // [rsp+30h] [rbp-118h]
long long v14; // [rsp+38h] [rbp-110h]
long long v15; // [rsp+40h] [rbp-108h]
long long v16; // [rsp+48h] [rbp-100h]
long long v17; // [rsp+58h] [rbp-F0h]
long long v18; // [rsp+68h] [rbp-E0h]
long long v19; // [rsp+78h] [rbp-D0h]
long long v20; // [rsp+A0h] [rbp-A8h]
long long v21; // [rsp+F0h] [rbp-58h] BYREF
google::protobuf *v22; // [rsp+F8h] [rbp-50h]
char v23; // [rsp+117h] [rbp-31h]
google::protobuf::strings::AlphaNum *v24; // [rsp+118h] [rbp-30h]
google::protobuf::strings::AlphaNum *v25; // [rsp+120h] [rbp-28h]
google::protobuf::strings::AlphaNum *v26; // [rsp+128h] [rbp-20h]
google::protobuf::strings::AlphaNum *v27; // [rsp+130h] [rbp-18h]
google::protobuf::strings::AlphaNum *v28; // [rsp+138h] [rbp-10h]
long long v29; // [rsp+140h] [rbp-8h]
v29 = a1;
v28 = a2;
v27 = a3;
v26 = a4;
v25 = a5;
v24 = a6;
v23 = 0;
std::string::basic_string(a1);
v20 = google::protobuf::strings::AlphaNum::size(a2);
v19 = google::protobuf::strings::AlphaNum::size(v27) + v20;
v18 = google::protobuf::strings::AlphaNum::size(v26) + v19;
v17 = google::protobuf::strings::AlphaNum::size(v25) + v18;
v16 = google::protobuf::strings::AlphaNum::size(v24) + v17;
v14 = google::protobuf::strings::AlphaNum::size(a7) + v16;
v15 = google::protobuf::strings::AlphaNum::size(a8);
std::string::resize(a1, v15 + v14);
v21 = std::string::begin(a1);
v22 = (google::protobuf *)__gnu_cxx::__normal_iterator<char *,std::string>::operator*(&v21);
v13 = google::protobuf::Append4(v22, v28, v27, v26, v25, v8);
v12 = google::protobuf::Append2(v13, v24, a7, v9);
google::protobuf::Append1(v12, a8, v10);
return a1;
}
|
StrCat[abi:cxx11]:
SUB RSP,0x148
MOV qword ptr [RSP + 0x90],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x98],RAX
MOV RAX,qword ptr [RSP + 0x158]
MOV RAX,qword ptr [RSP + 0x150]
MOV qword ptr [RSP + 0x140],RDI
MOV qword ptr [RSP + 0x138],RSI
MOV qword ptr [RSP + 0x130],RDX
MOV qword ptr [RSP + 0x128],RCX
MOV qword ptr [RSP + 0x120],R8
MOV qword ptr [RSP + 0x118],R9
MOV byte ptr [RSP + 0x117],0x0
CALL 0x00113620
MOV RDI,qword ptr [RSP + 0x138]
LAB_0012bf5f:
CALL 0x00130a80
MOV qword ptr [RSP + 0xa0],RAX
JMP 0x0012bf6e
LAB_0012bf6e:
MOV RDI,qword ptr [RSP + 0x130]
CALL 0x00130a80
MOV qword ptr [RSP + 0x88],RAX
JMP 0x0012bf85
LAB_0012bf85:
MOV RCX,qword ptr [RSP + 0x88]
MOV RAX,qword ptr [RSP + 0xa0]
ADD RAX,RCX
MOV qword ptr [RSP + 0x78],RAX
MOV RDI,qword ptr [RSP + 0x128]
CALL 0x00130a80
MOV qword ptr [RSP + 0x80],RAX
JMP 0x0012bfb4
LAB_0012bfb4:
MOV RCX,qword ptr [RSP + 0x80]
MOV RAX,qword ptr [RSP + 0x78]
ADD RAX,RCX
MOV qword ptr [RSP + 0x68],RAX
MOV RDI,qword ptr [RSP + 0x120]
CALL 0x00130a80
MOV qword ptr [RSP + 0x70],RAX
JMP 0x0012bfdd
LAB_0012bfdd:
MOV RCX,qword ptr [RSP + 0x70]
MOV RAX,qword ptr [RSP + 0x68]
ADD RAX,RCX
MOV qword ptr [RSP + 0x58],RAX
MOV RDI,qword ptr [RSP + 0x118]
CALL 0x00130a80
MOV qword ptr [RSP + 0x60],RAX
JMP 0x0012c003
LAB_0012c003:
MOV RCX,qword ptr [RSP + 0x60]
MOV RAX,qword ptr [RSP + 0x58]
ADD RAX,RCX
MOV qword ptr [RSP + 0x48],RAX
MOV RDI,qword ptr [RSP + 0x150]
CALL 0x00130a80
MOV qword ptr [RSP + 0x50],RAX
JMP 0x0012c029
LAB_0012c029:
MOV RCX,qword ptr [RSP + 0x50]
MOV RAX,qword ptr [RSP + 0x48]
ADD RAX,RCX
MOV qword ptr [RSP + 0x38],RAX
MOV RDI,qword ptr [RSP + 0x158]
CALL 0x00130a80
MOV qword ptr [RSP + 0x40],RAX
JMP 0x0012c04f
LAB_0012c04f:
MOV RDI,qword ptr [RSP + 0x90]
MOV RAX,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x38]
ADD RSI,RAX
CALL 0x00113600
JMP 0x0012c06b
LAB_0012c06b:
MOV RDI,qword ptr [RSP + 0x90]
CALL 0x001133b0
MOV qword ptr [RSP + 0xf0],RAX
LEA RDI,[RSP + 0xf0]
CALL 0x00130a90
MOV qword ptr [RSP + 0xf8],RAX
MOV RDI,qword ptr [RSP + 0xf8]
MOV RSI,qword ptr [RSP + 0x138]
MOV RDX,qword ptr [RSP + 0x130]
MOV RCX,qword ptr [RSP + 0x128]
MOV R8,qword ptr [RSP + 0x120]
CALL 0x0012b770
MOV qword ptr [RSP + 0x30],RAX
JMP 0x0012c0c9
LAB_0012c0c9:
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0xe8],RAX
MOV RDI,qword ptr [RSP + 0xe8]
MOV RSI,qword ptr [RSP + 0x118]
MOV RDX,qword ptr [RSP + 0x150]
CALL 0x0012b150
MOV qword ptr [RSP + 0x28],RAX
JMP 0x0012c0fa
LAB_0012c0fa:
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0xe8],RAX
MOV RDI,qword ptr [RSP + 0xe8]
MOV RSI,qword ptr [RSP + 0x158]
CALL 0x0012b480
MOV qword ptr [RSP + 0x20],RAX
JMP 0x0012c123
LAB_0012c123:
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0xe8],RAX
LAB_0012c130:
XOR EAX,EAX
TEST AL,0x1
JNZ 0x0012c13b
JMP 0x0012c23d
LAB_0012c13b:
MOV RDI,qword ptr [RSP + 0x90]
MOV RAX,qword ptr [RSP + 0xe8]
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [RSP + 0xf8]
MOV qword ptr [RSP + 0x10],RAX
CALL 0x001147d0
MOV RCX,qword ptr [RSP + 0x10]
MOV RDX,RAX
MOV RAX,qword ptr [RSP + 0x18]
ADD RCX,RDX
MOV byte ptr [RSP + 0xaf],0x0
CMP RAX,RCX
JNZ 0x0012c181
JMP 0x0012c1da
LAB_0012c181:
LEA RDX,[0x2ecc90]
LEA RDI,[RSP + 0xb0]
MOV ESI,0x3
MOV ECX,0x5fe
CALL 0x001237e0
JMP 0x0012c1a1
LAB_0012c1a1:
MOV byte ptr [RSP + 0xaf],0x1
LAB_0012c1a9:
LEA RSI,[0x2ecef1]
LEA RDI,[RSP + 0xb0]
CALL 0x001230a0
MOV qword ptr [RSP + 0x8],RAX
JMP 0x0012c1c4
LAB_0012c1c4:
MOV RSI,qword ptr [RSP + 0x8]
LEA RDI,[RSP + 0xae]
CALL 0x00123250
LAB_0012c1d6:
JMP 0x0012c1d8
LAB_0012c1d8:
JMP 0x0012c1da
LAB_0012c1da:
TEST byte ptr [RSP + 0xaf],0x1
JNZ 0x0012c1e6
JMP 0x0012c1f3
LAB_0012c1e6:
LEA RDI,[RSP + 0xb0]
CALL 0x00123820
LAB_0012c1f3:
JMP 0x0012c130
LAB_0012c23d:
MOV byte ptr [RSP + 0x117],0x1
TEST byte ptr [RSP + 0x117],0x1
JNZ 0x0012c25c
MOV RDI,qword ptr [RSP + 0x90]
CALL 0x00113290
LAB_0012c25c:
MOV RAX,qword ptr [RSP + 0x98]
ADD RSP,0x148
RET
|
/* WARNING: Removing unreachable block (ram,0x0012c13b) */
/* WARNING: Removing unreachable block (ram,0x0012c181) */
/* WARNING: Removing unreachable block (ram,0x0012c17f) */
/* WARNING: Removing unreachable block (ram,0x0012c1da) */
/* WARNING: Removing unreachable block (ram,0x0012c1e6) */
/* WARNING: Removing unreachable block (ram,0x0012c1e4) */
/* WARNING: Removing unreachable block (ram,0x0012c1f3) */
/* WARNING: Removing unreachable block (ram,0x0012c24f) */
/* google::protobuf::StrCat[abi:cxx11](google::protobuf::strings::AlphaNum const&,
google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&,
google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&,
google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&) */
protobuf * __thiscall
google::protobuf::StrCat_abi_cxx11_
(protobuf *this,AlphaNum *param_1,AlphaNum *param_2,AlphaNum *param_3,AlphaNum *param_4,
AlphaNum *param_5,AlphaNum *param_6,AlphaNum *param_7)
{
char *pcVar1;
int8 local_58;
char *local_50;
int1 local_31;
AlphaNum *local_30;
AlphaNum *local_28;
AlphaNum *local_20;
AlphaNum *local_18;
AlphaNum *local_10;
protobuf *local_8;
local_31 = 0;
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
local_8 = this;
std::__cxx11::string::string((string *)this);
/* try { // try from 0012bf5f to 0012c19e has its CatchHandler @ 0012c1f8 */
strings::AlphaNum::size(local_10);
strings::AlphaNum::size(local_18);
strings::AlphaNum::size(local_20);
strings::AlphaNum::size(local_28);
strings::AlphaNum::size(local_30);
strings::AlphaNum::size(param_6);
strings::AlphaNum::size(param_7);
std::__cxx11::string::resize((ulong)this);
local_58 = std::__cxx11::string::begin();
local_50 = (char *)__gnu_cxx::__normal_iterator<char*,std::__cxx11::string>::operator*
((__normal_iterator<char*,std::__cxx11::string> *)&local_58);
pcVar1 = (char *)Append4(local_50,local_10,local_18,local_20,local_28);
pcVar1 = (char *)Append2(pcVar1,local_30,param_6);
Append1(pcVar1,param_7);
return this;
}
|
|
60,649
|
google::protobuf::StrCat[abi:cxx11](google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&)
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/stubs/strutil.cc
|
std::string StrCat(const AlphaNum &a, const AlphaNum &b, const AlphaNum &c,
const AlphaNum &d, const AlphaNum &e, const AlphaNum &f,
const AlphaNum &g) {
std::string result;
result.resize(a.size() + b.size() + c.size() + d.size() + e.size() +
f.size() + g.size());
char *const begin = &*result.begin();
char *out = Append4(begin, a, b, c, d);
out = Append2(out, e, f);
out = Append1(out, g);
GOOGLE_DCHECK_EQ(out, begin + result.size());
return result;
}
|
O3
|
cpp
|
google::protobuf::StrCat[abi:cxx11](google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
movq 0x48(%rsp), %rax
movq 0x40(%rsp), %rcx
leaq 0x10(%rdi), %rdx
movq %rdx, (%rsp)
movq %rdx, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%r13), %rsi
addq 0x8(%rbp), %rsi
addq 0x8(%r12), %rsi
addq 0x8(%r8), %rsi
addq 0x8(%r9), %rsi
addq 0x8(%rcx), %rsi
addq 0x8(%rax), %rsi
xorl %edx, %edx
callq 0xf0f0
movq (%rbx), %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
callq 0x19a70
movq %rax, %r15
movq 0x8(%r14), %rdx
testq %rdx, %rdx
je 0x19cf7
movq (%r14), %rsi
movq %r15, %rdi
callq 0xf2f0
addq 0x8(%r14), %r15
movq 0x40(%rsp), %r14
movq 0x8(%r14), %rdx
testq %rdx, %rdx
je 0x19d14
movq (%r14), %rsi
movq %r15, %rdi
callq 0xf2f0
addq 0x8(%r14), %r15
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rdx
testq %rdx, %rdx
je 0x19d2d
movq (%rax), %rsi
movq %r15, %rdi
callq 0xf2f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x19d50
callq 0xf330
movq %r14, %rdi
callq 0xf570
|
_ZN6google8protobuf6StrCatB5cxx11ERKNS0_7strings8AlphaNumES4_S4_S4_S4_S4_S4_:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, r9
mov r15, r8
mov r12, rcx
mov r13, rdx
mov rbp, rsi
mov rbx, rdi
mov rax, [rsp+38h+arg_8]
mov rcx, [rsp+38h+arg_0]
lea rdx, [rdi+10h]
mov [rsp+38h+var_38], rdx
mov [rdi], rdx
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
mov rsi, [r13+8]
add rsi, [rbp+8]
add rsi, [r12+8]
add rsi, [r8+8]
add rsi, [r9+8]
add rsi, [rcx+8]
add rsi, [rax+8]
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6resizeEmc; std::string::resize(ulong,char)
mov rdi, [rbx]
mov rsi, rbp
mov rdx, r13
mov rcx, r12
mov r8, r15
call _ZN6google8protobufL7Append4EPcRKNS0_7strings8AlphaNumES5_S5_S5_; google::protobuf::Append4(char *,google::protobuf::strings::AlphaNum const&,google::protobuf::strings::AlphaNum const&,google::protobuf::strings::AlphaNum const&,google::protobuf::strings::AlphaNum const&)
mov r15, rax
mov rdx, [r14+8]
test rdx, rdx
jz short loc_19CF7
mov rsi, [r14]
mov rdi, r15
call _memcpy
add r15, [r14+8]
loc_19CF7:
mov r14, [rsp+38h+arg_0]
mov rdx, [r14+8]
test rdx, rdx
jz short loc_19D14
mov rsi, [r14]
mov rdi, r15
call _memcpy
add r15, [r14+8]
loc_19D14:
mov rax, [rsp+38h+arg_8]
mov rdx, [rax+8]
test rdx, rdx
jz short loc_19D2D
mov rsi, [rax]
mov rdi, r15
call _memcpy
loc_19D2D:
mov rax, rbx
add rsp, 8
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_19D50
call __ZdlPv; operator delete(void *)
loc_19D50:
mov rdi, r14
call __Unwind_Resume
|
long long google::protobuf::StrCat[abi:cxx11](
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
long long a7,
long long a8)
{
long long v12; // rax
long long v13; // r15
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
std::string::resize(
a1,
*(_QWORD *)(a8 + 8)
+ *(_QWORD *)(a7 + 8)
+ *(_QWORD *)(a6 + 8)
+ *(_QWORD *)(a5 + 8)
+ *(_QWORD *)(a4 + 8)
+ *(_QWORD *)(a2 + 8)
+ *(_QWORD *)(a3 + 8),
0LL);
v12 = google::protobuf::Append4(*(_QWORD *)a1, a2, a3, a4, a5);
v13 = v12;
if ( *(_QWORD *)(a6 + 8) )
{
memcpy(v12);
v13 += *(_QWORD *)(a6 + 8);
}
if ( *(_QWORD *)(a7 + 8) )
{
memcpy(v13);
v13 += *(_QWORD *)(a7 + 8);
}
if ( *(_QWORD *)(a8 + 8) )
memcpy(v13);
return a1;
}
|
StrCat[abi:cxx11]:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,R9
MOV R15,R8
MOV R12,RCX
MOV R13,RDX
MOV RBP,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RSP + 0x48]
MOV RCX,qword ptr [RSP + 0x40]
LEA RDX,[RDI + 0x10]
MOV qword ptr [RSP],RDX
MOV qword ptr [RDI],RDX
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
MOV RSI,qword ptr [R13 + 0x8]
ADD RSI,qword ptr [RBP + 0x8]
ADD RSI,qword ptr [R12 + 0x8]
ADD RSI,qword ptr [R8 + 0x8]
ADD RSI,qword ptr [R9 + 0x8]
ADD RSI,qword ptr [RCX + 0x8]
ADD RSI,qword ptr [RAX + 0x8]
LAB_00119cc1:
XOR EDX,EDX
CALL 0x0010f0f0
LAB_00119cc8:
MOV RDI,qword ptr [RBX]
MOV RSI,RBP
MOV RDX,R13
MOV RCX,R12
MOV R8,R15
CALL 0x00119a70
MOV R15,RAX
MOV RDX,qword ptr [R14 + 0x8]
TEST RDX,RDX
JZ 0x00119cf7
MOV RSI,qword ptr [R14]
MOV RDI,R15
CALL 0x0010f2f0
ADD R15,qword ptr [R14 + 0x8]
LAB_00119cf7:
MOV R14,qword ptr [RSP + 0x40]
MOV RDX,qword ptr [R14 + 0x8]
TEST RDX,RDX
JZ 0x00119d14
MOV RSI,qword ptr [R14]
MOV RDI,R15
CALL 0x0010f2f0
ADD R15,qword ptr [R14 + 0x8]
LAB_00119d14:
MOV RAX,qword ptr [RSP + 0x48]
MOV RDX,qword ptr [RAX + 0x8]
TEST RDX,RDX
JZ 0x00119d2d
MOV RSI,qword ptr [RAX]
MOV RDI,R15
CALL 0x0010f2f0
LAB_00119d2d:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* google::protobuf::StrCat[abi:cxx11](google::protobuf::strings::AlphaNum const&,
google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&,
google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&,
google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&) */
protobuf * __thiscall
google::protobuf::StrCat_abi_cxx11_
(protobuf *this,AlphaNum *param_1,AlphaNum *param_2,AlphaNum *param_3,AlphaNum *param_4,
AlphaNum *param_5,AlphaNum *param_6,AlphaNum *param_7)
{
void *__dest;
*(protobuf **)this = this + 0x10;
*(int8 *)(this + 8) = 0;
this[0x10] = (protobuf)0x0;
/* try { // try from 00119cc1 to 00119cc7 has its CatchHandler @ 00119d3f */
std::__cxx11::string::resize
((ulong)this,
(char)*(int8 *)(param_2 + 8) + (char)*(int8 *)(param_1 + 8) +
(char)*(int8 *)(param_3 + 8) + (char)*(int8 *)(param_4 + 8) +
(char)*(int8 *)(param_5 + 8) + (char)*(int8 *)(param_6 + 8) +
(char)*(int8 *)(param_7 + 8));
__dest = (void *)Append4(*(char **)this,param_1,param_2,param_3,param_4);
if (*(size_t *)(param_5 + 8) != 0) {
memcpy(__dest,*(void **)param_5,*(size_t *)(param_5 + 8));
__dest = (void *)((long)__dest + *(long *)(param_5 + 8));
}
if (*(size_t *)(param_6 + 8) != 0) {
memcpy(__dest,*(void **)param_6,*(size_t *)(param_6 + 8));
__dest = (void *)((long)__dest + *(long *)(param_6 + 8));
}
if (*(size_t *)(param_7 + 8) != 0) {
memcpy(__dest,*(void **)param_7,*(size_t *)(param_7 + 8));
}
return this;
}
|
|
60,650
|
js_map_write
|
bluesky950520[P]quickjs/quickjs.c
|
static int js_map_write(BCWriterState *s, struct JSMapState *map_state,
int magic)
{
struct list_head *el;
JSMapRecord *mr;
bc_put_leb128(s, map_state ? map_state->record_count : 0);
if (map_state) {
list_for_each(el, &map_state->records) {
mr = list_entry(el, JSMapRecord, link);
if (JS_WriteObjectRec(s, mr->key))
return -1;
// mr->value is always JS_UNDEFINED for sets
if (!(magic & MAGIC_SET))
if (JS_WriteObjectRec(s, mr->value))
return -1;
}
}
return 0;
}
|
O1
|
c
|
js_map_write:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0x45a20
movl %edx, %ebp
movq %rsi, %r14
movl 0x18(%rsi), %esi
leaq 0x8(%rbx), %rdi
callq 0x45854
movq 0x10(%r14), %r12
addq $0x8, %r14
cmpq %r14, %r12
je 0x45a1b
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
movq 0x20(%r12), %rsi
movq 0x28(%r12), %rdx
movq %rbx, %rdi
callq 0x31a6a
testl %eax, %eax
jne 0x45a31
testb $0x1, %bpl
jne 0x45a11
movq 0x30(%r12), %rsi
movq 0x38(%r12), %rdx
movq %rbx, %rdi
callq 0x31a6a
testl %eax, %eax
jne 0x45a31
movq 0x8(%r12), %r12
cmpq %r14, %r12
jne 0x459df
xorl %r15d, %r15d
jmp 0x45a31
addq $0x8, %rbx
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1b4d0
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
js_map_write:
push rbp
push r15
push r14
push r12
push rbx
mov rbx, rdi
test rsi, rsi
jz short loc_45A20
mov ebp, edx
mov r14, rsi
mov esi, [rsi+18h]
lea rdi, [rbx+8]
call dbuf_put_leb128
mov r12, [r14+10h]
add r14, 8
cmp r12, r14
jz short loc_45A1B
mov r15d, 0FFFFFFFFh
loc_459DF:
mov rsi, [r12+20h]
mov rdx, [r12+28h]
mov rdi, rbx
call JS_WriteObjectRec
test eax, eax
jnz short loc_45A31
test bpl, 1
jnz short loc_45A11
mov rsi, [r12+30h]
mov rdx, [r12+38h]
mov rdi, rbx
call JS_WriteObjectRec
test eax, eax
jnz short loc_45A31
loc_45A11:
mov r12, [r12+8]
cmp r12, r14
jnz short loc_459DF
loc_45A1B:
xor r15d, r15d
jmp short loc_45A31
loc_45A20:
add rbx, 8
xor r15d, r15d
mov rdi, rbx
xor esi, esi
call dbuf_putc
loc_45A31:
mov eax, r15d
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
long long js_map_write(
long long *a1,
long long a2,
char a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11)
{
long long v12; // rcx
long long v13; // r8
long long v14; // r9
__m128 v15; // xmm4
__m128 v16; // xmm5
_QWORD *v17; // r12
unsigned int v18; // r15d
if ( a2 )
{
dbuf_put_leb128(a1 + 1, *(_DWORD *)(a2 + 24));
v17 = *(_QWORD **)(a2 + 16);
if ( v17 == (_QWORD *)(a2 + 8) )
{
return 0;
}
else
{
v18 = -1;
while ( !(unsigned int)JS_WriteObjectRec(a1, v17[4], v17[5], v12, v13, v14, a4, a5, a6, a7, v15, v16, a10, a11)
&& ((a3 & 1) != 0
|| !(unsigned int)JS_WriteObjectRec(a1, v17[6], v17[7], v12, v13, v14, a4, a5, a6, a7, v15, v16, a10, a11)) )
{
v17 = (_QWORD *)v17[1];
if ( v17 == (_QWORD *)(a2 + 8) )
return 0;
}
}
}
else
{
v18 = 0;
dbuf_putc(a1 + 1, 0);
}
return v18;
}
| |||
60,651
|
js_map_write
|
bluesky950520[P]quickjs/quickjs.c
|
static int js_map_write(BCWriterState *s, struct JSMapState *map_state,
int magic)
{
struct list_head *el;
JSMapRecord *mr;
bc_put_leb128(s, map_state ? map_state->record_count : 0);
if (map_state) {
list_for_each(el, &map_state->records) {
mr = list_entry(el, JSMapRecord, link);
if (JS_WriteObjectRec(s, mr->key))
return -1;
// mr->value is always JS_UNDEFINED for sets
if (!(magic & MAGIC_SET))
if (JS_WriteObjectRec(s, mr->value))
return -1;
}
}
return 0;
}
|
O2
|
c
|
js_map_write:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0x3d12d
movl %edx, %ebp
movq %rsi, %r15
movl 0x18(%rsi), %esi
leaq 0x8(%rbx), %rdi
callq 0x3cf8f
leaq 0x8(%r15), %r12
addq $0x10, %r15
pushq $-0x1
popq %r14
movq (%r15), %r15
cmpq %r12, %r15
je 0x3d140
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
movq %rbx, %rdi
callq 0x29e39
testl %eax, %eax
jne 0x3d143
testb $0x1, %bpl
jne 0x3d127
movq 0x30(%r15), %rsi
movq 0x38(%r15), %rdx
movq %rbx, %rdi
callq 0x29e39
testl %eax, %eax
jne 0x3d143
addq $0x8, %r15
jmp 0x3d0f1
addq $0x8, %rbx
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3cf8f
jmp 0x3d143
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
js_map_write:
push rbp
push r15
push r14
push r12
push rbx
mov rbx, rdi
test rsi, rsi
jz short loc_3D12D
mov ebp, edx
mov r15, rsi
mov esi, [rsi+18h]
lea rdi, [rbx+8]
call dbuf_put_leb128
lea r12, [r15+8]
add r15, 10h
push 0FFFFFFFFFFFFFFFFh
pop r14
loc_3D0F1:
mov r15, [r15]
cmp r15, r12
jz short loc_3D140
mov rsi, [r15+20h]
mov rdx, [r15+28h]
mov rdi, rbx
call JS_WriteObjectRec
test eax, eax
jnz short loc_3D143
test bpl, 1
jnz short loc_3D127
mov rsi, [r15+30h]
mov rdx, [r15+38h]
mov rdi, rbx
call JS_WriteObjectRec
test eax, eax
jnz short loc_3D143
loc_3D127:
add r15, 8
jmp short loc_3D0F1
loc_3D12D:
add rbx, 8
xor r14d, r14d
mov rdi, rbx
xor esi, esi
call dbuf_put_leb128
jmp short loc_3D143
loc_3D140:
xor r14d, r14d
loc_3D143:
mov eax, r14d
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
long long js_map_write(
long long a1,
long long a2,
char a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11)
{
long long v12; // rcx
long long v13; // r8
long long v14; // r9
__m128 v15; // xmm4
__m128 v16; // xmm5
long long **v17; // r15
unsigned int v18; // r14d
long long *v19; // r15
if ( a2 )
{
dbuf_put_leb128((_QWORD *)(a1 + 8), *(_DWORD *)(a2 + 24));
v17 = (long long **)(a2 + 16);
v18 = -1;
while ( 1 )
{
v19 = *v17;
if ( v19 == (long long *)(a2 + 8) )
break;
if ( (unsigned int)JS_WriteObjectRec(a1, v19[4], v19[5], v12, v13, v14, a4, a5, a6, a7, v15, v16, a10, a11)
|| (a3 & 1) == 0
&& (unsigned int)JS_WriteObjectRec(a1, v19[6], v19[7], v12, v13, v14, a4, a5, a6, a7, v15, v16, a10, a11) )
{
return v18;
}
v17 = (long long **)(v19 + 1);
}
return 0;
}
else
{
v18 = 0;
dbuf_put_leb128((_QWORD *)(a1 + 8), 0);
}
return v18;
}
|
js_map_write:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RBX,RDI
TEST RSI,RSI
JZ 0x0013d12d
MOV EBP,EDX
MOV R15,RSI
MOV ESI,dword ptr [RSI + 0x18]
LEA RDI,[RBX + 0x8]
CALL 0x0013cf8f
LEA R12,[R15 + 0x8]
ADD R15,0x10
PUSH -0x1
POP R14
LAB_0013d0f1:
MOV R15,qword ptr [R15]
CMP R15,R12
JZ 0x0013d140
MOV RSI,qword ptr [R15 + 0x20]
MOV RDX,qword ptr [R15 + 0x28]
MOV RDI,RBX
CALL 0x00129e39
TEST EAX,EAX
JNZ 0x0013d143
TEST BPL,0x1
JNZ 0x0013d127
MOV RSI,qword ptr [R15 + 0x30]
MOV RDX,qword ptr [R15 + 0x38]
MOV RDI,RBX
CALL 0x00129e39
TEST EAX,EAX
JNZ 0x0013d143
LAB_0013d127:
ADD R15,0x8
JMP 0x0013d0f1
LAB_0013d12d:
ADD RBX,0x8
XOR R14D,R14D
MOV RDI,RBX
XOR ESI,ESI
CALL 0x0013cf8f
JMP 0x0013d143
LAB_0013d140:
XOR R14D,R14D
LAB_0013d143:
MOV EAX,R14D
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
int4 js_map_write(long param_1,long param_2,ulong param_3)
{
long lVar1;
int iVar2;
long *plVar3;
if (param_2 == 0) {
dbuf_put_leb128(param_1 + 8,0);
}
else {
dbuf_put_leb128(param_1 + 8,*(int4 *)(param_2 + 0x18));
plVar3 = (long *)(param_2 + 0x10);
while (lVar1 = *plVar3, lVar1 != param_2 + 8) {
iVar2 = JS_WriteObjectRec(param_1,*(int8 *)(lVar1 + 0x20),*(int8 *)(lVar1 + 0x28))
;
if (iVar2 != 0) {
return 0xffffffff;
}
if (((param_3 & 1) == 0) &&
(iVar2 = JS_WriteObjectRec(param_1,*(int8 *)(lVar1 + 0x30),
*(int8 *)(lVar1 + 0x38)), iVar2 != 0)) {
return 0xffffffff;
}
plVar3 = (long *)(lVar1 + 8);
}
}
return 0;
}
|
|
60,652
|
common_speculative_init(llama_context*)
|
monkey531[P]llama/common/speculative.cpp
|
struct common_speculative * common_speculative_init(
struct llama_context * ctx_dft) {
auto * result = new common_speculative {
/* .ctx = */ ctx_dft,
/* .smpl = */ nullptr,
/* .batch = */ llama_batch_init(llama_n_batch(ctx_dft), 0, 1),
/* .prompt = */ {},
};
// TODO: optimize or pass from outside?
#if 0
{
common_params_sampling params;
params.no_perf = false;
params.top_k = 40;
params.top_p = 0.9;
params.samplers = {
COMMON_SAMPLER_TYPE_TOP_K,
COMMON_SAMPLER_TYPE_TOP_P,
COMMON_SAMPLER_TYPE_INFILL,
};
result->smpl = common_sampler_init(llama_get_model(ctx_dft), params);
}
#else
{
common_params_sampling params;
params.no_perf = false;
params.top_k = 10;
params.samplers = {
COMMON_SAMPLER_TYPE_TOP_K,
};
result->smpl = common_sampler_init(llama_get_model(ctx_dft), params);
}
#endif
return result;
}
|
O1
|
cpp
|
common_speculative_init(llama_context*):
pushq %r15
pushq %r14
pushq %rbx
subq $0x140, %rsp # imm = 0x140
movq %rdi, %r14
movl $0x60, %edi
callq 0x1b8c0
movq %rax, %rbx
movq %r14, (%rax)
movq $0x0, 0x8(%rax)
movq %r14, %rdi
callq 0x1b200
movq %rbx, %rdi
addq $0x10, %rdi
movl %eax, %esi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x1b480
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rbx)
movq $0x0, 0x58(%rbx)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x220ca
movb $0x0, 0x61(%r15)
movl $0xa, 0x10(%r15)
leaq 0x8(%rsp), %rdx
movl $0x2, -0x4(%rdx)
leaq 0x88(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0xd1d26
movq %r14, %rdi
callq 0x1b7b0
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0xce5bd
movq %rax, 0x8(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x227ee
movq %rbx, %rax
addq $0x140, %rsp # imm = 0x140
popq %rbx
popq %r14
popq %r15
retq
jmp 0xd0fd8
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x227ee
jmp 0xd0ff7
movq %rax, %r14
movl $0x60, %esi
movq %rbx, %rdi
callq 0x1b8f0
movq %r14, %rdi
callq 0x1bfd0
|
_Z23common_speculative_initP13llama_context:
push r15
push r14
push rbx
sub rsp, 140h
mov r14, rdi
mov edi, 60h ; '`'; unsigned __int64
call __Znwm; operator new(ulong)
mov rbx, rax
mov [rax], r14
mov qword ptr [rax+8], 0
mov rdi, r14
call _llama_n_batch
mov rdi, rbx
add rdi, 10h
mov esi, eax
xor edx, edx
mov ecx, 1
call _llama_batch_init
xorps xmm0, xmm0
movups xmmword ptr [rbx+48h], xmm0
mov qword ptr [rbx+58h], 0
lea r15, [rsp+158h+var_150]
mov rdi, r15; this
call _ZN22common_params_samplingC2Ev; common_params_sampling::common_params_sampling(void)
mov byte ptr [r15+61h], 0
mov dword ptr [r15+10h], 0Ah
lea rdx, [rsp+158h+var_150]
mov dword ptr [rdx-4], 2
lea rdi, [rsp+158h+var_D0]
lea rsi, [rsp+158h+var_154]
call _ZNSt6vectorI19common_sampler_typeSaIS0_EE13_M_assign_auxIPKS0_EEvT_S6_St20forward_iterator_tag; std::vector<common_sampler_type>::_M_assign_aux<common_sampler_type const*>(common_sampler_type const*,common_sampler_type const*,std::forward_iterator_tag)
mov rdi, r14
call _llama_get_model
lea rsi, [rsp+158h+var_150]
mov rdi, rax
call _Z19common_sampler_initPK11llama_modelRK22common_params_sampling; common_sampler_init(llama_model const*,common_params_sampling const&)
mov [rbx+8], rax
lea rdi, [rsp+158h+var_150]; this
call _ZN22common_params_samplingD2Ev; common_params_sampling::~common_params_sampling()
mov rax, rbx
add rsp, 140h
pop rbx
pop r14
pop r15
retn
jmp short $+2
loc_D0FD8:
mov r14, rax
lea rdi, [rsp+arg_0]; this
call _ZN22common_params_samplingD2Ev; common_params_sampling::~common_params_sampling()
jmp short loc_D0FF7
mov r14, rax
mov esi, 60h ; '`'; unsigned __int64
mov rdi, rbx; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_D0FF7:
mov rdi, r14
call __Unwind_Resume
|
long long common_speculative_init(long long a1)
{
long long v1; // rbx
unsigned int v2; // eax
long long model; // rax
int v5; // [rsp+4h] [rbp-154h] BYREF
unsigned int v6[24]; // [rsp+8h] [rbp-150h] BYREF
char v7; // [rsp+69h] [rbp-EFh]
_BYTE v8[208]; // [rsp+88h] [rbp-D0h] BYREF
v1 = operator new(0x60uLL);
*(_QWORD *)v1 = a1;
*(_QWORD *)(v1 + 8) = 0LL;
v2 = llama_n_batch(a1);
llama_batch_init(v1 + 16, v2, 0LL, 1LL);
*(_OWORD *)(v1 + 72) = 0LL;
*(_QWORD *)(v1 + 88) = 0LL;
common_params_sampling::common_params_sampling((common_params_sampling *)v6);
v7 = 0;
v6[4] = 10;
v5 = 2;
std::vector<common_sampler_type>::_M_assign_aux<common_sampler_type const*>(v8, &v5);
model = llama_get_model(a1);
*(_QWORD *)(v1 + 8) = common_sampler_init(model, v6);
common_params_sampling::~common_params_sampling((common_params_sampling *)v6);
return v1;
}
|
common_speculative_init:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x140
MOV R14,RDI
MOV EDI,0x60
CALL 0x0011b8c0
MOV RBX,RAX
MOV qword ptr [RAX],R14
MOV qword ptr [RAX + 0x8],0x0
LAB_001d0f3f:
MOV RDI,R14
CALL 0x0011b200
MOV RDI,RBX
ADD RDI,0x10
MOV ESI,EAX
XOR EDX,EDX
MOV ECX,0x1
CALL 0x0011b480
LAB_001d0f5c:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x48],XMM0
MOV qword ptr [RBX + 0x58],0x0
LEA R15,[RSP + 0x8]
MOV RDI,R15
CALL 0x001220ca
MOV byte ptr [R15 + 0x61],0x0
MOV dword ptr [R15 + 0x10],0xa
LEA RDX,[RSP + 0x8]
MOV dword ptr [RDX + -0x4],0x2
LEA RDI,[RSP + 0x88]
LAB_001d0f99:
LEA RSI,[RSP + 0x4]
CALL 0x001d1d26
LAB_001d0fa3:
MOV RDI,R14
CALL 0x0011b7b0
LEA RSI,[RSP + 0x8]
MOV RDI,RAX
CALL 0x001ce5bd
LAB_001d0fb8:
MOV qword ptr [RBX + 0x8],RAX
LEA RDI,[RSP + 0x8]
CALL 0x001227ee
MOV RAX,RBX
ADD RSP,0x140
POP RBX
POP R14
POP R15
RET
|
/* common_speculative_init(llama_context*) */
int8 * common_speculative_init(llama_context *param_1)
{
int4 uVar1;
int8 *puVar2;
llama_model *plVar3;
int8 uVar4;
int4 local_154;
common_params_sampling local_150 [16];
int4 local_140;
int1 local_ef;
int1 local_d0 [184];
puVar2 = (int8 *)operator_new(0x60);
*puVar2 = param_1;
puVar2[1] = 0;
/* try { // try from 001d0f3f to 001d0f5b has its CatchHandler @ 001d0fe7 */
uVar1 = llama_n_batch(param_1);
llama_batch_init(puVar2 + 2,uVar1,0,1);
puVar2[9] = 0;
puVar2[10] = 0;
puVar2[0xb] = 0;
common_params_sampling::common_params_sampling(local_150);
local_ef = 0;
local_140 = 10;
local_154 = 2;
/* try { // try from 001d0f99 to 001d0fa2 has its CatchHandler @ 001d0fd6 */
std::vector<common_sampler_type,std::allocator<common_sampler_type>>::
_M_assign_aux<common_sampler_type_const*>(local_d0,&local_154);
/* try { // try from 001d0fa3 to 001d0fb7 has its CatchHandler @ 001d0fd8 */
plVar3 = (llama_model *)llama_get_model(param_1);
uVar4 = common_sampler_init(plVar3,local_150);
puVar2[1] = uVar4;
common_params_sampling::~common_params_sampling(local_150);
return puVar2;
}
|
|
60,653
|
ftb_check_phrase_internal
|
eloqsql/storage/myisam/ft_boolean_search.c
|
static int ftb_check_phrase_internal(MYSQL_FTPARSER_PARAM *param,
const char *document, int len)
{
FT_WORD word;
MY_FTB_PHRASE_PARAM *phrase_param= param->mysql_ftparam;
const uchar *docend= (uchar*) document + len;
while (ft_simple_get_word(phrase_param->cs, (uchar**) &document, docend,
&word, FALSE))
{
param->mysql_add_word(param, (char*) word.pos, (int)word.len, 0);
if (phrase_param->match)
break;
}
return 0;
}
|
O0
|
c
|
ftb_check_phrase_internal:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x40(%rbp), %rdx
leaq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rcx
xorl %r8d, %r8d
callq 0xa36c0
cmpb $0x0, %al
je 0xa1426
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rcx
movl %ecx, %edx
xorl %ecx, %ecx
callq *%rax
movq -0x38(%rbp), %rax
cmpl $0x0, 0x20(%rax)
je 0xa1424
jmp 0xa1426
jmp 0xa13de
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nop
|
ftb_check_phrase_internal:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov rax, [rbp+var_8]
mov rax, [rax+18h]
mov [rbp+var_38], rax
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_14]
add rax, rcx
mov [rbp+var_40], rax
loc_A13DE:
mov rax, [rbp+var_38]
mov rdi, [rax+10h]
mov rdx, [rbp+var_40]
lea rsi, [rbp+var_10]
lea rcx, [rbp+var_30]
xor r8d, r8d
call ft_simple_get_word
cmp al, 0
jz short loc_A1426
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_30]
mov rcx, [rbp+var_20]
mov edx, ecx
xor ecx, ecx
call rax
mov rax, [rbp+var_38]
cmp dword ptr [rax+20h], 0
jz short loc_A1424
jmp short loc_A1426
loc_A1424:
jmp short loc_A13DE
loc_A1426:
xor eax, eax
add rsp, 40h
pop rbp
retn
|
long long ftb_check_phrase_internal(long long a1, long long a2, int a3)
{
long long v4; // [rsp+0h] [rbp-40h]
long long v5; // [rsp+8h] [rbp-38h]
long long v6; // [rsp+10h] [rbp-30h] BYREF
long long v7; // [rsp+20h] [rbp-20h]
int v8; // [rsp+2Ch] [rbp-14h]
long long v9; // [rsp+30h] [rbp-10h] BYREF
long long v10; // [rsp+38h] [rbp-8h]
v10 = a1;
v9 = a2;
v8 = a3;
v5 = *(_QWORD *)(a1 + 24);
v4 = a3 + a2;
do
{
if ( !(unsigned __int8)ft_simple_get_word(*(_QWORD *)(v5 + 16), &v9, v4, &v6, 0LL) )
break;
(*(void ( **)(long long, long long, _QWORD, _QWORD))(v10 + 8))(v10, v6, (unsigned int)v7, 0LL);
}
while ( !*(_DWORD *)(v5 + 32) );
return 0LL;
}
|
ftb_check_phrase_internal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x14]
ADD RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
LAB_001a13de:
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,qword ptr [RAX + 0x10]
MOV RDX,qword ptr [RBP + -0x40]
LEA RSI,[RBP + -0x10]
LEA RCX,[RBP + -0x30]
XOR R8D,R8D
CALL 0x001a36c0
CMP AL,0x0
JZ 0x001a1426
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x20]
MOV EDX,ECX
XOR ECX,ECX
CALL RAX
MOV RAX,qword ptr [RBP + -0x38]
CMP dword ptr [RAX + 0x20],0x0
JZ 0x001a1424
JMP 0x001a1426
LAB_001a1424:
JMP 0x001a13de
LAB_001a1426:
XOR EAX,EAX
ADD RSP,0x40
POP RBP
RET
|
int8 ftb_check_phrase_internal(long param_1,long param_2,int param_3)
{
long lVar1;
char cVar2;
int8 local_38 [2];
ulong local_28;
int local_1c;
long local_18;
long local_10;
lVar1 = *(long *)(param_1 + 0x18);
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
do {
cVar2 = ft_simple_get_word(*(int8 *)(lVar1 + 0x10),&local_18,param_2 + param_3,local_38,0)
;
if (cVar2 == '\0') {
return 0;
}
(**(code **)(local_10 + 8))(local_10,local_38[0],local_28 & 0xffffffff,0);
} while (*(int *)(lVar1 + 0x20) == 0);
return 0;
}
|
|
60,654
|
ftb_check_phrase_internal
|
eloqsql/storage/myisam/ft_boolean_search.c
|
static int ftb_check_phrase_internal(MYSQL_FTPARSER_PARAM *param,
const char *document, int len)
{
FT_WORD word;
MY_FTB_PHRASE_PARAM *phrase_param= param->mysql_ftparam;
const uchar *docend= (uchar*) document + len;
while (ft_simple_get_word(phrase_param->cs, (uchar**) &document, docend,
&word, FALSE))
{
param->mysql_add_word(param, (char*) word.pos, (int)word.len, 0);
if (phrase_param->match)
break;
}
return 0;
}
|
O3
|
c
|
ftb_check_phrase_internal:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq -0x48(%rbp), %r14
movq %rsi, (%r14)
movq 0x18(%rdi), %r13
movslq %edx, %r15
addq %rsi, %r15
leaq -0x40(%rbp), %r12
movq 0x10(%r13), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
callq 0x74b09
testb %al, %al
je 0x73a9f
movq -0x40(%rbp), %rsi
movl -0x30(%rbp), %edx
movq %rbx, %rdi
xorl %ecx, %ecx
callq *0x8(%rbx)
cmpl $0x0, 0x20(%r13)
je 0x73a70
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
ftb_check_phrase_internal:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rbx, rdi
lea r14, [rbp+var_48]
mov [r14], rsi
mov r13, [rdi+18h]
movsxd r15, edx
add r15, rsi
lea r12, [rbp+var_40]
loc_73A70:
mov rdi, [r13+10h]
mov rsi, r14
mov rdx, r15
mov rcx, r12
xor r8d, r8d
call ft_simple_get_word
test al, al
jz short loc_73A9F
mov rsi, [rbp+var_40]
mov edx, [rbp+var_30]
mov rdi, rbx
xor ecx, ecx
call qword ptr [rbx+8]
cmp dword ptr [r13+20h], 0
jz short loc_73A70
loc_73A9F:
xor eax, eax
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long ftb_check_phrase_internal(long long a1, long long a2, int a3)
{
long long v3; // r13
long long v4; // r15
long long v6; // [rsp+8h] [rbp-48h] BYREF
long long v7; // [rsp+10h] [rbp-40h] BYREF
unsigned int v8; // [rsp+20h] [rbp-30h]
v6 = a2;
v3 = *(_QWORD *)(a1 + 24);
v4 = a2 + a3;
do
{
if ( !(unsigned __int8)ft_simple_get_word(*(_QWORD *)(v3 + 16), &v6, v4, &v7, 0LL) )
break;
(*(void ( **)(long long, long long, _QWORD, _QWORD))(a1 + 8))(a1, v7, v8, 0LL);
}
while ( !*(_DWORD *)(v3 + 32) );
return 0LL;
}
|
ftb_check_phrase_internal:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
LEA R14,[RBP + -0x48]
MOV qword ptr [R14],RSI
MOV R13,qword ptr [RDI + 0x18]
MOVSXD R15,EDX
ADD R15,RSI
LEA R12,[RBP + -0x40]
LAB_00173a70:
MOV RDI,qword ptr [R13 + 0x10]
MOV RSI,R14
MOV RDX,R15
MOV RCX,R12
XOR R8D,R8D
CALL 0x00174b09
TEST AL,AL
JZ 0x00173a9f
MOV RSI,qword ptr [RBP + -0x40]
MOV EDX,dword ptr [RBP + -0x30]
MOV RDI,RBX
XOR ECX,ECX
CALL qword ptr [RBX + 0x8]
CMP dword ptr [R13 + 0x20],0x0
JZ 0x00173a70
LAB_00173a9f:
XOR EAX,EAX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 ftb_check_phrase_internal(long param_1,long param_2,int param_3)
{
long lVar1;
char cVar2;
long local_50;
int8 local_48 [2];
int4 local_38;
lVar1 = *(long *)(param_1 + 0x18);
local_50 = param_2;
do {
cVar2 = ft_simple_get_word(*(int8 *)(lVar1 + 0x10),&local_50,param_3 + param_2,local_48,0)
;
if (cVar2 == '\0') {
return 0;
}
(**(code **)(param_1 + 8))(param_1,local_48[0],local_38,0);
} while (*(int *)(lVar1 + 0x20) == 0);
return 0;
}
|
|
60,655
|
my_memmem
|
eloqsql/mysys/my_memmem.c
|
void *my_memmem(const void *haystack, size_t haystacklen,
const void *needle, size_t needlelen)
{
const unsigned char *cursor;
const unsigned char *last_possible_needle_location =
(unsigned char *)haystack + haystacklen - needlelen;
/* Easy answers */
if (needlelen > haystacklen) return(NULL);
if (needle == NULL) return(NULL);
if (haystack == NULL) return(NULL);
if (needlelen == 0) return(NULL);
if (haystacklen == 0) return(NULL);
for (cursor = haystack; cursor <= last_possible_needle_location; cursor++) {
if (memcmp(needle, cursor, needlelen) == 0) {
return((void *) cursor);
}
}
return(NULL);
}
|
O3
|
c
|
my_memmem:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
leaq (%rdi,%rsi), %r12
subq %rcx, %r12
cmpq %rsi, %rcx
seta %al
movq %rdx, %r15
testq %rdx, %rdx
sete %cl
testq %rdi, %rdi
sete %dl
orb %cl, %dl
orb %al, %dl
testq %r14, %r14
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
orb %dl, %cl
cmpq %rdi, %r12
setb %al
orb %cl, %al
jne 0xaeda1
movq %rdi, %rbx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x396c0
testl %eax, %eax
je 0xaeda3
incq %rbx
cmpq %r12, %rbx
jbe 0xaed87
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
|
my_memmem:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov r14, rcx
lea r12, [rdi+rsi]
sub r12, rcx
cmp rcx, rsi
setnbe al
mov r15, rdx
test rdx, rdx
setz cl
test rdi, rdi
setz dl
or dl, cl
or dl, al
test r14, r14
setz al
test rsi, rsi
setz cl
or cl, al
or cl, dl
cmp r12, rdi
setb al
or al, cl
jnz short loc_AEDA1
mov rbx, rdi
loc_AED87:
mov rdi, r15
mov rsi, rbx
mov rdx, r14
call _bcmp
test eax, eax
jz short loc_AEDA3
inc rbx
cmp rbx, r12
jbe short loc_AED87
loc_AEDA1:
xor ebx, ebx
loc_AEDA3:
mov rax, rbx
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
unsigned long long my_memmem(unsigned long long a1, unsigned long long a2, long long a3, unsigned long long a4)
{
unsigned long long v5; // r12
unsigned long long v7; // rbx
v5 = a1 + a2 - a4;
if ( a4 > a2 || a3 == 0 || a1 == 0 || a4 == 0 || a2 == 0 || v5 < a1 )
return 0LL;
v7 = a1;
while ( (unsigned int)bcmp(a3, v7, a4) )
{
if ( ++v7 > v5 )
return 0LL;
}
return v7;
}
|
my_memmem:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R14,RCX
LEA R12,[RDI + RSI*0x1]
SUB R12,RCX
CMP RCX,RSI
SETA AL
MOV R15,RDX
TEST RDX,RDX
SETZ CL
TEST RDI,RDI
SETZ DL
OR DL,CL
OR DL,AL
TEST R14,R14
SETZ AL
TEST RSI,RSI
SETZ CL
OR CL,AL
OR CL,DL
CMP R12,RDI
SETC AL
OR AL,CL
JNZ 0x001aeda1
MOV RBX,RDI
LAB_001aed87:
MOV RDI,R15
MOV RSI,RBX
MOV RDX,R14
CALL 0x001396c0
TEST EAX,EAX
JZ 0x001aeda3
INC RBX
CMP RBX,R12
JBE 0x001aed87
LAB_001aeda1:
XOR EBX,EBX
LAB_001aeda3:
MOV RAX,RBX
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
void * my_memmem(void *param_1,ulong param_2,void *param_3,ulong param_4)
{
int iVar1;
void *pvVar2;
pvVar2 = (void *)((long)param_1 + (param_2 - param_4));
if (param_1 <= pvVar2 &&
((param_2 != 0 && param_4 != 0) &&
((param_1 != (void *)0x0 && param_3 != (void *)0x0) && param_4 <= param_2))) {
do {
iVar1 = bcmp(param_3,param_1,param_4);
if (iVar1 == 0) {
return param_1;
}
param_1 = (void *)((long)param_1 + 1);
} while (param_1 <= pvVar2);
}
return (void *)0x0;
}
|
|
60,656
|
ma_net_write_buff
|
eloqsql/libmariadb/libmariadb/ma_net.c
|
static int ma_net_write_buff(NET *net,const char *packet, size_t len)
{
size_t left_length;
if (!len)
return 0;
if (net->max_packet > MAX_PACKET_LENGTH &&
net->compress)
left_length= (size_t)(MAX_PACKET_LENGTH - (net->write_pos - net->buff));
else
left_length=(size_t) (net->buff_end - net->write_pos);
if (len > left_length)
{
if (net->write_pos != net->buff)
{
memcpy((char*) net->write_pos,packet,left_length);
if (ma_net_real_write(net,(char*) net->buff,
(size_t)(net->write_pos - net->buff) + left_length))
return 1;
packet+=left_length;
len-=left_length;
net->write_pos= net->buff;
}
if (net->compress)
{
/* uncompressed length is stored in 3 bytes,so
packet can't be > 0xFFFFFF */
left_length= MAX_PACKET_LENGTH;
while (len > left_length)
{
if (ma_net_real_write(net, packet, left_length))
return 1;
packet+= left_length;
len-= left_length;
}
}
if (len > net->max_packet)
return(test(ma_net_real_write(net, packet, len)));
}
memcpy((char*) net->write_pos,packet,len);
net->write_pos+=len;
return 0;
}
|
O3
|
c
|
ma_net_write_buff:
xorl %eax, %eax
testq %rdx, %rdx
je 0x33aaa
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x1000000, 0x50(%rdi) # imm = 0x1000000
jb 0x33a3c
cmpb $0x0, 0x84(%rbx)
je 0x33a3c
movq 0x8(%rbx), %r12
movq 0x18(%rbx), %rdi
subq %rdi, %r12
addq $0xffffff, %r12 # imm = 0xFFFFFF
jmp 0x33a47
movq 0x10(%rbx), %r12
movq 0x18(%rbx), %rdi
subq %rdi, %r12
movq %rdx, %r15
subq %r12, %r15
jbe 0x33a8e
cmpq 0x8(%rbx), %rdi
je 0x33aab
movq %r14, %rsi
movq %r12, %rdx
callq 0x13390
movq 0x8(%rbx), %rsi
movq %r12, %rdx
subq %rsi, %rdx
addq 0x18(%rbx), %rdx
movq %rbx, %rdi
callq 0x33707
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x33aa2
addq %r12, %r14
movq 0x8(%rbx), %rax
movq %rax, 0x18(%rbx)
jmp 0x33aae
movq %rdx, %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0x13390
addq %r15, 0x18(%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r15
cmpb $0x0, 0x84(%rbx)
je 0x33ae9
cmpq $0x1000000, %r15 # imm = 0x1000000
jb 0x33ae9
movl $0xffffff, %r12d # imm = 0xFFFFFF
movl $0xffffff, %edx # imm = 0xFFFFFF
movq %rbx, %rdi
movq %r14, %rsi
callq 0x33707
testl %eax, %eax
jne 0x33b0e
addq %r12, %r14
addq $-0xffffff, %r15 # imm = 0xFF000001
cmpq %r12, %r15
ja 0x33ac6
cmpq 0x50(%rbx), %r15
jbe 0x33b08
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x33707
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %al
jmp 0x33aa2
movq 0x18(%rbx), %rdi
jmp 0x33a91
movl $0x1, %eax
jmp 0x33aa2
|
ma_net_write_buff:
xor eax, eax
test rdx, rdx
jz locret_33AAA
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov r14, rsi
mov rbx, rdi
cmp qword ptr [rdi+50h], 1000000h
jb short loc_33A3C
cmp byte ptr [rbx+84h], 0
jz short loc_33A3C
mov r12, [rbx+8]
mov rdi, [rbx+18h]
sub r12, rdi
add r12, 0FFFFFFh
jmp short loc_33A47
loc_33A3C:
mov r12, [rbx+10h]
mov rdi, [rbx+18h]
sub r12, rdi
loc_33A47:
mov r15, rdx
sub r15, r12
jbe short loc_33A8E
cmp rdi, [rbx+8]
jz short loc_33AAB
mov rsi, r14
mov rdx, r12
call _memcpy
mov rsi, [rbx+8]
mov rdx, r12
sub rdx, rsi
add rdx, [rbx+18h]
mov rdi, rbx
call ma_net_real_write
mov ecx, eax
mov eax, 1
test ecx, ecx
jnz short loc_33AA2
add r14, r12
mov rax, [rbx+8]
mov [rbx+18h], rax
jmp short loc_33AAE
loc_33A8E:
mov r15, rdx
loc_33A91:
mov rsi, r14
mov rdx, r15
call _memcpy
add [rbx+18h], r15
xor eax, eax
loc_33AA2:
pop rbx
pop r12
pop r14
pop r15
pop rbp
locret_33AAA:
retn
loc_33AAB:
mov r15, rdx
loc_33AAE:
cmp byte ptr [rbx+84h], 0
jz short loc_33AE9
cmp r15, 1000000h
jb short loc_33AE9
mov r12d, 0FFFFFFh
loc_33AC6:
mov edx, 0FFFFFFh
mov rdi, rbx
mov rsi, r14
call ma_net_real_write
test eax, eax
jnz short loc_33B0E
add r14, r12
add r15, 0FFFFFFFFFF000001h
cmp r15, r12
ja short loc_33AC6
loc_33AE9:
cmp r15, [rbx+50h]
jbe short loc_33B08
mov rdi, rbx
mov rsi, r14
mov rdx, r15
call ma_net_real_write
mov ecx, eax
xor eax, eax
test ecx, ecx
setnz al
jmp short loc_33AA2
loc_33B08:
mov rdi, [rbx+18h]
jmp short loc_33A91
loc_33B0E:
mov eax, 1
jmp short loc_33AA2
|
_BOOL8 ma_net_write_buff(long long a1, long long a2, unsigned long long a3)
{
_BOOL8 result; // rax
long long v4; // r14
long long v6; // rdi
unsigned long long v7; // r12
long long v8; // r12
unsigned long long v9; // r15
int v10; // ecx
result = 0LL;
if ( !a3 )
return result;
v4 = a2;
if ( *(_QWORD *)(a1 + 80) >= 0x1000000uLL && *(_BYTE *)(a1 + 132) )
{
v6 = *(_QWORD *)(a1 + 24);
v7 = *(_QWORD *)(a1 + 8) - v6 + 0xFFFFFF;
}
else
{
v8 = *(_QWORD *)(a1 + 16);
v6 = *(_QWORD *)(a1 + 24);
v7 = v8 - v6;
}
v9 = a3 - v7;
if ( a3 <= v7 )
{
v9 = a3;
LABEL_11:
memcpy(v6, v4, v9);
*(_QWORD *)(a1 + 24) += v9;
return 0LL;
}
if ( v6 == *(_QWORD *)(a1 + 8) )
{
v9 = a3;
}
else
{
memcpy(v6, a2, v7);
v10 = ma_net_real_write((_BYTE *)a1, *(_QWORD *)(a1 + 8), *(_QWORD *)(a1 + 24) + v7 - *(_QWORD *)(a1 + 8));
result = 1LL;
if ( v10 )
return result;
v4 = v7 + a2;
*(_QWORD *)(a1 + 24) = *(_QWORD *)(a1 + 8);
}
if ( !*(_BYTE *)(a1 + 132) || v9 < 0x1000000 )
{
LABEL_18:
if ( v9 > *(_QWORD *)(a1 + 80) )
return (unsigned int)ma_net_real_write((_BYTE *)a1, v4, v9) != 0;
v6 = *(_QWORD *)(a1 + 24);
goto LABEL_11;
}
while ( !(unsigned int)ma_net_real_write((_BYTE *)a1, v4, 0xFFFFFFLL) )
{
v4 += 0xFFFFFFLL;
v9 -= 0xFFFFFFLL;
if ( v9 <= 0xFFFFFF )
goto LABEL_18;
}
return 1LL;
}
|
ma_net_write_buff:
XOR EAX,EAX
TEST RDX,RDX
JZ 0x00133aaa
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R14,RSI
MOV RBX,RDI
CMP qword ptr [RDI + 0x50],0x1000000
JC 0x00133a3c
CMP byte ptr [RBX + 0x84],0x0
JZ 0x00133a3c
MOV R12,qword ptr [RBX + 0x8]
MOV RDI,qword ptr [RBX + 0x18]
SUB R12,RDI
ADD R12,0xffffff
JMP 0x00133a47
LAB_00133a3c:
MOV R12,qword ptr [RBX + 0x10]
MOV RDI,qword ptr [RBX + 0x18]
SUB R12,RDI
LAB_00133a47:
MOV R15,RDX
SUB R15,R12
JBE 0x00133a8e
CMP RDI,qword ptr [RBX + 0x8]
JZ 0x00133aab
MOV RSI,R14
MOV RDX,R12
CALL 0x00113390
MOV RSI,qword ptr [RBX + 0x8]
MOV RDX,R12
SUB RDX,RSI
ADD RDX,qword ptr [RBX + 0x18]
MOV RDI,RBX
CALL 0x00133707
MOV ECX,EAX
MOV EAX,0x1
TEST ECX,ECX
JNZ 0x00133aa2
ADD R14,R12
MOV RAX,qword ptr [RBX + 0x8]
MOV qword ptr [RBX + 0x18],RAX
JMP 0x00133aae
LAB_00133a8e:
MOV R15,RDX
LAB_00133a91:
MOV RSI,R14
MOV RDX,R15
CALL 0x00113390
ADD qword ptr [RBX + 0x18],R15
XOR EAX,EAX
LAB_00133aa2:
POP RBX
POP R12
POP R14
POP R15
POP RBP
LAB_00133aaa:
RET
LAB_00133aab:
MOV R15,RDX
LAB_00133aae:
CMP byte ptr [RBX + 0x84],0x0
JZ 0x00133ae9
CMP R15,0x1000000
JC 0x00133ae9
MOV R12D,0xffffff
LAB_00133ac6:
MOV EDX,0xffffff
MOV RDI,RBX
MOV RSI,R14
CALL 0x00133707
TEST EAX,EAX
JNZ 0x00133b0e
ADD R14,R12
ADD R15,-0xffffff
CMP R15,R12
JA 0x00133ac6
LAB_00133ae9:
CMP R15,qword ptr [RBX + 0x50]
JBE 0x00133b08
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R15
CALL 0x00133707
MOV ECX,EAX
XOR EAX,EAX
TEST ECX,ECX
SETNZ AL
JMP 0x00133aa2
LAB_00133b08:
MOV RDI,qword ptr [RBX + 0x18]
JMP 0x00133a91
LAB_00133b0e:
MOV EAX,0x1
JMP 0x00133aa2
|
bool ma_net_write_buff(long param_1,void *param_2,ulong param_3)
{
int iVar1;
void *__dest;
ulong __n;
if (param_3 != 0) {
if ((*(ulong *)(param_1 + 0x50) < 0x1000000) || (*(char *)(param_1 + 0x84) == '\0')) {
__dest = *(void **)(param_1 + 0x18);
__n = *(long *)(param_1 + 0x10) - (long)__dest;
}
else {
__dest = *(void **)(param_1 + 0x18);
__n = (*(long *)(param_1 + 8) - (long)__dest) + 0xffffff;
}
if (__n <= param_3 && param_3 - __n != 0) {
if (__dest != *(void **)(param_1 + 8)) {
memcpy(__dest,param_2,__n);
iVar1 = ma_net_real_write(param_1,*(long *)(param_1 + 8),
(__n - *(long *)(param_1 + 8)) + *(long *)(param_1 + 0x18));
if (iVar1 != 0) {
return true;
}
param_2 = (void *)((long)param_2 + __n);
*(int8 *)(param_1 + 0x18) = *(int8 *)(param_1 + 8);
param_3 = param_3 - __n;
}
if (*(char *)(param_1 + 0x84) != '\0') {
for (; 0xffffff < param_3; param_3 = param_3 - 0xffffff) {
iVar1 = ma_net_real_write(param_1,param_2,0xffffff);
if (iVar1 != 0) {
return true;
}
param_2 = (void *)((long)param_2 + 0xffffff);
}
}
if (*(ulong *)(param_1 + 0x50) < param_3) {
iVar1 = ma_net_real_write(param_1,param_2,param_3);
return iVar1 != 0;
}
__dest = *(void **)(param_1 + 0x18);
}
memcpy(__dest,param_2,param_3);
*(long *)(param_1 + 0x18) = *(long *)(param_1 + 0x18) + param_3;
}
return false;
}
|
|
60,657
|
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>::end()
|
monkey531[P]llama/common/json.hpp
|
iterator end() noexcept
{
iterator result(this);
result.set_end();
return result;
}
|
O1
|
cpp
|
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::end():
pushq %rbx
movq %rdi, %rbx
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rsi, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq %rax, 0x18(%rdi)
movzbl (%rsi), %ecx
cmpl $0x2, %ecx
je 0x60f0a
cmpl $0x1, %ecx
jne 0x60f14
leaq 0x8(%rbx), %rax
movq $0x0, (%rax)
jmp 0x60f18
movq $0x0, 0x10(%rbx)
jmp 0x60f18
movq %rax, 0x18(%rbx)
movq %rbx, %rdi
callq 0x62036
movq %rbx, %rax
popq %rbx
retq
nop
|
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE3endEv:
push rbx
mov rbx, rdi
mov rax, 8000000000000000h
mov [rdi], rsi
xorps xmm0, xmm0
movups xmmword ptr [rdi+8], xmm0
mov [rdi+18h], rax
movzx ecx, byte ptr [rsi]
cmp ecx, 2
jz short loc_60F0A
cmp ecx, 1
jnz short loc_60F14
lea rax, [rbx+8]
mov qword ptr [rax], 0
jmp short loc_60F18
loc_60F0A:
mov qword ptr [rbx+10h], 0
jmp short loc_60F18
loc_60F14:
mov [rbx+18h], rax
loc_60F18:
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE7set_endEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<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>>::set_end(void)
mov rax, rbx
pop rbx
retn
|
long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::end(
long long a1,
unsigned __int8 *a2)
{
int v2; // ecx
*(_QWORD *)a1 = a2;
*(_OWORD *)(a1 + 8) = 0LL;
*(_QWORD *)(a1 + 24) = 0x8000000000000000LL;
v2 = *a2;
if ( v2 == 2 )
{
*(_QWORD *)(a1 + 16) = 0LL;
}
else if ( v2 == 1 )
{
*(_QWORD *)(a1 + 8) = 0LL;
}
else
{
*(_QWORD *)(a1 + 24) = 0x8000000000000000LL;
}
nlohmann::json_abi_v3_11_3::detail::iter_impl<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>>::set_end(a1);
return a1;
}
|
end:
PUSH RBX
MOV RBX,RDI
MOV RAX,-0x8000000000000000
MOV qword ptr [RDI],RSI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x8],XMM0
MOV qword ptr [RDI + 0x18],RAX
MOVZX ECX,byte ptr [RSI]
CMP ECX,0x2
JZ 0x00160f0a
CMP ECX,0x1
JNZ 0x00160f14
LEA RAX,[RBX + 0x8]
MOV qword ptr [RAX],0x0
JMP 0x00160f18
LAB_00160f0a:
MOV qword ptr [RBX + 0x10],0x0
JMP 0x00160f18
LAB_00160f14:
MOV qword ptr [RBX + 0x18],RAX
LAB_00160f18:
MOV RDI,RBX
CALL 0x00162036
MOV RAX,RBX
POP RBX
RET
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>::end() */
void nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::end(void)
{
char *in_RSI;
iter_impl<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>>
*in_RDI;
*(char **)in_RDI = in_RSI;
*(int8 *)(in_RDI + 8) = 0;
*(int8 *)(in_RDI + 0x10) = 0;
*(int8 *)(in_RDI + 0x18) = 0x8000000000000000;
if (*in_RSI == '\x02') {
*(int8 *)(in_RDI + 0x10) = 0;
}
else if (*in_RSI == '\x01') {
*(int8 *)(in_RDI + 8) = 0;
}
else {
*(int8 *)(in_RDI + 0x18) = 0x8000000000000000;
}
detail::
iter_impl<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>>
::set_end(in_RDI);
return;
}
|
|
60,658
|
nglog::tools::SymbolizeAndDemangle(void*, char*, unsigned long, nglog::tools::SymbolizeOptions)
|
ng-log[P]ng-log/src/symbolize.cc
|
static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(
void* pc, char* out, size_t out_size, SymbolizeOptions /*options*/) {
auto pc0 = reinterpret_cast<uintptr_t>(pc);
uint64_t start_address = 0;
uint64_t base_address = 0;
FileDescriptor object_fd;
if (out_size < 1) {
return false;
}
out[0] = '\0';
SafeAppendString("(", out, out_size);
if (g_symbolize_open_object_file_callback) {
object_fd.reset(g_symbolize_open_object_file_callback(
pc0, start_address, base_address, out + 1, out_size - 1));
} else {
object_fd = OpenObjectFileContainingPcAndGetStartAddress(
pc0, start_address, base_address, out + 1, out_size - 1);
}
# if defined(PRINT_UNSYMBOLIZED_STACK_TRACES)
{
# else
// Check whether a file name was returned.
if (!object_fd) {
# endif
if (out[1]) {
// The object file containing PC was determined successfully however the
// object file was not opened successfully. This is still considered
// success because the object file name and offset are known and tools
// like asan_symbolize.py can be used for the symbolization.
out[out_size - 1] = '\0'; // Making sure |out| is always null-terminated.
SafeAppendString("+0x", out, out_size);
SafeAppendHexNumber(pc0 - base_address, out, out_size);
SafeAppendString(")", out, out_size);
return true;
}
// Failed to determine the object file containing PC. Bail out.
return false;
}
int elf_type = FileGetElfType(object_fd.get());
if (elf_type == -1) {
return false;
}
if (g_symbolize_callback) {
// Run the call back if it's installed.
// Note: relocation (and much of the rest of this code) will be
// wrong for prelinked shared libraries and PIE executables.
uint64_t relocation = (elf_type == ET_DYN) ? start_address : 0;
int num_bytes_written =
g_symbolize_callback(object_fd.get(), pc, out, out_size, relocation);
if (num_bytes_written > 0) {
out += static_cast<size_t>(num_bytes_written);
out_size -= static_cast<size_t>(num_bytes_written);
}
}
if (!GetSymbolFromObjectFile(object_fd.get(), pc0, out, out_size,
base_address)) {
if (out[1] && !g_symbolize_callback) {
// The object file containing PC was opened successfully however the
// symbol was not found. The object may have been stripped. This is still
// considered success because the object file name and offset are known
// and tools like asan_symbolize.py can be used for the symbolization.
out[out_size - 1] = '\0'; // Making sure |out| is always null-terminated.
SafeAppendString("+0x", out, out_size);
SafeAppendHexNumber(pc0 - base_address, out, out_size);
SafeAppendString(")", out, out_size);
return true;
}
return false;
}
// Symbolization succeeded. Now we try to demangle the symbol.
DemangleInplace(out, out_size);
return true;
}
}
|
O0
|
cpp
|
nglog::tools::SymbolizeAndDemangle(void*, char*, unsigned long, nglog::tools::SymbolizeOptions):
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
leaq -0x44(%rbp), %rdi
callq 0x4ab30
cmpq $0x1, -0x20(%rbp)
jae 0x493a2
movb $0x0, -0x1(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0x49676
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq 0x44dd(%rip), %rdi # 0x4d895
callq 0x49730
jmp 0x493bf
cmpq $0x0, 0x37859(%rip) # 0x80c20
je 0x49419
movq 0x37850(%rip), %rax # 0x80c20
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rcx
incq %rcx
movq -0x20(%rbp), %r8
decq %r8
leaq -0x38(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq *%rax
movl %eax, -0x70(%rbp)
jmp 0x493f1
movl -0x70(%rbp), %esi
leaq -0x44(%rbp), %rdi
callq 0x4ab50
jmp 0x49454
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x44(%rbp), %rdi
callq 0x18b80
jmp 0x4968d
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %r8
incq %r8
movq -0x20(%rbp), %r9
decq %r9
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x497b0
jmp 0x4943e
leaq -0x44(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x4ab80
leaq -0x58(%rbp), %rdi
callq 0x18b80
leaq -0x44(%rbp), %rdi
callq 0x18b50
testb $0x1, %al
jne 0x494de
movq -0x18(%rbp), %rax
cmpb $0x0, 0x1(%rax)
je 0x494ce
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movb $0x0, -0x1(%rax,%rcx)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq 0x5a40(%rip), %rdi # 0x4eec7
callq 0x49730
jmp 0x4948e
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rax
subq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x49df0
jmp 0x494a8
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq 0x4696(%rip), %rdi # 0x4db4d
callq 0x49730
jmp 0x494be
movb $0x1, -0x1(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0x49676
movb $0x0, -0x1(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0x49676
leaq -0x44(%rbp), %rdi
callq 0x18b70
movl %eax, %edi
callq 0x49e50
movl %eax, -0x74(%rbp)
jmp 0x494f3
movl -0x74(%rbp), %eax
movl %eax, -0x5c(%rbp)
cmpl $-0x1, -0x5c(%rbp)
jne 0x4950f
movb $0x0, -0x1(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0x49676
cmpq $0x0, 0x37701(%rip) # 0x80c18
je 0x495a3
cmpl $0x3, -0x5c(%rbp)
jne 0x4952d
movq -0x38(%rbp), %rax
movq %rax, -0x80(%rbp)
jmp 0x49535
xorl %eax, %eax
movq %rax, -0x80(%rbp)
jmp 0x49535
movq -0x80(%rbp), %rax
movq %rax, -0x68(%rbp)
movq 0x376d4(%rip), %rax # 0x80c18
movq %rax, -0x90(%rbp)
leaq -0x44(%rbp), %rdi
callq 0x18b70
movl %eax, %edi
movq -0x90(%rbp), %rax
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x68(%rbp), %r8
callq *%rax
movl %eax, -0x84(%rbp)
jmp 0x49577
movl -0x84(%rbp), %eax
movl %eax, -0x6c(%rbp)
cmpl $0x0, -0x6c(%rbp)
jle 0x495a1
movslq -0x6c(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movslq -0x6c(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0x495a3
leaq -0x44(%rbp), %rdi
callq 0x18b70
movl %eax, %edi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x40(%rbp), %r8
callq 0x49eb0
movb %al, -0x91(%rbp)
jmp 0x495cb
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x4965c
jmp 0x495db
movq -0x18(%rbp), %rax
cmpb $0x0, 0x1(%rax)
je 0x4964f
cmpq $0x0, 0x3762b(%rip) # 0x80c18
jne 0x4964f
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movb $0x0, -0x1(%rax,%rcx)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq 0x58bc(%rip), %rdi # 0x4eec7
callq 0x49730
jmp 0x49612
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rax
subq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x49df0
jmp 0x4962c
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq 0x4512(%rip), %rdi # 0x4db4d
callq 0x49730
jmp 0x49642
movb $0x1, -0x1(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0x49676
movb $0x0, -0x1(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0x49676
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4a020
jmp 0x4966b
movb $0x1, -0x1(%rbp)
movl $0x1, -0x48(%rbp)
leaq -0x44(%rbp), %rdi
callq 0x18b80
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x9d00
nopw %cs:(%rax,%rax)
|
_ZN5nglog5toolsL20SymbolizeAndDemangleEPvPcmNS0_16SymbolizeOptionsE:
push rbp
mov rbp, rsp
sub rsp, 0A0h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_24], ecx
mov rax, [rbp+var_10]
mov [rbp+var_30], rax
mov [rbp+var_38], 0
mov [rbp+var_40], 0
lea rdi, [rbp+var_44]; this
call _ZN5nglog5tools14FileDescriptorC2Ev; nglog::tools::FileDescriptor::FileDescriptor(void)
cmp [rbp+var_20], 1
jnb short loc_493A2
mov [rbp+var_1], 0
mov [rbp+var_48], 1
jmp loc_49676
loc_493A2:
mov rax, [rbp+var_18]
mov byte ptr [rax], 0
mov rsi, [rbp+var_18]; char *
mov rdx, [rbp+var_20]; char *
lea rdi, asc_4D894+1; this
call _ZN5nglog5toolsL16SafeAppendStringEPKcPcm; nglog::tools::SafeAppendString(char const*,char *,ulong)
jmp short $+2
loc_493BF:
cmp cs:_ZN5nglog5tools12_GLOBAL__N_137g_symbolize_open_object_file_callbackE, 0; nglog::tools::`anonymous namespace'::g_symbolize_open_object_file_callback
jz short loc_49419
mov rax, cs:_ZN5nglog5tools12_GLOBAL__N_137g_symbolize_open_object_file_callbackE; nglog::tools::`anonymous namespace'::g_symbolize_open_object_file_callback
mov rdi, [rbp+var_30]
mov rcx, [rbp+var_18]
inc rcx
mov r8, [rbp+var_20]
dec r8
lea rsi, [rbp+var_38]
lea rdx, [rbp+var_40]
call rax ; nglog::tools::`anonymous namespace'::g_symbolize_open_object_file_callback
mov [rbp+var_70], eax
jmp short $+2
loc_493F1:
mov esi, [rbp+var_70]; int
lea rdi, [rbp+var_44]; this
call _ZN5nglog5tools14FileDescriptor5resetEi; nglog::tools::FileDescriptor::reset(int)
jmp short loc_49454
mov rcx, rax
mov eax, edx
mov [rbp+var_50], rcx
mov [rbp+var_54], eax
lea rdi, [rbp+var_44]; this
call _ZN5nglog5tools14FileDescriptorD2Ev; nglog::tools::FileDescriptor::~FileDescriptor()
jmp loc_4968D
loc_49419:
mov rsi, [rbp+var_30]; unsigned __int64
mov r8, [rbp+var_18]
inc r8; char *
mov r9, [rbp+var_20]
dec r9; unsigned __int64
lea rdi, [rbp+var_58]; this
lea rdx, [rbp+var_38]; unsigned __int64 *
lea rcx, [rbp+var_40]; unsigned __int64 *
call _ZN5nglog5toolsL44OpenObjectFileContainingPcAndGetStartAddressEmRmS1_Pcm; nglog::tools::OpenObjectFileContainingPcAndGetStartAddress(ulong,ulong &,ulong &,char *,ulong)
jmp short $+2
loc_4943E:
lea rdi, [rbp+var_44]
lea rsi, [rbp+var_58]; int
call _ZN5nglog5tools14FileDescriptoraSEOS1_; nglog::tools::FileDescriptor::operator=(nglog::tools::FileDescriptor&&)
lea rdi, [rbp+var_58]; this
call _ZN5nglog5tools14FileDescriptorD2Ev; nglog::tools::FileDescriptor::~FileDescriptor()
loc_49454:
lea rdi, [rbp+var_44]
call _ZNK5nglog5tools14FileDescriptorcvbEv; nglog::tools::FileDescriptor::operator bool(void)
test al, 1
jnz short loc_494DE
mov rax, [rbp+var_18]
cmp byte ptr [rax+1], 0
jz short loc_494CE
mov rcx, [rbp+var_18]; unsigned __int64
mov rax, [rbp+var_20]
mov byte ptr [rax+rcx-1], 0
mov rsi, [rbp+var_18]; char *
mov rdx, [rbp+var_20]; char *
lea rdi, a0x_0; "+0x"
call _ZN5nglog5toolsL16SafeAppendStringEPKcPcm; nglog::tools::SafeAppendString(char const*,char *,ulong)
jmp short $+2
loc_4948E:
mov rdi, [rbp+var_30]
mov rax, [rbp+var_40]
sub rdi, rax; this
mov rsi, [rbp+var_18]; unsigned __int64
mov rdx, [rbp+var_20]; char *
call _ZN5nglog5toolsL19SafeAppendHexNumberEmPcm; nglog::tools::SafeAppendHexNumber(ulong,char *,ulong)
jmp short $+2
loc_494A8:
mov rsi, [rbp+var_18]; char *
mov rdx, [rbp+var_20]; char *
lea rdi, aVoidNglogAnony+86h; this
call _ZN5nglog5toolsL16SafeAppendStringEPKcPcm; nglog::tools::SafeAppendString(char const*,char *,ulong)
jmp short $+2
loc_494BE:
mov [rbp+var_1], 1
mov [rbp+var_48], 1
jmp loc_49676
loc_494CE:
mov [rbp+var_1], 0
mov [rbp+var_48], 1
jmp loc_49676
loc_494DE:
lea rdi, [rbp+var_44]; this
call _ZNK5nglog5tools14FileDescriptor3getEv; nglog::tools::FileDescriptor::get(void)
mov edi, eax; this
call _ZN5nglog5toolsL14FileGetElfTypeEi; nglog::tools::FileGetElfType(int)
mov [rbp+var_74], eax
jmp short $+2
loc_494F3:
mov eax, [rbp+var_74]
mov [rbp+var_5C], eax
cmp [rbp+var_5C], 0FFFFFFFFh
jnz short loc_4950F
mov [rbp+var_1], 0
mov [rbp+var_48], 1
jmp loc_49676
loc_4950F:
cmp cs:_ZN5nglog5tools12_GLOBAL__N_120g_symbolize_callbackE, 0; nglog::tools::`anonymous namespace'::g_symbolize_callback
jz loc_495A3
cmp [rbp+var_5C], 3
jnz short loc_4952D
mov rax, [rbp+var_38]
mov [rbp+var_80], rax
jmp short loc_49535
loc_4952D:
xor eax, eax
mov [rbp+var_80], rax
jmp short $+2
loc_49535:
mov rax, [rbp+var_80]
mov [rbp+var_68], rax
mov rax, cs:_ZN5nglog5tools12_GLOBAL__N_120g_symbolize_callbackE; nglog::tools::`anonymous namespace'::g_symbolize_callback
mov [rbp+var_90], rax
lea rdi, [rbp+var_44]; this
call _ZNK5nglog5tools14FileDescriptor3getEv; nglog::tools::FileDescriptor::get(void)
mov edi, eax
mov rax, [rbp+var_90]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
mov r8, [rbp+var_68]
call rax
mov [rbp+var_84], eax
jmp short $+2
loc_49577:
mov eax, [rbp+var_84]
mov [rbp+var_6C], eax
cmp [rbp+var_6C], 0
jle short loc_495A1
movsxd rax, [rbp+var_6C]
add rax, [rbp+var_18]
mov [rbp+var_18], rax
movsxd rcx, [rbp+var_6C]
mov rax, [rbp+var_20]
sub rax, rcx
mov [rbp+var_20], rax
loc_495A1:
jmp short $+2
loc_495A3:
lea rdi, [rbp+var_44]; this
call _ZNK5nglog5tools14FileDescriptor3getEv; nglog::tools::FileDescriptor::get(void)
mov edi, eax; this
mov rsi, [rbp+var_30]; int
mov rdx, [rbp+var_18]; unsigned __int64
mov rcx, [rbp+var_20]; char *
mov r8, [rbp+var_40]; unsigned __int64
call _ZN5nglog5toolsL23GetSymbolFromObjectFileEimPcmm; nglog::tools::GetSymbolFromObjectFile(int,ulong,char *,ulong,ulong)
mov [rbp+var_91], al
jmp short $+2
loc_495CB:
mov al, [rbp+var_91]
test al, 1
jnz loc_4965C
jmp short $+2
loc_495DB:
mov rax, [rbp+var_18]
cmp byte ptr [rax+1], 0
jz short loc_4964F
cmp cs:_ZN5nglog5tools12_GLOBAL__N_120g_symbolize_callbackE, 0; nglog::tools::`anonymous namespace'::g_symbolize_callback
jnz short loc_4964F
mov rcx, [rbp+var_18]; unsigned __int64
mov rax, [rbp+var_20]
mov byte ptr [rax+rcx-1], 0
mov rsi, [rbp+var_18]; char *
mov rdx, [rbp+var_20]; char *
lea rdi, a0x_0; "+0x"
call _ZN5nglog5toolsL16SafeAppendStringEPKcPcm; nglog::tools::SafeAppendString(char const*,char *,ulong)
jmp short $+2
loc_49612:
mov rdi, [rbp+var_30]
mov rax, [rbp+var_40]
sub rdi, rax; this
mov rsi, [rbp+var_18]; unsigned __int64
mov rdx, [rbp+var_20]; char *
call _ZN5nglog5toolsL19SafeAppendHexNumberEmPcm; nglog::tools::SafeAppendHexNumber(ulong,char *,ulong)
jmp short $+2
loc_4962C:
mov rsi, [rbp+var_18]; char *
mov rdx, [rbp+var_20]; char *
lea rdi, aVoidNglogAnony+86h; this
call _ZN5nglog5toolsL16SafeAppendStringEPKcPcm; nglog::tools::SafeAppendString(char const*,char *,ulong)
jmp short $+2
loc_49642:
mov [rbp+var_1], 1
mov [rbp+var_48], 1
jmp short loc_49676
loc_4964F:
mov [rbp+var_1], 0
mov [rbp+var_48], 1
jmp short loc_49676
loc_4965C:
mov rdi, [rbp+var_18]; this
mov rsi, [rbp+var_20]; char *
call _ZN5nglog5tools12_GLOBAL__N_115DemangleInplaceEPcm; nglog::tools::`anonymous namespace'::DemangleInplace(char *,ulong)
jmp short $+2
loc_4966B:
mov [rbp+var_1], 1
mov [rbp+var_48], 1
loc_49676:
lea rdi, [rbp+var_44]; this
call _ZN5nglog5tools14FileDescriptorD2Ev; nglog::tools::FileDescriptor::~FileDescriptor()
mov al, [rbp+var_1]
and al, 1
add rsp, 0A0h
pop rbp
retn
loc_4968D:
mov rdi, [rbp+var_50]
call __Unwind_Resume
|
char nglog::tools::SymbolizeAndDemangle(
unsigned long long a1,
nglog::tools::_anonymous_namespace_ *a2,
char *a3,
int a4)
{
unsigned long long v4; // rcx
int *v5; // rsi
nglog::tools::_anonymous_namespace_ *v6; // rcx
unsigned long long v7; // rcx
unsigned long long v8; // rcx
unsigned int v9; // eax
unsigned int v10; // eax
unsigned int v11; // eax
unsigned long long v12; // r9
unsigned long long v13; // rdx
nglog::tools::_anonymous_namespace_ *v14; // rcx
unsigned long long v15; // rcx
unsigned long long v16; // rcx
long long ( *v18)(_QWORD, unsigned long long, nglog::tools::_anonymous_namespace_ *, char *, unsigned long long); // [rsp+10h] [rbp-90h]
unsigned long long v19; // [rsp+20h] [rbp-80h]
int v20; // [rsp+34h] [rbp-6Ch]
int ElfType; // [rsp+44h] [rbp-5Ch]
int v22; // [rsp+48h] [rbp-58h] BYREF
int v23; // [rsp+58h] [rbp-48h]
int v24; // [rsp+5Ch] [rbp-44h] BYREF
unsigned long long v25; // [rsp+60h] [rbp-40h] BYREF
unsigned long long v26; // [rsp+68h] [rbp-38h] BYREF
unsigned long long v27; // [rsp+70h] [rbp-30h]
int v28; // [rsp+7Ch] [rbp-24h]
char *v29; // [rsp+80h] [rbp-20h]
nglog::tools::_anonymous_namespace_ *v30; // [rsp+88h] [rbp-18h]
unsigned long long v31; // [rsp+90h] [rbp-10h]
char v32; // [rsp+9Fh] [rbp-1h]
v31 = a1;
v30 = a2;
v29 = a3;
v28 = a4;
v27 = a1;
v26 = 0LL;
v25 = 0LL;
nglog::tools::FileDescriptor::FileDescriptor((nglog::tools::FileDescriptor *)&v24);
if ( v29 )
{
*(_BYTE *)v30 = 0;
nglog::tools::SafeAppendString((nglog::tools *)"(", (const char *)v30, v29, v4);
if ( nglog::tools::`anonymous namespace'::g_symbolize_open_object_file_callback )
{
LODWORD(v5) = nglog::tools::`anonymous namespace'::g_symbolize_open_object_file_callback(
v27,
&v26,
&v25,
(char *)v30 + 1,
v29 - 1);
nglog::tools::FileDescriptor::reset((nglog::tools::FileDescriptor *)&v24, (int)v5);
}
else
{
nglog::tools::OpenObjectFileContainingPcAndGetStartAddress(
(nglog::tools *)&v22,
v27,
&v26,
&v25,
(char *)v30 + 1,
(unsigned long long)(v29 - 1));
v5 = &v22;
nglog::tools::FileDescriptor::operator=(&v24, &v22);
nglog::tools::FileDescriptor::~FileDescriptor((nglog::tools::FileDescriptor *)&v22);
}
if ( nglog::tools::FileDescriptor::operator bool(&v24) )
{
v9 = nglog::tools::FileDescriptor::get((nglog::tools::FileDescriptor *)&v24);
ElfType = nglog::tools::FileGetElfType((nglog::tools *)v9, (int)v5);
if ( ElfType == -1 )
{
v32 = 0;
v23 = 1;
}
else
{
if ( nglog::tools::`anonymous namespace'::g_symbolize_callback )
{
v19 = ElfType == 3 ? v26 : 0LL;
v18 = (long long ( *)(_QWORD, unsigned long long, nglog::tools::_anonymous_namespace_ *, char *, unsigned long long))nglog::tools::`anonymous namespace'::g_symbolize_callback;
v10 = nglog::tools::FileDescriptor::get((nglog::tools::FileDescriptor *)&v24);
v20 = v18(v10, v31, v30, v29, v19);
if ( v20 > 0 )
{
v30 = (nglog::tools::_anonymous_namespace_ *)((char *)v30 + v20);
v29 -= v20;
}
}
v11 = nglog::tools::FileDescriptor::get((nglog::tools::FileDescriptor *)&v24);
if ( (nglog::tools::GetSymbolFromObjectFile((nglog::tools *)v11, v27, (unsigned long long)v30, v29, v25, v12) & 1) != 0 )
{
nglog::tools::`anonymous namespace'::DemangleInplace(v30, v29, v13);
v32 = 1;
v23 = 1;
}
else if ( !*((_BYTE *)v30 + 1) || nglog::tools::`anonymous namespace'::g_symbolize_callback )
{
v32 = 0;
v23 = 1;
}
else
{
v14 = v30;
*((_BYTE *)v30 + (_QWORD)v29 - 1) = 0;
nglog::tools::SafeAppendString((nglog::tools *)"+0x", (const char *)v30, v29, (unsigned long long)v14);
nglog::tools::SafeAppendHexNumber((nglog::tools *)(v27 - v25), (unsigned long long)v30, v29, v15);
nglog::tools::SafeAppendString((nglog::tools *)")", (const char *)v30, v29, v16);
v32 = 1;
v23 = 1;
}
}
}
else
{
if ( *((_BYTE *)v30 + 1) )
{
v6 = v30;
*((_BYTE *)v30 + (_QWORD)v29 - 1) = 0;
nglog::tools::SafeAppendString((nglog::tools *)"+0x", (const char *)v30, v29, (unsigned long long)v6);
nglog::tools::SafeAppendHexNumber((nglog::tools *)(v27 - v25), (unsigned long long)v30, v29, v7);
nglog::tools::SafeAppendString((nglog::tools *)")", (const char *)v30, v29, v8);
v32 = 1;
}
else
{
v32 = 0;
}
v23 = 1;
}
}
else
{
v32 = 0;
v23 = 1;
}
nglog::tools::FileDescriptor::~FileDescriptor((nglog::tools::FileDescriptor *)&v24);
return v32 & 1;
}
|
SymbolizeAndDemangle:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xa0
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV dword ptr [RBP + -0x24],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x30],RAX
MOV qword ptr [RBP + -0x38],0x0
MOV qword ptr [RBP + -0x40],0x0
LEA RDI,[RBP + -0x44]
CALL 0x0014ab30
CMP qword ptr [RBP + -0x20],0x1
JNC 0x001493a2
MOV byte ptr [RBP + -0x1],0x0
MOV dword ptr [RBP + -0x48],0x1
JMP 0x00149676
LAB_001493a2:
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX],0x0
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
LAB_001493b1:
LEA RDI,[0x14d895]
CALL 0x00149730
JMP 0x001493bf
LAB_001493bf:
CMP qword ptr [0x00180c20],0x0
JZ 0x00149419
MOV RAX,qword ptr [0x00180c20]
MOV RDI,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x18]
INC RCX
MOV R8,qword ptr [RBP + -0x20]
DEC R8
LEA RSI,[RBP + -0x38]
LEA RDX,[RBP + -0x40]
CALL RAX
MOV dword ptr [RBP + -0x70],EAX
JMP 0x001493f1
LAB_001493f1:
MOV ESI,dword ptr [RBP + -0x70]
LEA RDI,[RBP + -0x44]
CALL 0x0014ab50
JMP 0x00149454
LAB_00149419:
MOV RSI,qword ptr [RBP + -0x30]
MOV R8,qword ptr [RBP + -0x18]
INC R8
MOV R9,qword ptr [RBP + -0x20]
DEC R9
LEA RDI,[RBP + -0x58]
LEA RDX,[RBP + -0x38]
LEA RCX,[RBP + -0x40]
CALL 0x001497b0
JMP 0x0014943e
LAB_0014943e:
LEA RDI,[RBP + -0x44]
LEA RSI,[RBP + -0x58]
CALL 0x0014ab80
LEA RDI,[RBP + -0x58]
CALL 0x00118b80
LAB_00149454:
LEA RDI,[RBP + -0x44]
CALL 0x00118b50
TEST AL,0x1
JNZ 0x001494de
MOV RAX,qword ptr [RBP + -0x18]
CMP byte ptr [RAX + 0x1],0x0
JZ 0x001494ce
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + RCX*0x1 + -0x1],0x0
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
LEA RDI,[0x14eec7]
CALL 0x00149730
JMP 0x0014948e
LAB_0014948e:
MOV RDI,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x40]
SUB RDI,RAX
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x00149df0
JMP 0x001494a8
LAB_001494a8:
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
LEA RDI,[0x14db4d]
CALL 0x00149730
JMP 0x001494be
LAB_001494be:
MOV byte ptr [RBP + -0x1],0x1
MOV dword ptr [RBP + -0x48],0x1
JMP 0x00149676
LAB_001494ce:
MOV byte ptr [RBP + -0x1],0x0
MOV dword ptr [RBP + -0x48],0x1
JMP 0x00149676
LAB_001494de:
LEA RDI,[RBP + -0x44]
CALL 0x00118b70
MOV EDI,EAX
CALL 0x00149e50
MOV dword ptr [RBP + -0x74],EAX
JMP 0x001494f3
LAB_001494f3:
MOV EAX,dword ptr [RBP + -0x74]
MOV dword ptr [RBP + -0x5c],EAX
CMP dword ptr [RBP + -0x5c],-0x1
JNZ 0x0014950f
MOV byte ptr [RBP + -0x1],0x0
MOV dword ptr [RBP + -0x48],0x1
JMP 0x00149676
LAB_0014950f:
CMP qword ptr [0x00180c18],0x0
JZ 0x001495a3
CMP dword ptr [RBP + -0x5c],0x3
JNZ 0x0014952d
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x80],RAX
JMP 0x00149535
LAB_0014952d:
XOR EAX,EAX
MOV qword ptr [RBP + -0x80],RAX
JMP 0x00149535
LAB_00149535:
MOV RAX,qword ptr [RBP + -0x80]
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [0x00180c18]
MOV qword ptr [RBP + -0x90],RAX
LEA RDI,[RBP + -0x44]
CALL 0x00118b70
MOV EDI,EAX
MOV RAX,qword ptr [RBP + -0x90]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
MOV R8,qword ptr [RBP + -0x68]
CALL RAX
MOV dword ptr [RBP + -0x84],EAX
JMP 0x00149577
LAB_00149577:
MOV EAX,dword ptr [RBP + -0x84]
MOV dword ptr [RBP + -0x6c],EAX
CMP dword ptr [RBP + -0x6c],0x0
JLE 0x001495a1
MOVSXD RAX,dword ptr [RBP + -0x6c]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x18],RAX
MOVSXD RCX,dword ptr [RBP + -0x6c]
MOV RAX,qword ptr [RBP + -0x20]
SUB RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
LAB_001495a1:
JMP 0x001495a3
LAB_001495a3:
LEA RDI,[RBP + -0x44]
CALL 0x00118b70
MOV EDI,EAX
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
MOV R8,qword ptr [RBP + -0x40]
CALL 0x00149eb0
MOV byte ptr [RBP + -0x91],AL
JMP 0x001495cb
LAB_001495cb:
MOV AL,byte ptr [RBP + -0x91]
TEST AL,0x1
JNZ 0x0014965c
JMP 0x001495db
LAB_001495db:
MOV RAX,qword ptr [RBP + -0x18]
CMP byte ptr [RAX + 0x1],0x0
JZ 0x0014964f
CMP qword ptr [0x00180c18],0x0
JNZ 0x0014964f
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + RCX*0x1 + -0x1],0x0
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
LEA RDI,[0x14eec7]
CALL 0x00149730
JMP 0x00149612
LAB_00149612:
MOV RDI,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x40]
SUB RDI,RAX
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x00149df0
JMP 0x0014962c
LAB_0014962c:
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
LEA RDI,[0x14db4d]
CALL 0x00149730
JMP 0x00149642
LAB_00149642:
MOV byte ptr [RBP + -0x1],0x1
MOV dword ptr [RBP + -0x48],0x1
JMP 0x00149676
LAB_0014964f:
MOV byte ptr [RBP + -0x1],0x0
MOV dword ptr [RBP + -0x48],0x1
JMP 0x00149676
LAB_0014965c:
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x0014a020
LAB_00149669:
JMP 0x0014966b
LAB_0014966b:
MOV byte ptr [RBP + -0x1],0x1
MOV dword ptr [RBP + -0x48],0x1
LAB_00149676:
LEA RDI,[RBP + -0x44]
CALL 0x00118b80
MOV AL,byte ptr [RBP + -0x1]
AND AL,0x1
ADD RSP,0xa0
POP RBP
RET
|
/* nglog::tools::SymbolizeAndDemangle(void*, char*, unsigned long, nglog::tools::SymbolizeOptions)
*/
ulong nglog::tools::SymbolizeAndDemangle
(ulong param_1,char *param_2,ulong param_3,int4 param_4)
{
code *pcVar1;
bool bVar2;
byte bVar3;
int iVar4;
int4 uVar5;
int8 uVar6;
ulong local_88;
tools local_60 [16];
int4 local_50;
FileDescriptor local_4c [4];
ulong local_48;
ulong local_40;
ulong local_38;
int4 local_2c;
ulong local_28;
char *local_20;
ulong local_18;
int1 local_9;
local_40 = 0;
local_48 = 0;
local_38 = param_1;
local_2c = param_4;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
FileDescriptor::FileDescriptor(local_4c);
if (local_28 == 0) {
local_9 = 0;
}
else {
*local_20 = '\0';
/* try { // try from 001493b1 to 00149668 has its CatchHandler @ 001493ff */
SafeAppendString("(",local_20,local_28);
if ((anonymous_namespace)::g_symbolize_open_object_file_callback == (code *)0x0) {
OpenObjectFileContainingPcAndGetStartAddress
(local_60,local_38,&local_40,&local_48,local_20 + 1,local_28 - 1);
FileDescriptor::operator=(local_4c,(FileDescriptor *)local_60);
FileDescriptor::~FileDescriptor((FileDescriptor *)local_60);
}
else {
iVar4 = (*(anonymous_namespace)::g_symbolize_open_object_file_callback)
(local_38,&local_40,&local_48,local_20 + 1,local_28 - 1);
FileDescriptor::reset(local_4c,iVar4);
}
bVar2 = FileDescriptor::operator_cast_to_bool(local_4c);
if (bVar2) {
iVar4 = FileDescriptor::get(local_4c);
iVar4 = FileGetElfType(iVar4);
pcVar1 = (anonymous_namespace)::g_symbolize_callback;
if (iVar4 == -1) {
local_9 = 0;
}
else {
if ((anonymous_namespace)::g_symbolize_callback != (code *)0x0) {
if (iVar4 == 3) {
local_88 = local_40;
}
else {
local_88 = 0;
}
uVar5 = FileDescriptor::get(local_4c);
iVar4 = (*pcVar1)(uVar5,local_18,local_20,local_28,local_88);
if (0 < iVar4) {
local_20 = local_20 + iVar4;
local_28 = local_28 - (long)iVar4;
}
}
iVar4 = FileDescriptor::get(local_4c);
bVar3 = GetSymbolFromObjectFile(iVar4,local_38,local_20,local_28,local_48);
if ((bVar3 & 1) == 0) {
if ((local_20[1] == '\0') || ((anonymous_namespace)::g_symbolize_callback != (code *)0x0))
{
local_9 = 0;
}
else {
local_20[local_28 - 1] = '\0';
SafeAppendString("+0x",local_20,local_28);
SafeAppendHexNumber(local_38 - local_48,local_20,local_28);
SafeAppendString(")",local_20,local_28);
local_9 = 1;
}
}
else {
(anonymous_namespace)::DemangleInplace(local_20,local_28);
local_9 = 1;
}
}
}
else if (local_20[1] == '\0') {
local_9 = 0;
}
else {
local_20[local_28 - 1] = '\0';
SafeAppendString("+0x",local_20,local_28);
SafeAppendHexNumber(local_38 - local_48,local_20,local_28);
SafeAppendString(")",local_20,local_28);
local_9 = 1;
}
}
local_50 = 1;
uVar6 = FileDescriptor::~FileDescriptor(local_4c);
return CONCAT71((int7)((ulong)uVar6 >> 8),local_9) & 0xffffffffffffff01;
}
|
|
60,659
|
pvio_socket_keepalive
|
eloqsql/libmariadb/plugins/pvio/pvio_socket.c
|
int pvio_socket_keepalive(MARIADB_PVIO *pvio)
{
int opt= 1;
struct st_pvio_socket *csock= NULL;
if (!pvio || !pvio->data)
return 1;
csock= (struct st_pvio_socket *)pvio->data;
return setsockopt(csock->socket, SOL_SOCKET, SO_KEEPALIVE,
#ifndef _WIN32
(const void *)&opt, sizeof(opt));
#else
(char *)&opt, (int)sizeof(opt));
#endif
}
|
O0
|
c
|
pvio_socket_keepalive:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x423bc
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x423c5
movl $0x1, -0x4(%rbp)
jmp 0x423f2
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %edi
movl $0x1, %esi
movl $0x9, %edx
leaq -0x14(%rbp), %rcx
movl $0x4, %r8d
callq 0x13770
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
pvio_socket_keepalive:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_14], 1
mov [rbp+var_20], 0
cmp [rbp+var_10], 0
jz short loc_423BC
mov rax, [rbp+var_10]
cmp qword ptr [rax], 0
jnz short loc_423C5
loc_423BC:
mov [rbp+var_4], 1
jmp short loc_423F2
loc_423C5:
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov edi, [rax]
mov esi, 1
mov edx, 9
lea rcx, [rbp+var_14]
mov r8d, 4
call _setsockopt
mov [rbp+var_4], eax
loc_423F2:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
|
long long pvio_socket_keepalive(_QWORD *a1)
{
int v2; // [rsp+Ch] [rbp-14h] BYREF
_QWORD *v3; // [rsp+10h] [rbp-10h]
v3 = a1;
v2 = 1;
if ( a1 && *v3 )
return (unsigned int)setsockopt(*(unsigned int *)*v3, 1LL, 9LL, &v2, 4LL);
else
return 1;
}
|
pvio_socket_keepalive:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],0x1
MOV qword ptr [RBP + -0x20],0x0
CMP qword ptr [RBP + -0x10],0x0
JZ 0x001423bc
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX],0x0
JNZ 0x001423c5
LAB_001423bc:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001423f2
LAB_001423c5:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV EDI,dword ptr [RAX]
MOV ESI,0x1
MOV EDX,0x9
LEA RCX,[RBP + -0x14]
MOV R8D,0x4
CALL 0x00113770
MOV dword ptr [RBP + -0x4],EAX
LAB_001423f2:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int pvio_socket_keepalive(long *param_1)
{
int4 local_1c;
long *local_18;
int local_c;
local_1c = 1;
if ((param_1 == (long *)0x0) || (*param_1 == 0)) {
local_c = 1;
}
else {
local_18 = param_1;
local_c = setsockopt(*(int *)*param_1,1,9,&local_1c,4);
}
return local_c;
}
|
|
60,660
|
build_envp
|
bluesky950520[P]quickjs/quickjs-libc.c
|
static char **build_envp(JSContext *ctx, JSValue obj)
{
uint32_t len, i;
JSPropertyEnum *tab;
char **envp, *pair;
const char *key, *str;
JSValue val;
size_t key_len, str_len;
if (JS_GetOwnPropertyNames(ctx, &tab, &len, obj,
JS_GPN_STRING_MASK | JS_GPN_ENUM_ONLY) < 0)
return NULL;
envp = js_mallocz(ctx, sizeof(envp[0]) * ((size_t)len + 1));
if (!envp)
goto fail;
for(i = 0; i < len; i++) {
val = JS_GetProperty(ctx, obj, tab[i].atom);
if (JS_IsException(val))
goto fail;
str = JS_ToCString(ctx, val);
JS_FreeValue(ctx, val);
if (!str)
goto fail;
key = JS_AtomToCString(ctx, tab[i].atom);
if (!key) {
JS_FreeCString(ctx, str);
goto fail;
}
key_len = strlen(key);
str_len = strlen(str);
pair = js_malloc(ctx, key_len + str_len + 2);
if (!pair) {
JS_FreeCString(ctx, key);
JS_FreeCString(ctx, str);
goto fail;
}
memcpy(pair, key, key_len);
pair[key_len] = '=';
memcpy(pair + key_len + 1, str, str_len);
pair[key_len + 1 + str_len] = '\0';
envp[i] = pair;
JS_FreeCString(ctx, key);
JS_FreeCString(ctx, str);
}
done:
for(i = 0; i < len; i++)
JS_FreeAtom(ctx, tab[i].atom);
js_free(ctx, tab);
return envp;
fail:
if (envp) {
for(i = 0; i < len; i++)
js_free(ctx, envp[i]);
js_free(ctx, envp);
envp = NULL;
}
goto done;
}
|
O3
|
c
|
build_envp:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r8
movq %rsi, %rcx
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
leaq 0x4(%rsp), %rdx
movq %rcx, 0x18(%rsp)
movq %r8, 0x20(%rsp)
movl $0x11, %r9d
callq 0x23db5
testl %eax, %eax
js 0x1b6be
movl 0x4(%rsp), %eax
leaq 0x8(,%rax,8), %rsi
movq %rbx, %rdi
callq 0xee3f
movq %rax, %r12
movl 0x4(%rsp), %eax
testq %r12, %r12
je 0x1b6c6
testl %eax, %eax
je 0x1b742
xorl %r13d, %r13d
movq %r12, 0x10(%rsp)
movq 0x8(%rsp), %rax
movl 0x4(%rax,%r13,8), %ecx
movq %rbx, %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x21613
movq %rdx, %r15
cmpl $0x6, %r15d
je 0x1b6e9
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
movq %rax, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x21353
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %r14
movq %r15, %rdx
callq 0x1e1d5
testq %r14, %r14
je 0x1b6e9
movq 0x8(%rsp), %rax
movl 0x4(%rax,%r13,8), %esi
movq %rbx, %rdi
callq 0x20f58
testq %rax, %rax
je 0x1b6de
movq %rax, %rbp
movq %r13, 0x30(%rsp)
movq %rax, %rdi
callq 0xe240
movq %rax, %r12
movq %r14, %rdi
callq 0xe240
movq %rax, %r15
leaq (%r12,%rax), %rsi
addq $0x2, %rsi
movq %rbx, %rdi
callq 0xee12
movq %r14, %r13
testq %rax, %rax
je 0x1b6cb
movq %rax, %r14
movq %rax, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0xe5b0
leaq (%r14,%r12), %rax
movq %rax, 0x28(%rsp)
movb $0x3d, (%r14,%r12)
leaq (%r14,%r12), %rdi
incq %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0xe5b0
movq 0x28(%rsp), %rax
movb $0x0, 0x1(%r15,%rax)
movq 0x10(%rsp), %r12
movq 0x30(%rsp), %r15
movq %r14, (%r12,%r15,8)
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x21629
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %r13
callq 0x21629
incq %r13
movl 0x4(%rsp), %eax
cmpq %rax, %r13
jb 0x1b59b
jmp 0x1b71d
xorl %r12d, %r12d
jmp 0x1b74f
xorl %r12d, %r12d
jmp 0x1b71d
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x21629
movq 0x10(%rsp), %r12
movq %r13, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21629
cmpl $0x0, 0x4(%rsp)
je 0x1b70b
xorl %r14d, %r14d
movq (%r12,%r14,8), %rsi
movq %rbx, %rdi
callq 0x1d481
incq %r14
movl 0x4(%rsp), %eax
cmpq %rax, %r14
jb 0x1b6f3
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1d481
xorl %r12d, %r12d
movl 0x4(%rsp), %eax
testl %eax, %eax
je 0x1b742
xorl %r14d, %r14d
movq 0x8(%rsp), %rax
movl 0x4(%rax,%r14,8), %esi
movq %rbx, %rdi
callq 0x20f31
incq %r14
movl 0x4(%rsp), %eax
cmpq %rax, %r14
jb 0x1b724
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1d481
movq %r12, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
build_envp:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r8, rdx
mov rcx, rsi
mov rbx, rdi
lea rsi, [rsp+68h+var_60]
lea rdx, [rsp+68h+var_64]
mov [rsp+68h+var_50], rcx
mov [rsp+68h+var_48], r8
mov r9d, 11h
call JS_GetOwnPropertyNames
test eax, eax
js loc_1B6BE
mov eax, [rsp+68h+var_64]
lea rsi, ds:8[rax*8]
mov rdi, rbx
call js_mallocz
mov r12, rax
mov eax, [rsp+68h+var_64]
test r12, r12
jz loc_1B6C6
test eax, eax
jz loc_1B742
xor r13d, r13d
mov [rsp+68h+var_58], r12
loc_1B59B:
mov rax, [rsp+68h+var_60]
mov ecx, [rax+r13*8+4]
mov rdi, rbx
mov rsi, [rsp+68h+var_50]
mov rdx, [rsp+68h+var_48]
call JS_GetProperty
mov r15, rdx
cmp r15d, 6
jz loc_1B6E9
mov r14, rax
mov rdi, rbx
xor esi, esi
mov rdx, rax
mov rcx, r15
xor r8d, r8d
call JS_ToCStringLen2
mov rdi, rbx
mov rsi, r14
mov r14, rax
mov rdx, r15
call JS_FreeValue
test r14, r14
jz loc_1B6E9
mov rax, [rsp+68h+var_60]
mov esi, [rax+r13*8+4]
mov rdi, rbx
call JS_AtomToCString
test rax, rax
jz loc_1B6DE
mov rbp, rax
mov [rsp+68h+var_38], r13
mov rdi, rax
call _strlen
mov r12, rax
mov rdi, r14
call _strlen
mov r15, rax
lea rsi, [r12+rax]
add rsi, 2
mov rdi, rbx
call js_malloc
mov r13, r14
test rax, rax
jz loc_1B6CB
mov r14, rax
mov rdi, rax
mov rsi, rbp
mov rdx, r12
call _memcpy
lea rax, [r14+r12]
mov [rsp+68h+var_40], rax
mov byte ptr [r14+r12], 3Dh ; '='
lea rdi, [r14+r12]
inc rdi
mov rsi, r13
mov rdx, r15
call _memcpy
mov rax, [rsp+68h+var_40]
mov byte ptr [r15+rax+1], 0
mov r12, [rsp+68h+var_58]
mov r15, [rsp+68h+var_38]
mov [r12+r15*8], r14
mov rdi, rbx
mov rsi, rbp
call JS_FreeCString
mov rdi, rbx
mov rsi, r13
mov r13, r15
call JS_FreeCString
inc r13
mov eax, [rsp+68h+var_64]
cmp r13, rax
jb loc_1B59B
jmp short loc_1B71D
loc_1B6BE:
xor r12d, r12d
jmp loc_1B74F
loc_1B6C6:
xor r12d, r12d
jmp short loc_1B71D
loc_1B6CB:
mov rdi, rbx
mov rsi, rbp
call JS_FreeCString
mov r12, [rsp+68h+var_58]
mov r14, r13
loc_1B6DE:
mov rdi, rbx
mov rsi, r14
call JS_FreeCString
loc_1B6E9:
cmp [rsp+68h+var_64], 0
jz short loc_1B70B
xor r14d, r14d
loc_1B6F3:
mov rsi, [r12+r14*8]
mov rdi, rbx
call js_free
inc r14
mov eax, [rsp+68h+var_64]
cmp r14, rax
jb short loc_1B6F3
loc_1B70B:
mov rdi, rbx
mov rsi, r12
call js_free
xor r12d, r12d
mov eax, [rsp+68h+var_64]
loc_1B71D:
test eax, eax
jz short loc_1B742
xor r14d, r14d
loc_1B724:
mov rax, [rsp+68h+var_60]
mov esi, [rax+r14*8+4]
mov rdi, rbx
call JS_FreeAtom
inc r14
mov eax, [rsp+68h+var_64]
cmp r14, rax
jb short loc_1B724
loc_1B742:
mov rsi, [rsp+68h+var_60]
mov rdi, rbx
call js_free
loc_1B74F:
mov rax, r12
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long build_envp(long long a1, long long a2, long long a3)
{
long long v3; // r12
unsigned int v4; // eax
long long v5; // r13
long long Property; // rax
long long v7; // rdx
long long v8; // r15
long long v9; // rsi
long long v10; // r14
long long v11; // rax
long long v12; // rbp
long long v13; // r12
long long v14; // r15
long long v15; // rax
long long v16; // r13
long long v17; // r14
long long v18; // r15
unsigned long long i; // r14
unsigned long long v20; // r14
unsigned int v22; // [rsp+4h] [rbp-64h] BYREF
long long v23; // [rsp+8h] [rbp-60h] BYREF
long long v24; // [rsp+10h] [rbp-58h]
long long v25; // [rsp+18h] [rbp-50h]
long long v26; // [rsp+20h] [rbp-48h]
long long v27; // [rsp+28h] [rbp-40h]
long long v28; // [rsp+30h] [rbp-38h]
v25 = a2;
v26 = a3;
if ( (int)JS_GetOwnPropertyNames(a1, &v23, &v22, a2, a3, 17LL) >= 0 )
{
v3 = js_mallocz(a1, 8LL * v22 + 8);
v4 = v22;
if ( v3 )
{
if ( !v22 )
{
LABEL_22:
js_free(a1, v23);
return v3;
}
v5 = 0LL;
v24 = v3;
while ( 1 )
{
Property = JS_GetProperty(a1, v25, v26, *(unsigned int *)(v23 + 8 * v5 + 4));
v8 = v7;
if ( (_DWORD)v7 == 6 )
break;
v9 = Property;
v10 = JS_ToCStringLen2(a1, 0LL, Property, v7, 0LL);
JS_FreeValue(a1, v9, v8);
if ( !v10 )
break;
v11 = JS_AtomToCString(a1, *(unsigned int *)(v23 + 8 * v5 + 4));
if ( !v11 )
goto LABEL_14;
v12 = v11;
v28 = v5;
v13 = strlen(v11);
v14 = strlen(v10);
v15 = js_malloc(a1, v13 + v14 + 2);
v16 = v10;
if ( !v15 )
{
JS_FreeCString(a1, v12);
v3 = v24;
LABEL_14:
JS_FreeCString(a1, v10);
break;
}
v17 = v15;
memcpy(v15, v12, v13);
v27 = v17 + v13;
*(_BYTE *)(v17 + v13) = 61;
memcpy(v17 + v13 + 1, v16, v14);
*(_BYTE *)(v14 + v27 + 1) = 0;
v3 = v24;
v18 = v28;
*(_QWORD *)(v24 + 8 * v28) = v17;
JS_FreeCString(a1, v12);
JS_FreeCString(a1, v16);
v5 = v18 + 1;
v4 = v22;
if ( v18 + 1 >= (unsigned long long)v22 )
goto LABEL_19;
}
if ( v22 )
{
for ( i = 0LL; i < v22; js_free(a1, *(_QWORD *)(v3 + 8 * i++)) )
;
}
js_free(a1, v3);
v3 = 0LL;
v4 = v22;
}
else
{
v3 = 0LL;
}
LABEL_19:
if ( v4 )
{
v20 = 0LL;
do
JS_FreeAtom(a1, *(unsigned int *)(v23 + 8 * v20++ + 4));
while ( v20 < v22 );
}
goto LABEL_22;
}
return 0LL;
}
|
build_envp:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R8,RDX
MOV RCX,RSI
MOV RBX,RDI
LEA RSI,[RSP + 0x8]
LEA RDX,[RSP + 0x4]
MOV qword ptr [RSP + 0x18],RCX
MOV qword ptr [RSP + 0x20],R8
MOV R9D,0x11
CALL 0x00123db5
TEST EAX,EAX
JS 0x0011b6be
MOV EAX,dword ptr [RSP + 0x4]
LEA RSI,[0x8 + RAX*0x8]
MOV RDI,RBX
CALL 0x0010ee3f
MOV R12,RAX
MOV EAX,dword ptr [RSP + 0x4]
TEST R12,R12
JZ 0x0011b6c6
TEST EAX,EAX
JZ 0x0011b742
XOR R13D,R13D
MOV qword ptr [RSP + 0x10],R12
LAB_0011b59b:
MOV RAX,qword ptr [RSP + 0x8]
MOV ECX,dword ptr [RAX + R13*0x8 + 0x4]
MOV RDI,RBX
MOV RSI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x20]
CALL 0x00121613
MOV R15,RDX
CMP R15D,0x6
JZ 0x0011b6e9
MOV R14,RAX
MOV RDI,RBX
XOR ESI,ESI
MOV RDX,RAX
MOV RCX,R15
XOR R8D,R8D
CALL 0x00121353
MOV RDI,RBX
MOV RSI,R14
MOV R14,RAX
MOV RDX,R15
CALL 0x0011e1d5
TEST R14,R14
JZ 0x0011b6e9
MOV RAX,qword ptr [RSP + 0x8]
MOV ESI,dword ptr [RAX + R13*0x8 + 0x4]
MOV RDI,RBX
CALL 0x00120f58
TEST RAX,RAX
JZ 0x0011b6de
MOV RBP,RAX
MOV qword ptr [RSP + 0x30],R13
MOV RDI,RAX
CALL 0x0010e240
MOV R12,RAX
MOV RDI,R14
CALL 0x0010e240
MOV R15,RAX
LEA RSI,[R12 + RAX*0x1]
ADD RSI,0x2
MOV RDI,RBX
CALL 0x0010ee12
MOV R13,R14
TEST RAX,RAX
JZ 0x0011b6cb
MOV R14,RAX
MOV RDI,RAX
MOV RSI,RBP
MOV RDX,R12
CALL 0x0010e5b0
LEA RAX,[R14 + R12*0x1]
MOV qword ptr [RSP + 0x28],RAX
MOV byte ptr [R14 + R12*0x1],0x3d
LEA RDI,[R14 + R12*0x1]
INC RDI
MOV RSI,R13
MOV RDX,R15
CALL 0x0010e5b0
MOV RAX,qword ptr [RSP + 0x28]
MOV byte ptr [R15 + RAX*0x1 + 0x1],0x0
MOV R12,qword ptr [RSP + 0x10]
MOV R15,qword ptr [RSP + 0x30]
MOV qword ptr [R12 + R15*0x8],R14
MOV RDI,RBX
MOV RSI,RBP
CALL 0x00121629
MOV RDI,RBX
MOV RSI,R13
MOV R13,R15
CALL 0x00121629
INC R13
MOV EAX,dword ptr [RSP + 0x4]
CMP R13,RAX
JC 0x0011b59b
JMP 0x0011b71d
LAB_0011b6be:
XOR R12D,R12D
JMP 0x0011b74f
LAB_0011b6c6:
XOR R12D,R12D
JMP 0x0011b71d
LAB_0011b6cb:
MOV RDI,RBX
MOV RSI,RBP
CALL 0x00121629
MOV R12,qword ptr [RSP + 0x10]
MOV R14,R13
LAB_0011b6de:
MOV RDI,RBX
MOV RSI,R14
CALL 0x00121629
LAB_0011b6e9:
CMP dword ptr [RSP + 0x4],0x0
JZ 0x0011b70b
XOR R14D,R14D
LAB_0011b6f3:
MOV RSI,qword ptr [R12 + R14*0x8]
MOV RDI,RBX
CALL 0x0011d481
INC R14
MOV EAX,dword ptr [RSP + 0x4]
CMP R14,RAX
JC 0x0011b6f3
LAB_0011b70b:
MOV RDI,RBX
MOV RSI,R12
CALL 0x0011d481
XOR R12D,R12D
MOV EAX,dword ptr [RSP + 0x4]
LAB_0011b71d:
TEST EAX,EAX
JZ 0x0011b742
XOR R14D,R14D
LAB_0011b724:
MOV RAX,qword ptr [RSP + 0x8]
MOV ESI,dword ptr [RAX + R14*0x8 + 0x4]
MOV RDI,RBX
CALL 0x00120f31
INC R14
MOV EAX,dword ptr [RSP + 0x4]
CMP R14,RAX
JC 0x0011b724
LAB_0011b742:
MOV RSI,qword ptr [RSP + 0x8]
MOV RDI,RBX
CALL 0x0011d481
LAB_0011b74f:
MOV RAX,R12
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long build_envp(int8 param_1,int8 param_2,int8 param_3)
{
int iVar1;
long lVar2;
char *__s;
char *__s_00;
size_t __n;
size_t __n_00;
void *__dest;
ulong uVar3;
int1 auVar4 [16];
uint local_64;
long local_60;
long local_58;
int8 local_50;
int8 local_48;
long local_40;
ulong local_38;
local_50 = param_2;
local_48 = param_3;
iVar1 = JS_GetOwnPropertyNames(param_1,&local_60,&local_64,param_2,param_3,0x11);
if (iVar1 < 0) {
return 0;
}
lVar2 = js_mallocz(param_1,(ulong)local_64 * 8 + 8);
if (lVar2 == 0) {
lVar2 = 0;
}
else {
if (local_64 == 0) goto LAB_0011b742;
uVar3 = 0;
local_58 = lVar2;
do {
auVar4 = JS_GetProperty(param_1,local_50,local_48,*(int4 *)(local_60 + 4 + uVar3 * 8));
if (auVar4._8_4_ == 6) {
LAB_0011b6e9:
if (local_64 != 0) {
uVar3 = 0;
do {
js_free(param_1,*(int8 *)(lVar2 + uVar3 * 8));
uVar3 = uVar3 + 1;
} while (uVar3 < local_64);
}
js_free(param_1,lVar2);
lVar2 = 0;
break;
}
__s = (char *)JS_ToCStringLen2(param_1,0,auVar4._0_8_,auVar4._8_8_,0);
JS_FreeValue(param_1,auVar4._0_8_,auVar4._8_8_);
if (__s == (char *)0x0) goto LAB_0011b6e9;
__s_00 = (char *)JS_AtomToCString(param_1,*(int4 *)(local_60 + 4 + uVar3 * 8));
if (__s_00 == (char *)0x0) {
LAB_0011b6de:
JS_FreeCString(param_1,__s);
goto LAB_0011b6e9;
}
local_38 = uVar3;
__n = strlen(__s_00);
__n_00 = strlen(__s);
__dest = (void *)js_malloc(param_1,__n + __n_00 + 2);
if (__dest == (void *)0x0) {
JS_FreeCString(param_1,__s_00);
lVar2 = local_58;
goto LAB_0011b6de;
}
memcpy(__dest,__s_00,__n);
local_40 = (long)__dest + __n;
*(int1 *)((long)__dest + __n) = 0x3d;
memcpy((void *)((long)__dest + __n + 1),__s,__n_00);
uVar3 = local_38;
lVar2 = local_58;
*(int1 *)(__n_00 + 1 + local_40) = 0;
*(void **)(local_58 + local_38 * 8) = __dest;
JS_FreeCString(param_1,__s_00);
JS_FreeCString(param_1,__s);
uVar3 = uVar3 + 1;
} while (uVar3 < local_64);
}
if (local_64 != 0) {
uVar3 = 0;
do {
JS_FreeAtom(param_1,*(int4 *)(local_60 + 4 + uVar3 * 8));
uVar3 = uVar3 + 1;
} while (uVar3 < local_64);
}
LAB_0011b742:
js_free(param_1,local_60);
return lVar2;
}
|
|
60,661
|
gguf_get_val_i32
|
monkey531[P]llama/ggml/src/gguf.cpp
|
int32_t gguf_get_val_i32(const struct gguf_context * ctx, int64_t key_id) {
GGML_ASSERT(key_id >= 0 && key_id < gguf_get_n_kv(ctx));
GGML_ASSERT(ctx->kv[key_id].get_ne() == 1);
return ctx->kv[key_id].get_val<int32_t>();
}
|
O3
|
cpp
|
gguf_get_val_i32:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
js 0x3d339
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq 0x10(%rbx), %rax
subq %rdi, %rax
sarq $0x3, %rax
movabsq $0x2e8ba2e8ba2e8ba3, %rcx # imm = 0x2E8BA2E8BA2E8BA3
imulq %rax, %rcx
cmpq %rsi, %rcx
jle 0x3d339
imulq $0x58, %rsi, %r14
addq %r14, %rdi
callq 0x16620
cmpq $0x1, %rax
jne 0x3d355
addq 0x8(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x169c0
movl (%rax), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1c995(%rip), %rdi # 0x59cd5
leaq 0xd316(%rip), %rdx # 0x4a65d
leaq 0x1ce12(%rip), %rcx # 0x5a160
movl $0x341, %esi # imm = 0x341
jmp 0x3d36f
leaq 0x1c979(%rip), %rdi # 0x59cd5
leaq 0xd2fa(%rip), %rdx # 0x4a65d
leaq 0x1cec5(%rip), %rcx # 0x5a22f
movl $0x342, %esi # imm = 0x342
xorl %eax, %eax
callq 0x17c60
|
gguf_get_val_i32:
push r14
push rbx
push rax
test rsi, rsi
js short loc_3D339
mov rbx, rdi
mov rdi, [rdi+8]
mov rax, [rbx+10h]
sub rax, rdi
sar rax, 3
mov rcx, 2E8BA2E8BA2E8BA3h
imul rcx, rax
cmp rcx, rsi
jle short loc_3D339
imul r14, rsi, 58h ; 'X'
add rdi, r14; this
call __ZNK7gguf_kv6get_neEv; gguf_kv::get_ne(void)
cmp rax, 1
jnz short loc_3D355
add r14, [rbx+8]
mov rdi, r14
xor esi, esi
call __ZNK7gguf_kv7get_valIiEERKT_m; gguf_kv::get_val<int>(ulong)
mov eax, [rax]
add rsp, 8
pop rbx
pop r14
retn
loc_3D339:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aKeyId0KeyIdGgu; "key_id >= 0 && key_id < gguf_get_n_kv(c"...
mov esi, 341h
jmp short loc_3D36F
loc_3D355:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aCtxKvKeyIdGetN; "ctx->kv[key_id].get_ne() == 1"
mov esi, 342h
loc_3D36F:
xor eax, eax
call _ggml_abort
|
long long gguf_get_val_i32(long long a1, long long a2, long long a3, long long a4, int a5, int a6)
{
long long v7; // rdi
const char *v9; // rcx
int v10; // esi
if ( a2 < 0 || (v7 = *(_QWORD *)(a1 + 8), 0x2E8BA2E8BA2E8BA3LL * ((*(_QWORD *)(a1 + 16) - v7) >> 3) <= a2) )
{
v9 = "key_id >= 0 && key_id < gguf_get_n_kv(ctx)";
v10 = 833;
goto LABEL_7;
}
if ( gguf_kv::get_ne((gguf_kv *)(88 * a2 + v7)) != 1 )
{
v9 = "ctx->kv[key_id].get_ne() == 1";
v10 = 834;
LABEL_7:
ggml_abort(
(unsigned int)"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/gguf.cpp",
v10,
(unsigned int)"GGML_ASSERT(%s) failed",
(_DWORD)v9,
a5,
a6);
}
return *(unsigned int *)gguf_kv::get_val<int>(*(_QWORD *)(a1 + 8) + 88 * a2, 0LL);
}
|
gguf_get_val_i32:
PUSH R14
PUSH RBX
PUSH RAX
TEST RSI,RSI
JS 0x0013d339
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x8]
MOV RAX,qword ptr [RBX + 0x10]
SUB RAX,RDI
SAR RAX,0x3
MOV RCX,0x2e8ba2e8ba2e8ba3
IMUL RCX,RAX
CMP RCX,RSI
JLE 0x0013d339
IMUL R14,RSI,0x58
ADD RDI,R14
CALL 0x00116620
CMP RAX,0x1
JNZ 0x0013d355
ADD R14,qword ptr [RBX + 0x8]
MOV RDI,R14
XOR ESI,ESI
CALL 0x001169c0
MOV EAX,dword ptr [RAX]
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_0013d339:
LEA RDI,[0x159cd5]
LEA RDX,[0x14a65d]
LEA RCX,[0x15a160]
MOV ESI,0x341
JMP 0x0013d36f
LAB_0013d355:
LEA RDI,[0x159cd5]
LEA RDX,[0x14a65d]
LEA RCX,[0x15a22f]
MOV ESI,0x342
LAB_0013d36f:
XOR EAX,EAX
CALL 0x00117c60
|
int gguf_get_val_i32(long param_1,long param_2)
{
int *piVar1;
long lVar2;
char *pcVar3;
int8 uVar4;
if ((param_2 < 0) ||
(lVar2 = (*(long *)(param_1 + 0x10) - *(long *)(param_1 + 8) >> 3) * 0x2e8ba2e8ba2e8ba3,
lVar2 - param_2 == 0 || lVar2 < param_2)) {
pcVar3 = "key_id >= 0 && key_id < gguf_get_n_kv(ctx)";
uVar4 = 0x341;
}
else {
lVar2 = gguf_kv::get_ne((gguf_kv *)(*(long *)(param_1 + 8) + param_2 * 0x58));
if (lVar2 == 1) {
piVar1 = gguf_kv::get_val<int>((gguf_kv *)(param_2 * 0x58 + *(long *)(param_1 + 8)),0);
return *piVar1;
}
pcVar3 = "ctx->kv[key_id].get_ne() == 1";
uVar4 = 0x342;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/gguf.cpp",uVar4,
"GGML_ASSERT(%s) failed",pcVar3);
}
|
|
60,662
|
ft_linearize
|
eloqsql/storage/myisam/ft_parser.c
|
FT_WORD * ft_linearize(TREE *wtree, MEM_ROOT *mem_root)
{
FT_WORD *wlist,*p;
FT_DOCSTAT docstat;
DBUG_ENTER("ft_linearize");
if ((wlist=(FT_WORD *) alloc_root(mem_root, sizeof(FT_WORD)*
(1+wtree->elements_in_tree))))
{
docstat.list=wlist;
docstat.uniq=wtree->elements_in_tree;
docstat.sum=0;
tree_walk(wtree,(tree_walk_action)&walk_and_copy,&docstat,left_root_right);
}
delete_tree(wtree, 0);
if (!wlist)
DBUG_RETURN(NULL);
docstat.list->pos=NULL;
for (p=wlist;p->pos;p++)
{
p->weight=PRENORM_IN_USE;
}
for (p=wlist;p->pos;p++)
{
p->weight/=NORM_IN_USE;
}
DBUG_RETURN(wlist);
}
|
O3
|
c
|
ft_linearize:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rax
movq %rdi, %r14
movl 0x20c(%rdi), %ecx
incl %ecx
shlq $0x3, %rcx
leaq (%rcx,%rcx,2), %rsi
movq %rax, %rdi
callq 0x9fb5b
movq %rax, %rbx
testq %rax, %rax
je 0x76a9c
leaq -0x38(%rbp), %r15
movq %rbx, (%r15)
movl 0x20c(%r14), %eax
movl %eax, 0x8(%r15)
xorl %r12d, %r12d
movq %r12, 0x10(%r15)
leaq 0xa9(%rip), %rsi # 0x76ab6
movq %r14, %rdi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0xa825f
movq %r14, %rdi
xorl %esi, %esi
callq 0xa76fa
movq (%r15), %rax
movq %r12, (%rax)
cmpq %r12, (%rbx)
je 0x76aa6
movsd -0x28(%rbp), %xmm0
movl -0x30(%rbp), %eax
cvtsi2sd %rax, %xmm1
leaq 0x8(%rbx), %rax
movsd (%rax), %xmm2
divsd %xmm0, %xmm2
mulsd %xmm1, %xmm2
movsd %xmm2, (%rax)
cmpq $0x0, 0x10(%rax)
leaq 0x18(%rax), %rax
jne 0x76a40
cmpq $0x0, (%rbx)
je 0x76aa6
movl -0x30(%rbp), %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
mulsd 0x6c65c(%rip), %xmm0 # 0xe30d0
addsd 0x6c64c(%rip), %xmm0 # 0xe30c8
movq %rbx, %rax
addq $0x8, %rax
movsd (%rax), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rax)
cmpq $0x0, 0x10(%rax)
leaq 0x18(%rax), %rax
jne 0x76a83
jmp 0x76aa6
movq %r14, %rdi
xorl %esi, %esi
callq 0xa76fa
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
ft_linearize:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 20h
mov rax, rsi
mov r14, rdi
mov ecx, [rdi+20Ch]
inc ecx
shl rcx, 3
lea rsi, [rcx+rcx*2]
mov rdi, rax
call alloc_root
mov rbx, rax
test rax, rax
jz loc_76A9C
lea r15, [rbp+var_38]
mov [r15], rbx
mov eax, [r14+20Ch]
mov [r15+8], eax
xor r12d, r12d
mov [r15+10h], r12
lea rsi, walk_and_copy_1
mov rdi, r14
mov rdx, r15
xor ecx, ecx
call tree_walk
mov rdi, r14
xor esi, esi
call delete_tree
mov rax, [r15]
mov [rax], r12
cmp [rbx], r12
jz short loc_76AA6
movsd xmm0, [rbp+var_28]
mov eax, [rbp+var_30]
cvtsi2sd xmm1, rax
lea rax, [rbx+8]
loc_76A40:
movsd xmm2, qword ptr [rax]
divsd xmm2, xmm0
mulsd xmm2, xmm1
movsd qword ptr [rax], xmm2
cmp qword ptr [rax+10h], 0
lea rax, [rax+18h]
jnz short loc_76A40
cmp qword ptr [rbx], 0
jz short loc_76AA6
mov eax, [rbp+var_30]
xorps xmm0, xmm0
cvtsi2sd xmm0, rax
mulsd xmm0, cs:qword_E30D0
addsd xmm0, cs:qword_E30C8
mov rax, rbx
add rax, 8
loc_76A83:
movsd xmm1, qword ptr [rax]
divsd xmm1, xmm0
movsd qword ptr [rax], xmm1
cmp qword ptr [rax+10h], 0
lea rax, [rax+18h]
jnz short loc_76A83
jmp short loc_76AA6
loc_76A9C:
mov rdi, r14
xor esi, esi
call delete_tree
loc_76AA6:
mov rax, rbx
add rsp, 20h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
_QWORD * ft_linearize(long long a1, long long a2)
{
long long v2; // rax
_QWORD *v3; // rbx
double v4; // xmm0_8
double v5; // xmm1_8
double *v6; // rax
bool v7; // zf
double v8; // xmm0_8
double *v9; // rax
_QWORD *v11; // [rsp+8h] [rbp-38h] BYREF
int v12; // [rsp+10h] [rbp-30h]
double v13; // [rsp+18h] [rbp-28h]
v2 = alloc_root(a2, 24LL * (unsigned int)(*(_DWORD *)(a1 + 524) + 1));
v3 = (_QWORD *)v2;
if ( v2 )
{
v11 = (_QWORD *)v2;
v12 = *(_DWORD *)(a1 + 524);
v13 = 0.0;
tree_walk(a1, walk_and_copy_1, &v11, 0LL);
delete_tree(a1, 0LL);
*v11 = 0LL;
if ( *v3 )
{
v4 = v13;
v5 = (double)v12;
v6 = (double *)(v3 + 1);
do
{
*v6 = *v6 / v4 * v5;
v7 = *((_QWORD *)v6 + 2) == 0LL;
v6 += 3;
}
while ( !v7 );
if ( *v3 )
{
v8 = (double)v12 * 0.0115 + 1.0;
v9 = (double *)(v3 + 1);
do
{
*v9 = *v9 / v8;
v7 = *((_QWORD *)v9 + 2) == 0LL;
v9 += 3;
}
while ( !v7 );
}
}
}
else
{
delete_tree(a1, 0LL);
}
return v3;
}
|
ft_linearize:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x20
MOV RAX,RSI
MOV R14,RDI
MOV ECX,dword ptr [RDI + 0x20c]
INC ECX
SHL RCX,0x3
LEA RSI,[RCX + RCX*0x2]
MOV RDI,RAX
CALL 0x0019fb5b
MOV RBX,RAX
TEST RAX,RAX
JZ 0x00176a9c
LEA R15,[RBP + -0x38]
MOV qword ptr [R15],RBX
MOV EAX,dword ptr [R14 + 0x20c]
MOV dword ptr [R15 + 0x8],EAX
XOR R12D,R12D
MOV qword ptr [R15 + 0x10],R12
LEA RSI,[0x176ab6]
MOV RDI,R14
MOV RDX,R15
XOR ECX,ECX
CALL 0x001a825f
MOV RDI,R14
XOR ESI,ESI
CALL 0x001a76fa
MOV RAX,qword ptr [R15]
MOV qword ptr [RAX],R12
CMP qword ptr [RBX],R12
JZ 0x00176aa6
MOVSD XMM0,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RBP + -0x30]
CVTSI2SD XMM1,RAX
LEA RAX,[RBX + 0x8]
LAB_00176a40:
MOVSD XMM2,qword ptr [RAX]
DIVSD XMM2,XMM0
MULSD XMM2,XMM1
MOVSD qword ptr [RAX],XMM2
CMP qword ptr [RAX + 0x10],0x0
LEA RAX,[RAX + 0x18]
JNZ 0x00176a40
CMP qword ptr [RBX],0x0
JZ 0x00176aa6
MOV EAX,dword ptr [RBP + -0x30]
XORPS XMM0,XMM0
CVTSI2SD XMM0,RAX
MULSD XMM0,qword ptr [0x001e30d0]
ADDSD XMM0,qword ptr [0x001e30c8]
MOV RAX,RBX
ADD RAX,0x8
LAB_00176a83:
MOVSD XMM1,qword ptr [RAX]
DIVSD XMM1,XMM0
MOVSD qword ptr [RAX],XMM1
CMP qword ptr [RAX + 0x10],0x0
LEA RAX,[RAX + 0x18]
JNZ 0x00176a83
JMP 0x00176aa6
LAB_00176a9c:
MOV RDI,R14
XOR ESI,ESI
CALL 0x001a76fa
LAB_00176aa6:
MOV RAX,RBX
ADD RSP,0x20
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
long * ft_linearize(long param_1,int8 param_2)
{
double *pdVar1;
long *plVar2;
double *pdVar3;
double dVar4;
long *local_40;
uint local_38;
double local_30;
plVar2 = (long *)alloc_root(param_2,(ulong)(*(int *)(param_1 + 0x20c) + 1) * 0x18);
if (plVar2 == (long *)0x0) {
delete_tree(param_1,0);
}
else {
local_38 = *(uint *)(param_1 + 0x20c);
local_30 = 0.0;
local_40 = plVar2;
tree_walk(param_1,walk_and_copy,&local_40,0);
delete_tree(param_1,0);
*local_40 = 0;
if (*plVar2 != 0) {
pdVar3 = (double *)(plVar2 + 1);
do {
*pdVar3 = (*pdVar3 / local_30) * (double)local_38;
pdVar1 = pdVar3 + 2;
pdVar3 = pdVar3 + 3;
} while (*pdVar1 != 0.0);
if (*plVar2 != 0) {
dVar4 = (double)local_38 * _DAT_001e30d0 + DAT_001e30c8;
pdVar3 = (double *)(plVar2 + 1);
do {
*pdVar3 = *pdVar3 / dVar4;
pdVar1 = pdVar3 + 2;
pdVar3 = pdVar3 + 3;
} while (*pdVar1 != 0.0);
}
}
}
return plVar2;
}
|
|
60,663
|
common_log::add(ggml_log_level, char const*, __va_list_tag*)
|
monkey531[P]llama/common/log.cpp
|
void add(enum ggml_log_level level, const char * fmt, va_list args) {
std::lock_guard<std::mutex> lock(mtx);
if (!running) {
// discard messages while the worker thread is paused
return;
}
auto & entry = entries[tail];
{
// cannot use args twice, so make a copy in case we need to expand the buffer
va_list args_copy;
va_copy(args_copy, args);
#if 1
const size_t n = vsnprintf(entry.msg.data(), entry.msg.size(), fmt, args);
if (n >= entry.msg.size()) {
entry.msg.resize(n + 1);
vsnprintf(entry.msg.data(), entry.msg.size(), fmt, args_copy);
}
#else
// hack for bolding arguments
std::stringstream ss;
for (int i = 0; fmt[i] != 0; i++) {
if (fmt[i] == '%') {
ss << LOG_COL_BOLD;
while (fmt[i] != ' ' && fmt[i] != ')' && fmt[i] != ']' && fmt[i] != 0) ss << fmt[i++];
ss << LOG_COL_DEFAULT;
if (fmt[i] == 0) break;
}
ss << fmt[i];
}
const size_t n = vsnprintf(entry.msg.data(), entry.msg.size(), ss.str().c_str(), args);
if (n >= entry.msg.size()) {
entry.msg.resize(n + 1);
vsnprintf(entry.msg.data(), entry.msg.size(), ss.str().c_str(), args_copy);
}
#endif
va_end(args_copy);
}
entry.level = level;
entry.prefix = prefix;
entry.timestamp = 0;
if (timestamps) {
entry.timestamp = t_us() - t_start;
}
entry.is_end = false;
tail = (tail + 1) % entries.size();
if (tail == head) {
// expand the buffer
std::vector<common_log_entry> new_entries(2*entries.size());
size_t new_tail = 0;
do {
new_entries[new_tail] = std::move(entries[head]);
head = (head + 1) % entries.size();
new_tail = (new_tail + 1);
} while (head != tail);
head = 0;
tail = new_tail;
for (size_t i = tail; i < new_entries.size(); i++) {
new_entries[i].msg.resize(256);
}
entries = std::move(new_entries);
}
cv.notify_one();
}
|
O3
|
cpp
|
common_log::add(ggml_log_level, char const*, __va_list_tag*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r15
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
callq 0x189b0
testl %eax, %eax
jne 0x7f79c
cmpb $0x1, 0x6a(%rbx)
jne 0x7f785
movl %ebp, 0xc(%rsp)
movq 0x78(%rbx), %r13
movq 0x98(%rbx), %rax
leaq (%rax,%rax,2), %rbp
shlq $0x4, %rbp
movq %r13, %r12
addq %rbp, %r12
movq 0x10(%r15), %rax
movq %rax, 0x40(%rsp)
movups (%r15), %xmm0
movaps %xmm0, 0x30(%rsp)
movq 0x10(%r13,%rbp), %rdi
movq 0x18(%r13,%rbp), %rsi
subq %rdi, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x18d38
movslq %eax, %rsi
movq 0x18(%r13,%rbp), %rax
subq 0x10(%r13,%rbp), %rax
cmpq %rsi, %rax
ja 0x7f584
leaq 0x10(,%rbp), %rdi
addq %r13, %rdi
incq %rsi
callq 0x2abea
movq 0x10(%r12), %rdi
movq 0x18(%r12), %rsi
subq %rdi, %rsi
leaq 0x30(%rsp), %rcx
movq %r14, %rdx
callq 0x18d38
movl 0xc(%rsp), %eax
movl %eax, (%r12)
movb 0x68(%rbx), %al
movb %al, 0x4(%r12)
movq $0x0, 0x8(%r12)
cmpb $0x1, 0x69(%rbx)
jne 0x7f5cc
callq 0x18080
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rdx
addq %rax, %rdx
subq 0x70(%rbx), %rdx
movq %rdx, 0x8(%r12)
movb $0x0, 0x28(%r12)
movq 0x80(%rbx), %rsi
movq 0x98(%rbx), %rax
incq %rax
subq 0x78(%rbx), %rsi
sarq $0x4, %rsi
movabsq $-0x5555555555555555, %r14 # imm = 0xAAAAAAAAAAAAAAAB
imulq %r14, %rsi
xorl %edx, %edx
divq %rsi
movq %rdx, 0x98(%rbx)
cmpq 0x90(%rbx), %rdx
jne 0x7f77c
addq %rsi, %rsi
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rdx
movq %rbx, (%rsp)
callq 0x8020e
movq 0x78(%rbx), %rcx
movq 0x90(%rbx), %rdx
movl $0x10, %r12d
xorl %ebp, %ebp
xorl %r13d, %r13d
leaq (%rdx,%rdx,2), %rax
shlq $0x4, %rax
movq 0x10(%rsp), %r15
movq %r14, %rbx
leaq (%rcx,%rax), %r14
addq $0x10, %r14
movups -0x10(%r14), %xmm0
movups %xmm0, (%r15,%rbp)
leaq (%r15,%r12), %rdi
movq %r14, %rsi
callq 0x8028c
movb 0x18(%r14), %al
movq %rbx, %r14
movq (%rsp), %rbx
movb %al, 0x28(%r15,%rbp)
movq 0x90(%rbx), %rax
incq %rax
movq 0x78(%rbx), %rcx
movq 0x80(%rbx), %rsi
movq %rsi, %rdi
subq %rcx, %rdi
sarq $0x4, %rdi
imulq %r14, %rdi
xorl %edx, %edx
divq %rdi
movq %rdx, 0x90(%rbx)
incq %r13
addq $0x30, %r12
addq $0x30, %rbp
cmpq 0x98(%rbx), %rdx
jne 0x7f63e
movq $0x0, 0x90(%rbx)
movq %r13, 0x98(%rbx)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, %rdx
subq %rdi, %rdx
sarq $0x4, %rdx
imulq %r14, %rdx
cmpq %rdx, %r13
jae 0x7f72e
addq %r12, %rdi
movl $0x100, %esi # imm = 0x100
callq 0x2abea
incq %r13
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, %rcx
subq %rdi, %rcx
sarq $0x4, %rcx
imulq %r14, %rcx
addq $0x30, %r12
cmpq %rcx, %r13
jb 0x7f6f2
movq 0x78(%rbx), %rcx
movq 0x80(%rbx), %rsi
movq 0x88(%rbx), %rdx
movq %rdi, 0x78(%rbx)
movq %rax, 0x80(%rbx)
leaq 0x10(%rsp), %r14
movq 0x10(%r14), %rax
movq %rax, 0x88(%rbx)
leaq 0x30(%rsp), %rdi
movq %rcx, (%rdi)
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
callq 0x7fa84
movq %r14, %rdi
callq 0x7fa84
leaq 0x30(%rbx), %rdi
callq 0x18370
movq %rbx, %rdi
callq 0x18520
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x18480
jmp 0x7f7a9
movq %rbx, (%rsp)
movq %rax, %r14
jmp 0x7f7bb
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x7fa84
movq (%rsp), %rdi
callq 0x18520
movq %r14, %rdi
callq 0x18b90
|
_ZN10common_log3addE14ggml_log_levelPKcP13__va_list_tag:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov r15, rcx
mov r14, rdx
mov ebp, esi
mov rbx, rdi
call _pthread_mutex_lock
test eax, eax
jnz loc_7F79C
cmp byte ptr [rbx+6Ah], 1
jnz loc_7F785
mov [rsp+78h+var_6C], ebp
mov r13, [rbx+78h]
mov rax, [rbx+98h]
lea rbp, [rax+rax*2]
shl rbp, 4
mov r12, r13
add r12, rbp
mov rax, [r15+10h]
mov [rsp+78h+var_38], rax
movups xmm0, xmmword ptr [r15]
movaps [rsp+78h+var_48], xmm0
mov rdi, [r13+rbp+10h]
mov rsi, [r13+rbp+18h]
sub rsi, rdi
mov rdx, r14
mov rcx, r15
call vsnprintf
movsxd rsi, eax
mov rax, [r13+rbp+18h]
sub rax, [r13+rbp+10h]
cmp rax, rsi
ja short loc_7F584
lea rdi, ds:10h[rbp]
add rdi, r13
inc rsi
call _ZNSt6vectorIcSaIcEE6resizeEm; std::vector<char>::resize(ulong)
mov rdi, [r12+10h]; this
mov rsi, [r12+18h]
sub rsi, rdi
lea rcx, [rsp+78h+var_48]
mov rdx, r14
call vsnprintf
loc_7F584:
mov eax, [rsp+78h+var_6C]
mov [r12], eax
mov al, [rbx+68h]
mov [r12+4], al
mov qword ptr [r12+8], 0
cmp byte ptr [rbx+69h], 1
jnz short loc_7F5CC
call __ZNSt6chrono3_V212system_clock3nowEv; std::chrono::_V2::system_clock::now(void)
mov rcx, 20C49BA5E353F7CFh
imul rcx
mov rax, rdx
shr rax, 3Fh
sar rdx, 7
add rdx, rax
sub rdx, [rbx+70h]
mov [r12+8], rdx
loc_7F5CC:
mov byte ptr [r12+28h], 0
mov rsi, [rbx+80h]
mov rax, [rbx+98h]
inc rax
sub rsi, [rbx+78h]
sar rsi, 4
mov r14, 0AAAAAAAAAAAAAAABh
imul rsi, r14
xor edx, edx
div rsi
mov [rbx+98h], rdx
cmp rdx, [rbx+90h]
jnz loc_7F77C
add rsi, rsi
lea rdi, [rsp+78h+var_68]
lea rdx, [rsp+78h+var_48]
mov [rsp+78h+var_78], rbx
call _ZNSt6vectorI16common_log_entrySaIS0_EEC2EmRKS1_; std::vector<common_log_entry>::vector(ulong,std::allocator<common_log_entry> const&)
mov rcx, [rbx+78h]
mov rdx, [rbx+90h]
mov r12d, 10h
xor ebp, ebp
xor r13d, r13d
loc_7F63E:
lea rax, [rdx+rdx*2]
shl rax, 4
mov r15, [rsp+78h+var_68]
mov rbx, r14
lea r14, [rcx+rax]
add r14, 10h
movups xmm0, xmmword ptr [r14-10h]
movups xmmword ptr [r15+rbp], xmm0
lea rdi, [r15+r12]
mov rsi, r14
call _ZNSt6vectorIcSaIcEE14_M_move_assignEOS1_St17integral_constantIbLb1EE; std::vector<char>::_M_move_assign(std::vector<char>&&,std::integral_constant<bool,true>)
mov al, [r14+18h]
mov r14, rbx
mov rbx, [rsp+78h+var_78]
mov [r15+rbp+28h], al
mov rax, [rbx+90h]
inc rax
mov rcx, [rbx+78h]
mov rsi, [rbx+80h]
mov rdi, rsi
sub rdi, rcx
sar rdi, 4
imul rdi, r14
xor edx, edx
div rdi
mov [rbx+90h], rdx
inc r13
add r12, 30h ; '0'
add rbp, 30h ; '0'
cmp rdx, [rbx+98h]
jnz loc_7F63E
mov qword ptr [rbx+90h], 0
mov [rbx+98h], r13
mov rdi, [rsp+78h+var_68]
mov rax, [rsp+78h+var_60]
mov rdx, rax
sub rdx, rdi
sar rdx, 4
imul rdx, r14
cmp r13, rdx
jnb short loc_7F72E
loc_7F6F2:
add rdi, r12
mov esi, 100h
call _ZNSt6vectorIcSaIcEE6resizeEm; std::vector<char>::resize(ulong)
inc r13
mov rdi, [rsp+78h+var_68]
mov rax, [rsp+78h+var_60]
mov rcx, rax
sub rcx, rdi
sar rcx, 4
imul rcx, r14
add r12, 30h ; '0'
cmp r13, rcx
jb short loc_7F6F2
mov rcx, [rbx+78h]
mov rsi, [rbx+80h]
loc_7F72E:
mov rdx, [rbx+88h]
mov [rbx+78h], rdi
mov [rbx+80h], rax
lea r14, [rsp+78h+var_68]
mov rax, [r14+10h]
mov [rbx+88h], rax
lea rdi, [rsp+78h+var_48]
mov [rdi], rcx
mov [rdi+8], rsi
mov [rdi+10h], rdx
xorps xmm0, xmm0
movaps xmmword ptr [r14], xmm0
mov qword ptr [r14+10h], 0
call _ZNSt6vectorI16common_log_entrySaIS0_EED2Ev; std::vector<common_log_entry>::~vector()
mov rdi, r14
call _ZNSt6vectorI16common_log_entrySaIS0_EED2Ev; std::vector<common_log_entry>::~vector()
loc_7F77C:
lea rdi, [rbx+30h]; this
call __ZNSt18condition_variable10notify_oneEv; std::condition_variable::notify_one(void)
loc_7F785:
mov rdi, rbx
call _pthread_mutex_unlock
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_7F79C:
mov edi, eax; int
call __ZSt20__throw_system_errori; std::__throw_system_error(int)
jmp short loc_7F7A9
mov [rsp+78h+var_78], rbx
loc_7F7A9:
mov r14, rax
jmp short loc_7F7BB
mov r14, rax
lea rdi, [rsp+78h+var_68]
call _ZNSt6vectorI16common_log_entrySaIS0_EED2Ev; std::vector<common_log_entry>::~vector()
loc_7F7BB:
mov rdi, [rsp+78h+var_78]
call _pthread_mutex_unlock
mov rdi, r14
call __Unwind_Resume
|
long long common_log::add(long long a1, int a2, long long a3, __int128 *a4)
{
_QWORD *v6; // rbx
int v7; // eax
long long v8; // r13
long long v9; // rbp
long long v10; // r12
std::chrono::_V2::system_clock *v11; // rdi
unsigned long long v12; // rsi
unsigned long long v13; // r14
unsigned long long v14; // rsi
unsigned long long v15; // rdx
long long v16; // rcx
unsigned long long v17; // rdx
long long v18; // r12
long long v19; // rbp
unsigned long long v20; // r13
long long v21; // r15
unsigned long long v22; // rbx
long long v23; // r14
char v24; // al
long long v25; // rsi
__int128 v26; // kr00_16
long long v27; // rdx
_QWORD *v29; // [rsp+0h] [rbp-78h]
__int128 v31; // [rsp+10h] [rbp-68h] BYREF
long long v32; // [rsp+20h] [rbp-58h]
__int128 v33; // [rsp+30h] [rbp-48h] BYREF
long long v34; // [rsp+40h] [rbp-38h]
v6 = (_QWORD *)a1;
v7 = pthread_mutex_lock();
if ( v7 )
std::__throw_system_error(v7);
if ( *(_BYTE *)(a1 + 106) == 1 )
{
v8 = *(_QWORD *)(a1 + 120);
v9 = 48LL * *(_QWORD *)(a1 + 152);
v10 = v9 + v8;
v34 = *((_QWORD *)a4 + 2);
v33 = *a4;
v11 = *(std::chrono::_V2::system_clock **)(v8 + v9 + 16);
v12 = (int)vsnprintf(v11, *(_QWORD *)(v8 + v9 + 24) - (_QWORD)v11, a3, a4);
if ( *(_QWORD *)(v8 + v9 + 24) - *(_QWORD *)(v8 + v9 + 16) <= v12 )
{
std::vector<char>::resize((_QWORD *)(v8 + v9 + 16), v12 + 1);
v11 = *(std::chrono::_V2::system_clock **)(v10 + 16);
vsnprintf(v11, *(_QWORD *)(v10 + 24) - (_QWORD)v11, a3, &v33);
}
*(_DWORD *)v10 = a2;
*(_BYTE *)(v10 + 4) = *((_BYTE *)v6 + 104);
*(_QWORD *)(v10 + 8) = 0LL;
if ( *((_BYTE *)v6 + 105) == 1 )
*(_QWORD *)(v10 + 8) = std::chrono::_V2::system_clock::now(v11) / 1000LL - v6[14];
*(_BYTE *)(v10 + 40) = 0;
v13 = 0xAAAAAAAAAAAAAAABLL;
v14 = 0xAAAAAAAAAAAAAAABLL * ((long long)(v6[16] - v6[15]) >> 4);
v15 = (v6[19] + 1LL) % v14;
v6[19] = v15;
if ( v15 == v6[18] )
{
v29 = v6;
std::vector<common_log_entry>::vector(&v31, 2 * v14, &v33);
v16 = v6[15];
v17 = v6[18];
v18 = 16LL;
v19 = 0LL;
v20 = 0LL;
do
{
v21 = v31;
v22 = v13;
v23 = v16 + 48 * v17 + 16;
*(_OWORD *)(v31 + v19) = *(_OWORD *)(v16 + 48 * v17);
std::vector<char>::_M_move_assign(v21 + v18, v23);
v24 = *(_BYTE *)(v23 + 24);
v13 = v22;
v6 = v29;
*(_BYTE *)(v21 + v19 + 40) = v24;
v16 = v29[15];
v25 = v29[16];
v17 = (v29[18] + 1LL) % (v13 * ((v25 - v16) >> 4));
v29[18] = v17;
++v20;
v18 += 48LL;
v19 += 48LL;
}
while ( v17 != v29[19] );
v29[18] = 0LL;
v29[19] = v20;
v26 = v31;
if ( v20 < v13 * ((long long)(*((_QWORD *)&v31 + 1) - v31) >> 4) )
{
do
{
std::vector<char>::resize((_QWORD *)(v18 + v26), 0x100uLL);
++v20;
v18 += 48LL;
v26 = v31;
}
while ( v20 < v13 * ((long long)(*((_QWORD *)&v31 + 1) - v31) >> 4) );
v16 = v29[15];
v25 = v29[16];
}
v27 = v29[17];
*(_OWORD *)(v29 + 15) = v26;
v29[17] = v32;
*(_QWORD *)&v33 = v16;
*((_QWORD *)&v33 + 1) = v25;
v34 = v27;
v31 = 0LL;
v32 = 0LL;
std::vector<common_log_entry>::~vector(&v33);
std::vector<common_log_entry>::~vector(&v31);
}
std::condition_variable::notify_one((std::condition_variable *)(v6 + 6));
}
return pthread_mutex_unlock(v6);
}
|
add:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R15,RCX
MOV R14,RDX
MOV EBP,ESI
MOV RBX,RDI
CALL 0x001189b0
TEST EAX,EAX
JNZ 0x0017f79c
CMP byte ptr [RBX + 0x6a],0x1
JNZ 0x0017f785
MOV dword ptr [RSP + 0xc],EBP
MOV R13,qword ptr [RBX + 0x78]
MOV RAX,qword ptr [RBX + 0x98]
LEA RBP,[RAX + RAX*0x2]
SHL RBP,0x4
MOV R12,R13
ADD R12,RBP
MOV RAX,qword ptr [R15 + 0x10]
MOV qword ptr [RSP + 0x40],RAX
MOVUPS XMM0,xmmword ptr [R15]
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOV RDI,qword ptr [R13 + RBP*0x1 + 0x10]
MOV RSI,qword ptr [R13 + RBP*0x1 + 0x18]
SUB RSI,RDI
MOV RDX,R14
MOV RCX,R15
CALL 0x00118d38
MOVSXD RSI,EAX
MOV RAX,qword ptr [R13 + RBP*0x1 + 0x18]
SUB RAX,qword ptr [R13 + RBP*0x1 + 0x10]
CMP RAX,RSI
JA 0x0017f584
LEA RDI,[0x10 + RBP*0x1]
ADD RDI,R13
INC RSI
LAB_0017f565:
CALL 0x0012abea
MOV RDI,qword ptr [R12 + 0x10]
MOV RSI,qword ptr [R12 + 0x18]
SUB RSI,RDI
LEA RCX,[RSP + 0x30]
MOV RDX,R14
CALL 0x00118d38
LAB_0017f584:
MOV EAX,dword ptr [RSP + 0xc]
MOV dword ptr [R12],EAX
MOV AL,byte ptr [RBX + 0x68]
MOV byte ptr [R12 + 0x4],AL
MOV qword ptr [R12 + 0x8],0x0
CMP byte ptr [RBX + 0x69],0x1
JNZ 0x0017f5cc
CALL 0x00118080
MOV RCX,0x20c49ba5e353f7cf
IMUL RCX
MOV RAX,RDX
SHR RAX,0x3f
SAR RDX,0x7
ADD RDX,RAX
SUB RDX,qword ptr [RBX + 0x70]
MOV qword ptr [R12 + 0x8],RDX
LAB_0017f5cc:
MOV byte ptr [R12 + 0x28],0x0
MOV RSI,qword ptr [RBX + 0x80]
MOV RAX,qword ptr [RBX + 0x98]
INC RAX
SUB RSI,qword ptr [RBX + 0x78]
SAR RSI,0x4
MOV R14,-0x5555555555555555
IMUL RSI,R14
XOR EDX,EDX
DIV RSI
MOV qword ptr [RBX + 0x98],RDX
CMP RDX,qword ptr [RBX + 0x90]
JNZ 0x0017f77c
ADD RSI,RSI
LAB_0017f615:
LEA RDI,[RSP + 0x10]
LEA RDX,[RSP + 0x30]
MOV qword ptr [RSP],RBX
CALL 0x0018020e
MOV RCX,qword ptr [RBX + 0x78]
MOV RDX,qword ptr [RBX + 0x90]
MOV R12D,0x10
XOR EBP,EBP
XOR R13D,R13D
LAB_0017f63e:
LEA RAX,[RDX + RDX*0x2]
SHL RAX,0x4
MOV R15,qword ptr [RSP + 0x10]
MOV RBX,R14
LEA R14,[RCX + RAX*0x1]
ADD R14,0x10
MOVUPS XMM0,xmmword ptr [R14 + -0x10]
MOVUPS xmmword ptr [R15 + RBP*0x1],XMM0
LEA RDI,[R15 + R12*0x1]
MOV RSI,R14
CALL 0x0018028c
MOV AL,byte ptr [R14 + 0x18]
MOV R14,RBX
MOV RBX,qword ptr [RSP]
MOV byte ptr [R15 + RBP*0x1 + 0x28],AL
MOV RAX,qword ptr [RBX + 0x90]
INC RAX
MOV RCX,qword ptr [RBX + 0x78]
MOV RSI,qword ptr [RBX + 0x80]
MOV RDI,RSI
SUB RDI,RCX
SAR RDI,0x4
IMUL RDI,R14
XOR EDX,EDX
DIV RDI
MOV qword ptr [RBX + 0x90],RDX
INC R13
ADD R12,0x30
ADD RBP,0x30
CMP RDX,qword ptr [RBX + 0x98]
JNZ 0x0017f63e
MOV qword ptr [RBX + 0x90],0x0
MOV qword ptr [RBX + 0x98],R13
MOV RDI,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RSP + 0x18]
MOV RDX,RAX
SUB RDX,RDI
SAR RDX,0x4
IMUL RDX,R14
CMP R13,RDX
JNC 0x0017f72e
LAB_0017f6f2:
ADD RDI,R12
LAB_0017f6f5:
MOV ESI,0x100
CALL 0x0012abea
LAB_0017f6ff:
INC R13
MOV RDI,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RSP + 0x18]
MOV RCX,RAX
SUB RCX,RDI
SAR RCX,0x4
IMUL RCX,R14
ADD R12,0x30
CMP R13,RCX
JC 0x0017f6f2
MOV RCX,qword ptr [RBX + 0x78]
MOV RSI,qword ptr [RBX + 0x80]
LAB_0017f72e:
MOV RDX,qword ptr [RBX + 0x88]
MOV qword ptr [RBX + 0x78],RDI
MOV qword ptr [RBX + 0x80],RAX
LEA R14,[RSP + 0x10]
MOV RAX,qword ptr [R14 + 0x10]
MOV qword ptr [RBX + 0x88],RAX
LEA RDI,[RSP + 0x30]
MOV qword ptr [RDI],RCX
MOV qword ptr [RDI + 0x8],RSI
MOV qword ptr [RDI + 0x10],RDX
XORPS XMM0,XMM0
MOVAPS xmmword ptr [R14],XMM0
MOV qword ptr [R14 + 0x10],0x0
CALL 0x0017fa84
MOV RDI,R14
CALL 0x0017fa84
LAB_0017f77c:
LEA RDI,[RBX + 0x30]
CALL 0x00118370
LAB_0017f785:
MOV RDI,RBX
CALL 0x00118520
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0017f79c:
MOV EDI,EAX
CALL 0x00118480
|
/* common_log::add(ggml_log_level, char const*, __va_list_tag*) */
void __thiscall common_log::add(common_log *this,int4 param_2,char *param_3,long *param_4)
{
int4 *puVar1;
char *__s;
int4 uVar2;
int4 uVar3;
int4 uVar4;
int iVar5;
long lVar6;
ulong uVar7;
long lVar8;
long lVar9;
int4 *puVar10;
long lVar11;
ulong uVar12;
long local_68;
long lStack_60;
int8 local_58;
long local_48;
long lStack_40;
long local_38;
iVar5 = pthread_mutex_lock((pthread_mutex_t *)this);
if (iVar5 == 0) {
if (this[0x6a] == (common_log)0x1) {
lVar6 = *(long *)(this + 0x78);
lVar8 = *(long *)(this + 0x98) * 0x30;
puVar10 = (int4 *)(lVar6 + lVar8);
local_38 = param_4[2];
local_48 = *param_4;
lStack_40 = param_4[1];
__s = *(char **)(lVar6 + 0x10 + lVar8);
iVar5 = vsnprintf(__s,*(long *)(lVar6 + 0x18 + lVar8) - (long)__s,param_3,param_4);
if ((ulong)(*(long *)(lVar6 + 0x18 + lVar8) - *(long *)(lVar6 + 0x10 + lVar8)) <=
(ulong)(long)iVar5) {
/* try { // try from 0017f565 to 0017f569 has its CatchHandler @ 0017f7a5 */
std::vector<char,std::allocator<char>>::resize
((vector<char,std::allocator<char>> *)(lVar8 + 0x10 + lVar6),(long)iVar5 + 1);
vsnprintf(*(char **)(puVar10 + 4),*(long *)(puVar10 + 6) - (long)*(char **)(puVar10 + 4),
param_3,&local_48);
}
*puVar10 = param_2;
*(common_log *)(puVar10 + 1) = this[0x68];
*(int8 *)(puVar10 + 2) = 0;
if (this[0x69] == (common_log)0x1) {
lVar6 = std::chrono::_V2::system_clock::now();
*(long *)(puVar10 + 2) = lVar6 / 1000 - *(long *)(this + 0x70);
}
*(int1 *)(puVar10 + 10) = 0;
lVar6 = *(long *)(this + 0x80) - *(long *)(this + 0x78) >> 4;
uVar7 = (*(long *)(this + 0x98) + 1U) % (ulong)(lVar6 * -0x5555555555555555);
*(ulong *)(this + 0x98) = uVar7;
if (uVar7 == *(ulong *)(this + 0x90)) {
/* try { // try from 0017f615 to 0017f627 has its CatchHandler @ 0017f7a3 */
std::vector<common_log_entry,std::allocator<common_log_entry>>::vector
((ulong)&local_68,(allocator *)(lVar6 * 0x5555555555555556));
lVar6 = *(long *)(this + 0x78);
uVar7 = *(ulong *)(this + 0x90);
lVar11 = 0x10;
lVar8 = 0;
uVar12 = 0;
do {
lVar9 = local_68;
puVar10 = (int4 *)(lVar6 + uVar7 * 0x30);
uVar2 = puVar10[1];
uVar3 = puVar10[2];
uVar4 = puVar10[3];
puVar1 = (int4 *)(local_68 + lVar8);
*puVar1 = *puVar10;
puVar1[1] = uVar2;
puVar1[2] = uVar3;
puVar1[3] = uVar4;
std::vector<char,std::allocator<char>>::_M_move_assign(local_68 + lVar11,puVar10 + 4);
*(int1 *)(lVar9 + 0x28 + lVar8) = *(int1 *)(puVar10 + 10);
lVar6 = *(long *)(this + 0x78);
lVar9 = *(long *)(this + 0x80);
uVar7 = (*(long *)(this + 0x90) + 1U) %
(ulong)((lVar9 - lVar6 >> 4) * -0x5555555555555555);
*(ulong *)(this + 0x90) = uVar7;
uVar12 = uVar12 + 1;
lVar11 = lVar11 + 0x30;
lVar8 = lVar8 + 0x30;
} while (uVar7 != *(ulong *)(this + 0x98));
*(int8 *)(this + 0x90) = 0;
*(ulong *)(this + 0x98) = uVar12;
if (uVar12 < (ulong)((lStack_60 - local_68 >> 4) * -0x5555555555555555)) {
do {
/* try { // try from 0017f6f5 to 0017f6fe has its CatchHandler @ 0017f7ae */
std::vector<char,std::allocator<char>>::resize
((vector<char,std::allocator<char>> *)(local_68 + lVar11),0x100);
uVar12 = uVar12 + 1;
lVar11 = lVar11 + 0x30;
} while (uVar12 < (ulong)((lStack_60 - local_68 >> 4) * -0x5555555555555555));
lVar6 = *(long *)(this + 0x78);
lVar9 = *(long *)(this + 0x80);
}
local_38 = *(long *)(this + 0x88);
*(long *)(this + 0x78) = local_68;
*(long *)(this + 0x80) = lStack_60;
*(int8 *)(this + 0x88) = local_58;
local_68 = 0;
lStack_60 = 0;
local_58 = 0;
local_48 = lVar6;
lStack_40 = lVar9;
std::vector<common_log_entry,std::allocator<common_log_entry>>::~vector
((vector<common_log_entry,std::allocator<common_log_entry>> *)&local_48);
std::vector<common_log_entry,std::allocator<common_log_entry>>::~vector
((vector<common_log_entry,std::allocator<common_log_entry>> *)&local_68);
}
std::condition_variable::notify_one();
}
pthread_mutex_unlock((pthread_mutex_t *)this);
return;
}
/* WARNING: Subroutine does not return */
std::__throw_system_error(iVar5);
}
|
|
60,664
|
minja::Parser::parseMathUnaryPlusMinus()
|
monkey531[P]llama/common/minja.hpp
|
std::shared_ptr<Expression> parseMathUnaryPlusMinus() {
static std::regex unary_plus_minus_tok(R"(\+|-(?![}%#]\}))");
auto op_str = consumeToken(unary_plus_minus_tok);
auto expr = parseExpansion();
if (!expr) throw std::runtime_error("Expected expr of 'unary plus/minus/expansion' expression");
if (!op_str.empty()) {
auto op = op_str == "+" ? UnaryOpExpr::Op::Plus : UnaryOpExpr::Op::Minus;
return std::make_shared<UnaryOpExpr>(get_location(), std::move(expr), op);
}
return expr;
}
|
O2
|
cpp
|
minja::Parser::parseMathUnaryPlusMinus():
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x9a5c6(%rip), %rax # 0xff148
movb (%rax), %al
testb %al, %al
je 0x64c5d
leaq 0x9a595(%rip), %rdx # 0xff128
leaq 0x30(%rsp), %rdi
pushq $0x1
popq %rcx
movq %r14, %rsi
callq 0x60914
movq %rsp, %rdi
movq %r14, %rsi
callq 0x64dce
movq (%rsp), %rax
testq %rax, %rax
je 0x64cb2
cmpq $0x0, 0x38(%rsp)
je 0x64c27
leaq 0x50023(%rip), %rsi # 0xb4bed
leaq 0x30(%rsp), %rdi
callq 0x3963b
xorb $0x1, %al
movzbl %al, %eax
movl %eax, 0x14(%rsp)
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x604f0
leaq 0x50(%rsp), %rdi
leaq 0x18(%rsp), %rsi
movq %rsp, %rdx
leaq 0x14(%rsp), %rcx
callq 0x64f96
leaq 0x58(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movups %xmm0, (%rbx)
andq $0x0, -0x8(%rdi)
callq 0x4f960
leaq 0x20(%rsp), %rdi
callq 0x4f960
jmp 0x64c3e
movq %rax, (%rbx)
movq 0x8(%rsp), %rax
andq $0x0, 0x8(%rsp)
movq %rax, 0x8(%rbx)
andq $0x0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x4f960
leaq 0x30(%rsp), %rdi
callq 0x24218
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
leaq 0x9a4e4(%rip), %rdi # 0xff148
callq 0x24040
testl %eax, %eax
je 0x64b8c
leaq 0x9a4b0(%rip), %rdi # 0xff128
leaq 0x4f3d6(%rip), %rsi # 0xb4055
pushq $0x10
popq %rdx
callq 0x464b2
leaq -0x1e5b6(%rip), %rdi # 0x466d8
leaq 0x9a493(%rip), %rsi # 0xff128
leaq 0x99c7c(%rip), %rdx # 0xfe918
callq 0x237e0
leaq 0x9a4a0(%rip), %rdi # 0xff148
callq 0x23600
jmp 0x64b8c
pushq $0x10
popq %rdi
callq 0x23480
movq %rax, %r14
leaq 0x4f47b(%rip), %rsi # 0xb413f
movq %rax, %rdi
callq 0x23330
movq 0x9931d(%rip), %rsi # 0xfdff0
movq 0x9927e(%rip), %rdx # 0xfdf58
movq %r14, %rdi
callq 0x23f40
movq %rax, %rbx
leaq 0x9a45c(%rip), %rdi # 0xff148
callq 0x235f0
jmp 0x64d2d
jmp 0x64d11
movq %rax, %rbx
movq %r14, %rdi
callq 0x236b0
jmp 0x64d14
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x4f960
jmp 0x64d14
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4f960
jmp 0x64d23
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x24218
movq %rbx, %rdi
callq 0x23fd0
nop
|
_ZN5minja6Parser23parseMathUnaryPlusMinusEv:
push r14
push rbx
sub rsp, 68h
mov r14, rsi
mov rbx, rdi
lea rax, _ZGVZN5minja6Parser23parseMathUnaryPlusMinusEvE20unary_plus_minus_tokB5cxx11; `guard variable for'minja::Parser::parseMathUnaryPlusMinus(void)::unary_plus_minus_tok
mov al, [rax]
test al, al
jz loc_64C5D
loc_64B8C:
lea rdx, _ZZN5minja6Parser23parseMathUnaryPlusMinusEvE20unary_plus_minus_tokB5cxx11; minja::Parser::parseMathUnaryPlusMinus(void)::unary_plus_minus_tok
lea rdi, [rsp+78h+var_48]
push 1
pop rcx
mov rsi, r14
call _ZN5minja6Parser12consumeTokenERKNSt7__cxx1111basic_regexIcNS1_12regex_traitsIcEEEENS_13SpaceHandlingE; minja::Parser::consumeToken(std::basic_regex<char,std::regex_traits<char>> const&,minja::SpaceHandling)
mov rdi, rsp; this
mov rsi, r14
call _ZN5minja6Parser14parseExpansionEv; minja::Parser::parseExpansion(void)
mov rax, [rsp+78h+var_78]
test rax, rax
jz loc_64CB2
cmp [rsp+78h+var_40], 0
jz short loc_64C27
lea rsi, aSRN_0+0Bh; "+"
lea rdi, [rsp+78h+var_48]
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
xor al, 1
movzx eax, al
mov [rsp+78h+var_64], eax
lea rdi, [rsp+78h+var_60]; this
mov rsi, r14
call _ZNK5minja6Parser12get_locationEv; minja::Parser::get_location(void)
lea rdi, [rsp+78h+var_28]
lea rsi, [rsp+78h+var_60]
mov rdx, rsp
lea rcx, [rsp+78h+var_64]
call _ZSt11make_sharedIN5minja11UnaryOpExprEJNS0_8LocationESt10shared_ptrINS0_10ExpressionEERNS1_2OpEEES3_IT_EDpOT0_; std::make_shared<minja::UnaryOpExpr,minja::Location,std::shared_ptr<minja::Expression>,minja::UnaryOpExpr::Op &>(minja::Location,std::shared_ptr<minja::Expression>,minja::UnaryOpExpr::Op &)
lea rdi, [rsp+78h+var_20]
movaps xmm0, xmmword ptr [rdi-8]
and qword ptr [rdi], 0
movups xmmword ptr [rbx], xmm0
and qword ptr [rdi-8], 0
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea rdi, [rsp+78h+var_58]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
jmp short loc_64C3E
loc_64C27:
mov [rbx], rax
mov rax, [rsp+78h+var_70]
and [rsp+78h+var_70], 0
mov [rbx+8], rax
and [rsp+78h+var_78], 0
loc_64C3E:
lea rdi, [rsp+78h+var_70]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea rdi, [rsp+78h+var_48]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rax, rbx
add rsp, 68h
pop rbx
pop r14
retn
loc_64C5D:
lea rdi, _ZGVZN5minja6Parser23parseMathUnaryPlusMinusEvE20unary_plus_minus_tokB5cxx11; __guard *
call ___cxa_guard_acquire
test eax, eax
jz loc_64B8C
lea rdi, _ZZN5minja6Parser23parseMathUnaryPlusMinusEvE20unary_plus_minus_tokB5cxx11; minja::Parser::parseMathUnaryPlusMinus(void)::unary_plus_minus_tok
lea rsi, asc_B4055; "\\+|-(?![}%#]\\})"
push 10h
pop rdx
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEEC2EPKcNSt15regex_constants18syntax_option_typeE; std::basic_regex<char,std::regex_traits<char>>::basic_regex(char const*,std::regex_constants::syntax_option_type)
lea rdi, _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; lpfunc
lea rsi, _ZZN5minja6Parser23parseMathUnaryPlusMinusEvE20unary_plus_minus_tokB5cxx11; obj
lea rdx, __dso_handle; lpdso_handle
call ___cxa_atexit
lea rdi, _ZGVZN5minja6Parser23parseMathUnaryPlusMinusEvE20unary_plus_minus_tokB5cxx11; __guard *
call ___cxa_guard_release
jmp loc_64B8C
loc_64CB2:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aExpectedExprOf; "Expected expr of 'unary plus/minus/expa"...
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
mov rbx, rax
lea rdi, _ZGVZN5minja6Parser23parseMathUnaryPlusMinusEvE20unary_plus_minus_tokB5cxx11; __guard *
call ___cxa_guard_abort
jmp short loc_64D2D
jmp short loc_64D11
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_64D14
mov rbx, rax
lea rdi, [rsp+78h+var_58]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
jmp short loc_64D14
loc_64D11:
mov rbx, rax
loc_64D14:
lea rdi, [rsp+78h+var_70]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
jmp short loc_64D23
mov rbx, rax
loc_64D23:
lea rdi, [rsp+78h+var_48]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_64D2D:
mov rdi, rbx
call __Unwind_Resume
|
minja::Parser * minja::Parser::parseMathUnaryPlusMinus(minja::Parser *this, _QWORD *a2)
{
__int128 v2; // xmm0
long long v3; // rax
std::runtime_error *exception; // r14
long long v6; // [rsp+0h] [rbp-78h] BYREF
long long v7; // [rsp+8h] [rbp-70h] BYREF
BOOL v8; // [rsp+14h] [rbp-64h] BYREF
_BYTE v9[8]; // [rsp+18h] [rbp-60h] BYREF
long long v10; // [rsp+20h] [rbp-58h] BYREF
_QWORD v11[4]; // [rsp+30h] [rbp-48h] BYREF
_OWORD v12[2]; // [rsp+50h] [rbp-28h] BYREF
if ( !(_BYTE)`guard variable for'minja::Parser::parseMathUnaryPlusMinus(void)::unary_plus_minus_tok[abi:cxx11]
&& __cxa_guard_acquire(&`guard variable for'minja::Parser::parseMathUnaryPlusMinus(void)::unary_plus_minus_tok[abi:cxx11]) )
{
std::basic_regex<char,std::regex_traits<char>>::basic_regex(
(long long)&minja::Parser::parseMathUnaryPlusMinus(void)::unary_plus_minus_tok[abi:cxx11],
(long long)"\\+|-(?![}%#]\\})",
0x10u);
__cxa_atexit(
(void (*)(void *))std::basic_regex<char,std::regex_traits<char>>::~basic_regex,
&minja::Parser::parseMathUnaryPlusMinus(void)::unary_plus_minus_tok[abi:cxx11],
&_dso_handle);
__cxa_guard_release(&`guard variable for'minja::Parser::parseMathUnaryPlusMinus(void)::unary_plus_minus_tok[abi:cxx11]);
}
minja::Parser::consumeToken(
v11,
(long long)a2,
(long long)&minja::Parser::parseMathUnaryPlusMinus(void)::unary_plus_minus_tok[abi:cxx11],
1u);
minja::Parser::parseExpansion((minja::Parser *)&v6);
if ( !v6 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Expected expr of 'unary plus/minus/expansion' expression");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( v11[1] )
{
v8 = !std::operator==<char>((long long)v11);
minja::Parser::get_location((minja::Parser *)v9, a2);
std::make_shared<minja::UnaryOpExpr,minja::Location,std::shared_ptr<minja::Expression>,minja::UnaryOpExpr::Op &>(
v12,
v9,
&v6,
&v8);
v2 = v12[0];
*((_QWORD *)&v12[0] + 1) = 0LL;
*(_OWORD *)this = v2;
*(_QWORD *)&v12[0] = 0LL;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count((_QWORD *)v12 + 1);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v10);
}
else
{
*(_QWORD *)this = v6;
v3 = v7;
v7 = 0LL;
*((_QWORD *)this + 1) = v3;
v6 = 0LL;
}
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v7);
std::string::~string(v11);
return this;
}
|
parseMathUnaryPlusMinus:
PUSH R14
PUSH RBX
SUB RSP,0x68
MOV R14,RSI
MOV RBX,RDI
LEA RAX,[0x1ff148]
MOV AL,byte ptr [RAX]
TEST AL,AL
JZ 0x00164c5d
LAB_00164b8c:
LEA RDX,[0x1ff128]
LEA RDI,[RSP + 0x30]
PUSH 0x1
POP RCX
MOV RSI,R14
CALL 0x00160914
LAB_00164ba3:
MOV RDI,RSP
MOV RSI,R14
CALL 0x00164dce
MOV RAX,qword ptr [RSP]
TEST RAX,RAX
JZ 0x00164cb2
CMP qword ptr [RSP + 0x38],0x0
JZ 0x00164c27
LEA RSI,[0x1b4bed]
LEA RDI,[RSP + 0x30]
CALL 0x0013963b
XOR AL,0x1
MOVZX EAX,AL
MOV dword ptr [RSP + 0x14],EAX
LAB_00164bdd:
LEA RDI,[RSP + 0x18]
MOV RSI,R14
CALL 0x001604f0
LAB_00164bea:
LEA RDI,[RSP + 0x50]
LEA RSI,[RSP + 0x18]
MOV RDX,RSP
LEA RCX,[RSP + 0x14]
CALL 0x00164f96
LEA RDI,[RSP + 0x58]
MOVAPS XMM0,xmmword ptr [RDI + -0x8]
AND qword ptr [RDI],0x0
MOVUPS xmmword ptr [RBX],XMM0
AND qword ptr [RDI + -0x8],0x0
CALL 0x0014f960
LEA RDI,[RSP + 0x20]
CALL 0x0014f960
JMP 0x00164c3e
LAB_00164c27:
MOV qword ptr [RBX],RAX
MOV RAX,qword ptr [RSP + 0x8]
AND qword ptr [RSP + 0x8],0x0
MOV qword ptr [RBX + 0x8],RAX
AND qword ptr [RSP],0x0
LAB_00164c3e:
LEA RDI,[RSP + 0x8]
CALL 0x0014f960
LEA RDI,[RSP + 0x30]
CALL 0x00124218
MOV RAX,RBX
ADD RSP,0x68
POP RBX
POP R14
RET
LAB_00164c5d:
LEA RDI,[0x1ff148]
CALL 0x00124040
TEST EAX,EAX
JZ 0x00164b8c
LAB_00164c71:
LEA RDI,[0x1ff128]
LEA RSI,[0x1b4055]
PUSH 0x10
POP RDX
CALL 0x001464b2
LAB_00164c87:
LEA RDI,[0x1466d8]
LEA RSI,[0x1ff128]
LEA RDX,[0x1fe918]
CALL 0x001237e0
LEA RDI,[0x1ff148]
CALL 0x00123600
JMP 0x00164b8c
LAB_00164cb2:
PUSH 0x10
POP RDI
CALL 0x00123480
MOV R14,RAX
LAB_00164cbd:
LEA RSI,[0x1b413f]
MOV RDI,RAX
CALL 0x00123330
LAB_00164ccc:
MOV RSI,qword ptr [0x001fdff0]
MOV RDX,qword ptr [0x001fdf58]
MOV RDI,R14
CALL 0x00123f40
|
/* minja::Parser::parseMathUnaryPlusMinus() */
void minja::Parser::parseMathUnaryPlusMinus(void)
{
long lVar1;
bool bVar2;
int iVar3;
runtime_error *this;
long *in_RDI;
long local_78;
long local_70;
uint local_64;
shared_ptr local_60 [8];
__shared_count<(__gnu_cxx::_Lock_policy)2> local_58 [16];
string local_48 [8];
long local_40;
long local_28;
long alStack_20 [2];
if (parseMathUnaryPlusMinus()::unary_plus_minus_tok_abi_cxx11_ == '\0') {
iVar3 = __cxa_guard_acquire(&parseMathUnaryPlusMinus()::unary_plus_minus_tok_abi_cxx11_);
if (iVar3 != 0) {
/* try { // try from 00164c71 to 00164c86 has its CatchHandler @ 00164ce2 */
std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::basic_regex
((basic_regex<char,std::__cxx11::regex_traits<char>> *)
parseMathUnaryPlusMinus()::unary_plus_minus_tok_abi_cxx11_,"\\+|-(?![}%#]\\})",0x10
);
__cxa_atexit(std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::~basic_regex,
parseMathUnaryPlusMinus()::unary_plus_minus_tok_abi_cxx11_,&__dso_handle);
__cxa_guard_release(&parseMathUnaryPlusMinus()::unary_plus_minus_tok_abi_cxx11_);
}
}
consumeToken(local_48);
/* try { // try from 00164ba3 to 00164bad has its CatchHandler @ 00164d20 */
parseExpansion();
lVar1 = local_70;
if (local_78 != 0) {
if (local_40 == 0) {
*in_RDI = local_78;
local_70 = 0;
in_RDI[1] = lVar1;
local_78 = 0;
}
else {
bVar2 = std::operator==(local_48,"+");
local_64 = (uint)!bVar2;
/* try { // try from 00164bdd to 00164be9 has its CatchHandler @ 00164d11 */
get_location();
/* try { // try from 00164bea to 00164c00 has its CatchHandler @ 00164d02 */
std::
make_shared<minja::UnaryOpExpr,minja::Location,std::shared_ptr<minja::Expression>,minja::UnaryOpExpr::Op&>
((Location *)&local_28,local_60,(Op *)&local_78);
lVar1 = alStack_20[0];
alStack_20[0] = 0;
*in_RDI = local_28;
in_RDI[1] = lVar1;
local_28 = 0;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)alStack_20);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_58);
}
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)&local_70);
std::__cxx11::string::~string(local_48);
return;
}
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00164cbd to 00164ccb has its CatchHandler @ 00164cf5 */
std::runtime_error::runtime_error
(this,"Expected expr of \'unary plus/minus/expansion\' expression");
/* try { // try from 00164ccc to 00164ce1 has its CatchHandler @ 00164cf3 */
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_001fdff0,PTR__runtime_error_001fdf58);
}
|
|
60,665
|
my_strnncollsp_padspace_bin
|
eloqsql/strings/ctype-bin.c
|
int my_strnncollsp_padspace_bin(const uchar *str, size_t length)
{
for ( ; length ; str++, length--)
{
if (*str < ' ')
return -1;
else if (*str > ' ')
return 1;
}
return 0;
}
|
O3
|
c
|
my_strnncollsp_padspace_bin:
pushq %rbp
movq %rsp, %rbp
testq %rsi, %rsi
je 0xabc98
xorl %eax, %eax
cmpb $0x20, (%rdi,%rax)
jb 0xabc9c
jne 0xabca3
incq %rax
cmpq %rax, %rsi
jne 0xabc88
xorl %eax, %eax
jmp 0xabca8
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0xabca8
movl $0x1, %eax
popq %rbp
retq
|
my_strnncollsp_padspace_bin:
push rbp
mov rbp, rsp
test rsi, rsi
jz short loc_ABC98
xor eax, eax
loc_ABC88:
cmp byte ptr [rdi+rax], 20h ; ' '
jb short loc_ABC9C
jnz short loc_ABCA3
inc rax
cmp rsi, rax
jnz short loc_ABC88
loc_ABC98:
xor eax, eax
jmp short loc_ABCA8
loc_ABC9C:
mov eax, 0FFFFFFFFh
jmp short loc_ABCA8
loc_ABCA3:
mov eax, 1
loc_ABCA8:
pop rbp
retn
|
long long my_strnncollsp_padspace_bin(long long a1, long long a2)
{
long long v2; // rax
if ( !a2 )
return 0LL;
v2 = 0LL;
while ( 1 )
{
if ( *(_BYTE *)(a1 + v2) < 0x20u )
return 0xFFFFFFFFLL;
if ( *(_BYTE *)(a1 + v2) != 32 )
break;
if ( a2 == ++v2 )
return 0LL;
}
return 1LL;
}
|
my_strnncollsp_padspace_bin:
PUSH RBP
MOV RBP,RSP
TEST RSI,RSI
JZ 0x001abc98
XOR EAX,EAX
LAB_001abc88:
CMP byte ptr [RDI + RAX*0x1],0x20
JC 0x001abc9c
JNZ 0x001abca3
INC RAX
CMP RSI,RAX
JNZ 0x001abc88
LAB_001abc98:
XOR EAX,EAX
JMP 0x001abca8
LAB_001abc9c:
MOV EAX,0xffffffff
JMP 0x001abca8
LAB_001abca3:
MOV EAX,0x1
LAB_001abca8:
POP RBP
RET
|
int8 my_strnncollsp_padspace_bin(long param_1,long param_2)
{
long lVar1;
if (param_2 != 0) {
lVar1 = 0;
do {
if (*(byte *)(param_1 + lVar1) < 0x20) {
return 0xffffffff;
}
if (*(byte *)(param_1 + lVar1) != 0x20) {
return 1;
}
lVar1 = lVar1 + 1;
} while (param_2 != lVar1);
}
return 0;
}
|
|
60,666
|
my_strxfrm_pad_unicode
|
eloqsql/strings/ctype-utf8.c
|
size_t
my_strxfrm_pad_unicode(uchar *str, uchar *strend)
{
uchar *str0= str;
DBUG_ASSERT(str && str <= strend);
for ( ; str < strend ; )
{
*str++= 0x00;
if (str < strend)
*str++= 0x20;
}
return str - str0;
}
|
O0
|
c
|
my_strxfrm_pad_unicode:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x6b266
jmp 0x6b268
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x6b2a2
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x6b2a0
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0x20, (%rax)
jmp 0x6b268
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
popq %rbp
retq
nop
|
my_strxfrm_pad_unicode:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov [rbp+var_18], rax
jmp short $+2
loc_6B266:
jmp short $+2
loc_6B268:
mov rax, [rbp+var_8]
cmp rax, [rbp+var_10]
jnb short loc_6B2A2
mov rax, [rbp+var_8]
mov rcx, rax
add rcx, 1
mov [rbp+var_8], rcx
mov byte ptr [rax], 0
mov rax, [rbp+var_8]
cmp rax, [rbp+var_10]
jnb short loc_6B2A0
mov rax, [rbp+var_8]
mov rcx, rax
add rcx, 1
mov [rbp+var_8], rcx
mov byte ptr [rax], 20h ; ' '
loc_6B2A0:
jmp short loc_6B268
loc_6B2A2:
mov rax, [rbp+var_8]
mov rcx, [rbp+var_18]
sub rax, rcx
pop rbp
retn
|
_BYTE * my_strxfrm_pad_unicode(_BYTE *a1, unsigned long long a2)
{
_BYTE *v2; // rax
_BYTE *v3; // rax
_BYTE *v5; // [rsp+10h] [rbp-8h]
v5 = a1;
while ( (unsigned long long)v5 < a2 )
{
v2 = v5++;
*v2 = 0;
if ( (unsigned long long)v5 < a2 )
{
v3 = v5++;
*v3 = 32;
}
}
return (_BYTE *)(v5 - a1);
}
|
my_strxfrm_pad_unicode:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0016b266
LAB_0016b266:
JMP 0x0016b268
LAB_0016b268:
MOV RAX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RBP + -0x10]
JNC 0x0016b2a2
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x8],RCX
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RBP + -0x10]
JNC 0x0016b2a0
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x8],RCX
MOV byte ptr [RAX],0x20
LAB_0016b2a0:
JMP 0x0016b268
LAB_0016b2a2:
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x18]
SUB RAX,RCX
POP RBP
RET
|
long my_strxfrm_pad_unicode(int1 *param_1,int1 *param_2)
{
int1 *puVar1;
int1 *local_10;
puVar1 = param_1;
while (local_10 = puVar1, local_10 < param_2) {
puVar1 = local_10 + 1;
*local_10 = 0;
if (puVar1 < param_2) {
*puVar1 = 0x20;
puVar1 = local_10 + 2;
}
}
return (long)local_10 - (long)param_1;
}
|
|
60,667
|
mbedtls_hmac_drbg_self_test
|
msxemulator/build_O3/_deps/pico_sdk-src/lib/mbedtls/library/hmac_drbg.c
|
int mbedtls_hmac_drbg_self_test(int verbose)
{
mbedtls_hmac_drbg_context ctx;
unsigned char buf[OUTPUT_LEN];
const mbedtls_md_info_t *md_info = mbedtls_md_info_from_type(MBEDTLS_MD_SHA1);
mbedtls_hmac_drbg_init(&ctx);
/*
* PR = True
*/
if (verbose != 0) {
mbedtls_printf(" HMAC_DRBG (PR = True) : ");
}
test_offset = 0;
CHK(mbedtls_hmac_drbg_seed(&ctx, md_info,
hmac_drbg_self_test_entropy, (void *) entropy_pr,
NULL, 0));
mbedtls_hmac_drbg_set_prediction_resistance(&ctx, MBEDTLS_HMAC_DRBG_PR_ON);
CHK(mbedtls_hmac_drbg_random(&ctx, buf, OUTPUT_LEN));
CHK(mbedtls_hmac_drbg_random(&ctx, buf, OUTPUT_LEN));
CHK(memcmp(buf, result_pr, OUTPUT_LEN));
mbedtls_hmac_drbg_free(&ctx);
mbedtls_hmac_drbg_free(&ctx);
if (verbose != 0) {
mbedtls_printf("passed\n");
}
/*
* PR = False
*/
if (verbose != 0) {
mbedtls_printf(" HMAC_DRBG (PR = False) : ");
}
mbedtls_hmac_drbg_init(&ctx);
test_offset = 0;
CHK(mbedtls_hmac_drbg_seed(&ctx, md_info,
hmac_drbg_self_test_entropy, (void *) entropy_nopr,
NULL, 0));
CHK(mbedtls_hmac_drbg_reseed(&ctx, NULL, 0));
CHK(mbedtls_hmac_drbg_random(&ctx, buf, OUTPUT_LEN));
CHK(mbedtls_hmac_drbg_random(&ctx, buf, OUTPUT_LEN));
CHK(memcmp(buf, result_nopr, OUTPUT_LEN));
mbedtls_hmac_drbg_free(&ctx);
mbedtls_hmac_drbg_free(&ctx);
if (verbose != 0) {
mbedtls_printf("passed\n");
}
if (verbose != 0) {
mbedtls_printf("\n");
}
return 0;
}
|
O3
|
c
|
mbedtls_hmac_drbg_self_test:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movl %edi, %ebx
movl $0x4, %edi
callq 0x8a34c
movq %rax, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, (%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x70(%rsp)
movl $0x2710, 0x6c(%rsp) # imm = 0x2710
testl %ebx, %ebx
je 0x8a021
leaq 0x26211(%rip), %rdi # 0xb0183
xorl %eax, %eax
callq 0xf070
movq $0x0, 0x657dc(%rip) # 0xef760
leaq 0x282(%rip), %rdx # 0x8a20d
leaq 0x2622e(%rip), %rcx # 0xb01c0
movq %rsp, %rdi
movq %r14, %rsi
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x89b69
testl %eax, %eax
jne 0x8a00b
movq %rsp, %rdi
movl $0x1, 0x68(%rdi)
leaq 0x80(%rsp), %rsi
movl $0x50, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x89c38
testl %eax, %eax
jne 0x8a00b
movq %rsp, %rdi
leaq 0x80(%rsp), %rsi
movl $0x50, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x89c38
testl %eax, %eax
jne 0x8a00b
leaq 0x2620f(%rip), %rsi # 0xb0200
leaq 0x80(%rsp), %rdi
movl $0x50, %edx
callq 0xf490
testl %eax, %eax
je 0x8a0c4
leaq 0x23684(%rip), %rdi # 0xad696
callq 0xf6b0
movl $0x1, %ebp
jmp 0x8a1cc
movq $0x0, 0x65734(%rip) # 0xef760
leaq 0x1da(%rip), %rdx # 0x8a20d
leaq 0x26186(%rip), %rcx # 0xb01c0
movq %rsp, %rdi
movq %r14, %rsi
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x89b69
movl $0x1, %ebp
testl %eax, %eax
jne 0x8a1cc
movq %rsp, %rdi
movl $0x1, 0x68(%rdi)
leaq 0x80(%rsp), %rsi
movl $0x50, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x89c38
testl %eax, %eax
jne 0x8a1cc
movq %rsp, %rdi
leaq 0x80(%rsp), %rsi
movl $0x50, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x89c38
testl %eax, %eax
jne 0x8a1cc
leaq 0x26156(%rip), %rsi # 0xb0200
leaq 0x80(%rsp), %rdi
movl $0x50, %edx
callq 0xf490
testl %eax, %eax
jne 0x8a1cc
movq %rsp, %r15
movq %r15, %rdi
callq 0x89d6f
movq %r15, %rdi
callq 0x89d6f
testl %ebx, %ebx
je 0x8a0f5
leaq 0x213b2(%rip), %rdi # 0xab494
callq 0xf6b0
leaq 0x260b0(%rip), %rdi # 0xb019e
xorl %eax, %eax
callq 0xf070
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, 0x60(%rdi)
movaps %xmm0, 0x70(%rdi)
movaps %xmm0, 0x50(%rdi)
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
movl $0x2710, 0x6c(%rdi) # imm = 0x2710
movq $0x0, 0x65634(%rip) # 0xef760
leaq 0xda(%rip), %rdx # 0x8a20d
leaq 0x26116(%rip), %rcx # 0xb0250
movq %r14, %rsi
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x89b69
testl %eax, %eax
jne 0x8a1b7
movq %rsp, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x89a6e
testl %eax, %eax
jne 0x8a1b7
movq %rsp, %rdi
leaq 0x80(%rsp), %rsi
movl $0x50, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x89c38
testl %eax, %eax
jne 0x8a1b7
movq %rsp, %rdi
leaq 0x80(%rsp), %rsi
movl $0x50, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x89c38
testl %eax, %eax
jne 0x8a1b7
leaq 0x260df(%rip), %rsi # 0xb0280
leaq 0x80(%rsp), %rdi
movl $0x50, %edx
callq 0xf490
testl %eax, %eax
je 0x8a1dc
movl $0x1, %ebp
testl %ebx, %ebx
je 0x8a1cc
leaq 0x234cf(%rip), %rdi # 0xad696
callq 0xf6b0
movl %ebp, %eax
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rsp, %r14
movq %r14, %rdi
callq 0x89d6f
movq %r14, %rdi
callq 0x89d6f
xorl %ebp, %ebp
testl %ebx, %ebx
je 0x8a1cc
leaq 0x21298(%rip), %rdi # 0xab494
callq 0xf6b0
movl $0xa, %edi
callq 0xf620
jmp 0x8a1cc
|
mbedtls_hmac_drbg_self_test:
push rbp
push r15
push r14
push rbx
sub rsp, 0D8h
mov ebx, edi
mov edi, 4
call mbedtls_md_info_from_type
mov r14, rax
xorps xmm0, xmm0
movaps [rsp+0F8h+var_98], xmm0
movaps [rsp+0F8h+var_F8], xmm0
movaps [rsp+0F8h+var_E8], xmm0
movaps [rsp+0F8h+var_D8], xmm0
movaps [rsp+0F8h+var_C8], xmm0
movaps [rsp+0F8h+var_B8], xmm0
movaps [rsp+0F8h+var_A8], xmm0
movaps [rsp+0F8h+var_88], xmm0
mov dword ptr [rsp+0F8h+var_98+0Ch], 2710h
test ebx, ebx
jz loc_8A021
lea rdi, aHmacDrbgPrTrue; " HMAC_DRBG (PR = True) : "
xor eax, eax
call _printf
mov cs:test_offset_0, 0
lea rdx, hmac_drbg_self_test_entropy
lea rcx, entropy_pr
mov rdi, rsp
mov rsi, r14
xor r8d, r8d
xor r9d, r9d
call mbedtls_hmac_drbg_seed
test eax, eax
jnz short loc_8A00B
mov rdi, rsp
mov dword ptr [rdi+68h], 1
lea rsi, [rsp+0F8h+var_78]
mov edx, 50h ; 'P'
xor ecx, ecx
xor r8d, r8d
call mbedtls_hmac_drbg_random_with_add
test eax, eax
jnz short loc_8A00B
mov rdi, rsp
lea rsi, [rsp+0F8h+var_78]
mov edx, 50h ; 'P'
xor ecx, ecx
xor r8d, r8d
call mbedtls_hmac_drbg_random_with_add
test eax, eax
jnz short loc_8A00B
lea rsi, result_pr_0
lea rdi, [rsp+0F8h+var_78]
mov edx, 50h ; 'P'
call _bcmp
test eax, eax
jz loc_8A0C4
loc_8A00B:
lea rdi, aEcpGenerationO+39h; "failed"
call _puts
mov ebp, 1
jmp loc_8A1CC
loc_8A021:
mov cs:test_offset_0, 0
lea rdx, hmac_drbg_self_test_entropy
lea rcx, entropy_pr
mov rdi, rsp
mov rsi, r14
xor r8d, r8d
xor r9d, r9d
call mbedtls_hmac_drbg_seed
mov ebp, 1
test eax, eax
jnz loc_8A1CC
mov rdi, rsp
mov dword ptr [rdi+68h], 1
lea rsi, [rsp+0F8h+var_78]
mov edx, 50h ; 'P'
xor ecx, ecx
xor r8d, r8d
call mbedtls_hmac_drbg_random_with_add
test eax, eax
jnz loc_8A1CC
mov rdi, rsp
lea rsi, [rsp+0F8h+var_78]
mov edx, 50h ; 'P'
xor ecx, ecx
xor r8d, r8d
call mbedtls_hmac_drbg_random_with_add
test eax, eax
jnz loc_8A1CC
lea rsi, result_pr_0
lea rdi, [rsp+0F8h+var_78]
mov edx, 50h ; 'P'
call _bcmp
test eax, eax
jnz loc_8A1CC
loc_8A0C4:
mov r15, rsp
mov rdi, r15
call mbedtls_hmac_drbg_free
mov rdi, r15
call mbedtls_hmac_drbg_free
test ebx, ebx
jz short loc_8A0F5
lea rdi, aPassed; "passed"
call _puts
lea rdi, aHmacDrbgPrFals; " HMAC_DRBG (PR = False) : "
xor eax, eax
call _printf
loc_8A0F5:
xorps xmm0, xmm0
mov rdi, rsp
movaps xmmword ptr [rdi+60h], xmm0
movaps xmmword ptr [rdi+70h], xmm0
movaps xmmword ptr [rdi+50h], xmm0
movaps xmmword ptr [rdi+40h], xmm0
movaps xmmword ptr [rdi+30h], xmm0
movaps xmmword ptr [rdi+20h], xmm0
movaps xmmword ptr [rdi+10h], xmm0
movaps xmmword ptr [rdi], xmm0
mov dword ptr [rdi+6Ch], 2710h
mov cs:test_offset_0, 0
lea rdx, hmac_drbg_self_test_entropy
lea rcx, entropy_nopr
mov rsi, r14
xor r8d, r8d
xor r9d, r9d
call mbedtls_hmac_drbg_seed
test eax, eax
jnz short loc_8A1B7
mov rdi, rsp
xor esi, esi
xor edx, edx
xor ecx, ecx
call hmac_drbg_reseed_core
test eax, eax
jnz short loc_8A1B7
mov rdi, rsp
lea rsi, [rsp+0F8h+var_78]
mov edx, 50h ; 'P'
xor ecx, ecx
xor r8d, r8d
call mbedtls_hmac_drbg_random_with_add
test eax, eax
jnz short loc_8A1B7
mov rdi, rsp
lea rsi, [rsp+0F8h+var_78]
mov edx, 50h ; 'P'
xor ecx, ecx
xor r8d, r8d
call mbedtls_hmac_drbg_random_with_add
test eax, eax
jnz short loc_8A1B7
lea rsi, result_nopr_0
lea rdi, [rsp+0F8h+var_78]
mov edx, 50h ; 'P'
call _bcmp
test eax, eax
jz short loc_8A1DC
loc_8A1B7:
mov ebp, 1
test ebx, ebx
jz short loc_8A1CC
lea rdi, aEcpGenerationO+39h; "failed"
call _puts
loc_8A1CC:
mov eax, ebp
add rsp, 0D8h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_8A1DC:
mov r14, rsp
mov rdi, r14
call mbedtls_hmac_drbg_free
mov rdi, r14
call mbedtls_hmac_drbg_free
xor ebp, ebp
test ebx, ebx
jz short loc_8A1CC
lea rdi, aPassed; "passed"
call _puts
mov edi, 0Ah
call _putchar
jmp short loc_8A1CC
|
long long mbedtls_hmac_drbg_self_test(int a1)
{
long long v1; // rax
long long v2; // r14
unsigned int v3; // ebp
__int128 v5; // [rsp+0h] [rbp-F8h] BYREF
__int128 v6; // [rsp+10h] [rbp-E8h]
__int128 v7; // [rsp+20h] [rbp-D8h]
__int128 v8; // [rsp+30h] [rbp-C8h]
__int128 v9; // [rsp+40h] [rbp-B8h]
__int128 v10; // [rsp+50h] [rbp-A8h]
__int128 v11; // [rsp+60h] [rbp-98h]
__int128 v12; // [rsp+70h] [rbp-88h]
_BYTE v13[120]; // [rsp+80h] [rbp-78h] BYREF
v1 = mbedtls_md_info_from_type(4LL);
v2 = v1;
v11 = 0LL;
v5 = 0LL;
v6 = 0LL;
v7 = 0LL;
v8 = 0LL;
v9 = 0LL;
v10 = 0LL;
v12 = 0LL;
HIDWORD(v11) = 10000;
if ( a1 )
{
printf(" HMAC_DRBG (PR = True) : ");
test_offset_0 = 0LL;
if ( (unsigned int)mbedtls_hmac_drbg_seed(
&v5,
v2,
(long long)hmac_drbg_self_test_entropy,
(long long)&entropy_pr,
0LL,
0LL)
|| (DWORD2(v11) = 1, (unsigned int)mbedtls_hmac_drbg_random_with_add(&v5, (long long)v13, 0x50uLL, 0LL, 0LL))
|| (unsigned int)mbedtls_hmac_drbg_random_with_add(&v5, (long long)v13, 0x50uLL, 0LL, 0LL)
|| (unsigned int)bcmp(v13, &result_pr_0, 80LL) )
{
puts("failed");
return 1;
}
}
else
{
test_offset_0 = 0LL;
v3 = 1;
if ( (unsigned int)mbedtls_hmac_drbg_seed(
&v5,
v1,
(long long)hmac_drbg_self_test_entropy,
(long long)&entropy_pr,
0LL,
0LL) )
return v3;
DWORD2(v11) = 1;
if ( (unsigned int)mbedtls_hmac_drbg_random_with_add(&v5, (long long)v13, 0x50uLL, 0LL, 0LL)
|| (unsigned int)mbedtls_hmac_drbg_random_with_add(&v5, (long long)v13, 0x50uLL, 0LL, 0LL)
|| (unsigned int)bcmp(v13, &result_pr_0, 80LL) )
{
return v3;
}
}
mbedtls_hmac_drbg_free((long long)&v5);
mbedtls_hmac_drbg_free((long long)&v5);
if ( a1 )
{
puts("passed");
printf(" HMAC_DRBG (PR = False) : ");
}
v11 = 0LL;
v12 = 0LL;
v10 = 0LL;
v9 = 0LL;
v8 = 0LL;
v7 = 0LL;
v6 = 0LL;
v5 = 0LL;
HIDWORD(v11) = 10000;
test_offset_0 = 0LL;
if ( (unsigned int)mbedtls_hmac_drbg_seed(
&v5,
v2,
(long long)hmac_drbg_self_test_entropy,
(long long)&entropy_nopr,
0LL,
0LL)
|| (unsigned int)hmac_drbg_reseed_core((long long)&v5, 0LL, 0LL, 0)
|| (unsigned int)mbedtls_hmac_drbg_random_with_add(&v5, (long long)v13, 0x50uLL, 0LL, 0LL)
|| (unsigned int)mbedtls_hmac_drbg_random_with_add(&v5, (long long)v13, 0x50uLL, 0LL, 0LL)
|| (unsigned int)bcmp(v13, &result_nopr_0, 80LL) )
{
v3 = 1;
if ( a1 )
puts("failed");
}
else
{
mbedtls_hmac_drbg_free((long long)&v5);
mbedtls_hmac_drbg_free((long long)&v5);
v3 = 0;
if ( a1 )
{
puts("passed");
putchar(10LL);
}
}
return v3;
}
|
mbedtls_hmac_drbg_self_test:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0xd8
MOV EBX,EDI
MOV EDI,0x4
CALL 0x0018a34c
MOV R14,RAX
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x60],XMM0
MOVAPS xmmword ptr [RSP],XMM0
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOVAPS xmmword ptr [RSP + 0x40],XMM0
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOVAPS xmmword ptr [RSP + 0x70],XMM0
MOV dword ptr [RSP + 0x6c],0x2710
TEST EBX,EBX
JZ 0x0018a021
LEA RDI,[0x1b0183]
XOR EAX,EAX
CALL 0x0010f070
MOV qword ptr [0x001ef760],0x0
LEA RDX,[0x18a20d]
LEA RCX,[0x1b01c0]
MOV RDI,RSP
MOV RSI,R14
XOR R8D,R8D
XOR R9D,R9D
CALL 0x00189b69
TEST EAX,EAX
JNZ 0x0018a00b
MOV RDI,RSP
MOV dword ptr [RDI + 0x68],0x1
LEA RSI,[RSP + 0x80]
MOV EDX,0x50
XOR ECX,ECX
XOR R8D,R8D
CALL 0x00189c38
TEST EAX,EAX
JNZ 0x0018a00b
MOV RDI,RSP
LEA RSI,[RSP + 0x80]
MOV EDX,0x50
XOR ECX,ECX
XOR R8D,R8D
CALL 0x00189c38
TEST EAX,EAX
JNZ 0x0018a00b
LEA RSI,[0x1b0200]
LEA RDI,[RSP + 0x80]
MOV EDX,0x50
CALL 0x0010f490
TEST EAX,EAX
JZ 0x0018a0c4
LAB_0018a00b:
LEA RDI,[0x1ad696]
CALL 0x0010f6b0
MOV EBP,0x1
JMP 0x0018a1cc
LAB_0018a021:
MOV qword ptr [0x001ef760],0x0
LEA RDX,[0x18a20d]
LEA RCX,[0x1b01c0]
MOV RDI,RSP
MOV RSI,R14
XOR R8D,R8D
XOR R9D,R9D
CALL 0x00189b69
MOV EBP,0x1
TEST EAX,EAX
JNZ 0x0018a1cc
MOV RDI,RSP
MOV dword ptr [RDI + 0x68],0x1
LEA RSI,[RSP + 0x80]
MOV EDX,0x50
XOR ECX,ECX
XOR R8D,R8D
CALL 0x00189c38
TEST EAX,EAX
JNZ 0x0018a1cc
MOV RDI,RSP
LEA RSI,[RSP + 0x80]
MOV EDX,0x50
XOR ECX,ECX
XOR R8D,R8D
CALL 0x00189c38
TEST EAX,EAX
JNZ 0x0018a1cc
LEA RSI,[0x1b0200]
LEA RDI,[RSP + 0x80]
MOV EDX,0x50
CALL 0x0010f490
TEST EAX,EAX
JNZ 0x0018a1cc
LAB_0018a0c4:
MOV R15,RSP
MOV RDI,R15
CALL 0x00189d6f
MOV RDI,R15
CALL 0x00189d6f
TEST EBX,EBX
JZ 0x0018a0f5
LEA RDI,[0x1ab494]
CALL 0x0010f6b0
LEA RDI,[0x1b019e]
XOR EAX,EAX
CALL 0x0010f070
LAB_0018a0f5:
XORPS XMM0,XMM0
MOV RDI,RSP
MOVAPS xmmword ptr [RDI + 0x60],XMM0
MOVAPS xmmword ptr [RDI + 0x70],XMM0
MOVAPS xmmword ptr [RDI + 0x50],XMM0
MOVAPS xmmword ptr [RDI + 0x40],XMM0
MOVAPS xmmword ptr [RDI + 0x30],XMM0
MOVAPS xmmword ptr [RDI + 0x20],XMM0
MOVAPS xmmword ptr [RDI + 0x10],XMM0
MOVAPS xmmword ptr [RDI],XMM0
MOV dword ptr [RDI + 0x6c],0x2710
MOV qword ptr [0x001ef760],0x0
LEA RDX,[0x18a20d]
LEA RCX,[0x1b0250]
MOV RSI,R14
XOR R8D,R8D
XOR R9D,R9D
CALL 0x00189b69
TEST EAX,EAX
JNZ 0x0018a1b7
MOV RDI,RSP
XOR ESI,ESI
XOR EDX,EDX
XOR ECX,ECX
CALL 0x00189a6e
TEST EAX,EAX
JNZ 0x0018a1b7
MOV RDI,RSP
LEA RSI,[RSP + 0x80]
MOV EDX,0x50
XOR ECX,ECX
XOR R8D,R8D
CALL 0x00189c38
TEST EAX,EAX
JNZ 0x0018a1b7
MOV RDI,RSP
LEA RSI,[RSP + 0x80]
MOV EDX,0x50
XOR ECX,ECX
XOR R8D,R8D
CALL 0x00189c38
TEST EAX,EAX
JNZ 0x0018a1b7
LEA RSI,[0x1b0280]
LEA RDI,[RSP + 0x80]
MOV EDX,0x50
CALL 0x0010f490
TEST EAX,EAX
JZ 0x0018a1dc
LAB_0018a1b7:
MOV EBP,0x1
TEST EBX,EBX
JZ 0x0018a1cc
LEA RDI,[0x1ad696]
CALL 0x0010f6b0
LAB_0018a1cc:
MOV EAX,EBP
ADD RSP,0xd8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0018a1dc:
MOV R14,RSP
MOV RDI,R14
CALL 0x00189d6f
MOV RDI,R14
CALL 0x00189d6f
XOR EBP,EBP
TEST EBX,EBX
JZ 0x0018a1cc
LEA RDI,[0x1ab494]
CALL 0x0010f6b0
MOV EDI,0xa
CALL 0x0010f620
JMP 0x0018a1cc
|
int8 mbedtls_hmac_drbg_self_test(int param_1)
{
int4 uVar1;
int iVar2;
int8 uVar3;
int8 local_f8;
int8 uStack_f0;
int8 local_e8;
int8 uStack_e0;
int8 local_d8;
int8 uStack_d0;
int8 local_c8;
int8 uStack_c0;
int8 local_b8;
int8 uStack_b0;
int8 local_a8;
int8 uStack_a0;
int8 local_98;
int8 uStack_90;
int8 local_88;
int8 uStack_80;
int1 local_78 [88];
uVar3 = mbedtls_md_info_from_type(4);
local_98 = 0;
local_f8 = 0;
uStack_f0 = 0;
local_e8 = 0;
uStack_e0 = 0;
local_d8 = 0;
uStack_d0 = 0;
local_c8 = 0;
uStack_c0 = 0;
local_b8 = 0;
uStack_b0 = 0;
local_a8 = 0;
uStack_a0 = 0;
local_88 = 0;
uStack_80 = 0;
uStack_90._0_4_ = 0;
uVar1 = (int4)uStack_90;
uStack_90._0_4_ = 0;
uStack_90._4_4_ = 10000;
if (param_1 == 0) {
test_offset = 0;
uStack_90._0_4_ = uVar1;
iVar2 = mbedtls_hmac_drbg_seed(&local_f8,uVar3,hmac_drbg_self_test_entropy,entropy_pr,0,0);
if (iVar2 != 0) {
return 1;
}
uStack_90._0_4_ = 1;
iVar2 = mbedtls_hmac_drbg_random_with_add(&local_f8,local_78,0x50,0,0);
if (iVar2 != 0) {
return 1;
}
iVar2 = mbedtls_hmac_drbg_random_with_add(&local_f8,local_78,0x50,0,0);
if (iVar2 != 0) {
return 1;
}
iVar2 = bcmp(local_78,result_pr,0x50);
if (iVar2 != 0) {
return 1;
}
LAB_0018a0c4:
mbedtls_hmac_drbg_free(&local_f8);
mbedtls_hmac_drbg_free(&local_f8);
if (param_1 != 0) {
puts("passed");
printf(" HMAC_DRBG (PR = False) : ");
}
local_98 = 0;
local_88 = 0;
uStack_80 = 0;
local_a8 = 0;
uStack_a0 = 0;
local_b8 = 0;
uStack_b0 = 0;
local_c8 = 0;
uStack_c0 = 0;
local_d8 = 0;
uStack_d0 = 0;
local_e8 = 0;
uStack_e0 = 0;
local_f8 = 0;
uStack_f0 = 0;
uStack_90 = 0x271000000000;
test_offset = 0;
iVar2 = mbedtls_hmac_drbg_seed(&local_f8,uVar3,hmac_drbg_self_test_entropy,entropy_nopr,0,0);
if (((iVar2 == 0) && (iVar2 = hmac_drbg_reseed_core(&local_f8,0,0,0), iVar2 == 0)) &&
((iVar2 = mbedtls_hmac_drbg_random_with_add(&local_f8,local_78,0x50,0,0), iVar2 == 0 &&
((iVar2 = mbedtls_hmac_drbg_random_with_add(&local_f8,local_78,0x50,0,0), iVar2 == 0 &&
(iVar2 = bcmp(local_78,result_nopr,0x50), iVar2 == 0)))))) {
mbedtls_hmac_drbg_free(&local_f8);
mbedtls_hmac_drbg_free(&local_f8);
if (param_1 == 0) {
return 0;
}
puts("passed");
putchar(10);
return 0;
}
if (param_1 != 0) {
puts("failed");
}
}
else {
printf(" HMAC_DRBG (PR = True) : ");
test_offset = 0;
iVar2 = mbedtls_hmac_drbg_seed(&local_f8,uVar3,hmac_drbg_self_test_entropy,entropy_pr,0,0);
if (iVar2 == 0) {
uStack_90._0_4_ = 1;
iVar2 = mbedtls_hmac_drbg_random_with_add(&local_f8,local_78,0x50,0,0);
if (((iVar2 == 0) &&
(iVar2 = mbedtls_hmac_drbg_random_with_add(&local_f8,local_78,0x50,0,0), iVar2 == 0)) &&
(iVar2 = bcmp(local_78,result_pr,0x50), iVar2 == 0)) goto LAB_0018a0c4;
}
puts("failed");
}
return 1;
}
|
|
60,668
|
my_charpos_mb
|
eloqsql/strings/ctype-mb.c
|
size_t my_charpos_mb(CHARSET_INFO *cs __attribute__((unused)),
const char *pos, const char *end, size_t length)
{
const char *start= pos;
while (length && pos < end)
{
uint mb_len;
pos+= (mb_len= my_ismbchar(cs, pos, end)) ? mb_len : 1;
length--;
}
return (size_t) (length ? end+2-start : pos-start);
}
|
O3
|
c
|
my_charpos_mb:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %rbx
testq %rcx, %rcx
setne %cl
sete %al
cmpq %rdx, %rsi
setae %dl
orb %al, %dl
movq %rsi, -0x30(%rbp)
movq %rsi, %rax
jne 0x3d5e2
movq %rdi, %r12
decq %r15
movl $0x1, %r14d
movq -0x30(%rbp), %rax
movq %rax, %r13
movq 0xb8(%r12), %rax
movq %r12, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq *0xc0(%rax)
cmpl $0x2, %eax
cmovbl %r14d, %eax
cmovll %r14d, %eax
addq %r13, %rax
addq $-0x1, %r15
setb %cl
jae 0x3d5e2
cmpq %rbx, %rax
jb 0x3d5ac
addq $0x2, %rbx
testb %cl, %cl
cmoveq %rax, %rbx
subq -0x30(%rbp), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
my_charpos_mb:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15, rcx
mov rbx, rdx
test rcx, rcx
setnz cl
setz al
cmp rsi, rdx
setnb dl
or dl, al
mov [rbp+var_30], rsi
mov rax, rsi
jnz short loc_3D5E2
mov r12, rdi
dec r15
mov r14d, 1
mov rax, [rbp+var_30]
loc_3D5AC:
mov r13, rax
mov rax, [r12+0B8h]
mov rdi, r12
mov rsi, r13
mov rdx, rbx
call qword ptr [rax+0C0h]
cmp eax, 2
cmovb eax, r14d
cmovl eax, r14d
add rax, r13
add r15, 0FFFFFFFFFFFFFFFFh
setb cl
jnb short loc_3D5E2
cmp rax, rbx
jb short loc_3D5AC
loc_3D5E2:
add rbx, 2
test cl, cl
cmovz rbx, rax
sub rbx, [rbp+var_30]
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
unsigned long long my_charpos_mb(long long a1, unsigned long long a2, unsigned long long a3, long long a4)
{
long long v4; // r15
bool v6; // zf
unsigned long long v7; // rax
long long v8; // r15
unsigned long long v9; // r13
long long v10; // rax
bool v11; // cc
bool v12; // cf
unsigned long long v13; // rbx
v4 = a4;
v6 = a4 == 0;
LOBYTE(a4) = a4 != 0;
v7 = a2;
if ( !v6 && a2 < a3 )
{
v8 = v4 - 1;
v7 = a2;
do
{
v9 = v7;
v10 = (*(long long ( **)(long long, unsigned long long, unsigned long long, long long))(*(_QWORD *)(a1 + 184)
+ 192LL))(
a1,
v7,
a3,
a4);
v11 = (int)v10 < 2;
if ( (unsigned int)v10 < 2 )
v10 = 1LL;
if ( v11 )
v10 = 1LL;
v7 = v9 + v10;
v12 = v8-- != 0;
LOBYTE(a4) = v12;
}
while ( v12 && v7 < a3 );
}
v13 = a3 + 2;
if ( !(_BYTE)a4 )
v13 = v7;
return v13 - a2;
}
|
my_charpos_mb:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RCX
MOV RBX,RDX
TEST RCX,RCX
SETNZ CL
SETZ AL
CMP RSI,RDX
SETNC DL
OR DL,AL
MOV qword ptr [RBP + -0x30],RSI
MOV RAX,RSI
JNZ 0x0013d5e2
MOV R12,RDI
DEC R15
MOV R14D,0x1
MOV RAX,qword ptr [RBP + -0x30]
LAB_0013d5ac:
MOV R13,RAX
MOV RAX,qword ptr [R12 + 0xb8]
MOV RDI,R12
MOV RSI,R13
MOV RDX,RBX
CALL qword ptr [RAX + 0xc0]
CMP EAX,0x2
CMOVC EAX,R14D
CMOVL EAX,R14D
ADD RAX,R13
ADD R15,-0x1
SETC CL
JNC 0x0013d5e2
CMP RAX,RBX
JC 0x0013d5ac
LAB_0013d5e2:
ADD RBX,0x2
TEST CL,CL
CMOVZ RBX,RAX
SUB RBX,qword ptr [RBP + -0x30]
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long my_charpos_mb(long param_1,ulong param_2,ulong param_3,long param_4)
{
uint uVar1;
ulong uVar2;
ulong uVar3;
bool bVar4;
bVar4 = param_4 != 0;
uVar3 = param_2;
if (param_2 < param_3 && bVar4) {
do {
param_4 = param_4 + -1;
uVar1 = (**(code **)(*(long *)(param_1 + 0xb8) + 0xc0))(param_1,uVar3,param_3);
uVar2 = (ulong)uVar1;
if (uVar1 < 2) {
uVar2 = 1;
}
if ((int)uVar1 < 2) {
uVar2 = 1;
}
uVar3 = uVar2 + uVar3;
bVar4 = param_4 != 0;
} while ((bVar4) && (uVar3 < param_3));
}
uVar2 = param_3 + 2;
if (!bVar4) {
uVar2 = uVar3;
}
return uVar2 - param_2;
}
|
|
60,669
|
inline_mysql_rwlock_destroy
|
eloqsql/include/mysql/psi/mysql_thread.h
|
static inline int inline_mysql_rwlock_destroy(
mysql_rwlock_t *that)
{
#ifdef HAVE_PSI_RWLOCK_INTERFACE
if (psi_likely(that->m_psi != NULL))
{
PSI_RWLOCK_CALL(destroy_rwlock)(that->m_psi);
that->m_psi= NULL;
}
#endif
return rwlock_destroy(&that->m_rwlock);
}
|
O0
|
c
|
inline_mysql_rwlock_destroy:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x90(%rax)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x8c3ad
leaq 0x1b0c36(%rip), %rax # 0x23cfc0
movq (%rax), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x90(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movq $0x0, 0x90(%rax)
movq -0x8(%rbp), %rdi
callq 0x89f90
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
|
inline_mysql_rwlock_destroy_0:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
cmp qword ptr [rax+90h], 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_8C3AD
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+58h]
mov rcx, [rbp+var_8]
mov rdi, [rcx+90h]
call rax
mov rax, [rbp+var_8]
mov qword ptr [rax+90h], 0
loc_8C3AD:
mov rdi, [rbp+var_8]
call my_rw_destroy
add rsp, 10h
pop rbp
retn
|
long long inline_mysql_rwlock_destroy_0(long long a1)
{
if ( *(_QWORD *)(a1 + 144) )
{
((void ( *)(_QWORD))PSI_server[11])(*(_QWORD *)(a1 + 144));
*(_QWORD *)(a1 + 144) = 0LL;
}
return my_rw_destroy(a1);
}
|
inline_mysql_rwlock_destroy:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x90],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 0x0018c3ad
LEA RAX,[0x33cfc0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x58]
MOV RCX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RCX + 0x90]
CALL RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x90],0x0
LAB_0018c3ad:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00189f90
ADD RSP,0x10
POP RBP
RET
|
void inline_mysql_rwlock_destroy(long param_1)
{
if (*(long *)(param_1 + 0x90) != 0) {
(**(code **)(PSI_server + 0x58))(*(int8 *)(param_1 + 0x90));
*(int8 *)(param_1 + 0x90) = 0;
}
my_rw_destroy(param_1);
return;
}
|
|
60,670
|
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>>, char const (&) [29], char const*>(char const (&) [29], char const*&&)
|
monkey531[P]llama/common/json.hpp
|
inline OutStringType concat(Args && ... args)
{
OutStringType str;
str.reserve(concat_length(args...));
concat_into(str, std::forward<Args>(args)...);
return str;
}
|
O2
|
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>>, char const (&) [29], char const*>(char const (&) [29], char const*&&):
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x37241
movq %rbx, %rdi
movq %rax, %rsi
callq 0x20a90
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x455c6
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x20de8
movq %r14, %rdi
callq 0x20bf0
|
_ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA52_KcPS9_EEET_DpOT0_:
push r15
push r14
push rbx
mov r14, rdx
mov r15, rsi
mov rbx, rdi
lea rax, [rdi+10h]
mov [rdi], rax
and qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
mov rdi, rsi
mov rsi, rdx
call _ZN8nlohmann16json_abi_v3_11_36detail13concat_lengthIJPKcEEEmS4_DpRKT_; nlohmann::json_abi_v3_11_3::detail::concat_length<char const*>(char const*,char const* const&)
mov rdi, rbx
mov rsi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
mov rdi, rbx
mov rsi, r15
mov rdx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail11concat_intoINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERA52_KcJPS9_ETnNSt9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSE_OSF_DpOT1_
mov rax, rbx
pop rbx
pop r14
pop r15
retn
mov r14, rax
mov rdi, rbx; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r14
call __Unwind_Resume
|
long long nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[52],char const*>(
long long a1,
long long a2,
_QWORD *a3)
{
long long v4; // rax
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
v4 = nlohmann::json_abi_v3_11_3::detail::concat_length<char const*>(a2, a3);
std::string::reserve(a1, v4);
ZN8nlohmann16json_abi_v3_11_36detail11concat_intoINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERA52_KcJPS9_ETnNSt9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSE_OSF_DpOT1_(
a1,
a2,
a3);
return a1;
}
|
concat<std::__cxx11::string,char_const(&)[52],char_const*>:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI],RAX
AND qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
MOV RDI,RSI
MOV RSI,RDX
CALL 0x00137241
LAB_00145471:
MOV RDI,RBX
MOV RSI,RAX
CALL 0x00120a90
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
CALL 0x001455c6
LAB_0014548a:
MOV RAX,RBX
POP RBX
POP R14
POP R15
RET
|
/* std::__cxx11::string nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string, char const
(&) [52], char const*>(char const (&) [52], char const*&&) */
detail * __thiscall
nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string,char_const(&)[52],char_const*>
(detail *this,char *param_1,char **param_2)
{
*(detail **)this = this + 0x10;
*(int8 *)(this + 8) = 0;
this[0x10] = (detail)0x0;
concat_length<char_const*>(param_1,param_2);
/* try { // try from 00145471 to 00145489 has its CatchHandler @ 00145493 */
std::__cxx11::string::reserve((ulong)this);
_ZN8nlohmann16json_abi_v3_11_36detail11concat_intoINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERA52_KcJPS9_ETnNSt9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSE_OSF_DpOT1_
(this,param_1,param_2);
return this;
}
|
|
60,671
|
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>>, char const (&) [29], char const*>(char const (&) [29], char const*&&)
|
monkey531[P]llama/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>>, char const (&) [29], char const*>(char const (&) [29], char const*&&):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x19320
movq %rax, %r12
movq (%r14), %rdi
callq 0x19320
addq %rax, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x19a90
movq %rbx, %rdi
movq %r15, %rsi
callq 0x19d30
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x19d30
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x8825e
movq (%r13), %rsi
incq %rsi
callq 0x196d0
movq %r14, %rdi
callq 0x19c00
|
_ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA22_KcPS9_EEET_DpOT0_:
push r15
push r14
push r13
push r12
push rbx
mov r14, rdx
mov r15, rsi
mov rbx, rdi
lea r13, [rdi+10h]
mov [rdi], r13
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
mov rdi, rsi
call _strlen
mov r12, rax
mov rdi, [r14]
call _strlen
add r12, rax
mov rdi, rbx
mov rsi, r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
mov rdi, rbx
mov rsi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov rsi, [r14]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov rax, rbx
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
mov r14, rax
mov rdi, [rbx]; void *
cmp rdi, r13
jz short loc_8825E
mov rsi, [r13+0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_8825E:
mov rdi, r14
call __Unwind_Resume
|
long long nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[22],char const*>(
long long a1,
long long a2,
_QWORD *a3)
{
long long v4; // r12
long long v5; // rax
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
v4 = strlen(a2);
v5 = strlen(*a3);
std::string::reserve(a1, v5 + v4);
std::string::append(a1, a2);
std::string::append(a1, *a3);
return a1;
}
|
concat<std::__cxx11::string,char_const(&)[22],char_const*>:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
LEA R13,[RDI + 0x10]
MOV qword ptr [RDI],R13
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
MOV RDI,RSI
CALL 0x00119320
MOV R12,RAX
MOV RDI,qword ptr [R14]
CALL 0x00119320
ADD R12,RAX
LAB_00188219:
MOV RDI,RBX
MOV RSI,R12
CALL 0x00119a90
MOV RDI,RBX
MOV RSI,R15
CALL 0x00119d30
MOV RSI,qword ptr [R14]
MOV RDI,RBX
CALL 0x00119d30
LAB_0018823a:
MOV RAX,RBX
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* std::__cxx11::string nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string, char const
(&) [22], char const*>(char const (&) [22], char const*&&) */
detail * __thiscall
nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string,char_const(&)[22],char_const*>
(detail *this,char *param_1,char **param_2)
{
*(detail **)this = this + 0x10;
*(int8 *)(this + 8) = 0;
this[0x10] = (detail)0x0;
strlen(param_1);
strlen(*param_2);
/* try { // try from 00188219 to 00188239 has its CatchHandler @ 00188247 */
std::__cxx11::string::reserve((ulong)this);
std::__cxx11::string::append((char *)this);
std::__cxx11::string::append((char *)this);
return this;
}
|
|
60,672
|
translog_set_sent_to_disk
|
eloqsql/storage/maria/ma_loghandler.c
|
static void translog_set_sent_to_disk(struct st_translog_buffer *buffer)
{
LSN lsn= buffer->last_lsn;
TRANSLOG_ADDRESS in_buffers= buffer->next_buffer_offset;
DBUG_ENTER("translog_set_sent_to_disk");
mysql_mutex_lock(&log_descriptor.sent_to_disk_lock);
DBUG_PRINT("enter", ("lsn: " LSN_FMT " in_buffers: " LSN_FMT " "
"in_buffers_only: " LSN_FMT " start: " LSN_FMT " "
"sent_to_disk: " LSN_FMT,
LSN_IN_PARTS(lsn),
LSN_IN_PARTS(in_buffers),
LSN_IN_PARTS(log_descriptor.log_start),
LSN_IN_PARTS(log_descriptor.in_buffers_only),
LSN_IN_PARTS(log_descriptor.sent_to_disk)));
/*
We write sequentially (first part of following assert) but we rewrite
the same page in case we started mysql and shut it down immediately
(second part of the following assert)
*/
DBUG_ASSERT(cmp_translog_addr(lsn, log_descriptor.sent_to_disk) >= 0 ||
cmp_translog_addr(lsn, log_descriptor.log_start) < 0);
log_descriptor.sent_to_disk= lsn;
/* LSN_IMPOSSIBLE == 0 => it will work for very first time */
if (cmp_translog_addr(in_buffers, log_descriptor.in_buffers_only) > 0)
{
log_descriptor.in_buffers_only= in_buffers;
DBUG_PRINT("info", ("set new in_buffers_only"));
}
mysql_mutex_unlock(&log_descriptor.sent_to_disk_lock);
DBUG_VOID_RETURN;
}
|
O0
|
c
|
translog_set_sent_to_disk:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x100000(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x100018(%rax), %rax
movq %rax, -0x18(%rbp)
leaq 0x41c6af(%rip), %rdi # 0x4793c0
addq $0x800cc0, %rdi # imm = 0x800CC0
leaq 0xf4faf(%rip), %rsi # 0x151cce
movl $0x8e9, %edx # imm = 0x8E9
callq 0x4fcf0
jmp 0x5cd2b
jmp 0x5cd2d
jmp 0x5cd2f
movq -0x10(%rbp), %rax
movq %rax, 0xc1d326(%rip) # 0xc7a060
movq -0x18(%rbp), %rax
subq 0xc1d333(%rip), %rax # 0xc7a078
cmpq $0x0, %rax
jle 0x5cd5a
movq -0x18(%rbp), %rax
movq %rax, 0xc1d322(%rip) # 0xc7a078
jmp 0x5cd58
jmp 0x5cd5a
leaq 0x41c65f(%rip), %rdi # 0x4793c0
addq $0x800cc0, %rdi # imm = 0x800CC0
callq 0x4fd60
jmp 0x5cd6f
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
translog_set_sent_to_disk:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov rax, qword ptr ds:loc_100000[rax]
mov [rbp+var_10], rax
mov rax, [rbp+var_8]
mov rax, [rax+100018h]
mov [rbp+var_18], rax
lea rdi, log_descriptor
add rdi, 800CC0h
lea rsi, aWorkspaceLlm4b_11; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 8E9h
call inline_mysql_mutex_lock_8
jmp short $+2
loc_5CD2B:
jmp short $+2
loc_5CD2D:
jmp short $+2
loc_5CD2F:
mov rax, [rbp+var_10]
mov cs:qword_C7A060, rax
mov rax, [rbp+var_18]
sub rax, cs:qword_C7A078
cmp rax, 0
jle short loc_5CD5A
mov rax, [rbp+var_18]
mov cs:qword_C7A078, rax
jmp short $+2
loc_5CD58:
jmp short $+2
loc_5CD5A:
lea rdi, log_descriptor
add rdi, 800CC0h
call inline_mysql_mutex_unlock_8
jmp short $+2
loc_5CD6F:
add rsp, 20h
pop rbp
retn
|
long long translog_set_sent_to_disk(long long a1)
{
long long v2; // [rsp+8h] [rbp-18h]
long long v3; // [rsp+10h] [rbp-10h]
v3 = *(_QWORD *)((char *)&loc_100000 + a1);
v2 = *(_QWORD *)(a1 + 1048600);
inline_mysql_mutex_lock_8(
(long long)&log_descriptor[1048984],
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
0x8E9u);
qword_C7A060 = v3;
if ( v2 - qword_C7A078 > 0 )
qword_C7A078 = v2;
return inline_mysql_mutex_unlock_8((long long)&log_descriptor[1048984]);
}
|
translog_set_sent_to_disk:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x100000]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x100018]
MOV qword ptr [RBP + -0x18],RAX
LEA RDI,[0x5793c0]
ADD RDI,0x800cc0
LEA RSI,[0x251cce]
MOV EDX,0x8e9
CALL 0x0014fcf0
JMP 0x0015cd2b
LAB_0015cd2b:
JMP 0x0015cd2d
LAB_0015cd2d:
JMP 0x0015cd2f
LAB_0015cd2f:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [0x00d7a060],RAX
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr [0x00d7a078]
CMP RAX,0x0
JLE 0x0015cd5a
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [0x00d7a078],RAX
JMP 0x0015cd58
LAB_0015cd58:
JMP 0x0015cd5a
LAB_0015cd5a:
LEA RDI,[0x5793c0]
ADD RDI,0x800cc0
CALL 0x0014fd60
JMP 0x0015cd6f
LAB_0015cd6f:
ADD RSP,0x20
POP RBP
RET
|
void translog_set_sent_to_disk(long param_1)
{
int8 uVar1;
long lVar2;
uVar1 = *(int8 *)(param_1 + 0x100000);
lVar2 = *(long *)(Elf64_Ehdr_00100000.e_ident_pad + param_1 + 0xf);
inline_mysql_mutex_lock
(&DAT_00d7a080,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
0x8e9);
if (0 < lVar2 - DAT_00d7a078) {
DAT_00d7a078 = lVar2;
}
DAT_00d7a060 = uVar1;
inline_mysql_mutex_unlock(&DAT_00d7a080);
return;
}
|
|
60,673
|
maria_ftparser_alloc_param
|
eloqsql/storage/maria/ma_ft_parser.c
|
MYSQL_FTPARSER_PARAM* maria_ftparser_alloc_param(MARIA_HA *info)
{
if (!info->ftparser_param)
{
/*
. info->ftparser_param can not be zero after the initialization,
because it always includes built-in fulltext parser. And built-in
parser can be called even if the table has no fulltext indexes and
no varchar/text fields.
ftb_find_relevance... parser (ftb_find_relevance_parse,
ftb_find_relevance_add_word) calls ftb_check_phrase... parser
(ftb_check_phrase_internal, ftb_phrase_add_word). Thus MAX_PARAM_NR=2.
*/
info->ftparser_param= (MYSQL_FTPARSER_PARAM *)
my_malloc(PSI_INSTRUMENT_ME, MAX_PARAM_NR * sizeof(MYSQL_FTPARSER_PARAM) *
info->s->ftkeys, MYF(MY_WME | MY_ZEROFILL));
init_alloc_root(PSI_INSTRUMENT_ME, &info->ft_memroot,
FTPARSER_MEMROOT_ALLOC_SIZE, 0, MYF(0));
}
return info->ftparser_param;
}
|
O3
|
c
|
maria_ftparser_alloc_param:
movq 0x368(%rdi), %rax
testq %rax, %rax
je 0x5eaee
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movl 0x748(%rax), %esi
shlq $0x7, %rsi
movl $0x30, %edx
xorl %edi, %edi
callq 0xa6f99
movq %rax, 0x368(%rbx)
leaq 0x328(%rbx), %rsi
movl $0x10000, %edx # imm = 0x10000
xorl %edi, %edi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xa1938
movq 0x368(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
maria_ftparser_alloc_param:
mov rax, [rdi+368h]
test rax, rax
jz short loc_5EAEE
retn
loc_5EAEE:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
mov rax, [rdi]
mov esi, [rax+748h]
shl rsi, 7
mov edx, 30h ; '0'
xor edi, edi
call my_malloc
mov [rbx+368h], rax
lea rsi, [rbx+328h]
mov edx, 10000h
xor edi, edi
xor ecx, ecx
xor r8d, r8d
call init_alloc_root
mov rax, [rbx+368h]
add rsp, 8
pop rbx
pop rbp
retn
|
long long maria_ftparser_alloc_param(_QWORD *a1)
{
long long result; // rax
result = a1[109];
if ( !result )
{
a1[109] = my_malloc(0LL, (unsigned long long)*(unsigned int *)(*a1 + 1864LL) << 7, 48LL);
init_alloc_root(0LL, a1 + 101, 0x10000LL, 0LL, 0LL);
return a1[109];
}
return result;
}
|
maria_ftparser_alloc_param:
MOV RAX,qword ptr [RDI + 0x368]
TEST RAX,RAX
JZ 0x0015eaee
RET
LAB_0015eaee:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV RAX,qword ptr [RDI]
MOV ESI,dword ptr [RAX + 0x748]
SHL RSI,0x7
MOV EDX,0x30
XOR EDI,EDI
CALL 0x001a6f99
MOV qword ptr [RBX + 0x368],RAX
LEA RSI,[RBX + 0x328]
MOV EDX,0x10000
XOR EDI,EDI
XOR ECX,ECX
XOR R8D,R8D
CALL 0x001a1938
MOV RAX,qword ptr [RBX + 0x368]
ADD RSP,0x8
POP RBX
POP RBP
RET
|
long maria_ftparser_alloc_param(long *param_1)
{
long lVar1;
int8 in_R9;
long lVar2;
lVar2 = param_1[0x6d];
if (lVar2 != 0) {
return lVar2;
}
lVar1 = my_malloc(0,(ulong)*(uint *)(*param_1 + 0x748) << 7,0x30);
param_1[0x6d] = lVar1;
init_alloc_root(0,param_1 + 0x65,0x10000,0,0,in_R9,lVar2);
return param_1[0x6d];
}
|
|
60,674
|
mp_add_ui_dec
|
bluesky950520[P]quickjs/libbf.c
|
limb_t mp_add_ui_dec(limb_t *tab, limb_t b, mp_size_t n)
{
limb_t base = BF_DEC_BASE;
mp_size_t i;
limb_t k, a, v;
k=b;
for(i=0;i<n;i++) {
v = tab[i];
a = v + k - base;
k = a <= v;
if (!k)
a += base;
tab[i] = a;
if (k == 0)
break;
}
return k;
}
|
O1
|
c
|
mp_add_ui_dec:
movq %rsi, %rax
testq %rdx, %rdx
jle 0x8cce5
movabsq $0x7538dcfb76180000, %rcx # imm = 0x7538DCFB76180000
xorl %esi, %esi
movq (%rdi,%rsi,8), %r8
addq %r8, %rax
leaq (%rax,%rcx), %r9
cmpq %r8, %r9
cmovbeq %r9, %rax
movq %rax, (%rdi,%rsi,8)
ja 0x8cce6
incq %rsi
movl $0x1, %eax
cmpq %rsi, %rdx
jne 0x8ccc0
retq
xorl %eax, %eax
retq
|
mp_add_ui_dec:
mov rax, rsi
test rdx, rdx
jle short locret_8CCE5
mov rcx, 7538DCFB76180000h
xor esi, esi
loc_8CCC0:
mov r8, [rdi+rsi*8]
add rax, r8
lea r9, [rax+rcx]
cmp r9, r8
cmovbe rax, r9
mov [rdi+rsi*8], rax
ja short loc_8CCE6
inc rsi
mov eax, 1
cmp rdx, rsi
jnz short loc_8CCC0
locret_8CCE5:
retn
loc_8CCE6:
xor eax, eax
retn
|
long long mp_add_ui_dec(long long a1, long long a2, long long a3)
{
long long result; // rax
long long v4; // rsi
unsigned long long v5; // r8
unsigned long long v6; // rax
bool v7; // cc
result = a2;
if ( a3 > 0 )
{
v4 = 0LL;
while ( 1 )
{
v5 = *(_QWORD *)(a1 + 8 * v4);
v6 = v5 + result;
v7 = v6 + 0x7538DCFB76180000LL <= v5;
if ( v6 + 0x7538DCFB76180000LL <= v5 )
v6 += 0x7538DCFB76180000LL;
*(_QWORD *)(a1 + 8 * v4) = v6;
if ( !v7 )
break;
++v4;
result = 1LL;
if ( a3 == v4 )
return result;
}
return 0LL;
}
return result;
}
|
mp_add_ui_dec:
MOV RAX,RSI
TEST RDX,RDX
JLE 0x0018cce5
MOV RCX,0x7538dcfb76180000
XOR ESI,ESI
LAB_0018ccc0:
MOV R8,qword ptr [RDI + RSI*0x8]
ADD RAX,R8
LEA R9,[RAX + RCX*0x1]
CMP R9,R8
CMOVBE RAX,R9
MOV qword ptr [RDI + RSI*0x8],RAX
JA 0x0018cce6
INC RSI
MOV EAX,0x1
CMP RDX,RSI
JNZ 0x0018ccc0
LAB_0018cce5:
RET
LAB_0018cce6:
XOR EAX,EAX
RET
|
long mp_add_ui_dec(long param_1,long param_2,long param_3)
{
ulong uVar1;
ulong uVar2;
ulong uVar3;
long lVar4;
if (0 < param_3) {
lVar4 = 0;
do {
uVar2 = *(ulong *)(param_1 + lVar4 * 8);
uVar1 = param_2 + uVar2 + 0x7538dcfb76180000;
uVar3 = param_2 + uVar2;
if (uVar1 <= uVar2) {
uVar3 = uVar1;
}
*(ulong *)(param_1 + lVar4 * 8) = uVar3;
if (uVar2 < uVar1) {
return 0;
}
lVar4 = lVar4 + 1;
param_2 = 1;
} while (param_3 != lVar4);
}
return param_2;
}
|
|
60,675
|
mp_add_ui_dec
|
bluesky950520[P]quickjs/libbf.c
|
limb_t mp_add_ui_dec(limb_t *tab, limb_t b, mp_size_t n)
{
limb_t base = BF_DEC_BASE;
mp_size_t i;
limb_t k, a, v;
k=b;
for(i=0;i<n;i++) {
v = tab[i];
a = v + k - base;
k = a <= v;
if (!k)
a += base;
tab[i] = a;
if (k == 0)
break;
}
return k;
}
|
O3
|
c
|
mp_add_ui_dec:
movq %rsi, %rax
testq %rdx, %rdx
jle 0x8f713
movabsq $0x7538dcfb76180000, %rcx # imm = 0x7538DCFB76180000
xorl %esi, %esi
movq (%rdi,%rsi,8), %r8
addq %r8, %rax
leaq (%rax,%rcx), %r9
cmpq %r8, %r9
cmovbeq %r9, %rax
movq %rax, (%rdi,%rsi,8)
ja 0x8f714
incq %rsi
movl $0x1, %eax
cmpq %rsi, %rdx
jne 0x8f6ee
retq
xorl %eax, %eax
retq
|
mp_add_ui_dec:
mov rax, rsi
test rdx, rdx
jle short locret_8F713
mov rcx, 7538DCFB76180000h
xor esi, esi
loc_8F6EE:
mov r8, [rdi+rsi*8]
add rax, r8
lea r9, [rax+rcx]
cmp r9, r8
cmovbe rax, r9
mov [rdi+rsi*8], rax
ja short loc_8F714
inc rsi
mov eax, 1
cmp rdx, rsi
jnz short loc_8F6EE
locret_8F713:
retn
loc_8F714:
xor eax, eax
retn
|
long long mp_add_ui_dec(long long a1, long long a2, long long a3)
{
long long result; // rax
long long v4; // rsi
unsigned long long v5; // r8
unsigned long long v6; // rax
bool v7; // cc
result = a2;
if ( a3 > 0 )
{
v4 = 0LL;
while ( 1 )
{
v5 = *(_QWORD *)(a1 + 8 * v4);
v6 = v5 + result;
v7 = v6 + 0x7538DCFB76180000LL <= v5;
if ( v6 + 0x7538DCFB76180000LL <= v5 )
v6 += 0x7538DCFB76180000LL;
*(_QWORD *)(a1 + 8 * v4) = v6;
if ( !v7 )
break;
++v4;
result = 1LL;
if ( a3 == v4 )
return result;
}
return 0LL;
}
return result;
}
|
mp_add_ui_dec:
MOV RAX,RSI
TEST RDX,RDX
JLE 0x0018f713
MOV RCX,0x7538dcfb76180000
XOR ESI,ESI
LAB_0018f6ee:
MOV R8,qword ptr [RDI + RSI*0x8]
ADD RAX,R8
LEA R9,[RAX + RCX*0x1]
CMP R9,R8
CMOVBE RAX,R9
MOV qword ptr [RDI + RSI*0x8],RAX
JA 0x0018f714
INC RSI
MOV EAX,0x1
CMP RDX,RSI
JNZ 0x0018f6ee
LAB_0018f713:
RET
LAB_0018f714:
XOR EAX,EAX
RET
|
long mp_add_ui_dec(long param_1,long param_2,long param_3)
{
ulong uVar1;
ulong uVar2;
ulong uVar3;
long lVar4;
if (0 < param_3) {
lVar4 = 0;
do {
uVar2 = *(ulong *)(param_1 + lVar4 * 8);
uVar1 = param_2 + uVar2 + 0x7538dcfb76180000;
uVar3 = param_2 + uVar2;
if (uVar1 <= uVar2) {
uVar3 = uVar1;
}
*(ulong *)(param_1 + lVar4 * 8) = uVar3;
if (uVar2 < uVar1) {
return 0;
}
lVar4 = lVar4 + 1;
param_2 = 1;
} while (param_3 != lVar4);
}
return param_2;
}
|
|
60,676
|
my_utf8mb3_uni_no_range
|
eloqsql/strings/ctype-utf8.c
|
static int my_utf8mb3_uni_no_range(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t * pwc, const uchar *s)
{
uchar c;
c= s[0];
if (c < 0x80)
{
*pwc = c;
return 1;
}
if (c < 0xc2)
return MY_CS_ILSEQ;
if (c < 0xe0)
{
if (!((s[1] ^ 0x80) < 0x40))
return MY_CS_ILSEQ;
*pwc= UTF8MB2_CODE(c, s[1]);
return 2;
}
if (c < 0xf0)
{
if (!IS_UTF8MB3_STEP2(c, s[1], s[2]))
return MY_CS_ILSEQ;
*pwc= UTF8MB3_CODE(c, s[1], s[2]);
return 3;
}
return MY_CS_ILSEQ;
}
|
O3
|
c
|
my_utf8mb3_uni_no_range:
pushq %rbp
movq %rsp, %rbp
movzbl (%rsi), %ecx
testb %cl, %cl
js 0x4f7ad
movl $0x1, %eax
movq %rcx, (%rdi)
jmp 0x4f7b4
xorl %eax, %eax
cmpb $-0x3e, %cl
jae 0x4f7b6
popq %rbp
retq
cmpb $-0x21, %cl
ja 0x4f7d9
movzbl 0x1(%rsi), %edx
xorl $0x80, %edx
cmpb $0x3f, %dl
ja 0x4f7b4
andl $0x1f, %ecx
shll $0x6, %ecx
orl %edx, %ecx
movl $0x2, %eax
jmp 0x4f7a8
cmpb $-0x11, %cl
ja 0x4f7b4
movzbl 0x1(%rsi), %edx
cmpb $-0x41, %dl
jg 0x4f7b4
movzbl 0x2(%rsi), %esi
cmpb $-0x41, %sil
jg 0x4f7b4
cmpl $0xe0, %ecx
sete %r8b
cmpb $-0x60, %dl
setb %r9b
testb %r9b, %r8b
jne 0x4f7b4
shll $0xc, %ecx
movzwl %cx, %eax
andl $0x3f, %edx
shll $0x6, %edx
orl %eax, %edx
andl $0x3f, %esi
orq %rdx, %rsi
movl $0x3, %eax
movq %rsi, %rcx
jmp 0x4f7a8
|
my_utf8mb3_uni_no_range:
push rbp
mov rbp, rsp
movzx ecx, byte ptr [rsi]
test cl, cl
js short loc_4F7AD
mov eax, 1
loc_4F7A8:
mov [rdi], rcx
jmp short loc_4F7B4
loc_4F7AD:
xor eax, eax
cmp cl, 0C2h
jnb short loc_4F7B6
loc_4F7B4:
pop rbp
retn
loc_4F7B6:
cmp cl, 0DFh
ja short loc_4F7D9
movzx edx, byte ptr [rsi+1]
xor edx, 80h
cmp dl, 3Fh ; '?'
ja short loc_4F7B4
and ecx, 1Fh
shl ecx, 6
or ecx, edx
mov eax, 2
jmp short loc_4F7A8
loc_4F7D9:
cmp cl, 0EFh
ja short loc_4F7B4
movzx edx, byte ptr [rsi+1]
cmp dl, 0BFh
jg short loc_4F7B4
movzx esi, byte ptr [rsi+2]
cmp sil, 0BFh
jg short loc_4F7B4
cmp ecx, 0E0h
setz r8b
cmp dl, 0A0h
setb r9b
test r8b, r9b
jnz short loc_4F7B4
shl ecx, 0Ch
movzx eax, cx
and edx, 3Fh
shl edx, 6
or edx, eax
and esi, 3Fh
or rsi, rdx
mov eax, 3
mov rcx, rsi
jmp short loc_4F7A8
|
long long my_utf8mb3_uni_no_range(unsigned long long *a1, unsigned __int8 *a2)
{
unsigned long long v2; // rcx
long long result; // rax
char v4; // dl
char v5; // si
v2 = *a2;
if ( (v2 & 0x80u) == 0LL )
{
result = 1LL;
LABEL_3:
*a1 = v2;
return result;
}
result = 0LL;
if ( (unsigned __int8)v2 >= 0xC2u )
{
if ( (unsigned __int8)v2 > 0xDFu )
{
if ( (unsigned __int8)v2 <= 0xEFu )
{
v4 = a2[1];
if ( v4 <= -65 )
{
v5 = a2[2];
if ( v5 <= -65 && ((unsigned __int8)v4 >= 0xA0u || (_DWORD)v2 != 224) )
{
result = 3LL;
v2 = (unsigned __int16)((_WORD)v2 << 12) | ((unsigned __int8)(v4 & 0x3F) << 6) | (unsigned long long)(v5 & 0x3F);
goto LABEL_3;
}
}
}
}
else if ( (a2[1] ^ 0x80u) <= 0x3F )
{
v2 = a2[1] ^ 0x80 | ((unsigned __int8)(v2 & 0x1F) << 6);
result = 2LL;
goto LABEL_3;
}
}
return result;
}
|
my_utf8mb3_uni_no_range:
PUSH RBP
MOV RBP,RSP
MOVZX ECX,byte ptr [RSI]
TEST CL,CL
JS 0x0014f7ad
MOV EAX,0x1
LAB_0014f7a8:
MOV qword ptr [RDI],RCX
JMP 0x0014f7b4
LAB_0014f7ad:
XOR EAX,EAX
CMP CL,0xc2
JNC 0x0014f7b6
LAB_0014f7b4:
POP RBP
RET
LAB_0014f7b6:
CMP CL,0xdf
JA 0x0014f7d9
MOVZX EDX,byte ptr [RSI + 0x1]
XOR EDX,0x80
CMP DL,0x3f
JA 0x0014f7b4
AND ECX,0x1f
SHL ECX,0x6
OR ECX,EDX
MOV EAX,0x2
JMP 0x0014f7a8
LAB_0014f7d9:
CMP CL,0xef
JA 0x0014f7b4
MOVZX EDX,byte ptr [RSI + 0x1]
CMP DL,0xbf
JG 0x0014f7b4
MOVZX ESI,byte ptr [RSI + 0x2]
CMP SIL,0xbf
JG 0x0014f7b4
CMP ECX,0xe0
SETZ R8B
CMP DL,0xa0
SETC R9B
TEST R8B,R9B
JNZ 0x0014f7b4
SHL ECX,0xc
MOVZX EAX,CX
AND EDX,0x3f
SHL EDX,0x6
OR EDX,EAX
AND ESI,0x3f
OR RSI,RDX
MOV EAX,0x3
MOV RCX,RSI
JMP 0x0014f7a8
|
int8 my_utf8mb3_uni_no_range(ulong *param_1,byte *param_2)
{
byte bVar1;
byte bVar2;
int8 uVar3;
ulong uVar4;
bVar1 = *param_2;
uVar4 = (ulong)bVar1;
if ((char)bVar1 < '\0') {
if (bVar1 < 0xc2) {
return 0;
}
if (bVar1 < 0xe0) {
if (0x3f < (byte)(param_2[1] ^ 0x80)) {
return 0;
}
uVar4 = (ulong)((bVar1 & 0x1f) << 6 | param_2[1] ^ 0x80);
uVar3 = 2;
}
else {
if (0xef < bVar1) {
return 0;
}
bVar2 = param_2[1];
if (-0x41 < (char)bVar2) {
return 0;
}
if (-0x41 < (char)param_2[2]) {
return 0;
}
if (bVar1 == 0xe0 && bVar2 < 0xa0) {
return 0;
}
uVar4 = (ulong)(param_2[2] & 0x3f | (bVar2 & 0x3f) << 6 | (bVar1 & 0xf) << 0xc);
uVar3 = 3;
}
}
else {
uVar3 = 1;
}
*param_1 = uVar4;
return uVar3;
}
|
|
60,677
|
ftxui::(anonymous namespace)::InputBase::HandleBackspace()
|
Andrewchistyakov[P]flashcards_lyc/build_O0/_deps/ftxui-src/src/ftxui/component/input.cpp
|
bool HandleBackspace() {
if (cursor_position() == 0) {
return false;
}
const size_t start = GlyphPrevious(content(), cursor_position());
const size_t end = cursor_position();
content->erase(start, end - start);
cursor_position() = start;
return true;
}
|
O0
|
cpp
|
ftxui::(anonymous namespace)::InputBase::HandleBackspace():
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x28, %rdi
addq $0xd0, %rdi
callq 0x5d970
cmpl $0x0, (%rax)
jne 0x5b0b2
movb $0x0, -0x1(%rbp)
jmp 0x5b147
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
callq 0x5d850
movq -0x28(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0x28, %rdi
addq $0xd0, %rdi
callq 0x5d970
movq -0x38(%rbp), %rdi
movslq (%rax), %rsi
callq 0x8dab0
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x28, %rdi
addq $0xd0, %rdi
callq 0x5d970
movq -0x28(%rbp), %rdi
movslq (%rax), %rax
movq %rax, -0x20(%rbp)
addq $0x28, %rdi
callq 0x5d830
movq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
subq -0x18(%rbp), %rdx
callq 0xd0e0
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, -0x2c(%rbp)
addq $0x28, %rdi
addq $0xd0, %rdi
callq 0x5d970
movl -0x2c(%rbp), %ecx
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
_ZN5ftxui12_GLOBAL__N_19InputBase15HandleBackspaceEv:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov rdi, [rbp+var_10]
mov [rbp+var_28], rdi
add rdi, 28h ; '('
add rdi, 0D0h
call _ZN5ftxui3RefIiEclEv; ftxui::Ref<int>::operator()(void)
cmp dword ptr [rax], 0
jnz short loc_5B0B2
mov [rbp+var_1], 0
jmp loc_5B147
loc_5B0B2:
mov rdi, [rbp+var_28]
add rdi, 28h ; '('
call _ZN5ftxui3RefINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEclEv; ftxui::Ref<std::string>::operator()(void)
mov rdi, [rbp+var_28]
mov [rbp+var_38], rax
add rdi, 28h ; '('
add rdi, 0D0h
call _ZN5ftxui3RefIiEclEv; ftxui::Ref<int>::operator()(void)
mov rdi, [rbp+var_38]
movsxd rsi, dword ptr [rax]
call _ZN5ftxui13GlyphPreviousERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEm; ftxui::GlyphPrevious(std::string const&,ulong)
mov rdi, [rbp+var_28]
mov [rbp+var_18], rax
add rdi, 28h ; '('
add rdi, 0D0h
call _ZN5ftxui3RefIiEclEv; ftxui::Ref<int>::operator()(void)
mov rdi, [rbp+var_28]
movsxd rax, dword ptr [rax]
mov [rbp+var_20], rax
add rdi, 28h ; '('
call _ZN5ftxui3RefINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEptEv; ftxui::Ref<std::string>::operator->(void)
mov rdi, rax
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
sub rdx, [rbp+var_18]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5eraseEmm; std::string::erase(ulong,ulong)
mov rdi, [rbp+var_28]
mov rax, [rbp+var_18]
mov [rbp+var_2C], eax
add rdi, 28h ; '('
add rdi, 0D0h
call _ZN5ftxui3RefIiEclEv; ftxui::Ref<int>::operator()(void)
mov ecx, [rbp+var_2C]
mov [rax], ecx
mov [rbp+var_1], 1
loc_5B147:
mov al, [rbp+var_1]
and al, 1
add rsp, 40h
pop rbp
retn
|
char ftxui::`anonymous namespace'::InputBase::HandleBackspace(ftxui::_anonymous_namespace_::InputBase *this)
{
int *v1; // rax
long long v2; // rax
long long v4; // [rsp+8h] [rbp-38h]
long long v5; // [rsp+20h] [rbp-20h]
long long v6; // [rsp+28h] [rbp-18h]
if ( !*(_DWORD *)ftxui::Ref<int>::operator()((char *)this + 248) )
return 0;
v4 = ftxui::Ref<std::string>::operator()((char *)this + 40);
v1 = (int *)ftxui::Ref<int>::operator()((char *)this + 248);
v6 = ftxui::GlyphPrevious(v4, *v1);
v5 = *(int *)ftxui::Ref<int>::operator()((char *)this + 248);
v2 = ftxui::Ref<std::string>::operator->((char *)this + 40);
std::string::erase(v2, v6, v5 - v6);
*(_DWORD *)ftxui::Ref<int>::operator()((char *)this + 248) = v6;
return 1;
}
|
HandleBackspace:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV RDI,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x28],RDI
ADD RDI,0x28
ADD RDI,0xd0
CALL 0x0015d970
CMP dword ptr [RAX],0x0
JNZ 0x0015b0b2
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0015b147
LAB_0015b0b2:
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x28
CALL 0x0015d850
MOV RDI,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x38],RAX
ADD RDI,0x28
ADD RDI,0xd0
CALL 0x0015d970
MOV RDI,qword ptr [RBP + -0x38]
MOVSXD RSI,dword ptr [RAX]
CALL 0x0018dab0
MOV RDI,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x18],RAX
ADD RDI,0x28
ADD RDI,0xd0
CALL 0x0015d970
MOV RDI,qword ptr [RBP + -0x28]
MOVSXD RAX,dword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
ADD RDI,0x28
CALL 0x0015d830
MOV RDI,RAX
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
SUB RDX,qword ptr [RBP + -0x18]
CALL 0x0010d0e0
MOV RDI,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x2c],EAX
ADD RDI,0x28
ADD RDI,0xd0
CALL 0x0015d970
MOV ECX,dword ptr [RBP + -0x2c]
MOV dword ptr [RAX],ECX
MOV byte ptr [RBP + -0x1],0x1
LAB_0015b147:
MOV AL,byte ptr [RBP + -0x1]
AND AL,0x1
ADD RSP,0x40
POP RBP
RET
|
/* ftxui::(anonymous namespace)::InputBase::HandleBackspace() */
bool __thiscall ftxui::(anonymous_namespace)::InputBase::HandleBackspace(InputBase *this)
{
int iVar1;
int *piVar2;
string *psVar3;
ulong uVar4;
ulong uVar5;
int4 *puVar6;
piVar2 = (int *)Ref<int>::operator()((Ref<int> *)(this + 0xf8));
iVar1 = *piVar2;
if (iVar1 != 0) {
psVar3 = (string *)
Ref<std::__cxx11::string>::operator()((Ref<std::__cxx11::string> *)(this + 0x28));
piVar2 = (int *)Ref<int>::operator()((Ref<int> *)(this + 0xf8));
uVar4 = GlyphPrevious(psVar3,(long)*piVar2);
Ref<int>::operator()((Ref<int> *)(this + 0xf8));
uVar5 = Ref<std::__cxx11::string>::operator->((Ref<std::__cxx11::string> *)(this + 0x28));
std::__cxx11::string::erase(uVar5,uVar4);
puVar6 = (int4 *)Ref<int>::operator()((Ref<int> *)(this + 0xf8));
*puVar6 = (int)uVar4;
}
return iVar1 != 0;
}
|
|
60,678
|
nglog::base_logging::LogStreamBuf::~LogStreamBuf()
|
ng-log[P]ng-log/src/ng-log/logging.h
|
class NGLOG_EXPORT LogStreamBuf : public std::streambuf {
public:
// REQUIREMENTS: "len" must be >= 2 to account for the '\n' and '\0'.
LogStreamBuf(char* buf, int len) { setp(buf, buf + len - 2); }
// This effectively ignores overflow.
int_type overflow(int_type ch) { return ch; }
// Legacy public ostrstream method.
size_t pcount() const { return static_cast<size_t>(pptr() - pbase()); }
char* pbase() const { return std::streambuf::pbase(); }
}
|
O2
|
c
|
nglog::base_logging::LogStreamBuf::~LogStreamBuf():
pushq %rbx
movq %rdi, %rbx
callq 0x8b40
movq %rbx, %rdi
popq %rbx
jmp 0x86e0
|
_ZN5nglog12base_logging12LogStreamBufD0Ev:
push rbx
mov rbx, rdi
call __ZNSt15basic_streambufIcSt11char_traitsIcEED2Ev; std::streambuf::~streambuf()
mov rdi, rbx
pop rbx
jmp _free
|
void nglog::base_logging::LogStreamBuf::~LogStreamBuf(nglog::base_logging::LogStreamBuf *this)
{
std::streambuf::~streambuf();
free(this);
}
|
~LogStreamBuf:
PUSH RBX
MOV RBX,RDI
CALL 0x00108b40
MOV RDI,RBX
POP RBX
JMP 0x001086e0
|
/* nglog::base_logging::LogStreamBuf::~LogStreamBuf() */
void __thiscall nglog::base_logging::LogStreamBuf::~LogStreamBuf(LogStreamBuf *this)
{
std::streambuf::~streambuf((streambuf *)this);
free(this);
return;
}
|
|
60,679
|
free_all_read_locks
|
eloqsql/mysys/thr_lock.c
|
static inline void free_all_read_locks(THR_LOCK *lock,
my_bool using_concurrent_insert)
{
THR_LOCK_DATA *data=lock->read_wait.data;
check_locks(lock,"before freeing read locks", TL_UNLOCK, 1);
/* move all locks from read_wait list to read list */
(*lock->read.last)=data;
data->prev=lock->read.last;
lock->read.last=lock->read_wait.last;
/* Clear read_wait list */
lock->read_wait.last= &lock->read_wait.data;
do
{
mysql_cond_t *cond= data->cond;
if ((int) data->type == (int) TL_READ_NO_INSERT)
{
if (using_concurrent_insert)
{
/*
We can't free this lock;
Link lock away from read chain back into read_wait chain
*/
if (((*data->prev)=data->next))
data->next->prev=data->prev;
else
lock->read.last=data->prev;
*lock->read_wait.last= data;
data->prev= lock->read_wait.last;
lock->read_wait.last= &data->next;
continue;
}
lock->read_no_write_count++;
}
/* purecov: begin inspected */
DBUG_PRINT("lock",("giving read lock to thread: %lu",
(ulong)data->owner->thread_id));
/* purecov: end */
data->cond=0; /* Mark thread free */
mysql_cond_signal(cond);
} while ((data=data->next));
*lock->read_wait.last=0;
if (!lock->read_wait.data)
lock->write_lock_count=0;
check_locks(lock,"after giving read locks", TL_UNLOCK, 0);
}
|
O3
|
c
|
free_all_read_locks:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x60(%rdi), %rax
movq 0x60(%rdi), %r12
movq 0x78(%rdi), %rcx
leaq 0x78(%rdi), %r13
movq %r12, (%rcx)
movq 0x78(%rdi), %rcx
movq %rcx, 0x10(%r12)
movq 0x68(%rdi), %rcx
movq %rcx, 0x78(%rdi)
movq %rax, 0x68(%rdi)
movq 0x20(%r12), %r15
cmpl $0x5, 0x40(%r12)
jne 0xa3efb
testb %r14b, %r14b
je 0xa3ef5
leaq 0x8(%r12), %rax
movq 0x8(%r12), %rcx
movq 0x10(%r12), %rdx
movq %rcx, (%rdx)
leaq 0x10(%rcx), %rdx
testq %rcx, %rcx
movq 0x10(%r12), %rcx
cmoveq %r13, %rdx
movq %rcx, (%rdx)
movq 0x68(%rbx), %rcx
movq %r12, (%rcx)
movq 0x68(%rbx), %rcx
movq %rcx, 0x10(%r12)
movq %rax, 0x68(%rbx)
jmp 0xa3f15
incl 0xa8(%rbx)
movq $0x0, 0x20(%r12)
movq 0x30(%r15), %rdi
testq %rdi, %rdi
jne 0xa3f21
movq %r15, %rdi
callq 0x295c0
movq 0x8(%r12), %r12
testq %r12, %r12
jne 0xa3ea8
jmp 0xa3f33
leaq 0x2e20e8(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x170(%rax)
jmp 0xa3f0d
movq 0x68(%rbx), %rax
movq $0x0, (%rax)
cmpq $0x0, 0x60(%rbx)
jne 0xa3f50
movq $0x0, 0xa0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
free_all_read_locks:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14d, esi
mov rbx, rdi
lea rax, [rdi+60h]
mov r12, [rdi+60h]
mov rcx, [rdi+78h]
lea r13, [rdi+78h]
mov [rcx], r12
mov rcx, [rdi+78h]
mov [r12+10h], rcx
mov rcx, [rdi+68h]
mov [rdi+78h], rcx
mov [rdi+68h], rax
loc_A3EA8:
mov r15, [r12+20h]
cmp dword ptr [r12+40h], 5
jnz short loc_A3EFB
test r14b, r14b
jz short loc_A3EF5
lea rax, [r12+8]
mov rcx, [r12+8]
mov rdx, [r12+10h]
mov [rdx], rcx
lea rdx, [rcx+10h]
test rcx, rcx
mov rcx, [r12+10h]
cmovz rdx, r13
mov [rdx], rcx
mov rcx, [rbx+68h]
mov [rcx], r12
mov rcx, [rbx+68h]
mov [r12+10h], rcx
mov [rbx+68h], rax
jmp short loc_A3F15
loc_A3EF5:
inc dword ptr [rbx+0A8h]
loc_A3EFB:
mov qword ptr [r12+20h], 0
mov rdi, [r15+30h]
test rdi, rdi
jnz short loc_A3F21
loc_A3F0D:
mov rdi, r15
call _pthread_cond_signal
loc_A3F15:
mov r12, [r12+8]
test r12, r12
jnz short loc_A3EA8
jmp short loc_A3F33
loc_A3F21:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+170h]
jmp short loc_A3F0D
loc_A3F33:
mov rax, [rbx+68h]
mov qword ptr [rax], 0
cmp qword ptr [rbx+60h], 0
jnz short loc_A3F50
mov qword ptr [rbx+0A0h], 0
loc_A3F50:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
_QWORD * free_all_read_locks(long long a1, char a2)
{
long long v3; // r12
_QWORD *v4; // r13
long long v5; // r15
long long v6; // rcx
_QWORD *v7; // rdx
long long v8; // rdi
_QWORD *result; // rax
v3 = *(_QWORD *)(a1 + 96);
v4 = (_QWORD *)(a1 + 120);
**(_QWORD **)(a1 + 120) = v3;
*(_QWORD *)(v3 + 16) = *(_QWORD *)(a1 + 120);
*(_QWORD *)(a1 + 120) = *(_QWORD *)(a1 + 104);
*(_QWORD *)(a1 + 104) = a1 + 96;
do
{
v5 = *(_QWORD *)(v3 + 32);
if ( *(_DWORD *)(v3 + 64) == 5 )
{
if ( a2 )
{
v6 = *(_QWORD *)(v3 + 8);
**(_QWORD **)(v3 + 16) = v6;
v7 = (_QWORD *)(v6 + 16);
if ( !v6 )
v7 = v4;
*v7 = *(_QWORD *)(v3 + 16);
**(_QWORD **)(a1 + 104) = v3;
*(_QWORD *)(v3 + 16) = *(_QWORD *)(a1 + 104);
*(_QWORD *)(a1 + 104) = v3 + 8;
goto LABEL_11;
}
++*(_DWORD *)(a1 + 168);
}
*(_QWORD *)(v3 + 32) = 0LL;
v8 = *(_QWORD *)(v5 + 48);
if ( v8 )
((void ( *)(long long))PSI_server[46])(v8);
pthread_cond_signal(v5);
LABEL_11:
v3 = *(_QWORD *)(v3 + 8);
}
while ( v3 );
result = *(_QWORD **)(a1 + 104);
*result = 0LL;
if ( !*(_QWORD *)(a1 + 96) )
*(_QWORD *)(a1 + 160) = 0LL;
return result;
}
|
free_all_read_locks:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14D,ESI
MOV RBX,RDI
LEA RAX,[RDI + 0x60]
MOV R12,qword ptr [RDI + 0x60]
MOV RCX,qword ptr [RDI + 0x78]
LEA R13,[RDI + 0x78]
MOV qword ptr [RCX],R12
MOV RCX,qword ptr [RDI + 0x78]
MOV qword ptr [R12 + 0x10],RCX
MOV RCX,qword ptr [RDI + 0x68]
MOV qword ptr [RDI + 0x78],RCX
MOV qword ptr [RDI + 0x68],RAX
LAB_001a3ea8:
MOV R15,qword ptr [R12 + 0x20]
CMP dword ptr [R12 + 0x40],0x5
JNZ 0x001a3efb
TEST R14B,R14B
JZ 0x001a3ef5
LEA RAX,[R12 + 0x8]
MOV RCX,qword ptr [R12 + 0x8]
MOV RDX,qword ptr [R12 + 0x10]
MOV qword ptr [RDX],RCX
LEA RDX,[RCX + 0x10]
TEST RCX,RCX
MOV RCX,qword ptr [R12 + 0x10]
CMOVZ RDX,R13
MOV qword ptr [RDX],RCX
MOV RCX,qword ptr [RBX + 0x68]
MOV qword ptr [RCX],R12
MOV RCX,qword ptr [RBX + 0x68]
MOV qword ptr [R12 + 0x10],RCX
MOV qword ptr [RBX + 0x68],RAX
JMP 0x001a3f15
LAB_001a3ef5:
INC dword ptr [RBX + 0xa8]
LAB_001a3efb:
MOV qword ptr [R12 + 0x20],0x0
MOV RDI,qword ptr [R15 + 0x30]
TEST RDI,RDI
JNZ 0x001a3f21
LAB_001a3f0d:
MOV RDI,R15
CALL 0x001295c0
LAB_001a3f15:
MOV R12,qword ptr [R12 + 0x8]
TEST R12,R12
JNZ 0x001a3ea8
JMP 0x001a3f33
LAB_001a3f21:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x170]
JMP 0x001a3f0d
LAB_001a3f33:
MOV RAX,qword ptr [RBX + 0x68]
MOV qword ptr [RAX],0x0
CMP qword ptr [RBX + 0x60],0x0
JNZ 0x001a3f50
MOV qword ptr [RBX + 0xa0],0x0
LAB_001a3f50:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void free_all_read_locks(long param_1,char param_2)
{
pthread_cond_t *__cond;
long lVar1;
int8 *puVar2;
long lVar3;
lVar3 = *(long *)(param_1 + 0x60);
**(long **)(param_1 + 0x78) = lVar3;
*(int8 *)(lVar3 + 0x10) = *(int8 *)(param_1 + 0x78);
*(int8 *)(param_1 + 0x78) = *(int8 *)(param_1 + 0x68);
*(long *)(param_1 + 0x68) = param_1 + 0x60;
do {
__cond = *(pthread_cond_t **)(lVar3 + 0x20);
if (*(int *)(lVar3 + 0x40) == 5) {
if (param_2 == '\0') {
*(int *)(param_1 + 0xa8) = *(int *)(param_1 + 0xa8) + 1;
goto LAB_001a3efb;
}
lVar1 = *(long *)(lVar3 + 8);
**(long **)(lVar3 + 0x10) = lVar1;
puVar2 = (int8 *)(lVar1 + 0x10);
if (lVar1 == 0) {
puVar2 = (int8 *)(param_1 + 0x78);
}
*puVar2 = *(int8 *)(lVar3 + 0x10);
**(long **)(param_1 + 0x68) = lVar3;
*(int8 *)(lVar3 + 0x10) = *(int8 *)(param_1 + 0x68);
*(long *)(param_1 + 0x68) = lVar3 + 8;
}
else {
LAB_001a3efb:
*(int8 *)(lVar3 + 0x20) = 0;
if (__cond[1].__align != 0) {
(**(code **)(PSI_server + 0x170))();
}
pthread_cond_signal(__cond);
}
lVar3 = *(long *)(lVar3 + 8);
if (lVar3 == 0) {
**(int8 **)(param_1 + 0x68) = 0;
if (*(long *)(param_1 + 0x60) == 0) {
*(int8 *)(param_1 + 0xa0) = 0;
}
return;
}
} while( true );
}
|
|
60,680
|
PAIRING_Commit
|
corpus-core[P]colibri-stateless/build_O1/_deps/blst-src/src/aggregate.c
|
static void PAIRING_Commit(PAIRING *ctx)
{
unsigned int n;
if ((n = ctx->nelems) != 0) {
if (ctx->ctrl & AGGR_GT_SET) {
vec384fp12 GT;
miller_loop_n(GT, ctx->Q, ctx->P, n);
mul_fp12(ctx->GT, ctx->GT, GT);
} else {
miller_loop_n(ctx->GT, ctx->Q, ctx->P, n);
ctx->ctrl |= AGGR_GT_SET;
}
ctx->nelems = 0;
}
}
|
O1
|
c
|
PAIRING_Commit:
movl 0x4(%rdi), %ecx
testq %rcx, %rcx
je 0x21999
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x240, %rsp # imm = 0x240
movq %rdi, %rbx
leaq 0x378(%rdi), %rsi
leaq 0x978(%rdi), %rdx
testb $0x20, (%rdi)
jne 0x21969
leaq 0x18(%rbx), %rdi
callq 0x2043d
orb $0x20, (%rbx)
jmp 0x21987
leaq -0x250(%rbp), %r14
movq %r14, %rdi
callq 0x2043d
leaq 0x18(%rbx), %rdi
movq %rdi, %rsi
movq %r14, %rdx
callq 0x1f662
movl $0x0, 0x4(%rbx)
addq $0x240, %rsp # imm = 0x240
popq %rbx
popq %r14
popq %rbp
retq
|
PAIRING_Commit:
mov ecx, [rdi+4]
test rcx, rcx
jz short locret_21999
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 240h
mov rbx, rdi
lea rsi, [rdi+378h]
lea rdx, [rdi+978h]
test byte ptr [rdi], 20h
jnz short loc_21969
lea rdi, [rbx+18h]
call miller_loop_n
or byte ptr [rbx], 20h
jmp short loc_21987
loc_21969:
lea r14, [rbp-250h]
mov rdi, r14
call miller_loop_n
lea rdi, [rbx+18h]
mov rsi, rdi
mov rdx, r14
call mul_fp12
loc_21987:
mov dword ptr [rbx+4], 0
add rsp, 240h
pop rbx
pop r14
pop rbp
locret_21999:
retn
|
long long PAIRING_Commit(long long a1)
{
long long v1; // rcx
long long v2; // rsi
long long v3; // rdx
long long result; // rax
_BYTE v5[600]; // [rsp-258h] [rbp-258h] BYREF
v1 = *(unsigned int *)(a1 + 4);
if ( *(_DWORD *)(a1 + 4) )
{
v2 = a1 + 888;
v3 = a1 + 2424;
if ( (*(_BYTE *)a1 & 0x20) != 0 )
{
miller_loop_n((long long)v5, v2, v3, v1);
result = mul_fp12(a1 + 24, a1 + 24, (long long)v5);
}
else
{
result = miller_loop_n(a1 + 24, v2, v3, v1);
*(_BYTE *)a1 |= 0x20u;
}
*(_DWORD *)(a1 + 4) = 0;
}
return result;
}
|
PAIRING_Commit:
MOV ECX,dword ptr [RDI + 0x4]
TEST RCX,RCX
JZ 0x00121999
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x240
MOV RBX,RDI
LEA RSI,[RDI + 0x378]
LEA RDX,[RDI + 0x978]
TEST byte ptr [RDI],0x20
JNZ 0x00121969
LEA RDI,[RBX + 0x18]
CALL 0x0012043d
OR byte ptr [RBX],0x20
JMP 0x00121987
LAB_00121969:
LEA R14,[RBP + -0x250]
MOV RDI,R14
CALL 0x0012043d
LEA RDI,[RBX + 0x18]
MOV RSI,RDI
MOV RDX,R14
CALL 0x0011f662
LAB_00121987:
MOV dword ptr [RBX + 0x4],0x0
ADD RSP,0x240
POP RBX
POP R14
POP RBP
LAB_00121999:
RET
|
void PAIRING_Commit(byte *param_1)
{
int1 local_258 [576];
if (*(int *)(param_1 + 4) != 0) {
if ((*param_1 & 0x20) == 0) {
miller_loop_n(param_1 + 0x18,param_1 + 0x378,param_1 + 0x978);
*param_1 = *param_1 | 0x20;
}
else {
miller_loop_n(local_258,param_1 + 0x378,param_1 + 0x978);
mul_fp12(param_1 + 0x18,param_1 + 0x18,local_258);
}
param_1[4] = 0;
param_1[5] = 0;
param_1[6] = 0;
param_1[7] = 0;
}
return;
}
|
|
60,681
|
cpu_get_num_physical_cores()
|
monkey531[P]llama/common/common.cpp
|
std::string string_from(bool value) {
return value ? "true" : "false";
}
|
O2
|
cpp
|
cpu_get_num_physical_cores():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2a8, %rsp # imm = 0x2A8
leaq 0x58(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
xorl %esi, %esi
leaq 0x60(%rsp), %r14
leaq 0x80(%rsp), %r12
leaq 0x8(%rsp), %rbp
leaq 0xa0(%rsp), %rbx
pushq $0x8
popq %r15
xorl %r13d, %r13d
incl %r13d
je 0x53303
movq %r14, %rdi
callq 0x588aa
movq %r12, %rdi
leaq 0x5f82e(%rip), %rsi # 0xb2a80
movq %r14, %rdx
callq 0x58886
movq %rbp, %rdi
movq %r12, %rsi
leaq 0x5f835(%rip), %rdx # 0xb2a9c
callq 0x384dc
movq %rbx, %rdi
movq %rbp, %rsi
movl %r15d, %edx
callq 0x23e60
movq %rbp, %rdi
callq 0x241f8
movq %r12, %rdi
callq 0x241f8
movq %r14, %rdi
callq 0x241f8
leaq 0x118(%rsp), %rdi
callq 0x231f0
testb %al, %al
je 0x532f6
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x23160
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x532de
leaq 0x28(%rsp), %rdi
movq %rbp, %rsi
callq 0x88f48
movq %rbp, %rdi
callq 0x241f8
movq %rbx, %rdi
callq 0x23230
movl %r13d, %esi
jmp 0x53237
leaq 0xa0(%rsp), %rdi
callq 0x23230
movq 0x40(%rsp), %rbx
testq %rbx, %rbx
jne 0x53324
callq 0x23c10
cmpl $0x5, %eax
setae %cl
movl %eax, %edx
shrl %cl, %edx
testl %eax, %eax
pushq $0x4
popq %rbx
cmovnel %edx, %ebx
leaq 0x28(%rsp), %rdi
callq 0x5c76a
movl %ebx, %eax
addq $0x2a8, %rsp # imm = 0x2A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x53391
movq %rax, %rbx
jmp 0x5335e
movq %rax, %rbx
jmp 0x5336b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x241f8
leaq 0x80(%rsp), %rdi
callq 0x241f8
leaq 0x60(%rsp), %rdi
callq 0x241f8
jmp 0x53391
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x241f8
leaq 0xa0(%rsp), %rdi
callq 0x23230
leaq 0x28(%rsp), %rdi
callq 0x5c76a
movq %rbx, %rdi
callq 0x23fc0
|
_Z26cpu_get_num_physical_coresv:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 2A8h
lea rax, [rsp+2D8h+var_280]
mov [rax-30h], rax
mov qword ptr [rax-28h], 1
xorps xmm0, xmm0
movups xmmword ptr [rax-20h], xmm0
mov dword ptr [rax-10h], 3F800000h
movups xmmword ptr [rax-8], xmm0
xor esi, esi; unsigned int
lea r14, [rsp+2D8h+var_278]
lea r12, [rsp+2D8h+var_258]
lea rbp, [rsp+2D8h+var_2D0]
lea rbx, [rsp+2D8h+var_238]
push 8
pop r15
xor r13d, r13d
loc_53237:
inc r13d
jz loc_53303
mov rdi, r14; this
call _ZNSt7__cxx119to_stringEj; std::to_string(uint)
mov rdi, r12
lea rsi, aSysDevicesSyst; "/sys/devices/system/cpu/cpu"
mov rdx, r14
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov rdi, rbp
mov rsi, r12
lea rdx, aTopologyThread; "/topology/thread_siblings"
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
mov rdi, rbx
mov rsi, rbp
mov edx, r15d
call __ZNSt14basic_ifstreamIcSt11char_traitsIcEEC1ERKNSt7__cxx1112basic_stringIcS1_SaIcEEESt13_Ios_Openmode; std::ifstream::basic_ifstream(std::string const&,std::_Ios_Openmode)
mov rdi, rbp; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r12; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r14; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+2D8h+var_1C0]
call __ZNKSt12__basic_fileIcE7is_openEv; std::__basic_file<char>::is_open(void)
test al, al
jz short loc_532F6
lea rax, [rsp+2D8h+var_2C0]
mov [rsp+2D8h+var_2D0], rax
and [rsp+2D8h+var_2C8], 0
mov [rsp+2D8h+var_2C0], 0
mov rdi, rbx
mov rsi, rbp
call __ZSt7getlineIcSt11char_traitsIcESaIcEERSt13basic_istreamIT_T0_ES7_RNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::getline<char,std::char_traits<char>,std::allocator<char>>(std::istream &,std::string &)
mov rcx, [rax]
mov rcx, [rcx-18h]
test byte ptr [rax+rcx+20h], 5
jnz short loc_532DE
lea rdi, [rsp+2D8h+var_2B0]
mov rsi, rbp
call _ZNSt8__detail12_Insert_baseINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_SaIS6_ENS_9_IdentityESt8equal_toIS6_ESt4hashIS6_ENS_18_Mod_range_hashingENS_20_Default_ranged_hashENS_20_Prime_rehash_policyENS_17_Hashtable_traitsILb1ELb1ELb1EEEE6insertERKS6_; std::__detail::_Insert_base<std::string,std::string,std::allocator<std::string>,std::__detail::_Identity,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>::insert(std::string const&)
loc_532DE:
mov rdi, rbp; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbx
call __ZNSt14basic_ifstreamIcSt11char_traitsIcEED1Ev; std::ifstream::~ifstream()
mov esi, r13d
jmp loc_53237
loc_532F6:
lea rdi, [rsp+2D8h+var_238]; this
call __ZNSt14basic_ifstreamIcSt11char_traitsIcEED1Ev; std::ifstream::~ifstream()
loc_53303:
mov rbx, [rsp+2D8h+var_298]
test rbx, rbx
jnz short loc_53324
call __ZNSt6thread20hardware_concurrencyEv; std::thread::hardware_concurrency(void)
cmp eax, 5
setnb cl
mov edx, eax
shr edx, cl
test eax, eax
push 4
pop rbx
cmovnz ebx, edx
loc_53324:
lea rdi, [rsp+2D8h+var_2B0]
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_SaIS5_ENSt8__detail9_IdentityESt8equal_toIS5_ESt4hashIS5_ENS7_18_Mod_range_hashingENS7_20_Default_ranged_hashENS7_20_Prime_rehash_policyENS7_17_Hashtable_traitsILb1ELb1ELb1EEEED2Ev; std::_Hashtable<std::string,std::string,std::allocator<std::string>,std::__detail::_Identity,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>::~_Hashtable()
mov eax, ebx
add rsp, 2A8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
jmp short loc_53391
mov rbx, rax
jmp short loc_5335E
mov rbx, rax
jmp short loc_5336B
mov rbx, rax
lea rdi, [rsp+arg_0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_5335E:
lea rdi, [rsp+arg_78]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_5336B:
lea rdi, [rsp+arg_58]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_53391
mov rbx, rax
lea rdi, [rsp+arg_0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+arg_98]
call __ZNSt14basic_ifstreamIcSt11char_traitsIcEED1Ev; std::ifstream::~ifstream()
loc_53391:
lea rdi, [rsp+arg_20]
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_SaIS5_ENSt8__detail9_IdentityESt8equal_toIS5_ESt4hashIS5_ENS7_18_Mod_range_hashingENS7_20_Default_ranged_hashENS7_20_Prime_rehash_policyENS7_17_Hashtable_traitsILb1ELb1ELb1EEEED2Ev; std::_Hashtable<std::string,std::string,std::allocator<std::string>,std::__detail::_Identity,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>::~_Hashtable()
mov rdi, rbx
call __Unwind_Resume
|
long long cpu_get_num_physical_cores(std::thread *a1)
{
unsigned long long v1; // rsi
unsigned int i; // r13d
_QWORD *v3; // rax
unsigned int v4; // ebx
unsigned int v5; // eax
_QWORD v7[2]; // [rsp+8h] [rbp-2D0h] BYREF
char v8; // [rsp+18h] [rbp-2C0h] BYREF
_QWORD v9[2]; // [rsp+28h] [rbp-2B0h] BYREF
__int128 v10; // [rsp+38h] [rbp-2A0h]
int v11; // [rsp+48h] [rbp-290h]
__int128 v12; // [rsp+50h] [rbp-288h] BYREF
_BYTE v13[32]; // [rsp+60h] [rbp-278h] BYREF
_BYTE v14[32]; // [rsp+80h] [rbp-258h] BYREF
_BYTE v15[120]; // [rsp+A0h] [rbp-238h] BYREF
_BYTE v16[448]; // [rsp+118h] [rbp-1C0h] BYREF
v9[0] = (char *)&v12 + 8;
v9[1] = 1LL;
v10 = 0LL;
v11 = 1065353216;
v12 = 0LL;
v1 = 0LL;
for ( i = 0; ++i; v1 = i )
{
std::to_string((std::__cxx11 *)v13, v1);
std::operator+<char>(v14, "/sys/devices/system/cpu/cpu", v13);
std::operator+<char>((long long)v7, (long long)v14, (long long)"/topology/thread_siblings");
v1 = (unsigned long long)v7;
std::ifstream::basic_ifstream(v15, v7, 8LL);
std::string::~string(v7);
std::string::~string(v14);
std::string::~string(v13);
if ( !(unsigned __int8)std::__basic_file<char>::is_open(v16) )
{
a1 = (std::thread *)v15;
std::ifstream::~ifstream(v15);
break;
}
v7[0] = &v8;
v7[1] = 0LL;
v8 = 0;
v3 = (_QWORD *)std::getline<char,std::char_traits<char>,std::allocator<char>>(v15, v7);
if ( (*((_BYTE *)v3 + *(_QWORD *)(*v3 - 24LL) + 32) & 5) == 0 )
std::__detail::_Insert_base<std::string,std::string,std::allocator<std::string>,std::__detail::_Identity,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>::insert(
v9,
v7);
std::string::~string(v7);
a1 = (std::thread *)v15;
std::ifstream::~ifstream(v15);
}
v4 = DWORD2(v10);
if ( !*((_QWORD *)&v10 + 1) )
{
v5 = std::thread::hardware_concurrency(a1);
v4 = 4;
if ( v5 )
v4 = v5 >> (v5 >= 5);
}
std::_Hashtable<std::string,std::string,std::allocator<std::string>,std::__detail::_Identity,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>::~_Hashtable(
v9,
v1);
return v4;
}
|
cpu_get_num_physical_cores:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x2a8
LEA RAX,[RSP + 0x58]
MOV qword ptr [RAX + -0x30],RAX
MOV qword ptr [RAX + -0x28],0x1
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX + -0x20],XMM0
MOV dword ptr [RAX + -0x10],0x3f800000
MOVUPS xmmword ptr [RAX + -0x8],XMM0
XOR ESI,ESI
LEA R14,[RSP + 0x60]
LEA R12,[RSP + 0x80]
LEA RBP,[RSP + 0x8]
LEA RBX,[RSP + 0xa0]
PUSH 0x8
POP R15
XOR R13D,R13D
LAB_00153237:
INC R13D
JZ 0x00153303
LAB_00153240:
MOV RDI,R14
CALL 0x001588aa
LAB_00153248:
MOV RDI,R12
LEA RSI,[0x1b2a80]
MOV RDX,R14
CALL 0x00158886
LAB_0015325a:
MOV RDI,RBP
MOV RSI,R12
LEA RDX,[0x1b2a9c]
CALL 0x001384dc
LAB_0015326c:
MOV RDI,RBX
MOV RSI,RBP
MOV EDX,R15D
CALL 0x00123e60
MOV RDI,RBP
CALL 0x001241f8
MOV RDI,R12
CALL 0x001241f8
MOV RDI,R14
CALL 0x001241f8
LEA RDI,[RSP + 0x118]
CALL 0x001231f0
TEST AL,AL
JZ 0x001532f6
LEA RAX,[RSP + 0x18]
MOV qword ptr [RSP + 0x8],RAX
AND qword ptr [RSP + 0x10],0x0
MOV byte ptr [RSP + 0x18],0x0
LAB_001532b8:
MOV RDI,RBX
MOV RSI,RBP
CALL 0x00123160
MOV RCX,qword ptr [RAX]
MOV RCX,qword ptr [RCX + -0x18]
TEST byte ptr [RAX + RCX*0x1 + 0x20],0x5
JNZ 0x001532de
LEA RDI,[RSP + 0x28]
MOV RSI,RBP
CALL 0x00188f48
LAB_001532de:
MOV RDI,RBP
CALL 0x001241f8
MOV RDI,RBX
CALL 0x00123230
MOV ESI,R13D
JMP 0x00153237
LAB_001532f6:
LEA RDI,[RSP + 0xa0]
CALL 0x00123230
LAB_00153303:
MOV RBX,qword ptr [RSP + 0x40]
TEST RBX,RBX
JNZ 0x00153324
CALL 0x00123c10
CMP EAX,0x5
SETNC CL
MOV EDX,EAX
SHR EDX,CL
TEST EAX,EAX
PUSH 0x4
POP RBX
CMOVNZ EBX,EDX
LAB_00153324:
LEA RDI,[RSP + 0x28]
CALL 0x0015c76a
MOV EAX,EBX
ADD RSP,0x2a8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* cpu_get_num_physical_cores() */
ulong cpu_get_num_physical_cores(void)
{
char cVar1;
uint uVar2;
istream *piVar3;
ulong uVar4;
int1 *local_2d0;
int8 local_2c8;
int1 local_2c0 [16];
int8 *local_2b0;
int8 local_2a8;
int8 local_2a0;
ulong uStack_298;
int4 local_290;
int8 local_288;
int8 uStack_280;
__cxx11 local_278 [32];
string local_258 [32];
istream local_238 [520];
local_2b0 = &uStack_280;
local_2a8 = 1;
local_2a0 = 0;
uStack_298 = 0;
local_290 = 0x3f800000;
local_288 = 0;
uStack_280 = 0;
uVar2 = 0;
do {
if (uVar2 + 1 == 0) {
LAB_00153303:
uVar4 = uStack_298;
if (uStack_298 == 0) {
uVar2 = std::thread::hardware_concurrency();
uVar4 = 4;
if (uVar2 != 0) {
uVar4 = (ulong)(uVar2 >> (4 < uVar2));
}
}
std::
_Hashtable<std::__cxx11::string,std::__cxx11::string,std::allocator<std::__cxx11::string>,std::__detail::_Identity,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>
::~_Hashtable((_Hashtable<std::__cxx11::string,std::__cxx11::string,std::allocator<std::__cxx11::string>,std::__detail::_Identity,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>
*)&local_2b0);
return uVar4 & 0xffffffff;
}
/* try { // try from 00153240 to 00153247 has its CatchHandler @ 00153342 */
std::__cxx11::to_string(local_278,uVar2);
/* try { // try from 00153248 to 00153259 has its CatchHandler @ 0015334c */
std::operator+((char *)local_258,(string *)"/sys/devices/system/cpu/cpu");
/* try { // try from 0015325a to 0015326b has its CatchHandler @ 00153347 */
std::operator+((string *)&local_2d0,(char *)local_258);
/* try { // try from 0015326c to 00153279 has its CatchHandler @ 00153351 */
std::ifstream::ifstream((ifstream *)local_238,(string *)&local_2d0,8);
std::__cxx11::string::~string((string *)&local_2d0);
std::__cxx11::string::~string(local_258);
std::__cxx11::string::~string((string *)local_278);
cVar1 = std::__basic_file<char>::is_open();
if (cVar1 == '\0') {
std::ifstream::~ifstream((ifstream *)local_238);
goto LAB_00153303;
}
local_2d0 = local_2c0;
local_2c8 = 0;
local_2c0[0] = 0;
/* try { // try from 001532b8 to 001532dd has its CatchHandler @ 00153377 */
piVar3 = std::getline<char,std::char_traits<char>,std::allocator<char>>
(local_238,(string *)&local_2d0);
if (((byte)piVar3[*(long *)(*(long *)piVar3 + -0x18) + 0x20] & 5) == 0) {
std::__detail::
_Insert_base<std::__cxx11::string,std::__cxx11::string,std::allocator<std::__cxx11::string>,std::__detail::_Identity,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>
::insert((string *)&local_2b0);
}
std::__cxx11::string::~string((string *)&local_2d0);
std::ifstream::~ifstream((ifstream *)local_238);
uVar2 = uVar2 + 1;
} while( true );
}
|
|
60,682
|
cpu_get_num_physical_cores()
|
monkey531[P]llama/common/common.cpp
|
std::string string_from(bool value) {
return value ? "true" : "false";
}
|
O3
|
cpp
|
cpu_get_num_physical_cores():
pushq %rbx
movq %rdi, %rbx
leaq 0x74757(%rip), %rcx # 0xe6bda
leaq 0x77439(%rip), %rax # 0xe98c3
testl %esi, %esi
cmovneq %rcx, %rax
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
movl %esi, %edx
xorq $0x5, %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x21cae
movq %rbx, %rax
popq %rbx
retq
|
_Z11string_fromB5cxx11b:
push rbx
mov rbx, rdi
lea rcx, aTrue; "true"
lea rax, aAdvancedOption+0ABh; "false"
test esi, esi
cmovnz rax, rcx
lea rcx, [rdi+10h]
mov [rdi], rcx
mov edx, esi
xor rdx, 5
add rdx, rax
mov rsi, rax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rax, rbx
pop rbx
retn
|
_QWORD * string_from[abi:cxx11](_QWORD *a1, unsigned int a2)
{
char *v2; // rax
v2 = "false";
if ( a2 )
v2 = "true";
*a1 = a1 + 2;
std::string::_M_construct<char const*>((long long)a1, v2, (long long)&v2[a2 ^ 5LL]);
return a1;
}
|
string_from[abi:cxx11]:
PUSH RBX
MOV RBX,RDI
LEA RCX,[0x1e6bda]
LEA RAX,[0x1e98c3]
TEST ESI,ESI
CMOVNZ RAX,RCX
LEA RCX,[RDI + 0x10]
MOV qword ptr [RDI],RCX
MOV EDX,ESI
XOR RDX,0x5
ADD RDX,RAX
MOV RSI,RAX
CALL 0x00121cae
MOV RAX,RBX
POP RBX
RET
|
/* string_from[abi:cxx11](bool) */
int8 string_from_abi_cxx11_(bool param_1)
{
char *pcVar1;
uint in_ESI;
int7 in_register_00000039;
pcVar1 = "false";
if (in_ESI != 0) {
pcVar1 = "true";
}
*(long *)CONCAT71(in_register_00000039,param_1) = CONCAT71(in_register_00000039,param_1) + 0x10;
std::__cxx11::string::_M_construct<char_const*>(param_1,pcVar1,pcVar1 + ((ulong)in_ESI ^ 5));
return CONCAT71(in_register_00000039,param_1);
}
|
|
60,683
|
bf_exp
|
bluesky950520[P]quickjs/libbf.c
|
int bf_exp(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
{
bf_context_t *s = r->ctx;
int ret;
assert(r != a);
if (a->len == 0) {
if (a->expn == BF_EXP_NAN) {
bf_set_nan(r);
} else if (a->expn == BF_EXP_INF) {
if (a->sign)
bf_set_zero(r, 0);
else
bf_set_inf(r, 0);
} else {
bf_set_ui(r, 1);
}
return 0;
}
ret = check_exp_underflow_overflow(s, r, a, a, prec, flags);
if (ret)
return ret;
if (a->expn < 0 && (-a->expn) >= (prec + 2)) {
/* small argument case: result = 1 + epsilon * sign(x) */
bf_set_ui(r, 1);
return bf_add_epsilon(r, r, -(prec + 2), a->sign, prec, flags);
}
return bf_ziv_rounding(r, a, prec, flags, bf_exp_internal, NULL);
}
|
O1
|
c
|
bf_exp:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x18(%rsi)
je 0x8a89d
movl %ecx, %ebp
movq %rdx, %r15
movq (%rbx), %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r14, %rcx
movq %r15, %r8
movl %ebp, %r9d
callq 0x8a994
testl %eax, %eax
jne 0x8a953
movq 0x10(%r14), %rax
testq %rax, %rax
jns 0x8a879
negq %rax
leaq 0x2(%r15), %rcx
cmpq %rax, %rcx
jbe 0x8a95e
leaq 0x54b(%rip), %r8 # 0x8adcb
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %ebp, %ecx
xorl %r9d, %r9d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8acec
movq 0x10(%r14), %rax
movabsq $0x7ffffffffffffffe, %r15 # imm = 0x7FFFFFFFFFFFFFFE
cmpq %r15, %rax
je 0x8a8e6
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rcx, %rax
jne 0x8a917
cmpq $0x0, 0x18(%rbx)
je 0x8a8e1
movq (%rbx), %rax
movq 0x20(%rbx), %rsi
movq (%rax), %rdi
xorl %edx, %edx
callq *0x8(%rax)
movq %rax, 0x20(%rbx)
movq $0x0, 0x18(%rbx)
incq %r15
jmp 0x8a946
cmpl $0x0, 0x8(%r14)
movq 0x18(%rbx), %rax
je 0x8a926
testq %rax, %rax
je 0x8a911
movq (%rbx), %rax
movq 0x20(%rbx), %rsi
movq (%rax), %rdi
xorl %edx, %edx
callq *0x8(%rax)
movq %rax, 0x20(%rbx)
movq $0x0, 0x18(%rbx)
addq $0x2, %r15
jmp 0x8a946
movl $0x1, %esi
movq %rbx, %rdi
callq 0x84abb
jmp 0x8a951
testq %rax, %rax
je 0x8a946
movq (%rbx), %rax
movq 0x20(%rbx), %rsi
movq (%rax), %rdi
xorl %edx, %edx
callq *0x8(%rax)
movq %rax, 0x20(%rbx)
movq $0x0, 0x18(%rbx)
movq %r15, 0x10(%rbx)
movl $0x0, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %esi
movq %rbx, %rdi
callq 0x84abb
movq $-0x2, %rdx
subq %r15, %rdx
movl 0x8(%r14), %ecx
movq %rbx, %rdi
movq %rbx, %rsi
movq %r15, %r8
movl %ebp, %r9d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8ac4a
|
bf_exp:
push rbp
push r15
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
cmp qword ptr [rsi+18h], 0
jz short loc_8A89D
mov ebp, ecx
mov r15, rdx
mov rdi, [rbx]
mov rsi, rbx
mov rdx, r14
mov rcx, r14
mov r8, r15
mov r9d, ebp
call check_exp_underflow_overflow
test eax, eax
jnz loc_8A953
mov rax, [r14+10h]
test rax, rax
jns short loc_8A879
neg rax
lea rcx, [r15+2]
cmp rcx, rax
jbe loc_8A95E
loc_8A879:
lea r8, bf_exp_internal
mov rdi, rbx
mov rsi, r14
mov rdx, r15
mov ecx, ebp
xor r9d, r9d
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
jmp bf_ziv_rounding
loc_8A89D:
mov rax, [r14+10h]
mov r15, 7FFFFFFFFFFFFFFEh
cmp rax, r15
jz short loc_8A8E6
mov rcx, 7FFFFFFFFFFFFFFFh
cmp rax, rcx
jnz short loc_8A917
cmp qword ptr [rbx+18h], 0
jz short loc_8A8E1
mov rax, [rbx]
mov rsi, [rbx+20h]
mov rdi, [rax]
xor edx, edx
call qword ptr [rax+8]
mov [rbx+20h], rax
mov qword ptr [rbx+18h], 0
loc_8A8E1:
inc r15
jmp short loc_8A946
loc_8A8E6:
cmp dword ptr [r14+8], 0
mov rax, [rbx+18h]
jz short loc_8A926
test rax, rax
jz short loc_8A911
mov rax, [rbx]
mov rsi, [rbx+20h]
mov rdi, [rax]
xor edx, edx
call qword ptr [rax+8]
mov [rbx+20h], rax
mov qword ptr [rbx+18h], 0
loc_8A911:
add r15, 2
jmp short loc_8A946
loc_8A917:
mov esi, 1
mov rdi, rbx
call bf_set_ui
jmp short loc_8A951
loc_8A926:
test rax, rax
jz short loc_8A946
mov rax, [rbx]
mov rsi, [rbx+20h]
mov rdi, [rax]
xor edx, edx
call qword ptr [rax+8]
mov [rbx+20h], rax
mov qword ptr [rbx+18h], 0
loc_8A946:
mov [rbx+10h], r15
mov dword ptr [rbx+8], 0
loc_8A951:
xor eax, eax
loc_8A953:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_8A95E:
mov esi, 1
mov rdi, rbx
call bf_set_ui
mov rdx, 0FFFFFFFFFFFFFFFEh
sub rdx, r15
mov ecx, [r14+8]
mov rdi, rbx
mov rsi, rbx
mov r8, r15
mov r9d, ebp
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
jmp bf_add_epsilon
|
long long bf_exp(_QWORD **a1, long long a2, long long a3, unsigned int a4)
{
long long v4; // rax
long long result; // rax
long long v8; // rax
long long v9; // rax
unsigned long long v10; // r15
_QWORD *v11; // rax
if ( !*(_QWORD *)(a2 + 24) )
{
v9 = *(_QWORD *)(a2 + 16);
v10 = 0x7FFFFFFFFFFFFFFELL;
if ( v9 == 0x7FFFFFFFFFFFFFFELL )
{
v11 = a1[3];
if ( *(_DWORD *)(a2 + 8) )
{
if ( v11 )
{
a1[4] = (_QWORD *)((long long ( *)(_QWORD, _QWORD *, _QWORD))(*a1)[1])(**a1, a1[4], 0LL);
a1[3] = 0LL;
}
v10 = 0x8000000000000000LL;
}
else if ( v11 )
{
a1[4] = (_QWORD *)((long long ( *)(_QWORD, _QWORD *, _QWORD))(*a1)[1])(**a1, a1[4], 0LL);
a1[3] = 0LL;
}
}
else
{
if ( v9 != 0x7FFFFFFFFFFFFFFFLL )
{
bf_set_ui(a1, 1uLL);
return 0LL;
}
if ( a1[3] )
{
a1[4] = (_QWORD *)((long long ( *)(_QWORD, _QWORD *, _QWORD))(*a1)[1])(**a1, a1[4], 0LL);
a1[3] = 0LL;
}
v10 = 0x7FFFFFFFFFFFFFFFLL;
}
a1[2] = (_QWORD *)v10;
*((_DWORD *)a1 + 2) = 0;
return 0LL;
}
result = check_exp_underflow_overflow(*a1, a1, a2, a2, a3, a4, v4);
if ( !(_DWORD)result )
{
v8 = *(_QWORD *)(a2 + 16);
if ( v8 < 0 && a3 + 2 <= (unsigned long long)-v8 )
{
bf_set_ui(a1, 1uLL);
return bf_add_epsilon(a1, a1, -2 - a3, *(unsigned int *)(a2 + 8), a3, a4);
}
else
{
return bf_ziv_rounding(a1, a2, a3, a4, bf_exp_internal, 0LL);
}
}
return result;
}
|
bf_exp:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
CMP qword ptr [RSI + 0x18],0x0
JZ 0x0018a89d
MOV EBP,ECX
MOV R15,RDX
MOV RDI,qword ptr [RBX]
MOV RSI,RBX
MOV RDX,R14
MOV RCX,R14
MOV R8,R15
MOV R9D,EBP
CALL 0x0018a994
TEST EAX,EAX
JNZ 0x0018a953
MOV RAX,qword ptr [R14 + 0x10]
TEST RAX,RAX
JNS 0x0018a879
NEG RAX
LEA RCX,[R15 + 0x2]
CMP RCX,RAX
JBE 0x0018a95e
LAB_0018a879:
LEA R8,[0x18adcb]
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R15
MOV ECX,EBP
XOR R9D,R9D
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
JMP 0x0018acec
LAB_0018a89d:
MOV RAX,qword ptr [R14 + 0x10]
MOV R15,0x7ffffffffffffffe
CMP RAX,R15
JZ 0x0018a8e6
MOV RCX,0x7fffffffffffffff
CMP RAX,RCX
JNZ 0x0018a917
CMP qword ptr [RBX + 0x18],0x0
JZ 0x0018a8e1
MOV RAX,qword ptr [RBX]
MOV RSI,qword ptr [RBX + 0x20]
MOV RDI,qword ptr [RAX]
XOR EDX,EDX
CALL qword ptr [RAX + 0x8]
MOV qword ptr [RBX + 0x20],RAX
MOV qword ptr [RBX + 0x18],0x0
LAB_0018a8e1:
INC R15
JMP 0x0018a946
LAB_0018a8e6:
CMP dword ptr [R14 + 0x8],0x0
MOV RAX,qword ptr [RBX + 0x18]
JZ 0x0018a926
TEST RAX,RAX
JZ 0x0018a911
MOV RAX,qword ptr [RBX]
MOV RSI,qword ptr [RBX + 0x20]
MOV RDI,qword ptr [RAX]
XOR EDX,EDX
CALL qword ptr [RAX + 0x8]
MOV qword ptr [RBX + 0x20],RAX
MOV qword ptr [RBX + 0x18],0x0
LAB_0018a911:
ADD R15,0x2
JMP 0x0018a946
LAB_0018a917:
MOV ESI,0x1
MOV RDI,RBX
CALL 0x00184abb
JMP 0x0018a951
LAB_0018a926:
TEST RAX,RAX
JZ 0x0018a946
MOV RAX,qword ptr [RBX]
MOV RSI,qword ptr [RBX + 0x20]
MOV RDI,qword ptr [RAX]
XOR EDX,EDX
CALL qword ptr [RAX + 0x8]
MOV qword ptr [RBX + 0x20],RAX
MOV qword ptr [RBX + 0x18],0x0
LAB_0018a946:
MOV qword ptr [RBX + 0x10],R15
MOV dword ptr [RBX + 0x8],0x0
LAB_0018a951:
XOR EAX,EAX
LAB_0018a953:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0018a95e:
MOV ESI,0x1
MOV RDI,RBX
CALL 0x00184abb
MOV RDX,-0x2
SUB RDX,R15
MOV ECX,dword ptr [R14 + 0x8]
MOV RDI,RBX
MOV RSI,RBX
MOV R8,R15
MOV R9D,EBP
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
JMP 0x0018ac4a
|
int8 bf_exp(long *param_1,long param_2,long param_3,int4 param_4)
{
int8 uVar1;
long lVar2;
long lVar3;
if (*(long *)(param_2 + 0x18) == 0) {
lVar3 = 0x7ffffffffffffffe;
if (*(long *)(param_2 + 0x10) == 0x7ffffffffffffffe) {
if (*(int *)(param_2 + 8) == 0) {
if (param_1[3] != 0) {
lVar2 = (*(code *)((int8 *)*param_1)[1])(*(int8 *)*param_1,param_1[4],0);
param_1[4] = lVar2;
param_1[3] = 0;
}
}
else {
if (param_1[3] != 0) {
lVar3 = (*(code *)((int8 *)*param_1)[1])(*(int8 *)*param_1,param_1[4],0);
param_1[4] = lVar3;
param_1[3] = 0;
}
lVar3 = -0x8000000000000000;
}
}
else {
if (*(long *)(param_2 + 0x10) != 0x7fffffffffffffff) {
bf_set_ui(param_1,1);
return 0;
}
if (param_1[3] != 0) {
lVar3 = (*(code *)((int8 *)*param_1)[1])(*(int8 *)*param_1,param_1[4],0);
param_1[4] = lVar3;
param_1[3] = 0;
}
lVar3 = 0x7fffffffffffffff;
}
param_1[2] = lVar3;
*(int4 *)(param_1 + 1) = 0;
return 0;
}
uVar1 = check_exp_underflow_overflow(*param_1,param_1,param_2,param_2,param_3,param_4);
if ((int)uVar1 != 0) {
return uVar1;
}
if ((*(long *)(param_2 + 0x10) < 0) && (param_3 + 2U <= (ulong)-*(long *)(param_2 + 0x10))) {
bf_set_ui(param_1,1);
uVar1 = bf_add_epsilon(param_1,param_1,-2 - param_3,*(int4 *)(param_2 + 8),param_3,param_4
);
return uVar1;
}
uVar1 = bf_ziv_rounding(param_1,param_2,param_3,param_4,bf_exp_internal,0);
return uVar1;
}
|
|
60,684
|
tailoring_append
|
eloqsql/strings/ctype.c
|
static int
tailoring_append(MY_XML_PARSER *st,
const char *fmt, size_t len, const char *attr)
{
struct my_cs_file_info *i= (struct my_cs_file_info *) st->user_data;
size_t newlen= i->tailoring_length + len + 64; /* 64 for format */
if (MY_XML_OK == my_charset_file_tailoring_realloc(i, newlen))
{
char *dst= i->tailoring + i->tailoring_length;
sprintf(dst, fmt, (int) len, attr);
i->tailoring_length+= strlen(dst);
return MY_XML_OK;
}
return MY_XML_ERROR;
}
|
O3
|
c
|
tailoring_append:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r9
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x690(%rdi), %r13
leaq (%rdx,%r13), %rax
addq $0x40, %rax
cmpq %rax, 0x698(%rdi)
jbe 0x58d7f
movq 0x688(%rbx), %rax
jmp 0x58dc3
movq %r9, %r14
addq %r15, %r13
movq 0x688(%rbx), %rdi
movq 0x7a8(%rbx), %rax
movq 0x90(%rax), %rax
addq $0x8040, %r13 # imm = 0x8040
movq %r13, 0x698(%rbx)
movq %r13, %rsi
callq *%rax
movq %rax, 0x688(%rbx)
testq %rax, %rax
je 0x58e06
movq 0x690(%rbx), %r13
movq %r14, %r9
addq %rax, %r13
xorl %r14d, %r14d
movq %r13, %rdi
movl $0x1, %esi
movq $-0x1, %rdx
movq %r12, %rcx
movl %r15d, %r8d
xorl %eax, %eax
callq 0x241c0
movq %r13, %rdi
callq 0x24120
addq %rax, 0x690(%rbx)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %r14d
jmp 0x58df4
|
tailoring_append:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r9, rcx
mov r15, rdx
mov r12, rsi
mov rbx, rdi
mov r13, [rdi+690h]
lea rax, [rdx+r13]
add rax, 40h ; '@'
cmp [rdi+698h], rax
jbe short loc_58D7F
mov rax, [rbx+688h]
jmp short loc_58DC3
loc_58D7F:
mov r14, r9
add r13, r15
mov rdi, [rbx+688h]
mov rax, [rbx+7A8h]
mov rax, [rax+90h]
add r13, 8040h
mov [rbx+698h], r13
mov rsi, r13
call rax
mov [rbx+688h], rax
test rax, rax
jz short loc_58E06
mov r13, [rbx+690h]
mov r9, r14
loc_58DC3:
add r13, rax
xor r14d, r14d
mov rdi, r13
mov esi, 1
mov rdx, 0FFFFFFFFFFFFFFFFh
mov rcx, r12
mov r8d, r15d
xor eax, eax
call ___sprintf_chk
mov rdi, r13
call _strlen
add [rbx+690h], rax
loc_58DF4:
mov eax, r14d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_58E06:
mov r14d, 1
jmp short loc_58DF4
|
long long tailoring_append(_QWORD *a1, const char *a2, long long a3, long long a4)
{
long long v4; // rax
long long v5; // r9
unsigned int v6; // r15d
long long v8; // r13
long long v9; // rax
long long v11; // rdi
long long ( *v12)(long long, long long); // rax
long long v13; // r13
long long v14; // r13
unsigned int v15; // r14d
long long v17; // [rsp-8h] [rbp-30h]
v17 = v4;
v5 = a4;
v6 = a3;
v8 = a1[210];
if ( a1[211] <= (unsigned long long)(a3 + v8 + 64) )
{
v11 = a1[209];
v12 = *(long long ( **)(long long, long long))(a1[245] + 144LL);
v13 = a3 + v8 + 32832;
a1[211] = v13;
v9 = v12(v11, v13);
a1[209] = v9;
if ( !v9 )
return 1;
v8 = a1[210];
v5 = a4;
}
else
{
v9 = a1[209];
}
v14 = v9 + v8;
v15 = 0;
__sprintf_chk(v14, 1LL, -1LL, a2, v6, v5, v17);
a1[210] += strlen(v14);
return v15;
}
|
tailoring_append:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R9,RCX
MOV R15,RDX
MOV R12,RSI
MOV RBX,RDI
MOV R13,qword ptr [RDI + 0x690]
LEA RAX,[RDX + R13*0x1]
ADD RAX,0x40
CMP qword ptr [RDI + 0x698],RAX
JBE 0x00158d7f
MOV RAX,qword ptr [RBX + 0x688]
JMP 0x00158dc3
LAB_00158d7f:
MOV R14,R9
ADD R13,R15
MOV RDI,qword ptr [RBX + 0x688]
MOV RAX,qword ptr [RBX + 0x7a8]
MOV RAX,qword ptr [RAX + 0x90]
ADD R13,0x8040
MOV qword ptr [RBX + 0x698],R13
MOV RSI,R13
CALL RAX
MOV qword ptr [RBX + 0x688],RAX
TEST RAX,RAX
JZ 0x00158e06
MOV R13,qword ptr [RBX + 0x690]
MOV R9,R14
LAB_00158dc3:
ADD R13,RAX
XOR R14D,R14D
MOV RDI,R13
MOV ESI,0x1
MOV RDX,-0x1
MOV RCX,R12
MOV R8D,R15D
XOR EAX,EAX
CALL 0x001241c0
MOV RDI,R13
CALL 0x00124120
ADD qword ptr [RBX + 0x690],RAX
LAB_00158df4:
MOV EAX,R14D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00158e06:
MOV R14D,0x1
JMP 0x00158df4
|
int8 tailoring_append(long param_1,int8 param_2,ulong param_3,int8 param_4)
{
code *pcVar1;
long lVar2;
size_t sVar3;
long lVar4;
lVar4 = *(long *)(param_1 + 0x690);
if (param_3 + lVar4 + 0x40 < *(ulong *)(param_1 + 0x698)) {
lVar2 = *(long *)(param_1 + 0x688);
}
else {
pcVar1 = *(code **)(*(long *)(param_1 + 0x7a8) + 0x90);
lVar4 = lVar4 + param_3 + 0x8040;
*(long *)(param_1 + 0x698) = lVar4;
lVar2 = (*pcVar1)(*(int8 *)(param_1 + 0x688),lVar4);
*(long *)(param_1 + 0x688) = lVar2;
if (lVar2 == 0) {
return 1;
}
lVar4 = *(long *)(param_1 + 0x690);
}
__sprintf_chk((char *)(lVar4 + lVar2),1,0xffffffffffffffff,param_2,param_3 & 0xffffffff,param_4);
sVar3 = strlen((char *)(lVar4 + lVar2));
*(long *)(param_1 + 0x690) = *(long *)(param_1 + 0x690) + sVar3;
return 0;
}
|
|
60,685
|
my_scan_utf32
|
eloqsql/strings/ctype-ucs2.c
|
static size_t
my_scan_utf32(CHARSET_INFO *cs,
const char *str, const char *end, int sequence_type)
{
const char *str0= str;
switch (sequence_type)
{
case MY_SEQ_SPACES:
for ( ; str < end; )
{
my_wc_t wc;
int res= my_utf32_uni(cs, &wc, (uchar*) str, (uchar*) end);
if (res < 0 || wc != ' ')
break;
str+= res;
}
return (size_t) (str - str0);
case MY_SEQ_NONSPACES:
DBUG_ASSERT(0); /* Not implemented */
/* pass through */
default:
return 0;
}
}
|
O0
|
c
|
my_scan_utf32:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x40(%rbp)
subl $0x2, %eax
je 0x6c436
jmp 0x6c42c
movl -0x40(%rbp), %eax
subl $0x3, %eax
je 0x6c48d
jmp 0x6c493
jmp 0x6c438
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x6c47c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x38(%rbp), %rsi
callq 0x6b8a0
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jl 0x6c467
cmpq $0x20, -0x38(%rbp)
je 0x6c469
jmp 0x6c47c
movl -0x3c(%rbp), %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x6c438
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x6c49b
jmp 0x6c48f
jmp 0x6c491
jmp 0x6c493
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_scan_utf32:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_24], ecx
mov rax, [rbp+var_18]
mov [rbp+var_30], rax
mov eax, [rbp+var_24]
mov [rbp+var_40], eax
sub eax, 2
jz short loc_6C436
jmp short $+2
loc_6C42C:
mov eax, [rbp+var_40]
sub eax, 3
jz short loc_6C48D
jmp short loc_6C493
loc_6C436:
jmp short $+2
loc_6C438:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jnb short loc_6C47C
mov rdi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
lea rsi, [rbp+var_38]
call my_utf32_uni
mov [rbp+var_3C], eax
cmp [rbp+var_3C], 0
jl short loc_6C467
cmp [rbp+var_38], 20h ; ' '
jz short loc_6C469
loc_6C467:
jmp short loc_6C47C
loc_6C469:
mov ecx, [rbp+var_3C]
mov rax, [rbp+var_18]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_18], rax
jmp short loc_6C438
loc_6C47C:
mov rax, [rbp+var_18]
mov rcx, [rbp+var_30]
sub rax, rcx
mov [rbp+var_8], rax
jmp short loc_6C49B
loc_6C48D:
jmp short $+2
loc_6C48F:
jmp short $+2
loc_6C491:
jmp short $+2
loc_6C493:
mov [rbp+var_8], 0
loc_6C49B:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
|
unsigned long long my_scan_utf32(
long long a1,
unsigned long long a2,
unsigned long long a3,
int a4,
long long a5,
long long a6)
{
int v7; // [rsp+4h] [rbp-3Ch]
long long v8; // [rsp+8h] [rbp-38h] BYREF
unsigned long long v9; // [rsp+10h] [rbp-30h]
int v10; // [rsp+1Ch] [rbp-24h]
unsigned long long v11; // [rsp+20h] [rbp-20h]
unsigned long long v12; // [rsp+28h] [rbp-18h]
long long v13; // [rsp+30h] [rbp-10h]
v13 = a1;
v12 = a2;
v11 = a3;
v10 = a4;
v9 = a2;
if ( a4 != 2 )
return 0LL;
while ( v12 < v11 )
{
v7 = my_utf32_uni(v13, (long long)&v8, v12, v11, a5, a6);
if ( v7 < 0 || v8 != 32 )
break;
v12 += v7;
}
return v12 - v9;
}
|
my_scan_utf32:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV dword ptr [RBP + -0x24],ECX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x40],EAX
SUB EAX,0x2
JZ 0x0016c436
JMP 0x0016c42c
LAB_0016c42c:
MOV EAX,dword ptr [RBP + -0x40]
SUB EAX,0x3
JZ 0x0016c48d
JMP 0x0016c493
LAB_0016c436:
JMP 0x0016c438
LAB_0016c438:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JNC 0x0016c47c
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
LEA RSI,[RBP + -0x38]
CALL 0x0016b8a0
MOV dword ptr [RBP + -0x3c],EAX
CMP dword ptr [RBP + -0x3c],0x0
JL 0x0016c467
CMP qword ptr [RBP + -0x38],0x20
JZ 0x0016c469
LAB_0016c467:
JMP 0x0016c47c
LAB_0016c469:
MOV ECX,dword ptr [RBP + -0x3c]
MOV RAX,qword ptr [RBP + -0x18]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0016c438
LAB_0016c47c:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x30]
SUB RAX,RCX
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0016c49b
LAB_0016c48d:
JMP 0x0016c48f
LAB_0016c48f:
JMP 0x0016c491
LAB_0016c491:
JMP 0x0016c493
LAB_0016c493:
MOV qword ptr [RBP + -0x8],0x0
LAB_0016c49b:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
long my_scan_utf32(int8 param_1,ulong param_2,ulong param_3,int param_4)
{
int iVar1;
long local_40;
ulong local_38;
int4 local_2c;
ulong local_28;
ulong local_20;
int8 local_18;
long local_10;
if (param_4 == 2) {
local_2c = 2;
local_38 = param_2;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
while (((local_20 < local_28 &&
(iVar1 = my_utf32_uni(local_18,&local_40,local_20,local_28), -1 < iVar1)) &&
(local_40 == 0x20))) {
local_20 = local_20 + (long)iVar1;
}
local_10 = local_20 - local_38;
}
else {
local_10 = 0;
}
return local_10;
}
|
|
60,686
|
mbr_join
|
eloqsql/storage/maria/ma_rt_split.c
|
static void mbr_join(double *a, const double *b, int n_dim)
{
double *end= a + n_dim * 2;
do
{
if (a[0] > b[0])
a[0]= b[0];
if (a[1] < b[1])
a[1]= b[1];
a+= 2;
b+= 2;
} while (a != end);
}
|
O0
|
c
|
mbr_join:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
shll %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
ucomisd (%rax), %xmm0
jbe 0xa6848
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm1
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xa6872
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0xa6826
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
mbr_join:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov rax, [rbp+var_8]
mov ecx, [rbp+var_14]
shl ecx, 1
movsxd rcx, ecx
shl rcx, 3
add rax, rcx
mov [rbp+var_20], rax
loc_A6826:
mov rax, [rbp+var_8]
movsd xmm0, qword ptr [rax]
mov rax, [rbp+var_10]
ucomisd xmm0, qword ptr [rax]
jbe short loc_A6848
mov rax, [rbp+var_10]
movsd xmm0, qword ptr [rax]
mov rax, [rbp+var_8]
movsd qword ptr [rax], xmm0
loc_A6848:
mov rax, [rbp+var_8]
movsd xmm1, qword ptr [rax+8]
mov rax, [rbp+var_10]
movsd xmm0, qword ptr [rax+8]
ucomisd xmm0, xmm1
jbe short loc_A6872
mov rax, [rbp+var_10]
movsd xmm0, qword ptr [rax+8]
mov rax, [rbp+var_8]
movsd qword ptr [rax+8], xmm0
loc_A6872:
mov rax, [rbp+var_8]
add rax, 10h
mov [rbp+var_8], rax
mov rax, [rbp+var_10]
add rax, 10h
mov [rbp+var_10], rax
mov rax, [rbp+var_8]
cmp rax, [rbp+var_20]
jnz short loc_A6826
pop rbp
retn
|
double * mbr_join(double *a1, double *a2, int a3)
{
double *result; // rax
double *v5; // [rsp+18h] [rbp-8h]
v5 = a1;
do
{
if ( *v5 > *a2 )
*v5 = *a2;
if ( a2[1] > v5[1] )
v5[1] = a2[1];
v5 += 2;
a2 += 2;
result = v5;
}
while ( v5 != &a1[2 * a3] );
return result;
}
|
mbr_join:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RBP + -0x14]
SHL ECX,0x1
MOVSXD RCX,ECX
SHL RCX,0x3
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
LAB_001a6826:
MOV RAX,qword ptr [RBP + -0x8]
MOVSD XMM0,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
UCOMISD XMM0,qword ptr [RAX]
JBE 0x001a6848
MOV RAX,qword ptr [RBP + -0x10]
MOVSD XMM0,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x8]
MOVSD qword ptr [RAX],XMM0
LAB_001a6848:
MOV RAX,qword ptr [RBP + -0x8]
MOVSD XMM1,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOVSD XMM0,qword ptr [RAX + 0x8]
UCOMISD XMM0,XMM1
JBE 0x001a6872
MOV RAX,qword ptr [RBP + -0x10]
MOVSD XMM0,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x8]
MOVSD qword ptr [RAX + 0x8],XMM0
LAB_001a6872:
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x10
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x10
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x001a6826
POP RBP
RET
|
void mbr_join(double *param_1,double *param_2,int param_3)
{
double *local_18;
double *local_10;
local_18 = param_2;
local_10 = param_1;
do {
if (*local_18 <= *local_10 && *local_10 != *local_18) {
*local_10 = *local_18;
}
if (local_10[1] < local_18[1]) {
local_10[1] = local_18[1];
}
local_10 = local_10 + 2;
local_18 = local_18 + 2;
} while (local_10 != param_1 + (param_3 << 1));
return;
}
|
|
60,687
|
my_utf16le_uni
|
eloqsql/strings/ctype-ucs2.c
|
static int
my_utf16le_uni(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t *pwc, const uchar *s, const uchar *e)
{
my_wc_t lo;
if (s + 2 > e)
return MY_CS_TOOSMALL2;
if ((*pwc= uint2korr(s)) < MY_UTF16_SURROGATE_HIGH_FIRST ||
(*pwc > MY_UTF16_SURROGATE_LOW_LAST))
return 2; /* [0000-D7FF,E000-FFFF] */
if (*pwc >= MY_UTF16_SURROGATE_LOW_FIRST)
return MY_CS_ILSEQ; /* [DC00-DFFF] Low surrogate part without high part */
if (s + 4 > e)
return MY_CS_TOOSMALL4;
s+= 2;
if ((lo= uint2korr(s)) < MY_UTF16_SURROGATE_LOW_FIRST ||
lo > MY_UTF16_SURROGATE_LOW_LAST)
return MY_CS_ILSEQ; /* Expected low surrogate part, got something else */
*pwc= 0x10000 + (((*pwc & 0x3FF) << 10) | (lo & 0x3FF));
return 4;
}
|
O3
|
c
|
my_utf16le_uni:
pushq %rbp
movq %rsp, %rbp
leaq 0x2(%rdx), %r8
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %r8
ja 0x48b25
movzwl (%rdx), %edi
movq %rdi, (%rsi)
leal 0x2000(%rdi), %eax
movzwl %ax, %r9d
movl $0x2, %eax
cmpl $0xf800, %r9d # imm = 0xF800
jb 0x48b25
xorl %eax, %eax
cmpl $0xdbff, %edi # imm = 0xDBFF
ja 0x48b25
addq $0x4, %rdx
movl $0xffffff98, %eax # imm = 0xFFFFFF98
cmpq %rcx, %rdx
ja 0x48b25
movzwl (%r8), %ecx
leal 0x2000(%rcx), %eax
movzwl %ax, %edx
movl $0x0, %eax
cmpl $0xfc00, %edx # imm = 0xFC00
jb 0x48b25
shll $0xa, %edi
andl $0xffc00, %edi # imm = 0xFFC00
andl $0x3ff, %ecx # imm = 0x3FF
leaq (%rdi,%rcx), %rax
addq $0x10000, %rax # imm = 0x10000
movq %rax, (%rsi)
movl $0x4, %eax
popq %rbp
retq
|
my_utf16le_uni:
push rbp
mov rbp, rsp
lea r8, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp r8, rcx
ja short loc_48B25
movzx edi, word ptr [rdx]
mov [rsi], rdi
lea eax, [rdi+2000h]
movzx r9d, ax
mov eax, 2
cmp r9d, 0F800h
jb short loc_48B25
xor eax, eax
cmp edi, 0DBFFh
ja short loc_48B25
add rdx, 4
mov eax, 0FFFFFF98h
cmp rdx, rcx
ja short loc_48B25
movzx ecx, word ptr [r8]
lea eax, [rcx+2000h]
movzx edx, ax
mov eax, 0
cmp edx, 0FC00h
jb short loc_48B25
shl edi, 0Ah
and edi, 0FFC00h
and ecx, 3FFh
lea rax, [rdi+rcx]
add rax, 10000h
mov [rsi], rax
mov eax, 4
loc_48B25:
pop rbp
retn
|
long long my_utf16le_uni(long long a1, _QWORD *a2, unsigned __int16 *a3, unsigned long long a4)
{
_WORD *v4; // r8
long long result; // rax
long long v6; // rdi
v4 = a3 + 1;
result = 4294967194LL;
if ( (unsigned long long)(a3 + 1) <= a4 )
{
v6 = *a3;
*a2 = v6;
result = 2LL;
if ( (unsigned __int16)(v6 + 0x2000) >= 0xF800u )
{
result = 0LL;
if ( (unsigned int)v6 <= 0xDBFF )
{
result = 4294967192LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
result = 0LL;
if ( (unsigned __int16)(*v4 + 0x2000) >= 0xFC00u )
{
*a2 = (((_DWORD)v6 << 10) & 0xFFC00) + (unsigned long long)(*v4 & 0x3FF) + 0x10000;
return 4LL;
}
}
}
}
}
return result;
}
|
my_utf16le_uni:
PUSH RBP
MOV RBP,RSP
LEA R8,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP R8,RCX
JA 0x00148b25
MOVZX EDI,word ptr [RDX]
MOV qword ptr [RSI],RDI
LEA EAX,[RDI + 0x2000]
MOVZX R9D,AX
MOV EAX,0x2
CMP R9D,0xf800
JC 0x00148b25
XOR EAX,EAX
CMP EDI,0xdbff
JA 0x00148b25
ADD RDX,0x4
MOV EAX,0xffffff98
CMP RDX,RCX
JA 0x00148b25
MOVZX ECX,word ptr [R8]
LEA EAX,[RCX + 0x2000]
MOVZX EDX,AX
MOV EAX,0x0
CMP EDX,0xfc00
JC 0x00148b25
SHL EDI,0xa
AND EDI,0xffc00
AND ECX,0x3ff
LEA RAX,[RDI + RCX*0x1]
ADD RAX,0x10000
MOV qword ptr [RSI],RAX
MOV EAX,0x4
LAB_00148b25:
POP RBP
RET
|
int8 my_utf16le_uni(int8 param_1,ulong *param_2,ushort *param_3,ushort *param_4)
{
ushort uVar1;
ushort uVar2;
int8 uVar3;
uVar3 = 0xffffff9a;
if (param_3 + 1 <= param_4) {
uVar1 = *param_3;
*param_2 = (ulong)uVar1;
uVar3 = 2;
if (((0xf7ff < (ushort)(uVar1 + 0x2000)) && (uVar3 = 0, uVar1 < 0xdc00)) &&
(uVar3 = 0xffffff98, param_3 + 2 <= param_4)) {
uVar2 = param_3[1];
uVar3 = 0;
if (0xfbff < (ushort)(uVar2 + 0x2000)) {
*param_2 = (ulong)((uVar1 & 0x3ff) << 10) + (ulong)(uVar2 & 0x3ff) + 0x10000;
uVar3 = 4;
}
}
}
return uVar3;
}
|
|
60,688
|
dirname_part
|
eloqsql/mysys/mf_dirname.c
|
size_t dirname_part(char *to, const char *name, size_t *to_res_length)
{
size_t length;
DBUG_ENTER("dirname_part");
DBUG_PRINT("enter",("'%s'",name));
length=dirname_length(name);
*to_res_length= (size_t) (convert_dirname(to, name, name+length) - to);
DBUG_RETURN(length);
}
|
O3
|
c
|
dirname_part:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
leaq -0x1(%rsi), %rdx
movq %rsi, %rax
movzbl (%rax), %ecx
cmpl $0x2f, %ecx
je 0x29f8e
testl %ecx, %ecx
jne 0x29f91
jmp 0x29f96
movq %rax, %rdx
incq %rax
jmp 0x29f80
incq %rdx
movq %rdx, %r15
subq %rsi, %r15
movq %r14, %rdi
callq 0x29fbb
subq %r14, %rax
movq %rax, (%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
dirname_part:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rdx
mov r14, rdi
lea rdx, [rsi-1]
mov rax, rsi
loc_29F80:
movzx ecx, byte ptr [rax]
cmp ecx, 2Fh ; '/'
jz short loc_29F8E
test ecx, ecx
jnz short loc_29F91
jmp short loc_29F96
loc_29F8E:
mov rdx, rax
loc_29F91:
inc rax
jmp short loc_29F80
loc_29F96:
inc rdx
mov r15, rdx
sub r15, rsi
mov rdi, r14
call convert_dirname
sub rax, r14
mov [rbx], rax
mov rax, r15
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
long long dirname_part(long long a1, _BYTE *a2, _QWORD *a3)
{
_BYTE *v4; // rdx
_BYTE *i; // rax
_BYTE *v6; // rdx
long long v7; // r15
v4 = a2 - 1;
for ( i = a2; *i == 47; ++i )
{
v4 = i;
LABEL_6:
;
}
if ( *i )
goto LABEL_6;
v6 = v4 + 1;
v7 = v6 - a2;
*a3 = convert_dirname(a1, a2, v6) - a1;
return v7;
}
|
dirname_part:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R14,RDI
LEA RDX,[RSI + -0x1]
MOV RAX,RSI
LAB_00129f80:
MOVZX ECX,byte ptr [RAX]
CMP ECX,0x2f
JZ 0x00129f8e
TEST ECX,ECX
JNZ 0x00129f91
JMP 0x00129f96
LAB_00129f8e:
MOV RDX,RAX
LAB_00129f91:
INC RAX
JMP 0x00129f80
LAB_00129f96:
INC RDX
MOV R15,RDX
SUB R15,RSI
MOV RDI,R14
CALL 0x00129fbb
SUB RAX,R14
MOV qword ptr [RBX],RAX
MOV RAX,R15
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
char * dirname_part(long param_1,char *param_2,long *param_3)
{
char *pcVar1;
long lVar2;
char *pcVar3;
char *pcVar4;
pcVar3 = param_2 + -1;
for (pcVar1 = param_2; (pcVar4 = pcVar1, *pcVar1 == '/' || (pcVar4 = pcVar3, *pcVar1 != '\0'));
pcVar1 = pcVar1 + 1) {
pcVar3 = pcVar4;
}
lVar2 = convert_dirname(param_1);
*param_3 = lVar2 - param_1;
return pcVar3 + (1 - (long)param_2);
}
|
|
60,689
|
reset_status_by_user()
|
eloqsql/storage/perfschema/pfs_status.cc
|
void reset_status_by_user()
{
global_user_container.apply_all(fct_reset_status_by_user);
}
|
O3
|
cpp
|
reset_status_by_user():
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %r14d, %r14d
leaq 0x38499e(%rip), %r15 # 0x3c82d8
movq 0xa8(%r15,%r14,8), %rax
testq %rax, %rax
je 0x43980
movq 0x50(%rax), %rcx
testq %rcx, %rcx
jle 0x43980
movq 0x48(%rax), %rbx
imulq $0x9c0, %rcx, %r12 # imm = 0x9C0
addq %rbx, %r12
movl 0x7e0(%rbx), %eax
andl $0x3, %eax
cmpl $0x2, %eax
jne 0x43974
movq %rbx, %rdi
callq 0x442ea
addq $0x9c0, %rbx # imm = 0x9C0
cmpq %r12, %rbx
jb 0x4395e
incq %r14
cmpq $0x80, %r14
jne 0x4393a
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
_Z20reset_status_by_userv:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
xor r14d, r14d
lea r15, global_user_container
loc_4393A:
mov rax, [r15+r14*8+0A8h]
test rax, rax
jz short loc_43980
mov rcx, [rax+50h]
test rcx, rcx
jle short loc_43980
mov rbx, [rax+48h]
imul r12, rcx, 9C0h
add r12, rbx
loc_4395E:
mov eax, [rbx+7E0h]
and eax, 3
cmp eax, 2
jnz short loc_43974
mov rdi, rbx; this
call _ZN8PFS_user16aggregate_statusEv; PFS_user::aggregate_status(void)
loc_43974:
add rbx, 9C0h
cmp rbx, r12
jb short loc_4395E
loc_43980:
inc r14
cmp r14, 80h
jnz short loc_4393A
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
long long reset_status_by_user(void)
{
long long i; // r14
long long result; // rax
long long v2; // rcx
PFS_user *v3; // rbx
PFS_user *v4; // r12
for ( i = 0LL; i != 128; ++i )
{
result = global_user_container[i + 21];
if ( result )
{
v2 = *(_QWORD *)(result + 80);
if ( v2 > 0 )
{
v3 = *(PFS_user **)(result + 72);
v4 = (PFS_user *)((char *)v3 + 2496 * v2);
do
{
result = *((_DWORD *)v3 + 504) & 3;
if ( (_DWORD)result == 2 )
result = PFS_user::aggregate_status(v3);
v3 = (PFS_user *)((char *)v3 + 2496);
}
while ( v3 < v4 );
}
}
}
return result;
}
|
reset_status_by_user:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
XOR R14D,R14D
LEA R15,[0x4c82d8]
LAB_0014393a:
MOV RAX,qword ptr [R15 + R14*0x8 + 0xa8]
TEST RAX,RAX
JZ 0x00143980
MOV RCX,qword ptr [RAX + 0x50]
TEST RCX,RCX
JLE 0x00143980
MOV RBX,qword ptr [RAX + 0x48]
IMUL R12,RCX,0x9c0
ADD R12,RBX
LAB_0014395e:
MOV EAX,dword ptr [RBX + 0x7e0]
AND EAX,0x3
CMP EAX,0x2
JNZ 0x00143974
MOV RDI,RBX
CALL 0x001442ea
LAB_00143974:
ADD RBX,0x9c0
CMP RBX,R12
JC 0x0014395e
LAB_00143980:
INC R14
CMP R14,0x80
JNZ 0x0014393a
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* reset_status_by_user() */
void reset_status_by_user(void)
{
long lVar1;
PFS_user *this;
PFS_user *pPVar2;
long lVar3;
lVar3 = 0;
do {
lVar1 = (&DAT_004c8380)[lVar3];
if ((lVar1 != 0) && (0 < *(long *)(lVar1 + 0x50))) {
this = *(PFS_user **)(lVar1 + 0x48);
pPVar2 = this + *(long *)(lVar1 + 0x50) * 0x9c0;
do {
if ((*(uint *)(this + 0x7e0) & 3) == 2) {
PFS_user::aggregate_status(this);
}
this = this + 0x9c0;
} while (this < pPVar2);
}
lVar3 = lVar3 + 1;
} while (lVar3 != 0x80);
return;
}
|
|
60,690
|
EsrganBlock::forward(ggml_context*, float, ggml_tensor*)
|
7CodeWizard[P]stablediffusion/esrgan.hpp
|
ggml_tensor* forward(ggml_context* ctx, float out_scale, ggml_tensor* x) {
ggml_tensor* out = x;
for (int i = 0; i < num_residual_blocks; i++) {
// out = self.rdb...(x)
out = rd_blocks[i].forward(ctx, out_scale, out);
}
// return out * 0.2 + x
out = ggml_add(ctx, ggml_scale(ctx, out, out_scale), x);
return out;
}
|
O0
|
cpp
|
EsrganBlock::forward(ggml_context*, float, ggml_tensor*):
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movss %xmm0, 0x34(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl 0x108(%rcx), %eax
jge 0xf36fe
movq 0x10(%rsp), %rdi
movslq 0x1c(%rsp), %rax
imulq $0x58, %rax, %rax
addq %rax, %rdi
movq 0x38(%rsp), %rsi
movss 0x34(%rsp), %xmm0
movq 0x20(%rsp), %rdx
callq 0xf3740
movq %rax, 0x20(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xf36b5
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
movss 0x34(%rsp), %xmm0
callq 0x121b40
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x28(%rsp), %rdx
callq 0x11ea50
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x48, %rsp
retq
nop
|
_ZN11EsrganBlock7forwardEP12ggml_contextfP11ggml_tensor:
sub rsp, 48h
mov [rsp+48h+var_8], rdi
mov [rsp+48h+var_10], rsi
movss [rsp+48h+var_14], xmm0
mov [rsp+48h+var_20], rdx
mov rax, [rsp+48h+var_8]
mov [rsp+48h+var_38], rax
mov rax, [rsp+48h+var_20]
mov [rsp+48h+var_28], rax
mov [rsp+48h+var_2C], 0
loc_F36B5:
mov rcx, [rsp+48h+var_38]
mov eax, [rsp+48h+var_2C]
cmp eax, [rcx+108h]
jge short loc_F36FE
mov rdi, [rsp+48h+var_38]
movsxd rax, [rsp+48h+var_2C]
imul rax, 58h ; 'X'
add rdi, rax
mov rsi, [rsp+48h+var_10]
movss xmm0, [rsp+48h+var_14]
mov rdx, [rsp+48h+var_28]
call _ZN18ResidualDenseBlock7forwardEP12ggml_contextfP11ggml_tensor; ResidualDenseBlock::forward(ggml_context *,float,ggml_tensor *)
mov [rsp+48h+var_28], rax
mov eax, [rsp+48h+var_2C]
add eax, 1
mov [rsp+48h+var_2C], eax
jmp short loc_F36B5
loc_F36FE:
mov rax, [rsp+48h+var_10]
mov [rsp+48h+var_40], rax
mov rdi, [rsp+48h+var_10]
mov rsi, [rsp+48h+var_28]
movss xmm0, [rsp+48h+var_14]
call ggml_scale
mov rdi, [rsp+48h+var_40]
mov rsi, rax
mov rdx, [rsp+48h+var_20]
call ggml_add
mov [rsp+48h+var_28], rax
mov rax, [rsp+48h+var_28]
add rsp, 48h
retn
|
long long EsrganBlock::forward(long long a1, long long a2, long long a3, float a4)
{
long long v4; // rax
int i; // [rsp+1Ch] [rbp-2Ch]
long long v7; // [rsp+20h] [rbp-28h]
v7 = a3;
for ( i = 0; i < *(_DWORD *)(a1 + 264); ++i )
v7 = ResidualDenseBlock::forward(88LL * i + a1, a2, v7, a4);
v4 = ggml_scale(a2, v7, a4);
return ggml_add(a2, v4, a3);
}
|
forward:
SUB RSP,0x48
MOV qword ptr [RSP + 0x40],RDI
MOV qword ptr [RSP + 0x38],RSI
MOVSS dword ptr [RSP + 0x34],XMM0
MOV qword ptr [RSP + 0x28],RDX
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x20],RAX
MOV dword ptr [RSP + 0x1c],0x0
LAB_001f36b5:
MOV RCX,qword ptr [RSP + 0x10]
MOV EAX,dword ptr [RSP + 0x1c]
CMP EAX,dword ptr [RCX + 0x108]
JGE 0x001f36fe
MOV RDI,qword ptr [RSP + 0x10]
MOVSXD RAX,dword ptr [RSP + 0x1c]
IMUL RAX,RAX,0x58
ADD RDI,RAX
MOV RSI,qword ptr [RSP + 0x38]
MOVSS XMM0,dword ptr [RSP + 0x34]
MOV RDX,qword ptr [RSP + 0x20]
CALL 0x001f3740
MOV qword ptr [RSP + 0x20],RAX
MOV EAX,dword ptr [RSP + 0x1c]
ADD EAX,0x1
MOV dword ptr [RSP + 0x1c],EAX
JMP 0x001f36b5
LAB_001f36fe:
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x38]
MOV RSI,qword ptr [RSP + 0x20]
MOVSS XMM0,dword ptr [RSP + 0x34]
CALL 0x00221b40
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,RAX
MOV RDX,qword ptr [RSP + 0x28]
CALL 0x0021ea50
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [RSP + 0x20]
ADD RSP,0x48
RET
|
/* EsrganBlock::forward(ggml_context*, float, ggml_tensor*) */
int8 __thiscall
EsrganBlock::forward(EsrganBlock *this,ggml_context *param_1,float param_2,ggml_tensor *param_3)
{
int8 uVar1;
int local_2c;
ggml_tensor *local_28;
local_28 = param_3;
for (local_2c = 0; local_2c < *(int *)(this + 0x108); local_2c = local_2c + 1) {
local_28 = (ggml_tensor *)
ResidualDenseBlock::forward
((ResidualDenseBlock *)(this + (long)local_2c * 0x58),param_1,param_2,
local_28);
}
uVar1 = ggml_scale(param_2,param_1,local_28);
uVar1 = ggml_add(param_1,uVar1,param_3);
return uVar1;
}
|
|
60,691
|
EsrganBlock::forward(ggml_context*, float, ggml_tensor*)
|
7CodeWizard[P]stablediffusion/esrgan.hpp
|
ggml_tensor* forward(ggml_context* ctx, float out_scale, ggml_tensor* x) {
ggml_tensor* out = x;
for (int i = 0; i < num_residual_blocks; i++) {
// out = self.rdb...(x)
out = rd_blocks[i].forward(ctx, out_scale, out);
}
// return out * 0.2 + x
out = ggml_add(ctx, ggml_scale(ctx, out, out_scale), x);
return out;
}
|
O1
|
cpp
|
EsrganBlock::forward(ggml_context*, float, ggml_tensor*):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
cmpl $0x0, 0x108(%rdi)
movq %rdx, %rax
jle 0x7e684
movq %rdi, %r15
xorl %r13d, %r13d
movq %rdi, %r12
movq %rbx, %rax
movss %xmm0, 0xc(%rsp)
movq %r12, %rdi
movq %r14, %rsi
movss 0xc(%rsp), %xmm0
movq %rax, %rdx
callq 0x7e6aa
movss 0xc(%rsp), %xmm0
incq %r13
movslq 0x108(%r15), %rcx
addq $0x58, %r12
cmpq %rcx, %r13
jl 0x7e657
movq %r14, %rdi
movq %rax, %rsi
callq 0x92750
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x90c8a
|
_ZN11EsrganBlock7forwardEP12ggml_contextfP11ggml_tensor:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 10h
mov rbx, rdx
mov r14, rsi
cmp dword ptr [rdi+108h], 0
mov rax, rdx
jle short loc_7E684
mov r15, rdi
xor r13d, r13d
mov r12, rdi
mov rax, rbx
movss [rsp+38h+var_2C], xmm0
loc_7E657:
mov rdi, r12
mov rsi, r14
movss xmm0, [rsp+38h+var_2C]
mov rdx, rax
call _ZN18ResidualDenseBlock7forwardEP12ggml_contextfP11ggml_tensor; ResidualDenseBlock::forward(ggml_context *,float,ggml_tensor *)
movss xmm0, [rsp+38h+var_2C]
inc r13
movsxd rcx, dword ptr [r15+108h]
add r12, 58h ; 'X'
cmp r13, rcx
jl short loc_7E657
loc_7E684:
mov rdi, r14
mov rsi, rax
call ggml_scale
mov rdi, r14
mov rsi, rax
mov rdx, rbx
add rsp, 10h
pop rbx
pop r12
pop r13
pop r14
pop r15
jmp ggml_add
|
long long EsrganBlock::forward(long long a1, long long a2, long long a3, float a4)
{
long long v5; // rax
long long v6; // r13
long long v7; // r12
long long v8; // rax
float v10; // [rsp+Ch] [rbp-2Ch]
v5 = a3;
if ( *(int *)(a1 + 264) > 0 )
{
v6 = 0LL;
v7 = a1;
v5 = a3;
v10 = a4;
do
{
v5 = ResidualDenseBlock::forward(v7, a2, v5, v10);
a4 = v10;
++v6;
v7 += 88LL;
}
while ( v6 < *(int *)(a1 + 264) );
}
v8 = ggml_scale(a2, v5, a4);
return ggml_add(a2, v8, a3);
}
| |||
60,692
|
EsrganBlock::forward(ggml_context*, float, ggml_tensor*)
|
7CodeWizard[P]stablediffusion/esrgan.hpp
|
ggml_tensor* forward(ggml_context* ctx, float out_scale, ggml_tensor* x) {
ggml_tensor* out = x;
for (int i = 0; i < num_residual_blocks; i++) {
// out = self.rdb...(x)
out = rd_blocks[i].forward(ctx, out_scale, out);
}
// return out * 0.2 + x
out = ggml_add(ctx, ggml_scale(ctx, out, out_scale), x);
return out;
}
|
O2
|
cpp
|
EsrganBlock::forward(ggml_context*, float, ggml_tensor*):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movss %xmm0, 0xc(%rsp)
movq %rsi, %r14
movq %rdi, %r15
xorl %r13d, %r13d
movq %rdi, %r12
movq %rdx, %rax
movslq 0x108(%r15), %rcx
cmpq %rcx, %r13
jge 0x59430
movq %r12, %rdi
movq %r14, %rsi
movss 0xc(%rsp), %xmm0
movq %rax, %rdx
callq 0x5945c
incq %r13
addq $0x58, %r12
jmp 0x59407
movq %r14, %rdi
movq %rax, %rsi
movss 0xc(%rsp), %xmm0
callq 0x6b500
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x69a53
|
_ZN11EsrganBlock7forwardEP12ggml_contextfP11ggml_tensor:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 10h
mov rbx, rdx
movss [rsp+38h+var_2C], xmm0
mov r14, rsi
mov r15, rdi
xor r13d, r13d
mov r12, rdi
mov rax, rdx
loc_59407:
movsxd rcx, dword ptr [r15+108h]
cmp r13, rcx
jge short loc_59430
mov rdi, r12
mov rsi, r14
movss xmm0, [rsp+38h+var_2C]
mov rdx, rax
call _ZN18ResidualDenseBlock7forwardEP12ggml_contextfP11ggml_tensor; ResidualDenseBlock::forward(ggml_context *,float,ggml_tensor *)
inc r13
add r12, 58h ; 'X'
jmp short loc_59407
loc_59430:
mov rdi, r14
mov rsi, rax
movss xmm0, [rsp+38h+var_2C]
call ggml_scale
mov rdi, r14
mov rsi, rax
mov rdx, rbx
add rsp, 10h
pop rbx
pop r12
pop r13
pop r14
pop r15
jmp ggml_add
|
long long EsrganBlock::forward(long long a1, long long a2, long long a3, float a4)
{
long long v5; // r13
long long v6; // r12
long long v7; // rax
long long v8; // rax
v5 = 0LL;
v6 = a1;
v7 = a3;
while ( v5 < *(int *)(a1 + 264) )
{
v7 = ResidualDenseBlock::forward(v6, a2, v7, a4);
++v5;
v6 += 88LL;
}
v8 = ggml_scale(a2, v7, a4);
return ggml_add(a2, v8, a3);
}
|
forward:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV RBX,RDX
MOVSS dword ptr [RSP + 0xc],XMM0
MOV R14,RSI
MOV R15,RDI
XOR R13D,R13D
MOV R12,RDI
MOV RAX,RDX
LAB_00159407:
MOVSXD RCX,dword ptr [R15 + 0x108]
CMP R13,RCX
JGE 0x00159430
MOV RDI,R12
MOV RSI,R14
MOVSS XMM0,dword ptr [RSP + 0xc]
MOV RDX,RAX
CALL 0x0015945c
INC R13
ADD R12,0x58
JMP 0x00159407
LAB_00159430:
MOV RDI,R14
MOV RSI,RAX
MOVSS XMM0,dword ptr [RSP + 0xc]
CALL 0x0016b500
MOV RDI,R14
MOV RSI,RAX
MOV RDX,RBX
ADD RSP,0x10
POP RBX
POP R12
POP R13
POP R14
POP R15
JMP 0x00169a53
|
/* EsrganBlock::forward(ggml_context*, float, ggml_tensor*) */
void __thiscall
EsrganBlock::forward(EsrganBlock *this,ggml_context *param_1,float param_2,ggml_tensor *param_3)
{
ggml_tensor *pgVar1;
int8 uVar2;
EsrganBlock *pEVar3;
long lVar4;
pgVar1 = param_3;
pEVar3 = this;
for (lVar4 = 0; lVar4 < *(int *)(this + 0x108); lVar4 = lVar4 + 1) {
pgVar1 = (ggml_tensor *)
ResidualDenseBlock::forward((ggml_context *)pEVar3,param_2,(ggml_tensor *)param_1);
pEVar3 = (EsrganBlock *)((ggml_context *)pEVar3 + 0x58);
}
uVar2 = ggml_scale(param_2,param_1,pgVar1);
ggml_add(param_1,uVar2,param_3);
return;
}
|
|
60,693
|
EsrganBlock::forward(ggml_context*, float, ggml_tensor*)
|
7CodeWizard[P]stablediffusion/esrgan.hpp
|
ggml_tensor* forward(ggml_context* ctx, float out_scale, ggml_tensor* x) {
ggml_tensor* out = x;
for (int i = 0; i < num_residual_blocks; i++) {
// out = self.rdb...(x)
out = rd_blocks[i].forward(ctx, out_scale, out);
}
// return out * 0.2 + x
out = ggml_add(ctx, ggml_scale(ctx, out, out_scale), x);
return out;
}
|
O3
|
cpp
|
EsrganBlock::forward(ggml_context*, float, ggml_tensor*):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
cmpl $0x0, 0x108(%rdi)
movq %rdx, %rax
jle 0x7d60e
movq %rdi, %r15
xorl %r13d, %r13d
movq %rdi, %r12
movq %rbx, %rax
movss %xmm0, 0xc(%rsp)
movq %r12, %rdi
movq %r14, %rsi
movss 0xc(%rsp), %xmm0
movq %rax, %rdx
callq 0x7d634
movss 0xc(%rsp), %xmm0
incq %r13
movslq 0x108(%r15), %rcx
addq $0x58, %r12
cmpq %rcx, %r13
jl 0x7d5e1
movq %r14, %rdi
movq %rax, %rsi
callq 0x9159e
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x8f9f3
|
_ZN11EsrganBlock7forwardEP12ggml_contextfP11ggml_tensor:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 10h
mov rbx, rdx
mov r14, rsi
cmp dword ptr [rdi+108h], 0
mov rax, rdx
jle short loc_7D60E
mov r15, rdi
xor r13d, r13d
mov r12, rdi
mov rax, rbx
movss [rsp+38h+var_2C], xmm0
loc_7D5E1:
mov rdi, r12
mov rsi, r14
movss xmm0, [rsp+38h+var_2C]
mov rdx, rax
call _ZN18ResidualDenseBlock7forwardEP12ggml_contextfP11ggml_tensor; ResidualDenseBlock::forward(ggml_context *,float,ggml_tensor *)
movss xmm0, [rsp+38h+var_2C]
inc r13
movsxd rcx, dword ptr [r15+108h]
add r12, 58h ; 'X'
cmp r13, rcx
jl short loc_7D5E1
loc_7D60E:
mov rdi, r14
mov rsi, rax
call ggml_scale
mov rdi, r14
mov rsi, rax
mov rdx, rbx
add rsp, 10h
pop rbx
pop r12
pop r13
pop r14
pop r15
jmp ggml_add
|
long long EsrganBlock::forward(long long a1, long long a2, long long a3, float a4)
{
long long v5; // rax
long long v6; // r13
long long v7; // r12
long long v8; // rax
float v10; // [rsp+Ch] [rbp-2Ch]
v5 = a3;
if ( *(int *)(a1 + 264) > 0 )
{
v6 = 0LL;
v7 = a1;
v5 = a3;
v10 = a4;
do
{
v5 = ResidualDenseBlock::forward(v7, a2, v5, v10);
a4 = v10;
++v6;
v7 += 88LL;
}
while ( v6 < *(int *)(a1 + 264) );
}
v8 = ggml_scale(a2, v5, a4);
return ggml_add(a2, v8, a3);
}
| |||
60,694
|
ma_dynstr_set
|
eloqsql/libmariadb/libmariadb/ma_string.c
|
my_bool ma_dynstr_set(DYNAMIC_STRING *str, const char *init_str)
{
uint length;
if (init_str && (length= (uint) strlen(init_str)+1) > str->max_length)
{
str->max_length=((length+str->alloc_increment-1)/str->alloc_increment)*
str->alloc_increment;
if (!str->max_length)
str->max_length=str->alloc_increment;
if (!(str->str=(char*) realloc(str->str,str->max_length)))
return(TRUE);
}
if (init_str)
{
str->length=length-1;
memcpy(str->str,init_str,length);
}
else
str->length=0;
return(FALSE);
}
|
O0
|
c
|
ma_dynstr_set:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x32757
movq -0x18(%rbp), %rdi
callq 0x131a0
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl %eax, %eax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x32757
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
addq 0x18(%rcx), %rax
subq $0x1, %rax
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divq 0x18(%rcx)
movq %rax, %rcx
movq -0x10(%rbp), %rax
imulq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x3272e
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x13700
movq -0x10(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x32755
movb $0x1, -0x1(%rbp)
jmp 0x32797
jmp 0x32757
cmpq $0x0, -0x18(%rbp)
je 0x32787
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %eax
movl %eax, %edx
callq 0x13360
jmp 0x32793
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
|
ma_dynstr_set:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
cmp [rbp+var_18], 0
jz loc_32757
mov rdi, [rbp+var_18]
call _strlen
add eax, 1
mov [rbp+var_1C], eax
mov eax, eax
mov rcx, [rbp+var_10]
cmp rax, [rcx+10h]
jbe short loc_32757
mov eax, [rbp+var_1C]
mov rcx, [rbp+var_10]
add rax, [rcx+18h]
sub rax, 1
mov rcx, [rbp+var_10]
xor edx, edx
div qword ptr [rcx+18h]
mov rcx, rax
mov rax, [rbp+var_10]
imul rcx, [rax+18h]
mov rax, [rbp+var_10]
mov [rax+10h], rcx
mov rax, [rbp+var_10]
cmp qword ptr [rax+10h], 0
jnz short loc_3272E
mov rax, [rbp+var_10]
mov rcx, [rax+18h]
mov rax, [rbp+var_10]
mov [rax+10h], rcx
loc_3272E:
mov rax, [rbp+var_10]
mov rdi, [rax]
mov rax, [rbp+var_10]
mov rsi, [rax+10h]
call _realloc
mov rcx, [rbp+var_10]
mov [rcx], rax
cmp rax, 0
jnz short loc_32755
mov [rbp+var_1], 1
jmp short loc_32797
loc_32755:
jmp short $+2
loc_32757:
cmp [rbp+var_18], 0
jz short loc_32787
mov eax, [rbp+var_1C]
sub eax, 1
mov eax, eax
mov ecx, eax
mov rax, [rbp+var_10]
mov [rax+8], rcx
mov rax, [rbp+var_10]
mov rdi, [rax]
mov rsi, [rbp+var_18]
mov eax, [rbp+var_1C]
mov edx, eax
call _memcpy
jmp short loc_32793
loc_32787:
mov rax, [rbp+var_10]
mov qword ptr [rax+8], 0
loc_32793:
mov [rbp+var_1], 0
loc_32797:
mov al, [rbp+var_1]
add rsp, 20h
pop rbp
retn
|
char ma_dynstr_set(long long *a1, long long a2)
{
long long v2; // rax
unsigned int v4; // [rsp+4h] [rbp-1Ch]
if ( !a2 )
goto LABEL_7;
v4 = strlen(a2) + 1;
if ( v4 <= (unsigned long long)a1[2] )
goto LABEL_7;
a1[2] = a1[3] * ((a1[3] + (unsigned long long)v4 - 1) / a1[3]);
if ( !a1[2] )
a1[2] = a1[3];
v2 = realloc(*a1, a1[2]);
*a1 = v2;
if ( !v2 )
return 1;
LABEL_7:
if ( a2 )
{
a1[1] = v4 - 1;
memcpy(*a1, a2, v4);
}
else
{
a1[1] = 0LL;
}
return 0;
}
|
ma_dynstr_set:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
CMP qword ptr [RBP + -0x18],0x0
JZ 0x00132757
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x001131a0
ADD EAX,0x1
MOV dword ptr [RBP + -0x1c],EAX
MOV EAX,EAX
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x10]
JBE 0x00132757
MOV EAX,dword ptr [RBP + -0x1c]
MOV RCX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RCX + 0x18]
SUB RAX,0x1
MOV RCX,qword ptr [RBP + -0x10]
XOR EDX,EDX
DIV qword ptr [RCX + 0x18]
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
IMUL RCX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x10],0x0
JNZ 0x0013272e
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x10],RCX
LAB_0013272e:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x10]
CALL 0x00113700
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX],RAX
CMP RAX,0x0
JNZ 0x00132755
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00132797
LAB_00132755:
JMP 0x00132757
LAB_00132757:
CMP qword ptr [RBP + -0x18],0x0
JZ 0x00132787
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x1
MOV EAX,EAX
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x1c]
MOV EDX,EAX
CALL 0x00113360
JMP 0x00132793
LAB_00132787:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x8],0x0
LAB_00132793:
MOV byte ptr [RBP + -0x1],0x0
LAB_00132797:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x20
POP RBP
RET
|
int1 ma_dynstr_set(int8 *param_1,char *param_2)
{
size_t sVar1;
void *pvVar2;
uint local_24;
if (param_2 != (char *)0x0) {
sVar1 = strlen(param_2);
local_24 = (int)sVar1 + 1;
if ((ulong)param_1[2] < (ulong)local_24) {
param_1[2] = ((((ulong)local_24 + param_1[3]) - 1) / (ulong)param_1[3]) * param_1[3];
if (param_1[2] == 0) {
param_1[2] = param_1[3];
}
pvVar2 = realloc((void *)*param_1,param_1[2]);
*param_1 = pvVar2;
if (pvVar2 == (void *)0x0) {
return 1;
}
}
}
if (param_2 == (char *)0x0) {
param_1[1] = 0;
}
else {
param_1[1] = (ulong)(local_24 - 1);
memcpy((void *)*param_1,param_2,(ulong)local_24);
}
return 0;
}
|
|
60,695
|
cmd_params_instance::to_llama_cparams() const
|
llama.cpp/examples/llama-bench/llama-bench.cpp
|
llama_context_params to_llama_cparams() const {
llama_context_params cparams = llama_context_default_params();
cparams.n_ctx = n_prompt + n_gen;
cparams.n_batch = n_batch;
cparams.n_ubatch = n_ubatch;
cparams.type_k = type_k;
cparams.type_v = type_v;
cparams.offload_kqv = !no_kv_offload;
cparams.flash_attn = flash_attn;
cparams.embeddings = embeddings;
return cparams;
}
|
O3
|
cpp
|
cmd_params_instance::to_llama_cparams() const:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x16de0
movl 0x24(%rbx), %eax
addl 0x20(%rbx), %eax
movl %eax, (%r14)
movq 0x28(%rbx), %rax
movq %rax, 0x4(%r14)
movq 0x30(%rbx), %rax
movq %rax, 0x58(%r14)
movb 0x98(%rbx), %al
xorb $0x1, %al
movb %al, 0x62(%r14)
movb 0x99(%rbx), %al
movb %al, 0x63(%r14)
movb 0xb9(%rbx), %al
movb %al, 0x61(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
_ZNK19cmd_params_instance16to_llama_cparamsEv:
push r14
push rbx
push rax
mov rbx, rsi
mov r14, rdi
call _llama_context_default_params
mov eax, [rbx+24h]
add eax, [rbx+20h]
mov [r14], eax
mov rax, [rbx+28h]
mov [r14+4], rax
mov rax, [rbx+30h]
mov [r14+58h], rax
mov al, [rbx+98h]
xor al, 1
mov [r14+62h], al
mov al, [rbx+99h]
mov [r14+63h], al
mov al, [rbx+0B9h]
mov [r14+61h], al
mov rax, r14
add rsp, 8
pop rbx
pop r14
retn
|
cmd_params_instance * cmd_params_instance::to_llama_cparams(cmd_params_instance *this, long long a2)
{
llama_context_default_params(this);
*(_DWORD *)this = *(_DWORD *)(a2 + 32) + *(_DWORD *)(a2 + 36);
*(_QWORD *)((char *)this + 4) = *(_QWORD *)(a2 + 40);
*((_QWORD *)this + 11) = *(_QWORD *)(a2 + 48);
*((_BYTE *)this + 98) = *(_BYTE *)(a2 + 152) ^ 1;
*((_BYTE *)this + 99) = *(_BYTE *)(a2 + 153);
*((_BYTE *)this + 97) = *(_BYTE *)(a2 + 185);
return this;
}
|
to_llama_cparams:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
CALL 0x00116de0
MOV EAX,dword ptr [RBX + 0x24]
ADD EAX,dword ptr [RBX + 0x20]
MOV dword ptr [R14],EAX
MOV RAX,qword ptr [RBX + 0x28]
MOV qword ptr [R14 + 0x4],RAX
MOV RAX,qword ptr [RBX + 0x30]
MOV qword ptr [R14 + 0x58],RAX
MOV AL,byte ptr [RBX + 0x98]
XOR AL,0x1
MOV byte ptr [R14 + 0x62],AL
MOV AL,byte ptr [RBX + 0x99]
MOV byte ptr [R14 + 0x63],AL
MOV AL,byte ptr [RBX + 0xb9]
MOV byte ptr [R14 + 0x61],AL
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* cmd_params_instance::to_llama_cparams() const */
void cmd_params_instance::to_llama_cparams(void)
{
long in_RSI;
int *in_RDI;
llama_context_default_params();
*in_RDI = *(int *)(in_RSI + 0x24) + *(int *)(in_RSI + 0x20);
*(int8 *)(in_RDI + 1) = *(int8 *)(in_RSI + 0x28);
*(int8 *)(in_RDI + 0x16) = *(int8 *)(in_RSI + 0x30);
*(byte *)((long)in_RDI + 0x62) = *(byte *)(in_RSI + 0x98) ^ 1;
*(int1 *)((long)in_RDI + 99) = *(int1 *)(in_RSI + 0x99);
*(int1 *)((long)in_RDI + 0x61) = *(int1 *)(in_RSI + 0xb9);
return;
}
|
|
60,696
|
my_hash_sort_simple
|
eloqsql/strings/ctype-simple.c
|
void my_hash_sort_simple(CHARSET_INFO *cs,
const uchar *key, size_t len,
ulong *nr1, ulong *nr2)
{
register const uchar *sort_order=cs->sort_order;
const uchar *end;
uint16 space_weight= sort_order[' '];
/*
Remove all trailing characters that are equal to space.
We have to do this to be able to compare 'A ' and 'A' as identical.
If the key is long enough, cut the trailing spaces (0x20) using an
optimized function implemented in skip_trailing_spaces().
"len > 16" is just some heuristic here.
Calling skip_triling_space() for short values is not desirable,
because its initialization block may be more expensive than the
performance gained.
*/
end= len > 16 ? skip_trailing_space(key, len) : key + len;
/*
We removed all trailing characters that are binary equal to space 0x20.
Now remove all trailing characters that have weights equal to space.
Some 8bit simple collations may have such characters:
- cp1250_general_ci 0xA0 NO-BREAK SPACE == 0x20 SPACE
- cp1251_ukrainian_ci 0x60 GRAVE ACCENT == 0x20 SPACE
- koi8u_general_ci 0x60 GRAVE ACCENT == 0x20 SPACE
*/
for ( ; key < end ; )
{
if (sort_order[*--end] != space_weight)
{
end++;
break;
}
}
my_hash_sort_simple_nopad(cs, key, end - key, nr1, nr2);
}
|
O0
|
c
|
my_hash_sort_simple:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movzbl 0x20(%rax), %eax
movw %ax, -0x3a(%rbp)
cmpq $0x10, -0x18(%rbp)
jbe 0x7924e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x792d0
movq %rax, -0x48(%rbp)
jmp 0x7925a
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x7929f
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, %rdx
addq $-0x1, %rdx
movq %rdx, -0x38(%rbp)
movzbl -0x1(%rcx), %ecx
movzbl (%rax,%rcx), %eax
movzwl -0x3a(%rbp), %ecx
cmpl %ecx, %eax
je 0x7929d
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x7929f
jmp 0x79262
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x10(%rbp), %rax
subq %rax, %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x79140
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_hash_sort_simple:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_8]
mov rax, [rax+58h]
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
movzx eax, byte ptr [rax+20h]
mov [rbp+var_3A], ax
cmp [rbp+var_18], 10h
jbe short loc_7924E
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call skip_trailing_space_2
mov [rbp+var_48], rax
jmp short loc_7925A
loc_7924E:
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_48], rax
loc_7925A:
mov rax, [rbp+var_48]
mov [rbp+var_38], rax
loc_79262:
mov rax, [rbp+var_10]
cmp rax, [rbp+var_38]
jnb short loc_7929F
mov rax, [rbp+var_30]
mov rcx, [rbp+var_38]
mov rdx, rcx
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_38], rdx
movzx ecx, byte ptr [rcx-1]
movzx eax, byte ptr [rax+rcx]
movzx ecx, [rbp+var_3A]
cmp eax, ecx
jz short loc_7929D
mov rax, [rbp+var_38]
add rax, 1
mov [rbp+var_38], rax
jmp short loc_7929F
loc_7929D:
jmp short loc_79262
loc_7929F:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_38]
mov rax, [rbp+var_10]
sub rdx, rax
mov rcx, [rbp+var_20]
mov r8, [rbp+var_28]
call my_hash_sort_simple_nopad
add rsp, 50h
pop rbp
retn
|
_QWORD * my_hash_sort_simple(long long a1, unsigned __int8 *a2, unsigned long long a3, long long *a4, _QWORD *a5)
{
unsigned long long v5; // rcx
long long v7; // [rsp+8h] [rbp-48h]
__int16 v8; // [rsp+16h] [rbp-3Ah]
unsigned long long v9; // [rsp+18h] [rbp-38h]
long long v10; // [rsp+20h] [rbp-30h]
v10 = *(_QWORD *)(a1 + 88);
v8 = *(unsigned __int8 *)(v10 + 32);
if ( a3 <= 0x10 )
v7 = (long long)&a2[a3];
else
v7 = skip_trailing_space_2(a2, a3);
v9 = v7;
while ( (unsigned long long)a2 < v9 )
{
v5 = v9--;
if ( *(unsigned __int8 *)(v10 + *(unsigned __int8 *)(v5 - 1)) != v8 )
return my_hash_sort_simple_nopad(a1, a2, ++v9 - (_QWORD)a2, a4, a5);
}
return my_hash_sort_simple_nopad(a1, a2, v9 - (_QWORD)a2, a4, a5);
}
|
my_hash_sort_simple:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x58]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,byte ptr [RAX + 0x20]
MOV word ptr [RBP + -0x3a],AX
CMP qword ptr [RBP + -0x18],0x10
JBE 0x0017924e
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x001792d0
MOV qword ptr [RBP + -0x48],RAX
JMP 0x0017925a
LAB_0017924e:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x48],RAX
LAB_0017925a:
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x38],RAX
LAB_00179262:
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x38]
JNC 0x0017929f
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x38]
MOV RDX,RCX
ADD RDX,-0x1
MOV qword ptr [RBP + -0x38],RDX
MOVZX ECX,byte ptr [RCX + -0x1]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOVZX ECX,word ptr [RBP + -0x3a]
CMP EAX,ECX
JZ 0x0017929d
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x1
MOV qword ptr [RBP + -0x38],RAX
JMP 0x0017929f
LAB_0017929d:
JMP 0x00179262
LAB_0017929f:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x10]
SUB RDX,RAX
MOV RCX,qword ptr [RBP + -0x20]
MOV R8,qword ptr [RBP + -0x28]
CALL 0x00179140
ADD RSP,0x50
POP RBP
RET
|
void my_hash_sort_simple(long param_1,ulong param_2,ulong param_3,int8 param_4,
int8 param_5)
{
char cVar1;
long lVar2;
ulong uVar3;
ulong local_50;
ulong local_40;
lVar2 = *(long *)(param_1 + 0x58);
cVar1 = *(char *)(lVar2 + 0x20);
if (param_3 < 0x11) {
local_50 = param_2 + param_3;
}
else {
local_50 = skip_trailing_space(param_2,param_3);
}
local_40 = local_50;
uVar3 = local_40;
do {
local_40 = uVar3;
if (local_40 <= param_2) break;
uVar3 = local_40 - 1;
} while (*(char *)(lVar2 + (ulong)*(byte *)(local_40 - 1)) == cVar1);
my_hash_sort_simple_nopad(param_1,param_2,local_40 - param_2,param_4,param_5);
return;
}
|
|
60,697
|
testing::Test::IsSkipped()
|
seiftnesse[P]memoryallocator/build_O1/_deps/googletest-src/googletest/src/gtest.cc
|
bool Test::IsSkipped() {
return internal::GetUnitTestImpl()->current_test_result()->Skipped();
}
|
O1
|
cpp
|
testing::Test::IsSkipped():
pushq %rax
callq 0x1d29e
movq 0x41392e7(%rip), %rax # 0x415df60
movq 0x170(%rax), %rdi
testq %rdi, %rdi
je 0x24c8e
addq $0x90, %rdi
jmp 0x24cac
movq 0x168(%rax), %rdi
testq %rdi, %rdi
je 0x24ca3
addq $0x88, %rdi
jmp 0x24cac
addq $0x178, %rax # imm = 0x178
movq %rax, %rdi
popq %rax
jmp 0x2417c
|
_ZN7testing4Test9IsSkippedEv:
push rax
call _ZN7testing8UnitTest11GetInstanceEv; testing::UnitTest::GetInstance(void)
mov rax, cs:qword_415DF60
mov rdi, [rax+170h]
test rdi, rdi
jz short loc_24C8E
add rdi, 90h
jmp short loc_24CAC
loc_24C8E:
mov rdi, [rax+168h]
test rdi, rdi
jz short loc_24CA3
add rdi, 88h
jmp short loc_24CAC
loc_24CA3:
add rax, 178h
mov rdi, rax; this
loc_24CAC:
pop rax
jmp _ZNK7testing10TestResult7SkippedEv; testing::TestResult::Skipped(void)
|
char testing::Test::IsSkipped(testing::Test *this)
{
long long v1; // rdi
long long v3; // rdi
testing::UnitTest::GetInstance(this);
v1 = *((_QWORD *)qword_415DF60 + 46);
if ( v1 )
return testing::TestResult::Skipped((testing::TestResult *)(v1 + 144));
v3 = *((_QWORD *)qword_415DF60 + 45);
if ( v3 )
return testing::TestResult::Skipped((testing::TestResult *)(v3 + 136));
else
return testing::TestResult::Skipped((testing::internal::UnitTestImpl *)((char *)qword_415DF60 + 376));
}
|
IsSkipped:
PUSH RAX
CALL 0x0011d29e
MOV RAX,qword ptr [0x0425df60]
MOV RDI,qword ptr [RAX + 0x170]
TEST RDI,RDI
JZ 0x00124c8e
ADD RDI,0x90
JMP 0x00124cac
LAB_00124c8e:
MOV RDI,qword ptr [RAX + 0x168]
TEST RDI,RDI
JZ 0x00124ca3
ADD RDI,0x88
JMP 0x00124cac
LAB_00124ca3:
ADD RAX,0x178
MOV RDI,RAX
LAB_00124cac:
POP RAX
JMP 0x0012417c
|
/* testing::Test::IsSkipped() */
void testing::Test::IsSkipped(void)
{
TestResult *this;
UnitTest::GetInstance();
if (*(long *)(UnitTest::GetInstance()::instance._64_8_ + 0x170) == 0) {
if (*(long *)(UnitTest::GetInstance()::instance._64_8_ + 0x168) == 0) {
this = (TestResult *)(UnitTest::GetInstance()::instance._64_8_ + 0x178);
}
else {
this = (TestResult *)(*(long *)(UnitTest::GetInstance()::instance._64_8_ + 0x168) + 0x88);
}
}
else {
this = (TestResult *)(*(long *)(UnitTest::GetInstance()::instance._64_8_ + 0x170) + 0x90);
}
TestResult::Skipped(this);
return;
}
|
|
60,698
|
ma_ft_segiterator_init
|
eloqsql/storage/maria/ma_ft_update.c
|
void _ma_ft_segiterator_init(MARIA_HA *info, uint keynr, const uchar *record,
FT_SEG_ITERATOR *ftsi)
{
DBUG_ENTER("_ma_ft_segiterator_init");
ftsi->num=info->s->keyinfo[keynr].keysegs;
ftsi->seg=info->s->keyinfo[keynr].seg;
ftsi->rec=record;
ftsi->pos= 0; /* Avoid warnings from gcc */
ftsi->len= 0; /* Avoid warnings from gcc */
DBUG_VOID_RETURN;
}
|
O0
|
c
|
ma_ft_segiterator_init:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x570(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x118, %rcx, %rcx # imm = 0x118
addq %rcx, %rax
movzwl 0xa0(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x570(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x118, %rcx, %rcx # imm = 0x118
addq %rcx, %rax
movq 0xc0(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x4(%rax)
jmp 0x8beca
popq %rbp
retq
nopl (%rax)
|
_ma_ft_segiterator_init:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov rax, [rbp+var_8]
mov rax, [rax]
mov rax, [rax+570h]
mov ecx, [rbp+var_C]
imul rcx, 118h
add rax, rcx
movzx ecx, word ptr [rax+0A0h]
mov rax, [rbp+var_20]
mov [rax], ecx
mov rax, [rbp+var_8]
mov rax, [rax]
mov rax, [rax+570h]
mov ecx, [rbp+var_C]
imul rcx, 118h
add rax, rcx
mov rcx, [rax+0C0h]
mov rax, [rbp+var_20]
mov [rax+8], rcx
mov rcx, [rbp+var_18]
mov rax, [rbp+var_20]
mov [rax+10h], rcx
mov rax, [rbp+var_20]
mov qword ptr [rax+18h], 0
mov rax, [rbp+var_20]
mov dword ptr [rax+4], 0
jmp short $+2
loc_8BECA:
pop rbp
retn
|
long long ma_ft_segiterator_init(long long a1, unsigned int a2, long long a3, long long a4)
{
long long result; // rax
*(_DWORD *)a4 = *(unsigned __int16 *)(280LL * a2 + *(_QWORD *)(*(_QWORD *)a1 + 1392LL) + 160);
*(_QWORD *)(a4 + 8) = *(_QWORD *)(280LL * a2 + *(_QWORD *)(*(_QWORD *)a1 + 1392LL) + 192);
*(_QWORD *)(a4 + 16) = a3;
*(_QWORD *)(a4 + 24) = 0LL;
result = a4;
*(_DWORD *)(a4 + 4) = 0;
return result;
}
|
_ma_ft_segiterator_init:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x570]
MOV ECX,dword ptr [RBP + -0xc]
IMUL RCX,RCX,0x118
ADD RAX,RCX
MOVZX ECX,word ptr [RAX + 0xa0]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x570]
MOV ECX,dword ptr [RBP + -0xc]
IMUL RCX,RCX,0x118
ADD RAX,RCX
MOV RCX,qword ptr [RAX + 0xc0]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x8],RCX
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x18],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x4],0x0
JMP 0x0018beca
LAB_0018beca:
POP RBP
RET
|
void _ma_ft_segiterator_init(long *param_1,uint param_2,int8 param_3,uint *param_4)
{
*param_4 = (uint)*(ushort *)(*(long *)(*param_1 + 0x570) + (ulong)param_2 * 0x118 + 0xa0);
*(int8 *)(param_4 + 2) =
*(int8 *)(*(long *)(*param_1 + 0x570) + (ulong)param_2 * 0x118 + 0xc0);
*(int8 *)(param_4 + 4) = param_3;
param_4[6] = 0;
param_4[7] = 0;
param_4[1] = 0;
return;
}
|
|
60,699
|
ma_ft_segiterator_init
|
eloqsql/storage/maria/ma_ft_update.c
|
void _ma_ft_segiterator_init(MARIA_HA *info, uint keynr, const uchar *record,
FT_SEG_ITERATOR *ftsi)
{
DBUG_ENTER("_ma_ft_segiterator_init");
ftsi->num=info->s->keyinfo[keynr].keysegs;
ftsi->seg=info->s->keyinfo[keynr].seg;
ftsi->rec=record;
ftsi->pos= 0; /* Avoid warnings from gcc */
ftsi->len= 0; /* Avoid warnings from gcc */
DBUG_VOID_RETURN;
}
|
O3
|
c
|
ma_ft_segiterator_init:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movq 0x570(%rax), %rax
movl %esi, %esi
imulq $0x118, %rsi, %rsi # imm = 0x118
movzwl 0xa0(%rax,%rsi), %eax
movl %eax, (%rcx)
movq (%rdi), %rax
movq 0x570(%rax), %rax
movq 0xc0(%rax,%rsi), %rax
movq %rax, 0x8(%rcx)
movq %rdx, 0x10(%rcx)
movq $0x0, 0x18(%rcx)
movl $0x0, 0x4(%rcx)
popq %rbp
retq
|
_ma_ft_segiterator_init:
push rbp
mov rbp, rsp
mov rax, [rdi]
mov rax, [rax+570h]
mov esi, esi
imul rsi, 118h
movzx eax, word ptr [rax+rsi+0A0h]
mov [rcx], eax
mov rax, [rdi]
mov rax, [rax+570h]
mov rax, [rax+rsi+0C0h]
mov [rcx+8], rax
mov [rcx+10h], rdx
mov qword ptr [rcx+18h], 0
mov dword ptr [rcx+4], 0
pop rbp
retn
|
long long ma_ft_segiterator_init(long long a1, unsigned int a2, long long a3, long long a4)
{
long long v4; // rsi
long long result; // rax
v4 = 280LL * a2;
*(_DWORD *)a4 = *(unsigned __int16 *)(*(_QWORD *)(*(_QWORD *)a1 + 1392LL) + v4 + 160);
result = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)a1 + 1392LL) + v4 + 192);
*(_QWORD *)(a4 + 8) = result;
*(_QWORD *)(a4 + 16) = a3;
*(_QWORD *)(a4 + 24) = 0LL;
*(_DWORD *)(a4 + 4) = 0;
return result;
}
|
_ma_ft_segiterator_init:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x570]
MOV ESI,ESI
IMUL RSI,RSI,0x118
MOVZX EAX,word ptr [RAX + RSI*0x1 + 0xa0]
MOV dword ptr [RCX],EAX
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x570]
MOV RAX,qword ptr [RAX + RSI*0x1 + 0xc0]
MOV qword ptr [RCX + 0x8],RAX
MOV qword ptr [RCX + 0x10],RDX
MOV qword ptr [RCX + 0x18],0x0
MOV dword ptr [RCX + 0x4],0x0
POP RBP
RET
|
void _ma_ft_segiterator_init(long *param_1,uint param_2,int8 param_3,uint *param_4)
{
*param_4 = (uint)*(ushort *)(*(long *)(*param_1 + 0x570) + 0xa0 + (ulong)param_2 * 0x118);
*(int8 *)(param_4 + 2) =
*(int8 *)(*(long *)(*param_1 + 0x570) + 0xc0 + (ulong)param_2 * 0x118);
*(int8 *)(param_4 + 4) = param_3;
param_4[6] = 0;
param_4[7] = 0;
param_4[1] = 0;
return;
}
|
Subsets and Splits
C++ Functions Using STL
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++ STL Function Queries
Filters C++ code examples that use standard library containers and algorithms, helping identify common programming patterns and library usage in code generation tasks.
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.