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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
11,700 |
LefDefParser::defiPath::addViaRect(int, int, int, int)
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defiPath.cpp
|
void defiPath::addViaRect(int deltaX1, int deltaY1, int deltaX2, int deltaY2) {
if (numUsed_ == numAllocated_)
bumpSize(numAllocated_ * 2);
keys_[numUsed_] = 'E'; // RECT
data_[numUsed_] = malloc(sizeof(struct defiViaRect));
((struct defiViaRect*)(data_[numUsed_]))->deltaX1 = deltaX1;
((struct defiViaRect*)(data_[numUsed_]))->deltaY1 = deltaY1;
((struct defiViaRect*)(data_[numUsed_]))->deltaX2 = deltaX2;
((struct defiViaRect*)(data_[numUsed_]))->deltaY2 = deltaY2;
(numUsed_)++;
}
|
O0
|
cpp
|
LefDefParser::defiPath::addViaRect(int, int, int, int):
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movl %r8d, 0x10(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movl 0x10(%rcx), %eax
cmpl 0x14(%rcx), %eax
jne 0x186fb
movq 0x8(%rsp), %rdi
movl 0x14(%rdi), %esi
shll %esi
callq 0x179b0
movq 0x8(%rsp), %rcx
movq (%rcx), %rax
movslq 0x10(%rcx), %rcx
movl $0x45, (%rax,%rcx,4)
movl $0x10, %edi
callq 0x72d0
movq %rax, %rsi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movslq 0x10(%rax), %rdx
movq %rsi, (%rcx,%rdx,8)
movl 0x1c(%rsp), %edx
movq 0x8(%rax), %rcx
movslq 0x10(%rax), %rsi
movq (%rcx,%rsi,8), %rcx
movl %edx, (%rcx)
movl 0x18(%rsp), %edx
movq 0x8(%rax), %rcx
movslq 0x10(%rax), %rsi
movq (%rcx,%rsi,8), %rcx
movl %edx, 0x4(%rcx)
movl 0x14(%rsp), %edx
movq 0x8(%rax), %rcx
movslq 0x10(%rax), %rsi
movq (%rcx,%rsi,8), %rcx
movl %edx, 0x8(%rcx)
movl 0x10(%rsp), %edx
movq 0x8(%rax), %rcx
movslq 0x10(%rax), %rsi
movq (%rcx,%rsi,8), %rcx
movl %edx, 0xc(%rcx)
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
|
_ZN12LefDefParser8defiPath10addViaRectEiiii:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov [rsp+28h+var_C], esi
mov [rsp+28h+var_10], edx
mov [rsp+28h+var_14], ecx
mov [rsp+28h+var_18], r8d
mov rcx, [rsp+28h+var_8]
mov [rsp+28h+var_20], rcx
mov eax, [rcx+10h]
cmp eax, [rcx+14h]
jnz short loc_186FB
mov rdi, [rsp+28h+var_20]; this
mov esi, [rdi+14h]
shl esi, 1; int
call _ZN12LefDefParser8defiPath8bumpSizeEi; LefDefParser::defiPath::bumpSize(int)
loc_186FB:
mov rcx, [rsp+28h+var_20]
mov rax, [rcx]
movsxd rcx, dword ptr [rcx+10h]
mov dword ptr [rax+rcx*4], 45h ; 'E'
mov edi, 10h
call _malloc
mov rsi, rax
mov rax, [rsp+28h+var_20]
mov rcx, [rax+8]
movsxd rdx, dword ptr [rax+10h]
mov [rcx+rdx*8], rsi
mov edx, [rsp+28h+var_C]
mov rcx, [rax+8]
movsxd rsi, dword ptr [rax+10h]
mov rcx, [rcx+rsi*8]
mov [rcx], edx
mov edx, [rsp+28h+var_10]
mov rcx, [rax+8]
movsxd rsi, dword ptr [rax+10h]
mov rcx, [rcx+rsi*8]
mov [rcx+4], edx
mov edx, [rsp+28h+var_14]
mov rcx, [rax+8]
movsxd rsi, dword ptr [rax+10h]
mov rcx, [rcx+rsi*8]
mov [rcx+8], edx
mov edx, [rsp+28h+var_18]
mov rcx, [rax+8]
movsxd rsi, dword ptr [rax+10h]
mov rcx, [rcx+rsi*8]
mov [rcx+0Ch], edx
mov ecx, [rax+10h]
add ecx, 1
mov [rax+10h], ecx
add rsp, 28h
retn
|
LefDefParser::defiPath * LefDefParser::defiPath::addViaRect(
LefDefParser::defiPath *this,
int a2,
int a3,
int a4,
int a5)
{
long long v5; // rsi
LefDefParser::defiPath *result; // rax
if ( *((_DWORD *)this + 4) == *((_DWORD *)this + 5) )
LefDefParser::defiPath::bumpSize(this, 2 * *((_DWORD *)this + 5));
*(_DWORD *)(*(_QWORD *)this + 4LL * *((int *)this + 4)) = 69;
v5 = malloc(16LL);
result = this;
*(_QWORD *)(*((_QWORD *)this + 1) + 8LL * *((int *)this + 4)) = v5;
**(_DWORD **)(*((_QWORD *)this + 1) + 8LL * *((int *)this + 4)) = a2;
*(_DWORD *)(*(_QWORD *)(*((_QWORD *)this + 1) + 8LL * *((int *)this + 4)) + 4LL) = a3;
*(_DWORD *)(*(_QWORD *)(*((_QWORD *)this + 1) + 8LL * *((int *)this + 4)) + 8LL) = a4;
*(_DWORD *)(*(_QWORD *)(*((_QWORD *)this + 1) + 8LL * (int)(*((_DWORD *)this + 4))++) + 12LL) = a5;
return result;
}
|
addViaRect:
SUB RSP,0x28
MOV qword ptr [RSP + 0x20],RDI
MOV dword ptr [RSP + 0x1c],ESI
MOV dword ptr [RSP + 0x18],EDX
MOV dword ptr [RSP + 0x14],ECX
MOV dword ptr [RSP + 0x10],R8D
MOV RCX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x8],RCX
MOV EAX,dword ptr [RCX + 0x10]
CMP EAX,dword ptr [RCX + 0x14]
JNZ 0x001186fb
MOV RDI,qword ptr [RSP + 0x8]
MOV ESI,dword ptr [RDI + 0x14]
SHL ESI,0x1
CALL 0x001179b0
LAB_001186fb:
MOV RCX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RCX]
MOVSXD RCX,dword ptr [RCX + 0x10]
MOV dword ptr [RAX + RCX*0x4],0x45
MOV EDI,0x10
CALL 0x001072d0
MOV RSI,RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RAX + 0x8]
MOVSXD RDX,dword ptr [RAX + 0x10]
MOV qword ptr [RCX + RDX*0x8],RSI
MOV EDX,dword ptr [RSP + 0x1c]
MOV RCX,qword ptr [RAX + 0x8]
MOVSXD RSI,dword ptr [RAX + 0x10]
MOV RCX,qword ptr [RCX + RSI*0x8]
MOV dword ptr [RCX],EDX
MOV EDX,dword ptr [RSP + 0x18]
MOV RCX,qword ptr [RAX + 0x8]
MOVSXD RSI,dword ptr [RAX + 0x10]
MOV RCX,qword ptr [RCX + RSI*0x8]
MOV dword ptr [RCX + 0x4],EDX
MOV EDX,dword ptr [RSP + 0x14]
MOV RCX,qword ptr [RAX + 0x8]
MOVSXD RSI,dword ptr [RAX + 0x10]
MOV RCX,qword ptr [RCX + RSI*0x8]
MOV dword ptr [RCX + 0x8],EDX
MOV EDX,dword ptr [RSP + 0x10]
MOV RCX,qword ptr [RAX + 0x8]
MOVSXD RSI,dword ptr [RAX + 0x10]
MOV RCX,qword ptr [RCX + RSI*0x8]
MOV dword ptr [RCX + 0xc],EDX
MOV ECX,dword ptr [RAX + 0x10]
ADD ECX,0x1
MOV dword ptr [RAX + 0x10],ECX
ADD RSP,0x28
RET
|
/* LefDefParser::defiPath::addViaRect(int, int, int, int) */
void __thiscall
LefDefParser::defiPath::addViaRect(defiPath *this,int param_1,int param_2,int param_3,int param_4)
{
void *pvVar1;
if (*(int *)(this + 0x10) == *(int *)(this + 0x14)) {
bumpSize(this,*(int *)(this + 0x14) << 1);
}
*(int4 *)(*(long *)this + (long)*(int *)(this + 0x10) * 4) = 0x45;
pvVar1 = malloc(0x10);
*(void **)(*(long *)(this + 8) + (long)*(int *)(this + 0x10) * 8) = pvVar1;
**(int **)(*(long *)(this + 8) + (long)*(int *)(this + 0x10) * 8) = param_1;
*(int *)(*(long *)(*(long *)(this + 8) + (long)*(int *)(this + 0x10) * 8) + 4) = param_2;
*(int *)(*(long *)(*(long *)(this + 8) + (long)*(int *)(this + 0x10) * 8) + 8) = param_3;
*(int *)(*(long *)(*(long *)(this + 8) + (long)*(int *)(this + 0x10) * 8) + 0xc) = param_4;
*(int *)(this + 0x10) = *(int *)(this + 0x10) + 1;
return;
}
|
|
11,701 |
add_directory
|
eloqsql/mysys/my_default.c
|
static int add_directory(MEM_ROOT *alloc, const char *dir, const char **dirs)
{
char buf[FN_REFLEN];
size_t len;
char *p;
my_bool err __attribute__((unused));
len= normalize_dirname(buf, dir);
if (!(p= strmake_root(alloc, buf, len)))
return 1; /* Failure */
/* Should never fail if DEFAULT_DIRS_SIZE is correct size */
err= array_append_string_unique(p, dirs, DEFAULT_DIRS_SIZE);
DBUG_ASSERT(err == FALSE);
return 0;
}
|
O3
|
c
|
add_directory:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movq %rdx, %rbx
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, -0x20(%rbp)
leaq -0x220(%rbp), %r15
movq %r15, %rdi
callq 0x35247
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x36501
testq %rax, %rax
je 0x34667
movl $0x8, %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x35d48
xorl %eax, %eax
jmp 0x3466c
movl $0x1, %eax
movq %fs:0x28, %rcx
cmpq -0x20(%rbp), %rcx
jne 0x34689
addq $0x208, %rsp # imm = 0x208
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x243e0
nop
|
add_directory:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 208h
mov rbx, rdx
mov r14, rdi
mov rax, fs:28h
mov [rbp+var_20], rax
lea r15, [rbp+var_220]
mov rdi, r15
call normalize_dirname
mov rdi, r14
mov rsi, r15
mov rdx, rax
call strmake_root
test rax, rax
jz short loc_34667
mov edx, 8
mov rdi, rax
mov rsi, rbx
call array_append_string_unique
xor eax, eax
jmp short loc_3466C
loc_34667:
mov eax, 1
loc_3466C:
mov rcx, fs:28h
cmp rcx, [rbp+var_20]
jnz short loc_34689
add rsp, 208h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_34689:
call ___stack_chk_fail
|
long long add_directory(long long a1, long long a2, long long a3)
{
long long v4; // rax
long long v5; // rax
_BYTE v7[512]; // [rsp+0h] [rbp-220h] BYREF
unsigned long long v8; // [rsp+200h] [rbp-20h]
v8 = __readfsqword(0x28u);
v4 = normalize_dirname(v7);
v5 = strmake_root(a1, v7, v4);
if ( !v5 )
return 1LL;
array_append_string_unique(v5, a3, 8LL);
return 0LL;
}
|
add_directory:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x208
MOV RBX,RDX
MOV R14,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x20],RAX
LEA R15,[RBP + -0x220]
MOV RDI,R15
CALL 0x00135247
MOV RDI,R14
MOV RSI,R15
MOV RDX,RAX
CALL 0x00136501
TEST RAX,RAX
JZ 0x00134667
MOV EDX,0x8
MOV RDI,RAX
MOV RSI,RBX
CALL 0x00135d48
XOR EAX,EAX
JMP 0x0013466c
LAB_00134667:
MOV EAX,0x1
LAB_0013466c:
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x20]
JNZ 0x00134689
ADD RSP,0x208
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00134689:
CALL 0x001243e0
|
bool add_directory(int8 param_1,int8 param_2,int8 param_3)
{
int8 uVar1;
long lVar2;
long in_FS_OFFSET;
int1 local_228 [512];
long local_28;
local_28 = *(long *)(in_FS_OFFSET + 0x28);
uVar1 = normalize_dirname(local_228);
lVar2 = strmake_root(param_1,local_228,uVar1);
if (lVar2 != 0) {
array_append_string_unique(lVar2,param_3,8);
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_28) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return lVar2 == 0;
}
|
|
11,702 |
ma_crypt_data_post_read_hook
|
eloqsql/storage/maria/ma_crypt.c
|
static my_bool ma_crypt_data_post_read_hook(int res,
PAGECACHE_IO_HOOK_ARGS *args)
{
MARIA_SHARE *share= (MARIA_SHARE*) args->data;
const uint size= share->block_size;
const uchar page_type= args->page[PAGE_TYPE_OFFSET] & PAGE_TYPE_MASK;
const uint32 key_version_offset= (page_type <= TAIL_PAGE) ?
KEY_VERSION_OFFSET : FULL_PAGE_KEY_VERSION_OFFSET;
if (res == 0)
{
const uchar *src= args->page;
uchar* dst= args->crypt_buf;
uint pageno= (uint)args->pageno;
LSN lsn= lsn_korr(src);
const uint head= (page_type <= TAIL_PAGE) ?
PAGE_HEADER_SIZE(share) : FULL_PAGE_HEADER_SIZE(share);
const uint tail= CRC_SIZE;
const uint32 key_version= uint4korr(src + key_version_offset);
/* 1 - copy head */
memcpy(dst, src, head);
/* 2 - decrypt page */
res= ma_decrypt(share, share->crypt_data,
src + head, dst + head, size - (head + tail), pageno, lsn,
key_version);
/* 3 - copy tail */
memcpy(dst + size - tail, src + size - tail, tail);
/* 4 clear key version to get correct crc */
int4store(dst + key_version_offset, 0);
}
if (args->crypt_buf != NULL)
{
uchar *tmp= args->page;
args->page= args->crypt_buf;
args->crypt_buf= NULL;
my_free(tmp);
}
return maria_page_crc_check_data(res, args);
}
|
O0
|
c
|
ma_crypt_data_post_read_hook:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x7bc(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl 0x7(%rax), %eax
andl $0x7, %eax
movb %al, -0x1d(%rbp)
movzbl -0x1d(%rbp), %edx
movl $0x8, %eax
movl $0xc, %ecx
cmpl $0x2, %edx
cmovlel %ecx, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0xc3fa6
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, -0x3c(%rbp)
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
movq -0x30(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x30(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl %eax, %eax
shlq $0x20, %rax
movq -0x30(%rbp), %rcx
movl 0x3(%rcx), %ecx
orq %rcx, %rax
movq %rax, -0x48(%rbp)
movzbl -0x1d(%rbp), %eax
cmpl $0x2, %eax
jg 0xc3eef
movq -0x18(%rbp), %rax
movl 0xc18(%rax), %eax
addl $0xc, %eax
movl %eax, -0x6c(%rbp)
jmp 0xc3eff
movq -0x18(%rbp), %rax
movl 0xc18(%rax), %eax
addl $0x8, %eax
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movl %eax, -0x4c(%rbp)
movl $0x4, -0x50(%rbp)
movq -0x30(%rbp), %rax
movl -0x24(%rbp), %ecx
movl (%rax,%rcx), %eax
movl %eax, -0x54(%rbp)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x4c(%rbp), %eax
movl %eax, %edx
callq 0x2c0c0
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0xc20(%rax), %rsi
movq -0x30(%rbp), %rdx
movl -0x4c(%rbp), %eax
addq %rax, %rdx
movq -0x38(%rbp), %rcx
movl -0x4c(%rbp), %eax
addq %rax, %rcx
movl -0x1c(%rbp), %r8d
movl -0x4c(%rbp), %eax
addl $0x4, %eax
subl %eax, %r8d
movl -0x3c(%rbp), %r9d
movq -0x48(%rbp), %r10
movl -0x54(%rbp), %eax
movq %r10, (%rsp)
movl %eax, 0x8(%rsp)
callq 0xc4780
movl %eax, -0x4(%rbp)
movq -0x38(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq -0x30(%rbp), %rdx
movl -0x1c(%rbp), %esi
movl -0x4(%rdx,%rsi), %edx
movl %edx, -0x4(%rax,%rcx)
movq -0x38(%rbp), %rax
movl -0x24(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movl $0x0, (%rax)
jmp 0xc3fa6
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xc3fe0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x68(%rbp), %rdi
callq 0x126ac0
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0xc2a30
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
ma_crypt_data_post_read_hook:
push rbp
mov rbp, rsp
sub rsp, 80h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
mov rax, [rax+10h]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov eax, [rax+7BCh]
mov [rbp+var_1C], eax
mov rax, [rbp+var_10]
mov rax, [rax]
movzx eax, byte ptr [rax+7]
and eax, 7
mov [rbp+var_1D], al
movzx edx, [rbp+var_1D]
mov eax, 8
mov ecx, 0Ch
cmp edx, 2
cmovle eax, ecx
mov [rbp+var_24], eax
cmp [rbp+var_4], 0
jnz loc_C3FA6
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_30], rax
mov rax, [rbp+var_10]
mov rax, [rax+18h]
mov [rbp+var_38], rax
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rbp+var_3C], eax
mov rax, [rbp+var_30]
movzx eax, byte ptr [rax]
mov rcx, [rbp+var_30]
movzx ecx, byte ptr [rcx+1]
shl ecx, 8
or eax, ecx
mov rcx, [rbp+var_30]
movzx ecx, byte ptr [rcx+2]
shl ecx, 10h
or eax, ecx
mov eax, eax
shl rax, 20h
mov rcx, [rbp+var_30]
mov ecx, [rcx+3]
or rax, rcx
mov [rbp+var_48], rax
movzx eax, [rbp+var_1D]
cmp eax, 2
jg short loc_C3EEF
mov rax, [rbp+var_18]
mov eax, [rax+0C18h]
add eax, 0Ch
mov [rbp+var_6C], eax
jmp short loc_C3EFF
loc_C3EEF:
mov rax, [rbp+var_18]
mov eax, [rax+0C18h]
add eax, 8
mov [rbp+var_6C], eax
loc_C3EFF:
mov eax, [rbp+var_6C]
mov [rbp+var_4C], eax
mov [rbp+var_50], 4
mov rax, [rbp+var_30]
mov ecx, [rbp+var_24]
mov eax, [rax+rcx]
mov [rbp+var_54], eax
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_30]
mov eax, [rbp+var_4C]
mov edx, eax
call _memcpy
mov rdi, [rbp+var_18]
mov rax, [rbp+var_18]
mov rsi, [rax+0C20h]
mov rdx, [rbp+var_30]
mov eax, [rbp+var_4C]
add rdx, rax
mov rcx, [rbp+var_38]
mov eax, [rbp+var_4C]
add rcx, rax
mov r8d, [rbp+var_1C]
mov eax, [rbp+var_4C]
add eax, 4
sub r8d, eax
mov r9d, [rbp+var_3C]
mov r10, [rbp+var_48]
mov eax, [rbp+var_54]
mov [rsp+80h+var_80], r10
mov [rsp+80h+var_78], eax
call ma_decrypt
mov [rbp+var_4], eax
mov rax, [rbp+var_38]
mov ecx, [rbp+var_1C]
mov rdx, [rbp+var_30]
mov esi, [rbp+var_1C]
mov edx, [rdx+rsi-4]
mov [rax+rcx-4], edx
mov rax, [rbp+var_38]
mov ecx, [rbp+var_24]
add rax, rcx
mov [rbp+var_60], rax
mov rax, [rbp+var_60]
mov dword ptr [rax], 0
jmp short $+2
loc_C3FA6:
mov rax, [rbp+var_10]
cmp qword ptr [rax+18h], 0
jz short loc_C3FE0
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_68], rax
mov rax, [rbp+var_10]
mov rcx, [rax+18h]
mov rax, [rbp+var_10]
mov [rax], rcx
mov rax, [rbp+var_10]
mov qword ptr [rax+18h], 0
mov rdi, [rbp+var_68]
call my_free
loc_C3FE0:
mov edi, [rbp+var_4]
mov rsi, [rbp+var_10]
call maria_page_crc_check_data
add rsp, 80h
pop rbp
retn
|
bool ma_crypt_data_post_read_hook(int a1, _QWORD *a2)
{
int v2; // eax
unsigned int v3; // eax
long long v5; // [rsp+18h] [rbp-68h]
int v6; // [rsp+2Ch] [rbp-54h]
unsigned int v7; // [rsp+34h] [rbp-4Ch]
unsigned long long v8; // [rsp+38h] [rbp-48h]
int v9; // [rsp+44h] [rbp-3Ch]
long long v10; // [rsp+48h] [rbp-38h]
unsigned __int16 *v11; // [rsp+50h] [rbp-30h]
unsigned int v12; // [rsp+5Ch] [rbp-24h]
unsigned __int8 v13; // [rsp+63h] [rbp-1Dh]
unsigned int v14; // [rsp+64h] [rbp-1Ch]
long long v15; // [rsp+68h] [rbp-18h]
int v16; // [rsp+7Ch] [rbp-4h]
v16 = a1;
v15 = a2[2];
v14 = *(_DWORD *)(v15 + 1980);
v13 = *(_BYTE *)(*a2 + 7LL) & 7;
v2 = 8;
if ( v13 <= 2u )
v2 = 12;
v12 = v2;
if ( !a1 )
{
v11 = (unsigned __int16 *)*a2;
v10 = a2[3];
v9 = a2[1];
v8 = *(unsigned int *)((char *)v11 + 3) | ((unsigned long long)((*((unsigned __int8 *)v11 + 2) << 16) | (unsigned int)*v11) << 32);
if ( v13 > 2u )
v3 = *(_DWORD *)(v15 + 3096) + 8;
else
v3 = *(_DWORD *)(v15 + 3096) + 12;
v7 = v3;
v6 = *(_DWORD *)((char *)v11 + v12);
memcpy(v10, v11, v3);
v16 = ma_decrypt(
v15,
*(_QWORD *)(v15 + 3104),
v7 + (unsigned int)v11,
v7 + (unsigned int)v10,
v14 - (v7 + 4),
v9,
v8,
v6);
*(_DWORD *)(v10 + v14 - 4) = *(_DWORD *)((char *)v11 + v14 - 4);
*(_DWORD *)(v12 + v10) = 0;
}
if ( a2[3] )
{
v5 = *a2;
*a2 = a2[3];
a2[3] = 0LL;
my_free(v5);
}
return maria_page_crc_check_data(v16, (long long)a2);
}
|
ma_crypt_data_post_read_hook:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x7bc]
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOVZX EAX,byte ptr [RAX + 0x7]
AND EAX,0x7
MOV byte ptr [RBP + -0x1d],AL
MOVZX EDX,byte ptr [RBP + -0x1d]
MOV EAX,0x8
MOV ECX,0xc
CMP EDX,0x2
CMOVLE EAX,ECX
MOV dword ptr [RBP + -0x24],EAX
CMP dword ptr [RBP + -0x4],0x0
JNZ 0x001c3fa6
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV dword ptr [RBP + -0x3c],EAX
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x30]
MOVZX ECX,byte ptr [RCX + 0x1]
SHL ECX,0x8
OR EAX,ECX
MOV RCX,qword ptr [RBP + -0x30]
MOVZX ECX,byte ptr [RCX + 0x2]
SHL ECX,0x10
OR EAX,ECX
MOV EAX,EAX
SHL RAX,0x20
MOV RCX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RCX + 0x3]
OR RAX,RCX
MOV qword ptr [RBP + -0x48],RAX
MOVZX EAX,byte ptr [RBP + -0x1d]
CMP EAX,0x2
JG 0x001c3eef
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0xc18]
ADD EAX,0xc
MOV dword ptr [RBP + -0x6c],EAX
JMP 0x001c3eff
LAB_001c3eef:
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0xc18]
ADD EAX,0x8
MOV dword ptr [RBP + -0x6c],EAX
LAB_001c3eff:
MOV EAX,dword ptr [RBP + -0x6c]
MOV dword ptr [RBP + -0x4c],EAX
MOV dword ptr [RBP + -0x50],0x4
MOV RAX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RBP + -0x24]
MOV EAX,dword ptr [RAX + RCX*0x1]
MOV dword ptr [RBP + -0x54],EAX
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RBP + -0x4c]
MOV EDX,EAX
CALL 0x0012c0c0
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RAX + 0xc20]
MOV RDX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RBP + -0x4c]
ADD RDX,RAX
MOV RCX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RBP + -0x4c]
ADD RCX,RAX
MOV R8D,dword ptr [RBP + -0x1c]
MOV EAX,dword ptr [RBP + -0x4c]
ADD EAX,0x4
SUB R8D,EAX
MOV R9D,dword ptr [RBP + -0x3c]
MOV R10,qword ptr [RBP + -0x48]
MOV EAX,dword ptr [RBP + -0x54]
MOV qword ptr [RSP],R10
MOV dword ptr [RSP + 0x8],EAX
CALL 0x001c4780
MOV dword ptr [RBP + -0x4],EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RBP + -0x1c]
MOV RDX,qword ptr [RBP + -0x30]
MOV ESI,dword ptr [RBP + -0x1c]
MOV EDX,dword ptr [RDX + RSI*0x1 + -0x4]
MOV dword ptr [RAX + RCX*0x1 + -0x4],EDX
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RBP + -0x24]
ADD RAX,RCX
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x60]
MOV dword ptr [RAX],0x0
JMP 0x001c3fa6
LAB_001c3fa6:
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x18],0x0
JZ 0x001c3fe0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x18],0x0
MOV RDI,qword ptr [RBP + -0x68]
CALL 0x00226ac0
LAB_001c3fe0:
MOV EDI,dword ptr [RBP + -0x4]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x001c2a30
ADD RSP,0x80
POP RBP
RET
|
void ma_crypt_data_post_read_hook(int param_1,long *param_2)
{
uint uVar1;
int4 uVar2;
int4 uVar3;
long lVar4;
int3 *__src;
void *__dest;
ulong uVar5;
int3 uVar6;
byte bVar7;
uint uVar8;
uint local_74;
int local_c;
lVar4 = param_2[2];
uVar1 = *(uint *)(lVar4 + 0x7bc);
bVar7 = *(byte *)(*param_2 + 7) & 7;
uVar8 = 8;
if (bVar7 < 3) {
uVar8 = 0xc;
}
local_c = param_1;
if (param_1 == 0) {
__src = (int3 *)*param_2;
__dest = (void *)param_2[3];
uVar5 = param_2[1];
uVar6 = *__src;
uVar2 = *(int4 *)((long)__src + 3);
if (bVar7 < 3) {
local_74 = *(int *)(lVar4 + 0xc18) + 0xc;
}
else {
local_74 = *(int *)(lVar4 + 0xc18) + 8;
}
uVar3 = *(int4 *)((long)__src + (ulong)uVar8);
memcpy(__dest,__src,(ulong)local_74);
local_c = ma_decrypt(lVar4,*(int8 *)(lVar4 + 0xc20),(long)__src + (ulong)local_74,
(long)__dest + (ulong)local_74,uVar1 - (local_74 + 4),uVar5 & 0xffffffff,
(ulong)CONCAT34(uVar6,uVar2),uVar3);
*(int4 *)((long)__dest + ((ulong)uVar1 - 4)) =
*(int4 *)((long)__src + ((ulong)uVar1 - 4));
*(int4 *)((long)__dest + (ulong)uVar8) = 0;
}
if (param_2[3] != 0) {
lVar4 = *param_2;
*param_2 = param_2[3];
param_2[3] = 0;
my_free(lVar4);
}
maria_page_crc_check_data(local_c,param_2);
return;
}
|
|
11,703 |
sp_get_linestring_mbr
|
eloqsql/storage/maria/ma_sp_key.c
|
static int sp_get_linestring_mbr(uchar *(*wkb), uchar *end, uint n_dims,
uchar byte_order, double *mbr)
{
uint n_points;
n_points = uint4korr(*wkb);
(*wkb) += 4;
for (; n_points > 0; --n_points)
{
/* Add next point to mbr */
if (sp_add_point_to_mbr(wkb, end, n_dims, byte_order, mbr))
return -1;
}
return 0;
}
|
O0
|
c
|
sp_get_linestring_mbr:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movb %al, -0x1d(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
cmpl $0x0, -0x2c(%rbp)
jbe 0x9db11
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movb -0x1d(%rbp), %al
movq -0x28(%rbp), %r8
movzbl %al, %ecx
callq 0x9dbe0
cmpl $0x0, %eax
je 0x9db04
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9db18
jmp 0x9db06
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x9dad6
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
sp_get_linestring_mbr:
push rbp
mov rbp, rsp
sub rsp, 30h
mov al, cl
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov [rbp+var_1D], al
mov [rbp+var_28], r8
mov rax, [rbp+var_10]
mov rax, [rax]
mov eax, [rax]
mov [rbp+var_2C], eax
mov rax, [rbp+var_10]
mov rcx, [rax]
add rcx, 4
mov [rax], rcx
loc_9DAD6:
cmp [rbp+var_2C], 0
jbe short loc_9DB11
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov edx, [rbp+var_1C]
mov al, [rbp+var_1D]
mov r8, [rbp+var_28]
movzx ecx, al
call sp_add_point_to_mbr
cmp eax, 0
jz short loc_9DB04
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_9DB18
loc_9DB04:
jmp short $+2
loc_9DB06:
mov eax, [rbp+var_2C]
add eax, 0FFFFFFFFh
mov [rbp+var_2C], eax
jmp short loc_9DAD6
loc_9DB11:
mov [rbp+var_4], 0
loc_9DB18:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
|
long long sp_get_linestring_mbr(_DWORD **a1, long long a2, unsigned int a3, unsigned __int8 a4, long long a5)
{
int i; // [rsp+4h] [rbp-2Ch]
for ( i = *(*a1)++; i; --i )
{
if ( (unsigned int)sp_add_point_to_mbr(a1, a2, a3, a4, a5) )
return (unsigned int)-1;
}
return 0;
}
|
sp_get_linestring_mbr:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV AL,CL
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV byte ptr [RBP + -0x1d],AL
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x2c],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
ADD RCX,0x4
MOV qword ptr [RAX],RCX
LAB_0019dad6:
CMP dword ptr [RBP + -0x2c],0x0
JBE 0x0019db11
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x1c]
MOV AL,byte ptr [RBP + -0x1d]
MOV R8,qword ptr [RBP + -0x28]
MOVZX ECX,AL
CALL 0x0019dbe0
CMP EAX,0x0
JZ 0x0019db04
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x0019db18
LAB_0019db04:
JMP 0x0019db06
LAB_0019db06:
MOV EAX,dword ptr [RBP + -0x2c]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x0019dad6
LAB_0019db11:
MOV dword ptr [RBP + -0x4],0x0
LAB_0019db18:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4
sp_get_linestring_mbr
(long *param_1,int8 param_2,int4 param_3,int1 param_4,int8 param_5
)
{
int iVar1;
int local_34;
local_34 = *(int *)*param_1;
*param_1 = *param_1 + 4;
while( true ) {
if (local_34 == 0) {
return 0;
}
iVar1 = sp_add_point_to_mbr(param_1,param_2,param_3,param_4,param_5);
if (iVar1 != 0) break;
local_34 = local_34 + -1;
}
return 0xffffffff;
}
|
|
11,704 |
tailoring_append_abbreviation
|
eloqsql/strings/ctype.c
|
static int
tailoring_append_abbreviation(MY_XML_PARSER *st,
const char *fmt, size_t len, const char *attr)
{
size_t clen;
const char *attrend= attr + len;
my_wc_t wc;
for ( ; (clen= scan_one_character(attr, attrend, &wc)) > 0; attr+= clen)
{
DBUG_ASSERT(attr < attrend);
if (tailoring_append(st, fmt, clen, attr) != MY_XML_OK)
return MY_XML_ERROR;
}
return MY_XML_OK;
}
|
O0
|
c
|
tailoring_append_abbreviation:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x7d2f0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jbe 0x7d2d6
jmp 0x7d2a1
jmp 0x7d2a3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x7cd90
cmpl $0x0, %eax
je 0x7d2c6
movl $0x1, -0x4(%rbp)
jmp 0x7d2dd
jmp 0x7d2c8
movq -0x30(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x7d284
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
tailoring_append_abbreviation:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_28]
add rax, [rbp+var_20]
mov [rbp+var_38], rax
loc_7D284:
mov rdi, [rbp+var_28]
mov rsi, [rbp+var_38]
lea rdx, [rbp+var_40]
call scan_one_character
mov [rbp+var_30], rax
cmp rax, 0
jbe short loc_7D2D6
jmp short $+2
loc_7D2A1:
jmp short $+2
loc_7D2A3:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_30]
mov rcx, [rbp+var_28]
call tailoring_append
cmp eax, 0
jz short loc_7D2C6
mov [rbp+var_4], 1
jmp short loc_7D2DD
loc_7D2C6:
jmp short $+2
loc_7D2C8:
mov rax, [rbp+var_30]
add rax, [rbp+var_28]
mov [rbp+var_28], rax
jmp short loc_7D284
loc_7D2D6:
mov [rbp+var_4], 0
loc_7D2DD:
mov eax, [rbp+var_4]
add rsp, 40h
pop rbp
retn
|
long long tailoring_append_abbreviation(long long a1, const char *a2, long long a3, long long a4)
{
_BYTE v5[8]; // [rsp+0h] [rbp-40h] BYREF
long long v6; // [rsp+8h] [rbp-38h]
long long v7; // [rsp+10h] [rbp-30h]
long long v8; // [rsp+18h] [rbp-28h]
long long v9; // [rsp+20h] [rbp-20h]
const char *v10; // [rsp+28h] [rbp-18h]
long long v11; // [rsp+30h] [rbp-10h]
v11 = a1;
v10 = a2;
v9 = a3;
v8 = a4;
v6 = a3 + a4;
while ( 1 )
{
v7 = scan_one_character(v8, v6, v5);
if ( !v7 )
break;
if ( (unsigned int)tailoring_append(v11, v10, v7, v8) )
return 1;
v8 += v7;
}
return 0;
}
|
tailoring_append_abbreviation:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x38],RAX
LAB_0017d284:
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x38]
LEA RDX,[RBP + -0x40]
CALL 0x0017d2f0
MOV qword ptr [RBP + -0x30],RAX
CMP RAX,0x0
JBE 0x0017d2d6
JMP 0x0017d2a1
LAB_0017d2a1:
JMP 0x0017d2a3
LAB_0017d2a3:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x28]
CALL 0x0017cd90
CMP EAX,0x0
JZ 0x0017d2c6
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0017d2dd
LAB_0017d2c6:
JMP 0x0017d2c8
LAB_0017d2c8:
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x28],RAX
JMP 0x0017d284
LAB_0017d2d6:
MOV dword ptr [RBP + -0x4],0x0
LAB_0017d2dd:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x40
POP RBP
RET
|
int4
tailoring_append_abbreviation(int8 param_1,int8 param_2,long param_3,long param_4)
{
int iVar1;
int1 local_48 [8];
long local_40;
long local_38;
long local_30;
long local_28;
int8 local_20;
int8 local_18;
local_40 = param_4 + param_3;
local_30 = param_4;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
while( true ) {
local_38 = scan_one_character(local_30,local_40,local_48);
if (local_38 == 0) {
return 0;
}
iVar1 = tailoring_append(local_18,local_20,local_38,local_30);
if (iVar1 != 0) break;
local_30 = local_38 + local_30;
}
return 1;
}
|
|
11,705 |
google::protobuf::(anonymous namespace)::GeneratedMessageFactory::RegisterType(google::protobuf::Descriptor const*, google::protobuf::Message const*)
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/message.cc
|
void GeneratedMessageFactory::RegisterType(const Descriptor* descriptor,
const Message* prototype) {
GOOGLE_DCHECK_EQ(descriptor->file()->pool(), DescriptorPool::generated_pool())
<< "Tried to register a non-generated type with the generated "
"type registry.";
// This should only be called as a result of calling a file registration
// function during GetPrototype(), in which case we already have locked
// the mutex.
mutex_.AssertHeld();
if (!InsertIfNotPresent(&type_map_, descriptor, prototype)) {
GOOGLE_LOG(DFATAL) << "Type is already registered: " << descriptor->full_name();
}
}
|
O0
|
cpp
|
google::protobuf::(anonymous namespace)::GeneratedMessageFactory::RegisterType(google::protobuf::Descriptor const*, google::protobuf::Message const*):
subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0x38(%rsp)
xorl %eax, %eax
testb $0x1, %al
jne 0x1dc047
jmp 0x1dc13e
movq 0xd8(%rsp), %rdi
callq 0x1c1590
movq %rax, %rdi
callq 0x1ddd80
movq %rax, 0x30(%rsp)
callq 0x242c30
movq %rax, %rcx
movq 0x30(%rsp), %rax
movb $0x0, 0x97(%rsp)
cmpq %rcx, %rax
jne 0x1dc07d
jmp 0x1dc0ee
leaq 0x20c914(%rip), %rdx # 0x3e8998
leaq 0x98(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movl $0x3, %esi
movl $0x108, %ecx # imm = 0x108
callq 0x19a670
movq 0x20(%rsp), %rdi
movb $0x1, 0x97(%rsp)
leaq 0x20cb85(%rip), %rsi # 0x3e8c39
callq 0x199f30
movq %rax, 0x28(%rsp)
jmp 0x1dc0c0
movq 0x28(%rsp), %rdi
leaq 0x20cbc0(%rip), %rsi # 0x3e8c8c
callq 0x199f30
movq %rax, 0x18(%rsp)
jmp 0x1dc0d8
movq 0x18(%rsp), %rsi
leaq 0x83(%rsp), %rdi
callq 0x19a0e0
jmp 0x1dc0ec
jmp 0x1dc0ee
testb $0x1, 0x97(%rsp)
jne 0x1dc0fa
jmp 0x1dc107
leaq 0x98(%rsp), %rdi
callq 0x19a6b0
jmp 0x1dc03c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
testb $0x1, 0x97(%rsp)
jne 0x1dc12c
jmp 0x1dc139
leaq 0x98(%rsp), %rdi
callq 0x19a6b0
jmp 0x1dc20e
movq 0x38(%rsp), %rdi
addq $0x40, %rdi
callq 0x1df640
movq 0x38(%rsp), %rdi
addq $0x68, %rdi
leaq 0xd8(%rsp), %rsi
leaq 0xd0(%rsp), %rdx
callq 0x1df650
testb $0x1, %al
jne 0x1dc206
leaq 0x20c81f(%rip), %rdx # 0x3e8998
leaq 0x48(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x2, %esi
movl $0x111, %ecx # imm = 0x111
callq 0x19a670
movq 0x8(%rsp), %rdi
leaq 0x20cb37(%rip), %rsi # 0x3e8cd5
callq 0x199f30
movq %rax, 0x10(%rsp)
jmp 0x1dc1aa
movq 0xd8(%rsp), %rdi
callq 0x1bd120
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x199f60
movq %rax, (%rsp)
jmp 0x1dc1ca
movq (%rsp), %rsi
leaq 0x47(%rsp), %rdi
callq 0x19a0e0
jmp 0x1dc1da
leaq 0x48(%rsp), %rdi
callq 0x19a6b0
jmp 0x1dc206
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x19a6b0
jmp 0x1dc20e
addq $0xe8, %rsp
retq
movq 0x88(%rsp), %rdi
callq 0x90db0
nopl (%rax,%rax)
|
_ZN6google8protobuf12_GLOBAL__N_123GeneratedMessageFactory12RegisterTypeEPKNS0_10DescriptorEPKNS0_7MessageE:
sub rsp, 0E8h
mov [rsp+0E8h+var_8], rdi
mov [rsp+0E8h+var_10], rsi
mov [rsp+0E8h+var_18], rdx
mov rax, [rsp+0E8h+var_8]
mov [rsp+0E8h+var_B0], rax
loc_1DC03C:
xor eax, eax
test al, 1
jnz short loc_1DC047
jmp loc_1DC13E
loc_1DC047:
mov rdi, [rsp+0E8h+var_10]; this
call _ZNK6google8protobuf10Descriptor4fileEv; google::protobuf::Descriptor::file(void)
mov rdi, rax; this
call _ZNK6google8protobuf14FileDescriptor4poolEv; google::protobuf::FileDescriptor::pool(void)
mov [rsp+0E8h+var_B8], rax
call _ZN6google8protobuf14DescriptorPool14generated_poolEv; google::protobuf::DescriptorPool::generated_pool(void)
mov rcx, rax
mov rax, [rsp+0E8h+var_B8]
mov [rsp+0E8h+var_51], 0
cmp rax, rcx
jnz short loc_1DC07D
jmp short loc_1DC0EE
loc_1DC07D:
lea rdx, aWorkspaceLlm4b_37; "/workspace/llm4binary/github2025/aimrt_"...
lea rdi, [rsp+0E8h+var_50]
mov [rsp+0E8h+var_C8], rdi
mov esi, 3
mov ecx, 108h
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
mov rdi, [rsp+0E8h+var_C8]
mov [rsp+0E8h+var_51], 1
lea rsi, aCheckFailedDes_0; "CHECK failed: (descriptor->file()->pool"...
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+0E8h+var_C0], rax
jmp short $+2
loc_1DC0C0:
mov rdi, [rsp+0E8h+var_C0]
lea rsi, aTriedToRegiste; "Tried to register a non-generated type "...
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+0E8h+var_D0], rax
jmp short $+2
loc_1DC0D8:
mov rsi, [rsp+0E8h+var_D0]
lea rdi, [rsp+0E8h+var_65]
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
jmp short $+2
loc_1DC0EC:
jmp short $+2
loc_1DC0EE:
test [rsp+0E8h+var_51], 1
jnz short loc_1DC0FA
jmp short loc_1DC107
loc_1DC0FA:
lea rdi, [rsp+0E8h+var_50]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_1DC107:
jmp loc_1DC03C
mov rcx, rax
mov eax, edx
mov [rsp+arg_80], rcx
mov [rsp+arg_7C], eax
test [rsp+arg_8F], 1
jnz short loc_1DC12C
jmp short loc_1DC139
loc_1DC12C:
lea rdi, [rsp+arg_90]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_1DC139:
jmp loc_1DC20E
loc_1DC13E:
mov rdi, [rsp+0E8h+var_B0]
add rdi, 40h ; '@'; this
call _ZNK6google8protobuf8internal12WrappedMutex10AssertHeldEv; google::protobuf::internal::WrappedMutex::AssertHeld(void)
mov rdi, [rsp+0E8h+var_B0]
add rdi, 68h ; 'h'
lea rsi, [rsp+0E8h+var_10]
lea rdx, [rsp+0E8h+var_18]
call _ZN6google8protobuf18InsertIfNotPresentISt13unordered_mapIPKNS0_10DescriptorEPKNS0_7MessageESt4hashIS5_ESt8equal_toIS5_ESaISt4pairIKS5_S8_EEEEEbPT_RKNSI_10value_type10first_typeERKNSK_11second_typeE; google::protobuf::InsertIfNotPresent<std::unordered_map<google::protobuf::Descriptor const*,google::protobuf::Message const*>>(std::unordered_map<google::protobuf::Descriptor const*,google::protobuf::Message const*> *,std::unordered_map<google::protobuf::Descriptor const*,google::protobuf::Message const*>::value_type::first_type const&,std::unordered_map<google::protobuf::Descriptor const*,google::protobuf::Message const*>::value_type::second_type const&)
test al, 1
jnz loc_1DC206
lea rdx, aWorkspaceLlm4b_37; "/workspace/llm4binary/github2025/aimrt_"...
lea rdi, [rsp+0E8h+var_A0]
mov [rsp+0E8h+var_E0], rdi
mov esi, 2
mov ecx, 111h
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
mov rdi, [rsp+0E8h+var_E0]
lea rsi, aTypeIsAlreadyR; "Type is already registered: "
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+0E8h+var_D8], rax
jmp short $+2
loc_1DC1AA:
mov rdi, [rsp+0E8h+var_10]
call _ZNK6google8protobuf10Descriptor9full_nameB5cxx11Ev; google::protobuf::Descriptor::full_name(void)
mov rdi, [rsp+0E8h+var_D8]
mov rsi, rax
call _ZN6google8protobuf8internal10LogMessagelsERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; google::protobuf::internal::LogMessage::operator<<(std::string const&)
mov [rsp+0E8h+var_E8], rax
jmp short $+2
loc_1DC1CA:
mov rsi, [rsp+0E8h+var_E8]
lea rdi, [rsp+0E8h+var_A1]
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
jmp short $+2
loc_1DC1DA:
lea rdi, [rsp+0E8h+var_A0]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
jmp short loc_1DC206
mov rcx, rax
mov eax, edx
mov [rsp+arg_80], rcx
mov [rsp+arg_7C], eax
lea rdi, [rsp+arg_40]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
jmp short loc_1DC20E
loc_1DC206:
add rsp, 0E8h
retn
loc_1DC20E:
mov rdi, [rsp+arg_80]
call __Unwind_Resume
|
void google::protobuf::`anonymous namespace'::GeneratedMessageFactory::RegisterType(
google::protobuf::_anonymous_namespace_::GeneratedMessageFactory *this,
const google::protobuf::Descriptor *a2,
const google::protobuf::Message *a3)
{
long long v3; // rax
google::protobuf::internal::LogMessage *v4; // [rsp+0h] [rbp-E8h]
long long v5; // [rsp+10h] [rbp-D8h]
char v6; // [rsp+47h] [rbp-A1h] BYREF
_BYTE v7[59]; // [rsp+48h] [rbp-A0h] BYREF
const google::protobuf::Message *v8; // [rsp+D0h] [rbp-18h] BYREF
google::protobuf::Descriptor *v9[2]; // [rsp+D8h] [rbp-10h] BYREF
v9[1] = this;
v9[0] = a2;
v8 = a3;
google::protobuf::internal::WrappedMutex::AssertHeld((google::protobuf::_anonymous_namespace_::GeneratedMessageFactory *)((char *)this + 64));
if ( (google::protobuf::InsertIfNotPresent<std::unordered_map<google::protobuf::Descriptor const*,google::protobuf::Message const*>>(
(char *)this + 104,
v9,
&v8) & 1) == 0 )
{
google::protobuf::internal::LogMessage::LogMessage(
(long long)v7,
2,
(long long)"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/message.cc",
273);
v5 = google::protobuf::internal::LogMessage::operator<<((long long)v7, (long long)"Type is already registered: ");
v3 = google::protobuf::Descriptor::full_name[abi:cxx11]((long long)v9[0]);
v4 = (google::protobuf::internal::LogMessage *)google::protobuf::internal::LogMessage::operator<<(v5, v3);
google::protobuf::internal::LogFinisher::operator=((long long)&v6, v4);
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)v7);
}
}
|
_M_addr:
MOV qword ptr [RSP + -0x8],RDI
MOV RAX,qword ptr [RSP + -0x8]
RET
|
/* __gnu_cxx::__aligned_buffer<std::pair<std::__cxx11::string const,
std::function<std::unique_ptr<aimrt_mujoco_sim::mujoco_sim_module::subscriber::SubscriberBase,
std::default_delete<aimrt_mujoco_sim::mujoco_sim_module::subscriber::SubscriberBase> > ()> >
>::_M_addr() const */
__aligned_buffer<std::pair<std::__cxx11::string_const,std::function<std::unique_ptr<aimrt_mujoco_sim::mujoco_sim_module::subscriber::SubscriberBase,std::default_delete<aimrt_mujoco_sim::mujoco_sim_module::subscriber::SubscriberBase>>()>>>
* __thiscall
__gnu_cxx::
__aligned_buffer<std::pair<std::__cxx11::string_const,std::function<std::unique_ptr<aimrt_mujoco_sim::mujoco_sim_module::subscriber::SubscriberBase,std::default_delete<aimrt_mujoco_sim::mujoco_sim_module::subscriber::SubscriberBase>>()>>>
::_M_addr(__aligned_buffer<std::pair<std::__cxx11::string_const,std::function<std::unique_ptr<aimrt_mujoco_sim::mujoco_sim_module::subscriber::SubscriberBase,std::default_delete<aimrt_mujoco_sim::mujoco_sim_module::subscriber::SubscriberBase>>()>>>
*this)
{
return this;
}
|
|
11,706 |
minja::simple_function(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::function<minja::Value (std::shared_ptr<minja::Context> const&, minja::Value&)> const&)
|
monkey531[P]llama/common/minja.hpp
|
static Value simple_function(const std::string & fn_name, const std::vector<std::string> & params, const std::function<Value(const std::shared_ptr<Context> &, Value & args)> & fn) {
std::map<std::string, size_t> named_positions;
for (size_t i = 0, n = params.size(); i < n; i++) named_positions[params[i]] = i;
return Value::callable([=](const std::shared_ptr<Context> & context, ArgumentsValue & args) -> Value {
auto args_obj = Value::object();
std::vector<bool> provided_args(params.size());
for (size_t i = 0, n = args.args.size(); i < n; i++) {
auto & arg = args.args[i];
if (i < params.size()) {
args_obj.set(params[i], arg);
provided_args[i] = true;
} else {
throw std::runtime_error("Too many positional params for " + fn_name);
}
}
for (auto & [name, value] : args.kwargs) {
auto named_pos_it = named_positions.find(name);
if (named_pos_it == named_positions.end()) {
throw std::runtime_error("Unknown argument " + name + " for function " + fn_name);
}
provided_args[named_pos_it->second] = true;
args_obj.set(name, value);
}
return fn(context, args_obj);
});
}
|
O2
|
cpp
|
minja::simple_function(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::function<minja::Value (std::shared_ptr<minja::Context> const&, minja::Value&)> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, %r15
movq %rsi, %r12
leaq 0x38(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
movq %rdi, (%rsp)
movq 0x8(%rdx), %rbp
subq (%rdx), %rbp
sarq $0x5, %rbp
xorl %ebx, %ebx
leaq 0x30(%rsp), %r13
xorl %r14d, %r14d
cmpq %r14, %rbp
je 0x63ea0
movq (%r15), %rsi
addq %rbx, %rsi
movq %r13, %rdi
callq 0x8abec
movq %r14, (%rax)
incq %r14
addq $0x20, %rbx
jmp 0x63e81
leaq 0x60(%rsp), %rdi
movq %r15, %rsi
callq 0x4596c
leaq 0x78(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x24c50
leaq 0x98(%rsp), %r13
leaq 0x30(%rsp), %rsi
movq %r13, %rdi
callq 0x8b036
leaq 0xc8(%rsp), %r12
movq %r12, %rdi
movq 0x8(%rsp), %rsi
callq 0x8ac52
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movl $0x88, %edi
callq 0x248e0
movq %rax, %r14
leaq 0x60(%rsp), %rsi
movq %rax, %rdi
callq 0x4596c
leaq 0x18(%r14), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x24c50
leaq 0x40(%r14), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x483c0
leaq 0x68(%r14), %rdi
movq %r12, %rsi
callq 0x8ac52
leaq 0x10(%rsp), %rsi
movq %r14, (%rsi)
leaq 0x109(%rip), %rax # 0x64052
movq %rax, 0x18(%rsi)
leaq 0x42c(%rip), %rax # 0x64380
movq %rax, 0x10(%rsi)
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x7b4ec
leaq 0x10(%rsp), %rdi
callq 0x53a4e
leaq 0x60(%rsp), %rdi
callq 0x6402a
leaq 0x30(%rsp), %rdi
callq 0x8b27c
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x63fd1
movq %rax, %rbx
movq %r14, %rdi
addq $0x38, %rdi
callq 0x8b27c
movq %r13, %rdi
callq 0x25298
jmp 0x63fb5
movq %rax, %rbx
movq %r14, %rdi
callq 0x30b26
jmp 0x63fc2
movq %rax, %rbx
movl $0x88, %esi
movq %r14, %rdi
callq 0x24900
jmp 0x63fd4
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x53a4e
leaq 0x60(%rsp), %rdi
callq 0x6402a
jmp 0x64018
movq %rax, %rbx
movq %r13, %rdi
callq 0x8b27c
jmp 0x63ffa
movq %rax, %rbx
movq %r15, %rdi
callq 0x25298
jmp 0x64007
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x30b26
jmp 0x64018
jmp 0x64015
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x8b27c
movq %rbx, %rdi
callq 0x25010
|
_ZN5minjaL15simple_functionERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKSt6vectorIS5_SaIS5_EERKSt8functionIFNS_5ValueERKSt10shared_ptrINS_7ContextEERSE_EE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0E8h
mov [rsp+118h+var_110], rcx
mov r15, rdx
mov r12, rsi
lea rax, [rsp+118h+var_E0]
and dword ptr [rax], 0
and qword ptr [rax+8], 0
mov [rax+10h], rax
mov [rax+18h], rax
and qword ptr [rax+20h], 0
mov [rsp+118h+var_118], rdi
mov rbp, [rdx+8]
sub rbp, [rdx]
sar rbp, 5
xor ebx, ebx
lea r13, [rsp+118h+var_E8]
xor r14d, r14d
loc_63E81:
cmp rbp, r14
jz short loc_63EA0
mov rsi, [r15]
add rsi, rbx
mov rdi, r13
call _ZNSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEmSt4lessIS5_ESaISt4pairIKS5_mEEEixERS9_; std::map<std::string,ulong>::operator[](std::string const&)
mov [rax], r14
inc r14
add rbx, 20h ; ' '
jmp short loc_63E81
loc_63EA0:
lea rdi, [rsp+118h+var_B8]
mov rsi, r15
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEC2ERKS7_; std::vector<std::string>::vector(std::vector<std::string> const&)
lea r15, [rsp+118h+var_A0]
mov rdi, r15
mov rsi, r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2ERKS4_; std::string::basic_string(std::string const&)
lea r13, [rsp+118h+var_80]
lea rsi, [rsp+118h+var_E8]
mov rdi, r13
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_mESt10_Select1stIS8_ESt4lessIS5_ESaIS8_EEC2ERKSE_; std::_Rb_tree<std::string,std::pair<std::string const,ulong>,std::_Select1st<std::pair<std::string const,ulong>>,std::less<std::string>,std::allocator<std::pair<std::string const,ulong>>>::_Rb_tree(std::_Rb_tree<std::string,std::pair<std::string const,ulong>,std::_Select1st<std::pair<std::string const,ulong>>,std::less<std::string>,std::allocator<std::pair<std::string const,ulong>>> const&)
lea r12, [rsp+118h+var_50]
mov rdi, r12
mov rsi, [rsp+118h+var_110]
call _ZNSt8functionIFN5minja5ValueERKSt10shared_ptrINS0_7ContextEERS1_EEC2ERKS9_; std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)>::function(std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)> const&)
xorps xmm0, xmm0
movaps [rsp+118h+var_F8], xmm0
movaps [rsp+118h+var_108], xmm0
mov edi, 88h; unsigned __int64
call __Znwm; operator new(ulong)
mov r14, rax
lea rsi, [rsp+118h+var_B8]
mov rdi, rax
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEC2ERKS7_; std::vector<std::string>::vector(std::vector<std::string> const&)
lea r13, [r14+18h]
mov rdi, r13
mov rsi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2ERKS4_; std::string::basic_string(std::string const&)
lea rdi, [r14+40h]
lea rsi, [rsp+118h+var_78]
call _ZNSt15_Rb_tree_headerC2EOS_; std::_Rb_tree_header::_Rb_tree_header(std::_Rb_tree_header&&)
lea rdi, [r14+68h]
mov rsi, r12
call _ZNSt8functionIFN5minja5ValueERKSt10shared_ptrINS0_7ContextEERS1_EEC2ERKS9_; std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)>::function(std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)> const&)
lea rsi, [rsp+118h+var_108]
mov [rsi], r14
lea rax, _ZNSt17_Function_handlerIFN5minja5ValueERKSt10shared_ptrINS0_7ContextEERNS0_14ArgumentsValueEEZNS0_L15simple_functionERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKSt6vectorISF_SaISF_EERKSt8functionIFS1_S6_RS1_EEE3$_0E9_M_invokeERKSt9_Any_dataS6_S8_; std::_Function_handler<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &),minja::simple_function(std::string const&,std::vector<std::string> const&,std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)> const&)::$_0>::_M_invoke(std::_Any_data const&,std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)
mov [rsi+18h], rax
lea rax, _ZNSt17_Function_handlerIFN5minja5ValueERKSt10shared_ptrINS0_7ContextEERNS0_14ArgumentsValueEEZNS0_L15simple_functionERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKSt6vectorISF_SaISF_EERKSt8functionIFS1_S6_RS1_EEE3$_0E10_M_managerERSt9_Any_dataRKSV_St18_Manager_operation; std::_Function_handler<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &),minja::simple_function(std::string const&,std::vector<std::string> const&,std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)> const&)::$_0>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov [rsi+10h], rax
mov rbx, [rsp+118h+var_118]
mov rdi, rbx
call _ZN5minja5Value8callableERKSt8functionIFS0_RKSt10shared_ptrINS_7ContextEERNS_14ArgumentsValueEEE; minja::Value::callable(std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)> const&)
lea rdi, [rsp+118h+var_108]; this
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
lea rdi, [rsp+118h+var_B8]
call _ZZN5minjaL15simple_functionERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKSt6vectorIS5_SaIS5_EERKSt8functionIFNS_5ValueERKSt10shared_ptrINS_7ContextEERSE_EEEN3$_0D2Ev; minja::simple_function(std::string const&,std::vector<std::string> const&,std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)> const&)::$_0::~$_0()
lea rdi, [rsp+118h+var_E8]
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_mESt10_Select1stIS8_ESt4lessIS5_ESaIS8_EED2Ev; std::_Rb_tree<std::string,std::pair<std::string const,ulong>,std::_Select1st<std::pair<std::string const,ulong>>,std::less<std::string>,std::allocator<std::pair<std::string const,ulong>>>::~_Rb_tree()
mov rax, rbx
add rsp, 0E8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_63FD1
mov rbx, rax
mov rdi, r14
add rdi, 38h ; '8'
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_mESt10_Select1stIS8_ESt4lessIS5_ESaIS8_EED2Ev; std::_Rb_tree<std::string,std::pair<std::string const,ulong>,std::_Select1st<std::pair<std::string const,ulong>>,std::less<std::string>,std::allocator<std::pair<std::string const,ulong>>>::~_Rb_tree()
mov rdi, r13; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_63FB5
mov rbx, rax
loc_63FB5:
mov rdi, r14
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
jmp short loc_63FC2
mov rbx, rax
loc_63FC2:
mov esi, 88h; unsigned __int64
mov rdi, r14; void *
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_63FD4
loc_63FD1:
mov rbx, rax
loc_63FD4:
lea rdi, [rsp+arg_8]; this
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
lea rdi, [rsp+arg_58]
call _ZZN5minjaL15simple_functionERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKSt6vectorIS5_SaIS5_EERKSt8functionIFNS_5ValueERKSt10shared_ptrINS_7ContextEERSE_EEEN3$_0D2Ev; minja::simple_function(std::string const&,std::vector<std::string> const&,std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)> const&)::$_0::~$_0()
jmp short loc_64018
mov rbx, rax
mov rdi, r13
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_mESt10_Select1stIS8_ESt4lessIS5_ESaIS8_EED2Ev; std::_Rb_tree<std::string,std::pair<std::string const,ulong>,std::_Select1st<std::pair<std::string const,ulong>>,std::less<std::string>,std::allocator<std::pair<std::string const,ulong>>>::~_Rb_tree()
jmp short loc_63FFA
mov rbx, rax
loc_63FFA:
mov rdi, r15; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_64007
mov rbx, rax
loc_64007:
lea rdi, [rsp+arg_58]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
jmp short loc_64018
jmp short $+2
loc_64015:
mov rbx, rax
loc_64018:
lea rdi, [rsp+arg_28]
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_mESt10_Select1stIS8_ESt4lessIS5_ESaIS8_EED2Ev; std::_Rb_tree<std::string,std::pair<std::string const,ulong>,std::_Select1st<std::pair<std::string const,ulong>>,std::less<std::string>,std::allocator<std::pair<std::string const,ulong>>>::~_Rb_tree()
mov rdi, rbx
call __Unwind_Resume
|
long long minja::simple_function(long long a1, long long a2, _QWORD *a3, long long a4)
{
long long v5; // rbp
long long v6; // rbx
long long i; // r14
_QWORD *v8; // r14
int v9; // edx
int v10; // ecx
int v11; // r8d
int v12; // r9d
__int128 v15; // [rsp+10h] [rbp-108h] BYREF
long long ( *v16)(); // [rsp+20h] [rbp-F8h]
long long ( *v17)(); // [rsp+28h] [rbp-F0h]
_BYTE v18[8]; // [rsp+30h] [rbp-E8h] BYREF
int v19; // [rsp+38h] [rbp-E0h] BYREF
long long v20; // [rsp+40h] [rbp-D8h]
int *v21; // [rsp+48h] [rbp-D0h]
int *v22; // [rsp+50h] [rbp-C8h]
long long v23; // [rsp+58h] [rbp-C0h]
_QWORD v24[3]; // [rsp+60h] [rbp-B8h] BYREF
_BYTE v25[32]; // [rsp+78h] [rbp-A0h] BYREF
_BYTE v26[8]; // [rsp+98h] [rbp-80h] BYREF
_BYTE v27[40]; // [rsp+A0h] [rbp-78h] BYREF
_BYTE v28[80]; // [rsp+C8h] [rbp-50h] BYREF
v19 = 0;
v20 = 0LL;
v21 = &v19;
v22 = &v19;
v23 = 0LL;
v5 = (long long)(a3[1] - *a3) >> 5;
v6 = 0LL;
for ( i = 0LL; v5 != i; ++i )
{
*(_QWORD *)std::map<std::string,unsigned long>::operator[](v18, v6 + *a3) = i;
v6 += 32LL;
}
std::vector<std::string>::vector(v24, a3);
std::string::basic_string(v25, a2);
std::_Rb_tree<std::string,std::pair<std::string const,unsigned long>,std::_Select1st<std::pair<std::string const,unsigned long>>,std::less<std::string>,std::allocator<std::pair<std::string const,unsigned long>>>::_Rb_tree(
v26,
v18);
std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)>::function(v28, a4);
v15 = 0LL;
v8 = (_QWORD *)operator new(0x88uLL);
std::vector<std::string>::vector(v8, v24);
std::string::basic_string(v8 + 3, v25);
std::_Rb_tree_header::_Rb_tree_header((long long)(v8 + 8), (long long)v27);
std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)>::function(v8 + 13, v28);
*(_QWORD *)&v15 = v8;
v17 = std::_Function_handler<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &),minja::simple_function(std::string const&,std::vector<std::string> const&,std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)> const&)::$_0>::_M_invoke;
v16 = std::_Function_handler<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &),minja::simple_function(std::string const&,std::vector<std::string> const&,std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)> const&)::$_0>::_M_manager;
minja::Value::callable(a1, (unsigned int)&v15, v9, v10, v11, v12, a1, a4);
std::_Function_base::~_Function_base((std::_Function_base *)&v15);
minja::simple_function(std::string const&,std::vector<std::string> const&,std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)> const&)::$_0::~$_0(v24);
std::_Rb_tree<std::string,std::pair<std::string const,unsigned long>,std::_Select1st<std::pair<std::string const,unsigned long>>,std::less<std::string>,std::allocator<std::pair<std::string const,unsigned long>>>::~_Rb_tree(v18);
return a1;
}
|
simple_function:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xe8
MOV qword ptr [RSP + 0x8],RCX
MOV R15,RDX
MOV R12,RSI
LEA RAX,[RSP + 0x38]
AND dword ptr [RAX],0x0
AND qword ptr [RAX + 0x8],0x0
MOV qword ptr [RAX + 0x10],RAX
MOV qword ptr [RAX + 0x18],RAX
AND qword ptr [RAX + 0x20],0x0
MOV qword ptr [RSP],RDI
MOV RBP,qword ptr [RDX + 0x8]
SUB RBP,qword ptr [RDX]
SAR RBP,0x5
XOR EBX,EBX
LEA R13,[RSP + 0x30]
XOR R14D,R14D
LAB_00163e81:
CMP RBP,R14
JZ 0x00163ea0
MOV RSI,qword ptr [R15]
ADD RSI,RBX
LAB_00163e8c:
MOV RDI,R13
CALL 0x0018abec
MOV qword ptr [RAX],R14
INC R14
ADD RBX,0x20
JMP 0x00163e81
LAB_00163ea0:
LEA RDI,[RSP + 0x60]
MOV RSI,R15
CALL 0x0014596c
LEA R15,[RSP + 0x78]
LAB_00163eb2:
MOV RDI,R15
MOV RSI,R12
CALL 0x00124c50
LEA R13,[RSP + 0x98]
LAB_00163ec5:
LEA RSI,[RSP + 0x30]
MOV RDI,R13
CALL 0x0018b036
LEA R12,[RSP + 0xc8]
LAB_00163eda:
MOV RDI,R12
MOV RSI,qword ptr [RSP + 0x8]
CALL 0x0018ac52
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOVAPS xmmword ptr [RSP + 0x10],XMM0
LAB_00163ef4:
MOV EDI,0x88
CALL 0x001248e0
LAB_00163efe:
MOV R14,RAX
LEA RSI,[RSP + 0x60]
MOV RDI,RAX
CALL 0x0014596c
LEA R13,[R14 + 0x18]
LAB_00163f12:
MOV RDI,R13
MOV RSI,R15
CALL 0x00124c50
LEA RDI,[R14 + 0x40]
LEA RSI,[RSP + 0xa0]
CALL 0x001483c0
LEA RDI,[R14 + 0x68]
LAB_00163f32:
MOV RSI,R12
CALL 0x0018ac52
LEA RSI,[RSP + 0x10]
MOV qword ptr [RSI],R14
LEA RAX,[0x164052]
MOV qword ptr [RSI + 0x18],RAX
LEA RAX,[0x164380]
MOV qword ptr [RSI + 0x10],RAX
LAB_00163f58:
MOV RBX,qword ptr [RSP]
MOV RDI,RBX
CALL 0x0017b4ec
LAB_00163f64:
LEA RDI,[RSP + 0x10]
CALL 0x00153a4e
LEA RDI,[RSP + 0x60]
CALL 0x0016402a
LEA RDI,[RSP + 0x30]
CALL 0x0018b27c
MOV RAX,RBX
ADD RSP,0xe8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* minja::simple_function(std::__cxx11::string const&, std::vector<std::__cxx11::string,
std::allocator<std::__cxx11::string > > const&, std::function<minja::Value
(std::shared_ptr<minja::Context> const&, minja::Value&)> const&) */
minja * __thiscall
minja::simple_function(minja *this,string *param_1,vector *param_2,function *param_3)
{
long lVar1;
long lVar2;
long *plVar3;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *this_00;
long lVar4;
long lVar5;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *local_108;
int8 uStack_100;
code *local_f8;
code *pcStack_f0;
map<std::__cxx11::string,unsigned_long,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,unsigned_long>>>
local_e8 [8];
int4 local_e0 [2];
int8 local_d8;
int4 *local_d0;
int4 *local_c8;
int8 local_c0;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> local_b8 [24];
string local_a0 [32];
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,unsigned_long>,std::_Select1st<std::pair<std::__cxx11::string_const,unsigned_long>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,unsigned_long>>>
local_80 [8];
_Rb_tree_header local_78 [40];
function<minja::Value(std::shared_ptr<minja::Context>const&,minja::Value&)> local_50 [32];
local_d0 = local_e0;
local_e0[0] = 0;
local_d8 = 0;
local_c0 = 0;
lVar1 = *(long *)(param_2 + 8);
lVar2 = *(long *)param_2;
lVar4 = 0;
local_c8 = local_d0;
for (lVar5 = 0; lVar1 - lVar2 >> 5 != lVar5; lVar5 = lVar5 + 1) {
/* try { // try from 00163e8c to 00163e93 has its CatchHandler @ 00164015 */
plVar3 = (long *)std::
map<std::__cxx11::string,unsigned_long,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,unsigned_long>>>
::operator[](local_e8,(string *)(*(long *)param_2 + lVar4));
*plVar3 = lVar5;
lVar4 = lVar4 + 0x20;
}
/* try { // try from 00163ea0 to 00163eac has its CatchHandler @ 00164013 */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::vector(local_b8,param_2);
/* try { // try from 00163eb2 to 00163ebc has its CatchHandler @ 00164004 */
std::__cxx11::string::string(local_a0,param_1);
/* try { // try from 00163ec5 to 00163ed1 has its CatchHandler @ 00163ff7 */
std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,unsigned_long>,std::_Select1st<std::pair<std::__cxx11::string_const,unsigned_long>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,unsigned_long>>>
::_Rb_tree(local_80,(_Rb_tree *)local_e8);
/* try { // try from 00163eda to 00163ee6 has its CatchHandler @ 00163fea */
std::function<minja::Value(std::shared_ptr<minja::Context>const&,minja::Value&)>::function
(local_50,param_3);
local_f8 = (code *)0x0;
pcStack_f0 = (code *)0x0;
local_108 = (vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)0x0;
uStack_100 = 0;
/* try { // try from 00163ef4 to 00163efd has its CatchHandler @ 00163fd1 */
this_00 = (vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)operator_new(0x88);
/* try { // try from 00163efe to 00163f0d has its CatchHandler @ 00163fbf */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::vector
(this_00,(vector *)local_b8);
/* try { // try from 00163f12 to 00163f1c has its CatchHandler @ 00163fb2 */
std::__cxx11::string::string((string *)(this_00 + 0x18),local_a0);
std::_Rb_tree_header::_Rb_tree_header((_Rb_tree_header *)(this_00 + 0x40),local_78);
/* try { // try from 00163f32 to 00163f39 has its CatchHandler @ 00163f99 */
std::function<minja::Value(std::shared_ptr<minja::Context>const&,minja::Value&)>::function
((function<minja::Value(std::shared_ptr<minja::Context>const&,minja::Value&)> *)
(this_00 + 0x68),local_50);
pcStack_f0 = std::
_Function_handler<minja::Value(std::shared_ptr<minja::Context>const&,minja::ArgumentsValue&),minja::simple_function(std::__cxx11::string_const&,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&,std::function<minja::Value(std::shared_ptr<minja::Context>const&,minja::Value&)>const&)::$_0>
::_M_invoke;
local_f8 = std::
_Function_handler<minja::Value(std::shared_ptr<minja::Context>const&,minja::ArgumentsValue&),minja::simple_function(std::__cxx11::string_const&,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&,std::function<minja::Value(std::shared_ptr<minja::Context>const&,minja::Value&)>const&)::$_0>
::_M_manager;
local_108 = this_00;
/* try { // try from 00163f58 to 00163f63 has its CatchHandler @ 00163f97 */
Value::callable(this);
std::_Function_base::~_Function_base((_Function_base *)&local_108);
simple_function(std::__cxx11::string_const&,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&,std::function<minja::Value(std::shared_ptr<minja::Context>const&,minja::Value&)>const&)
::$_0::~__0((__0 *)local_b8);
std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,unsigned_long>,std::_Select1st<std::pair<std::__cxx11::string_const,unsigned_long>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,unsigned_long>>>
::~_Rb_tree((_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,unsigned_long>,std::_Select1st<std::pair<std::__cxx11::string_const,unsigned_long>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,unsigned_long>>>
*)local_e8);
return this;
}
|
|
11,707 |
mp_add
|
bluesky950520[P]quickjs/libbf.c
|
limb_t mp_add(limb_t *res, const limb_t *op1, const limb_t *op2,
limb_t n, limb_t carry)
{
slimb_t i;
limb_t k, a, v, k1;
k = carry;
for(i=0;i<n;i++) {
v = op1[i];
a = v + op2[i];
k1 = a < v;
a = a + k;
k = (a < k) | k1;
res[i] = a;
}
return k;
}
|
O3
|
c
|
mp_add:
movq %r8, %rax
testq %rcx, %rcx
je 0x87fb9
xorl %r8d, %r8d
movq (%rdx,%r8,8), %r9
addq (%rsi,%r8,8), %r9
setb %r10b
addq %rax, %r9
setb %al
orb %r10b, %al
movzbl %al, %eax
movq %r9, (%rdi,%r8,8)
incq %r8
cmpq %r8, %rcx
jne 0x87f95
retq
|
mp_add:
mov rax, r8
test rcx, rcx
jz short locret_87FB9
xor r8d, r8d
loc_87F95:
mov r9, [rdx+r8*8]
add r9, [rsi+r8*8]
setb r10b
add r9, rax
setb al
or al, r10b
movzx eax, al
mov [rdi+r8*8], r9
inc r8
cmp rcx, r8
jnz short loc_87F95
locret_87FB9:
retn
|
long long mp_add(long long a1, long long a2, long long a3, long long a4, long long a5)
{
long long result; // rax
long long i; // r8
long long v7; // r9
bool v8; // cf
long long v9; // r9
bool v10; // r10
long long v11; // r9
result = a5;
if ( a4 )
{
for ( i = 0LL; i != a4; ++i )
{
v7 = *(_QWORD *)(a3 + 8 * i);
v8 = __CFADD__(*(_QWORD *)(a2 + 8 * i), v7);
v9 = *(_QWORD *)(a2 + 8 * i) + v7;
v10 = v8;
v8 = __CFADD__(result, v9);
v11 = result + v9;
result = v10 | (unsigned __int8)v8;
*(_QWORD *)(a1 + 8 * i) = v11;
}
}
return result;
}
|
mp_add:
MOV RAX,R8
TEST RCX,RCX
JZ 0x00187fb9
XOR R8D,R8D
LAB_00187f95:
MOV R9,qword ptr [RDX + R8*0x8]
ADD R9,qword ptr [RSI + R8*0x8]
SETC R10B
ADD R9,RAX
SETC AL
OR AL,R10B
MOVZX EAX,AL
MOV qword ptr [RDI + R8*0x8],R9
INC R8
CMP RCX,R8
JNZ 0x00187f95
LAB_00187fb9:
RET
|
void mp_add(long param_1,long param_2,long param_3,long param_4,ulong param_5)
{
ulong *puVar1;
ulong uVar2;
long lVar3;
ulong uVar4;
long lVar5;
if (param_4 != 0) {
lVar3 = 0;
do {
uVar2 = *(ulong *)(param_3 + lVar3 * 8);
puVar1 = (ulong *)(param_2 + lVar3 * 8);
uVar4 = uVar2 + *puVar1;
lVar5 = uVar4 + param_5;
param_5 = (ulong)(CARRY8(uVar4,param_5) || CARRY8(uVar2,*puVar1));
*(long *)(param_1 + lVar3 * 8) = lVar5;
lVar3 = lVar3 + 1;
} while (param_4 != lVar3);
}
return;
}
|
|
11,708 |
coro::thread_pool::spawn(coro::task<void>&&)
|
AlayaLite/build_O3/_deps/libcoro-src/src/thread_pool.cpp
|
auto thread_pool::spawn(coro::task<void>&& task) noexcept -> bool
{
m_size.fetch_add(1, std::memory_order::release);
auto wrapper_task = detail::make_task_self_deleting(std::move(task));
wrapper_task.promise().executor_size(m_size);
return resume(wrapper_task.handle());
}
|
O3
|
cpp
|
coro::thread_pool::spawn(coro::task<void>&&):
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
lock
incq 0x120(%rdi)
movq (%rsi), %rax
movq $0x0, (%rsi)
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x8(%rsp), %rdi
callq 0x499d
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x3da7
callq *0x8(%rdi)
leaq 0x120(%rbx), %r14
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x497c
movq 0x8(%rsp), %rsi
cmpq $0x0, -0x10(%rsi)
je 0x3ddd
lock
incq 0x120(%rbx)
movb 0x128(%rbx), %al
testb $0x1, %al
je 0x3de1
lock
decq (%r14)
xorl %ebx, %ebx
jmp 0x3def
addq $-0x10, %rsi
movq %rbx, %rdi
callq 0x3868
movb $0x1, %bl
leaq 0x8(%rsp), %rdi
callq 0x4984
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
jmp 0x3e05
movq %rax, %rdi
callq 0x2d32
nop
|
_ZN4coro11thread_pool5spawnEONS_4taskIvEE:
push r14
push rbx
sub rsp, 18h
mov rbx, rdi
lock inc qword ptr [rdi+120h]
mov rax, [rsi]
mov qword ptr [rsi], 0
lea rsi, [rsp+28h+var_18]
mov [rsi], rax
lea rdi, [rsp+28h+var_20]; this
call _ZN4coro6detail23make_task_self_deletingENS_4taskIvEE; coro::detail::make_task_self_deleting(coro::task<void>)
mov rdi, [rsp+28h+var_18]
test rdi, rdi
jz short loc_3DA7
call qword ptr [rdi+8]
loc_3DA7:
lea r14, [rbx+120h]
mov rdi, [rsp+28h+var_20]
mov rsi, r14
call _ZN4coro6detail21promise_self_deleting13executor_sizeERSt6atomicImE; coro::detail::promise_self_deleting::executor_size(std::atomic<ulong> &)
mov rsi, [rsp+28h+var_20]
cmp qword ptr [rsi-10h], 0
jz short loc_3DDD
lock inc qword ptr [rbx+120h]
mov al, [rbx+128h]
test al, 1
jz short loc_3DE1
lock dec qword ptr [r14]
loc_3DDD:
xor ebx, ebx
jmp short loc_3DEF
loc_3DE1:
add rsi, 0FFFFFFFFFFFFFFF0h
mov rdi, rbx
call _ZN4coro11thread_pool13schedule_implENSt7__n486116coroutine_handleIvEE; coro::thread_pool::schedule_impl(std::__n4861::coroutine_handle<void>)
mov bl, 1
loc_3DEF:
lea rdi, [rsp+28h+var_20]; this
call _ZN4coro6detail18task_self_deletingD2Ev; coro::detail::task_self_deleting::~task_self_deleting()
mov eax, ebx
add rsp, 18h
pop rbx
pop r14
retn
jmp short $+2
loc_3E05:
mov rdi, rax
call __clang_call_terminate
|
long long coro::thread_pool::spawn(long long a1, long long *a2)
{
unsigned int v2; // ebx
long long v3; // rax
long long v4; // rsi
long long v6; // [rsp+8h] [rbp-20h] BYREF
long long v7; // [rsp+10h] [rbp-18h]
v2 = a1;
_InterlockedIncrement64((volatile signed long long *)(a1 + 288));
v3 = *a2;
*a2 = 0LL;
v7 = v3;
coro::detail::make_task_self_deleting((coro::detail::task_self_deleting *)&v6);
if ( v7 )
(*(void (**)(void))(v7 + 8))();
coro::detail::promise_self_deleting::executor_size(v6, a1 + 288);
v4 = v6;
if ( *(_QWORD *)(v6 - 16) )
{
_InterlockedIncrement64((volatile signed long long *)(a1 + 288));
if ( (*(_BYTE *)(a1 + 296) & 1) == 0 )
{
coro::thread_pool::schedule_impl(a1, (_QWORD *)(v4 - 16));
LOBYTE(v2) = 1;
goto LABEL_8;
}
_InterlockedDecrement64((volatile signed long long *)(a1 + 288));
}
v2 = 0;
LABEL_8:
coro::detail::task_self_deleting::~task_self_deleting((coro::detail::task_self_deleting *)&v6);
return v2;
}
|
spawn:
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
INC.LOCK qword ptr [RDI + 0x120]
MOV RAX,qword ptr [RSI]
MOV qword ptr [RSI],0x0
LEA RSI,[RSP + 0x10]
MOV qword ptr [RSI],RAX
LAB_00103d90:
LEA RDI,[RSP + 0x8]
CALL 0x0010499d
MOV RDI,qword ptr [RSP + 0x10]
TEST RDI,RDI
JZ 0x00103da7
LAB_00103da4:
CALL qword ptr [RDI + 0x8]
LAB_00103da7:
LEA R14,[RBX + 0x120]
MOV RDI,qword ptr [RSP + 0x8]
LAB_00103db3:
MOV RSI,R14
CALL 0x0010497c
MOV RSI,qword ptr [RSP + 0x8]
CMP qword ptr [RSI + -0x10],0x0
JZ 0x00103ddd
INC.LOCK qword ptr [RBX + 0x120]
MOV AL,byte ptr [RBX + 0x128]
TEST AL,0x1
JZ 0x00103de1
DEC.LOCK qword ptr [R14]
LAB_00103ddd:
XOR EBX,EBX
JMP 0x00103def
LAB_00103de1:
ADD RSI,-0x10
MOV RDI,RBX
CALL 0x00103868
MOV BL,0x1
LAB_00103def:
LEA RDI,[RSP + 0x8]
CALL 0x00104984
MOV EAX,EBX
ADD RSP,0x18
POP RBX
POP R14
RET
|
/* coro::thread_pool::spawn(coro::task<void>&&) */
ulong __thiscall coro::thread_pool::spawn(thread_pool *this,task *param_1)
{
atomic *paVar1;
ulong uVar2;
promise_self_deleting *local_20;
long local_18;
LOCK();
*(long *)(this + 0x120) = *(long *)(this + 0x120) + 1;
UNLOCK();
local_18 = *(long *)param_1;
*(int8 *)param_1 = 0;
/* try { // try from 00103d90 to 00103d99 has its CatchHandler @ 00103e05 */
detail::make_task_self_deleting((detail *)&local_20);
if (local_18 != 0) {
/* try { // try from 00103da4 to 00103da6 has its CatchHandler @ 00103e03 */
(**(code **)(local_18 + 8))();
}
paVar1 = (atomic *)(this + 0x120);
/* try { // try from 00103db3 to 00103dba has its CatchHandler @ 00103e05 */
detail::promise_self_deleting::executor_size(local_20,paVar1);
if (*(long *)(local_20 + -0x10) != 0) {
LOCK();
*(long *)(this + 0x120) = *(long *)(this + 0x120) + 1;
UNLOCK();
if (((byte)this[0x128] & 1) == 0) {
schedule_impl(this,local_20 + -0x10);
uVar2 = CONCAT71((int7)((ulong)this >> 8),1);
goto LAB_00103def;
}
LOCK();
*(long *)paVar1 = *(long *)paVar1 + -1;
UNLOCK();
}
uVar2 = 0;
LAB_00103def:
detail::task_self_deleting::~task_self_deleting((task_self_deleting *)&local_20);
return uVar2 & 0xffffffff;
}
|
|
11,709 |
exchange_int16s
|
bluesky950520[P]quickjs/cutils.c
|
static void exchange_int16s(void *a, void *b, size_t size) {
uint16_t *ap = (uint16_t *)a;
uint16_t *bp = (uint16_t *)b;
for (size /= sizeof(uint16_t); size-- != 0;) {
uint16_t t = *ap;
*ap++ = *bp;
*bp++ = t;
}
}
|
O0
|
c
|
exchange_int16s:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x18(%rsp), %rax
shrq %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x18(%rsp)
cmpq $0x0, %rax
je 0x2024b
movq -0x20(%rsp), %rax
movw (%rax), %ax
movw %ax, -0x2a(%rsp)
movq -0x28(%rsp), %rax
movw (%rax), %cx
movq -0x20(%rsp), %rax
movq %rax, %rdx
addq $0x2, %rdx
movq %rdx, -0x20(%rsp)
movw %cx, (%rax)
movw -0x2a(%rsp), %cx
movq -0x28(%rsp), %rax
movq %rax, %rdx
addq $0x2, %rdx
movq %rdx, -0x28(%rsp)
movw %cx, (%rax)
jmp 0x201f0
retq
nopl (%rax)
|
exchange_int16s:
mov [rsp+var_8], rdi
mov [rsp+var_10], rsi
mov [rsp+var_18], rdx
mov rax, [rsp+var_8]
mov [rsp+var_20], rax
mov rax, [rsp+var_10]
mov [rsp+var_28], rax
mov rax, [rsp+var_18]
shr rax, 1
mov [rsp+var_18], rax
loc_201F0:
mov rax, [rsp+var_18]
mov rcx, rax
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rsp+var_18], rcx
loc_20201:
cmp rax, 0
jz short locret_2024B
mov rax, [rsp+var_20]
mov ax, [rax]
mov [rsp+var_2A], ax
mov rax, [rsp+var_28]
mov cx, [rax]
mov rax, [rsp+var_20]
mov rdx, rax
add rdx, 2
mov [rsp+var_20], rdx
mov [rax], cx
mov cx, [rsp+var_2A]
mov rax, [rsp+var_28]
mov rdx, rax
add rdx, 2
mov [rsp+var_28], rdx
mov [rax], cx
jmp short loc_201F0
locret_2024B:
retn
|
long long exchange_int16s(__int16 *a1, __int16 *a2, unsigned long long a3)
{
long long result; // rax
__int16 *v4; // rax
__int16 *v5; // rax
__int16 v6; // [rsp+0h] [rbp-2Ah]
unsigned long long v9; // [rsp+12h] [rbp-18h]
v9 = a3 >> 1;
while ( 1 )
{
result = v9--;
if ( !result )
break;
v6 = *a1;
v4 = a1++;
*v4 = *a2;
v5 = a2++;
*v5 = v6;
}
return result;
}
|
exchange_int16s:
MOV qword ptr [RSP + -0x8],RDI
MOV qword ptr [RSP + -0x10],RSI
MOV qword ptr [RSP + -0x18],RDX
MOV RAX,qword ptr [RSP + -0x8]
MOV qword ptr [RSP + -0x20],RAX
MOV RAX,qword ptr [RSP + -0x10]
MOV qword ptr [RSP + -0x28],RAX
MOV RAX,qword ptr [RSP + -0x18]
SHR RAX,0x1
MOV qword ptr [RSP + -0x18],RAX
LAB_001201f0:
MOV RAX,qword ptr [RSP + -0x18]
MOV RCX,RAX
ADD RCX,-0x1
MOV qword ptr [RSP + -0x18],RCX
CMP RAX,0x0
JZ 0x0012024b
MOV RAX,qword ptr [RSP + -0x20]
MOV AX,word ptr [RAX]
MOV word ptr [RSP + -0x2a],AX
MOV RAX,qword ptr [RSP + -0x28]
MOV CX,word ptr [RAX]
MOV RAX,qword ptr [RSP + -0x20]
MOV RDX,RAX
ADD RDX,0x2
MOV qword ptr [RSP + -0x20],RDX
MOV word ptr [RAX],CX
MOV CX,word ptr [RSP + -0x2a]
MOV RAX,qword ptr [RSP + -0x28]
MOV RDX,RAX
ADD RDX,0x2
MOV qword ptr [RSP + -0x28],RDX
MOV word ptr [RAX],CX
JMP 0x001201f0
LAB_0012024b:
RET
|
void exchange_int16s(int2 *param_1,int2 *param_2,ulong param_3)
{
int2 uVar1;
int2 *local_28;
int2 *local_20;
ulong local_18;
local_28 = param_2;
local_20 = param_1;
local_18 = param_3 >> 1;
while (local_18 != 0) {
uVar1 = *local_20;
*local_20 = *local_28;
*local_28 = uVar1;
local_28 = local_28 + 1;
local_20 = local_20 + 1;
local_18 = local_18 - 1;
}
return;
}
|
|
11,710 |
exchange_int16s
|
bluesky950520[P]quickjs/cutils.c
|
static void exchange_int16s(void *a, void *b, size_t size) {
uint16_t *ap = (uint16_t *)a;
uint16_t *bp = (uint16_t *)b;
for (size /= sizeof(uint16_t); size-- != 0;) {
uint16_t t = *ap;
*ap++ = *bp;
*bp++ = t;
}
}
|
O1
|
c
|
exchange_int16s:
cmpq $0x2, %rdx
jb 0x1bd55
shrq %rdx
xorl %eax, %eax
movzwl (%rdi,%rax,2), %ecx
movzwl (%rsi,%rax,2), %r8d
movw %r8w, (%rdi,%rax,2)
movw %cx, (%rsi,%rax,2)
incq %rax
cmpq %rax, %rdx
jne 0x1bd3b
retq
|
exchange_int16s:
cmp rdx, 2
jb short locret_1BD55
shr rdx, 1
xor eax, eax
loc_1BD3B:
movzx ecx, word ptr [rdi+rax*2]
movzx r8d, word ptr [rsi+rax*2]
mov [rdi+rax*2], r8w
mov [rsi+rax*2], cx
inc rax
cmp rdx, rax
jnz short loc_1BD3B
locret_1BD55:
retn
|
void exchange_int16s(long long a1, long long a2, unsigned long long a3)
{
unsigned long long v3; // rdx
long long v4; // rax
__int16 v5; // cx
if ( a3 >= 2 )
{
v3 = a3 >> 1;
v4 = 0LL;
do
{
v5 = *(_WORD *)(a1 + 2 * v4);
*(_WORD *)(a1 + 2 * v4) = *(_WORD *)(a2 + 2 * v4);
*(_WORD *)(a2 + 2 * v4++) = v5;
}
while ( v3 != v4 );
}
}
|
exchange_int16s:
CMP RDX,0x2
JC 0x0011bd55
SHR RDX,0x1
XOR EAX,EAX
LAB_0011bd3b:
MOVZX ECX,word ptr [RDI + RAX*0x2]
MOVZX R8D,word ptr [RSI + RAX*0x2]
MOV word ptr [RDI + RAX*0x2],R8W
MOV word ptr [RSI + RAX*0x2],CX
INC RAX
CMP RDX,RAX
JNZ 0x0011bd3b
LAB_0011bd55:
RET
|
void exchange_int16s(long param_1,long param_2,ulong param_3)
{
int2 uVar1;
ulong uVar2;
if (1 < param_3) {
uVar2 = 0;
do {
uVar1 = *(int2 *)(param_1 + uVar2 * 2);
*(int2 *)(param_1 + uVar2 * 2) = *(int2 *)(param_2 + uVar2 * 2);
*(int2 *)(param_2 + uVar2 * 2) = uVar1;
uVar2 = uVar2 + 1;
} while (param_3 >> 1 != uVar2);
}
return;
}
|
|
11,711 |
exchange_int16s
|
bluesky950520[P]quickjs/cutils.c
|
static void exchange_int16s(void *a, void *b, size_t size) {
uint16_t *ap = (uint16_t *)a;
uint16_t *bp = (uint16_t *)b;
for (size /= sizeof(uint16_t); size-- != 0;) {
uint16_t t = *ap;
*ap++ = *bp;
*bp++ = t;
}
}
|
O3
|
c
|
exchange_int16s:
cmpq $0x2, %rdx
jb 0x1c62b
shrq %rdx
xorl %eax, %eax
movzwl (%rdi,%rax,2), %ecx
movzwl (%rsi,%rax,2), %r8d
movw %r8w, (%rdi,%rax,2)
movw %cx, (%rsi,%rax,2)
incq %rax
cmpq %rax, %rdx
jne 0x1c611
retq
|
exchange_int16s:
cmp rdx, 2
jb short locret_1C62B
shr rdx, 1
xor eax, eax
loc_1C611:
movzx ecx, word ptr [rdi+rax*2]
movzx r8d, word ptr [rsi+rax*2]
mov [rdi+rax*2], r8w
mov [rsi+rax*2], cx
inc rax
cmp rdx, rax
jnz short loc_1C611
locret_1C62B:
retn
|
void exchange_int16s(long long a1, long long a2, unsigned long long a3)
{
unsigned long long v3; // rdx
long long v4; // rax
__int16 v5; // cx
if ( a3 >= 2 )
{
v3 = a3 >> 1;
v4 = 0LL;
do
{
v5 = *(_WORD *)(a1 + 2 * v4);
*(_WORD *)(a1 + 2 * v4) = *(_WORD *)(a2 + 2 * v4);
*(_WORD *)(a2 + 2 * v4++) = v5;
}
while ( v3 != v4 );
}
}
|
exchange_int16s:
CMP RDX,0x2
JC 0x0011c62b
SHR RDX,0x1
XOR EAX,EAX
LAB_0011c611:
MOVZX ECX,word ptr [RDI + RAX*0x2]
MOVZX R8D,word ptr [RSI + RAX*0x2]
MOV word ptr [RDI + RAX*0x2],R8W
MOV word ptr [RSI + RAX*0x2],CX
INC RAX
CMP RDX,RAX
JNZ 0x0011c611
LAB_0011c62b:
RET
|
void exchange_int16s(long param_1,long param_2,ulong param_3)
{
int2 uVar1;
ulong uVar2;
if (1 < param_3) {
uVar2 = 0;
do {
uVar1 = *(int2 *)(param_1 + uVar2 * 2);
*(int2 *)(param_1 + uVar2 * 2) = *(int2 *)(param_2 + uVar2 * 2);
*(int2 *)(param_2 + uVar2 * 2) = uVar1;
uVar2 = uVar2 + 1;
} while (param_3 >> 1 != uVar2);
}
return;
}
|
|
11,712 |
mi_ck_write
|
eloqsql/storage/myisam/mi_write.c
|
int _mi_ck_write(MI_INFO *info, uint keynr, uchar *key, uint key_length)
{
DBUG_ENTER("_mi_ck_write");
if (info->bulk_insert && is_tree_inited(&info->bulk_insert[keynr]))
{
DBUG_RETURN(_mi_ck_write_tree(info, keynr, key, key_length));
}
else
{
DBUG_RETURN(_mi_ck_write_btree(info, keynr, key, key_length));
}
}
|
O3
|
c
|
mi_ck_write:
movq %rdi, %rax
movq 0x80(%rdi), %rdi
testq %rdi, %rdi
je 0x8824a
movl %esi, %r8d
imulq $0x298, %r8, %r8 # imm = 0x298
cmpq $0x0, (%rdi,%r8)
je 0x8824a
pushq %rbp
movq %rsp, %rbp
addq %r8, %rdi
movq (%rax), %rax
addl 0x338(%rax), %ecx
movq 0x230(%rdi), %rax
movq %rdx, %rsi
movl %ecx, %edx
movq %rax, %rcx
callq 0xa482a
xorl %ecx, %ecx
testq %rax, %rax
sete %cl
shll $0x7, %ecx
movl %ecx, %eax
popq %rbp
retq
movq %rax, %rdi
jmp 0x88297
|
_mi_ck_write:
mov rax, rdi
mov rdi, [rdi+80h]
test rdi, rdi
jz short loc_8824A
mov r8d, esi
imul r8, 298h
cmp qword ptr [rdi+r8], 0
jz short loc_8824A
push rbp
mov rbp, rsp
add rdi, r8
mov rax, [rax]
add ecx, [rax+338h]
mov rax, [rdi+230h]
mov rsi, rdx
mov edx, ecx
mov rcx, rax
call tree_insert
xor ecx, ecx
test rax, rax
setz cl
shl ecx, 7
mov eax, ecx
pop rbp
retn
loc_8824A:
mov rdi, rax
jmp _mi_ck_write_btree
|
long long mi_ck_write(_QWORD *a1, unsigned int a2, long long a3, int a4)
{
long long v5; // rdi
long long v6; // r8
v5 = a1[16];
if ( v5 && (v6 = 664LL * a2, *(_QWORD *)(v5 + v6)) )
return (unsigned __int8)(tree_insert(
v6 + v5,
a3,
(unsigned int)(*(_DWORD *)(*a1 + 824LL) + a4),
*(_QWORD *)(v6 + v5 + 560)) == 0) << 7;
else
return mi_ck_write_btree(a1);
}
|
_mi_ck_write:
MOV RAX,RDI
MOV RDI,qword ptr [RDI + 0x80]
TEST RDI,RDI
JZ 0x0018824a
MOV R8D,ESI
IMUL R8,R8,0x298
CMP qword ptr [RDI + R8*0x1],0x0
JZ 0x0018824a
PUSH RBP
MOV RBP,RSP
ADD RDI,R8
MOV RAX,qword ptr [RAX]
ADD ECX,dword ptr [RAX + 0x338]
MOV RAX,qword ptr [RDI + 0x230]
MOV RSI,RDX
MOV EDX,ECX
MOV RCX,RAX
CALL 0x001a482a
XOR ECX,ECX
TEST RAX,RAX
SETZ CL
SHL ECX,0x7
MOV EAX,ECX
POP RBP
RET
LAB_0018824a:
MOV RDI,RAX
JMP 0x00188297
|
long _mi_ck_write(long *param_1,ulong param_2,int8 param_3,int param_4)
{
long lVar1;
long lVar2;
lVar1 = param_1[0x10];
if ((lVar1 != 0) && (lVar2 = (param_2 & 0xffffffff) * 0x298, *(long *)(lVar1 + lVar2) != 0)) {
lVar1 = lVar1 + lVar2;
lVar1 = tree_insert(lVar1,param_3,param_4 + *(int *)(*param_1 + 0x338),
*(int8 *)(lVar1 + 0x230));
return (ulong)(lVar1 == 0) << 7;
}
lVar1 = _mi_ck_write_btree(param_1);
return lVar1;
}
|
|
11,713 |
OpenSubdiv::v3_6_0::Far::GregoryConverter<float>::resizeMatrixUnisolated(OpenSubdiv::v3_6_0::Far::SparseMatrix<float>&) const
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/catmarkPatchBuilder.cpp
|
void
GregoryConverter<REAL>::resizeMatrixUnisolated(Matrix & matrix) const {
int rowSizes[20];
int numElements = 0;
for (int cIndex = 0; cIndex < 4; ++cIndex) {
int * rowSize = rowSizes + cIndex*5;
CornerTopology const & corner = _corners[cIndex];
// First, the corner and pair of edge points:
if (corner.isRegular) {
if (! corner.isBoundary) {
rowSize[0] = 9;
rowSize[1] = 6;
rowSize[2] = 6;
} else {
rowSize[0] = 3;
rowSize[1] = corner.epOnBoundary ? 2 : 6;
rowSize[2] = corner.emOnBoundary ? 2 : 6;
}
} else {
if (corner.isSharp) {
rowSize[0] = 1;
rowSize[1] = 2;
rowSize[2] = 2;
} else if (! corner.isBoundary) {
int ringSize = 1 + 2 * corner.valence;
rowSize[0] = ringSize;
rowSize[1] = ringSize;
rowSize[2] = ringSize;
} else if (corner.numFaces > 1) {
int ringSize = 1 + corner.valence + corner.numFaces;
rowSize[0] = 3;
rowSize[1] = corner.epOnBoundary ? 2 : ringSize;
rowSize[2] = corner.emOnBoundary ? 2 : ringSize;
} else {
rowSize[0] = 3;
rowSize[1] = 2;
rowSize[2] = 2;
}
}
numElements += rowSize[0] + rowSize[1] + rowSize[2];
// Second, the pair of face points:
rowSize[3] = 4;
rowSize[4] = 4;
if (!corner.fpIsRegular || !corner.fmIsRegular) {
int cNext = (cIndex + 1) & 0x3;
int cPrev = (cIndex + 3) & 0x3;
if (!corner.fpIsRegular) {
rowSize[3] = getIrregularFacePointSize(cIndex,
corner.fpIsCopied ? cPrev : cNext);
}
if (!corner.fmIsRegular) {
rowSize[4] = getIrregularFacePointSize(cIndex,
corner.fmIsCopied ? cNext : cPrev);
}
}
numElements += rowSize[3] + rowSize[4];
}
_resizeMatrix(matrix, 20, _numSourcePoints, numElements, rowSizes);
}
|
O0
|
cpp
|
OpenSubdiv::v3_6_0::Far::GregoryConverter<float>::resizeMatrixUnisolated(OpenSubdiv::v3_6_0::Far::SparseMatrix<float>&) const:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movl $0x0, -0x64(%rbp)
movl $0x0, -0x68(%rbp)
cmpl $0x4, -0x68(%rbp)
jge 0x10f0c9
movq -0x90(%rbp), %rax
leaq -0x60(%rbp), %rcx
imull $0x5, -0x68(%rbp), %edx
movslq %edx, %rdx
shlq $0x2, %rdx
addq %rdx, %rcx
movq %rcx, -0x70(%rbp)
addq $0x18, %rax
movslq -0x68(%rbp), %rcx
imulq $0xd8, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movw (%rax), %ax
shrw $0x3, %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0x10edfa
movq -0x78(%rbp), %rax
movw (%rax), %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
jne 0x10ed99
movq -0x70(%rbp), %rax
movl $0x9, (%rax)
movq -0x70(%rbp), %rax
movl $0x6, 0x4(%rax)
movq -0x70(%rbp), %rax
movl $0x6, 0x8(%rax)
jmp 0x10edf5
movq -0x70(%rbp), %rax
movl $0x3, (%rax)
movq -0x78(%rbp), %rax
movw (%rax), %ax
shrw $0x5, %ax
andw $0x1, %ax
movzwl %ax, %edx
movl $0x6, %ecx
movl $0x2, %eax
cmpl $0x0, %edx
cmovnel %eax, %ecx
movq -0x70(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x78(%rbp), %rax
movw (%rax), %ax
shrw $0x6, %ax
andw $0x1, %ax
movzwl %ax, %edx
movl $0x6, %ecx
movl $0x2, %eax
cmpl $0x0, %edx
cmovnel %eax, %ecx
movq -0x70(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0x10ef41
movq -0x78(%rbp), %rax
movw (%rax), %ax
shrw %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0x10ee35
movq -0x70(%rbp), %rax
movl $0x1, (%rax)
movq -0x70(%rbp), %rax
movl $0x2, 0x4(%rax)
movq -0x70(%rbp), %rax
movl $0x2, 0x8(%rax)
jmp 0x10ef3f
movq -0x78(%rbp), %rax
movw (%rax), %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
jne 0x10ee79
movq -0x78(%rbp), %rax
movl 0x4(%rax), %eax
shll %eax
addl $0x1, %eax
movl %eax, -0x7c(%rbp)
movl -0x7c(%rbp), %ecx
movq -0x70(%rbp), %rax
movl %ecx, (%rax)
movl -0x7c(%rbp), %ecx
movq -0x70(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x7c(%rbp), %ecx
movq -0x70(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0x10ef3d
movq -0x78(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jle 0x10ef1b
movq -0x78(%rbp), %rax
movl 0x4(%rax), %eax
addl $0x1, %eax
movq -0x78(%rbp), %rcx
addl 0x8(%rcx), %eax
movl %eax, -0x80(%rbp)
movq -0x70(%rbp), %rax
movl $0x3, (%rax)
movq -0x78(%rbp), %rax
movw (%rax), %ax
shrw $0x5, %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0x10eec9
movl $0x2, %eax
movl %eax, -0x94(%rbp)
jmp 0x10eed2
movl -0x80(%rbp), %eax
movl %eax, -0x94(%rbp)
movl -0x94(%rbp), %ecx
movq -0x70(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x78(%rbp), %rax
movw (%rax), %ax
shrw $0x6, %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0x10ef03
movl $0x2, %eax
movl %eax, -0x98(%rbp)
jmp 0x10ef0c
movl -0x80(%rbp), %eax
movl %eax, -0x98(%rbp)
movl -0x98(%rbp), %ecx
movq -0x70(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0x10ef3b
movq -0x70(%rbp), %rax
movl $0x3, (%rax)
movq -0x70(%rbp), %rax
movl $0x2, 0x4(%rax)
movq -0x70(%rbp), %rax
movl $0x2, 0x8(%rax)
jmp 0x10ef3d
jmp 0x10ef3f
jmp 0x10ef41
movq -0x70(%rbp), %rax
movl (%rax), %eax
movq -0x70(%rbp), %rcx
addl 0x4(%rcx), %eax
movq -0x70(%rbp), %rcx
addl 0x8(%rcx), %eax
addl -0x64(%rbp), %eax
movl %eax, -0x64(%rbp)
movq -0x70(%rbp), %rax
movl $0x4, 0xc(%rax)
movq -0x70(%rbp), %rax
movl $0x4, 0x10(%rax)
movq -0x78(%rbp), %rax
movw (%rax), %ax
shrw $0x7, %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0x10efa3
movq -0x78(%rbp), %rax
movw (%rax), %ax
shrw $0x8, %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
jne 0x10f0a7
movl -0x68(%rbp), %eax
addl $0x1, %eax
andl $0x3, %eax
movl %eax, -0x84(%rbp)
movl -0x68(%rbp), %eax
addl $0x3, %eax
andl $0x3, %eax
movl %eax, -0x88(%rbp)
movq -0x78(%rbp), %rax
movw (%rax), %ax
shrw $0x7, %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
jne 0x10f033
movl -0x68(%rbp), %eax
movl %eax, -0x9c(%rbp)
movq -0x78(%rbp), %rax
movw (%rax), %ax
shrw $0x9, %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0x10f006
movl -0x88(%rbp), %eax
movl %eax, -0xa0(%rbp)
jmp 0x10f012
movl -0x84(%rbp), %eax
movl %eax, -0xa0(%rbp)
movl -0x9c(%rbp), %esi
movq -0x90(%rbp), %rdi
movl -0xa0(%rbp), %edx
callq 0xc78f0
movl %eax, %ecx
movq -0x70(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x78(%rbp), %rax
movw (%rax), %ax
shrw $0x8, %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
jne 0x10f0a5
movl -0x68(%rbp), %eax
movl %eax, -0xa4(%rbp)
movq -0x78(%rbp), %rax
movw (%rax), %ax
shrw $0xa, %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0x10f078
movl -0x84(%rbp), %eax
movl %eax, -0xa8(%rbp)
jmp 0x10f084
movl -0x88(%rbp), %eax
movl %eax, -0xa8(%rbp)
movl -0xa4(%rbp), %esi
movq -0x90(%rbp), %rdi
movl -0xa8(%rbp), %edx
callq 0xc78f0
movl %eax, %ecx
movq -0x70(%rbp), %rax
movl %ecx, 0x10(%rax)
jmp 0x10f0a7
movq -0x70(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x70(%rbp), %rcx
addl 0x10(%rcx), %eax
addl -0x64(%rbp), %eax
movl %eax, -0x64(%rbp)
movl -0x68(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x68(%rbp)
jmp 0x10ed0c
movq -0x90(%rbp), %rax
movq -0x10(%rbp), %rdi
movl (%rax), %edx
movl -0x64(%rbp), %ecx
leaq -0x60(%rbp), %r8
movl $0x14, %esi
callq 0x10b570
addq $0xb0, %rsp
popq %rbp
retq
|
_ZNK10OpenSubdiv6v3_6_03Far16GregoryConverterIfE22resizeMatrixUnisolatedERNS1_12SparseMatrixIfEE:
push rbp
mov rbp, rsp
sub rsp, 0B0h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov [rbp+var_90], rax
mov [rbp+var_64], 0
mov [rbp+var_68], 0
loc_10ED0C:
cmp [rbp+var_68], 4
jge loc_10F0C9
mov rax, [rbp+var_90]
lea rcx, [rbp+var_60]
imul edx, [rbp+var_68], 5
movsxd rdx, edx
shl rdx, 2
add rcx, rdx
mov [rbp+var_70], rcx
add rax, 18h
movsxd rcx, [rbp+var_68]
imul rcx, 0D8h
add rax, rcx
mov [rbp+var_78], rax
mov rax, [rbp+var_78]
mov ax, [rax]
shr ax, 3
and ax, 1
movzx eax, ax
cmp eax, 0
jz loc_10EDFA
mov rax, [rbp+var_78]
mov ax, [rax]
and ax, 1
movzx eax, ax
cmp eax, 0
jnz short loc_10ED99
mov rax, [rbp+var_70]
mov dword ptr [rax], 9
mov rax, [rbp+var_70]
mov dword ptr [rax+4], 6
mov rax, [rbp+var_70]
mov dword ptr [rax+8], 6
jmp short loc_10EDF5
loc_10ED99:
mov rax, [rbp+var_70]
mov dword ptr [rax], 3
mov rax, [rbp+var_78]
mov ax, [rax]
shr ax, 5
and ax, 1
movzx edx, ax
mov ecx, 6
mov eax, 2
cmp edx, 0
cmovnz ecx, eax
mov rax, [rbp+var_70]
mov [rax+4], ecx
mov rax, [rbp+var_78]
mov ax, [rax]
shr ax, 6
and ax, 1
movzx edx, ax
mov ecx, 6
mov eax, 2
cmp edx, 0
cmovnz ecx, eax
mov rax, [rbp+var_70]
mov [rax+8], ecx
loc_10EDF5:
jmp loc_10EF41
loc_10EDFA:
mov rax, [rbp+var_78]
mov ax, [rax]
shr ax, 1
and ax, 1
movzx eax, ax
cmp eax, 0
jz short loc_10EE35
mov rax, [rbp+var_70]
mov dword ptr [rax], 1
mov rax, [rbp+var_70]
mov dword ptr [rax+4], 2
mov rax, [rbp+var_70]
mov dword ptr [rax+8], 2
jmp loc_10EF3F
loc_10EE35:
mov rax, [rbp+var_78]
mov ax, [rax]
and ax, 1
movzx eax, ax
cmp eax, 0
jnz short loc_10EE79
mov rax, [rbp+var_78]
mov eax, [rax+4]
shl eax, 1
add eax, 1
mov [rbp+var_7C], eax
mov ecx, [rbp+var_7C]
mov rax, [rbp+var_70]
mov [rax], ecx
mov ecx, [rbp+var_7C]
mov rax, [rbp+var_70]
mov [rax+4], ecx
mov ecx, [rbp+var_7C]
mov rax, [rbp+var_70]
mov [rax+8], ecx
jmp loc_10EF3D
loc_10EE79:
mov rax, [rbp+var_78]
cmp dword ptr [rax+8], 1
jle loc_10EF1B
mov rax, [rbp+var_78]
mov eax, [rax+4]
add eax, 1
mov rcx, [rbp+var_78]
add eax, [rcx+8]
mov [rbp+var_80], eax
mov rax, [rbp+var_70]
mov dword ptr [rax], 3
mov rax, [rbp+var_78]
mov ax, [rax]
shr ax, 5
and ax, 1
movzx eax, ax
cmp eax, 0
jz short loc_10EEC9
mov eax, 2
mov [rbp+var_94], eax
jmp short loc_10EED2
loc_10EEC9:
mov eax, [rbp+var_80]
mov [rbp+var_94], eax
loc_10EED2:
mov ecx, [rbp+var_94]
mov rax, [rbp+var_70]
mov [rax+4], ecx
mov rax, [rbp+var_78]
mov ax, [rax]
shr ax, 6
and ax, 1
movzx eax, ax
cmp eax, 0
jz short loc_10EF03
mov eax, 2
mov [rbp+var_98], eax
jmp short loc_10EF0C
loc_10EF03:
mov eax, [rbp+var_80]
mov [rbp+var_98], eax
loc_10EF0C:
mov ecx, [rbp+var_98]
mov rax, [rbp+var_70]
mov [rax+8], ecx
jmp short loc_10EF3B
loc_10EF1B:
mov rax, [rbp+var_70]
mov dword ptr [rax], 3
mov rax, [rbp+var_70]
mov dword ptr [rax+4], 2
mov rax, [rbp+var_70]
mov dword ptr [rax+8], 2
loc_10EF3B:
jmp short $+2
loc_10EF3D:
jmp short $+2
loc_10EF3F:
jmp short $+2
loc_10EF41:
mov rax, [rbp+var_70]
mov eax, [rax]
mov rcx, [rbp+var_70]
add eax, [rcx+4]
mov rcx, [rbp+var_70]
add eax, [rcx+8]
add eax, [rbp+var_64]
mov [rbp+var_64], eax
mov rax, [rbp+var_70]
mov dword ptr [rax+0Ch], 4
mov rax, [rbp+var_70]
mov dword ptr [rax+10h], 4
mov rax, [rbp+var_78]
mov ax, [rax]
shr ax, 7
and ax, 1
movzx eax, ax
cmp eax, 0
jz short loc_10EFA3
mov rax, [rbp+var_78]
mov ax, [rax]
shr ax, 8
and ax, 1
movzx eax, ax
cmp eax, 0
jnz loc_10F0A7
loc_10EFA3:
mov eax, [rbp+var_68]
add eax, 1
and eax, 3
mov [rbp+var_84], eax
mov eax, [rbp+var_68]
add eax, 3
and eax, 3
mov [rbp+var_88], eax
mov rax, [rbp+var_78]
mov ax, [rax]
shr ax, 7
and ax, 1
movzx eax, ax
cmp eax, 0
jnz short loc_10F033
mov eax, [rbp+var_68]
mov [rbp+var_9C], eax
mov rax, [rbp+var_78]
mov ax, [rax]
shr ax, 9
and ax, 1
movzx eax, ax
cmp eax, 0
jz short loc_10F006
mov eax, [rbp+var_88]
mov [rbp+var_A0], eax
jmp short loc_10F012
loc_10F006:
mov eax, [rbp+var_84]
mov [rbp+var_A0], eax
loc_10F012:
mov esi, [rbp+var_9C]
mov rdi, [rbp+var_90]
mov edx, [rbp+var_A0]
call __ZNK10OpenSubdiv6v3_6_03Far16GregoryConverterIfE25getIrregularFacePointSizeEii; OpenSubdiv::v3_6_0::Far::GregoryConverter<float>::getIrregularFacePointSize(int,int)
mov ecx, eax
mov rax, [rbp+var_70]
mov [rax+0Ch], ecx
loc_10F033:
mov rax, [rbp+var_78]
mov ax, [rax]
shr ax, 8
and ax, 1
movzx eax, ax
cmp eax, 0
jnz short loc_10F0A5
mov eax, [rbp+var_68]
mov [rbp+var_A4], eax
mov rax, [rbp+var_78]
mov ax, [rax]
shr ax, 0Ah
and ax, 1
movzx eax, ax
cmp eax, 0
jz short loc_10F078
mov eax, [rbp+var_84]
mov [rbp+var_A8], eax
jmp short loc_10F084
loc_10F078:
mov eax, [rbp+var_88]
mov [rbp+var_A8], eax
loc_10F084:
mov esi, [rbp+var_A4]
mov rdi, [rbp+var_90]
mov edx, [rbp+var_A8]
call __ZNK10OpenSubdiv6v3_6_03Far16GregoryConverterIfE25getIrregularFacePointSizeEii; OpenSubdiv::v3_6_0::Far::GregoryConverter<float>::getIrregularFacePointSize(int,int)
mov ecx, eax
mov rax, [rbp+var_70]
mov [rax+10h], ecx
loc_10F0A5:
jmp short $+2
loc_10F0A7:
mov rax, [rbp+var_70]
mov eax, [rax+0Ch]
mov rcx, [rbp+var_70]
add eax, [rcx+10h]
add eax, [rbp+var_64]
mov [rbp+var_64], eax
mov eax, [rbp+var_68]
add eax, 1
mov [rbp+var_68], eax
jmp loc_10ED0C
loc_10F0C9:
mov rax, [rbp+var_90]
mov rdi, [rbp+var_10]
mov edx, [rax]
mov ecx, [rbp+var_64]
lea r8, [rbp+var_60]
mov esi, 14h
call _ZN10OpenSubdiv6v3_6_03Far12_GLOBAL__N_113_resizeMatrixIfEEvRNS1_12SparseMatrixIT_EEiiiPKi; OpenSubdiv::v3_6_0::Far::`anonymous namespace'::_resizeMatrix<float>(OpenSubdiv::v3_6_0::Far::SparseMatrix<float> &,int,int,int,int const*)
add rsp, 0B0h
pop rbp
retn
|
long long OpenSubdiv::v3_6_0::Far::GregoryConverter<float>::resizeMatrixUnisolated(
unsigned int *a1,
long long a2)
{
int v2; // ecx
int v3; // ecx
unsigned int v5; // [rsp+8h] [rbp-A8h]
unsigned int v6; // [rsp+10h] [rbp-A0h]
int v7; // [rsp+18h] [rbp-98h]
int v8; // [rsp+1Ch] [rbp-94h]
int v9; // [rsp+30h] [rbp-80h]
int v10; // [rsp+34h] [rbp-7Ch]
long long v11; // [rsp+38h] [rbp-78h]
int *v12; // [rsp+40h] [rbp-70h]
int i; // [rsp+48h] [rbp-68h]
unsigned int v14; // [rsp+4Ch] [rbp-64h]
unsigned int v15; // [rsp+4Ch] [rbp-64h]
_DWORD v16[20]; // [rsp+50h] [rbp-60h] BYREF
long long v17; // [rsp+A0h] [rbp-10h]
unsigned int *v18; // [rsp+A8h] [rbp-8h]
v18 = a1;
v17 = a2;
v14 = 0;
for ( i = 0; i < 4; ++i )
{
v12 = &v16[5 * i];
v11 = (long long)&a1[54 * i + 6];
if ( ((*(_WORD *)v11 >> 3) & 1) != 0 )
{
if ( (*(_WORD *)v11 & 1) != 0 )
{
*v12 = 3;
v2 = 6;
if ( ((*(_WORD *)v11 >> 5) & 1) != 0 )
v2 = 2;
v12[1] = v2;
v3 = 6;
if ( ((*(_WORD *)v11 >> 6) & 1) != 0 )
v3 = 2;
v12[2] = v3;
}
else
{
*v12 = 9;
v12[1] = 6;
v12[2] = 6;
}
}
else if ( ((*(_WORD *)v11 >> 1) & 1) != 0 )
{
*v12 = 1;
v12[1] = 2;
v12[2] = 2;
}
else if ( (*(_WORD *)v11 & 1) != 0 )
{
if ( *(int *)(v11 + 8) <= 1 )
{
*v12 = 3;
v12[1] = 2;
v12[2] = 2;
}
else
{
v9 = *(_DWORD *)(v11 + 8) + *(_DWORD *)(v11 + 4) + 1;
*v12 = 3;
if ( ((*(_WORD *)v11 >> 5) & 1) != 0 )
v8 = 2;
else
v8 = v9;
v12[1] = v8;
if ( ((*(_WORD *)v11 >> 6) & 1) != 0 )
v7 = 2;
else
v7 = v9;
v12[2] = v7;
}
}
else
{
v10 = 2 * *(_DWORD *)(v11 + 4) + 1;
*v12 = v10;
v12[1] = v10;
v12[2] = v10;
}
v15 = v14 + v12[2] + v12[1] + *v12;
v12[3] = 4;
v12[4] = 4;
if ( ((*(_WORD *)v11 >> 7) & 1) == 0 || (*(_WORD *)v11 & 0x100) == 0 )
{
if ( ((*(_WORD *)v11 >> 7) & 1) == 0 )
{
if ( ((*(_WORD *)v11 >> 9) & 1) != 0 )
v6 = ((_BYTE)i + 3) & 3;
else
v6 = ((_BYTE)i + 1) & 3;
v12[3] = OpenSubdiv::v3_6_0::Far::GregoryConverter<float>::getIrregularFacePointSize(a1, (unsigned int)i, v6);
}
if ( (*(_WORD *)v11 & 0x100) == 0 )
{
if ( ((*(_WORD *)v11 >> 10) & 1) != 0 )
v5 = ((_BYTE)i + 1) & 3;
else
v5 = ((_BYTE)i + 3) & 3;
v12[4] = OpenSubdiv::v3_6_0::Far::GregoryConverter<float>::getIrregularFacePointSize(a1, (unsigned int)i, v5);
}
}
v14 = v15 + v12[4] + v12[3];
}
return OpenSubdiv::v3_6_0::Far::`anonymous namespace'::_resizeMatrix<float>(v17, 0x14u, *a1, v14, (long long)v16);
}
| |||
11,714 |
OpenSubdiv::v3_6_0::Far::GregoryConverter<float>::resizeMatrixUnisolated(OpenSubdiv::v3_6_0::Far::SparseMatrix<float>&) const
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/catmarkPatchBuilder.cpp
|
void
GregoryConverter<REAL>::resizeMatrixUnisolated(Matrix & matrix) const {
int rowSizes[20];
int numElements = 0;
for (int cIndex = 0; cIndex < 4; ++cIndex) {
int * rowSize = rowSizes + cIndex*5;
CornerTopology const & corner = _corners[cIndex];
// First, the corner and pair of edge points:
if (corner.isRegular) {
if (! corner.isBoundary) {
rowSize[0] = 9;
rowSize[1] = 6;
rowSize[2] = 6;
} else {
rowSize[0] = 3;
rowSize[1] = corner.epOnBoundary ? 2 : 6;
rowSize[2] = corner.emOnBoundary ? 2 : 6;
}
} else {
if (corner.isSharp) {
rowSize[0] = 1;
rowSize[1] = 2;
rowSize[2] = 2;
} else if (! corner.isBoundary) {
int ringSize = 1 + 2 * corner.valence;
rowSize[0] = ringSize;
rowSize[1] = ringSize;
rowSize[2] = ringSize;
} else if (corner.numFaces > 1) {
int ringSize = 1 + corner.valence + corner.numFaces;
rowSize[0] = 3;
rowSize[1] = corner.epOnBoundary ? 2 : ringSize;
rowSize[2] = corner.emOnBoundary ? 2 : ringSize;
} else {
rowSize[0] = 3;
rowSize[1] = 2;
rowSize[2] = 2;
}
}
numElements += rowSize[0] + rowSize[1] + rowSize[2];
// Second, the pair of face points:
rowSize[3] = 4;
rowSize[4] = 4;
if (!corner.fpIsRegular || !corner.fmIsRegular) {
int cNext = (cIndex + 1) & 0x3;
int cPrev = (cIndex + 3) & 0x3;
if (!corner.fpIsRegular) {
rowSize[3] = getIrregularFacePointSize(cIndex,
corner.fpIsCopied ? cPrev : cNext);
}
if (!corner.fmIsRegular) {
rowSize[4] = getIrregularFacePointSize(cIndex,
corner.fmIsCopied ? cNext : cPrev);
}
}
numElements += rowSize[3] + rowSize[4];
}
_resizeMatrix(matrix, 20, _numSourcePoints, numElements, rowSizes);
}
|
O1
|
cpp
|
OpenSubdiv::v3_6_0::Far::GregoryConverter<float>::resizeMatrixUnisolated(OpenSubdiv::v3_6_0::Far::SparseMatrix<float>&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, 0x28(%rsp)
movq %rdi, 0x10(%rsp)
leaq 0x18(%rdi), %r12
xorl %r14d, %r14d
movq $-0x4, %rsi
leaq 0x30(%rsp), %rbx
movabsq $0x400000004, %rdi # imm = 0x400000004
movzwl (%r12), %eax
testb $0x8, %al
jne 0x515ea
testb $0x2, %al
jne 0x51602
testb $0x1, %al
jne 0x51719
movl 0x4(%r12), %ecx
leal 0x1(,%rcx,2), %edx
movl %edx, (%rbx)
movl %edx, 0x4(%rbx)
jmp 0x5163b
testb $0x1, %al
jne 0x51616
movabsq $0x600000009, %rcx # imm = 0x600000009
movq %rcx, (%rbx)
movl $0x6, %edx
jmp 0x5163b
movabsq $0x200000001, %rcx # imm = 0x200000001
movq %rcx, (%rbx)
movl $0x2, %edx
jmp 0x5163b
movl $0x3, (%rbx)
xorl %ecx, %ecx
testb $0x20, %al
sete %cl
leal 0x2(,%rcx,4), %ecx
movl %ecx, 0x4(%rbx)
xorl %ecx, %ecx
testb $0x40, %al
sete %cl
leal 0x2(,%rcx,4), %edx
movl %edx, 0x8(%rbx)
movl (%rbx), %ebp
movl 0x4(%rbx), %r8d
movq %rdi, 0xc(%rbx)
movl %eax, %ecx
notl %ecx
testl $0x180, %ecx # imm = 0x180
je 0x516f1
leal 0x5(%rsi), %r15d
andl $0x3, %r15d
leal -0x1(%rsi), %r13d
andl $0x3, %r13d
testb %al, %al
movl %edx, 0xc(%rsp)
js 0x516b2
btl $0x9, %eax
movl %r13d, %edx
cmovael %r15d, %edx
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
leal 0x4(%rax), %esi
movq 0x10(%rsp), %rdi
movl %r8d, 0x1c(%rsp)
callq 0x3a740
movl 0x1c(%rsp), %r8d
movl 0xc(%rsp), %edx
movabsq $0x400000004, %rdi # imm = 0x400000004
movq 0x20(%rsp), %rsi
movl %eax, 0xc(%rbx)
movl (%r12), %eax
btl $0x8, %eax
jb 0x516f1
btl $0xa, %eax
cmovael %r13d, %r15d
movq %rsi, %r13
addl $0x4, %esi
movq 0x10(%rsp), %rdi
movl %r15d, %edx
movl %r8d, %r15d
callq 0x3a740
movl %r15d, %r8d
movl 0xc(%rsp), %edx
movabsq $0x400000004, %rdi # imm = 0x400000004
movq %r13, %rsi
movl %eax, 0x10(%rbx)
addl %r14d, %ebp
addl %r8d, %ebp
addl %edx, %ebp
addl 0xc(%rbx), %ebp
movl %ebp, %r14d
addl 0x10(%rbx), %r14d
addq $0x14, %rbx
addq $0xe0, %r12
incq %rsi
jne 0x515c2
jmp 0x5175d
movl 0x8(%r12), %ecx
cmpl $0x2, %ecx
jl 0x5174e
movl 0x4(%r12), %edx
addl %ecx, %edx
incl %edx
movl $0x3, (%rbx)
testb $0x20, %al
movl $0x2, %ecx
cmovel %edx, %ecx
movl %ecx, 0x4(%rbx)
testb $0x40, %al
movl $0x2, %ecx
cmovnel %ecx, %edx
jmp 0x5163b
movabsq $0x200000003, %rcx # imm = 0x200000003
jmp 0x5160c
movq 0x10(%rsp), %rax
movl (%rax), %esi
leaq 0x30(%rsp), %rcx
movq 0x28(%rsp), %rdi
movl %r14d, %edx
callq 0x4d473
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_ZNK10OpenSubdiv6v3_6_03Far16GregoryConverterIdE22resizeMatrixUnisolatedERNS1_12SparseMatrixIdEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 88h
mov [rsp+0B8h+var_90], rsi
mov [rsp+0B8h+var_A8], rdi
lea r12, [rdi+18h]
xor r14d, r14d
mov rsi, 0FFFFFFFFFFFFFFFCh
lea rbx, [rsp+0B8h+var_88]
mov rdi, 400000004h
loc_515C2:
movzx eax, word ptr [r12]
test al, 8
jnz short loc_515EA
test al, 2
jnz short loc_51602
test al, 1
jnz loc_51719
mov ecx, [r12+4]
lea edx, ds:1[rcx*2]
mov [rbx], edx
mov [rbx+4], edx
jmp short loc_5163B
loc_515EA:
test al, 1
jnz short loc_51616
mov rcx, 600000009h
mov [rbx], rcx
mov edx, 6
jmp short loc_5163B
loc_51602:
mov rcx, 200000001h
loc_5160C:
mov [rbx], rcx
mov edx, 2
jmp short loc_5163B
loc_51616:
mov dword ptr [rbx], 3
xor ecx, ecx
test al, 20h
setz cl
lea ecx, ds:2[rcx*4]
mov [rbx+4], ecx
xor ecx, ecx
test al, 40h
setz cl
lea edx, ds:2[rcx*4]
loc_5163B:
mov [rbx+8], edx
mov ebp, [rbx]
mov r8d, [rbx+4]
mov [rbx+0Ch], rdi
mov ecx, eax
not ecx
test ecx, 180h
jz loc_516F1
lea r15d, [rsi+5]
and r15d, 3
lea r13d, [rsi-1]
and r13d, 3
test al, al
mov [rsp+0B8h+var_AC], edx
js short loc_516B2
bt eax, 9
mov edx, r13d
cmovnb edx, r15d
mov [rsp+0B8h+var_98], rsi
mov rax, [rsp+0B8h+var_98]
lea esi, [rax+4]
mov rdi, [rsp+0B8h+var_A8]
mov [rsp+0B8h+var_9C], r8d
call __ZNK10OpenSubdiv6v3_6_03Far16GregoryConverterIdE25getIrregularFacePointSizeEii; OpenSubdiv::v3_6_0::Far::GregoryConverter<double>::getIrregularFacePointSize(int,int)
mov r8d, [rsp+0B8h+var_9C]
mov edx, [rsp+0B8h+var_AC]
mov rdi, 400000004h
mov rsi, [rsp+0B8h+var_98]
mov [rbx+0Ch], eax
loc_516B2:
mov eax, [r12]
bt eax, 8
jb short loc_516F1
bt eax, 0Ah
cmovnb r15d, r13d
mov r13, rsi
add esi, 4
mov rdi, [rsp+0B8h+var_A8]
mov edx, r15d
mov r15d, r8d
call __ZNK10OpenSubdiv6v3_6_03Far16GregoryConverterIdE25getIrregularFacePointSizeEii; OpenSubdiv::v3_6_0::Far::GregoryConverter<double>::getIrregularFacePointSize(int,int)
mov r8d, r15d
mov edx, [rsp+0B8h+var_AC]
mov rdi, 400000004h
mov rsi, r13
mov [rbx+10h], eax
loc_516F1:
add ebp, r14d
add ebp, r8d
add ebp, edx
add ebp, [rbx+0Ch]
mov r14d, ebp
add r14d, [rbx+10h]
add rbx, 14h
add r12, 0E0h
inc rsi
jnz loc_515C2
jmp short loc_5175D
loc_51719:
mov ecx, [r12+8]
cmp ecx, 2
jl short loc_5174E
mov edx, [r12+4]
add edx, ecx
inc edx
mov dword ptr [rbx], 3
test al, 20h
mov ecx, 2
cmovz ecx, edx
mov [rbx+4], ecx
test al, 40h
mov ecx, 2
cmovnz edx, ecx
jmp loc_5163B
loc_5174E:
mov rcx, 200000003h
jmp loc_5160C
loc_5175D:
mov rax, [rsp+0B8h+var_A8]
mov esi, [rax]
lea rcx, [rsp+0B8h+var_88]
mov rdi, [rsp+0B8h+var_90]
mov edx, r14d
call _ZN10OpenSubdiv6v3_6_03Far12_GLOBAL__N_113_resizeMatrixIdEEvRNS1_12SparseMatrixIT_EEiiiPKi; OpenSubdiv::v3_6_0::Far::`anonymous namespace'::_resizeMatrix<double>(OpenSubdiv::v3_6_0::Far::SparseMatrix<double> &,int,int,int,int const*)
add rsp, 88h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long OpenSubdiv::v3_6_0::Far::GregoryConverter<double>::resizeMatrixUnisolated(int *a1, int *a2)
{
_DWORD *v2; // r12
int v3; // r14d
long long v4; // rsi
_BYTE *v5; // rbx
int v6; // eax
int v7; // edx
long long v8; // rcx
int v9; // ebp
int v10; // r8d
unsigned int v11; // r15d
long long v12; // rdx
int IrregularFacePointSize; // eax
long long v14; // rdx
int v15; // r15d
int v16; // eax
int v17; // ecx
int v18; // ecx
int v20; // [rsp+Ch] [rbp-ACh]
int v21; // [rsp+1Ch] [rbp-9Ch]
_BYTE v23[136]; // [rsp+30h] [rbp-88h] BYREF
v2 = a1 + 6;
v3 = 0;
v4 = -4LL;
v5 = v23;
do
{
v6 = *(unsigned __int16 *)v2;
if ( (v6 & 8) != 0 )
{
if ( (v6 & 1) != 0 )
{
*(_DWORD *)v5 = 3;
*((_DWORD *)v5 + 1) = 4 * ((v6 & 0x20) == 0) + 2;
v7 = 4 * ((v6 & 0x40) == 0) + 2;
}
else
{
*(_QWORD *)v5 = 0x600000009LL;
v7 = 6;
}
}
else
{
if ( (v6 & 2) != 0 )
{
v8 = 0x200000001LL;
LABEL_9:
*(_QWORD *)v5 = v8;
v7 = 2;
goto LABEL_11;
}
if ( (v6 & 1) == 0 )
{
v7 = 2 * v2[1] + 1;
*(_DWORD *)v5 = v7;
*((_DWORD *)v5 + 1) = v7;
goto LABEL_11;
}
v17 = v2[2];
if ( v17 < 2 )
{
v8 = 0x200000003LL;
goto LABEL_9;
}
v7 = v17 + v2[1] + 1;
*(_DWORD *)v5 = 3;
v18 = 2;
if ( (v6 & 0x20) == 0 )
v18 = v7;
*((_DWORD *)v5 + 1) = v18;
if ( (v6 & 0x40) != 0 )
v7 = 2;
}
LABEL_11:
*((_DWORD *)v5 + 2) = v7;
v9 = *(_DWORD *)v5;
v10 = *((_DWORD *)v5 + 1);
*(_QWORD *)(v5 + 12) = 0x400000004LL;
if ( (~v6 & 0x180) != 0 )
{
v11 = ((_BYTE)v4 + 5) & 3;
v20 = v7;
if ( (v6 & 0x80u) == 0 )
{
v12 = ((_BYTE)v4 - 1) & 3;
if ( (v6 & 0x200) == 0 )
v12 = ((_BYTE)v4 + 5) & 3;
v21 = v10;
IrregularFacePointSize = OpenSubdiv::v3_6_0::Far::GregoryConverter<double>::getIrregularFacePointSize(
a1,
(unsigned int)(v4 + 4),
v12);
v10 = v21;
v7 = v20;
*((_DWORD *)v5 + 3) = IrregularFacePointSize;
}
if ( (*v2 & 0x100) == 0 )
{
if ( (*v2 & 0x400) == 0 )
v11 = ((_BYTE)v4 - 1) & 3;
v14 = v11;
v15 = v10;
v16 = OpenSubdiv::v3_6_0::Far::GregoryConverter<double>::getIrregularFacePointSize(
a1,
(unsigned int)(v4 + 4),
v14);
v10 = v15;
v7 = v20;
*((_DWORD *)v5 + 4) = v16;
}
}
v3 += *((_DWORD *)v5 + 4) + *((_DWORD *)v5 + 3) + v7 + v10 + v9;
v5 += 20;
v2 += 56;
++v4;
}
while ( v4 );
return OpenSubdiv::v3_6_0::Far::`anonymous namespace'::_resizeMatrix<double>(a2, *a1, v3, (long long)v23);
}
|
resizeMatrixUnisolated:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x88
MOV qword ptr [RSP + 0x28],RSI
MOV qword ptr [RSP + 0x10],RDI
LEA R12,[RDI + 0x18]
XOR R14D,R14D
MOV RSI,-0x4
LEA RBX,[RSP + 0x30]
MOV RDI,0x400000004
LAB_001515c2:
MOVZX EAX,word ptr [R12]
TEST AL,0x8
JNZ 0x001515ea
TEST AL,0x2
JNZ 0x00151602
TEST AL,0x1
JNZ 0x00151719
MOV ECX,dword ptr [R12 + 0x4]
LEA EDX,[0x1 + RCX*0x2]
MOV dword ptr [RBX],EDX
MOV dword ptr [RBX + 0x4],EDX
JMP 0x0015163b
LAB_001515ea:
TEST AL,0x1
JNZ 0x00151616
MOV RCX,0x600000009
MOV qword ptr [RBX],RCX
MOV EDX,0x6
JMP 0x0015163b
LAB_00151602:
MOV RCX,0x200000001
LAB_0015160c:
MOV qword ptr [RBX],RCX
MOV EDX,0x2
JMP 0x0015163b
LAB_00151616:
MOV dword ptr [RBX],0x3
XOR ECX,ECX
TEST AL,0x20
SETZ CL
LEA ECX,[0x2 + RCX*0x4]
MOV dword ptr [RBX + 0x4],ECX
XOR ECX,ECX
TEST AL,0x40
SETZ CL
LEA EDX,[0x2 + RCX*0x4]
LAB_0015163b:
MOV dword ptr [RBX + 0x8],EDX
MOV EBP,dword ptr [RBX]
MOV R8D,dword ptr [RBX + 0x4]
MOV qword ptr [RBX + 0xc],RDI
MOV ECX,EAX
NOT ECX
TEST ECX,0x180
JZ 0x001516f1
LEA R15D,[RSI + 0x5]
AND R15D,0x3
LEA R13D,[RSI + -0x1]
AND R13D,0x3
TEST AL,AL
MOV dword ptr [RSP + 0xc],EDX
JS 0x001516b2
BT EAX,0x9
MOV EDX,R13D
CMOVNC EDX,R15D
MOV qword ptr [RSP + 0x20],RSI
MOV RAX,qword ptr [RSP + 0x20]
LEA ESI,[RAX + 0x4]
MOV RDI,qword ptr [RSP + 0x10]
MOV dword ptr [RSP + 0x1c],R8D
CALL 0x0013a740
MOV R8D,dword ptr [RSP + 0x1c]
MOV EDX,dword ptr [RSP + 0xc]
MOV RDI,0x400000004
MOV RSI,qword ptr [RSP + 0x20]
MOV dword ptr [RBX + 0xc],EAX
LAB_001516b2:
MOV EAX,dword ptr [R12]
BT EAX,0x8
JC 0x001516f1
BT EAX,0xa
CMOVNC R15D,R13D
MOV R13,RSI
ADD ESI,0x4
MOV RDI,qword ptr [RSP + 0x10]
MOV EDX,R15D
MOV R15D,R8D
CALL 0x0013a740
MOV R8D,R15D
MOV EDX,dword ptr [RSP + 0xc]
MOV RDI,0x400000004
MOV RSI,R13
MOV dword ptr [RBX + 0x10],EAX
LAB_001516f1:
ADD EBP,R14D
ADD EBP,R8D
ADD EBP,EDX
ADD EBP,dword ptr [RBX + 0xc]
MOV R14D,EBP
ADD R14D,dword ptr [RBX + 0x10]
ADD RBX,0x14
ADD R12,0xe0
INC RSI
JNZ 0x001515c2
JMP 0x0015175d
LAB_00151719:
MOV ECX,dword ptr [R12 + 0x8]
CMP ECX,0x2
JL 0x0015174e
MOV EDX,dword ptr [R12 + 0x4]
ADD EDX,ECX
INC EDX
MOV dword ptr [RBX],0x3
TEST AL,0x20
MOV ECX,0x2
CMOVZ ECX,EDX
MOV dword ptr [RBX + 0x4],ECX
TEST AL,0x40
MOV ECX,0x2
CMOVNZ EDX,ECX
JMP 0x0015163b
LAB_0015174e:
MOV RCX,0x200000003
JMP 0x0015160c
LAB_0015175d:
MOV RAX,qword ptr [RSP + 0x10]
MOV ESI,dword ptr [RAX]
LEA RCX,[RSP + 0x30]
MOV RDI,qword ptr [RSP + 0x28]
MOV EDX,R14D
CALL 0x0014d473
ADD RSP,0x88
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* OpenSubdiv::v3_6_0::Far::GregoryConverter<double>::resizeMatrixUnisolated(OpenSubdiv::v3_6_0::Far::SparseMatrix<double>&)
const */
void __thiscall
OpenSubdiv::v3_6_0::Far::GregoryConverter<double>::resizeMatrixUnisolated
(GregoryConverter<double> *this,SparseMatrix *param_1)
{
ushort uVar1;
uint uVar2;
uint uVar3;
int iVar4;
int iVar5;
int iVar6;
int8 uVar7;
int iVar8;
int *piVar9;
long lVar10;
GregoryConverter<double> *pGVar11;
uint uVar12;
int iVar13;
uint uVar14;
int local_88 [22];
pGVar11 = this + 0x18;
iVar13 = 0;
lVar10 = -4;
piVar9 = local_88;
do {
uVar1 = *(ushort *)pGVar11;
if ((uVar1 & 8) == 0) {
if ((uVar1 & 2) == 0) {
if ((uVar1 & 1) == 0) {
iVar8 = *(uint *)(pGVar11 + 4) * 2 + 1;
*piVar9 = iVar8;
piVar9[1] = iVar8;
}
else {
if ((int)*(uint *)(pGVar11 + 8) < 2) {
uVar7 = 0x200000003;
goto LAB_0015160c;
}
iVar8 = *(uint *)(pGVar11 + 4) + *(uint *)(pGVar11 + 8) + 1;
*piVar9 = 3;
iVar6 = 2;
if ((uVar1 & 0x20) == 0) {
iVar6 = iVar8;
}
piVar9[1] = iVar6;
if ((uVar1 & 0x40) != 0) {
iVar8 = 2;
}
}
}
else {
uVar7 = 0x200000001;
LAB_0015160c:
*(int8 *)piVar9 = uVar7;
iVar8 = 2;
}
}
else if ((uVar1 & 1) == 0) {
piVar9[0] = 9;
piVar9[1] = 6;
iVar8 = 6;
}
else {
*piVar9 = 3;
piVar9[1] = (uint)((uVar1 & 0x20) == 0) * 4 + 2;
iVar8 = (uint)((uVar1 & 0x40) == 0) * 4 + 2;
}
piVar9[2] = iVar8;
iVar6 = *piVar9;
uVar2 = piVar9[1];
piVar9[3] = 4;
piVar9[4] = 4;
if ((~uVar1 & 0x180) != 0) {
iVar5 = (int)lVar10;
uVar14 = iVar5 + 5U & 3;
uVar12 = iVar5 - 1U & 3;
if (-1 < (char)uVar1) {
uVar3 = uVar12;
if ((uVar1 >> 9 & 1) == 0) {
uVar3 = uVar14;
}
iVar4 = getIrregularFacePointSize(this,iVar5 + 4,uVar3);
piVar9[3] = iVar4;
}
if ((*(uint *)pGVar11 >> 8 & 1) == 0) {
if ((*(uint *)pGVar11 >> 10 & 1) == 0) {
uVar14 = uVar12;
}
iVar5 = getIrregularFacePointSize(this,iVar5 + 4,uVar14);
piVar9[4] = iVar5;
}
}
iVar13 = iVar6 + iVar13 + uVar2 + iVar8 + piVar9[3] + piVar9[4];
piVar9 = piVar9 + 5;
pGVar11 = pGVar11 + 0xe0;
lVar10 = lVar10 + 1;
if (lVar10 == 0) {
(anonymous_namespace)::_resizeMatrix<double>
(param_1,*(int *)this,iVar13,(int)local_88,(int *)(ulong)uVar2);
return;
}
} while( true );
}
|
|
11,715 |
OpenSubdiv::v3_6_0::Far::GregoryConverter<float>::resizeMatrixUnisolated(OpenSubdiv::v3_6_0::Far::SparseMatrix<float>&) const
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/catmarkPatchBuilder.cpp
|
void
GregoryConverter<REAL>::resizeMatrixUnisolated(Matrix & matrix) const {
int rowSizes[20];
int numElements = 0;
for (int cIndex = 0; cIndex < 4; ++cIndex) {
int * rowSize = rowSizes + cIndex*5;
CornerTopology const & corner = _corners[cIndex];
// First, the corner and pair of edge points:
if (corner.isRegular) {
if (! corner.isBoundary) {
rowSize[0] = 9;
rowSize[1] = 6;
rowSize[2] = 6;
} else {
rowSize[0] = 3;
rowSize[1] = corner.epOnBoundary ? 2 : 6;
rowSize[2] = corner.emOnBoundary ? 2 : 6;
}
} else {
if (corner.isSharp) {
rowSize[0] = 1;
rowSize[1] = 2;
rowSize[2] = 2;
} else if (! corner.isBoundary) {
int ringSize = 1 + 2 * corner.valence;
rowSize[0] = ringSize;
rowSize[1] = ringSize;
rowSize[2] = ringSize;
} else if (corner.numFaces > 1) {
int ringSize = 1 + corner.valence + corner.numFaces;
rowSize[0] = 3;
rowSize[1] = corner.epOnBoundary ? 2 : ringSize;
rowSize[2] = corner.emOnBoundary ? 2 : ringSize;
} else {
rowSize[0] = 3;
rowSize[1] = 2;
rowSize[2] = 2;
}
}
numElements += rowSize[0] + rowSize[1] + rowSize[2];
// Second, the pair of face points:
rowSize[3] = 4;
rowSize[4] = 4;
if (!corner.fpIsRegular || !corner.fmIsRegular) {
int cNext = (cIndex + 1) & 0x3;
int cPrev = (cIndex + 3) & 0x3;
if (!corner.fpIsRegular) {
rowSize[3] = getIrregularFacePointSize(cIndex,
corner.fpIsCopied ? cPrev : cNext);
}
if (!corner.fmIsRegular) {
rowSize[4] = getIrregularFacePointSize(cIndex,
corner.fmIsCopied ? cNext : cPrev);
}
}
numElements += rowSize[3] + rowSize[4];
}
_resizeMatrix(matrix, 20, _numSourcePoints, numElements, rowSizes);
}
|
O2
|
cpp
|
OpenSubdiv::v3_6_0::Far::GregoryConverter<float>::resizeMatrixUnisolated(OpenSubdiv::v3_6_0::Far::SparseMatrix<float>&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, 0x30(%rsp)
movq %rdi, 0x10(%rsp)
leaq 0x18(%rdi), %rsi
xorl %r15d, %r15d
movabsq $0x400000004, %rdi # imm = 0x400000004
pushq $0x4
popq %r8
xorl %edx, %edx
movq %rsi, 0x18(%rsp)
cmpq $0x4, %r15
je 0x68785
imulq $0x14, %r15, %r10
imulq $0xe0, %r15, %rax
leaq (%rsi,%rax), %r11
movzwl (%rsi,%rax), %eax
testb $0x8, %al
jne 0x685c8
testb $0x2, %al
jne 0x685e7
testb $0x1, %al
jne 0x68732
movl 0x4(%r11), %ecx
leal 0x1(,%rcx,2), %ebp
movl %ebp, 0x40(%rsp,%r10)
movl %ebp, 0x44(%rsp,%r10)
movl %ebp, %r9d
movl %ebp, %ebx
jmp 0x68630
testb $0x1, %al
jne 0x68602
movabsq $0x600000009, %rcx # imm = 0x600000009
movq %rcx, 0x40(%rsp,%r10)
pushq $0x6
popq %rcx
movl %ecx, %ebp
movl %ecx, %r9d
pushq $0x9
jmp 0x6862f
movabsq $0x200000001, %rcx # imm = 0x200000001
movq %rcx, 0x40(%rsp,%r10)
pushq $0x2
popq %rcx
movl %ecx, %ebp
movl %ecx, %r9d
pushq $0x1
jmp 0x6862f
movl $0x3, 0x40(%rsp,%r10)
xorl %ecx, %ecx
testb $0x20, %al
sete %cl
leal 0x2(,%rcx,4), %r9d
movl %r9d, 0x44(%rsp,%r10)
xorl %ecx, %ecx
testb $0x40, %al
sete %cl
leal 0x2(,%rcx,4), %ebp
pushq $0x3
popq %rbx
movl %ebp, 0x48(%rsp,%r10)
movq %rdi, 0x4c(%rsp,%r10)
movl %eax, %ecx
notl %ecx
testw $0x180, %cx # imm = 0x180
jne 0x68653
incq %r15
movl %r8d, %eax
movl %r8d, %r12d
jmp 0x6871f
leaq 0x1(%r15), %rcx
movq %rcx, 0x20(%rsp)
movl %ecx, %r14d
andl $0x3, %r14d
leal -0x1(%r15), %r13d
andl $0x3, %r13d
testb %al, %al
movl %edx, 0xc(%rsp)
movq %r10, 0x28(%rsp)
movl %r9d, 0x8(%rsp)
js 0x686ce
movq %r11, 0x38(%rsp)
btl $0x9, %eax
movl %r14d, %edx
jae 0x6868e
movl %r13d, %edx
movq 0x10(%rsp), %rdi
movl %r15d, %esi
callq 0x53010
movl %eax, %r12d
movq 0x28(%rsp), %r10
movl %eax, 0x4c(%rsp,%r10)
movq 0x38(%rsp), %rax
movzwl (%rax), %eax
movq 0x18(%rsp), %rsi
movabsq $0x400000004, %rdi # imm = 0x400000004
pushq $0x4
popq %r8
movl 0xc(%rsp), %edx
movl 0x8(%rsp), %r9d
jmp 0x686d1
movl %r8d, %r12d
btl $0x8, %eax
jb 0x68717
btl $0xa, %eax
jae 0x686e0
movl %r14d, %r13d
movq 0x10(%rsp), %rdi
movl %r15d, %esi
movl %r13d, %edx
callq 0x53010
movq 0x28(%rsp), %rcx
movl %eax, 0x50(%rsp,%rcx)
movq 0x18(%rsp), %rsi
movabsq $0x400000004, %rdi # imm = 0x400000004
pushq $0x4
popq %r8
movl 0xc(%rsp), %edx
movl 0x8(%rsp), %r9d
jmp 0x6871a
movl %r8d, %eax
movq 0x20(%rsp), %r15
addl %edx, %ebx
addl %r9d, %ebx
addl %r12d, %ebp
addl %ebx, %ebp
addl %eax, %ebp
movl %ebp, %edx
jmp 0x6857f
movl 0x8(%r11), %ecx
cmpl $0x2, %ecx
jl 0x68769
movl 0x4(%r11), %r9d
leal (%rcx,%r9), %ebp
incl %ebp
movl $0x3, 0x40(%rsp,%r10)
testb $0x20, %al
pushq $0x2
popq %rcx
movl %ecx, %r9d
cmovel %ebp, %r9d
movl %r9d, 0x44(%rsp,%r10)
testb $0x40, %al
cmovnel %ecx, %ebp
jmp 0x6862d
movabsq $0x200000003, %rcx # imm = 0x200000003
movq %rcx, 0x40(%rsp,%r10)
pushq $0x2
popq %rcx
movl %ecx, %ebp
movl %ecx, %r9d
jmp 0x6862d
movq 0x10(%rsp), %rax
movl (%rax), %esi
leaq 0x40(%rsp), %rcx
movq 0x30(%rsp), %rdi
callq 0x64b75
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
_ZNK10OpenSubdiv6v3_6_03Far16GregoryConverterIdE22resizeMatrixUnisolatedERNS1_12SparseMatrixIdEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 98h
mov [rsp+0C8h+var_98], rsi
mov [rsp+0C8h+var_B8], rdi
lea rsi, [rdi+18h]
xor r15d, r15d
mov rdi, 400000004h
push 4
pop r8
xor edx, edx
mov [rsp+0C8h+var_B0], rsi
loc_6857F:
cmp r15, 4
jz loc_68785
imul r10, r15, 14h
imul rax, r15, 0E0h
lea r11, [rsi+rax]
movzx eax, word ptr [rsi+rax]
test al, 8
jnz short loc_685C8
test al, 2
jnz short loc_685E7
test al, 1
jnz loc_68732
mov ecx, [r11+4]
lea ebp, ds:1[rcx*2]
mov dword ptr [rsp+r10+0C8h+var_88], ebp
mov dword ptr [rsp+r10+0C8h+var_88+4], ebp
mov r9d, ebp
mov ebx, ebp
jmp short loc_68630
loc_685C8:
test al, 1
jnz short loc_68602
mov rcx, 600000009h
mov [rsp+r10+0C8h+var_88], rcx
push 6
pop rcx
mov ebp, ecx
mov r9d, ecx
push 9
jmp short loc_6862F
loc_685E7:
mov rcx, 200000001h
mov [rsp+r10+0C8h+var_88], rcx
push 2
pop rcx
mov ebp, ecx
mov r9d, ecx
push 1
jmp short loc_6862F
loc_68602:
mov dword ptr [rsp+r10+0C8h+var_88], 3
xor ecx, ecx
test al, 20h
setz cl
lea r9d, ds:2[rcx*4]
mov dword ptr [rsp+r10+0C8h+var_88+4], r9d
xor ecx, ecx
test al, 40h
setz cl
lea ebp, ds:2[rcx*4]
loc_6862D:
push 3
loc_6862F:
pop rbx
loc_68630:
mov [rsp+r10+0C8h+var_80], ebp
mov [rsp+r10+0C8h+var_7C], rdi
mov ecx, eax
not ecx
test cx, 180h
jnz short loc_68653
inc r15
mov eax, r8d
mov r12d, r8d
jmp loc_6871F
loc_68653:
lea rcx, [r15+1]
mov [rsp+0C8h+var_A8], rcx
mov r14d, ecx
and r14d, 3
lea r13d, [r15-1]
and r13d, 3
test al, al
mov [rsp+0C8h+var_BC], edx
mov [rsp+0C8h+var_A0], r10
mov [rsp+0C8h+var_C0], r9d
js short loc_686CE
mov [rsp+0C8h+var_90], r11
bt eax, 9
mov edx, r14d
jnb short loc_6868E
mov edx, r13d
loc_6868E:
mov rdi, [rsp+0C8h+var_B8]
mov esi, r15d
call __ZNK10OpenSubdiv6v3_6_03Far16GregoryConverterIdE25getIrregularFacePointSizeEii; OpenSubdiv::v3_6_0::Far::GregoryConverter<double>::getIrregularFacePointSize(int,int)
mov r12d, eax
mov r10, [rsp+0C8h+var_A0]
mov dword ptr [rsp+r10+0C8h+var_7C], eax
mov rax, [rsp+0C8h+var_90]
movzx eax, word ptr [rax]
mov rsi, [rsp+0C8h+var_B0]
mov rdi, 400000004h
push 4
pop r8
mov edx, [rsp+0C8h+var_BC]
mov r9d, [rsp+0C8h+var_C0]
jmp short loc_686D1
loc_686CE:
mov r12d, r8d
loc_686D1:
bt eax, 8
jb short loc_68717
bt eax, 0Ah
jnb short loc_686E0
mov r13d, r14d
loc_686E0:
mov rdi, [rsp+0C8h+var_B8]
mov esi, r15d
mov edx, r13d
call __ZNK10OpenSubdiv6v3_6_03Far16GregoryConverterIdE25getIrregularFacePointSizeEii; OpenSubdiv::v3_6_0::Far::GregoryConverter<double>::getIrregularFacePointSize(int,int)
mov rcx, [rsp+0C8h+var_A0]
mov dword ptr [rsp+rcx+0C8h+var_7C+4], eax
mov rsi, [rsp+0C8h+var_B0]
mov rdi, 400000004h
push 4
pop r8
mov edx, [rsp+0C8h+var_BC]
mov r9d, [rsp+0C8h+var_C0]
jmp short loc_6871A
loc_68717:
mov eax, r8d
loc_6871A:
mov r15, [rsp+0C8h+var_A8]
loc_6871F:
add ebx, edx
add ebx, r9d
add ebp, r12d
add ebp, ebx
add ebp, eax
mov edx, ebp
jmp loc_6857F
loc_68732:
mov ecx, [r11+8]
cmp ecx, 2
jl short loc_68769
mov r9d, [r11+4]
lea ebp, [rcx+r9]
inc ebp
mov dword ptr [rsp+r10+0C8h+var_88], 3
test al, 20h
push 2
pop rcx
mov r9d, ecx
cmovz r9d, ebp
mov dword ptr [rsp+r10+0C8h+var_88+4], r9d
test al, 40h
cmovnz ebp, ecx
jmp loc_6862D
loc_68769:
mov rcx, 200000003h
mov [rsp+r10+0C8h+var_88], rcx
push 2
pop rcx
mov ebp, ecx
mov r9d, ecx
jmp loc_6862D
loc_68785:
mov rax, [rsp+0C8h+var_B8]
mov esi, [rax]
lea rcx, [rsp+0C8h+var_88]
mov rdi, [rsp+0C8h+var_98]
call _ZN10OpenSubdiv6v3_6_03Far12_GLOBAL__N_113_resizeMatrixIdEEvRNS1_12SparseMatrixIT_EEiiiPKi; OpenSubdiv::v3_6_0::Far::`anonymous namespace'::_resizeMatrix<double>(OpenSubdiv::v3_6_0::Far::SparseMatrix<double> &,int,int,int,int const*)
add rsp, 98h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long OpenSubdiv::v3_6_0::Far::GregoryConverter<double>::resizeMatrixUnisolated(
unsigned int *a1,
long long a2)
{
unsigned int *v2; // rsi
long long v3; // r15
unsigned int v4; // edx
unsigned int *v5; // r11
__int16 v6; // ax
int v7; // ebp
int v8; // r9d
int v9; // ebx
int v10; // eax
int IrregularFacePointSize; // r12d
long long v12; // rcx
unsigned int v13; // r13d
long long v14; // rdx
int v15; // ecx
int v17; // [rsp-8h] [rbp-D0h]
int v18; // [rsp+8h] [rbp-C0h]
unsigned int v19; // [rsp+Ch] [rbp-BCh]
_QWORD v21[17]; // [rsp+40h] [rbp-88h] BYREF
v2 = a1 + 6;
v3 = 0LL;
v4 = 0;
while ( v3 != 4 )
{
v5 = &v2[56 * v3];
v6 = *(_WORD *)v5;
if ( (*(_WORD *)v5 & 8) != 0 )
{
if ( (v6 & 1) != 0 )
{
*((_DWORD *)v21 + 5 * v3) = 3;
v8 = 4 * ((v6 & 0x20) == 0) + 2;
*((_DWORD *)v21 + 5 * v3 + 1) = v8;
v7 = 4 * ((v6 & 0x40) == 0) + 2;
LABEL_11:
v17 = 3;
goto LABEL_12;
}
*(_QWORD *)((char *)v21 + 20 * v3) = 0x600000009LL;
v7 = 6;
v8 = 6;
v17 = 9;
}
else
{
if ( (v6 & 2) == 0 )
{
if ( (v6 & 1) == 0 )
{
v7 = 2 * v5[1] + 1;
*((_DWORD *)v21 + 5 * v3) = v7;
*((_DWORD *)v21 + 5 * v3 + 1) = v7;
v8 = v7;
v9 = v7;
goto LABEL_13;
}
v15 = v5[2];
if ( v15 < 2 )
{
*(_QWORD *)((char *)v21 + 20 * v3) = 0x200000003LL;
v7 = 2;
v8 = 2;
}
else
{
v7 = v15 + v5[1] + 1;
*((_DWORD *)v21 + 5 * v3) = 3;
v8 = 2;
if ( (v6 & 0x20) == 0 )
v8 = v7;
*((_DWORD *)v21 + 5 * v3 + 1) = v8;
if ( (v6 & 0x40) != 0 )
v7 = 2;
}
goto LABEL_11;
}
*(_QWORD *)((char *)v21 + 20 * v3) = 0x200000001LL;
v7 = 2;
v8 = 2;
v17 = 1;
}
LABEL_12:
v9 = v17;
LABEL_13:
*((_DWORD *)&v21[1] + 5 * v3) = v7;
*(_QWORD *)((char *)&v21[1] + 20 * v3 + 4) = 0x400000004LL;
if ( (~v6 & 0x180) != 0 )
{
v12 = v3 + 1;
v13 = ((_BYTE)v3 - 1) & 3;
v19 = v4;
v18 = v8;
if ( (v6 & 0x80u) != 0 )
{
IrregularFacePointSize = 4;
}
else
{
v14 = ((_BYTE)v3 + 1) & 3;
if ( (v6 & 0x200) != 0 )
v14 = ((_BYTE)v3 - 1) & 3;
IrregularFacePointSize = OpenSubdiv::v3_6_0::Far::GregoryConverter<double>::getIrregularFacePointSize(
a1,
(unsigned int)v3,
v14,
v12,
4LL);
*((_DWORD *)&v21[1] + 5 * v3 + 1) = IrregularFacePointSize;
v6 = v2[56 * v3];
v2 = a1 + 6;
v4 = v19;
v8 = v18;
}
if ( (v6 & 0x100) != 0 )
{
v10 = 4;
}
else
{
if ( (v6 & 0x400) != 0 )
v13 = ((_BYTE)v3 + 1) & 3;
v10 = OpenSubdiv::v3_6_0::Far::GregoryConverter<double>::getIrregularFacePointSize(
a1,
(unsigned int)v3,
v13,
v12,
4LL);
*((_DWORD *)&v21[2] + 5 * v3) = v10;
v2 = a1 + 6;
v4 = v19;
v8 = v18;
}
++v3;
}
else
{
++v3;
v10 = 4;
IrregularFacePointSize = 4;
}
v4 += v10 + v8 + v9 + IrregularFacePointSize + v7;
}
return OpenSubdiv::v3_6_0::Far::`anonymous namespace'::_resizeMatrix<double>(a2, *a1, v4, (long long)v21);
}
|
resizeMatrixUnisolated:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x98
MOV qword ptr [RSP + 0x30],RSI
MOV qword ptr [RSP + 0x10],RDI
LEA RSI,[RDI + 0x18]
XOR R15D,R15D
MOV RDI,0x400000004
PUSH 0x4
POP R8
XOR EDX,EDX
MOV qword ptr [RSP + 0x18],RSI
LAB_0016857f:
CMP R15,0x4
JZ 0x00168785
IMUL R10,R15,0x14
IMUL RAX,R15,0xe0
LEA R11,[RSI + RAX*0x1]
MOVZX EAX,word ptr [RSI + RAX*0x1]
TEST AL,0x8
JNZ 0x001685c8
TEST AL,0x2
JNZ 0x001685e7
TEST AL,0x1
JNZ 0x00168732
MOV ECX,dword ptr [R11 + 0x4]
LEA EBP,[0x1 + RCX*0x2]
MOV dword ptr [RSP + R10*0x1 + 0x40],EBP
MOV dword ptr [RSP + R10*0x1 + 0x44],EBP
MOV R9D,EBP
MOV EBX,EBP
JMP 0x00168630
LAB_001685c8:
TEST AL,0x1
JNZ 0x00168602
MOV RCX,0x600000009
MOV qword ptr [RSP + R10*0x1 + 0x40],RCX
PUSH 0x6
POP RCX
MOV EBP,ECX
MOV R9D,ECX
PUSH 0x9
JMP 0x0016862f
LAB_001685e7:
MOV RCX,0x200000001
MOV qword ptr [RSP + R10*0x1 + 0x40],RCX
PUSH 0x2
POP RCX
MOV EBP,ECX
MOV R9D,ECX
PUSH 0x1
JMP 0x0016862f
LAB_00168602:
MOV dword ptr [RSP + R10*0x1 + 0x40],0x3
XOR ECX,ECX
TEST AL,0x20
SETZ CL
LEA R9D,[0x2 + RCX*0x4]
MOV dword ptr [RSP + R10*0x1 + 0x44],R9D
XOR ECX,ECX
TEST AL,0x40
SETZ CL
LEA EBP,[0x2 + RCX*0x4]
LAB_0016862d:
PUSH 0x3
LAB_0016862f:
POP RBX
LAB_00168630:
MOV dword ptr [RSP + R10*0x1 + 0x48],EBP
MOV qword ptr [RSP + R10*0x1 + 0x4c],RDI
MOV ECX,EAX
NOT ECX
TEST CX,0x180
JNZ 0x00168653
INC R15
MOV EAX,R8D
MOV R12D,R8D
JMP 0x0016871f
LAB_00168653:
LEA RCX,[R15 + 0x1]
MOV qword ptr [RSP + 0x20],RCX
MOV R14D,ECX
AND R14D,0x3
LEA R13D,[R15 + -0x1]
AND R13D,0x3
TEST AL,AL
MOV dword ptr [RSP + 0xc],EDX
MOV qword ptr [RSP + 0x28],R10
MOV dword ptr [RSP + 0x8],R9D
JS 0x001686ce
MOV qword ptr [RSP + 0x38],R11
BT EAX,0x9
MOV EDX,R14D
JNC 0x0016868e
MOV EDX,R13D
LAB_0016868e:
MOV RDI,qword ptr [RSP + 0x10]
MOV ESI,R15D
CALL 0x00153010
MOV R12D,EAX
MOV R10,qword ptr [RSP + 0x28]
MOV dword ptr [RSP + R10*0x1 + 0x4c],EAX
MOV RAX,qword ptr [RSP + 0x38]
MOVZX EAX,word ptr [RAX]
MOV RSI,qword ptr [RSP + 0x18]
MOV RDI,0x400000004
PUSH 0x4
POP R8
MOV EDX,dword ptr [RSP + 0xc]
MOV R9D,dword ptr [RSP + 0x8]
JMP 0x001686d1
LAB_001686ce:
MOV R12D,R8D
LAB_001686d1:
BT EAX,0x8
JC 0x00168717
BT EAX,0xa
JNC 0x001686e0
MOV R13D,R14D
LAB_001686e0:
MOV RDI,qword ptr [RSP + 0x10]
MOV ESI,R15D
MOV EDX,R13D
CALL 0x00153010
MOV RCX,qword ptr [RSP + 0x28]
MOV dword ptr [RSP + RCX*0x1 + 0x50],EAX
MOV RSI,qword ptr [RSP + 0x18]
MOV RDI,0x400000004
PUSH 0x4
POP R8
MOV EDX,dword ptr [RSP + 0xc]
MOV R9D,dword ptr [RSP + 0x8]
JMP 0x0016871a
LAB_00168717:
MOV EAX,R8D
LAB_0016871a:
MOV R15,qword ptr [RSP + 0x20]
LAB_0016871f:
ADD EBX,EDX
ADD EBX,R9D
ADD EBP,R12D
ADD EBP,EBX
ADD EBP,EAX
MOV EDX,EBP
JMP 0x0016857f
LAB_00168732:
MOV ECX,dword ptr [R11 + 0x8]
CMP ECX,0x2
JL 0x00168769
MOV R9D,dword ptr [R11 + 0x4]
LEA EBP,[RCX + R9*0x1]
INC EBP
MOV dword ptr [RSP + R10*0x1 + 0x40],0x3
TEST AL,0x20
PUSH 0x2
POP RCX
MOV R9D,ECX
CMOVZ R9D,EBP
MOV dword ptr [RSP + R10*0x1 + 0x44],R9D
TEST AL,0x40
CMOVNZ EBP,ECX
JMP 0x0016862d
LAB_00168769:
MOV RCX,0x200000003
MOV qword ptr [RSP + R10*0x1 + 0x40],RCX
PUSH 0x2
POP RCX
MOV EBP,ECX
MOV R9D,ECX
JMP 0x0016862d
LAB_00168785:
MOV RAX,qword ptr [RSP + 0x10]
MOV ESI,dword ptr [RAX]
LEA RCX,[RSP + 0x40]
MOV RDI,qword ptr [RSP + 0x30]
CALL 0x00164b75
ADD RSP,0x98
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* OpenSubdiv::v3_6_0::Far::GregoryConverter<double>::resizeMatrixUnisolated(OpenSubdiv::v3_6_0::Far::SparseMatrix<double>&)
const */
void __thiscall
OpenSubdiv::v3_6_0::Far::GregoryConverter<double>::resizeMatrixUnisolated
(GregoryConverter<double> *this,SparseMatrix *param_1)
{
GregoryConverter<double> *pGVar1;
ushort uVar2;
int iVar3;
int iVar4;
uint uVar5;
int iVar6;
int iVar7;
int iVar8;
int iVar9;
long lVar10;
uint uVar11;
uint uVar12;
long lVar13;
int local_88 [3];
int8 uStack_7c;
lVar13 = 0;
iVar7 = 0;
do {
if (lVar13 == 4) {
(anonymous_namespace)::_resizeMatrix<double>
(param_1,*(int *)this,iVar7,(int)local_88,(int *)0x4);
return;
}
lVar10 = lVar13 * 0x14;
pGVar1 = this + lVar13 * 0xe0 + 0x18;
uVar2 = *(ushort *)(this + lVar13 * 0xe0 + 0x18);
if ((uVar2 & 8) == 0) {
if ((uVar2 & 2) == 0) {
if ((uVar2 & 1) != 0) {
if (*(int *)(pGVar1 + 8) < 2) {
(local_88 + lVar13 * 5)[0] = 3;
(local_88 + lVar13 * 5)[1] = 2;
iVar9 = 2;
iVar8 = iVar9;
}
else {
iVar8 = *(int *)(pGVar1 + 8) + *(int *)(pGVar1 + 4) + 1;
local_88[lVar13 * 5] = 3;
iVar9 = 2;
if ((uVar2 & 0x20) == 0) {
iVar9 = iVar8;
}
local_88[lVar13 * 5 + 1] = iVar9;
if ((uVar2 & 0x40) != 0) {
iVar8 = 2;
}
}
goto LAB_0016862d;
}
iVar8 = *(int *)(pGVar1 + 4) * 2 + 1;
local_88[lVar13 * 5] = iVar8;
local_88[lVar13 * 5 + 1] = iVar8;
iVar6 = iVar8;
iVar9 = iVar8;
}
else {
(local_88 + lVar13 * 5)[0] = 1;
(local_88 + lVar13 * 5)[1] = 2;
iVar8 = 2;
iVar6 = 1;
iVar9 = iVar8;
}
}
else if ((uVar2 & 1) == 0) {
(local_88 + lVar13 * 5)[0] = 9;
(local_88 + lVar13 * 5)[1] = 6;
iVar8 = 6;
iVar6 = 9;
iVar9 = iVar8;
}
else {
local_88[lVar13 * 5] = 3;
iVar9 = (uint)((uVar2 & 0x20) == 0) * 4 + 2;
local_88[lVar13 * 5 + 1] = iVar9;
iVar8 = (uint)((uVar2 & 0x40) == 0) * 4 + 2;
LAB_0016862d:
iVar6 = 3;
}
local_88[lVar13 * 5 + 2] = iVar8;
*(int8 *)((long)&uStack_7c + lVar10) = 0x400000004;
iVar3 = 4;
iVar4 = iVar3;
if ((~uVar2 & 0x180) != 0) {
iVar4 = (int)lVar13;
uVar12 = iVar4 + 1U & 3;
uVar11 = iVar4 - 1U & 3;
if (-1 < (char)uVar2) {
uVar5 = uVar12;
if ((uVar2 >> 9 & 1) != 0) {
uVar5 = uVar11;
}
iVar3 = getIrregularFacePointSize(this,iVar4,uVar5);
*(int *)((long)&uStack_7c + lVar10) = iVar3;
uVar2 = *(ushort *)pGVar1;
}
if ((uVar2 >> 8 & 1) == 0) {
if ((uVar2 >> 10 & 1) != 0) {
uVar11 = uVar12;
}
iVar4 = getIrregularFacePointSize(this,iVar4,uVar11);
*(int *)((long)&uStack_7c + lVar10 + 4) = iVar4;
}
else {
iVar4 = 4;
}
}
lVar13 = lVar13 + 1;
iVar7 = iVar8 + iVar3 + iVar6 + iVar7 + iVar9 + iVar4;
} while( true );
}
|
|
11,716 |
OpenSubdiv::v3_6_0::Far::GregoryConverter<float>::resizeMatrixUnisolated(OpenSubdiv::v3_6_0::Far::SparseMatrix<float>&) const
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/catmarkPatchBuilder.cpp
|
void
GregoryConverter<REAL>::resizeMatrixUnisolated(Matrix & matrix) const {
int rowSizes[20];
int numElements = 0;
for (int cIndex = 0; cIndex < 4; ++cIndex) {
int * rowSize = rowSizes + cIndex*5;
CornerTopology const & corner = _corners[cIndex];
// First, the corner and pair of edge points:
if (corner.isRegular) {
if (! corner.isBoundary) {
rowSize[0] = 9;
rowSize[1] = 6;
rowSize[2] = 6;
} else {
rowSize[0] = 3;
rowSize[1] = corner.epOnBoundary ? 2 : 6;
rowSize[2] = corner.emOnBoundary ? 2 : 6;
}
} else {
if (corner.isSharp) {
rowSize[0] = 1;
rowSize[1] = 2;
rowSize[2] = 2;
} else if (! corner.isBoundary) {
int ringSize = 1 + 2 * corner.valence;
rowSize[0] = ringSize;
rowSize[1] = ringSize;
rowSize[2] = ringSize;
} else if (corner.numFaces > 1) {
int ringSize = 1 + corner.valence + corner.numFaces;
rowSize[0] = 3;
rowSize[1] = corner.epOnBoundary ? 2 : ringSize;
rowSize[2] = corner.emOnBoundary ? 2 : ringSize;
} else {
rowSize[0] = 3;
rowSize[1] = 2;
rowSize[2] = 2;
}
}
numElements += rowSize[0] + rowSize[1] + rowSize[2];
// Second, the pair of face points:
rowSize[3] = 4;
rowSize[4] = 4;
if (!corner.fpIsRegular || !corner.fmIsRegular) {
int cNext = (cIndex + 1) & 0x3;
int cPrev = (cIndex + 3) & 0x3;
if (!corner.fpIsRegular) {
rowSize[3] = getIrregularFacePointSize(cIndex,
corner.fpIsCopied ? cPrev : cNext);
}
if (!corner.fmIsRegular) {
rowSize[4] = getIrregularFacePointSize(cIndex,
corner.fmIsCopied ? cNext : cPrev);
}
}
numElements += rowSize[3] + rowSize[4];
}
_resizeMatrix(matrix, 20, _numSourcePoints, numElements, rowSizes);
}
|
O3
|
cpp
|
OpenSubdiv::v3_6_0::Far::GregoryConverter<float>::resizeMatrixUnisolated(OpenSubdiv::v3_6_0::Far::SparseMatrix<float>&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, 0x30(%rsp)
movq %rdi, 0x10(%rsp)
leaq 0x18(%rdi), %rsi
xorl %r15d, %r15d
movabsq $0x400000004, %rdi # imm = 0x400000004
xorl %r14d, %r14d
movq %rsi, 0x20(%rsp)
leaq (,%r15,4), %rax
leaq (%rax,%rax,4), %r8
imulq $0xd8, %r15, %rax
leaq (%rsi,%rax), %r9
movzwl (%rsi,%rax), %eax
testb $0x8, %al
jne 0x50896
testb $0x2, %al
jne 0x508ba
testb $0x1, %al
jne 0x50a19
movl 0x4(%r9), %ecx
leal 0x1(,%rcx,2), %ebp
movl %ebp, 0x40(%rsp,%r8)
movl %ebp, 0x44(%rsp,%r8)
movl %ebp, %edx
movl %ebp, %ebx
jmp 0x50909
testb $0x1, %al
jne 0x508da
movabsq $0x600000009, %rcx # imm = 0x600000009
movq %rcx, 0x40(%rsp,%r8)
movl $0x9, %ebx
movl $0x6, %ebp
movl $0x6, %edx
jmp 0x50909
movabsq $0x200000001, %rcx # imm = 0x200000001
movq %rcx, 0x40(%rsp,%r8)
movl $0x1, %ebx
movl $0x2, %ebp
movl $0x2, %edx
jmp 0x50909
movl $0x3, 0x40(%rsp,%r8)
xorl %ecx, %ecx
testb $0x20, %al
sete %cl
leal 0x2(,%rcx,4), %edx
movl %edx, 0x44(%rsp,%r8)
xorl %ecx, %ecx
testb $0x40, %al
sete %cl
leal 0x2(,%rcx,4), %ebp
movl $0x3, %ebx
movl %ebp, 0x48(%rsp,%r8)
movq %rdi, 0x4c(%rsp,%r8)
movl %eax, %ecx
notl %ecx
testl $0x180, %ecx # imm = 0x180
jne 0x50935
incq %r15
movl $0x4, %ecx
movq %r15, %r12
movl $0x4, %r13d
jmp 0x509fa
leaq 0x1(%r15), %r12
movl %r12d, %r11d
andl $0x3, %r11d
leal -0x1(%r15), %r10d
andl $0x3, %r10d
movl $0x4, %ecx
testb %al, %al
movq %r8, 0x28(%rsp)
movl %edx, 0xc(%rsp)
js 0x509b7
movq %r9, 0x38(%rsp)
btl $0x9, %eax
movl %r11d, 0x1c(%rsp)
movl %r11d, %edx
jae 0x50970
movl %r10d, %edx
movq 0x10(%rsp), %rdi
movl %r15d, %esi
movl %r10d, %r13d
callq 0x39000
movl %r13d, %r10d
movl %eax, %r13d
movq 0x28(%rsp), %r8
movl %eax, 0x4c(%rsp,%r8)
movq 0x38(%rsp), %rax
movzwl (%rax), %eax
movq 0x20(%rsp), %rsi
movabsq $0x400000004, %rdi # imm = 0x400000004
movl 0xc(%rsp), %edx
movl $0x4, %ecx
movl 0x1c(%rsp), %r11d
jmp 0x509bd
movl $0x4, %r13d
btl $0x8, %eax
jb 0x509fa
btl $0xa, %eax
jae 0x509cc
movl %r11d, %r10d
movq 0x10(%rsp), %rdi
movl %r15d, %esi
movl %r10d, %edx
callq 0x39000
movl %eax, %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x50(%rsp,%rax)
movq 0x20(%rsp), %rsi
movabsq $0x400000004, %rdi # imm = 0x400000004
movl 0xc(%rsp), %edx
addl %r14d, %ebx
addl %edx, %ebx
addl %r13d, %ebp
addl %ebx, %ebp
movl %ebp, %r14d
addl %ecx, %r14d
movq %r12, %r15
cmpq $0x4, %r12
jne 0x50850
jmp 0x50a6b
movl 0x8(%r9), %ecx
cmpl $0x2, %ecx
jl 0x50a52
movl 0x4(%r9), %edx
leal (%rcx,%rdx), %ebp
incl %ebp
movl $0x3, 0x40(%rsp,%r8)
testb $0x20, %al
movl $0x2, %edx
cmovel %ebp, %edx
movl %edx, 0x44(%rsp,%r8)
testb $0x40, %al
movl $0x2, %ecx
cmovnel %ecx, %ebp
jmp 0x50904
movabsq $0x200000003, %rcx # imm = 0x200000003
movq %rcx, 0x40(%rsp,%r8)
movl $0x3, %ebx
jmp 0x508ce
movq 0x10(%rsp), %rax
movl (%rax), %esi
leaq 0x40(%rsp), %rcx
movq 0x30(%rsp), %rdi
movl %r14d, %edx
callq 0x4f227
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_ZNK10OpenSubdiv6v3_6_03Far16GregoryConverterIfE22resizeMatrixUnisolatedERNS1_12SparseMatrixIfEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 98h
mov [rsp+0C8h+var_98], rsi
mov [rsp+0C8h+var_B8], rdi
lea rsi, [rdi+18h]
xor r15d, r15d
mov rdi, 400000004h
xor r14d, r14d
mov [rsp+0C8h+var_A8], rsi
loc_50850:
lea rax, ds:0[r15*4]
lea r8, [rax+rax*4]
imul rax, r15, 0D8h
lea r9, [rsi+rax]
movzx eax, word ptr [rsi+rax]
test al, 8
jnz short loc_50896
test al, 2
jnz short loc_508BA
test al, 1
jnz loc_50A19
mov ecx, [r9+4]
lea ebp, ds:1[rcx*2]
mov dword ptr [rsp+r8+0C8h+var_88], ebp
mov dword ptr [rsp+r8+0C8h+var_88+4], ebp
mov edx, ebp
mov ebx, ebp
jmp short loc_50909
loc_50896:
test al, 1
jnz short loc_508DA
mov rcx, 600000009h
mov [rsp+r8+0C8h+var_88], rcx
mov ebx, 9
mov ebp, 6
mov edx, 6
jmp short loc_50909
loc_508BA:
mov rcx, 200000001h
mov [rsp+r8+0C8h+var_88], rcx
mov ebx, 1
loc_508CE:
mov ebp, 2
mov edx, 2
jmp short loc_50909
loc_508DA:
mov dword ptr [rsp+r8+0C8h+var_88], 3
xor ecx, ecx
test al, 20h
setz cl
lea edx, ds:2[rcx*4]
mov dword ptr [rsp+r8+0C8h+var_88+4], edx
xor ecx, ecx
test al, 40h
setz cl
lea ebp, ds:2[rcx*4]
loc_50904:
mov ebx, 3
loc_50909:
mov [rsp+r8+0C8h+var_80], ebp
mov [rsp+r8+0C8h+var_7C], rdi
mov ecx, eax
not ecx
test ecx, 180h
jnz short loc_50935
inc r15
mov ecx, 4
mov r12, r15
mov r13d, 4
jmp loc_509FA
loc_50935:
lea r12, [r15+1]
mov r11d, r12d
and r11d, 3
lea r10d, [r15-1]
and r10d, 3
mov ecx, 4
test al, al
mov [rsp+0C8h+var_A0], r8
mov [rsp+0C8h+var_BC], edx
js short loc_509B7
mov [rsp+0C8h+var_90], r9
bt eax, 9
mov [rsp+0C8h+var_AC], r11d
mov edx, r11d
jnb short loc_50970
mov edx, r10d
loc_50970:
mov rdi, [rsp+0C8h+var_B8]
mov esi, r15d
mov r13d, r10d
call __ZNK10OpenSubdiv6v3_6_03Far16GregoryConverterIfE25getIrregularFacePointSizeEii; OpenSubdiv::v3_6_0::Far::GregoryConverter<float>::getIrregularFacePointSize(int,int)
mov r10d, r13d
mov r13d, eax
mov r8, [rsp+0C8h+var_A0]
mov dword ptr [rsp+r8+0C8h+var_7C], eax
mov rax, [rsp+0C8h+var_90]
movzx eax, word ptr [rax]
mov rsi, [rsp+0C8h+var_A8]
mov rdi, 400000004h
mov edx, [rsp+0C8h+var_BC]
mov ecx, 4
mov r11d, [rsp+0C8h+var_AC]
jmp short loc_509BD
loc_509B7:
mov r13d, 4
loc_509BD:
bt eax, 8
jb short loc_509FA
bt eax, 0Ah
jnb short loc_509CC
mov r10d, r11d
loc_509CC:
mov rdi, [rsp+0C8h+var_B8]
mov esi, r15d
mov edx, r10d
call __ZNK10OpenSubdiv6v3_6_03Far16GregoryConverterIfE25getIrregularFacePointSizeEii; OpenSubdiv::v3_6_0::Far::GregoryConverter<float>::getIrregularFacePointSize(int,int)
mov ecx, eax
mov rax, [rsp+0C8h+var_A0]
mov dword ptr [rsp+rax+0C8h+var_7C+4], ecx
mov rsi, [rsp+0C8h+var_A8]
mov rdi, 400000004h
mov edx, [rsp+0C8h+var_BC]
loc_509FA:
add ebx, r14d
add ebx, edx
add ebp, r13d
add ebp, ebx
mov r14d, ebp
add r14d, ecx
mov r15, r12
cmp r12, 4
jnz loc_50850
jmp short loc_50A6B
loc_50A19:
mov ecx, [r9+8]
cmp ecx, 2
jl short loc_50A52
mov edx, [r9+4]
lea ebp, [rcx+rdx]
inc ebp
mov dword ptr [rsp+r8+0C8h+var_88], 3
test al, 20h
mov edx, 2
cmovz edx, ebp
mov dword ptr [rsp+r8+0C8h+var_88+4], edx
test al, 40h
mov ecx, 2
cmovnz ebp, ecx
jmp loc_50904
loc_50A52:
mov rcx, 200000003h
mov [rsp+r8+0C8h+var_88], rcx
mov ebx, 3
jmp loc_508CE
loc_50A6B:
mov rax, [rsp+0C8h+var_B8]
mov esi, [rax]
lea rcx, [rsp+0C8h+var_88]
mov rdi, [rsp+0C8h+var_98]
mov edx, r14d
call _ZN10OpenSubdiv6v3_6_03Far12_GLOBAL__N_113_resizeMatrixIfEEvRNS1_12SparseMatrixIT_EEiiiPKi; OpenSubdiv::v3_6_0::Far::`anonymous namespace'::_resizeMatrix<float>(OpenSubdiv::v3_6_0::Far::SparseMatrix<float> &,int,int,int,int const*)
add rsp, 98h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long OpenSubdiv::v3_6_0::Far::GregoryConverter<float>::resizeMatrixUnisolated(int *a1, int *a2)
{
int *v2; // rsi
long long v3; // r15
int v4; // r14d
long long v5; // r8
int *v6; // r9
__int16 v7; // ax
int v8; // ebp
int v9; // edx
int v10; // ebx
int v11; // ecx
long long v12; // r12
int v13; // r13d
int v14; // r11d
unsigned int v15; // r10d
long long v16; // rdx
int IrregularFacePointSize; // eax
int v18; // ecx
int v20; // [rsp+Ch] [rbp-BCh]
_QWORD v22[17]; // [rsp+40h] [rbp-88h] BYREF
v2 = a1 + 6;
v3 = 0LL;
v4 = 0;
do
{
v5 = 20 * v3;
v6 = &v2[54 * v3];
v7 = *(_WORD *)v6;
if ( (*(_WORD *)v6 & 8) != 0 )
{
if ( (v7 & 1) == 0 )
{
*(_QWORD *)((char *)v22 + 20 * v3) = 0x600000009LL;
v10 = 9;
v8 = 6;
v9 = 6;
goto LABEL_12;
}
*((_DWORD *)v22 + 5 * v3) = 3;
v9 = 4 * ((v7 & 0x20) == 0) + 2;
*((_DWORD *)v22 + 5 * v3 + 1) = v9;
v8 = 4 * ((v7 & 0x40) == 0) + 2;
goto LABEL_11;
}
if ( (v7 & 2) != 0 )
{
*(_QWORD *)((char *)v22 + 20 * v3) = 0x200000001LL;
v10 = 1;
LABEL_9:
v8 = 2;
v9 = 2;
goto LABEL_12;
}
if ( (v7 & 1) == 0 )
{
v8 = 2 * v6[1] + 1;
*((_DWORD *)v22 + 5 * v3) = v8;
*((_DWORD *)v22 + 5 * v3 + 1) = v8;
v9 = v8;
v10 = v8;
goto LABEL_12;
}
v18 = v6[2];
if ( v18 < 2 )
{
*(_QWORD *)((char *)v22 + 20 * v3) = 0x200000003LL;
v10 = 3;
goto LABEL_9;
}
v8 = v18 + v6[1] + 1;
*((_DWORD *)v22 + 5 * v3) = 3;
v9 = 2;
if ( (v7 & 0x20) == 0 )
v9 = v8;
*((_DWORD *)v22 + 5 * v3 + 1) = v9;
if ( (v7 & 0x40) != 0 )
v8 = 2;
LABEL_11:
v10 = 3;
LABEL_12:
*((_DWORD *)&v22[1] + 5 * v3) = v8;
*(_QWORD *)((char *)&v22[1] + 20 * v3 + 4) = 0x400000004LL;
if ( (~v7 & 0x180) != 0 )
{
v12 = v3 + 1;
v14 = ((_BYTE)v3 + 1) & 3;
v15 = ((_BYTE)v3 - 1) & 3;
v11 = 4;
v20 = v9;
if ( (v7 & 0x80u) != 0 )
{
v13 = 4;
}
else
{
v16 = ((_BYTE)v3 + 1) & 3;
if ( (v7 & 0x200) != 0 )
v16 = ((_BYTE)v3 - 1) & 3;
IrregularFacePointSize = OpenSubdiv::v3_6_0::Far::GregoryConverter<float>::getIrregularFacePointSize(
a1,
(unsigned int)v3,
v16,
4LL,
v5);
v15 = ((_BYTE)v3 - 1) & 3;
v13 = IrregularFacePointSize;
v5 = 20 * v3;
*((_DWORD *)&v22[1] + 5 * v3 + 1) = IrregularFacePointSize;
v7 = v2[54 * v3];
v2 = a1 + 6;
v9 = v20;
v11 = 4;
v14 = ((_BYTE)v3 + 1) & 3;
}
if ( (v7 & 0x100) == 0 )
{
if ( (v7 & 0x400) != 0 )
v15 = v14;
v11 = OpenSubdiv::v3_6_0::Far::GregoryConverter<float>::getIrregularFacePointSize(
a1,
(unsigned int)v3,
v15,
4LL,
v5);
*((_DWORD *)&v22[2] + 5 * v3) = v11;
v2 = a1 + 6;
v9 = v20;
}
}
else
{
v11 = 4;
v12 = v3 + 1;
v13 = 4;
}
v4 += v11 + v9 + v10 + v13 + v8;
v3 = v12;
}
while ( v12 != 4 );
return OpenSubdiv::v3_6_0::Far::`anonymous namespace'::_resizeMatrix<float>(a2, *a1, v4, (long long)v22);
}
|
resizeMatrixUnisolated:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x98
MOV qword ptr [RSP + 0x30],RSI
MOV qword ptr [RSP + 0x10],RDI
LEA RSI,[RDI + 0x18]
XOR R15D,R15D
MOV RDI,0x400000004
XOR R14D,R14D
MOV qword ptr [RSP + 0x20],RSI
LAB_00150850:
LEA RAX,[R15*0x4]
LEA R8,[RAX + RAX*0x4]
IMUL RAX,R15,0xd8
LEA R9,[RSI + RAX*0x1]
MOVZX EAX,word ptr [RSI + RAX*0x1]
TEST AL,0x8
JNZ 0x00150896
TEST AL,0x2
JNZ 0x001508ba
TEST AL,0x1
JNZ 0x00150a19
MOV ECX,dword ptr [R9 + 0x4]
LEA EBP,[0x1 + RCX*0x2]
MOV dword ptr [RSP + R8*0x1 + 0x40],EBP
MOV dword ptr [RSP + R8*0x1 + 0x44],EBP
MOV EDX,EBP
MOV EBX,EBP
JMP 0x00150909
LAB_00150896:
TEST AL,0x1
JNZ 0x001508da
MOV RCX,0x600000009
MOV qword ptr [RSP + R8*0x1 + 0x40],RCX
MOV EBX,0x9
MOV EBP,0x6
MOV EDX,0x6
JMP 0x00150909
LAB_001508ba:
MOV RCX,0x200000001
MOV qword ptr [RSP + R8*0x1 + 0x40],RCX
MOV EBX,0x1
LAB_001508ce:
MOV EBP,0x2
MOV EDX,0x2
JMP 0x00150909
LAB_001508da:
MOV dword ptr [RSP + R8*0x1 + 0x40],0x3
XOR ECX,ECX
TEST AL,0x20
SETZ CL
LEA EDX,[0x2 + RCX*0x4]
MOV dword ptr [RSP + R8*0x1 + 0x44],EDX
XOR ECX,ECX
TEST AL,0x40
SETZ CL
LEA EBP,[0x2 + RCX*0x4]
LAB_00150904:
MOV EBX,0x3
LAB_00150909:
MOV dword ptr [RSP + R8*0x1 + 0x48],EBP
MOV qword ptr [RSP + R8*0x1 + 0x4c],RDI
MOV ECX,EAX
NOT ECX
TEST ECX,0x180
JNZ 0x00150935
INC R15
MOV ECX,0x4
MOV R12,R15
MOV R13D,0x4
JMP 0x001509fa
LAB_00150935:
LEA R12,[R15 + 0x1]
MOV R11D,R12D
AND R11D,0x3
LEA R10D,[R15 + -0x1]
AND R10D,0x3
MOV ECX,0x4
TEST AL,AL
MOV qword ptr [RSP + 0x28],R8
MOV dword ptr [RSP + 0xc],EDX
JS 0x001509b7
MOV qword ptr [RSP + 0x38],R9
BT EAX,0x9
MOV dword ptr [RSP + 0x1c],R11D
MOV EDX,R11D
JNC 0x00150970
MOV EDX,R10D
LAB_00150970:
MOV RDI,qword ptr [RSP + 0x10]
MOV ESI,R15D
MOV R13D,R10D
CALL 0x00139000
MOV R10D,R13D
MOV R13D,EAX
MOV R8,qword ptr [RSP + 0x28]
MOV dword ptr [RSP + R8*0x1 + 0x4c],EAX
MOV RAX,qword ptr [RSP + 0x38]
MOVZX EAX,word ptr [RAX]
MOV RSI,qword ptr [RSP + 0x20]
MOV RDI,0x400000004
MOV EDX,dword ptr [RSP + 0xc]
MOV ECX,0x4
MOV R11D,dword ptr [RSP + 0x1c]
JMP 0x001509bd
LAB_001509b7:
MOV R13D,0x4
LAB_001509bd:
BT EAX,0x8
JC 0x001509fa
BT EAX,0xa
JNC 0x001509cc
MOV R10D,R11D
LAB_001509cc:
MOV RDI,qword ptr [RSP + 0x10]
MOV ESI,R15D
MOV EDX,R10D
CALL 0x00139000
MOV ECX,EAX
MOV RAX,qword ptr [RSP + 0x28]
MOV dword ptr [RSP + RAX*0x1 + 0x50],ECX
MOV RSI,qword ptr [RSP + 0x20]
MOV RDI,0x400000004
MOV EDX,dword ptr [RSP + 0xc]
LAB_001509fa:
ADD EBX,R14D
ADD EBX,EDX
ADD EBP,R13D
ADD EBP,EBX
MOV R14D,EBP
ADD R14D,ECX
MOV R15,R12
CMP R12,0x4
JNZ 0x00150850
JMP 0x00150a6b
LAB_00150a19:
MOV ECX,dword ptr [R9 + 0x8]
CMP ECX,0x2
JL 0x00150a52
MOV EDX,dword ptr [R9 + 0x4]
LEA EBP,[RCX + RDX*0x1]
INC EBP
MOV dword ptr [RSP + R8*0x1 + 0x40],0x3
TEST AL,0x20
MOV EDX,0x2
CMOVZ EDX,EBP
MOV dword ptr [RSP + R8*0x1 + 0x44],EDX
TEST AL,0x40
MOV ECX,0x2
CMOVNZ EBP,ECX
JMP 0x00150904
LAB_00150a52:
MOV RCX,0x200000003
MOV qword ptr [RSP + R8*0x1 + 0x40],RCX
MOV EBX,0x3
JMP 0x001508ce
LAB_00150a6b:
MOV RAX,qword ptr [RSP + 0x10]
MOV ESI,dword ptr [RAX]
LEA RCX,[RSP + 0x40]
MOV RDI,qword ptr [RSP + 0x30]
MOV EDX,R14D
CALL 0x0014f227
ADD RSP,0x98
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* OpenSubdiv::v3_6_0::Far::GregoryConverter<float>::resizeMatrixUnisolated(OpenSubdiv::v3_6_0::Far::SparseMatrix<float>&)
const */
void __thiscall
OpenSubdiv::v3_6_0::Far::GregoryConverter<float>::resizeMatrixUnisolated
(GregoryConverter<float> *this,SparseMatrix *param_1)
{
GregoryConverter<float> *pGVar1;
ushort uVar2;
int *piVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
uint uVar8;
int iVar9;
int iVar10;
int *piVar11;
uint uVar12;
uint uVar13;
long lVar14;
int iVar15;
int local_88 [3];
int8 uStack_7c;
lVar14 = 0;
iVar15 = 0;
do {
piVar3 = (int *)(lVar14 * 0x14);
pGVar1 = this + lVar14 * 0xd8 + 0x18;
uVar2 = *(ushort *)(this + lVar14 * 0xd8 + 0x18);
if ((uVar2 & 8) == 0) {
if ((uVar2 & 2) == 0) {
if ((uVar2 & 1) == 0) {
iVar10 = *(int *)(pGVar1 + 4) * 2 + 1;
local_88[lVar14 * 5] = iVar10;
local_88[lVar14 * 5 + 1] = iVar10;
iVar9 = iVar10;
iVar7 = iVar10;
goto LAB_00150909;
}
if (1 < *(int *)(pGVar1 + 8)) {
iVar10 = *(int *)(pGVar1 + 8) + *(int *)(pGVar1 + 4) + 1;
local_88[lVar14 * 5] = 3;
iVar7 = 2;
if ((uVar2 & 0x20) == 0) {
iVar7 = iVar10;
}
local_88[lVar14 * 5 + 1] = iVar7;
if ((uVar2 & 0x40) != 0) {
iVar10 = 2;
}
goto LAB_00150904;
}
(local_88 + lVar14 * 5)[0] = 3;
(local_88 + lVar14 * 5)[1] = 2;
iVar9 = 3;
}
else {
(local_88 + lVar14 * 5)[0] = 1;
(local_88 + lVar14 * 5)[1] = 2;
iVar9 = 1;
}
iVar10 = 2;
iVar7 = 2;
}
else if ((uVar2 & 1) == 0) {
(local_88 + lVar14 * 5)[0] = 9;
(local_88 + lVar14 * 5)[1] = 6;
iVar9 = 9;
iVar10 = 6;
iVar7 = 6;
}
else {
local_88[lVar14 * 5] = 3;
iVar7 = (uint)((uVar2 & 0x20) == 0) * 4 + 2;
local_88[lVar14 * 5 + 1] = iVar7;
iVar10 = (uint)((uVar2 & 0x40) == 0) * 4 + 2;
LAB_00150904:
iVar9 = 3;
}
LAB_00150909:
local_88[lVar14 * 5 + 2] = iVar10;
*(int8 *)((long)&uStack_7c + (long)piVar3) = 0x400000004;
piVar11 = piVar3;
if ((~uVar2 & 0x180) == 0) {
iVar6 = 4;
iVar5 = 4;
}
else {
iVar4 = (int)lVar14;
uVar13 = iVar4 + 1U & 3;
uVar12 = iVar4 - 1U & 3;
if ((char)uVar2 < '\0') {
iVar5 = 4;
}
else {
uVar8 = uVar13;
if ((uVar2 >> 9 & 1) != 0) {
uVar8 = uVar12;
}
iVar5 = getIrregularFacePointSize(this,iVar4,uVar8);
*(int *)((long)&uStack_7c + (long)piVar3) = iVar5;
uVar2 = *(ushort *)pGVar1;
}
iVar6 = 4;
if ((uVar2 >> 8 & 1) == 0) {
if ((uVar2 >> 10 & 1) != 0) {
uVar12 = uVar13;
}
iVar6 = getIrregularFacePointSize(this,iVar4,uVar12);
*(int *)((long)&uStack_7c + 4 + (long)piVar3) = iVar6;
}
}
lVar14 = lVar14 + 1;
iVar15 = iVar10 + iVar5 + iVar9 + iVar15 + iVar7 + iVar6;
if (lVar14 == 4) {
(anonymous_namespace)::_resizeMatrix<float>(param_1,*(int *)this,iVar15,(int)local_88,piVar11)
;
return;
}
} while( true );
}
|
|
11,717 |
ma_log_change
|
eloqsql/storage/maria/ma_write.c
|
my_bool _ma_log_change(MARIA_PAGE *ma_page, const uchar *key_pos, uint length,
enum en_key_debug debug_marker __attribute__((unused)))
{
LSN lsn;
uchar log_data[FILEID_STORE_SIZE + PAGE_STORE_SIZE + 2 + 6 + 7], *log_pos;
LEX_CUSTRING log_array[TRANSLOG_INTERNAL_PARTS + 4];
uint offset= (uint) (key_pos - ma_page->buff), translog_parts;
MARIA_HA *info= ma_page->info;
my_off_t page= ma_page->pos / info->s->block_size;
DBUG_ENTER("_ma_log_change");
DBUG_PRINT("enter", ("page: %lu length: %u", (ulong) page, length));
DBUG_ASSERT(info->s->now_transactional);
DBUG_ASSERT(offset + length <= ma_page->size);
DBUG_ASSERT(ma_page->org_size == ma_page->size);
/* Store address of new root page */
page= ma_page->pos / info->s->block_size;
page_store(log_data + FILEID_STORE_SIZE, page);
log_pos= log_data+ FILEID_STORE_SIZE + PAGE_STORE_SIZE;
#ifdef EXTRA_DEBUG_KEY_CHANGES
(*log_pos++)= KEY_OP_DEBUG;
(*log_pos++)= debug_marker;
#endif
log_pos[0]= KEY_OP_OFFSET;
int2store(log_pos+1, offset);
log_pos[3]= KEY_OP_CHANGE;
int2store(log_pos+4, length);
log_pos+= 6;
log_array[TRANSLOG_INTERNAL_PARTS + 0].str= log_data;
log_array[TRANSLOG_INTERNAL_PARTS + 0].length= (log_pos - log_data);
log_array[TRANSLOG_INTERNAL_PARTS + 1].str= key_pos;
log_array[TRANSLOG_INTERNAL_PARTS + 1].length= length;
translog_parts= 2;
_ma_log_key_changes(ma_page,
log_array + TRANSLOG_INTERNAL_PARTS + translog_parts,
log_pos, &length, &translog_parts);
if (translog_write_record(&lsn, LOGREC_REDO_INDEX,
info->trn, info,
(translog_size_t) (log_pos - log_data) + length,
TRANSLOG_INTERNAL_PARTS + translog_parts,
log_array, log_data, NULL))
DBUG_RETURN(1);
DBUG_RETURN(0);
}
|
O0
|
c
|
ma_log_change:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
movl %edx, -0x3c(%rbp)
movl %ecx, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
movl %eax, -0xb4(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xc0(%rbp)
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq -0xc0(%rbp), %rcx
movq (%rcx), %rcx
movl 0x7bc(%rcx), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0xc8(%rbp)
jmp 0x6ae3f
jmp 0x6ae41
jmp 0x6ae43
jmp 0x6ae45
jmp 0x6ae47
jmp 0x6ae49
jmp 0x6ae4b
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq -0xc0(%rbp), %rcx
movq (%rcx), %rcx
movl 0x7bc(%rcx), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0xc8(%rbp)
leaq -0x20(%rbp), %rax
addq $0x2, %rax
movq %rax, -0xd0(%rbp)
movq -0xc8(%rbp), %rax
movl %eax, %ecx
movq -0xd0(%rbp), %rax
movl %ecx, (%rax)
movq -0xc8(%rbp), %rax
shrq $0x20, %rax
movb %al, %cl
movq -0xd0(%rbp), %rax
movb %cl, 0x4(%rax)
leaq -0x20(%rbp), %rax
addq $0x2, %rax
addq $0x5, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movb $0x1, (%rax)
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xd8(%rbp)
movl -0xb4(%rbp), %eax
movw %ax, %cx
movq -0xd8(%rbp), %rax
movw %cx, (%rax)
movq -0x50(%rbp), %rax
movb $0x3, 0x3(%rax)
movq -0x50(%rbp), %rax
addq $0x4, %rax
movq %rax, -0xe0(%rbp)
movl -0x3c(%rbp), %eax
movw %ax, %cx
movq -0xe0(%rbp), %rax
movw %cx, (%rax)
movq -0x50(%rbp), %rax
addq $0x6, %rax
movq %rax, -0x50(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x50(%rbp), %rax
leaq -0x20(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x88(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x80(%rbp)
movl -0x3c(%rbp), %eax
movq %rax, -0x78(%rbp)
movl $0x2, -0xb8(%rbp)
movq -0xc0(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0xc0(%rbp), %rcx
movq -0x50(%rbp), %rax
leaq -0x20(%rbp), %rsi
subq %rsi, %rax
movl %eax, %r8d
addl -0x3c(%rbp), %r8d
movl -0xb8(%rbp), %r9d
addl $0x2, %r9d
leaq -0xb0(%rbp), %r10
leaq -0x20(%rbp), %rax
leaq -0x48(%rbp), %rdi
movl $0xc, %esi
xorl %r11d, %r11d
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
callq 0x90c10
cmpb $0x0, %al
je 0x6afb2
jmp 0x6afac
movb $0x1, -0x21(%rbp)
jmp 0x6afb8
jmp 0x6afb4
movb $0x0, -0x21(%rbp)
movb -0x21(%rbp), %al
movb %al, -0xe1(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x6afe2
movb -0xe1(%rbp), %al
addq $0x100, %rsp # imm = 0x100
popq %rbp
retq
callq 0x29230
nopw (%rax,%rax)
|
_ma_log_change:
push rbp
mov rbp, rsp
sub rsp, 100h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_30], rdi
mov [rbp+var_38], rsi
mov [rbp+var_3C], edx
mov [rbp+var_40], ecx
mov rax, [rbp+var_38]
mov rcx, [rbp+var_30]
mov rcx, [rcx+10h]
sub rax, rcx
mov [rbp+var_B4], eax
mov rax, [rbp+var_30]
mov rax, [rax]
mov [rbp+var_C0], rax
mov rax, [rbp+var_30]
mov rax, [rax+18h]
mov rcx, [rbp+var_C0]
mov rcx, [rcx]
mov ecx, [rcx+7BCh]
xor edx, edx
div rcx
mov [rbp+var_C8], rax
jmp short $+2
loc_6AE3F:
jmp short $+2
loc_6AE41:
jmp short $+2
loc_6AE43:
jmp short $+2
loc_6AE45:
jmp short $+2
loc_6AE47:
jmp short $+2
loc_6AE49:
jmp short $+2
loc_6AE4B:
mov rax, [rbp+var_30]
mov rax, [rax+18h]
mov rcx, [rbp+var_C0]
mov rcx, [rcx]
mov ecx, [rcx+7BCh]
xor edx, edx
div rcx
mov [rbp+var_C8], rax
lea rax, [rbp+var_20]
add rax, 2
mov [rbp+var_D0], rax
mov rax, [rbp+var_C8]
mov ecx, eax
mov rax, [rbp+var_D0]
mov [rax], ecx
mov rax, [rbp+var_C8]
shr rax, 20h
mov cl, al
mov rax, [rbp+var_D0]
mov [rax+4], cl
lea rax, [rbp+var_20]
add rax, 2
add rax, 5
mov [rbp+var_50], rax
mov rax, [rbp+var_50]
mov byte ptr [rax], 1
mov rax, [rbp+var_50]
add rax, 1
mov [rbp+var_D8], rax
mov eax, [rbp+var_B4]
mov cx, ax
mov rax, [rbp+var_D8]
mov [rax], cx
mov rax, [rbp+var_50]
mov byte ptr [rax+3], 3
mov rax, [rbp+var_50]
add rax, 4
mov [rbp+var_E0], rax
mov eax, [rbp+var_3C]
mov cx, ax
mov rax, [rbp+var_E0]
mov [rax], cx
mov rax, [rbp+var_50]
add rax, 6
mov [rbp+var_50], rax
lea rax, [rbp+var_20]
mov [rbp+var_90], rax
mov rax, [rbp+var_50]
lea rcx, [rbp+var_20]
sub rax, rcx
mov [rbp+var_88], rax
mov rax, [rbp+var_38]
mov [rbp+var_80], rax
mov eax, [rbp+var_3C]
mov [rbp+var_78], rax
mov [rbp+var_B8], 2
mov rax, [rbp+var_C0]
mov rdx, [rax+8]
mov rcx, [rbp+var_C0]
mov rax, [rbp+var_50]
lea rsi, [rbp+var_20]
sub rax, rsi
mov r8d, eax
add r8d, [rbp+var_3C]
mov r9d, [rbp+var_B8]
add r9d, 2
lea r10, [rbp+var_B0]
lea rax, [rbp+var_20]
lea rdi, [rbp+var_48]
mov esi, 0Ch
xor r11d, r11d
mov [rsp+100h+var_100], r10
mov [rsp+100h+var_F8], rax
mov [rsp+100h+var_F0], 0
call translog_write_record
cmp al, 0
jz short loc_6AFB2
jmp short $+2
loc_6AFAC:
mov [rbp+var_21], 1
jmp short loc_6AFB8
loc_6AFB2:
jmp short $+2
loc_6AFB4:
mov [rbp+var_21], 0
loc_6AFB8:
mov al, [rbp+var_21]
mov [rbp+var_E1], al
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_6AFE2
mov al, [rbp+var_E1]
add rsp, 100h
pop rbp
retn
loc_6AFE2:
call ___stack_chk_fail
|
bool ma_log_change(_QWORD *a1, long long a2, unsigned int a3, int a4)
{
unsigned long long v5; // [rsp+38h] [rbp-C8h]
long long v6; // [rsp+40h] [rbp-C0h]
__int16 v7; // [rsp+4Ch] [rbp-B4h]
_BYTE v8[32]; // [rsp+50h] [rbp-B0h] BYREF
_BYTE *v9; // [rsp+70h] [rbp-90h]
long long v10; // [rsp+78h] [rbp-88h]
long long v11; // [rsp+80h] [rbp-80h]
long long v12; // [rsp+88h] [rbp-78h]
_BYTE *v13; // [rsp+B0h] [rbp-50h]
char v14; // [rsp+B8h] [rbp-48h] BYREF
int v15; // [rsp+C0h] [rbp-40h]
unsigned int v16; // [rsp+C4h] [rbp-3Ch]
long long v17; // [rsp+C8h] [rbp-38h]
_QWORD *v18; // [rsp+D0h] [rbp-30h]
_BYTE v19[2]; // [rsp+E0h] [rbp-20h] BYREF
int v20; // [rsp+E2h] [rbp-1Eh]
char v21; // [rsp+E6h] [rbp-1Ah]
char v22; // [rsp+E7h] [rbp-19h]
__int16 v23; // [rsp+E8h] [rbp-18h]
char v24; // [rsp+EAh] [rbp-16h]
__int16 v25; // [rsp+EBh] [rbp-15h]
_BYTE v26[19]; // [rsp+EDh] [rbp-13h] BYREF
long long savedregs; // [rsp+100h] [rbp+0h] BYREF
*(_QWORD *)&v26[11] = __readfsqword(0x28u);
v18 = a1;
v17 = a2;
v16 = a3;
v15 = a4;
v7 = a2 - a1[2];
v6 = *a1;
v5 = a1[3] / (unsigned long long)*(unsigned int *)(*(_QWORD *)*a1 + 1980LL);
v20 = v5;
v21 = BYTE4(v5);
v22 = 1;
v23 = v7;
v24 = 3;
v25 = a3;
v13 = v26;
v9 = v19;
v10 = 13LL;
v11 = a2;
v12 = a3;
return (unsigned __int8)translog_write_record(
(unsigned int)&v14,
12,
*(_QWORD *)(v6 + 8),
v6,
a3 + (unsigned int)v26 - ((unsigned int)&savedregs - 32),
4,
(long long)v8,
(long long)v19,
0LL) != 0;
}
|
_ma_log_change:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x100
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x30],RDI
MOV qword ptr [RBP + -0x38],RSI
MOV dword ptr [RBP + -0x3c],EDX
MOV dword ptr [RBP + -0x40],ECX
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RCX + 0x10]
SUB RAX,RCX
MOV dword ptr [RBP + -0xb4],EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0xc0],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x18]
MOV RCX,qword ptr [RBP + -0xc0]
MOV RCX,qword ptr [RCX]
MOV ECX,dword ptr [RCX + 0x7bc]
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0xc8],RAX
JMP 0x0016ae3f
LAB_0016ae3f:
JMP 0x0016ae41
LAB_0016ae41:
JMP 0x0016ae43
LAB_0016ae43:
JMP 0x0016ae45
LAB_0016ae45:
JMP 0x0016ae47
LAB_0016ae47:
JMP 0x0016ae49
LAB_0016ae49:
JMP 0x0016ae4b
LAB_0016ae4b:
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x18]
MOV RCX,qword ptr [RBP + -0xc0]
MOV RCX,qword ptr [RCX]
MOV ECX,dword ptr [RCX + 0x7bc]
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0xc8],RAX
LEA RAX,[RBP + -0x20]
ADD RAX,0x2
MOV qword ptr [RBP + -0xd0],RAX
MOV RAX,qword ptr [RBP + -0xc8]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0xd0]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0xc8]
SHR RAX,0x20
MOV CL,AL
MOV RAX,qword ptr [RBP + -0xd0]
MOV byte ptr [RAX + 0x4],CL
LEA RAX,[RBP + -0x20]
ADD RAX,0x2
ADD RAX,0x5
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV byte ptr [RAX],0x1
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,0x1
MOV qword ptr [RBP + -0xd8],RAX
MOV EAX,dword ptr [RBP + -0xb4]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0xd8]
MOV word ptr [RAX],CX
MOV RAX,qword ptr [RBP + -0x50]
MOV byte ptr [RAX + 0x3],0x3
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,0x4
MOV qword ptr [RBP + -0xe0],RAX
MOV EAX,dword ptr [RBP + -0x3c]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0xe0]
MOV word ptr [RAX],CX
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,0x6
MOV qword ptr [RBP + -0x50],RAX
LEA RAX,[RBP + -0x20]
MOV qword ptr [RBP + -0x90],RAX
MOV RAX,qword ptr [RBP + -0x50]
LEA RCX,[RBP + -0x20]
SUB RAX,RCX
MOV qword ptr [RBP + -0x88],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x80],RAX
MOV EAX,dword ptr [RBP + -0x3c]
MOV qword ptr [RBP + -0x78],RAX
MOV dword ptr [RBP + -0xb8],0x2
MOV RAX,qword ptr [RBP + -0xc0]
MOV RDX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0xc0]
MOV RAX,qword ptr [RBP + -0x50]
LEA RSI,[RBP + -0x20]
SUB RAX,RSI
MOV R8D,EAX
ADD R8D,dword ptr [RBP + -0x3c]
MOV R9D,dword ptr [RBP + -0xb8]
ADD R9D,0x2
LEA R10,[RBP + -0xb0]
LEA RAX,[RBP + -0x20]
LEA RDI,[RBP + -0x48]
MOV ESI,0xc
XOR R11D,R11D
MOV qword ptr [RSP],R10
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],0x0
CALL 0x00190c10
CMP AL,0x0
JZ 0x0016afb2
JMP 0x0016afac
LAB_0016afac:
MOV byte ptr [RBP + -0x21],0x1
JMP 0x0016afb8
LAB_0016afb2:
JMP 0x0016afb4
LAB_0016afb4:
MOV byte ptr [RBP + -0x21],0x0
LAB_0016afb8:
MOV AL,byte ptr [RBP + -0x21]
MOV byte ptr [RBP + -0xe1],AL
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0016afe2
MOV AL,byte ptr [RBP + -0xe1]
ADD RSP,0x100
POP RBP
RET
LAB_0016afe2:
CALL 0x00129230
|
int8 _ma_log_change(long *param_1,int8 param_2,uint param_3,int4 param_4)
{
long *plVar1;
char cVar2;
ulong uVar3;
long in_FS_OFFSET;
int1 local_b8 [32];
int1 *local_98;
long local_90;
int8 local_88;
ulong local_80;
int1 *local_58;
int1 local_50 [8];
int4 local_48;
uint local_44;
int8 local_40;
long *local_38;
int1 local_29;
int1 local_28 [2];
int4 local_26;
int1 local_22;
int1 local_21;
short local_20;
int1 local_1e;
int2 local_1d;
int1 auStack_1b [11];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_20 = (short)param_2 - (short)param_1[2];
plVar1 = (long *)*param_1;
uVar3 = (ulong)param_1[3] / (ulong)*(uint *)(*plVar1 + 0x7bc);
local_26 = (int4)uVar3;
local_22 = (int1)(uVar3 >> 0x20);
local_21 = 1;
local_1e = 3;
local_1d = (int2)param_3;
local_58 = auStack_1b;
local_98 = local_28;
local_90 = (long)local_58 - (long)local_28;
local_80 = (ulong)param_3;
local_88 = param_2;
local_48 = param_4;
local_44 = param_3;
local_40 = param_2;
local_38 = param_1;
cVar2 = translog_write_record
(local_50,0xc,plVar1[1],plVar1,((int)local_58 - (int)local_28) + param_3,4,
local_b8,local_28,0);
local_29 = cVar2 != '\0';
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return CONCAT71((int7)((ulong)*(long *)(in_FS_OFFSET + 0x28) >> 8),local_29);
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
11,718 |
void (anonymous namespace)::tinyBLAS_Q0_AVX<block_q8_0, block_q8_0, float>::gemmMx4<2>(long, long, long, long)
|
llama.cpp/ggml/src/ggml-cpu/llamafile/sgemm.cpp
|
NOINLINE void gemmMx4(int64_t m0, int64_t m, int64_t n0, int64_t n) {
int64_t ytiles = (m - m0) / RM;
int64_t xtiles = (n - n0) / 4;
int64_t tiles = xtiles * ytiles;
int64_t duty = (tiles + nth - 1) / nth;
int64_t start = duty * ith;
int64_t end = start + duty;
if (end > tiles)
end = tiles;
for (int64_t job = start; job < end; ++job) {
int64_t ii = m0 + job / xtiles * RM;
int64_t jj = n0 + job % xtiles * 4;
__m256 Cv[4][RM] = {};
for (int64_t l = 0; l < k; ++l) {
uint64_t b_delta = ((uint64_t)B[ldb * (jj + 3) + l].d << 48) | ((uint64_t)B[ldb * (jj + 2) + l].d << 32) | ((uint64_t)B[ldb * (jj + 1) + l].d << 16) | (B[ldb * (jj + 0) + l].d);
// Convert delta values for four blocks to float values
__m128 db = _mm_cvtph_ps(_mm_set_epi64x(0, b_delta));
__m256i bvec0 = load(B + ldb * (jj + 0) + l);
__m256i bvec1 = load(B + ldb * (jj + 1) + l);
__m256i bvec2 = load(B + ldb * (jj + 2) + l);
__m256i bvec3 = load(B + ldb * (jj + 3) + l);
for (int64_t i = 0; i < RM; ++i) {
__m128 da = _mm_set1_ps(unhalf((A[lda * (ii + i) + l].d)));
// Computation of product of delta values for four blocks and replicate it across 256 bit lane
__m256 dvec = _mm256_castps128_ps256(_mm_mul_ps(da, db));
dvec = _mm256_permute2f128_ps(dvec ,dvec, 0);
// Computation of dot product and multiplication with appropriate delta value products
Cv[0][i] = madd(_mm256_shuffle_ps(dvec, dvec, 0),
updot(_mm256_sign_epi8(load(A + lda * (ii + i) + l),
load(A + lda * (ii + i) + l)),
_mm256_sign_epi8(bvec0, load(A + lda * (ii + i) + l))),
Cv[0][i]);
Cv[1][i] = madd(_mm256_shuffle_ps(dvec, dvec, 85),
updot(_mm256_sign_epi8(load(A + lda * (ii + i) + l),
load(A + lda * (ii + i) + l)),
_mm256_sign_epi8(bvec1, load(A + lda * (ii + i) + l))),
Cv[1][i]);
Cv[2][i] = madd(_mm256_shuffle_ps(dvec, dvec, 170),
updot(_mm256_sign_epi8(load(A + lda * (ii + i) + l),
load(A + lda * (ii + i) + l)),
_mm256_sign_epi8(bvec2, load(A + lda * (ii + i) + l))),
Cv[2][i]);
Cv[3][i] = madd(_mm256_shuffle_ps(dvec, dvec, 255),
updot(_mm256_sign_epi8(load(A + lda * (ii + i) + l),
load(A + lda * (ii + i) + l)),
_mm256_sign_epi8(bvec3, load(A + lda * (ii + i) + l))),
Cv[3][i]);
}
}
for (int64_t j = 0; j < 4; ++j)
for (int64_t i = 0; i < RM; ++i)
C[ldc * (jj + j) + (ii + i)] = hsum(Cv[j][i]);
}
}
|
O3
|
cpp
|
void (anonymous namespace)::tinyBLAS_Q0_AVX<block_q8_0, block_q8_0, float>::gemmMx4<2>(long, long, long, long):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
andq $-0x20, %rsp
subq $0x100, %rsp # imm = 0x100
movq %rdx, %r10
movq %rsi, 0x50(%rsp)
subq %rsi, %r10
movq %rcx, 0x58(%rsp)
subq %rcx, %r8
leaq 0x3(%r8), %rax
testq %r8, %r8
cmovnsq %r8, %rax
sarq $0x2, %rax
movq %rax, 0x48(%rsp)
imulq %rax, %r10
movslq 0x3c(%rdi), %rcx
leaq (%r10,%rcx), %rax
decq %rax
cqto
idivq %rcx
movslq 0x38(%rdi), %r8
imulq %rax, %r8
addq %r8, %rax
cmpq %r10, %rax
cmovgeq %r10, %rax
movq %rax, 0x40(%rsp)
cmpq %rax, %r8
jge 0x5ce02
movq 0x18(%rdi), %r14
movq (%rdi), %rax
movq %rax, 0x30(%rsp)
movq 0x8(%rdi), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rdi), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rdi), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rdi), %rax
movq %rax, 0x38(%rsp)
movq 0x30(%rdi), %rdi
shlq $0x2, %rdi
vxorps %xmm16, %xmm16, %xmm16
movq 0x20398(%rip), %r12 # 0x7cf60
vpbroadcastw 0x16d2b(%rip), %ymm1 # 0x738fc
vbroadcastss 0xc1c2(%rip), %ymm2 # 0x68d9c
vbroadcastss 0xc1bd(%rip), %ymm3 # 0x68da0
vbroadcastss 0xc18c(%rip), %ymm4 # 0x68d78
movq %r8, %rax
cqto
idivq 0x48(%rsp)
addq 0x50(%rsp), %rax
movq 0x58(%rsp), %rcx
leaq (%rcx,%rdx,4), %rdx
leaq 0x80(%rsp), %rcx
vmovaps %ymm16, 0x40(%rcx)
vmovaps %ymm16, 0x20(%rcx)
vmovaps %ymm16, (%rcx)
vxorps %xmm5, %xmm5, %xmm5
testq %r14, %r14
jle 0x5cdb2
leaq 0x3(%rdx), %rcx
movq 0x20(%rsp), %r10
imulq %r10, %rcx
movq %rcx, %rsi
shlq $0x5, %rsi
leaq (%rsi,%rcx,2), %r13
movq 0x28(%rsp), %rbx
addq %rbx, %r13
leaq 0x2(%rdx), %rcx
imulq %r10, %rcx
movq %rcx, %rsi
shlq $0x5, %rsi
leaq (%rsi,%rcx,2), %rcx
addq %rbx, %rcx
leaq 0x1(%rdx), %rsi
imulq %r10, %rsi
movq %rsi, %r9
shlq $0x5, %r9
leaq (%r9,%rsi,2), %rsi
addq %rbx, %rsi
movq %r10, %r9
imulq %rdx, %r9
movq %r9, %r10
shlq $0x5, %r10
leaq (%r10,%r9,2), %r11
addq %rbx, %r11
movq 0x18(%rsp), %r9
imulq %rax, %r9
movq %r9, %r10
shlq $0x5, %r10
leaq (%r10,%r9,2), %r9
addq 0x30(%rsp), %r9
vxorps %xmm6, %xmm6, %xmm6
movl $0x2, %ebx
movq %r14, %r15
movq %r14, %r10
vxorps %xmm7, %xmm7, %xmm7
vxorps %xmm8, %xmm8, %xmm8
movzwl -0x2(%r11,%rbx), %r14d
vmovd %r14d, %xmm9
vpinsrw $0x1, -0x2(%rsi,%rbx), %xmm9, %xmm9
vpinsrw $0x2, -0x2(%rcx,%rbx), %xmm9, %xmm9
vpinsrw $0x3, -0x2(%r13,%rbx), %xmm9, %xmm9
vcvtph2ps %xmm9, %xmm9
vmovdqu (%r11,%rbx), %ymm10
vmovdqu (%rsi,%rbx), %ymm11
vmovdqu (%rcx,%rbx), %ymm12
vmovdqu (%r13,%rbx), %ymm13
movzwl -0x2(%r9,%rbx), %r14d
vmulps (%r12,%r14,4){1to4}, %xmm9, %xmm9
vbroadcastss %xmm9, %ymm14
vmovdqu (%r9,%rbx), %ymm15
vpsignb %ymm15, %ymm15, %ymm0
vpsignb %ymm15, %ymm10, %ymm10
vpmaddubsw %ymm10, %ymm0, %ymm10
vpmaddwd %ymm1, %ymm10, %ymm10
vcvtdq2ps %ymm10, %ymm10
vfmadd231ps %ymm10, %ymm14, %ymm5 # ymm5 = (ymm14 * ymm10) + ymm5
vpermps %ymm9, %ymm2, %ymm10
vpsignb %ymm15, %ymm11, %ymm11
vpmaddubsw %ymm11, %ymm0, %ymm11
vpmaddwd %ymm1, %ymm11, %ymm11
vcvtdq2ps %ymm11, %ymm11
vfmadd231ps %ymm11, %ymm10, %ymm8 # ymm8 = (ymm10 * ymm11) + ymm8
vpermps %ymm9, %ymm3, %ymm10
vpsignb %ymm15, %ymm12, %ymm11
vpmaddubsw %ymm11, %ymm0, %ymm11
vpmaddwd %ymm1, %ymm11, %ymm11
vcvtdq2ps %ymm11, %ymm11
vfmadd231ps %ymm11, %ymm10, %ymm7 # ymm7 = (ymm10 * ymm11) + ymm7
vpermps %ymm9, %ymm4, %ymm9
vpsignb %ymm15, %ymm13, %ymm10
vpmaddubsw %ymm10, %ymm0, %ymm0
vpmaddwd %ymm0, %ymm1, %ymm0
vcvtdq2ps %ymm0, %ymm0
vfmadd231ps %ymm0, %ymm9, %ymm6 # ymm6 = (ymm9 * ymm0) + ymm6
addq $0x22, %rbx
decq %r10
jne 0x5ccbf
vmovaps %ymm8, 0x80(%rsp)
vmovaps %ymm7, 0xa0(%rsp)
vmovaps %ymm6, 0xc0(%rsp)
movq %r15, %r14
vmovaps %ymm5, 0x60(%rsp)
imulq %rdi, %rdx
leaq (%rdx,%rax,4), %rax
addq 0x38(%rsp), %rax
xorl %ecx, %ecx
vmovaps 0x70(%rsp,%rcx), %xmm0
vaddps 0x60(%rsp,%rcx), %xmm0, %xmm0
vshufpd $0x1, %xmm0, %xmm0, %xmm5 # xmm5 = xmm0[1,0]
vaddps %xmm5, %xmm0, %xmm0
vhaddps %xmm0, %xmm0, %xmm0
vmovss %xmm0, (%rax)
addq $0x20, %rcx
addq %rdi, %rax
cmpq $0x80, %rcx
jne 0x5cdc7
incq %r8
cmpq 0x40(%rsp), %r8
jne 0x5cbec
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
vzeroupper
retq
|
_ZN12_GLOBAL__N_115tinyBLAS_Q0_AVXI10block_q8_0S1_fE7gemmMx4ILi1EEEvllll:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
and rsp, 0FFFFFFFFFFFFFFE0h
sub rsp, 100h
mov r10, rdx
mov [rsp+128h+var_D8], rsi
sub r10, rsi
mov [rsp+128h+var_D0], rcx
sub r8, rcx
lea rax, [r8+3]
test r8, r8
cmovns rax, r8
sar rax, 2
mov [rsp+128h+var_E0], rax
imul r10, rax
movsxd rcx, dword ptr [rdi+3Ch]
lea rax, [r10+rcx]
dec rax
cqo
idiv rcx
movsxd r8, dword ptr [rdi+38h]
imul r8, rax
add rax, r8
cmp rax, r10
cmovge rax, r10
mov [rsp+128h+var_E8], rax
cmp r8, rax
jge loc_5CE02
mov r14, [rdi+18h]
mov rax, [rdi]
mov [rsp+128h+var_F8], rax
mov rax, [rdi+8]
mov [rsp+128h+var_100], rax
mov rax, [rdi+28h]
mov [rsp+128h+var_108], rax
mov rax, [rdi+20h]
mov [rsp+128h+var_110], rax
mov rax, [rdi+10h]
mov [rsp+128h+var_F0], rax
mov rdi, [rdi+30h]
shl rdi, 2
vxorps xmm16, xmm16, xmm16
mov r12, cs:ggml_table_f32_f16_ptr
vpbroadcastw ymm1, cs:word_738FC
vbroadcastss ymm2, cs:dword_68D9C
vbroadcastss ymm3, cs:dword_68DA0
vbroadcastss ymm4, cs:dword_68D78
loc_5CBEC:
mov rax, r8
cqo
idiv [rsp+128h+var_E0]
add rax, [rsp+128h+var_D8]
mov rcx, [rsp+128h+var_D0]
lea rdx, [rcx+rdx*4]
lea rcx, [rsp+128h+var_A8]
vmovaps ymmword ptr [rcx+40h], ymm16
vmovaps ymmword ptr [rcx+20h], ymm16
vmovaps ymmword ptr [rcx], ymm16
vxorps xmm5, xmm5, xmm5
test r14, r14
jle loc_5CDB2
lea rcx, [rdx+3]
mov r10, [rsp+128h+var_108]
imul rcx, r10
mov rsi, rcx
shl rsi, 5
lea r13, [rsi+rcx*2]
mov rbx, [rsp+128h+var_100]
add r13, rbx
lea rcx, [rdx+2]
imul rcx, r10
mov rsi, rcx
shl rsi, 5
lea rcx, [rsi+rcx*2]
add rcx, rbx
lea rsi, [rdx+1]
imul rsi, r10
mov r9, rsi
shl r9, 5
lea rsi, [r9+rsi*2]
add rsi, rbx
mov r9, r10
imul r9, rdx
mov r10, r9
shl r10, 5
lea r11, [r10+r9*2]
add r11, rbx
mov r9, [rsp+128h+var_110]
imul r9, rax
mov r10, r9
shl r10, 5
lea r9, [r10+r9*2]
add r9, [rsp+128h+var_F8]
vxorps xmm6, xmm6, xmm6
mov ebx, 2
mov r15, r14
mov r10, r14
vxorps xmm7, xmm7, xmm7
vxorps xmm8, xmm8, xmm8
loc_5CCBF:
movzx r14d, word ptr [r11+rbx-2]
vmovd xmm9, r14d
vpinsrw xmm9, xmm9, word ptr [rsi+rbx-2], 1
vpinsrw xmm9, xmm9, word ptr [rcx+rbx-2], 2
vpinsrw xmm9, xmm9, word ptr [r13+rbx-2], 3
vcvtph2ps xmm9, xmm9
vmovdqu ymm10, ymmword ptr [r11+rbx]
vmovdqu ymm11, ymmword ptr [rsi+rbx]
vmovdqu ymm12, ymmword ptr [rcx+rbx]
vmovdqu ymm13, ymmword ptr [r13+rbx+0]
movzx r14d, word ptr [r9+rbx-2]
vmulps xmm9, xmm9, dword ptr [r12+r14*4]{1to4}
vbroadcastss ymm14, xmm9
vmovdqu ymm15, ymmword ptr [r9+rbx]
vpsignb ymm0, ymm15, ymm15
vpsignb ymm10, ymm10, ymm15
vpmaddubsw ymm10, ymm0, ymm10
vpmaddwd ymm10, ymm10, ymm1
vcvtdq2ps ymm10, ymm10
vfmadd231ps ymm5, ymm14, ymm10
vpermps ymm10, ymm2, ymm9
vpsignb ymm11, ymm11, ymm15
vpmaddubsw ymm11, ymm0, ymm11
vpmaddwd ymm11, ymm11, ymm1
vcvtdq2ps ymm11, ymm11
vfmadd231ps ymm8, ymm10, ymm11
vpermps ymm10, ymm3, ymm9
vpsignb ymm11, ymm12, ymm15
vpmaddubsw ymm11, ymm0, ymm11
vpmaddwd ymm11, ymm11, ymm1
vcvtdq2ps ymm11, ymm11
vfmadd231ps ymm7, ymm10, ymm11
vpermps ymm9, ymm4, ymm9
vpsignb ymm10, ymm13, ymm15
vpmaddubsw ymm0, ymm0, ymm10
vpmaddwd ymm0, ymm1, ymm0
vcvtdq2ps ymm0, ymm0
vfmadd231ps ymm6, ymm9, ymm0
add rbx, 22h ; '"'
dec r10
jnz loc_5CCBF
vmovaps [rsp+128h+var_A8], ymm8
vmovaps [rsp+128h+var_88], ymm7
vmovaps [rsp+128h+var_68], ymm6
mov r14, r15
loc_5CDB2:
vmovaps [rsp+128h+var_C8], ymm5
imul rdx, rdi
lea rax, [rdx+rax*4]
add rax, [rsp+128h+var_F0]
xor ecx, ecx
loc_5CDC7:
vmovaps xmm0, xmmword ptr [rsp+rcx+128h+var_C8+10h]
vaddps xmm0, xmm0, xmmword ptr [rsp+rcx+128h+var_C8]
vshufpd xmm5, xmm0, xmm0, 1
vaddps xmm0, xmm0, xmm5
vhaddps xmm0, xmm0, xmm0
vmovss dword ptr [rax], xmm0
add rcx, 20h ; ' '
add rax, rdi
cmp rcx, 80h
jnz short loc_5CDC7
inc r8
cmp r8, [rsp+128h+var_E8]
jnz loc_5CBEC
loc_5CE02:
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
vzeroupper
retn
|
long long `anonymous namespace'::tinyBLAS_Q0_AVX<block_q8_0,block_q8_0,float>::gemmMx4<1>(
long long *a1,
long long a2,
long long a3,
long long a4,
long long a5,
double a6,
double a7,
double a8,
double a9,
double a10,
__m128 _XMM5,
__m128 _XMM6,
__m128 _XMM7)
{
long long v19; // r10
long long v20; // rax
long long v21; // r8
long long result; // rax
long long v23; // r14
long long v24; // rdi
long long v30; // rax
long long v31; // rdx
long long v40; // r15
long long v41; // r10
long long v80; // [rsp+18h] [rbp-110h]
long long v81; // [rsp+20h] [rbp-108h]
long long v82; // [rsp+28h] [rbp-100h]
long long v83; // [rsp+30h] [rbp-F8h]
long long v84; // [rsp+38h] [rbp-F0h]
long long v85; // [rsp+40h] [rbp-E8h]
long long v86; // [rsp+48h] [rbp-E0h]
__m256 v90; // [rsp+80h] [rbp-A8h] BYREF
v86 = (a5 - a4) / 4;
v19 = v86 * (a3 - a2);
v20 = (v19 + *((int *)a1 + 15) - 1) / *((int *)a1 + 15);
v21 = v20 * *((int *)a1 + 14);
result = v21 + v20;
if ( result >= v19 )
result = v86 * (a3 - a2);
v85 = result;
if ( v21 < result )
{
v23 = a1[3];
v83 = *a1;
v82 = a1[1];
v81 = a1[5];
v80 = a1[4];
v84 = a1[2];
v24 = 4 * a1[6];
__asm
{
vxorps xmm16, xmm16, xmm16
vpbroadcastw ymm1, cs:word_738FC
vbroadcastss ymm2, cs:dword_68D9C
vbroadcastss ymm3, cs:dword_68DA0
vbroadcastss ymm4, cs:dword_68D78
}
do
{
v30 = a2 + v21 / v86;
v31 = a4 + 4 * (v21 % v86);
_RCX = &v90;
__asm
{
vmovaps ymmword ptr [rcx+40h], ymm16
vmovaps ymmword ptr [rcx+20h], ymm16
vmovaps ymmword ptr [rcx], ymm16
vxorps xmm5, xmm5, xmm5
}
if ( v23 > 0 )
{
_R13 = v82 + 34 * v81 * (v31 + 3);
_RCX = v82 + 34 * v81 * (v31 + 2);
_RSI = v82 + 34 * v81 * (v31 + 1);
_R11 = v82 + 34 * v31 * v81;
_R9 = v83 + 34 * v30 * v80;
__asm { vxorps xmm6, xmm6, xmm6 }
_RBX = 2LL;
v40 = v23;
v41 = v23;
__asm
{
vxorps xmm7, xmm7, xmm7
vxorps xmm8, xmm8, xmm8
}
do
{
_R14D = *(unsigned __int16 *)(_R11 + _RBX - 2);
__asm
{
vmovd xmm9, r14d
vpinsrw xmm9, xmm9, word ptr [rsi+rbx-2], 1
vpinsrw xmm9, xmm9, word ptr [rcx+rbx-2], 2
vpinsrw xmm9, xmm9, word ptr [r13+rbx-2], 3
vcvtph2ps xmm9, xmm9
vmovdqu ymm10, ymmword ptr [r11+rbx]
vmovdqu ymm11, ymmword ptr [rsi+rbx]
vmovdqu ymm12, ymmword ptr [rcx+rbx]
vmovdqu ymm13, ymmword ptr [r13+rbx+0]
vmulps xmm9, xmm9, dword ptr [r12+r14*4]{1to4}
vbroadcastss ymm14, xmm9
vmovdqu ymm15, ymmword ptr [r9+rbx]
vpsignb ymm0, ymm15, ymm15
vpsignb ymm10, ymm10, ymm15
vpmaddubsw ymm10, ymm0, ymm10
vpmaddwd ymm10, ymm10, ymm1
vcvtdq2ps ymm10, ymm10
vfmadd231ps ymm5, ymm14, ymm10
vpermps ymm10, ymm2, ymm9
vpsignb ymm11, ymm11, ymm15
vpmaddubsw ymm11, ymm0, ymm11
vpmaddwd ymm11, ymm11, ymm1
vcvtdq2ps ymm11, ymm11
vfmadd231ps ymm8, ymm10, ymm11
vpermps ymm10, ymm3, ymm9
vpsignb ymm11, ymm12, ymm15
vpmaddubsw ymm11, ymm0, ymm11
vpmaddwd ymm11, ymm11, ymm1
vcvtdq2ps ymm11, ymm11
vfmadd231ps ymm7, ymm10, ymm11
vpermps ymm9, ymm4, ymm9
vpsignb ymm10, ymm13, ymm15
vpmaddubsw ymm0, ymm0, ymm10
vpmaddwd ymm0, ymm1, ymm0
vcvtdq2ps ymm0, ymm0
vfmadd231ps ymm6, ymm9, ymm0
}
_RBX += 34LL;
--v41;
}
while ( v41 );
__asm
{
vmovaps [rsp+128h+var_A8], ymm8
vmovaps [rsp+128h+var_88], ymm7
vmovaps [rsp+128h+var_68], ymm6
}
v23 = v40;
}
__asm { vmovaps [rsp+128h+var_C8], ymm5 }
result = v84 + v24 * v31 + 4 * v30;
for ( _RCX = 0LL; _RCX != 128; _RCX += 32LL )
{
__asm
{
vmovaps xmm0, xmmword ptr [rsp+rcx+128h+var_C8+10h]
vaddps xmm0, xmm0, xmmword ptr [rsp+rcx+128h+var_C8]
vshufpd xmm5, xmm0, xmm0, 1
vaddps xmm0, xmm0, xmm5
vhaddps xmm0, xmm0, xmm0
vmovss dword ptr [rax], xmm0
}
result += v24;
}
++v21;
}
while ( v21 != v85 );
}
__asm { vzeroupper }
return result;
}
|
gemmMx4<1>:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
AND RSP,-0x20
SUB RSP,0x100
MOV R10,RDX
MOV qword ptr [RSP + 0x50],RSI
SUB R10,RSI
MOV qword ptr [RSP + 0x58],RCX
SUB R8,RCX
LEA RAX,[R8 + 0x3]
TEST R8,R8
CMOVNS RAX,R8
SAR RAX,0x2
MOV qword ptr [RSP + 0x48],RAX
IMUL R10,RAX
MOVSXD RCX,dword ptr [RDI + 0x3c]
LEA RAX,[R10 + RCX*0x1]
DEC RAX
CQO
IDIV RCX
MOVSXD R8,dword ptr [RDI + 0x38]
IMUL R8,RAX
ADD RAX,R8
CMP RAX,R10
CMOVGE RAX,R10
MOV qword ptr [RSP + 0x40],RAX
CMP R8,RAX
JGE 0x0015ce02
MOV R14,qword ptr [RDI + 0x18]
MOV RAX,qword ptr [RDI]
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RDI + 0x8]
MOV qword ptr [RSP + 0x28],RAX
MOV RAX,qword ptr [RDI + 0x28]
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [RDI + 0x20]
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [RDI + 0x10]
MOV qword ptr [RSP + 0x38],RAX
MOV RDI,qword ptr [RDI + 0x30]
SHL RDI,0x2
VXORPS XMM0,XMM0,XMM0
MOV R12,qword ptr [0x0017cf60]
VPBROADCASTW YMM1,word ptr [0x001738fc]
VBROADCASTSS YMM2,dword ptr [0x00168d9c]
VBROADCASTSS YMM3,dword ptr [0x00168da0]
VBROADCASTSS YMM4,dword ptr [0x00168d78]
LAB_0015cbec:
MOV RAX,R8
CQO
IDIV qword ptr [RSP + 0x48]
ADD RAX,qword ptr [RSP + 0x50]
MOV RCX,qword ptr [RSP + 0x58]
LEA RDX,[RCX + RDX*0x4]
LEA RCX,[RSP + 0x80]
VMOVAPS ymmword ptr [RCX + 0x40] ,YMM0
VMOVAPS ymmword ptr [RCX + 0x20] ,YMM0
VMOVAPS ymmword ptr [RCX] ,YMM0
VXORPS XMM5,XMM5,XMM5
TEST R14,R14
JLE 0x0015cdb2
LEA RCX,[RDX + 0x3]
MOV R10,qword ptr [RSP + 0x20]
IMUL RCX,R10
MOV RSI,RCX
SHL RSI,0x5
LEA R13,[RSI + RCX*0x2]
MOV RBX,qword ptr [RSP + 0x28]
ADD R13,RBX
LEA RCX,[RDX + 0x2]
IMUL RCX,R10
MOV RSI,RCX
SHL RSI,0x5
LEA RCX,[RSI + RCX*0x2]
ADD RCX,RBX
LEA RSI,[RDX + 0x1]
IMUL RSI,R10
MOV R9,RSI
SHL R9,0x5
LEA RSI,[R9 + RSI*0x2]
ADD RSI,RBX
MOV R9,R10
IMUL R9,RDX
MOV R10,R9
SHL R10,0x5
LEA R11,[R10 + R9*0x2]
ADD R11,RBX
MOV R9,qword ptr [RSP + 0x18]
IMUL R9,RAX
MOV R10,R9
SHL R10,0x5
LEA R9,[R10 + R9*0x2]
ADD R9,qword ptr [RSP + 0x30]
VXORPS XMM6,XMM6,XMM6
MOV EBX,0x2
MOV R15,R14
MOV R10,R14
VXORPS XMM7,XMM7,XMM7
VXORPS XMM8,XMM8,XMM8
LAB_0015ccbf:
MOVZX R14D,word ptr [R11 + RBX*0x1 + -0x2]
VMOVD XMM9,R14D
VPINSRW XMM9,XMM9,word ptr [RSI + RBX*0x1 + -0x2],0x1
VPINSRW XMM9,XMM9,word ptr [RCX + RBX*0x1 + -0x2],0x2
VPINSRW XMM9,XMM9,word ptr [R13 + RBX*0x1 + -0x2],0x3
VCVTPH2PS XMM9,XMM9
VMOVDQU YMM10,ymmword ptr [R11 + RBX*0x1]
VMOVDQU YMM11,ymmword ptr [RSI + RBX*0x1]
VMOVDQU YMM12,ymmword ptr [RCX + RBX*0x1]
VMOVDQU YMM13,ymmword ptr [R13 + RBX*0x1]
MOVZX R14D,word ptr [R9 + RBX*0x1 + -0x2]
VMULPS XMM9,XMM9,dword ptr [R12 + R14*0x4]
VBROADCASTSS YMM14,XMM9
VMOVDQU YMM15,ymmword ptr [R9 + RBX*0x1]
VPSIGNB YMM0,YMM15,YMM15
VPSIGNB YMM10,YMM10,YMM15
VPMADDUBSW YMM10,YMM0,YMM10
VPMADDWD YMM10,YMM10,YMM1
VCVTDQ2PS YMM10,YMM10
VFMADD231PS YMM5,YMM14,YMM10
VPERMPS YMM10,YMM2,YMM9
VPSIGNB YMM11,YMM11,YMM15
VPMADDUBSW YMM11,YMM0,YMM11
VPMADDWD YMM11,YMM11,YMM1
VCVTDQ2PS YMM11,YMM11
VFMADD231PS YMM8,YMM10,YMM11
VPERMPS YMM10,YMM3,YMM9
VPSIGNB YMM11,YMM12,YMM15
VPMADDUBSW YMM11,YMM0,YMM11
VPMADDWD YMM11,YMM11,YMM1
VCVTDQ2PS YMM11,YMM11
VFMADD231PS YMM7,YMM10,YMM11
VPERMPS YMM9,YMM4,YMM9
VPSIGNB YMM10,YMM13,YMM15
VPMADDUBSW YMM0,YMM0,YMM10
VPMADDWD YMM0,YMM1,YMM0
VCVTDQ2PS YMM0,YMM0
VFMADD231PS YMM6,YMM9,YMM0
ADD RBX,0x22
DEC R10
JNZ 0x0015ccbf
VMOVAPS ymmword ptr [RSP + 0x80],YMM8
VMOVAPS ymmword ptr [RSP + 0xa0],YMM7
VMOVAPS ymmword ptr [RSP + 0xc0],YMM6
MOV R14,R15
LAB_0015cdb2:
VMOVAPS ymmword ptr [RSP + 0x60],YMM5
IMUL RDX,RDI
LEA RAX,[RDX + RAX*0x4]
ADD RAX,qword ptr [RSP + 0x38]
XOR ECX,ECX
LAB_0015cdc7:
VMOVAPS XMM0,xmmword ptr [RSP + RCX*0x1 + 0x70]
VADDPS XMM0,XMM0,xmmword ptr [RSP + RCX*0x1 + 0x60]
VSHUFPD XMM5,XMM0,XMM0,0x1
VADDPS XMM0,XMM0,XMM5
VHADDPS XMM0,XMM0,XMM0
VMOVSS dword ptr [RAX],XMM0
ADD RCX,0x20
ADD RAX,RDI
CMP RCX,0x80
JNZ 0x0015cdc7
INC R8
CMP R8,qword ptr [RSP + 0x40]
JNZ 0x0015cbec
LAB_0015ce02:
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
VZEROUPPER
RET
|
/* void (anonymous namespace)::tinyBLAS_Q0_AVX<block_q8_0, block_q8_0, float>::gemmMx4<1>(long,
long, long, long) */
void __thiscall
(anonymous_namespace)::tinyBLAS_Q0_AVX<block_q8_0,block_q8_0,float>::gemmMx4<1>
(tinyBLAS_Q0_AVX<block_q8_0,block_q8_0,float> *this,long param_1,long param_2,long param_3
,long param_4)
{
int1 auVar1 [32];
long lVar2;
long lVar3;
long lVar4;
long lVar5;
long lVar6;
long lVar7;
int1 auVar8 [32];
int1 auVar9 [32];
int1 auVar10 [16];
int *puVar11;
long lVar12;
long lVar13;
int4 *puVar14;
long lVar15;
long lVar16;
long lVar17;
long lVar18;
long lVar19;
long lVar20;
long lVar21;
long lVar22;
long lVar23;
long lVar24;
long lVar25;
int1 auVar26 [16];
int1 auVar27 [16];
int1 auVar28 [16];
int1 auVar29 [16];
int1 in_ZMM0 [64];
int1 auVar30 [32];
int1 auVar31 [32];
int1 auVar32 [32];
int1 auVar33 [32];
int1 auVar34 [16];
int4 uVar35;
int1 auVar36 [32];
int1 auVar37 [32];
int1 local_e0 [4];
float afStack_dc [7];
int1 local_c0 [32];
int1 local_a0 [32];
int1 local_80 [32];
puVar11 = PTR_ggml_table_f32_f16_0017cf60;
lVar19 = param_4 - param_3;
lVar12 = lVar19 + 3;
if (-1 < lVar19) {
lVar12 = lVar19;
}
lVar12 = lVar12 >> 2;
lVar22 = (param_2 - param_1) * lVar12;
lVar19 = (lVar22 + *(int *)(this + 0x3c) + -1) / (long)*(int *)(this + 0x3c);
lVar20 = *(int *)(this + 0x38) * lVar19;
lVar19 = lVar19 + lVar20;
if (lVar22 <= lVar19) {
lVar19 = lVar22;
}
if (lVar20 < lVar19) {
lVar22 = *(long *)(this + 0x18);
lVar2 = *(long *)this;
lVar3 = *(long *)(this + 8);
lVar4 = *(long *)(this + 0x28);
lVar5 = *(long *)(this + 0x20);
lVar6 = *(long *)(this + 0x10);
lVar7 = *(long *)(this + 0x30);
auVar26 = vxorps_avx512vl(in_ZMM0._0_16_,in_ZMM0._0_16_);
auVar30._2_2_ = DAT_001738fc;
auVar30._0_2_ = DAT_001738fc;
auVar30._4_2_ = DAT_001738fc;
auVar30._6_2_ = DAT_001738fc;
auVar30._8_2_ = DAT_001738fc;
auVar30._10_2_ = DAT_001738fc;
auVar30._12_2_ = DAT_001738fc;
auVar30._14_2_ = DAT_001738fc;
auVar30._16_2_ = DAT_001738fc;
auVar30._18_2_ = DAT_001738fc;
auVar30._20_2_ = DAT_001738fc;
auVar30._22_2_ = DAT_001738fc;
auVar30._24_2_ = DAT_001738fc;
auVar30._26_2_ = DAT_001738fc;
auVar30._28_2_ = DAT_001738fc;
auVar30._30_2_ = DAT_001738fc;
auVar31._4_4_ = DAT_00168d9c;
auVar31._0_4_ = DAT_00168d9c;
auVar31._8_4_ = DAT_00168d9c;
auVar31._12_4_ = DAT_00168d9c;
auVar31._16_4_ = DAT_00168d9c;
auVar31._20_4_ = DAT_00168d9c;
auVar31._24_4_ = DAT_00168d9c;
auVar31._28_4_ = DAT_00168d9c;
auVar32._4_4_ = DAT_00168da0;
auVar32._0_4_ = DAT_00168da0;
auVar32._8_4_ = DAT_00168da0;
auVar32._12_4_ = DAT_00168da0;
auVar32._16_4_ = DAT_00168da0;
auVar32._20_4_ = DAT_00168da0;
auVar32._24_4_ = DAT_00168da0;
auVar32._28_4_ = DAT_00168da0;
auVar33._4_4_ = DAT_00168d78;
auVar33._0_4_ = DAT_00168d78;
auVar33._8_4_ = DAT_00168d78;
auVar33._12_4_ = DAT_00168d78;
auVar33._16_4_ = DAT_00168d78;
auVar33._20_4_ = DAT_00168d78;
auVar33._24_4_ = DAT_00168d78;
auVar33._28_4_ = DAT_00168d78;
do {
lVar13 = lVar20 / lVar12 + param_1;
lVar16 = param_3 + (lVar20 % lVar12) * 4;
local_80 = ZEXT1632(auVar26);
local_a0 = local_80;
local_c0 = local_80;
auVar26 = ZEXT816(0) << 0x40;
if (0 < lVar22) {
lVar25 = (lVar16 + 3) * lVar4 * 0x22 + lVar3;
lVar15 = (lVar16 + 2) * lVar4 * 0x22 + lVar3;
lVar18 = (lVar16 + 1) * lVar4 * 0x22 + lVar3;
lVar24 = lVar4 * lVar16 * 0x22 + lVar3;
lVar21 = lVar5 * lVar13 * 0x22 + lVar2;
auVar34 = ZEXT816(0) << 0x40;
lVar17 = 2;
auVar29 = ZEXT816(0) << 0x40;
auVar28 = ZEXT816(0) << 0x40;
lVar23 = lVar22;
do {
auVar27 = vpinsrw_avx(ZEXT216(*(ushort *)(lVar24 + -2 + lVar17)),
(uint)*(ushort *)(lVar18 + -2 + lVar17),1);
auVar27 = vpinsrw_avx(auVar27,(uint)*(ushort *)(lVar15 + -2 + lVar17),2);
auVar27 = vpinsrw_avx(auVar27,(uint)*(ushort *)(lVar25 + -2 + lVar17),3);
auVar27 = vcvtph2ps_f16c(auVar27);
uVar35 = *(int4 *)(puVar11 + (ulong)*(ushort *)(lVar21 + -2 + lVar17) * 4);
auVar10._4_4_ = uVar35;
auVar10._0_4_ = uVar35;
auVar10._8_4_ = uVar35;
auVar10._12_4_ = uVar35;
auVar27 = vmulps_avx512vl(auVar27,auVar10);
uVar35 = auVar27._0_4_;
auVar37._4_4_ = uVar35;
auVar37._0_4_ = uVar35;
auVar37._8_4_ = uVar35;
auVar37._12_4_ = uVar35;
auVar37._16_4_ = uVar35;
auVar37._20_4_ = uVar35;
auVar37._24_4_ = uVar35;
auVar37._28_4_ = uVar35;
auVar1 = *(int1 (*) [32])(lVar21 + lVar17);
auVar8 = vpsignb_avx2(auVar1,auVar1);
auVar9 = vpsignb_avx2(*(int1 (*) [32])(lVar24 + lVar17),auVar1);
auVar9 = vpmaddubsw_avx2(auVar8,auVar9);
auVar9 = vpmaddwd_avx2(auVar9,auVar30);
auVar9 = vcvtdq2ps_avx(auVar9);
auVar26 = vfmadd231ps_fma(ZEXT1632(auVar26),auVar37,auVar9);
auVar36 = ZEXT1632(auVar27);
auVar37 = vpermps_avx2(auVar31,auVar36);
auVar9 = vpsignb_avx2(*(int1 (*) [32])(lVar18 + lVar17),auVar1);
auVar9 = vpmaddubsw_avx2(auVar8,auVar9);
auVar9 = vpmaddwd_avx2(auVar9,auVar30);
auVar9 = vcvtdq2ps_avx(auVar9);
auVar28 = vfmadd231ps_fma(ZEXT1632(auVar28),auVar37,auVar9);
auVar37 = vpermps_avx2(auVar32,auVar36);
auVar9 = vpsignb_avx2(*(int1 (*) [32])(lVar15 + lVar17),auVar1);
auVar9 = vpmaddubsw_avx2(auVar8,auVar9);
auVar9 = vpmaddwd_avx2(auVar9,auVar30);
auVar9 = vcvtdq2ps_avx(auVar9);
auVar29 = vfmadd231ps_fma(ZEXT1632(auVar29),auVar37,auVar9);
auVar9 = vpermps_avx2(auVar33,auVar36);
auVar1 = vpsignb_avx2(*(int1 (*) [32])(lVar25 + lVar17),auVar1);
auVar1 = vpmaddubsw_avx2(auVar8,auVar1);
auVar1 = vpmaddwd_avx2(auVar30,auVar1);
auVar1 = vcvtdq2ps_avx(auVar1);
auVar34 = vfmadd231ps_fma(ZEXT1632(auVar34),auVar9,auVar1);
lVar17 = lVar17 + 0x22;
lVar23 = lVar23 + -1;
} while (lVar23 != 0);
local_c0 = ZEXT1632(auVar28);
local_a0 = ZEXT1632(auVar29);
local_80 = ZEXT1632(auVar34);
}
_local_e0 = ZEXT1632(auVar26);
puVar14 = (int4 *)(lVar16 * lVar7 * 4 + lVar13 * 4 + lVar6);
lVar16 = 0;
do {
auVar28._0_4_ = *(float *)(local_e0 + lVar16 + 0x10) + *(float *)(local_e0 + lVar16);
auVar28._4_4_ = *(float *)(local_e0 + lVar16 + 0x14) + *(float *)(local_e0 + lVar16 + 4);
auVar28._8_4_ = *(float *)(local_e0 + lVar16 + 0x18) + *(float *)(local_e0 + lVar16 + 8);
auVar28._12_4_ = *(float *)(local_e0 + lVar16 + 0x1c) + *(float *)(local_e0 + lVar16 + 0xc);
auVar26 = vshufpd_avx(auVar28,auVar28,1);
auVar29._0_4_ = auVar28._0_4_ + auVar26._0_4_;
auVar29._4_4_ = auVar28._4_4_ + auVar26._4_4_;
auVar29._8_4_ = auVar28._8_4_ + auVar26._8_4_;
auVar29._12_4_ = auVar28._12_4_ + auVar26._12_4_;
auVar26 = vhaddps_avx(auVar29,auVar29);
*puVar14 = auVar26._0_4_;
lVar16 = lVar16 + 0x20;
puVar14 = puVar14 + lVar7;
} while (lVar16 != 0x80);
lVar20 = lVar20 + 1;
} while (lVar20 != lVar19);
}
return;
}
|
|
11,719 |
delete_dynamic_record
|
eloqsql/storage/maria/ma_dynrec.c
|
static my_bool delete_dynamic_record(MARIA_HA *info, MARIA_RECORD_POS filepos,
uint second_read)
{
uint length,b_type;
MARIA_BLOCK_INFO block_info,del_block;
int error;
my_bool remove_next_block;
DBUG_ENTER("delete_dynamic_record");
/* First add a link from the last block to the new one */
error= update_backward_delete_link(info, info->s->state.dellink, filepos);
block_info.second_read=second_read;
do
{
/* Remove block at 'filepos' */
if ((b_type= _ma_get_block_info(info, &block_info, info->dfile.file,
filepos))
& (BLOCK_DELETED | BLOCK_ERROR | BLOCK_SYNC_ERROR |
BLOCK_FATAL_ERROR) ||
(length=(uint) (block_info.filepos-filepos) +block_info.block_len) <
MARIA_MIN_BLOCK_LENGTH)
{
_ma_set_fatal_error(info, HA_ERR_WRONG_IN_RECORD);
DBUG_RETURN(1);
}
/* Check if next block is a delete block */
del_block.second_read=0;
remove_next_block=0;
if (_ma_get_block_info(info, &del_block, info->dfile.file,
filepos + length) &
BLOCK_DELETED && del_block.block_len+length <
MARIA_DYN_MAX_BLOCK_LENGTH)
{
/* We can't remove this yet as this block may be the head block */
remove_next_block=1;
length+=del_block.block_len;
}
block_info.header[0]=0;
mi_int3store(block_info.header+1,length);
mi_sizestore(block_info.header+4,info->s->state.dellink);
if (b_type & BLOCK_LAST)
bfill(block_info.header+12,8,255);
else
mi_sizestore(block_info.header+12,block_info.next_filepos);
if (info->s->file_write(info, block_info.header, 20, filepos,
MYF(MY_NABP)))
DBUG_RETURN(1);
info->s->state.dellink = filepos;
info->state->del++;
info->state->empty+=length;
filepos=block_info.next_filepos;
/* Now it's safe to unlink the deleted block directly after this one */
if (remove_next_block && unlink_deleted_block(info,&del_block))
error=1;
} while (!(b_type & BLOCK_LAST));
DBUG_RETURN(error);
}
|
O3
|
c
|
delete_dynamic_record:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movl %edx, %r13d
movq %rsi, %r15
movq %rdi, %r12
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq (%rdi), %rax
movq 0xc8(%rax), %rsi
movq %r15, %rdx
callq 0x4978f
movl %eax, -0xe4(%rbp)
leaq -0x88(%rbp), %rax
movl %r13d, 0x50(%rax)
movl 0x480(%r12), %edx
movq %r12, %rdi
leaq -0x88(%rbp), %rsi
movq %r15, %rcx
callq 0x49240
cmpl $0x3, %eax
ja 0x48afd
movq -0x50(%rbp), %rbx
subq %r15, %rbx
addq -0x60(%rbp), %rbx
cmpl $0x13, %ebx
jbe 0x48afd
movl %eax, %r13d
movl $0x0, -0x90(%rbp)
movl 0x480(%r12), %edx
movq %r15, %rax
movl %ebx, %r15d
movq %rax, -0xf0(%rbp)
leaq (%r15,%rax), %rcx
movq %r12, %rdi
leaq -0xe0(%rbp), %rsi
callq 0x49240
testb $0x4, %al
sete %al
addq -0xb8(%rbp), %r15
cmpq $0xfffffc, %r15 # imm = 0xFFFFFC
setae %r14b
orb %al, %r14b
jne 0x48a29
movq %r15, %rbx
movb $0x0, -0x88(%rbp)
movb %bl, -0x85(%rbp)
movb %bh, -0x86(%rbp)
movl %ebx, %eax
shrl $0x10, %eax
movb %al, -0x87(%rbp)
movq (%r12), %rax
movq 0xc8(%rax), %rcx
bswapq %rcx
movq %rcx, -0x84(%rbp)
cmpl $0x2, %r13d
jae 0x48a6f
movq -0x48(%rbp), %rcx
bswapq %rcx
movq %rcx, -0x7c(%rbp)
jmp 0x48a77
movq $-0x1, -0x7c(%rbp)
movq -0xf0(%rbp), %r15
movl $0x14, %edx
movl $0x4, %r8d
movq %r12, %rdi
leaq -0x88(%rbp), %rsi
movq %r15, %rcx
callq *0x6e8(%rax)
testq %rax, %rax
jne 0x48b0a
movl %ebx, %eax
movq (%r12), %rcx
movq %r15, 0xc8(%rcx)
movq 0x20(%r12), %rcx
incq 0x8(%rcx)
movq 0x20(%r12), %rcx
addq %rax, 0x10(%rcx)
movq -0x48(%rbp), %r15
testb %r14b, %r14b
jne 0x48af1
movq %r12, %rdi
leaq -0xe0(%rbp), %rsi
callq 0x4964f
testb %al, %al
movl -0xe4(%rbp), %eax
movzbl %al, %eax
movl $0x1, %ecx
cmovnel %ecx, %eax
movl %eax, -0xe4(%rbp)
cmpl $0x2, %r13d
jb 0x4899e
jmp 0x48b12
movq %r12, %rdi
movl $0x7f, %esi
callq 0x3c86c
movb $0x1, %al
movl %eax, -0xe4(%rbp)
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x48b39
movl -0xe4(%rbp), %eax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2a250
|
delete_dynamic_record:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0C8h
mov r13d, edx
mov r15, rsi
mov r12, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov rax, [rdi]
mov rsi, [rax+0C8h]
mov rdx, r15
call update_backward_delete_link
mov [rbp+var_E4], eax
lea rax, [rbp+var_88]
mov [rax+50h], r13d
loc_4899E:
mov edx, [r12+480h]
mov rdi, r12
lea rsi, [rbp+var_88]
mov rcx, r15
call _ma_get_block_info
cmp eax, 3
ja loc_48AFD
mov rbx, [rbp+var_50]
sub rbx, r15
add rbx, [rbp+var_60]
cmp ebx, 13h
jbe loc_48AFD
mov r13d, eax
mov [rbp+var_90], 0
mov edx, [r12+480h]
mov rax, r15
mov r15d, ebx
mov [rbp+var_F0], rax
lea rcx, [r15+rax]
mov rdi, r12
lea rsi, [rbp+var_E0]
call _ma_get_block_info
test al, 4
setz al
add r15, [rbp+var_B8]
cmp r15, 0FFFFFCh
setnb r14b
or r14b, al
jnz short loc_48A29
mov rbx, r15
loc_48A29:
mov [rbp+var_88], 0
mov [rbp+var_85], bl
mov [rbp+var_86], bh
mov eax, ebx
shr eax, 10h
mov [rbp+var_87], al
mov rax, [r12]
mov rcx, [rax+0C8h]
bswap rcx
mov [rbp+var_84], rcx
cmp r13d, 2
jnb short loc_48A6F
mov rcx, [rbp+var_48]
bswap rcx
mov [rbp+var_7C], rcx
jmp short loc_48A77
loc_48A6F:
mov [rbp+var_7C], 0FFFFFFFFFFFFFFFFh
loc_48A77:
mov r15, [rbp+var_F0]
mov edx, 14h
mov r8d, 4
mov rdi, r12
lea rsi, [rbp+var_88]
mov rcx, r15
call qword ptr [rax+6E8h]
test rax, rax
jnz short loc_48B0A
mov eax, ebx
mov rcx, [r12]
mov [rcx+0C8h], r15
mov rcx, [r12+20h]
inc qword ptr [rcx+8]
mov rcx, [r12+20h]
add [rcx+10h], rax
mov r15, [rbp+var_48]
test r14b, r14b
jnz short loc_48AF1
mov rdi, r12
lea rsi, [rbp+var_E0]
call unlink_deleted_block
test al, al
mov eax, [rbp+var_E4]
movzx eax, al
mov ecx, 1
cmovnz eax, ecx
mov [rbp+var_E4], eax
loc_48AF1:
cmp r13d, 2
jb loc_4899E
jmp short loc_48B12
loc_48AFD:
mov rdi, r12
mov esi, 7Fh
call _ma_set_fatal_error
loc_48B0A:
mov al, 1
mov [rbp+var_E4], eax
loc_48B12:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_48B39
mov eax, [rbp+var_E4]
add rsp, 0C8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_48B39:
call ___stack_chk_fail
|
long long delete_dynamic_record(unsigned int *a1, unsigned long long a2, int a3)
{
unsigned long long v4; // r15
unsigned int block_info; // eax
long long v6; // rdx
long long v7; // rcx
long long v8; // r8
int v9; // r9d
unsigned int v10; // ebx
unsigned int v11; // r13d
char v12; // al
bool v13; // r14
long long v14; // rax
int *v15; // rax
bool v16; // zf
int v17; // eax
unsigned int v19; // [rsp+Ch] [rbp-E4h]
_BYTE v20[40]; // [rsp+10h] [rbp-E0h] BYREF
long long v21; // [rsp+38h] [rbp-B8h]
int v22; // [rsp+60h] [rbp-90h]
_BYTE v23[4]; // [rsp+68h] [rbp-88h] BYREF
unsigned long long v24; // [rsp+6Ch] [rbp-84h]
unsigned long long v25; // [rsp+74h] [rbp-7Ch]
long long v26; // [rsp+90h] [rbp-60h]
long long v27; // [rsp+A0h] [rbp-50h]
unsigned long long v28; // [rsp+A8h] [rbp-48h]
int v29; // [rsp+B8h] [rbp-38h]
unsigned long long v30; // [rsp+C0h] [rbp-30h]
v4 = a2;
v30 = __readfsqword(0x28u);
v19 = update_backward_delete_link(a1, *(_QWORD *)(*(_QWORD *)a1 + 200LL), a2);
v29 = a3;
while ( 1 )
{
block_info = ma_get_block_info(a1, v23, a1[288], v4);
if ( block_info > 3 )
break;
v10 = v26 + v27 - v4;
if ( v10 <= 0x13 )
break;
v11 = block_info;
v22 = 0;
v12 = ma_get_block_info(a1, v20, a1[288], v10 + v4);
v13 = (v12 & 4) == 0 || v21 + (unsigned long long)v10 >= 0xFFFFFC;
if ( !v13 )
v10 += v21;
v23[0] = 0;
v23[2] = BYTE1(v10);
v23[3] = v10;
v23[1] = BYTE2(v10);
v14 = *(_QWORD *)a1;
v24 = _byteswap_uint64(*(_QWORD *)(*(_QWORD *)a1 + 200LL));
if ( v11 >= 2 )
v25 = -1LL;
else
v25 = _byteswap_uint64(v28);
v15 = (int *)(*(long long ( **)(unsigned int *, _BYTE *, long long, unsigned long long, long long))(v14 + 1768))(
a1,
v23,
20LL,
v4,
4LL);
if ( v15 )
goto LABEL_17;
*(_QWORD *)(*(_QWORD *)a1 + 200LL) = v4;
++*(_QWORD *)(*((_QWORD *)a1 + 4) + 8LL);
*(_QWORD *)(*((_QWORD *)a1 + 4) + 16LL) += v10;
v4 = v28;
if ( !v13 )
{
v16 = (unsigned __int8)unlink_deleted_block(a1, v20) == 0;
v17 = (unsigned __int8)v19;
if ( !v16 )
v17 = 1;
v19 = v17;
}
if ( v11 >= 2 )
return v19;
}
v15 = ma_set_fatal_error(a1, 127, v6, v7, v8, v9);
LABEL_17:
LOBYTE(v15) = 1;
return (unsigned int)v15;
}
|
delete_dynamic_record:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xc8
MOV R13D,EDX
MOV R15,RSI
MOV R12,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RDI]
MOV RSI,qword ptr [RAX + 0xc8]
MOV RDX,R15
CALL 0x0014978f
MOV dword ptr [RBP + -0xe4],EAX
LEA RAX,[RBP + -0x88]
MOV dword ptr [RAX + 0x50],R13D
LAB_0014899e:
MOV EDX,dword ptr [R12 + 0x480]
MOV RDI,R12
LEA RSI,[RBP + -0x88]
MOV RCX,R15
CALL 0x00149240
CMP EAX,0x3
JA 0x00148afd
MOV RBX,qword ptr [RBP + -0x50]
SUB RBX,R15
ADD RBX,qword ptr [RBP + -0x60]
CMP EBX,0x13
JBE 0x00148afd
MOV R13D,EAX
MOV dword ptr [RBP + -0x90],0x0
MOV EDX,dword ptr [R12 + 0x480]
MOV RAX,R15
MOV R15D,EBX
MOV qword ptr [RBP + -0xf0],RAX
LEA RCX,[R15 + RAX*0x1]
MOV RDI,R12
LEA RSI,[RBP + -0xe0]
CALL 0x00149240
TEST AL,0x4
SETZ AL
ADD R15,qword ptr [RBP + -0xb8]
CMP R15,0xfffffc
SETNC R14B
OR R14B,AL
JNZ 0x00148a29
MOV RBX,R15
LAB_00148a29:
MOV byte ptr [RBP + -0x88],0x0
MOV byte ptr [RBP + -0x85],BL
MOV byte ptr [RBP + -0x86],BH
MOV EAX,EBX
SHR EAX,0x10
MOV byte ptr [RBP + -0x87],AL
MOV RAX,qword ptr [R12]
MOV RCX,qword ptr [RAX + 0xc8]
BSWAP RCX
MOV qword ptr [RBP + -0x84],RCX
CMP R13D,0x2
JNC 0x00148a6f
MOV RCX,qword ptr [RBP + -0x48]
BSWAP RCX
MOV qword ptr [RBP + -0x7c],RCX
JMP 0x00148a77
LAB_00148a6f:
MOV qword ptr [RBP + -0x7c],-0x1
LAB_00148a77:
MOV R15,qword ptr [RBP + -0xf0]
MOV EDX,0x14
MOV R8D,0x4
MOV RDI,R12
LEA RSI,[RBP + -0x88]
MOV RCX,R15
CALL qword ptr [RAX + 0x6e8]
TEST RAX,RAX
JNZ 0x00148b0a
MOV EAX,EBX
MOV RCX,qword ptr [R12]
MOV qword ptr [RCX + 0xc8],R15
MOV RCX,qword ptr [R12 + 0x20]
INC qword ptr [RCX + 0x8]
MOV RCX,qword ptr [R12 + 0x20]
ADD qword ptr [RCX + 0x10],RAX
MOV R15,qword ptr [RBP + -0x48]
TEST R14B,R14B
JNZ 0x00148af1
MOV RDI,R12
LEA RSI,[RBP + -0xe0]
CALL 0x0014964f
TEST AL,AL
MOV EAX,dword ptr [RBP + -0xe4]
MOVZX EAX,AL
MOV ECX,0x1
CMOVNZ EAX,ECX
MOV dword ptr [RBP + -0xe4],EAX
LAB_00148af1:
CMP R13D,0x2
JC 0x0014899e
JMP 0x00148b12
LAB_00148afd:
MOV RDI,R12
MOV ESI,0x7f
CALL 0x0013c86c
LAB_00148b0a:
MOV AL,0x1
MOV dword ptr [RBP + -0xe4],EAX
LAB_00148b12:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00148b39
MOV EAX,dword ptr [RBP + -0xe4]
ADD RSP,0xc8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00148b39:
CALL 0x0012a250
|
uint delete_dynamic_record(long *param_1,ulong param_2,int4 param_3)
{
ulong uVar1;
char cVar2;
uint uVar3;
ulong uVar4;
long lVar5;
ulong uVar6;
long in_FS_OFFSET;
bool bVar7;
uint local_ec;
int1 local_e8 [40];
long local_c0;
int4 local_98;
int1 local_90;
int1 local_8f;
int1 local_8e;
int1 local_8d;
ulong local_8c;
ulong local_84;
long local_68;
long local_58;
ulong local_50;
int4 local_40;
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
local_ec = update_backward_delete_link(param_1,*(int8 *)(*param_1 + 200),param_2);
local_40 = param_3;
do {
uVar3 = _ma_get_block_info(param_1,&local_90,(int)param_1[0x90],param_2);
if ((3 < uVar3) || (uVar6 = (local_58 - param_2) + local_68, (uint)uVar6 < 0x14)) {
lVar5 = _ma_set_fatal_error(param_1,0x7f);
LAB_00148b0a:
local_ec = (uint)CONCAT71((int7)((ulong)lVar5 >> 8),1);
break;
}
local_98 = 0;
uVar4 = _ma_get_block_info(param_1,local_e8,(int)param_1[0x90],(uVar6 & 0xffffffff) + param_2);
bVar7 = (uVar4 & 4) != 0;
uVar4 = (uVar6 & 0xffffffff) + local_c0;
if (uVar4 < 0xfffffc && bVar7) {
uVar6 = uVar4;
}
local_90 = 0;
local_8d = (int1)uVar6;
local_8e = (int1)(uVar6 >> 8);
local_8f = (int1)(uVar6 >> 0x10);
uVar1 = *(ulong *)(*param_1 + 200);
local_8c = uVar1 >> 0x38 | (uVar1 & 0xff000000000000) >> 0x28 | (uVar1 & 0xff0000000000) >> 0x18
| (uVar1 & 0xff00000000) >> 8 | (uVar1 & 0xff000000) << 8 |
(uVar1 & 0xff0000) << 0x18 | (uVar1 & 0xff00) << 0x28 | uVar1 << 0x38;
if (uVar3 < 2) {
local_84 = local_50 >> 0x38 | (local_50 & 0xff000000000000) >> 0x28 |
(local_50 & 0xff0000000000) >> 0x18 | (local_50 & 0xff00000000) >> 8 |
(local_50 & 0xff000000) << 8 | (local_50 & 0xff0000) << 0x18 |
(local_50 & 0xff00) << 0x28 | local_50 << 0x38;
}
else {
local_84 = 0xffffffffffffffff;
}
lVar5 = (**(code **)(*param_1 + 0x6e8))(param_1,&local_90,0x14,param_2,4);
uVar1 = local_50;
if (lVar5 != 0) goto LAB_00148b0a;
*(ulong *)(*param_1 + 200) = param_2;
*(long *)(param_1[4] + 8) = *(long *)(param_1[4] + 8) + 1;
*(long *)(param_1[4] + 0x10) = *(long *)(param_1[4] + 0x10) + (uVar6 & 0xffffffff);
if (uVar4 < 0xfffffc && bVar7) {
cVar2 = unlink_deleted_block(param_1,local_e8);
local_ec = local_ec & 0xff;
if (cVar2 != '\0') {
local_ec = 1;
}
}
param_2 = uVar1;
} while (uVar3 < 2);
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_ec;
}
|
|
11,720 |
yoyo::Logger::logConf::logConf()
|
isyoCode[P]yoyologger/test/./../src/logger.hpp
|
logConf()
: _fileMaxSize(1024 * 1024 * 128),
_fileNum(10),
_isConsle(true),
_isColor(true),
_isWritefile(true),
_isRotate(false),
_logDirName("log"),
_isStop(false),
_logPrefixPath("."),
_logFileName("app") {}
|
O3
|
cpp
|
yoyo::Logger::logConf::logConf():
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
movl $0x1010100, (%rdi) # imm = 0x1010100
movb $0x0, 0x4(%rdi)
movq $0x8000000, 0x8(%rdi) # imm = 0x8000000
movq $0xa, 0x10(%rdi)
leaq 0x18(%rdi), %rbx
leaq 0x28(%rdi), %r12
movq %r12, 0x18(%rdi)
leaq 0x2da0(%rip), %rsi # 0x72a5
leaq 0x2d9c(%rip), %rdx # 0x72a8
movq %rbx, %rdi
callq 0x3f48
leaq 0x38(%r14), %r15
leaq 0x48(%r14), %r13
movq %r13, 0x38(%r14)
leaq 0x2d77(%rip), %rsi # 0x729e
leaq 0x2d71(%rip), %rdx # 0x729f
movq %r15, %rdi
callq 0x3f48
leaq 0x58(%r14), %rdi
leaq 0x68(%r14), %rax
movq %rax, 0x58(%r14)
leaq 0x2d57(%rip), %rsi # 0x72a0
leaq 0x2d53(%rip), %rdx # 0x72a3
callq 0x3f48
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x457b
movq (%r13), %rsi
incq %rsi
callq 0x32e0
jmp 0x457b
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x458f
movq (%r12), %rsi
incq %rsi
callq 0x32e0
movq %r14, %rdi
callq 0x3420
nop
|
_ZN4yoyo6Logger7logConfC2Ev:
push r15
push r14
push r13
push r12
push rbx
mov r14, rdi
mov dword ptr [rdi], 1010100h
mov byte ptr [rdi+4], 0
mov qword ptr [rdi+8], 8000000h
mov qword ptr [rdi+10h], 0Ah
lea rbx, [rdi+18h]
lea r12, [rdi+28h]
mov [rdi+18h], r12
lea rsi, aLog+1; "log"
lea rdx, aLog+4; ""
mov rdi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea r15, [r14+38h]
lea r13, [r14+48h]
mov [r14+38h], r13
lea rsi, asc_729E; "."
lea rdx, asc_729E+1; ""
mov rdi, r15
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rdi, [r14+58h]
lea rax, [r14+68h]
mov [r14+58h], rax
lea rsi, aApp; "app"
lea rdx, aApp+3; ""
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
mov r14, rax
mov rdi, [r15]; void *
cmp rdi, r13
jz short loc_457B
mov rsi, [r13+0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_457B
mov r14, rax
loc_457B:
mov rdi, [rbx]; void *
cmp rdi, r12
jz short loc_458F
mov rsi, [r12]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_458F:
mov rdi, r14
call __Unwind_Resume
|
long long yoyo::Logger::logConf::logConf(yoyo::Logger::logConf *this)
{
*(_DWORD *)this = 16843008;
*((_BYTE *)this + 4) = 0;
*((_QWORD *)this + 1) = 0x8000000LL;
*((_QWORD *)this + 2) = 10LL;
*((_QWORD *)this + 3) = (char *)this + 40;
std::string::_M_construct<char const*>((long long)this + 24, "log", (long long)"");
*((_QWORD *)this + 7) = (char *)this + 72;
std::string::_M_construct<char const*>((long long)this + 56, ".", (long long)"");
*((_QWORD *)this + 11) = (char *)this + 104;
return std::string::_M_construct<char const*>((long long)this + 88, "app", (long long)"");
}
|
logConf:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV R14,RDI
MOV dword ptr [RDI],0x1010100
MOV byte ptr [RDI + 0x4],0x0
MOV qword ptr [RDI + 0x8],0x8000000
MOV qword ptr [RDI + 0x10],0xa
LEA RBX,[RDI + 0x18]
LEA R12,[RDI + 0x28]
MOV qword ptr [RDI + 0x18],R12
LEA RSI,[0x1072a5]
LEA RDX,[0x1072a8]
MOV RDI,RBX
CALL 0x00103f48
LEA R15,[R14 + 0x38]
LEA R13,[R14 + 0x48]
MOV qword ptr [R14 + 0x38],R13
LAB_00104520:
LEA RSI,[0x10729e]
LEA RDX,[0x10729f]
MOV RDI,R15
CALL 0x00103f48
LEA RDI,[R14 + 0x58]
LEA RAX,[R14 + 0x68]
MOV qword ptr [R14 + 0x58],RAX
LAB_00104542:
LEA RSI,[0x1072a0]
LEA RDX,[0x1072a3]
CALL 0x00103f48
LAB_00104555:
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* yoyo::Logger::logConf::logConf() */
void __thiscall yoyo::Logger::logConf::logConf(logConf *this)
{
*(int4 *)this = 0x1010100;
this[4] = (logConf)0x0;
*(int8 *)(this + 8) = 0x8000000;
*(int8 *)(this + 0x10) = 10;
*(logConf **)(this + 0x18) = this + 0x28;
std::__cxx11::string::_M_construct<char_const*>(this + 0x18,&DAT_001072a5,&DAT_001072a8);
*(logConf **)(this + 0x38) = this + 0x48;
/* try { // try from 00104520 to 00104535 has its CatchHandler @ 00104578 */
std::__cxx11::string::_M_construct<char_const*>(this + 0x38,&DAT_0010729e,&DAT_0010729f);
*(logConf **)(this + 0x58) = this + 0x68;
/* try { // try from 00104542 to 00104554 has its CatchHandler @ 0010455f */
std::__cxx11::string::_M_construct<char_const*>(this + 0x58,&DAT_001072a0,&DAT_001072a3);
return;
}
|
|
11,721 |
translog_set_lsn_for_files
|
eloqsql/storage/maria/ma_loghandler.c
|
static my_bool translog_set_lsn_for_files(uint32 from_file, uint32 to_file,
LSN lsn, my_bool is_locked)
{
uint32 file;
DBUG_ENTER("translog_set_lsn_for_files");
DBUG_PRINT("enter", ("From: %lu to: %lu lsn: " LSN_FMT " locked: %d",
(ulong) from_file, (ulong) to_file,
LSN_IN_PARTS(lsn),
is_locked));
DBUG_ASSERT(from_file <= to_file);
DBUG_ASSERT(from_file > 0); /* we have not file 0 */
/* Checks the current file (not finished yet file) */
if (!is_locked)
translog_lock();
if (to_file == (uint32) LSN_FILE_NO(log_descriptor.horizon))
{
if (likely(cmp_translog_addr(lsn, log_descriptor.max_lsn) > 0))
log_descriptor.max_lsn= lsn;
to_file--;
}
if (!is_locked)
translog_unlock();
/* Checks finished files if they are */
mysql_mutex_lock(&log_descriptor.file_header_lock);
for (file= from_file; file <= to_file; file++)
{
LOGHANDLER_FILE_INFO info;
File fd;
fd= open_logfile_by_number_no_cache(file);
if ((fd < 0) ||
((translog_read_file_header(&info, fd) ||
(cmp_translog_addr(lsn, info.max_lsn) > 0 &&
translog_max_lsn_to_header(fd, lsn))) |
mysql_file_close(fd, MYF(MY_WME))))
{
translog_stop_writing();
mysql_mutex_unlock(&log_descriptor.file_header_lock);
DBUG_RETURN(1);
}
}
mysql_mutex_unlock(&log_descriptor.file_header_lock);
DBUG_RETURN(0);
}
|
O0
|
c
|
translog_set_lsn_for_files:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %cl, %al
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
jmp 0x5ade9
jmp 0x5adeb
jmp 0x5aded
jmp 0x5adef
jmp 0x5adf1
cmpb $0x0, -0x19(%rbp)
jne 0x5adfc
callq 0x4faa0
movl -0xc(%rbp), %eax
movq 0xc1e202(%rip), %rcx # 0xc79008
sarq $0x20, %rcx
cmpl %ecx, %eax
jne 0x5ae4c
movq -0x18(%rbp), %rax
subq 0xc1e237(%rip), %rax # 0xc79050
cmpq $0x0, %rax
setg %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x5ae43
movq -0x18(%rbp), %rax
movq %rax, 0xc1e20d(%rip) # 0xc79050
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
cmpb $0x0, -0x19(%rbp)
jne 0x5ae57
callq 0x4fb90
leaq 0x41d562(%rip), %rdi # 0x4783c0
addq $0x800dc0, %rdi # imm = 0x800DC0
leaq 0xf5cec(%rip), %rsi # 0x150b58
movl $0x519, %edx # imm = 0x519
callq 0x4f6d0
movl -0x8(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
ja 0x5af41
movl -0x20(%rbp), %edi
callq 0x4f7a0
movl %eax, -0x5c(%rbp)
cmpl $0x0, -0x5c(%rbp)
jl 0x5af13
movl -0x5c(%rbp), %esi
leaq -0x58(%rbp), %rdi
callq 0x4f3a0
movsbl %al, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x5d(%rbp)
jne 0x5aee3
movq -0x18(%rbp), %rcx
subq -0x58(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x5e(%rbp)
jle 0x5aedd
movl -0x5c(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x590c0
movsbl %al, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x5e(%rbp)
movb -0x5e(%rbp), %al
movb %al, -0x5d(%rbp)
movb -0x5d(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x64(%rbp)
movl -0x5c(%rbp), %edx
leaq 0xf5c60(%rip), %rdi # 0x150b58
movl $0x524, %esi # imm = 0x524
movl $0x10, %ecx
callq 0x4f870
movl %eax, %ecx
movl -0x64(%rbp), %eax
orl %ecx, %eax
cmpl $0x0, %eax
je 0x5af31
callq 0x4f190
leaq 0x41d4a1(%rip), %rdi # 0x4783c0
addq $0x800dc0, %rdi # imm = 0x800DC0
callq 0x4f740
movb $0x1, -0x1(%rbp)
jmp 0x5af58
jmp 0x5af33
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x5ae7c
leaq 0x41d478(%rip), %rdi # 0x4783c0
addq $0x800dc0, %rdi # imm = 0x800DC0
callq 0x4f740
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
translog_set_lsn_for_files:
push rbp
mov rbp, rsp
sub rsp, 70h
mov al, cl
mov [rbp+var_8], edi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov [rbp+var_19], al
jmp short $+2
loc_5ADE9:
jmp short $+2
loc_5ADEB:
jmp short $+2
loc_5ADED:
jmp short $+2
loc_5ADEF:
jmp short $+2
loc_5ADF1:
cmp [rbp+var_19], 0
jnz short loc_5ADFC
call translog_lock
loc_5ADFC:
mov eax, [rbp+var_C]
mov rcx, cs:qword_C79008
sar rcx, 20h
cmp eax, ecx
jnz short loc_5AE4C
mov rax, [rbp+var_18]
sub rax, cs:qword_C79050
cmp rax, 0
setnle 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_5AE43
mov rax, [rbp+var_18]
mov cs:qword_C79050, rax
loc_5AE43:
mov eax, [rbp+var_C]
add eax, 0FFFFFFFFh
mov [rbp+var_C], eax
loc_5AE4C:
cmp [rbp+var_19], 0
jnz short loc_5AE57
call translog_unlock
loc_5AE57:
lea rdi, log_descriptor
add rdi, 800DC0h
lea rsi, aWorkspaceLlm4b_11; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 519h
call inline_mysql_mutex_lock_8
mov eax, [rbp+var_8]
mov [rbp+var_20], eax
loc_5AE7C:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_C]
ja loc_5AF41
mov edi, [rbp+var_20]
call open_logfile_by_number_no_cache
mov [rbp+var_5C], eax
cmp [rbp+var_5C], 0
jl short loc_5AF13
mov esi, [rbp+var_5C]
lea rdi, [rbp+var_58]
call translog_read_file_header
movsx ecx, al
mov al, 1
cmp ecx, 0
mov [rbp+var_5D], al
jnz short loc_5AEE3
mov rcx, [rbp+var_18]
sub rcx, [rbp+var_58]
xor eax, eax
cmp rcx, 0
mov [rbp+var_5E], al
jle short loc_5AEDD
mov edi, [rbp+var_5C]
mov rsi, [rbp+var_18]
call translog_max_lsn_to_header
movsx eax, al
cmp eax, 0
setnz al
mov [rbp+var_5E], al
loc_5AEDD:
mov al, [rbp+var_5E]
mov [rbp+var_5D], al
loc_5AEE3:
mov al, [rbp+var_5D]
and al, 1
movzx eax, al
mov [rbp+var_64], eax
mov edx, [rbp+var_5C]
lea rdi, aWorkspaceLlm4b_11; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 524h
mov ecx, 10h
call inline_mysql_file_close_2
mov ecx, eax
mov eax, [rbp+var_64]
or eax, ecx
cmp eax, 0
jz short loc_5AF31
loc_5AF13:
call translog_stop_writing
lea rdi, log_descriptor
add rdi, 800DC0h
call inline_mysql_mutex_unlock_8
mov [rbp+var_1], 1
jmp short loc_5AF58
loc_5AF31:
jmp short $+2
loc_5AF33:
mov eax, [rbp+var_20]
add eax, 1
mov [rbp+var_20], eax
jmp loc_5AE7C
loc_5AF41:
lea rdi, log_descriptor
add rdi, 800DC0h
call inline_mysql_mutex_unlock_8
mov [rbp+var_1], 0
loc_5AF58:
mov al, [rbp+var_1]
add rsp, 70h
pop rbp
retn
|
char translog_set_lsn_for_files(unsigned int a1, unsigned int a2, long long a3, char a4)
{
const char *v4; // rsi
long long v5; // rdx
long long v6; // rcx
int v7; // r8d
int v8; // r9d
unsigned int v9; // eax
bool v11; // [rsp+12h] [rbp-5Eh]
char v12; // [rsp+13h] [rbp-5Dh]
int v13; // [rsp+14h] [rbp-5Ch]
unsigned long long v14[7]; // [rsp+18h] [rbp-58h] BYREF
unsigned int i; // [rsp+50h] [rbp-20h]
char v16; // [rsp+57h] [rbp-19h]
long long v17; // [rsp+58h] [rbp-18h]
unsigned int v18; // [rsp+64h] [rbp-Ch]
unsigned int v19; // [rsp+68h] [rbp-8h]
v19 = a1;
v18 = a2;
v17 = a3;
v16 = a4;
if ( !a4 )
translog_lock();
if ( v18 == HIDWORD(qword_C79008) )
{
if ( v17 - qword_C79050 > 0 )
qword_C79050 = v17;
--v18;
}
if ( !v16 )
translog_unlock();
v4 = "/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c";
inline_mysql_mutex_lock_8(
(long long)&log_descriptor[1049016],
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
0x519u);
for ( i = v19; i <= v18; ++i )
{
v13 = open_logfile_by_number_no_cache(i, (long long)v4, v5, v6, v7, v8);
if ( v13 < 0 )
goto LABEL_17;
v12 = 1;
if ( !translog_read_file_header(v14, v13) )
{
v11 = 0;
if ( (signed long long)(v17 - v14[0]) > 0 )
v11 = translog_max_lsn_to_header(v13, v17);
v12 = v11;
}
v4 = (_BYTE *)(&stru_520 + 4);
v9 = inline_mysql_file_close_2(
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
0x524u,
v13,
16LL);
v6 = v9;
if ( v9 | v12 & 1 )
{
LABEL_17:
translog_stop_writing();
inline_mysql_mutex_unlock_8((long long)&log_descriptor[1049016]);
return 1;
}
}
inline_mysql_mutex_unlock_8((long long)&log_descriptor[1049016]);
return 0;
}
|
translog_set_lsn_for_files:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV AL,CL
MOV dword ptr [RBP + -0x8],EDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV byte ptr [RBP + -0x19],AL
JMP 0x0015ade9
LAB_0015ade9:
JMP 0x0015adeb
LAB_0015adeb:
JMP 0x0015aded
LAB_0015aded:
JMP 0x0015adef
LAB_0015adef:
JMP 0x0015adf1
LAB_0015adf1:
CMP byte ptr [RBP + -0x19],0x0
JNZ 0x0015adfc
CALL 0x0014faa0
LAB_0015adfc:
MOV EAX,dword ptr [RBP + -0xc]
MOV RCX,qword ptr [0x00d79008]
SAR RCX,0x20
CMP EAX,ECX
JNZ 0x0015ae4c
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr [0x00d79050]
CMP RAX,0x0
SETG AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x0015ae43
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [0x00d79050],RAX
LAB_0015ae43:
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,-0x1
MOV dword ptr [RBP + -0xc],EAX
LAB_0015ae4c:
CMP byte ptr [RBP + -0x19],0x0
JNZ 0x0015ae57
CALL 0x0014fb90
LAB_0015ae57:
LEA RDI,[0x5783c0]
ADD RDI,0x800dc0
LEA RSI,[0x250b58]
MOV EDX,0x519
CALL 0x0014f6d0
MOV EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0x20],EAX
LAB_0015ae7c:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0xc]
JA 0x0015af41
MOV EDI,dword ptr [RBP + -0x20]
CALL 0x0014f7a0
MOV dword ptr [RBP + -0x5c],EAX
CMP dword ptr [RBP + -0x5c],0x0
JL 0x0015af13
MOV ESI,dword ptr [RBP + -0x5c]
LEA RDI,[RBP + -0x58]
CALL 0x0014f3a0
MOVSX ECX,AL
MOV AL,0x1
CMP ECX,0x0
MOV byte ptr [RBP + -0x5d],AL
JNZ 0x0015aee3
MOV RCX,qword ptr [RBP + -0x18]
SUB RCX,qword ptr [RBP + -0x58]
XOR EAX,EAX
CMP RCX,0x0
MOV byte ptr [RBP + -0x5e],AL
JLE 0x0015aedd
MOV EDI,dword ptr [RBP + -0x5c]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x001590c0
MOVSX EAX,AL
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0x5e],AL
LAB_0015aedd:
MOV AL,byte ptr [RBP + -0x5e]
MOV byte ptr [RBP + -0x5d],AL
LAB_0015aee3:
MOV AL,byte ptr [RBP + -0x5d]
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RBP + -0x64],EAX
MOV EDX,dword ptr [RBP + -0x5c]
LEA RDI,[0x250b58]
MOV ESI,0x524
MOV ECX,0x10
CALL 0x0014f870
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x64]
OR EAX,ECX
CMP EAX,0x0
JZ 0x0015af31
LAB_0015af13:
CALL 0x0014f190
LEA RDI,[0x5783c0]
ADD RDI,0x800dc0
CALL 0x0014f740
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0015af58
LAB_0015af31:
JMP 0x0015af33
LAB_0015af33:
MOV EAX,dword ptr [RBP + -0x20]
ADD EAX,0x1
MOV dword ptr [RBP + -0x20],EAX
JMP 0x0015ae7c
LAB_0015af41:
LEA RDI,[0x5783c0]
ADD RDI,0x800dc0
CALL 0x0014f740
MOV byte ptr [RBP + -0x1],0x0
LAB_0015af58:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x70
POP RBP
RET
|
int1 translog_set_lsn_for_files(uint param_1,uint param_2,long param_3,char param_4)
{
char cVar1;
int iVar2;
bool bVar3;
long local_60 [7];
uint local_28;
char local_21;
long local_20;
uint local_14;
uint local_10;
local_21 = param_4;
local_20 = param_3;
local_14 = param_2;
local_10 = param_1;
if (param_4 == '\0') {
translog_lock();
}
if (local_14 == (uint)((ulong)DAT_00d79008 >> 0x20)) {
if (0 < local_20 - DAT_00d79050) {
DAT_00d79050 = local_20;
}
local_14 = local_14 - 1;
}
if (local_21 == '\0') {
translog_unlock();
}
inline_mysql_mutex_lock
(&DAT_00d79180,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
0x519);
local_28 = local_10;
while( true ) {
if (local_14 < local_28) {
inline_mysql_mutex_unlock(&DAT_00d79180);
return 0;
}
iVar2 = open_logfile_by_number_no_cache(local_28);
if (iVar2 < 0) break;
cVar1 = translog_read_file_header(local_60,iVar2);
bVar3 = true;
if ((cVar1 == '\0') && (bVar3 = false, 0 < local_20 - local_60[0])) {
cVar1 = translog_max_lsn_to_header(iVar2,local_20);
bVar3 = cVar1 != '\0';
}
iVar2 = inline_mysql_file_close
("/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
0x524,iVar2,0x10);
if (bVar3 || iVar2 != 0) break;
local_28 = local_28 + 1;
}
translog_stop_writing();
inline_mysql_mutex_unlock(&DAT_00d79180);
return 1;
}
|
|
11,722 |
Shell::handleSignal(int)
|
isaiah76[P]linux-shell/src/Shell.cpp
|
void Shell::handleSignal(int signum){
if(globalShellPtr) {
switch(signum) {
case SIGINT:
std::cout << "\n";
if(globalShellPtr->running){
std::cout << globalShellPtr->curDir << "$ ";
std::cout.flush();
}
break;
case SIGTSTP:
// Ignore Ctrl+Z for this shell
std::cout << "\n";
if(globalShellPtr->running){
std::cout << globalShellPtr->curDir << "$ ";
std::cout.flush();
}
break;
}
}
}
|
O0
|
cpp
|
Shell::handleSignal(int):
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpq $0x0, 0x983d(%rip) # 0xd2d0
je 0x3b5b
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
subl $0x2, %eax
je 0x3ab3
jmp 0x3aa6
movl -0x8(%rbp), %eax
subl $0x14, %eax
je 0x3b06
jmp 0x3b59
movq 0x9516(%rip), %rdi # 0xcfd0
leaq 0x5678(%rip), %rsi # 0x9139
callq 0x32c0
movq 0x9803(%rip), %rax # 0xd2d0
testb $0x1, (%rax)
je 0x3b04
movq 0x97f7(%rip), %rsi # 0xd2d0
addq $0x8, %rsi
movq 0x94ec(%rip), %rdi # 0xcfd0
callq 0x3280
movq %rax, %rdi
leaq 0x5513(%rip), %rsi # 0x9006
callq 0x32c0
movq 0x94d1(%rip), %rdi # 0xcfd0
callq 0x31f0
jmp 0x3b59
movq 0x94c3(%rip), %rdi # 0xcfd0
leaq 0x5625(%rip), %rsi # 0x9139
callq 0x32c0
movq 0x97b0(%rip), %rax # 0xd2d0
testb $0x1, (%rax)
je 0x3b57
movq 0x97a4(%rip), %rsi # 0xd2d0
addq $0x8, %rsi
movq 0x9499(%rip), %rdi # 0xcfd0
callq 0x3280
movq %rax, %rdi
leaq 0x54c0(%rip), %rsi # 0x9006
callq 0x32c0
movq 0x947e(%rip), %rdi # 0xcfd0
callq 0x31f0
jmp 0x3b59
jmp 0x3b5b
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
_ZN5Shell12handleSignalEi:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_4], edi
cmp cs:_ZL14globalShellPtr, 0; globalShellPtr
jz loc_3B5B
mov eax, [rbp+var_4]
mov [rbp+var_8], eax
sub eax, 2
jz short loc_3AB3
jmp short $+2
loc_3AA6:
mov eax, [rbp+var_8]
sub eax, 14h
jz short loc_3B06
jmp loc_3B59
loc_3AB3:
mov rdi, cs:_ZSt4cout_ptr
lea rsi, aForkFailed+0Bh; "\n"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rax, cs:_ZL14globalShellPtr; globalShellPtr
test byte ptr [rax], 1
jz short loc_3B04
mov rsi, cs:_ZL14globalShellPtr; globalShellPtr
add rsi, 8
mov rdi, cs:_ZSt4cout_ptr
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
mov rdi, rax
lea rsi, unk_9006
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rdi, cs:_ZSt4cout_ptr; this
call __ZNSo5flushEv; std::ostream::flush(void)
loc_3B04:
jmp short loc_3B59
loc_3B06:
mov rdi, cs:_ZSt4cout_ptr
lea rsi, aForkFailed+0Bh; "\n"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rax, cs:_ZL14globalShellPtr; globalShellPtr
test byte ptr [rax], 1
jz short loc_3B57
mov rsi, cs:_ZL14globalShellPtr; globalShellPtr
add rsi, 8
mov rdi, cs:_ZSt4cout_ptr
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
mov rdi, rax
lea rsi, unk_9006
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rdi, cs:_ZSt4cout_ptr; this
call __ZNSo5flushEv; std::ostream::flush(void)
loc_3B57:
jmp short $+2
loc_3B59:
jmp short $+2
loc_3B5B:
add rsp, 10h
pop rbp
retn
|
void Shell::handleSignal(Shell *this)
{
long long v1; // rax
long long v2; // rax
if ( globalShellPtr )
{
if ( (_DWORD)this == 2 )
{
std::operator<<<std::char_traits<char>>(&std::cout, "\n");
if ( (*(_BYTE *)globalShellPtr & 1) != 0 )
{
v1 = std::operator<<<char>(&std::cout, globalShellPtr + 8);
std::operator<<<std::char_traits<char>>(v1, &unk_9006);
std::ostream::flush((std::ostream *)&std::cout);
}
}
else if ( (_DWORD)this == 20 )
{
std::operator<<<std::char_traits<char>>(&std::cout, "\n");
if ( (*(_BYTE *)globalShellPtr & 1) != 0 )
{
v2 = std::operator<<<char>(&std::cout, globalShellPtr + 8);
std::operator<<<std::char_traits<char>>(v2, &unk_9006);
std::ostream::flush((std::ostream *)&std::cout);
}
}
}
}
|
handleSignal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV dword ptr [RBP + -0x4],EDI
CMP qword ptr [0x0010d2d0],0x0
JZ 0x00103b5b
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x8],EAX
SUB EAX,0x2
JZ 0x00103ab3
JMP 0x00103aa6
LAB_00103aa6:
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x14
JZ 0x00103b06
JMP 0x00103b59
LAB_00103ab3:
MOV RDI,qword ptr [0x0010cfd0]
LEA RSI,[0x109139]
CALL 0x001032c0
MOV RAX,qword ptr [0x0010d2d0]
TEST byte ptr [RAX],0x1
JZ 0x00103b04
MOV RSI,qword ptr [0x0010d2d0]
ADD RSI,0x8
MOV RDI,qword ptr [0x0010cfd0]
CALL 0x00103280
MOV RDI,RAX
LEA RSI,[0x109006]
CALL 0x001032c0
MOV RDI,qword ptr [0x0010cfd0]
CALL 0x001031f0
LAB_00103b04:
JMP 0x00103b59
LAB_00103b06:
MOV RDI,qword ptr [0x0010cfd0]
LEA RSI,[0x109139]
CALL 0x001032c0
MOV RAX,qword ptr [0x0010d2d0]
TEST byte ptr [RAX],0x1
JZ 0x00103b57
MOV RSI,qword ptr [0x0010d2d0]
ADD RSI,0x8
MOV RDI,qword ptr [0x0010cfd0]
CALL 0x00103280
MOV RDI,RAX
LEA RSI,[0x109006]
CALL 0x001032c0
MOV RDI,qword ptr [0x0010cfd0]
CALL 0x001031f0
LAB_00103b57:
JMP 0x00103b59
LAB_00103b59:
JMP 0x00103b5b
LAB_00103b5b:
ADD RSP,0x10
POP RBP
RET
|
/* Shell::handleSignal(int) */
void Shell::handleSignal(int param_1)
{
ostream *poVar1;
if (globalShellPtr != (byte *)0x0) {
if (param_1 == 2) {
std::operator<<((ostream *)PTR_cout_0010cfd0,"\n");
if ((*globalShellPtr & 1) != 0) {
poVar1 = std::operator<<((ostream *)PTR_cout_0010cfd0,(string *)(globalShellPtr + 8));
std::operator<<(poVar1,"$ ");
std::ostream::flush();
}
}
else if ((param_1 == 0x14) &&
(std::operator<<((ostream *)PTR_cout_0010cfd0,"\n"), (*globalShellPtr & 1) != 0)) {
poVar1 = std::operator<<((ostream *)PTR_cout_0010cfd0,(string *)(globalShellPtr + 8));
std::operator<<(poVar1,"$ ");
std::ostream::flush();
}
}
return;
}
|
|
11,723 |
var_def_ptr(st_mysql_sys_var*)
|
eloqsql/sql/sql_plugin.cc
|
static const void *var_def_ptr(st_mysql_sys_var *pv)
{
switch (pv->flags & (PLUGIN_VAR_TYPEMASK | PLUGIN_VAR_THDLOCAL)) {
case PLUGIN_VAR_INT:
return &((sysvar_uint_t*) pv)->def_val;
case PLUGIN_VAR_LONG:
return &((sysvar_ulong_t*) pv)->def_val;
case PLUGIN_VAR_LONGLONG:
return &((sysvar_ulonglong_t*) pv)->def_val;
case PLUGIN_VAR_ENUM:
return &((sysvar_enum_t*) pv)->def_val;
case PLUGIN_VAR_SET:
return &((sysvar_set_t*) pv)->def_val;
case PLUGIN_VAR_BOOL:
return &((sysvar_bool_t*) pv)->def_val;
case PLUGIN_VAR_STR:
return &((sysvar_str_t*) pv)->def_val;
case PLUGIN_VAR_DOUBLE:
return &((sysvar_double_t*) pv)->def_val;
case PLUGIN_VAR_INT | PLUGIN_VAR_THDLOCAL:
return &((thdvar_uint_t*) pv)->def_val;
case PLUGIN_VAR_LONG | PLUGIN_VAR_THDLOCAL:
return &((thdvar_ulong_t*) pv)->def_val;
case PLUGIN_VAR_LONGLONG | PLUGIN_VAR_THDLOCAL:
return &((thdvar_ulonglong_t*) pv)->def_val;
case PLUGIN_VAR_ENUM | PLUGIN_VAR_THDLOCAL:
return &((thdvar_enum_t*) pv)->def_val;
case PLUGIN_VAR_SET | PLUGIN_VAR_THDLOCAL:
return &((thdvar_set_t*) pv)->def_val;
case PLUGIN_VAR_BOOL | PLUGIN_VAR_THDLOCAL:
return &((thdvar_bool_t*) pv)->def_val;
case PLUGIN_VAR_STR | PLUGIN_VAR_THDLOCAL:
return &((thdvar_str_t*) pv)->def_val;
case PLUGIN_VAR_DOUBLE | PLUGIN_VAR_THDLOCAL:
return &((thdvar_double_t*) pv)->def_val;
default:
DBUG_ASSERT(0);
return NULL;
}
}
|
O0
|
cpp
|
var_def_ptr(st_mysql_sys_var*):
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x17f, %eax # imm = 0x17F
movl %eax, -0x14(%rbp)
subl $0x1, %eax
je 0xa1140b
jmp 0xa112d1
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0xa113b6
jmp 0xa112df
movl -0x14(%rbp), %eax
subl $0x3, %eax
je 0xa113c7
jmp 0xa112ed
movl -0x14(%rbp), %eax
subl $0x4, %eax
je 0xa113d8
jmp 0xa112fb
movl -0x14(%rbp), %eax
subl $0x5, %eax
je 0xa1141c
jmp 0xa11309
movl -0x14(%rbp), %eax
subl $0x6, %eax
je 0xa113e9
jmp 0xa11317
movl -0x14(%rbp), %eax
subl $0x7, %eax
je 0xa113fa
jmp 0xa11325
movl -0x14(%rbp), %eax
subl $0x8, %eax
je 0xa1142d
jmp 0xa11333
movl -0x14(%rbp), %eax
subl $0x101, %eax # imm = 0x101
je 0xa11481
jmp 0xa11343
movl -0x14(%rbp), %eax
subl $0x102, %eax # imm = 0x102
je 0xa1143b
jmp 0xa11353
movl -0x14(%rbp), %eax
subl $0x103, %eax # imm = 0x103
je 0xa11449
jmp 0xa11363
movl -0x14(%rbp), %eax
subl $0x104, %eax # imm = 0x104
je 0xa11457
jmp 0xa11373
movl -0x14(%rbp), %eax
subl $0x105, %eax # imm = 0x105
je 0xa1148f
jmp 0xa11383
movl -0x14(%rbp), %eax
subl $0x106, %eax # imm = 0x106
je 0xa11465
jmp 0xa11393
movl -0x14(%rbp), %eax
subl $0x107, %eax # imm = 0x107
je 0xa11473
jmp 0xa113a3
movl -0x14(%rbp), %eax
subl $0x108, %eax # imm = 0x108
je 0xa1149d
jmp 0xa114ab
movq -0x10(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x8(%rbp)
jmp 0xa114b7
movq -0x10(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x8(%rbp)
jmp 0xa114b7
movq -0x10(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x8(%rbp)
jmp 0xa114b7
movq -0x10(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x8(%rbp)
jmp 0xa114b7
movq -0x10(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x8(%rbp)
jmp 0xa114b7
movq -0x10(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x8(%rbp)
jmp 0xa114b7
movq -0x10(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x8(%rbp)
jmp 0xa114b7
movq -0x10(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x8(%rbp)
jmp 0xa114b7
movq -0x10(%rbp), %rax
addq $0x2c, %rax
movq %rax, -0x8(%rbp)
jmp 0xa114b7
movq -0x10(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x8(%rbp)
jmp 0xa114b7
movq -0x10(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x8(%rbp)
jmp 0xa114b7
movq -0x10(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x8(%rbp)
jmp 0xa114b7
movq -0x10(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x8(%rbp)
jmp 0xa114b7
movq -0x10(%rbp), %rax
addq $0x2c, %rax
movq %rax, -0x8(%rbp)
jmp 0xa114b7
movq -0x10(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x8(%rbp)
jmp 0xa114b7
movq -0x10(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x8(%rbp)
jmp 0xa114b7
jmp 0xa114ad
jmp 0xa114af
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
|
_ZL11var_def_ptrP16st_mysql_sys_var:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov eax, [rax]
and eax, 17Fh
mov [rbp+var_14], eax
sub eax, 1
jz loc_A1140B
jmp short $+2
loc_A112D1:
mov eax, [rbp+var_14]
sub eax, 2
jz loc_A113B6
jmp short $+2
loc_A112DF:
mov eax, [rbp+var_14]
sub eax, 3
jz loc_A113C7
jmp short $+2
loc_A112ED:
mov eax, [rbp+var_14]
sub eax, 4
jz loc_A113D8
jmp short $+2
loc_A112FB:
mov eax, [rbp+var_14]
sub eax, 5
jz loc_A1141C
jmp short $+2
loc_A11309:
mov eax, [rbp+var_14]
sub eax, 6
jz loc_A113E9
jmp short $+2
loc_A11317:
mov eax, [rbp+var_14]
sub eax, 7
jz loc_A113FA
jmp short $+2
loc_A11325:
mov eax, [rbp+var_14]
sub eax, 8
jz loc_A1142D
jmp short $+2
loc_A11333:
mov eax, [rbp+var_14]
sub eax, 101h
jz loc_A11481
jmp short $+2
loc_A11343:
mov eax, [rbp+var_14]
sub eax, 102h
jz loc_A1143B
jmp short $+2
loc_A11353:
mov eax, [rbp+var_14]
sub eax, 103h
jz loc_A11449
jmp short $+2
loc_A11363:
mov eax, [rbp+var_14]
sub eax, 104h
jz loc_A11457
jmp short $+2
loc_A11373:
mov eax, [rbp+var_14]
sub eax, 105h
jz loc_A1148F
jmp short $+2
loc_A11383:
mov eax, [rbp+var_14]
sub eax, 106h
jz loc_A11465
jmp short $+2
loc_A11393:
mov eax, [rbp+var_14]
sub eax, 107h
jz loc_A11473
jmp short $+2
loc_A113A3:
mov eax, [rbp+var_14]
sub eax, 108h
jz loc_A1149D
jmp loc_A114AB
loc_A113B6:
mov rax, [rbp+var_10]
add rax, 30h ; '0'
mov [rbp+var_8], rax
jmp loc_A114B7
loc_A113C7:
mov rax, [rbp+var_10]
add rax, 30h ; '0'
mov [rbp+var_8], rax
jmp loc_A114B7
loc_A113D8:
mov rax, [rbp+var_10]
add rax, 30h ; '0'
mov [rbp+var_8], rax
jmp loc_A114B7
loc_A113E9:
mov rax, [rbp+var_10]
add rax, 30h ; '0'
mov [rbp+var_8], rax
jmp loc_A114B7
loc_A113FA:
mov rax, [rbp+var_10]
add rax, 30h ; '0'
mov [rbp+var_8], rax
jmp loc_A114B7
loc_A1140B:
mov rax, [rbp+var_10]
add rax, 30h ; '0'
mov [rbp+var_8], rax
jmp loc_A114B7
loc_A1141C:
mov rax, [rbp+var_10]
add rax, 30h ; '0'
mov [rbp+var_8], rax
jmp loc_A114B7
loc_A1142D:
mov rax, [rbp+var_10]
add rax, 30h ; '0'
mov [rbp+var_8], rax
jmp short loc_A114B7
loc_A1143B:
mov rax, [rbp+var_10]
add rax, 2Ch ; ','
mov [rbp+var_8], rax
jmp short loc_A114B7
loc_A11449:
mov rax, [rbp+var_10]
add rax, 30h ; '0'
mov [rbp+var_8], rax
jmp short loc_A114B7
loc_A11457:
mov rax, [rbp+var_10]
add rax, 30h ; '0'
mov [rbp+var_8], rax
jmp short loc_A114B7
loc_A11465:
mov rax, [rbp+var_10]
add rax, 30h ; '0'
mov [rbp+var_8], rax
jmp short loc_A114B7
loc_A11473:
mov rax, [rbp+var_10]
add rax, 30h ; '0'
mov [rbp+var_8], rax
jmp short loc_A114B7
loc_A11481:
mov rax, [rbp+var_10]
add rax, 2Ch ; ','
mov [rbp+var_8], rax
jmp short loc_A114B7
loc_A1148F:
mov rax, [rbp+var_10]
add rax, 30h ; '0'
mov [rbp+var_8], rax
jmp short loc_A114B7
loc_A1149D:
mov rax, [rbp+var_10]
add rax, 30h ; '0'
mov [rbp+var_8], rax
jmp short loc_A114B7
loc_A114AB:
jmp short $+2
loc_A114AD:
jmp short $+2
loc_A114AF:
mov [rbp+var_8], 0
loc_A114B7:
mov rax, [rbp+var_8]
pop rbp
retn
|
_DWORD * var_def_ptr(_DWORD *a1)
{
int v2; // [rsp+0h] [rbp-14h]
v2 = *a1 & 0x17F;
switch ( v2 )
{
case 1:
return a1 + 12;
case 2:
return a1 + 12;
case 3:
return a1 + 12;
case 4:
return a1 + 12;
case 5:
return a1 + 12;
case 6:
return a1 + 12;
case 7:
return a1 + 12;
case 8:
return a1 + 12;
case 257:
return a1 + 11;
case 258:
return a1 + 11;
case 259:
return a1 + 12;
case 260:
return a1 + 12;
case 261:
return a1 + 12;
case 262:
return a1 + 12;
case 263:
return a1 + 12;
case 264:
return a1 + 12;
}
return 0LL;
}
|
~sp_instr_hpush_jump:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
LEA RCX,[0x1af4068]
ADD RCX,0x10
MOV qword ptr [RAX],RCX
MOV RDI,qword ptr [RAX + 0x50]
ADD RDI,0x8
CALL 0x009563e0
MOV RDI,qword ptr [RBP + -0x10]
MOV qword ptr [RDI + 0x50],0x0
CALL 0x00a10f80
ADD RSP,0x10
POP RBP
RET
|
/* sp_instr_hpush_jump::~sp_instr_hpush_jump() */
void __thiscall sp_instr_hpush_jump::~sp_instr_hpush_jump(sp_instr_hpush_jump *this)
{
*(int ***)this = &PTR_type_01af4078;
base_list::empty((base_list *)(*(long *)(this + 0x50) + 8));
*(int8 *)(this + 0x50) = 0;
sp_instr_jump::~sp_instr_jump((sp_instr_jump *)this);
return;
}
|
|
11,724 |
func_uni_gb2312_onechar
|
eloqsql/strings/ctype-gb2312.c
|
static int func_uni_gb2312_onechar(int code){
if ((code>=0x00A4)&&(code<=0x01DC))
return(tab_uni_gb23120[code-0x00A4]);
if ((code>=0x02C7)&&(code<=0x0451))
return(tab_uni_gb23121[code-0x02C7]);
if ((code>=0x2015)&&(code<=0x2312))
return(tab_uni_gb23122[code-0x2015]);
if ((code>=0x2460)&&(code<=0x2642))
return(tab_uni_gb23123[code-0x2460]);
if ((code>=0x3000)&&(code<=0x3129))
return(tab_uni_gb23124[code-0x3000]);
if ((code>=0x3220)&&(code<=0x3229))
return(tab_uni_gb23125[code-0x3220]);
if ((code>=0x4E00)&&(code<=0x9B54))
return(tab_uni_gb23126[code-0x4E00]);
if ((code>=0x9C7C)&&(code<=0x9CE2))
return(tab_uni_gb23127[code-0x9C7C]);
if ((code>=0x9E1F)&&(code<=0x9FA0))
return(tab_uni_gb23128[code-0x9E1F]);
if ((code>=0xFF01)&&(code<=0xFFE5))
return(tab_uni_gb23129[code-0xFF01]);
return(0);
}
|
O0
|
c
|
func_uni_gb2312_onechar:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0xa4, -0x8(%rbp)
jl 0x8c567
cmpl $0x1dc, -0x8(%rbp) # imm = 0x1DC
jg 0x8c567
movl -0x8(%rbp), %eax
subl $0xa4, %eax
movslq %eax, %rcx
leaq 0xd3c15(%rip), %rax # 0x160170
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x8c715
cmpl $0x2c7, -0x8(%rbp) # imm = 0x2C7
jl 0x8c597
cmpl $0x451, -0x8(%rbp) # imm = 0x451
jg 0x8c597
movl -0x8(%rbp), %eax
subl $0x2c7, %eax # imm = 0x2C7
movslq %eax, %rcx
leaq 0xd3e65(%rip), %rax # 0x1603f0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x8c715
cmpl $0x2015, -0x8(%rbp) # imm = 0x2015
jl 0x8c5c7
cmpl $0x2312, -0x8(%rbp) # imm = 0x2312
jg 0x8c5c7
movl -0x8(%rbp), %eax
subl $0x2015, %eax # imm = 0x2015
movslq %eax, %rcx
leaq 0xd4155(%rip), %rax # 0x160710
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x8c715
cmpl $0x2460, -0x8(%rbp) # imm = 0x2460
jl 0x8c5f7
cmpl $0x2642, -0x8(%rbp) # imm = 0x2642
jg 0x8c5f7
movl -0x8(%rbp), %eax
subl $0x2460, %eax # imm = 0x2460
movslq %eax, %rcx
leaq 0xd4725(%rip), %rax # 0x160d10
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x8c715
cmpl $0x3000, -0x8(%rbp) # imm = 0x3000
jl 0x8c627
cmpl $0x3129, -0x8(%rbp) # imm = 0x3129
jg 0x8c627
movl -0x8(%rbp), %eax
subl $0x3000, %eax # imm = 0x3000
movslq %eax, %rcx
leaq 0xd4ac5(%rip), %rax # 0x1610e0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x8c715
cmpl $0x3220, -0x8(%rbp) # imm = 0x3220
jl 0x8c657
cmpl $0x3229, -0x8(%rbp) # imm = 0x3229
jg 0x8c657
movl -0x8(%rbp), %eax
subl $0x3220, %eax # imm = 0x3220
movslq %eax, %rcx
leaq 0xd4cf5(%rip), %rax # 0x161340
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x8c715
cmpl $0x4e00, -0x8(%rbp) # imm = 0x4E00
jl 0x8c687
cmpl $0x9b54, -0x8(%rbp) # imm = 0x9B54
jg 0x8c687
movl -0x8(%rbp), %eax
subl $0x4e00, %eax # imm = 0x4E00
movslq %eax, %rcx
leaq 0xd4ce5(%rip), %rax # 0x161360
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x8c715
cmpl $0x9c7c, -0x8(%rbp) # imm = 0x9C7C
jl 0x8c6b4
cmpl $0x9ce2, -0x8(%rbp) # imm = 0x9CE2
jg 0x8c6b4
movl -0x8(%rbp), %eax
subl $0x9c7c, %eax # imm = 0x9C7C
movslq %eax, %rcx
leaq 0xde765(%rip), %rax # 0x16ae10
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x8c715
cmpl $0x9e1f, -0x8(%rbp) # imm = 0x9E1F
jl 0x8c6e1
cmpl $0x9fa0, -0x8(%rbp) # imm = 0x9FA0
jg 0x8c6e1
movl -0x8(%rbp), %eax
subl $0x9e1f, %eax # imm = 0x9E1F
movslq %eax, %rcx
leaq 0xde808(%rip), %rax # 0x16aee0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x8c715
cmpl $0xff01, -0x8(%rbp) # imm = 0xFF01
jl 0x8c70e
cmpl $0xffe5, -0x8(%rbp) # imm = 0xFFE5
jg 0x8c70e
movl -0x8(%rbp), %eax
subl $0xff01, %eax # imm = 0xFF01
movslq %eax, %rcx
leaq 0xdeaeb(%rip), %rax # 0x16b1f0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x8c715
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
|
func_uni_gb2312_onechar:
push rbp
mov rbp, rsp
mov [rbp+var_8], edi
cmp [rbp+var_8], 0A4h
jl short loc_8C567
cmp [rbp+var_8], 1DCh
jg short loc_8C567
mov eax, [rbp+var_8]
sub eax, 0A4h
movsxd rcx, eax
lea rax, tab_uni_gb23120
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_8C715
loc_8C567:
cmp [rbp+var_8], 2C7h
jl short loc_8C597
cmp [rbp+var_8], 451h
jg short loc_8C597
mov eax, [rbp+var_8]
sub eax, 2C7h
movsxd rcx, eax
lea rax, tab_uni_gb23121
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_8C715
loc_8C597:
cmp [rbp+var_8], 2015h
jl short loc_8C5C7
cmp [rbp+var_8], 2312h
jg short loc_8C5C7
mov eax, [rbp+var_8]
sub eax, 2015h
movsxd rcx, eax
lea rax, tab_uni_gb23122; "*!,!"
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_8C715
loc_8C5C7:
cmp [rbp+var_8], 2460h
jl short loc_8C5F7
cmp [rbp+var_8], 2642h
jg short loc_8C5F7
mov eax, [rbp+var_8]
sub eax, 2460h
movsxd rcx, eax
lea rax, tab_uni_gb23123; "Y\"Z\"[\"\\\"]\"^\"_\"`\"a\"b\""
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_8C715
loc_8C5F7:
cmp [rbp+var_8], 3000h
jl short loc_8C627
cmp [rbp+var_8], 3129h
jg short loc_8C627
mov eax, [rbp+var_8]
sub eax, 3000h
movsxd rcx, eax
lea rax, tab_uni_gb23124; "!!\"!#!(!"
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_8C715
loc_8C627:
cmp [rbp+var_8], 3220h
jl short loc_8C657
cmp [rbp+var_8], 3229h
jg short loc_8C657
mov eax, [rbp+var_8]
sub eax, 3220h
movsxd rcx, eax
lea rax, tab_uni_gb23125; "e\"f\"g\"h\"i\"j\"k\"l\"m\"n\""
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_8C715
loc_8C657:
cmp [rbp+var_8], 4E00h
jl short loc_8C687
cmp [rbp+var_8], 9B54h
jg short loc_8C687
mov eax, [rbp+var_8]
sub eax, 4E00h
movsxd rcx, eax
lea rax, tab_uni_gb23126; ";R!6"
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_8C715
loc_8C687:
cmp [rbp+var_8], 9C7Ch
jl short loc_8C6B4
cmp [rbp+var_8], 9CE2h
jg short loc_8C6B4
mov eax, [rbp+var_8]
sub eax, 9C7Ch
movsxd rcx, eax
lea rax, tab_uni_gb23127
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_8C715
loc_8C6B4:
cmp [rbp+var_8], 9E1Fh
jl short loc_8C6E1
cmp [rbp+var_8], 9FA0h
jg short loc_8C6E1
mov eax, [rbp+var_8]
sub eax, 9E1Fh
movsxd rcx, eax
lea rax, tab_uni_gb23128; "qD/p&<0pyC"
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_8C715
loc_8C6E1:
cmp [rbp+var_8], 0FF01h
jl short loc_8C70E
cmp [rbp+var_8], 0FFE5h
jg short loc_8C70E
mov eax, [rbp+var_8]
sub eax, 0FF01h
movsxd rcx, eax
lea rax, tab_uni_gb23129; "!#\"###g!%#&#'#(#)#*#+#,#-#.#/#0#1#2#3#"...
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_8C715
loc_8C70E:
mov [rbp+var_4], 0
loc_8C715:
mov eax, [rbp+var_4]
pop rbp
retn
|
long long func_uni_gb2312_onechar(int a1)
{
if ( a1 < 164 || a1 > 476 )
{
if ( a1 < 711 || a1 > 1105 )
{
if ( a1 < 8213 || a1 > 8978 )
{
if ( a1 < 9312 || a1 > 9794 )
{
if ( a1 < 12288 || a1 > 12585 )
{
if ( a1 < 12832 || a1 > 12841 )
{
if ( a1 < 19968 || a1 > 39764 )
{
if ( a1 < 40060 || a1 > 40162 )
{
if ( a1 < 40479 || a1 > 40864 )
{
if ( a1 < 65281 || a1 > 65509 )
return 0;
else
return tab_uni_gb23129[a1 - 65281];
}
else
{
return *(unsigned __int16 *)&tab_uni_gb23128[2 * a1 - 80958];
}
}
else
{
return tab_uni_gb23127[a1 - 40060];
}
}
else
{
return *(unsigned __int16 *)&tab_uni_gb23126[2 * a1 - 39936];
}
}
else
{
return *(unsigned __int16 *)&tab_uni_gb23125[2 * a1 - 25664];
}
}
else
{
return *(unsigned __int16 *)&tab_uni_gb23124[2 * a1 - 24576];
}
}
else
{
return tab_uni_gb23123[a1 - 9312];
}
}
else
{
return *(unsigned __int16 *)&tab_uni_gb23122[2 * a1 - 16426];
}
}
else
{
return tab_uni_gb23121[a1 - 711];
}
}
else
{
return tab_uni_gb23120[a1 - 164];
}
}
|
func_uni_gb2312_onechar:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x8],EDI
CMP dword ptr [RBP + -0x8],0xa4
JL 0x0018c567
CMP dword ptr [RBP + -0x8],0x1dc
JG 0x0018c567
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0xa4
MOVSXD RCX,EAX
LEA RAX,[0x260170]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0018c715
LAB_0018c567:
CMP dword ptr [RBP + -0x8],0x2c7
JL 0x0018c597
CMP dword ptr [RBP + -0x8],0x451
JG 0x0018c597
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2c7
MOVSXD RCX,EAX
LEA RAX,[0x2603f0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0018c715
LAB_0018c597:
CMP dword ptr [RBP + -0x8],0x2015
JL 0x0018c5c7
CMP dword ptr [RBP + -0x8],0x2312
JG 0x0018c5c7
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2015
MOVSXD RCX,EAX
LEA RAX,[0x260710]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0018c715
LAB_0018c5c7:
CMP dword ptr [RBP + -0x8],0x2460
JL 0x0018c5f7
CMP dword ptr [RBP + -0x8],0x2642
JG 0x0018c5f7
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2460
MOVSXD RCX,EAX
LEA RAX,[0x260d10]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0018c715
LAB_0018c5f7:
CMP dword ptr [RBP + -0x8],0x3000
JL 0x0018c627
CMP dword ptr [RBP + -0x8],0x3129
JG 0x0018c627
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x3000
MOVSXD RCX,EAX
LEA RAX,[0x2610e0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0018c715
LAB_0018c627:
CMP dword ptr [RBP + -0x8],0x3220
JL 0x0018c657
CMP dword ptr [RBP + -0x8],0x3229
JG 0x0018c657
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x3220
MOVSXD RCX,EAX
LEA RAX,[0x261340]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0018c715
LAB_0018c657:
CMP dword ptr [RBP + -0x8],0x4e00
JL 0x0018c687
CMP dword ptr [RBP + -0x8],0x9b54
JG 0x0018c687
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x4e00
MOVSXD RCX,EAX
LEA RAX,[0x261360]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0018c715
LAB_0018c687:
CMP dword ptr [RBP + -0x8],0x9c7c
JL 0x0018c6b4
CMP dword ptr [RBP + -0x8],0x9ce2
JG 0x0018c6b4
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x9c7c
MOVSXD RCX,EAX
LEA RAX,[0x26ae10]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0018c715
LAB_0018c6b4:
CMP dword ptr [RBP + -0x8],0x9e1f
JL 0x0018c6e1
CMP dword ptr [RBP + -0x8],0x9fa0
JG 0x0018c6e1
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x9e1f
MOVSXD RCX,EAX
LEA RAX,[0x26aee0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0018c715
LAB_0018c6e1:
CMP dword ptr [RBP + -0x8],0xff01
JL 0x0018c70e
CMP dword ptr [RBP + -0x8],0xffe5
JG 0x0018c70e
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0xff01
MOVSXD RCX,EAX
LEA RAX,[0x26b1f0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0018c715
LAB_0018c70e:
MOV dword ptr [RBP + -0x4],0x0
LAB_0018c715:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int2 func_uni_gb2312_onechar(int param_1)
{
int2 uVar1;
if ((param_1 < 0xa4) || (0x1dc < param_1)) {
if ((param_1 < 0x2c7) || (0x451 < param_1)) {
if ((param_1 < 0x2015) || (0x2312 < param_1)) {
if ((param_1 < 0x2460) || (0x2642 < param_1)) {
if ((param_1 < 0x3000) || (0x3129 < param_1)) {
if ((param_1 < 0x3220) || (0x3229 < param_1)) {
if ((param_1 < 0x4e00) || (0x9b54 < param_1)) {
if ((param_1 < 0x9c7c) || (0x9ce2 < param_1)) {
if ((param_1 < 0x9e1f) || (0x9fa0 < param_1)) {
if ((param_1 < 0xff01) || (0xffe5 < param_1)) {
uVar1 = 0;
}
else {
uVar1 = *(int2 *)(tab_uni_gb23129 + (long)(param_1 + -0xff01) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gb23128 + (long)(param_1 + -0x9e1f) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gb23127 + (long)(param_1 + -0x9c7c) * 2);
}
}
else {
uVar1 = *(int2 *)(&tab_uni_gb23126 + (long)(param_1 + -0x4e00) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gb23125 + (long)(param_1 + -0x3220) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gb23124 + (long)(param_1 + -0x3000) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gb23123 + (long)(param_1 + -0x2460) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gb23122 + (long)(param_1 + -0x2015) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gb23121 + (long)(param_1 + -0x2c7) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gb23120 + (long)(param_1 + -0xa4) * 2);
}
return uVar1;
}
|
|
11,725 |
inline_mysql_file_fclose
|
eloqsql/include/mysql/psi/mysql_file.h
|
static inline int
inline_mysql_file_fclose(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
MYSQL_FILE *file, myf flags)
{
int result= 0;
if (likely(file != NULL))
{
#ifdef HAVE_PSI_FILE_INTERFACE
if (psi_likely(file->m_psi))
{
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_stream_locker)(&state, file->m_psi,
PSI_FILE_STREAM_CLOSE);
if (likely(locker != NULL))
{
PSI_FILE_CALL(start_file_close_wait)(locker, src_file, src_line);
result= my_fclose(file->m_file, flags);
PSI_FILE_CALL(end_file_close_wait)(locker, result);
my_free(file);
return result;
}
}
#endif
result= my_fclose(file->m_file, flags);
my_free(file);
}
return result;
}
|
O0
|
c
|
inline_mysql_file_fclose:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpq $0x0, -0x20(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x394d4
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x394b8
leaq 0x1aaa7f(%rip), %rax # 0x1e3e98
movq (%rax), %rax
movq 0x150(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rsi
leaq -0x80(%rbp), %rdi
movl $0x5, %edx
callq *%rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x394b6
leaq 0x1aaa37(%rip), %rax # 0x1e3e98
movq (%rax), %rax
movq 0x220(%rax), %rax
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq *%rax
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x2d2b0
movl %eax, -0x2c(%rbp)
leaq 0x1aaa06(%rip), %rax # 0x1e3e98
movq (%rax), %rax
movq 0x228(%rax), %rax
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq *%rax
movq -0x20(%rbp), %rdi
callq 0x325f0
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x394da
jmp 0x394b8
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x2d2b0
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rdi
callq 0x325f0
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
inline_mysql_file_fclose:
push rbp
mov rbp, rsp
sub rsp, 80h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_2C], 0
cmp [rbp+var_20], 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 loc_394D4
mov rax, [rbp+var_20]
cmp qword ptr [rax+8], 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz loc_394B8
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+150h]
mov rcx, [rbp+var_20]
mov rsi, [rcx+8]
lea rdi, [rbp+var_80]
mov edx, 5
call rax
mov [rbp+var_38], rax
cmp [rbp+var_38], 0
setnz al
and al, 1
movzx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_394B6
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+220h]
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_10]
mov edx, [rbp+var_14]
call rax
mov rax, [rbp+var_20]
mov rdi, [rax]
mov rsi, [rbp+var_28]
call my_fclose
mov [rbp+var_2C], eax
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+228h]
mov rdi, [rbp+var_38]
mov esi, [rbp+var_2C]
call rax
mov rdi, [rbp+var_20]
call my_free
mov eax, [rbp+var_2C]
mov [rbp+var_4], eax
jmp short loc_394DA
loc_394B6:
jmp short $+2
loc_394B8:
mov rax, [rbp+var_20]
mov rdi, [rax]
mov rsi, [rbp+var_28]
call my_fclose
mov [rbp+var_2C], eax
mov rdi, [rbp+var_20]
call my_free
loc_394D4:
mov eax, [rbp+var_2C]
mov [rbp+var_4], eax
loc_394DA:
mov eax, [rbp+var_4]
add rsp, 80h
pop rbp
retn
|
long long inline_mysql_file_fclose(long long a1, unsigned int a2, long long *a3, long long a4)
{
_BYTE v5[72]; // [rsp+0h] [rbp-80h] BYREF
long long v6; // [rsp+48h] [rbp-38h]
unsigned int v7; // [rsp+54h] [rbp-2Ch]
long long v8; // [rsp+58h] [rbp-28h]
long long *v9; // [rsp+60h] [rbp-20h]
unsigned int v10; // [rsp+6Ch] [rbp-14h]
long long v11; // [rsp+70h] [rbp-10h]
v11 = a1;
v10 = a2;
v9 = a3;
v8 = a4;
v7 = 0;
if ( !a3 )
return v7;
if ( !v9[1] || (v6 = (*((long long ( **)(_BYTE *, long long, long long))PSI_server + 42))(v5, v9[1], 5LL)) == 0 )
{
v7 = my_fclose(*v9, v8);
my_free((long long)v9);
return v7;
}
(*((void ( **)(long long, long long, _QWORD))PSI_server + 68))(v6, v11, v10);
v7 = my_fclose(*v9, v8);
(*((void ( **)(long long, _QWORD))PSI_server + 69))(v6, v7);
my_free((long long)v9);
return v7;
}
|
inline_mysql_file_fclose:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV dword ptr [RBP + -0x2c],0x0
CMP qword ptr [RBP + -0x20],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 0x001394d4
MOV RAX,qword ptr [RBP + -0x20]
CMP qword ptr [RAX + 0x8],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x001394b8
LEA RAX,[0x2e3e98]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x150]
MOV RCX,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RCX + 0x8]
LEA RDI,[RBP + -0x80]
MOV EDX,0x5
CALL RAX
MOV qword ptr [RBP + -0x38],RAX
CMP qword ptr [RBP + -0x38],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x001394b6
LEA RAX,[0x2e3e98]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x220]
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x14]
CALL RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x0012d2b0
MOV dword ptr [RBP + -0x2c],EAX
LEA RAX,[0x2e3e98]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x228]
MOV RDI,qword ptr [RBP + -0x38]
MOV ESI,dword ptr [RBP + -0x2c]
CALL RAX
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x001325f0
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001394da
LAB_001394b6:
JMP 0x001394b8
LAB_001394b8:
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x0012d2b0
MOV dword ptr [RBP + -0x2c],EAX
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x001325f0
LAB_001394d4:
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x4],EAX
LAB_001394da:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x80
POP RBP
RET
|
int4
inline_mysql_file_fclose
(int8 param_1,int4 param_2,int8 *param_3,int8 param_4)
{
int1 local_88 [72];
long local_40;
int4 local_34;
int8 local_30;
int8 *local_28;
int4 local_1c;
int8 local_18;
local_34 = 0;
if (param_3 != (int8 *)0x0) {
local_30 = param_4;
local_28 = param_3;
local_1c = param_2;
local_18 = param_1;
if (param_3[1] != 0) {
local_40 = (**(code **)(PSI_server + 0x150))(local_88,param_3[1],5);
if (local_40 != 0) {
(**(code **)(PSI_server + 0x220))(local_40,local_18,local_1c);
local_34 = my_fclose(*local_28,local_30);
(**(code **)(PSI_server + 0x228))(local_40,local_34);
my_free(local_28);
return local_34;
}
local_40 = 0;
}
local_34 = my_fclose(*local_28,local_30);
my_free(local_28);
}
return local_34;
}
|
|
11,726 |
ma_multi_command
|
eloqsql/libmariadb/libmariadb/mariadb_lib.c
|
int ma_multi_command(MYSQL *mysql, enum enum_multi_status status)
{
NET *net= &mysql->net;
switch (status) {
case COM_MULTI_OFF:
ma_net_clear(net);
net->extension->multi_status= status;
return 0;
case COM_MULTI_ENABLED:
if (net->extension->multi_status > COM_MULTI_DISABLED)
return 1;
ma_net_clear(net);
net->extension->multi_status= status;
return 0;
case COM_MULTI_DISABLED:
/* Opposite to COM_MULTI_OFF we don't clear net buffer,
next command or com_nulti_end will flush entire buffer */
net->extension->multi_status= status;
return 0;
case COM_MULTI_END:
{
size_t len= net->write_pos - net->buff - NET_HEADER_SIZE;
if (len < NET_HEADER_SIZE) /* don't send empty request */
{
ma_net_clear(net);
return 1;
}
net->extension->multi_status= COM_MULTI_OFF;
return ma_net_flush(net);
}
case COM_MULTI_CANCEL:
ma_net_clear(net);
net->extension->multi_status= COM_MULTI_OFF;
return 0;
default:
return 1;
}
}
|
O3
|
c
|
ma_multi_command:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl $0x1, %r14d
cmpl $0x4, %esi
ja 0x16a12
movq %rdi, %rbx
movl %esi, %eax
leaq 0x2339d(%rip), %rcx # 0x39d40
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x32c04
movq 0x2a0(%rbx), %rax
movl $0x0, (%rax)
jmp 0x16a0f
movq 0x18(%rbx), %rax
subq 0x8(%rbx), %rax
andq $-0x4, %rax
cmpq $0x4, %rax
jne 0x16a1a
movq %rbx, %rdi
callq 0x32c04
jmp 0x16a12
movq 0x2a0(%rbx), %rax
cmpl $0x3, (%rax)
ja 0x16a12
movq %rbx, %rdi
callq 0x32c04
movq 0x2a0(%rbx), %rax
movl $0x2, (%rax)
jmp 0x16a0f
movq 0x2a0(%rbx), %rax
movl $0x3, (%rax)
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x2a0(%rbx), %rax
movl $0x0, (%rax)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x32c26
|
ma_multi_command:
push rbp
mov rbp, rsp
push r14
push rbx
mov r14d, 1
cmp esi, 4; switch 5 cases
ja short def_169AA; jumptable 00000000000169AA default case
mov rbx, rdi
mov eax, esi
lea rcx, jpt_169AA
movsxd rax, ds:(jpt_169AA - 39D40h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_169AC:
mov rdi, rbx; jumptable 00000000000169AA cases 0,1
call ma_net_clear
mov rax, [rbx+2A0h]
mov dword ptr [rax], 0
jmp short loc_16A0F
loc_169C3:
mov rax, [rbx+18h]; jumptable 00000000000169AA case 4
sub rax, [rbx+8]
and rax, 0FFFFFFFFFFFFFFFCh
cmp rax, 4
jnz short loc_16A1A
mov rdi, rbx
call ma_net_clear
jmp short def_169AA; jumptable 00000000000169AA default case
loc_169DF:
mov rax, [rbx+2A0h]; jumptable 00000000000169AA case 2
cmp dword ptr [rax], 3
ja short def_169AA; jumptable 00000000000169AA default case
mov rdi, rbx
call ma_net_clear
mov rax, [rbx+2A0h]
mov dword ptr [rax], 2
jmp short loc_16A0F
loc_16A02:
mov rax, [rbx+2A0h]; jumptable 00000000000169AA case 3
mov dword ptr [rax], 3
loc_16A0F:
xor r14d, r14d
def_169AA:
mov eax, r14d; jumptable 00000000000169AA default case
pop rbx
pop r14
pop rbp
retn
loc_16A1A:
mov rax, [rbx+2A0h]
mov dword ptr [rax], 0
mov rdi, rbx
pop rbx
pop r14
pop rbp
jmp ma_net_flush
|
long long ma_multi_command(long long a1, int a2)
{
unsigned int v2; // r14d
v2 = 1;
switch ( a2 )
{
case 0:
case 1:
ma_net_clear(a1);
**(_DWORD **)(a1 + 672) = 0;
return 0;
case 2:
if ( **(_DWORD **)(a1 + 672) > 3u )
return v2;
ma_net_clear(a1);
**(_DWORD **)(a1 + 672) = 2;
return 0;
case 3:
**(_DWORD **)(a1 + 672) = 3;
return 0;
case 4:
if ( ((*(_QWORD *)(a1 + 24) - *(_QWORD *)(a1 + 8)) & 0xFFFFFFFFFFFFFFFCLL) == 4 )
{
ma_net_clear(a1);
return v2;
}
else
{
**(_DWORD **)(a1 + 672) = 0;
return ma_net_flush(a1);
}
default:
return v2;
}
}
|
ma_multi_command:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV R14D,0x1
CMP ESI,0x4
JA 0x00116a12
MOV RBX,RDI
MOV EAX,ESI
LEA RCX,[0x139d40]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_0:
MOV RDI,RBX
CALL 0x00132c04
MOV RAX,qword ptr [RBX + 0x2a0]
MOV dword ptr [RAX],0x0
JMP 0x00116a0f
caseD_4:
MOV RAX,qword ptr [RBX + 0x18]
SUB RAX,qword ptr [RBX + 0x8]
AND RAX,-0x4
CMP RAX,0x4
JNZ 0x00116a1a
MOV RDI,RBX
CALL 0x00132c04
JMP 0x00116a12
caseD_2:
MOV RAX,qword ptr [RBX + 0x2a0]
CMP dword ptr [RAX],0x3
JA 0x00116a12
MOV RDI,RBX
CALL 0x00132c04
MOV RAX,qword ptr [RBX + 0x2a0]
MOV dword ptr [RAX],0x2
JMP 0x00116a0f
caseD_3:
MOV RAX,qword ptr [RBX + 0x2a0]
MOV dword ptr [RAX],0x3
LAB_00116a0f:
XOR R14D,R14D
default:
MOV EAX,R14D
POP RBX
POP R14
POP RBP
RET
LAB_00116a1a:
MOV RAX,qword ptr [RBX + 0x2a0]
MOV dword ptr [RAX],0x0
MOV RDI,RBX
POP RBX
POP R14
POP RBP
JMP 0x00132c26
|
int8 ma_multi_command(long param_1,int4 param_2)
{
int8 uVar1;
uVar1 = 1;
switch(param_2) {
case 0:
case 1:
ma_net_clear(param_1);
**(int4 **)(param_1 + 0x2a0) = 0;
break;
case 2:
if (3 < **(uint **)(param_1 + 0x2a0)) {
return 1;
}
ma_net_clear(param_1);
**(int4 **)(param_1 + 0x2a0) = 2;
break;
case 3:
**(int4 **)(param_1 + 0x2a0) = 3;
break;
case 4:
if ((*(long *)(param_1 + 0x18) - *(long *)(param_1 + 8) & 0xfffffffffffffffcU) != 4) {
**(int4 **)(param_1 + 0x2a0) = 0;
uVar1 = ma_net_flush(param_1);
return uVar1;
}
ma_net_clear(param_1);
default:
goto switchD_001169aa_default;
}
uVar1 = 0;
switchD_001169aa_default:
return uVar1;
}
|
|
11,727 |
mbedtls_cipher_info_from_string
|
msxemulator/build_O3/_deps/pico_sdk-src/lib/mbedtls/library/cipher.c
|
const mbedtls_cipher_info_t *mbedtls_cipher_info_from_string(
const char *cipher_name)
{
const mbedtls_cipher_definition_t *def;
if (NULL == cipher_name) {
return NULL;
}
for (def = mbedtls_cipher_definitions; def->info != NULL; def++) {
if (!strcmp(def->info->name, cipher_name)) {
return def->info;
}
}
return NULL;
}
|
O3
|
c
|
mbedtls_cipher_info_from_string:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x9a254
leaq 0x4a298(%rip), %r15 # 0xe44c0
movq 0x8(%r15), %rbx
testq %rbx, %rbx
je 0x9a254
movq %rdi, %r14
addq $0x18, %r15
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0xf630
testl %eax, %eax
je 0x9a256
movq (%r15), %rbx
addq $0x10, %r15
testq %rbx, %rbx
jne 0x9a238
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
|
mbedtls_cipher_info_from_string:
push r15
push r14
push rbx
test rdi, rdi
jz short loc_9A254
lea r15, mbedtls_cipher_definitions
mov rbx, [r15+8]
test rbx, rbx
jz short loc_9A254
mov r14, rdi
add r15, 18h
loc_9A238:
mov rdi, [rbx+10h]
mov rsi, r14
call _strcmp
test eax, eax
jz short loc_9A256
mov rbx, [r15]
add r15, 10h
test rbx, rbx
jnz short loc_9A238
loc_9A254:
xor ebx, ebx
loc_9A256:
mov rax, rbx
pop rbx
pop r14
pop r15
retn
|
long long mbedtls_cipher_info_from_string(long long a1)
{
long long v1; // rbx
long long *v2; // r15
if ( !a1 )
return 0LL;
v1 = *(_QWORD *)&mbedtls_cipher_definitions[2];
if ( !v1 )
return 0LL;
v2 = (long long *)&mbedtls_cipher_definitions[6];
while ( (unsigned int)strcmp(*(_QWORD *)(v1 + 16), a1) )
{
v1 = *v2;
v2 += 2;
if ( !v1 )
return 0LL;
}
return v1;
}
|
mbedtls_cipher_info_from_string:
PUSH R15
PUSH R14
PUSH RBX
TEST RDI,RDI
JZ 0x0019a254
LEA R15,[0x1e44c0]
MOV RBX,qword ptr [R15 + 0x8]
TEST RBX,RBX
JZ 0x0019a254
MOV R14,RDI
ADD R15,0x18
LAB_0019a238:
MOV RDI,qword ptr [RBX + 0x10]
MOV RSI,R14
CALL 0x0010f630
TEST EAX,EAX
JZ 0x0019a256
MOV RBX,qword ptr [R15]
ADD R15,0x10
TEST RBX,RBX
JNZ 0x0019a238
LAB_0019a254:
XOR EBX,EBX
LAB_0019a256:
MOV RAX,RBX
POP RBX
POP R14
POP R15
RET
|
int * mbedtls_cipher_info_from_string(char *param_1)
{
int iVar1;
int *puVar2;
int **ppuVar3;
if ((param_1 != (char *)0x0) && (PTR_aes_128_ecb_info_001e44c8 != (int *)0x0)) {
ppuVar3 = &PTR_aes_192_ecb_info_001e44d8;
puVar2 = PTR_aes_128_ecb_info_001e44c8;
do {
iVar1 = strcmp(*(char **)(puVar2 + 0x10),param_1);
if (iVar1 == 0) {
return puVar2;
}
puVar2 = *ppuVar3;
ppuVar3 = ppuVar3 + 2;
} while (puVar2 != (int *)0x0);
}
return (int *)0x0;
}
|
|
11,728 |
my_scan_8bit
|
eloqsql/strings/ctype-simple.c
|
size_t my_scan_8bit(CHARSET_INFO *cs, const char *str, const char *end, int sq)
{
const char *str0= str;
switch (sq)
{
case MY_SEQ_INTTAIL:
if (*str == '.')
{
for(str++ ; str != end && *str == '0' ; str++);
return (size_t) (str - str0);
}
return 0;
case MY_SEQ_SPACES:
for ( ; str < end ; str++)
{
if (!my_isspace(cs,*str))
break;
}
return (size_t) (str - str0);
case MY_SEQ_NONSPACES:
for ( ; str < end ; str++)
{
if (my_isspace(cs, *str))
break;
}
return (size_t) (str - str0);
default:
return 0;
}
}
|
O0
|
c
|
my_scan_8bit:
pushq %rbp
movq %rsp, %rbp
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, -0x34(%rbp)
subl $0x1, %eax
je 0x4d927
jmp 0x4d908
movl -0x34(%rbp), %eax
subl $0x2, %eax
je 0x4d998
jmp 0x4d916
movl -0x34(%rbp), %eax
subl $0x3, %eax
je 0x4d9e3
jmp 0x4da2e
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x4d98b
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x35(%rbp)
je 0x4d95e
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
sete %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
testb $0x1, %al
jne 0x4d967
jmp 0x4d977
jmp 0x4d969
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4d93f
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x4da36
movq $0x0, -0x8(%rbp)
jmp 0x4da36
jmp 0x4d99a
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x4d9d2
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x18(%rbp), %rcx
movzbl (%rcx), %ecx
movzbl 0x1(%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x4d9c2
jmp 0x4d9d2
jmp 0x4d9c4
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4d99a
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x4da36
jmp 0x4d9e5
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x4da1d
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x18(%rbp), %rcx
movzbl (%rcx), %ecx
movzbl 0x1(%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x4da0d
jmp 0x4da1d
jmp 0x4da0f
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4d9e5
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x4da36
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
|
my_scan_8bit:
push rbp
mov rbp, rsp
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_34], eax
sub eax, 1
jz short loc_4D927
jmp short $+2
loc_4D908:
mov eax, [rbp+var_34]
sub eax, 2
jz loc_4D998
jmp short $+2
loc_4D916:
mov eax, [rbp+var_34]
sub eax, 3
jz loc_4D9E3
jmp loc_4DA2E
loc_4D927:
mov rax, [rbp+var_18]
movsx eax, byte ptr [rax]
cmp eax, 2Eh ; '.'
jnz short loc_4D98B
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
loc_4D93F:
mov rcx, [rbp+var_18]
xor eax, eax
cmp rcx, [rbp+var_20]
mov [rbp+var_35], al
jz short loc_4D95E
mov rax, [rbp+var_18]
movsx eax, byte ptr [rax]
cmp eax, 30h ; '0'
setz al
mov [rbp+var_35], al
loc_4D95E:
mov al, [rbp+var_35]
test al, 1
jnz short loc_4D967
jmp short loc_4D977
loc_4D967:
jmp short $+2
loc_4D969:
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
jmp short loc_4D93F
loc_4D977:
mov rax, [rbp+var_18]
mov rcx, [rbp+var_30]
sub rax, rcx
mov [rbp+var_8], rax
jmp loc_4DA36
loc_4D98B:
mov [rbp+var_8], 0
jmp loc_4DA36
loc_4D998:
jmp short $+2
loc_4D99A:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jnb short loc_4D9D2
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx+1]
and eax, 8
cmp eax, 0
jnz short loc_4D9C2
jmp short loc_4D9D2
loc_4D9C2:
jmp short $+2
loc_4D9C4:
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
jmp short loc_4D99A
loc_4D9D2:
mov rax, [rbp+var_18]
mov rcx, [rbp+var_30]
sub rax, rcx
mov [rbp+var_8], rax
jmp short loc_4DA36
loc_4D9E3:
jmp short $+2
loc_4D9E5:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jnb short loc_4DA1D
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx+1]
and eax, 8
cmp eax, 0
jz short loc_4DA0D
jmp short loc_4DA1D
loc_4DA0D:
jmp short $+2
loc_4DA0F:
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
jmp short loc_4D9E5
loc_4DA1D:
mov rax, [rbp+var_18]
mov rcx, [rbp+var_30]
sub rax, rcx
mov [rbp+var_8], rax
jmp short loc_4DA36
loc_4DA2E:
mov [rbp+var_8], 0
loc_4DA36:
mov rax, [rbp+var_8]
pop rbp
retn
|
long long my_scan_8bit(long long a1, unsigned __int8 *a2, unsigned __int8 *a3, int a4)
{
bool v5; // [rsp+1h] [rbp-35h]
unsigned __int8 *v6; // [rsp+1Eh] [rbp-18h]
unsigned __int8 *i; // [rsp+1Eh] [rbp-18h]
v6 = a2;
switch ( a4 )
{
case 1:
if ( *a2 == 46 )
{
for ( i = a2 + 1; ; ++i )
{
v5 = 0;
if ( i != a3 )
v5 = *i == 48;
if ( !v5 )
break;
}
return i - a2;
}
else
{
return 0LL;
}
case 2:
while ( v6 < a3 && (*(_BYTE *)(*(_QWORD *)(a1 + 64) + *v6 + 1LL) & 8) != 0 )
++v6;
return v6 - a2;
case 3:
while ( v6 < a3 && (*(_BYTE *)(*(_QWORD *)(a1 + 64) + *v6 + 1LL) & 8) == 0 )
++v6;
return v6 - a2;
default:
return 0LL;
}
}
|
my_scan_8bit:
PUSH RBP
MOV RBP,RSP
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 + -0x34],EAX
SUB EAX,0x1
JZ 0x0014d927
JMP 0x0014d908
LAB_0014d908:
MOV EAX,dword ptr [RBP + -0x34]
SUB EAX,0x2
JZ 0x0014d998
JMP 0x0014d916
LAB_0014d916:
MOV EAX,dword ptr [RBP + -0x34]
SUB EAX,0x3
JZ 0x0014d9e3
JMP 0x0014da2e
LAB_0014d927:
MOV RAX,qword ptr [RBP + -0x18]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2e
JNZ 0x0014d98b
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
LAB_0014d93f:
MOV RCX,qword ptr [RBP + -0x18]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x20]
MOV byte ptr [RBP + -0x35],AL
JZ 0x0014d95e
MOV RAX,qword ptr [RBP + -0x18]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x30
SETZ AL
MOV byte ptr [RBP + -0x35],AL
LAB_0014d95e:
MOV AL,byte ptr [RBP + -0x35]
TEST AL,0x1
JNZ 0x0014d967
JMP 0x0014d977
LAB_0014d967:
JMP 0x0014d969
LAB_0014d969:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0014d93f
LAB_0014d977:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x30]
SUB RAX,RCX
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0014da36
LAB_0014d98b:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0014da36
LAB_0014d998:
JMP 0x0014d99a
LAB_0014d99a:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JNC 0x0014d9d2
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX]
MOVZX EAX,byte ptr [RAX + RCX*0x1 + 0x1]
AND EAX,0x8
CMP EAX,0x0
JNZ 0x0014d9c2
JMP 0x0014d9d2
LAB_0014d9c2:
JMP 0x0014d9c4
LAB_0014d9c4:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0014d99a
LAB_0014d9d2:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x30]
SUB RAX,RCX
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0014da36
LAB_0014d9e3:
JMP 0x0014d9e5
LAB_0014d9e5:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JNC 0x0014da1d
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX]
MOVZX EAX,byte ptr [RAX + RCX*0x1 + 0x1]
AND EAX,0x8
CMP EAX,0x0
JZ 0x0014da0d
JMP 0x0014da1d
LAB_0014da0d:
JMP 0x0014da0f
LAB_0014da0f:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0014d9e5
LAB_0014da1d:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x30]
SUB RAX,RCX
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0014da36
LAB_0014da2e:
MOV qword ptr [RBP + -0x8],0x0
LAB_0014da36:
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
long my_scan_8bit(long param_1,byte *param_2,byte *param_3,int param_4)
{
bool bVar1;
byte *local_20;
long local_10;
if (param_4 == 1) {
if (*param_2 == 0x2e) {
local_20 = param_2 + 1;
while( true ) {
bVar1 = false;
if (local_20 != param_3) {
bVar1 = *local_20 == 0x30;
}
if (!bVar1) break;
local_20 = local_20 + 1;
}
local_10 = (long)local_20 - (long)param_2;
}
else {
local_10 = 0;
}
}
else {
local_20 = param_2;
if (param_4 == 2) {
while ((local_20 < param_3 &&
((*(byte *)(*(long *)(param_1 + 0x40) + 1 + (ulong)*local_20) & 8) != 0))) {
local_20 = local_20 + 1;
}
local_10 = (long)local_20 - (long)param_2;
}
else if (param_4 == 3) {
while ((local_20 < param_3 &&
((*(byte *)(*(long *)(param_1 + 0x40) + 1 + (ulong)*local_20) & 8) == 0))) {
local_20 = local_20 + 1;
}
local_10 = (long)local_20 - (long)param_2;
}
else {
local_10 = 0;
}
}
return local_10;
}
|
|
11,729 |
my_scan_8bit
|
eloqsql/strings/ctype-simple.c
|
size_t my_scan_8bit(CHARSET_INFO *cs, const char *str, const char *end, int sq)
{
const char *str0= str;
switch (sq)
{
case MY_SEQ_INTTAIL:
if (*str == '.')
{
for(str++ ; str != end && *str == '0' ; str++);
return (size_t) (str - str0);
}
return 0;
case MY_SEQ_SPACES:
for ( ; str < end ; str++)
{
if (!my_isspace(cs,*str))
break;
}
return (size_t) (str - str0);
case MY_SEQ_NONSPACES:
for ( ; str < end ; str++)
{
if (my_isspace(cs, *str))
break;
}
return (size_t) (str - str0);
default:
return 0;
}
}
|
O3
|
c
|
my_scan_8bit:
pushq %rbp
movq %rsp, %rbp
movq %rdx, %rax
cmpl $0x1, %ecx
je 0x3e086
cmpl $0x2, %ecx
je 0x3e05a
cmpl $0x3, %ecx
jne 0x3e0ab
movq %rsi, %rcx
cmpq %rax, %rsi
jae 0x3e07e
movq 0x40(%rdi), %rdx
movq %rsi, %rcx
movzbl (%rcx), %edi
testb $0x8, 0x1(%rdx,%rdi)
jne 0x3e07e
incq %rcx
cmpq %rax, %rcx
jne 0x3e046
jmp 0x3e07b
movq %rsi, %rcx
cmpq %rax, %rsi
jae 0x3e07e
movq 0x40(%rdi), %rdx
movq %rsi, %rcx
movzbl (%rcx), %edi
testb $0x8, 0x1(%rdx,%rdi)
je 0x3e07e
incq %rcx
cmpq %rax, %rcx
jne 0x3e069
movq %rax, %rcx
subq %rsi, %rcx
movq %rcx, %rax
jmp 0x3e0ad
cmpb $0x2e, (%rsi)
jne 0x3e0ab
leaq 0x1(%rsi), %rcx
cmpq %rax, %rcx
je 0x3e0a6
leaq 0x1(%rcx), %rdx
cmpb $0x30, (%rcx)
movq %rdx, %rcx
je 0x3e08f
decq %rdx
movq %rdx, %rax
subq %rsi, %rax
jmp 0x3e0ad
xorl %eax, %eax
popq %rbp
retq
|
my_scan_8bit:
push rbp
mov rbp, rsp
mov rax, rdx
cmp ecx, 1
jz short loc_3E086
cmp ecx, 2
jz short loc_3E05A
cmp ecx, 3
jnz short loc_3E0AB
mov rcx, rsi
cmp rsi, rax
jnb short loc_3E07E
mov rdx, [rdi+40h]
mov rcx, rsi
loc_3E046:
movzx edi, byte ptr [rcx]
test byte ptr [rdx+rdi+1], 8
jnz short loc_3E07E
inc rcx
cmp rcx, rax
jnz short loc_3E046
jmp short loc_3E07B
loc_3E05A:
mov rcx, rsi
cmp rsi, rax
jnb short loc_3E07E
mov rdx, [rdi+40h]
mov rcx, rsi
loc_3E069:
movzx edi, byte ptr [rcx]
test byte ptr [rdx+rdi+1], 8
jz short loc_3E07E
inc rcx
cmp rcx, rax
jnz short loc_3E069
loc_3E07B:
mov rcx, rax
loc_3E07E:
sub rcx, rsi
mov rax, rcx
jmp short loc_3E0AD
loc_3E086:
cmp byte ptr [rsi], 2Eh ; '.'
jnz short loc_3E0AB
lea rcx, [rsi+1]
loc_3E08F:
cmp rcx, rax
jz short loc_3E0A6
lea rdx, [rcx+1]
cmp byte ptr [rcx], 30h ; '0'
mov rcx, rdx
jz short loc_3E08F
dec rdx
mov rax, rdx
loc_3E0A6:
sub rax, rsi
jmp short loc_3E0AD
loc_3E0AB:
xor eax, eax
loc_3E0AD:
pop rbp
retn
|
long long my_scan_8bit(long long a1, unsigned __int8 *a2, unsigned __int8 *a3, int a4)
{
unsigned __int8 *v4; // rax
unsigned __int8 *v5; // rcx
unsigned __int8 *v7; // rcx
_BYTE *v8; // rdx
v4 = a3;
if ( a4 != 1 )
{
if ( a4 == 2 )
{
v5 = a2;
if ( a2 < a3 )
{
v5 = a2;
while ( (*(_BYTE *)(*(_QWORD *)(a1 + 64) + *v5 + 1LL) & 8) != 0 )
{
if ( ++v5 == a3 )
{
LABEL_13:
v5 = a3;
return v5 - a2;
}
}
}
return v5 - a2;
}
if ( a4 == 3 )
{
v5 = a2;
if ( a2 < a3 )
{
v5 = a2;
while ( (*(_BYTE *)(*(_QWORD *)(a1 + 64) + *v5 + 1LL) & 8) == 0 )
{
if ( ++v5 == a3 )
goto LABEL_13;
}
}
return v5 - a2;
}
return 0LL;
}
if ( *a2 != 46 )
return 0LL;
v7 = a2 + 1;
while ( v7 != v4 )
{
v8 = v7 + 1;
if ( *v7++ != 48 )
{
v4 = v8 - 1;
return v4 - a2;
}
}
return v4 - a2;
}
|
my_scan_8bit:
PUSH RBP
MOV RBP,RSP
MOV RAX,RDX
CMP ECX,0x1
JZ 0x0013e086
CMP ECX,0x2
JZ 0x0013e05a
CMP ECX,0x3
JNZ 0x0013e0ab
MOV RCX,RSI
CMP RSI,RAX
JNC 0x0013e07e
MOV RDX,qword ptr [RDI + 0x40]
MOV RCX,RSI
LAB_0013e046:
MOVZX EDI,byte ptr [RCX]
TEST byte ptr [RDX + RDI*0x1 + 0x1],0x8
JNZ 0x0013e07e
INC RCX
CMP RCX,RAX
JNZ 0x0013e046
JMP 0x0013e07b
LAB_0013e05a:
MOV RCX,RSI
CMP RSI,RAX
JNC 0x0013e07e
MOV RDX,qword ptr [RDI + 0x40]
MOV RCX,RSI
LAB_0013e069:
MOVZX EDI,byte ptr [RCX]
TEST byte ptr [RDX + RDI*0x1 + 0x1],0x8
JZ 0x0013e07e
INC RCX
CMP RCX,RAX
JNZ 0x0013e069
LAB_0013e07b:
MOV RCX,RAX
LAB_0013e07e:
SUB RCX,RSI
MOV RAX,RCX
JMP 0x0013e0ad
LAB_0013e086:
CMP byte ptr [RSI],0x2e
JNZ 0x0013e0ab
LEA RCX,[RSI + 0x1]
LAB_0013e08f:
CMP RCX,RAX
JZ 0x0013e0a6
LEA RDX,[RCX + 0x1]
CMP byte ptr [RCX],0x30
MOV RCX,RDX
JZ 0x0013e08f
DEC RDX
MOV RAX,RDX
LAB_0013e0a6:
SUB RAX,RSI
JMP 0x0013e0ad
LAB_0013e0ab:
XOR EAX,EAX
LAB_0013e0ad:
POP RBP
RET
|
long my_scan_8bit(long param_1,byte *param_2,byte *param_3,int param_4)
{
byte bVar1;
byte *pbVar2;
long lVar3;
byte *pbVar4;
if (param_4 == 1) {
if (*param_2 == 0x2e) {
pbVar4 = param_2 + 1;
do {
pbVar2 = param_3;
if (pbVar4 == param_3) break;
bVar1 = *pbVar4;
pbVar2 = pbVar4;
pbVar4 = pbVar4 + 1;
} while (bVar1 == 0x30);
return (long)pbVar2 - (long)param_2;
}
LAB_0013e0ab:
lVar3 = 0;
}
else {
pbVar4 = param_2;
if (param_4 == 2) {
if (param_2 < param_3) {
pbVar2 = param_2;
do {
pbVar4 = pbVar2;
if ((*(byte *)(*(long *)(param_1 + 0x40) + 1 + (ulong)*pbVar2) & 8) == 0) break;
pbVar2 = pbVar2 + 1;
pbVar4 = param_3;
} while (pbVar2 != param_3);
}
}
else {
if (param_4 != 3) goto LAB_0013e0ab;
if (param_2 < param_3) {
pbVar2 = param_2;
do {
pbVar4 = pbVar2;
if ((*(byte *)(*(long *)(param_1 + 0x40) + 1 + (ulong)*pbVar2) & 8) != 0) break;
pbVar2 = pbVar2 + 1;
pbVar4 = param_3;
} while (pbVar2 != param_3);
}
}
lVar3 = (long)pbVar4 - (long)param_2;
}
return lVar3;
}
|
|
11,730 |
my_append_fix_badly_formed_tail
|
eloqsql/strings/ctype-mb.c
|
static size_t
my_append_fix_badly_formed_tail(CHARSET_INFO *cs,
char *to, char *to_end,
const char *from, const char *from_end,
size_t nchars,
MY_STRCOPY_STATUS *status)
{
char *to0= to;
for ( ; nchars; nchars--)
{
int chlen;
if ((chlen= my_ci_charlen(cs, (const uchar*) from,
(const uchar *) from_end)) > 0)
{
/* Found a valid character */ /* chlen == 1..MBMAXLEN */
DBUG_ASSERT(chlen <= (int) cs->mbmaxlen);
if (to + chlen > to_end)
goto end; /* Does not fit to "to" */
memcpy(to, from, (size_t) chlen);
from+= chlen;
to+= chlen;
continue;
}
if (chlen == MY_CS_ILSEQ) /* chlen == 0 */
{
DBUG_ASSERT(from < from_end); /* Shouldn't get MY_CS_ILSEQ if empty */
goto bad;
}
/* Got an incomplete character */ /* chlen == MY_CS_TOOSMALLXXX */
DBUG_ASSERT(chlen >= MY_CS_TOOSMALL6);
DBUG_ASSERT(chlen <= MY_CS_TOOSMALL);
if (from >= from_end)
break; /* End of the source string */
bad:
/* Bad byte sequence, or incomplete character found */
if (!status->m_well_formed_error_pos)
status->m_well_formed_error_pos= from;
if ((chlen= my_ci_wc_mb(cs, '?', (uchar*) to, (uchar *) to_end)) <= 0)
break; /* Question mark does not fit into the destination */
to+= chlen;
from++;
}
end:
status->m_source_end_pos= from;
return to - to0;
}
|
O0
|
c
|
my_append_fix_badly_formed_tail:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x79cb5
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x792c0
movl %eax, -0x3c(%rbp)
cmpl $0x0, %eax
jle 0x79c22
jmp 0x79bd2
jmp 0x79bd4
movq -0x10(%rbp), %rax
movslq -0x3c(%rbp), %rcx
addq %rcx, %rax
cmpq -0x18(%rbp), %rax
jbe 0x79bea
jmp 0x79cb7
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movslq -0x3c(%rbp), %rdx
callq 0x26280
movl -0x3c(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x3c(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x79ca4
cmpl $0x0, -0x3c(%rbp)
jne 0x79c2e
jmp 0x79c2a
jmp 0x79c2c
jmp 0x79c44
jmp 0x79c30
jmp 0x79c32
jmp 0x79c34
jmp 0x79c36
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x79c42
jmp 0x79cb5
jmp 0x79c44
movq 0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x79c5b
movq -0x20(%rbp), %rcx
movq 0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0xb8(%rax), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x3f, %esi
callq *%rax
movl %eax, -0x3c(%rbp)
cmpl $0x0, %eax
jg 0x79c87
jmp 0x79cb5
movl -0x3c(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x79bac
jmp 0x79cb7
movq -0x20(%rbp), %rcx
movq 0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
subq %rcx, %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_append_fix_badly_formed_tail:
push rbp
mov rbp, rsp
sub rsp, 40h
mov rax, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov rax, [rbp+var_10]
mov [rbp+var_38], rax
loc_79BAC:
cmp [rbp+var_30], 0
jz loc_79CB5
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_28]
call my_ci_charlen_2
mov [rbp+var_3C], eax
cmp eax, 0
jle short loc_79C22
jmp short $+2
loc_79BD2:
jmp short $+2
loc_79BD4:
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_3C]
add rax, rcx
cmp rax, [rbp+var_18]
jbe short loc_79BEA
jmp loc_79CB7
loc_79BEA:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
movsxd rdx, [rbp+var_3C]
call _memcpy
mov ecx, [rbp+var_3C]
mov rax, [rbp+var_20]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_20], rax
mov ecx, [rbp+var_3C]
mov rax, [rbp+var_10]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_10], rax
jmp loc_79CA4
loc_79C22:
cmp [rbp+var_3C], 0
jnz short loc_79C2E
jmp short $+2
loc_79C2A:
jmp short $+2
loc_79C2C:
jmp short loc_79C44
loc_79C2E:
jmp short $+2
loc_79C30:
jmp short $+2
loc_79C32:
jmp short $+2
loc_79C34:
jmp short $+2
loc_79C36:
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jb short loc_79C42
jmp short loc_79CB5
loc_79C42:
jmp short $+2
loc_79C44:
mov rax, [rbp+arg_0]
cmp qword ptr [rax+8], 0
jnz short loc_79C5B
mov rcx, [rbp+var_20]
mov rax, [rbp+arg_0]
mov [rax+8], rcx
loc_79C5B:
mov rax, [rbp+var_8]
mov rax, [rax+0B8h]
mov rax, [rax+30h]
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_18]
mov esi, 3Fh ; '?'
call rax
mov [rbp+var_3C], eax
cmp eax, 0
jg short loc_79C87
jmp short loc_79CB5
loc_79C87:
mov ecx, [rbp+var_3C]
mov rax, [rbp+var_10]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_10], rax
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_20], rax
loc_79CA4:
mov rax, [rbp+var_30]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_30], rax
jmp loc_79BAC
loc_79CB5:
jmp short $+2
loc_79CB7:
mov rcx, [rbp+var_20]
mov rax, [rbp+arg_0]
mov [rax], rcx
mov rax, [rbp+var_10]
mov rcx, [rbp+var_38]
sub rax, rcx
add rsp, 40h
pop rbp
retn
|
long long my_append_fix_badly_formed_tail(
long long a1,
long long a2,
unsigned long long a3,
unsigned long long a4,
unsigned long long a5,
long long a6,
unsigned long long *a7)
{
int v8; // [rsp+4h] [rbp-3Ch]
int v9; // [rsp+4h] [rbp-3Ch]
long long v14; // [rsp+30h] [rbp-10h]
v14 = a2;
while ( a6 )
{
v8 = my_ci_charlen_2(a1, a4, a5);
if ( v8 <= 0 )
{
if ( v8 && a4 >= a5 )
break;
if ( !a7[1] )
a7[1] = a4;
v9 = (*(long long ( **)(long long, long long, long long, unsigned long long))(*(_QWORD *)(a1 + 184) + 48LL))(
a1,
63LL,
v14,
a3);
if ( v9 <= 0 )
break;
v14 += v9;
++a4;
}
else
{
if ( v8 + v14 > a3 )
break;
memcpy(v14, a4, v8);
a4 += v8;
v14 += v8;
}
--a6;
}
*a7 = a4;
return v14 - a2;
}
|
my_append_fix_badly_formed_tail:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x38],RAX
LAB_00179bac:
CMP qword ptr [RBP + -0x30],0x0
JZ 0x00179cb5
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x28]
CALL 0x001792c0
MOV dword ptr [RBP + -0x3c],EAX
CMP EAX,0x0
JLE 0x00179c22
JMP 0x00179bd2
LAB_00179bd2:
JMP 0x00179bd4
LAB_00179bd4:
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x3c]
ADD RAX,RCX
CMP RAX,qword ptr [RBP + -0x18]
JBE 0x00179bea
JMP 0x00179cb7
LAB_00179bea:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
MOVSXD RDX,dword ptr [RBP + -0x3c]
CALL 0x00126280
MOV ECX,dword ptr [RBP + -0x3c]
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV ECX,dword ptr [RBP + -0x3c]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
JMP 0x00179ca4
LAB_00179c22:
CMP dword ptr [RBP + -0x3c],0x0
JNZ 0x00179c2e
JMP 0x00179c2a
LAB_00179c2a:
JMP 0x00179c2c
LAB_00179c2c:
JMP 0x00179c44
LAB_00179c2e:
JMP 0x00179c30
LAB_00179c30:
JMP 0x00179c32
LAB_00179c32:
JMP 0x00179c34
LAB_00179c34:
JMP 0x00179c36
LAB_00179c36:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JC 0x00179c42
JMP 0x00179cb5
LAB_00179c42:
JMP 0x00179c44
LAB_00179c44:
MOV RAX,qword ptr [RBP + 0x10]
CMP qword ptr [RAX + 0x8],0x0
JNZ 0x00179c5b
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
LAB_00179c5b:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RAX + 0x30]
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x18]
MOV ESI,0x3f
CALL RAX
MOV dword ptr [RBP + -0x3c],EAX
CMP EAX,0x0
JG 0x00179c87
JMP 0x00179cb5
LAB_00179c87:
MOV ECX,dword ptr [RBP + -0x3c]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
LAB_00179ca4:
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x30],RAX
JMP 0x00179bac
LAB_00179cb5:
JMP 0x00179cb7
LAB_00179cb7:
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x38]
SUB RAX,RCX
ADD RSP,0x40
POP RBP
RET
|
long my_append_fix_badly_formed_tail
(long param_1,void *param_2,ulong param_3,void *param_4,void *param_5,long param_6,
int8 *param_7)
{
int iVar1;
long local_38;
void *local_28;
void *local_18;
local_28 = param_4;
local_18 = param_2;
for (local_38 = param_6; local_38 != 0; local_38 = local_38 + -1) {
iVar1 = my_ci_charlen(param_1,local_28,param_5);
if (iVar1 < 1) {
if ((iVar1 != 0) && (param_5 <= local_28)) break;
if (param_7[1] == 0) {
param_7[1] = local_28;
}
iVar1 = (**(code **)(*(long *)(param_1 + 0xb8) + 0x30))(param_1,0x3f,local_18,param_3);
if (iVar1 < 1) break;
local_28 = (void *)((long)local_28 + 1);
}
else {
if (param_3 < (ulong)((long)local_18 + (long)iVar1)) break;
memcpy(local_18,local_28,(long)iVar1);
local_28 = (void *)((long)local_28 + (long)iVar1);
}
local_18 = (void *)((long)local_18 + (long)iVar1);
}
*param_7 = local_28;
return (long)local_18 - (long)param_2;
}
|
|
11,731 |
my_caseup_utf16
|
eloqsql/strings/ctype-ucs2.c
|
static size_t
my_caseup_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_toupper_utf16(uni_plane, &wc);
if (res != wc_mb(cs, wc, (uchar *) dst, (uchar *) dstend))
break;
src+= res;
dst+= res;
}
return srclen;
}
|
O3
|
c
|
my_caseup_utf16:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
testq %rdx, %rdx
jle 0x7c5e5
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq 0x78(%rdi), %rax
movq %rax, -0x50(%rbp)
movq 0xb8(%rdi), %rax
movq 0x28(%rax), %rcx
movq %rcx, -0x58(%rbp)
movq 0x30(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
leaq (%rsi,%rax), %r14
addq %r15, -0x38(%rbp)
movq %r13, %rdi
leaq -0x40(%rbp), %rsi
movq %r12, %rdx
movq %r14, %rcx
callq *-0x58(%rbp)
testl %eax, %eax
jle 0x7c5e5
movl %eax, %ebx
movq -0x40(%rbp), %rsi
movq -0x50(%rbp), %rax
cmpq (%rax), %rsi
ja 0x7c5c7
movq 0x8(%rax), %rax
movq %rsi, %rcx
shrq $0x8, %rcx
movq (%rax,%rcx,8), %rax
testq %rax, %rax
je 0x7c5c7
movzbl %sil, %ecx
leaq (%rcx,%rcx,2), %rcx
movl (%rax,%rcx,4), %esi
movq %rsi, -0x40(%rbp)
movq %r13, %rdi
movq %r15, %rdx
movq -0x38(%rbp), %rcx
callq *-0x48(%rbp)
cmpl %eax, %ebx
jne 0x7c5e5
movl %ebx, %eax
addq %rax, %r12
addq %rax, %r15
cmpq %r14, %r12
jb 0x7c581
movq -0x30(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
my_caseup_utf16:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov [rbp+var_38], r8
mov [rbp+var_30], rdx
test rdx, rdx
jle loc_7C5E5
mov r15, rcx
mov r12, rsi
mov r13, rdi
mov rax, [rdi+78h]
mov [rbp+var_50], rax
mov rax, [rdi+0B8h]
mov rcx, [rax+28h]
mov [rbp+var_58], rcx
mov rax, [rax+30h]
mov [rbp+var_48], rax
mov rax, [rbp+var_30]
lea r14, [rsi+rax]
add [rbp+var_38], r15
loc_7C581:
mov rdi, r13
lea rsi, [rbp+var_40]
mov rdx, r12
mov rcx, r14
call [rbp+var_58]
test eax, eax
jle short loc_7C5E5
mov ebx, eax
mov rsi, [rbp+var_40]
mov rax, [rbp+var_50]
cmp rsi, [rax]
ja short loc_7C5C7
mov rax, [rax+8]
mov rcx, rsi
shr rcx, 8
mov rax, [rax+rcx*8]
test rax, rax
jz short loc_7C5C7
movzx ecx, sil
lea rcx, [rcx+rcx*2]
mov esi, [rax+rcx*4]
mov [rbp+var_40], rsi
loc_7C5C7:
mov rdi, r13
mov rdx, r15
mov rcx, [rbp+var_38]
call [rbp+var_48]
cmp ebx, eax
jnz short loc_7C5E5
mov eax, ebx
add r12, rax
add r15, rax
cmp r12, r14
jb short loc_7C581
loc_7C5E5:
mov rax, [rbp+var_30]
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long my_caseup_utf16(long long a1, unsigned long long a2, long long a3, long long a4, long long a5)
{
long long v5; // r15
unsigned long long v6; // r12
long long v7; // rax
unsigned long long v8; // r14
int v9; // eax
unsigned int v10; // ebx
unsigned long long v11; // rsi
long long v12; // rax
long long ( *v14)(long long, unsigned long long *, unsigned long long, unsigned long long); // [rsp+8h] [rbp-58h]
unsigned long long *v15; // [rsp+10h] [rbp-50h]
unsigned int ( *v16)(long long, unsigned long long, long long, long long); // [rsp+18h] [rbp-48h]
unsigned long long v17; // [rsp+20h] [rbp-40h] BYREF
long long v18; // [rsp+28h] [rbp-38h]
long long v19; // [rsp+30h] [rbp-30h]
v18 = a5;
v19 = a3;
if ( a3 > 0 )
{
v5 = a4;
v6 = a2;
v15 = *(unsigned long long **)(a1 + 120);
v7 = *(_QWORD *)(a1 + 184);
v14 = *(long long ( **)(long long, unsigned long long *, unsigned long long, unsigned long long))(v7 + 40);
v16 = *(unsigned int ( **)(long long, unsigned long long, long long, long long))(v7 + 48);
v8 = a2 + v19;
v18 += a4;
do
{
v9 = v14(a1, &v17, v6, v8);
if ( v9 <= 0 )
break;
v10 = v9;
v11 = v17;
if ( v17 <= *v15 )
{
v12 = *(_QWORD *)(v15[1] + 8 * (v17 >> 8));
if ( v12 )
{
v11 = *(unsigned int *)(v12 + 12LL * (unsigned __int8)v17);
v17 = v11;
}
}
if ( v10 != v16(a1, v11, v5, v18) )
break;
v6 += v10;
v5 += v10;
}
while ( v6 < v8 );
}
return v19;
}
|
my_caseup_utf16:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x38],R8
MOV qword ptr [RBP + -0x30],RDX
TEST RDX,RDX
JLE 0x0017c5e5
MOV R15,RCX
MOV R12,RSI
MOV R13,RDI
MOV RAX,qword ptr [RDI + 0x78]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RDI + 0xb8]
MOV RCX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x58],RCX
MOV RAX,qword ptr [RAX + 0x30]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x30]
LEA R14,[RSI + RAX*0x1]
ADD qword ptr [RBP + -0x38],R15
LAB_0017c581:
MOV RDI,R13
LEA RSI,[RBP + -0x40]
MOV RDX,R12
MOV RCX,R14
CALL qword ptr [RBP + -0x58]
TEST EAX,EAX
JLE 0x0017c5e5
MOV EBX,EAX
MOV RSI,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x50]
CMP RSI,qword ptr [RAX]
JA 0x0017c5c7
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,RSI
SHR RCX,0x8
MOV RAX,qword ptr [RAX + RCX*0x8]
TEST RAX,RAX
JZ 0x0017c5c7
MOVZX ECX,SIL
LEA RCX,[RCX + RCX*0x2]
MOV ESI,dword ptr [RAX + RCX*0x4]
MOV qword ptr [RBP + -0x40],RSI
LAB_0017c5c7:
MOV RDI,R13
MOV RDX,R15
MOV RCX,qword ptr [RBP + -0x38]
CALL qword ptr [RBP + -0x48]
CMP EBX,EAX
JNZ 0x0017c5e5
MOV EAX,EBX
ADD R12,RAX
ADD R15,RAX
CMP R12,R14
JC 0x0017c581
LAB_0017c5e5:
MOV RAX,qword ptr [RBP + -0x30]
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long my_caseup_utf16(long param_1,ulong param_2,long param_3,long param_4,long param_5)
{
ulong uVar1;
ulong *puVar2;
code *pcVar3;
code *pcVar4;
long lVar5;
uint uVar6;
uint uVar7;
ulong local_48;
long local_40;
long local_38;
local_38 = param_3;
if (0 < param_3) {
puVar2 = *(ulong **)(param_1 + 0x78);
pcVar3 = *(code **)(*(long *)(param_1 + 0xb8) + 0x28);
pcVar4 = *(code **)(*(long *)(param_1 + 0xb8) + 0x30);
uVar1 = param_2 + param_3;
local_40 = param_5 + param_4;
do {
uVar6 = (*pcVar3)(param_1,&local_48,param_2,uVar1);
if ((int)uVar6 < 1) {
return local_38;
}
if ((local_48 <= *puVar2) && (lVar5 = *(long *)(puVar2[1] + (local_48 >> 8) * 8), lVar5 != 0))
{
local_48 = (ulong)*(uint *)(lVar5 + (local_48 & 0xff) * 0xc);
}
uVar7 = (*pcVar4)(param_1,local_48,param_4,local_40);
if (uVar6 != uVar7) {
return local_38;
}
param_2 = param_2 + uVar6;
param_4 = param_4 + (ulong)uVar6;
} while (param_2 < uVar1);
}
return local_38;
}
|
|
11,732 |
LefDefParser::defiPinPort::addPolygon(char const*)
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defiPinCap.cpp
|
void defiPinPort::addPolygon(const char* layerName) {
int *pms, *pdw, *pm;
int i;
if (numPolys_ == polysAllocated_) {
char** newn;
struct defiPoints** poly;
polysAllocated_ = (polysAllocated_ == 0) ?
2 : polysAllocated_ * 2;
newn = (char**)malloc(sizeof(char*) * polysAllocated_);
poly = (struct defiPoints**)malloc(sizeof(struct defiPoints*) *
polysAllocated_);
pms = (int*)malloc(polysAllocated_ * sizeof(int));
pdw = (int*)malloc(polysAllocated_ * sizeof(int));
pm = (int*)malloc(polysAllocated_ * sizeof(int));
for (i = 0; i < numPolys_; i++) {
newn[i] = polygonNames_[i];
poly[i] = polygons_[i];
pms[i] = polyMinSpacing_[i];
pdw[i] = polyEffectiveWidth_[i];
pm[i] = polyMask_[i];
}
if (numPolys_ > 0) {
free((char*)(polygons_));
free((char*)(polygonNames_));
free((char*)(polyMinSpacing_));
free((char*)(polyEffectiveWidth_));
free((char*)(polyMask_));
}
polygonNames_ = newn;
polygons_ = poly;
polyMinSpacing_ = pms;
polyEffectiveWidth_ = pdw;
polyMask_ = pm;
}
polygonNames_[numPolys_] = strdup(layerName);
polygons_[numPolys_] = 0;
polyMinSpacing_[numPolys_] = -1;
polyEffectiveWidth_[numPolys_] = -1;
polyMask_[numPolys_] = 0;
numPolys_ += 1;
}
|
O0
|
cpp
|
LefDefParser::defiPinPort::addPolygon(char const*):
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movl 0x4c(%rcx), %eax
cmpl 0x48(%rcx), %eax
jne 0x2c711
movq 0x10(%rsp), %rax
cmpl $0x0, 0x48(%rax)
jne 0x2c54a
movl $0x2, %eax
movl %eax, 0xc(%rsp)
jmp 0x2c558
movq 0x10(%rsp), %rax
movl 0x48(%rax), %eax
shll %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
movl %ecx, 0x48(%rax)
movslq 0x48(%rax), %rdi
shlq $0x3, %rdi
callq 0x72d0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rsp)
movslq 0x48(%rax), %rdi
shlq $0x3, %rdi
callq 0x72d0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rsp)
movslq 0x48(%rax), %rdi
shlq $0x2, %rdi
callq 0x72d0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x40(%rsp)
movslq 0x48(%rax), %rdi
shlq $0x2, %rdi
callq 0x72d0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x38(%rsp)
movslq 0x48(%rax), %rdi
shlq $0x2, %rdi
callq 0x72d0
movq %rax, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x10(%rsp), %rcx
movl 0x2c(%rsp), %eax
cmpl 0x4c(%rcx), %eax
jge 0x2c68e
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rcx
movslq 0x2c(%rsp), %rdx
movq (%rcx,%rdx,8), %rsi
movq 0x20(%rsp), %rcx
movslq 0x2c(%rsp), %rdx
movq %rsi, (%rcx,%rdx,8)
movq 0x70(%rax), %rcx
movslq 0x2c(%rsp), %rdx
movq (%rcx,%rdx,8), %rsi
movq 0x18(%rsp), %rcx
movslq 0x2c(%rsp), %rdx
movq %rsi, (%rcx,%rdx,8)
movq 0x58(%rax), %rcx
movslq 0x2c(%rsp), %rdx
movl (%rcx,%rdx,4), %esi
movq 0x40(%rsp), %rcx
movslq 0x2c(%rsp), %rdx
movl %esi, (%rcx,%rdx,4)
movq 0x68(%rax), %rcx
movslq 0x2c(%rsp), %rdx
movl (%rcx,%rdx,4), %esi
movq 0x38(%rsp), %rcx
movslq 0x2c(%rsp), %rdx
movl %esi, (%rcx,%rdx,4)
movq 0x60(%rax), %rax
movslq 0x2c(%rsp), %rcx
movl (%rax,%rcx,4), %edx
movq 0x30(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x2c5e6
movq 0x10(%rsp), %rax
cmpl $0x0, 0x4c(%rax)
jle 0x2c6df
movq 0x10(%rsp), %rax
movq 0x70(%rax), %rdi
callq 0x72a0
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rdi
callq 0x72a0
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rdi
callq 0x72a0
movq 0x10(%rsp), %rax
movq 0x68(%rax), %rdi
callq 0x72a0
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rdi
callq 0x72a0
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, 0x50(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x70(%rax)
movq 0x40(%rsp), %rcx
movq %rcx, 0x58(%rax)
movq 0x38(%rsp), %rcx
movq %rcx, 0x68(%rax)
movq 0x30(%rsp), %rcx
movq %rcx, 0x60(%rax)
movq 0x48(%rsp), %rdi
callq 0x73d0
movq %rax, %rsi
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rcx
movslq 0x4c(%rax), %rdx
movq %rsi, (%rcx,%rdx,8)
movq 0x70(%rax), %rcx
movslq 0x4c(%rax), %rdx
movq $0x0, (%rcx,%rdx,8)
movq 0x58(%rax), %rcx
movslq 0x4c(%rax), %rdx
movl $0xffffffff, (%rcx,%rdx,4) # imm = 0xFFFFFFFF
movq 0x68(%rax), %rcx
movslq 0x4c(%rax), %rdx
movl $0xffffffff, (%rcx,%rdx,4) # imm = 0xFFFFFFFF
movq 0x60(%rax), %rcx
movslq 0x4c(%rax), %rdx
movl $0x0, (%rcx,%rdx,4)
movl 0x4c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4c(%rax)
addq $0x58, %rsp
retq
nopw (%rax,%rax)
|
_ZN12LefDefParser11defiPinPort10addPolygonEPKc:
sub rsp, 58h
mov [rsp+58h+var_8], rdi
mov [rsp+58h+var_10], rsi
mov rcx, [rsp+58h+var_8]
mov [rsp+58h+var_48], rcx
mov eax, [rcx+4Ch]
cmp eax, [rcx+48h]
jnz loc_2C711
mov rax, [rsp+58h+var_48]
cmp dword ptr [rax+48h], 0
jnz short loc_2C54A
mov eax, 2
mov [rsp+58h+var_4C], eax
jmp short loc_2C558
loc_2C54A:
mov rax, [rsp+58h+var_48]
mov eax, [rax+48h]
shl eax, 1
mov [rsp+58h+var_4C], eax
loc_2C558:
mov rax, [rsp+58h+var_48]
mov ecx, [rsp+58h+var_4C]
mov [rax+48h], ecx
movsxd rdi, dword ptr [rax+48h]
shl rdi, 3
call _malloc
mov rcx, rax
mov rax, [rsp+58h+var_48]
mov [rsp+58h+var_38], rcx
movsxd rdi, dword ptr [rax+48h]
shl rdi, 3
call _malloc
mov rcx, rax
mov rax, [rsp+58h+var_48]
mov [rsp+58h+var_40], rcx
movsxd rdi, dword ptr [rax+48h]
shl rdi, 2
call _malloc
mov rcx, rax
mov rax, [rsp+58h+var_48]
mov [rsp+58h+var_18], rcx
movsxd rdi, dword ptr [rax+48h]
shl rdi, 2
call _malloc
mov rcx, rax
mov rax, [rsp+58h+var_48]
mov [rsp+58h+var_20], rcx
movsxd rdi, dword ptr [rax+48h]
shl rdi, 2
call _malloc
mov [rsp+58h+var_28], rax
mov [rsp+58h+var_2C], 0
loc_2C5E6:
mov rcx, [rsp+58h+var_48]
mov eax, [rsp+58h+var_2C]
cmp eax, [rcx+4Ch]
jge loc_2C68E
mov rax, [rsp+58h+var_48]
mov rcx, [rax+50h]
movsxd rdx, [rsp+58h+var_2C]
mov rsi, [rcx+rdx*8]
mov rcx, [rsp+58h+var_38]
movsxd rdx, [rsp+58h+var_2C]
mov [rcx+rdx*8], rsi
mov rcx, [rax+70h]
movsxd rdx, [rsp+58h+var_2C]
mov rsi, [rcx+rdx*8]
mov rcx, [rsp+58h+var_40]
movsxd rdx, [rsp+58h+var_2C]
mov [rcx+rdx*8], rsi
mov rcx, [rax+58h]
movsxd rdx, [rsp+58h+var_2C]
mov esi, [rcx+rdx*4]
mov rcx, [rsp+58h+var_18]
movsxd rdx, [rsp+58h+var_2C]
mov [rcx+rdx*4], esi
mov rcx, [rax+68h]
movsxd rdx, [rsp+58h+var_2C]
mov esi, [rcx+rdx*4]
mov rcx, [rsp+58h+var_20]
movsxd rdx, [rsp+58h+var_2C]
mov [rcx+rdx*4], esi
mov rax, [rax+60h]
movsxd rcx, [rsp+58h+var_2C]
mov edx, [rax+rcx*4]
mov rax, [rsp+58h+var_28]
movsxd rcx, [rsp+58h+var_2C]
mov [rax+rcx*4], edx
mov eax, [rsp+58h+var_2C]
add eax, 1
mov [rsp+58h+var_2C], eax
jmp loc_2C5E6
loc_2C68E:
mov rax, [rsp+58h+var_48]
cmp dword ptr [rax+4Ch], 0
jle short loc_2C6DF
mov rax, [rsp+58h+var_48]
mov rdi, [rax+70h]
call _free
mov rax, [rsp+58h+var_48]
mov rdi, [rax+50h]
call _free
mov rax, [rsp+58h+var_48]
mov rdi, [rax+58h]
call _free
mov rax, [rsp+58h+var_48]
mov rdi, [rax+68h]
call _free
mov rax, [rsp+58h+var_48]
mov rdi, [rax+60h]
call _free
loc_2C6DF:
mov rax, [rsp+58h+var_48]
mov rcx, [rsp+58h+var_38]
mov [rax+50h], rcx
mov rcx, [rsp+58h+var_40]
mov [rax+70h], rcx
mov rcx, [rsp+58h+var_18]
mov [rax+58h], rcx
mov rcx, [rsp+58h+var_20]
mov [rax+68h], rcx
mov rcx, [rsp+58h+var_28]
mov [rax+60h], rcx
loc_2C711:
mov rdi, [rsp+58h+var_10]
call _strdup
mov rsi, rax
mov rax, [rsp+58h+var_48]
mov rcx, [rax+50h]
movsxd rdx, dword ptr [rax+4Ch]
mov [rcx+rdx*8], rsi
mov rcx, [rax+70h]
movsxd rdx, dword ptr [rax+4Ch]
mov qword ptr [rcx+rdx*8], 0
mov rcx, [rax+58h]
movsxd rdx, dword ptr [rax+4Ch]
mov dword ptr [rcx+rdx*4], 0FFFFFFFFh
mov rcx, [rax+68h]
movsxd rdx, dword ptr [rax+4Ch]
mov dword ptr [rcx+rdx*4], 0FFFFFFFFh
mov rcx, [rax+60h]
movsxd rdx, dword ptr [rax+4Ch]
mov dword ptr [rcx+rdx*4], 0
mov ecx, [rax+4Ch]
add ecx, 1
mov [rax+4Ch], ecx
add rsp, 58h
retn
|
LefDefParser::defiPinPort * LefDefParser::defiPinPort::addPolygon(
LefDefParser::defiPinPort *this,
const char *a2)
{
long long v2; // rsi
LefDefParser::defiPinPort *result; // rax
int v4; // [rsp+Ch] [rbp-4Ch]
long long v5; // [rsp+18h] [rbp-40h]
long long v6; // [rsp+20h] [rbp-38h]
int i; // [rsp+2Ch] [rbp-2Ch]
long long v8; // [rsp+30h] [rbp-28h]
long long v9; // [rsp+38h] [rbp-20h]
long long v10; // [rsp+40h] [rbp-18h]
if ( *((_DWORD *)this + 19) == *((_DWORD *)this + 18) )
{
if ( *((_DWORD *)this + 18) )
v4 = 2 * *((_DWORD *)this + 18);
else
v4 = 2;
*((_DWORD *)this + 18) = v4;
v6 = malloc(8LL * *((int *)this + 18));
v5 = malloc(8LL * *((int *)this + 18));
v10 = malloc(4LL * *((int *)this + 18));
v9 = malloc(4LL * *((int *)this + 18));
v8 = malloc(4LL * *((int *)this + 18));
for ( i = 0; i < *((_DWORD *)this + 19); ++i )
{
*(_QWORD *)(v6 + 8LL * i) = *(_QWORD *)(*((_QWORD *)this + 10) + 8LL * i);
*(_QWORD *)(v5 + 8LL * i) = *(_QWORD *)(*((_QWORD *)this + 14) + 8LL * i);
*(_DWORD *)(v10 + 4LL * i) = *(_DWORD *)(*((_QWORD *)this + 11) + 4LL * i);
*(_DWORD *)(v9 + 4LL * i) = *(_DWORD *)(*((_QWORD *)this + 13) + 4LL * i);
*(_DWORD *)(v8 + 4LL * i) = *(_DWORD *)(*((_QWORD *)this + 12) + 4LL * i);
}
if ( *((int *)this + 19) > 0 )
{
free(*((_QWORD *)this + 14));
free(*((_QWORD *)this + 10));
free(*((_QWORD *)this + 11));
free(*((_QWORD *)this + 13));
free(*((_QWORD *)this + 12));
}
*((_QWORD *)this + 10) = v6;
*((_QWORD *)this + 14) = v5;
*((_QWORD *)this + 11) = v10;
*((_QWORD *)this + 13) = v9;
*((_QWORD *)this + 12) = v8;
}
v2 = strdup(a2);
result = this;
*(_QWORD *)(*((_QWORD *)this + 10) + 8LL * *((int *)this + 19)) = v2;
*(_QWORD *)(*((_QWORD *)this + 14) + 8LL * *((int *)this + 19)) = 0LL;
*(_DWORD *)(*((_QWORD *)this + 11) + 4LL * *((int *)this + 19)) = -1;
*(_DWORD *)(*((_QWORD *)this + 13) + 4LL * *((int *)this + 19)) = -1;
*(_DWORD *)(*((_QWORD *)this + 12) + 4LL * (int)(*((_DWORD *)this + 19))++) = 0;
return result;
}
|
addPolygon:
SUB RSP,0x58
MOV qword ptr [RSP + 0x50],RDI
MOV qword ptr [RSP + 0x48],RSI
MOV RCX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x10],RCX
MOV EAX,dword ptr [RCX + 0x4c]
CMP EAX,dword ptr [RCX + 0x48]
JNZ 0x0012c711
MOV RAX,qword ptr [RSP + 0x10]
CMP dword ptr [RAX + 0x48],0x0
JNZ 0x0012c54a
MOV EAX,0x2
MOV dword ptr [RSP + 0xc],EAX
JMP 0x0012c558
LAB_0012c54a:
MOV RAX,qword ptr [RSP + 0x10]
MOV EAX,dword ptr [RAX + 0x48]
SHL EAX,0x1
MOV dword ptr [RSP + 0xc],EAX
LAB_0012c558:
MOV RAX,qword ptr [RSP + 0x10]
MOV ECX,dword ptr [RSP + 0xc]
MOV dword ptr [RAX + 0x48],ECX
MOVSXD RDI,dword ptr [RAX + 0x48]
SHL RDI,0x3
CALL 0x001072d0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x20],RCX
MOVSXD RDI,dword ptr [RAX + 0x48]
SHL RDI,0x3
CALL 0x001072d0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x18],RCX
MOVSXD RDI,dword ptr [RAX + 0x48]
SHL RDI,0x2
CALL 0x001072d0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x40],RCX
MOVSXD RDI,dword ptr [RAX + 0x48]
SHL RDI,0x2
CALL 0x001072d0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x38],RCX
MOVSXD RDI,dword ptr [RAX + 0x48]
SHL RDI,0x2
CALL 0x001072d0
MOV qword ptr [RSP + 0x30],RAX
MOV dword ptr [RSP + 0x2c],0x0
LAB_0012c5e6:
MOV RCX,qword ptr [RSP + 0x10]
MOV EAX,dword ptr [RSP + 0x2c]
CMP EAX,dword ptr [RCX + 0x4c]
JGE 0x0012c68e
MOV RAX,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RAX + 0x50]
MOVSXD RDX,dword ptr [RSP + 0x2c]
MOV RSI,qword ptr [RCX + RDX*0x8]
MOV RCX,qword ptr [RSP + 0x20]
MOVSXD RDX,dword ptr [RSP + 0x2c]
MOV qword ptr [RCX + RDX*0x8],RSI
MOV RCX,qword ptr [RAX + 0x70]
MOVSXD RDX,dword ptr [RSP + 0x2c]
MOV RSI,qword ptr [RCX + RDX*0x8]
MOV RCX,qword ptr [RSP + 0x18]
MOVSXD RDX,dword ptr [RSP + 0x2c]
MOV qword ptr [RCX + RDX*0x8],RSI
MOV RCX,qword ptr [RAX + 0x58]
MOVSXD RDX,dword ptr [RSP + 0x2c]
MOV ESI,dword ptr [RCX + RDX*0x4]
MOV RCX,qword ptr [RSP + 0x40]
MOVSXD RDX,dword ptr [RSP + 0x2c]
MOV dword ptr [RCX + RDX*0x4],ESI
MOV RCX,qword ptr [RAX + 0x68]
MOVSXD RDX,dword ptr [RSP + 0x2c]
MOV ESI,dword ptr [RCX + RDX*0x4]
MOV RCX,qword ptr [RSP + 0x38]
MOVSXD RDX,dword ptr [RSP + 0x2c]
MOV dword ptr [RCX + RDX*0x4],ESI
MOV RAX,qword ptr [RAX + 0x60]
MOVSXD RCX,dword ptr [RSP + 0x2c]
MOV EDX,dword ptr [RAX + RCX*0x4]
MOV RAX,qword ptr [RSP + 0x30]
MOVSXD RCX,dword ptr [RSP + 0x2c]
MOV dword ptr [RAX + RCX*0x4],EDX
MOV EAX,dword ptr [RSP + 0x2c]
ADD EAX,0x1
MOV dword ptr [RSP + 0x2c],EAX
JMP 0x0012c5e6
LAB_0012c68e:
MOV RAX,qword ptr [RSP + 0x10]
CMP dword ptr [RAX + 0x4c],0x0
JLE 0x0012c6df
MOV RAX,qword ptr [RSP + 0x10]
MOV RDI,qword ptr [RAX + 0x70]
CALL 0x001072a0
MOV RAX,qword ptr [RSP + 0x10]
MOV RDI,qword ptr [RAX + 0x50]
CALL 0x001072a0
MOV RAX,qword ptr [RSP + 0x10]
MOV RDI,qword ptr [RAX + 0x58]
CALL 0x001072a0
MOV RAX,qword ptr [RSP + 0x10]
MOV RDI,qword ptr [RAX + 0x68]
CALL 0x001072a0
MOV RAX,qword ptr [RSP + 0x10]
MOV RDI,qword ptr [RAX + 0x60]
CALL 0x001072a0
LAB_0012c6df:
MOV RAX,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP + 0x20]
MOV qword ptr [RAX + 0x50],RCX
MOV RCX,qword ptr [RSP + 0x18]
MOV qword ptr [RAX + 0x70],RCX
MOV RCX,qword ptr [RSP + 0x40]
MOV qword ptr [RAX + 0x58],RCX
MOV RCX,qword ptr [RSP + 0x38]
MOV qword ptr [RAX + 0x68],RCX
MOV RCX,qword ptr [RSP + 0x30]
MOV qword ptr [RAX + 0x60],RCX
LAB_0012c711:
MOV RDI,qword ptr [RSP + 0x48]
CALL 0x001073d0
MOV RSI,RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RAX + 0x50]
MOVSXD RDX,dword ptr [RAX + 0x4c]
MOV qword ptr [RCX + RDX*0x8],RSI
MOV RCX,qword ptr [RAX + 0x70]
MOVSXD RDX,dword ptr [RAX + 0x4c]
MOV qword ptr [RCX + RDX*0x8],0x0
MOV RCX,qword ptr [RAX + 0x58]
MOVSXD RDX,dword ptr [RAX + 0x4c]
MOV dword ptr [RCX + RDX*0x4],0xffffffff
MOV RCX,qword ptr [RAX + 0x68]
MOVSXD RDX,dword ptr [RAX + 0x4c]
MOV dword ptr [RCX + RDX*0x4],0xffffffff
MOV RCX,qword ptr [RAX + 0x60]
MOVSXD RDX,dword ptr [RAX + 0x4c]
MOV dword ptr [RCX + RDX*0x4],0x0
MOV ECX,dword ptr [RAX + 0x4c]
ADD ECX,0x1
MOV dword ptr [RAX + 0x4c],ECX
ADD RSP,0x58
RET
|
/* LefDefParser::defiPinPort::addPolygon(char const*) */
void __thiscall LefDefParser::defiPinPort::addPolygon(defiPinPort *this,char *param_1)
{
void *pvVar1;
void *pvVar2;
void *pvVar3;
void *pvVar4;
void *pvVar5;
char *pcVar6;
int local_4c;
int local_2c;
if (*(int *)(this + 0x4c) == *(int *)(this + 0x48)) {
if (*(int *)(this + 0x48) == 0) {
local_4c = 2;
}
else {
local_4c = *(int *)(this + 0x48) << 1;
}
*(int *)(this + 0x48) = local_4c;
pvVar1 = malloc((long)*(int *)(this + 0x48) << 3);
pvVar2 = malloc((long)*(int *)(this + 0x48) << 3);
pvVar3 = malloc((long)*(int *)(this + 0x48) << 2);
pvVar4 = malloc((long)*(int *)(this + 0x48) << 2);
pvVar5 = malloc((long)*(int *)(this + 0x48) << 2);
for (local_2c = 0; local_2c < *(int *)(this + 0x4c); local_2c = local_2c + 1) {
*(int8 *)((long)pvVar1 + (long)local_2c * 8) =
*(int8 *)(*(long *)(this + 0x50) + (long)local_2c * 8);
*(int8 *)((long)pvVar2 + (long)local_2c * 8) =
*(int8 *)(*(long *)(this + 0x70) + (long)local_2c * 8);
*(int4 *)((long)pvVar3 + (long)local_2c * 4) =
*(int4 *)(*(long *)(this + 0x58) + (long)local_2c * 4);
*(int4 *)((long)pvVar4 + (long)local_2c * 4) =
*(int4 *)(*(long *)(this + 0x68) + (long)local_2c * 4);
*(int4 *)((long)pvVar5 + (long)local_2c * 4) =
*(int4 *)(*(long *)(this + 0x60) + (long)local_2c * 4);
}
if (0 < *(int *)(this + 0x4c)) {
free(*(void **)(this + 0x70));
free(*(void **)(this + 0x50));
free(*(void **)(this + 0x58));
free(*(void **)(this + 0x68));
free(*(void **)(this + 0x60));
}
*(void **)(this + 0x50) = pvVar1;
*(void **)(this + 0x70) = pvVar2;
*(void **)(this + 0x58) = pvVar3;
*(void **)(this + 0x68) = pvVar4;
*(void **)(this + 0x60) = pvVar5;
}
pcVar6 = strdup(param_1);
*(char **)(*(long *)(this + 0x50) + (long)*(int *)(this + 0x4c) * 8) = pcVar6;
*(int8 *)(*(long *)(this + 0x70) + (long)*(int *)(this + 0x4c) * 8) = 0;
*(int4 *)(*(long *)(this + 0x58) + (long)*(int *)(this + 0x4c) * 4) = 0xffffffff;
*(int4 *)(*(long *)(this + 0x68) + (long)*(int *)(this + 0x4c) * 4) = 0xffffffff;
*(int4 *)(*(long *)(this + 0x60) + (long)*(int *)(this + 0x4c) * 4) = 0;
*(int *)(this + 0x4c) = *(int *)(this + 0x4c) + 1;
return;
}
|
|
11,733 |
mysql_stmt_store_result_start
|
eloqsql/libmariadb/libmariadb/mariadb_async.c
|
int STDCALL
mysql_stmt_store_result_start(int *ret, MYSQL_STMT *stmt)
{
MK_ASYNC_START_BODY(
mysql_stmt_store_result,
stmt->mysql,
{
WIN_SET_NONBLOCKING(stmt->mysql)
parms.stmt= stmt;
},
1,
r_int,
/* If stmt->mysql==NULL then we will not block so can call directly. */
if (!stmt->mysql)
{
*ret= mysql_stmt_store_result(stmt);
return 0;
})
}
|
O3
|
c
|
mysql_stmt_store_result_start:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rsi), %rax
testq %rax, %rax
je 0x2ee9b
movq 0x480(%rax), %rax
movq 0x28(%rax), %r15
leaq -0x20(%rbp), %rdx
movq %r14, (%rdx)
movb $0x1, 0x14(%r15)
leaq 0x38(%r15), %rdi
leaq 0xa2(%rip), %rsi # 0x2ef23
callq 0x303a4
movw $0x0, 0x14(%r15)
testl %eax, %eax
jle 0x2eea5
movb $0x1, 0x15(%r15)
movl (%r15), %eax
jmp 0x2ef18
movq %r14, %rdi
callq 0x23d72
jmp 0x2ef14
js 0x2eead
movl 0x8(%r15), %eax
jmp 0x2ef14
movq 0x38(%r14), %rax
movl $0x7d8, 0x90(%rax) # imm = 0x7D8
movl $0x297, %edi # imm = 0x297
addq 0x38(%r14), %rdi
leaq 0x1cdc5(%rip), %rax # 0x4bc90
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13220
movq 0x38(%r14), %rax
xorl %r15d, %r15d
movb %r15b, 0x29c(%rax)
movl $0x97, %edi
addq 0x38(%r14), %rdi
leaq 0x1cdaa(%rip), %rax # 0x4bca0
movq 0x40(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x13220
movq 0x38(%r14), %rax
movb %r15b, 0x296(%rax)
movl $0x1, %eax
movl %eax, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
mysql_stmt_store_result_start:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
mov rax, [rsi+38h]
test rax, rax
jz short loc_2EE9B
mov rax, [rax+480h]
mov r15, [rax+28h]
lea rdx, [rbp+var_20]
mov [rdx], r14
mov byte ptr [r15+14h], 1
lea rdi, [r15+38h]
lea rsi, mysql_stmt_store_result_start_internal
call my_context_spawn
mov word ptr [r15+14h], 0
test eax, eax
jle short loc_2EEA5
mov byte ptr [r15+15h], 1
mov eax, [r15]
jmp short loc_2EF18
loc_2EE9B:
mov rdi, r14
call mysql_stmt_store_result
jmp short loc_2EF14
loc_2EEA5:
js short loc_2EEAD
mov eax, [r15+8]
jmp short loc_2EF14
loc_2EEAD:
mov rax, [r14+38h]
mov dword ptr [rax+90h], 7D8h
mov edi, 297h
add rdi, [r14+38h]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [r14+38h]
xor r15d, r15d
mov [rax+29Ch], r15b
mov edi, 97h
add rdi, [r14+38h]
lea rax, client_errors
mov rsi, [rax+40h]
mov edx, 1FFh
call _strncpy
mov rax, [r14+38h]
mov [rax+296h], r15b
mov eax, 1
loc_2EF14:
mov [rbx], eax
xor eax, eax
loc_2EF18:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
long long mysql_stmt_store_result_start(int *a1, long long a2)
{
long long v2; // rax
long long v3; // rax
unsigned int *v4; // r15
int v5; // eax
int v7; // eax
long long v8[4]; // [rsp+0h] [rbp-20h] BYREF
v8[0] = v2;
v3 = *(_QWORD *)(a2 + 56);
if ( v3 )
{
v4 = *(unsigned int **)(*(_QWORD *)(v3 + 1152) + 40LL);
v8[0] = a2;
*((_BYTE *)v4 + 20) = 1;
v5 = my_context_spawn(v4 + 14, mysql_stmt_store_result_start_internal, v8);
*((_WORD *)v4 + 10) = 0;
if ( v5 > 0 )
{
*((_BYTE *)v4 + 21) = 1;
return *v4;
}
if ( v5 < 0 )
{
*(_DWORD *)(*(_QWORD *)(a2 + 56) + 144LL) = 2008;
strncpy(*(_QWORD *)(a2 + 56) + 663LL, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(*(_QWORD *)(a2 + 56) + 668LL) = 0;
strncpy(*(_QWORD *)(a2 + 56) + 151LL, client_errors[8], 511LL);
*(_BYTE *)(*(_QWORD *)(a2 + 56) + 662LL) = 0;
v7 = 1;
}
else
{
v7 = v4[2];
}
}
else
{
v7 = mysql_stmt_store_result(a2);
}
*a1 = v7;
return 0LL;
}
|
mysql_stmt_store_result_start:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RSI + 0x38]
TEST RAX,RAX
JZ 0x0012ee9b
MOV RAX,qword ptr [RAX + 0x480]
MOV R15,qword ptr [RAX + 0x28]
LEA RDX,[RBP + -0x20]
MOV qword ptr [RDX],R14
MOV byte ptr [R15 + 0x14],0x1
LEA RDI,[R15 + 0x38]
LEA RSI,[0x12ef23]
CALL 0x001303a4
MOV word ptr [R15 + 0x14],0x0
TEST EAX,EAX
JLE 0x0012eea5
MOV byte ptr [R15 + 0x15],0x1
MOV EAX,dword ptr [R15]
JMP 0x0012ef18
LAB_0012ee9b:
MOV RDI,R14
CALL 0x00123d72
JMP 0x0012ef14
LAB_0012eea5:
JS 0x0012eead
MOV EAX,dword ptr [R15 + 0x8]
JMP 0x0012ef14
LAB_0012eead:
MOV RAX,qword ptr [R14 + 0x38]
MOV dword ptr [RAX + 0x90],0x7d8
MOV EDI,0x297
ADD RDI,qword ptr [R14 + 0x38]
LEA RAX,[0x14bc90]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113220
MOV RAX,qword ptr [R14 + 0x38]
XOR R15D,R15D
MOV byte ptr [RAX + 0x29c],R15B
MOV EDI,0x97
ADD RDI,qword ptr [R14 + 0x38]
LEA RAX,[0x14bca0]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x1ff
CALL 0x00113220
MOV RAX,qword ptr [R14 + 0x38]
MOV byte ptr [RAX + 0x296],R15B
MOV EAX,0x1
LAB_0012ef14:
MOV dword ptr [RBX],EAX
XOR EAX,EAX
LAB_0012ef18:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int4 mysql_stmt_store_result_start(int4 *param_1,long param_2)
{
int4 *puVar1;
int iVar2;
int4 uVar3;
if (*(long *)(param_2 + 0x38) == 0) {
uVar3 = mysql_stmt_store_result(param_2);
}
else {
puVar1 = *(int4 **)(*(long *)(*(long *)(param_2 + 0x38) + 0x480) + 0x28);
*(int1 *)(puVar1 + 5) = 1;
iVar2 = my_context_spawn(puVar1 + 0xe,mysql_stmt_store_result_start_internal);
*(int2 *)(puVar1 + 5) = 0;
if (0 < iVar2) {
*(int1 *)((long)puVar1 + 0x15) = 1;
return *puVar1;
}
if (iVar2 < 0) {
*(int4 *)(*(long *)(param_2 + 0x38) + 0x90) = 0x7d8;
strncpy((char *)(*(long *)(param_2 + 0x38) + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(*(long *)(param_2 + 0x38) + 0x29c) = 0;
strncpy((char *)(*(long *)(param_2 + 0x38) + 0x97),PTR_s_Client_run_out_of_memory_0014bce0,
0x1ff);
*(int1 *)(*(long *)(param_2 + 0x38) + 0x296) = 0;
uVar3 = 1;
}
else {
uVar3 = puVar1[2];
}
}
*param_1 = uVar3;
return 0;
}
|
|
11,734 |
my_scan_8bit
|
eloqsql/strings/ctype-simple.c
|
size_t my_scan_8bit(CHARSET_INFO *cs, const char *str, const char *end, int sq)
{
const char *str0= str;
switch (sq)
{
case MY_SEQ_INTTAIL:
if (*str == '.')
{
for(str++ ; str != end && *str == '0' ; str++);
return (size_t) (str - str0);
}
return 0;
case MY_SEQ_SPACES:
for ( ; str < end ; str++)
{
if (!my_isspace(cs,*str))
break;
}
return (size_t) (str - str0);
case MY_SEQ_NONSPACES:
for ( ; str < end ; str++)
{
if (my_isspace(cs, *str))
break;
}
return (size_t) (str - str0);
default:
return 0;
}
}
|
O3
|
c
|
my_scan_8bit:
pushq %rbp
movq %rsp, %rbp
movq %rdx, %rax
cmpl $0x1, %ecx
je 0x2e3e2
cmpl $0x2, %ecx
je 0x2e3b6
cmpl $0x3, %ecx
jne 0x2e407
movq %rsi, %rcx
cmpq %rax, %rsi
jae 0x2e3da
movq 0x40(%rdi), %rdx
movq %rsi, %rcx
movzbl (%rcx), %edi
testb $0x8, 0x1(%rdx,%rdi)
jne 0x2e3da
incq %rcx
cmpq %rax, %rcx
jne 0x2e3a2
jmp 0x2e3d7
movq %rsi, %rcx
cmpq %rax, %rsi
jae 0x2e3da
movq 0x40(%rdi), %rdx
movq %rsi, %rcx
movzbl (%rcx), %edi
testb $0x8, 0x1(%rdx,%rdi)
je 0x2e3da
incq %rcx
cmpq %rax, %rcx
jne 0x2e3c5
movq %rax, %rcx
subq %rsi, %rcx
movq %rcx, %rax
jmp 0x2e409
cmpb $0x2e, (%rsi)
jne 0x2e407
leaq 0x1(%rsi), %rcx
cmpq %rax, %rcx
je 0x2e402
leaq 0x1(%rcx), %rdx
cmpb $0x30, (%rcx)
movq %rdx, %rcx
je 0x2e3eb
decq %rdx
movq %rdx, %rax
subq %rsi, %rax
jmp 0x2e409
xorl %eax, %eax
popq %rbp
retq
|
my_scan_8bit:
push rbp
mov rbp, rsp
mov rax, rdx
cmp ecx, 1
jz short loc_2E3E2
cmp ecx, 2
jz short loc_2E3B6
cmp ecx, 3
jnz short loc_2E407
mov rcx, rsi
cmp rsi, rax
jnb short loc_2E3DA
mov rdx, [rdi+40h]
mov rcx, rsi
loc_2E3A2:
movzx edi, byte ptr [rcx]
test byte ptr [rdx+rdi+1], 8
jnz short loc_2E3DA
inc rcx
cmp rcx, rax
jnz short loc_2E3A2
jmp short loc_2E3D7
loc_2E3B6:
mov rcx, rsi
cmp rsi, rax
jnb short loc_2E3DA
mov rdx, [rdi+40h]
mov rcx, rsi
loc_2E3C5:
movzx edi, byte ptr [rcx]
test byte ptr [rdx+rdi+1], 8
jz short loc_2E3DA
inc rcx
cmp rcx, rax
jnz short loc_2E3C5
loc_2E3D7:
mov rcx, rax
loc_2E3DA:
sub rcx, rsi
mov rax, rcx
jmp short loc_2E409
loc_2E3E2:
cmp byte ptr [rsi], 2Eh ; '.'
jnz short loc_2E407
lea rcx, [rsi+1]
loc_2E3EB:
cmp rcx, rax
jz short loc_2E402
lea rdx, [rcx+1]
cmp byte ptr [rcx], 30h ; '0'
mov rcx, rdx
jz short loc_2E3EB
dec rdx
mov rax, rdx
loc_2E402:
sub rax, rsi
jmp short loc_2E409
loc_2E407:
xor eax, eax
loc_2E409:
pop rbp
retn
|
long long my_scan_8bit(long long a1, unsigned __int8 *a2, unsigned __int8 *a3, int a4)
{
unsigned __int8 *v4; // rax
unsigned __int8 *v5; // rcx
unsigned __int8 *v7; // rcx
_BYTE *v8; // rdx
v4 = a3;
if ( a4 != 1 )
{
if ( a4 == 2 )
{
v5 = a2;
if ( a2 < a3 )
{
v5 = a2;
while ( (*(_BYTE *)(*(_QWORD *)(a1 + 64) + *v5 + 1LL) & 8) != 0 )
{
if ( ++v5 == a3 )
{
LABEL_13:
v5 = a3;
return v5 - a2;
}
}
}
return v5 - a2;
}
if ( a4 == 3 )
{
v5 = a2;
if ( a2 < a3 )
{
v5 = a2;
while ( (*(_BYTE *)(*(_QWORD *)(a1 + 64) + *v5 + 1LL) & 8) == 0 )
{
if ( ++v5 == a3 )
goto LABEL_13;
}
}
return v5 - a2;
}
return 0LL;
}
if ( *a2 != 46 )
return 0LL;
v7 = a2 + 1;
while ( v7 != v4 )
{
v8 = v7 + 1;
if ( *v7++ != 48 )
{
v4 = v8 - 1;
return v4 - a2;
}
}
return v4 - a2;
}
|
my_scan_8bit:
PUSH RBP
MOV RBP,RSP
MOV RAX,RDX
CMP ECX,0x1
JZ 0x0012e3e2
CMP ECX,0x2
JZ 0x0012e3b6
CMP ECX,0x3
JNZ 0x0012e407
MOV RCX,RSI
CMP RSI,RAX
JNC 0x0012e3da
MOV RDX,qword ptr [RDI + 0x40]
MOV RCX,RSI
LAB_0012e3a2:
MOVZX EDI,byte ptr [RCX]
TEST byte ptr [RDX + RDI*0x1 + 0x1],0x8
JNZ 0x0012e3da
INC RCX
CMP RCX,RAX
JNZ 0x0012e3a2
JMP 0x0012e3d7
LAB_0012e3b6:
MOV RCX,RSI
CMP RSI,RAX
JNC 0x0012e3da
MOV RDX,qword ptr [RDI + 0x40]
MOV RCX,RSI
LAB_0012e3c5:
MOVZX EDI,byte ptr [RCX]
TEST byte ptr [RDX + RDI*0x1 + 0x1],0x8
JZ 0x0012e3da
INC RCX
CMP RCX,RAX
JNZ 0x0012e3c5
LAB_0012e3d7:
MOV RCX,RAX
LAB_0012e3da:
SUB RCX,RSI
MOV RAX,RCX
JMP 0x0012e409
LAB_0012e3e2:
CMP byte ptr [RSI],0x2e
JNZ 0x0012e407
LEA RCX,[RSI + 0x1]
LAB_0012e3eb:
CMP RCX,RAX
JZ 0x0012e402
LEA RDX,[RCX + 0x1]
CMP byte ptr [RCX],0x30
MOV RCX,RDX
JZ 0x0012e3eb
DEC RDX
MOV RAX,RDX
LAB_0012e402:
SUB RAX,RSI
JMP 0x0012e409
LAB_0012e407:
XOR EAX,EAX
LAB_0012e409:
POP RBP
RET
|
long my_scan_8bit(long param_1,byte *param_2,byte *param_3,int param_4)
{
byte bVar1;
byte *pbVar2;
long lVar3;
byte *pbVar4;
if (param_4 == 1) {
if (*param_2 == 0x2e) {
pbVar4 = param_2 + 1;
do {
pbVar2 = param_3;
if (pbVar4 == param_3) break;
bVar1 = *pbVar4;
pbVar2 = pbVar4;
pbVar4 = pbVar4 + 1;
} while (bVar1 == 0x30);
return (long)pbVar2 - (long)param_2;
}
LAB_0012e407:
lVar3 = 0;
}
else {
pbVar4 = param_2;
if (param_4 == 2) {
if (param_2 < param_3) {
pbVar2 = param_2;
do {
pbVar4 = pbVar2;
if ((*(byte *)(*(long *)(param_1 + 0x40) + 1 + (ulong)*pbVar2) & 8) == 0) break;
pbVar2 = pbVar2 + 1;
pbVar4 = param_3;
} while (pbVar2 != param_3);
}
}
else {
if (param_4 != 3) goto LAB_0012e407;
if (param_2 < param_3) {
pbVar2 = param_2;
do {
pbVar4 = pbVar2;
if ((*(byte *)(*(long *)(param_1 + 0x40) + 1 + (ulong)*pbVar2) & 8) != 0) break;
pbVar2 = pbVar2 + 1;
pbVar4 = param_3;
} while (pbVar2 != param_3);
}
}
lVar3 = (long)pbVar4 - (long)param_2;
}
return lVar3;
}
|
|
11,735 |
my_printv_error
|
eloqsql/mysys/my_error.c
|
void my_printv_error(uint error, const char *format, myf MyFlags, va_list ap)
{
char ebuff[ERRMSGSIZE];
DBUG_ENTER("my_printv_error");
DBUG_PRINT("my", ("nr: %d MyFlags: %lu errno: %d format: %s",
error, MyFlags, errno, format));
(void) my_vsnprintf(ebuff, sizeof(ebuff), format, ap);
(*error_handler_hook)(error, ebuff, MyFlags);
DBUG_VOID_RETURN;
}
|
O3
|
c
|
my_printv_error:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movq %rdx, %rbx
movq %rsi, %rdx
movl %edi, %r14d
movq %fs:0x28, %rax
movq %rax, -0x20(%rbp)
leaq -0x220(%rbp), %r15
movl $0x200, %esi # imm = 0x200
movq %r15, %rdi
callq 0x5a2f9
leaq 0x2c44b7(%rip), %rax # 0x2ef380
movl %r14d, %edi
movq %r15, %rsi
movq %rbx, %rdx
callq *(%rax)
movq %fs:0x28, %rax
cmpq -0x20(%rbp), %rax
jne 0x2aef1
addq $0x208, %rsp # imm = 0x208
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x24390
|
my_printv_error:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 208h
mov rbx, rdx
mov rdx, rsi
mov r14d, edi
mov rax, fs:28h
mov [rbp+var_20], rax
lea r15, [rbp+var_220]
mov esi, 200h
mov rdi, r15
call my_vsnprintf
lea rax, error_handler_hook
mov edi, r14d
mov rsi, r15
mov rdx, rbx
call qword ptr [rax]
mov rax, fs:28h
cmp rax, [rbp+var_20]
jnz short loc_2AEF1
add rsp, 208h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_2AEF1:
call ___stack_chk_fail
|
unsigned long long my_printv_error(unsigned int a1, long long a2, __int16 a3, long long a4)
{
_BYTE v6[512]; // [rsp+0h] [rbp-220h] BYREF
unsigned long long v7; // [rsp+200h] [rbp-20h]
v7 = __readfsqword(0x28u);
my_vsnprintf(v6, 512LL, a2, a4);
error_handler_hook(a1, (long long)v6, a3);
return __readfsqword(0x28u);
}
|
my_printv_error:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x208
MOV RBX,RDX
MOV RDX,RSI
MOV R14D,EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x20],RAX
LEA R15,[RBP + -0x220]
MOV ESI,0x200
MOV RDI,R15
CALL 0x0015a2f9
LEA RAX,[0x3ef380]
MOV EDI,R14D
MOV RSI,R15
MOV RDX,RBX
CALL qword ptr [RAX]
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x0012aef1
ADD RSP,0x208
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0012aef1:
CALL 0x00124390
|
void my_printv_error(int4 param_1,int8 param_2,int8 param_3)
{
long in_FS_OFFSET;
int1 local_228 [512];
long local_28;
local_28 = *(long *)(in_FS_OFFSET + 0x28);
my_vsnprintf(local_228,0x200,param_2);
(*(code *)error_handler_hook)(param_1,local_228,param_3);
if (*(long *)(in_FS_OFFSET + 0x28) == local_28) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
11,736 |
ma_init_dynamic_array
|
eloqsql/libmariadb/libmariadb/ma_array.c
|
my_bool ma_init_dynamic_array(DYNAMIC_ARRAY *array, uint element_size,
uint init_alloc, uint alloc_increment CALLER_INFO_PROTO)
{
if (!alloc_increment)
{
alloc_increment=max((8192-MALLOC_OVERHEAD)/element_size,16);
if (init_alloc > 8 && alloc_increment > init_alloc * 2)
alloc_increment=init_alloc*2;
}
if (!init_alloc)
init_alloc=alloc_increment;
array->elements=0;
array->max_element=init_alloc;
array->alloc_increment=alloc_increment;
array->size_of_element=element_size;
if (!(array->buffer=(char*) malloc(element_size*init_alloc)))
{
array->max_element=0;
return(TRUE);
}
return(FALSE);
}
|
O3
|
c
|
ma_init_dynamic_array:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edx, %r8d
movq %rdi, %rbx
testl %ecx, %ecx
jne 0x3259c
movl $0x10, %ecx
cmpl $0x1e1, %esi # imm = 0x1E1
ja 0x3258d
movw $0x1ff8, %ax # imm = 0x1FF8
xorl %edx, %edx
divw %si
movzwl %ax, %ecx
cmpl $0x9, %r8d
jb 0x3259c
leal (%r8,%r8), %eax
cmpl %eax, %ecx
cmovael %eax, %ecx
testl %r8d, %r8d
cmovel %ecx, %r8d
movl $0x0, 0x8(%rbx)
movl %r8d, 0xc(%rbx)
movl %ecx, 0x10(%rbx)
movl %esi, 0x14(%rbx)
imull %esi, %r8d
movq %r8, %rdi
callq 0x13610
movq %rax, (%rbx)
testq %rax, %rax
je 0x325cc
xorl %eax, %eax
jmp 0x325d5
movl $0x0, 0xc(%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
ma_init_dynamic_array:
push rbp
mov rbp, rsp
push rbx
push rax
mov r8d, edx
mov rbx, rdi
test ecx, ecx
jnz short loc_3259C
mov ecx, 10h
cmp esi, 1E1h
ja short loc_3258D
mov ax, 1FF8h
xor edx, edx
div si
movzx ecx, ax
loc_3258D:
cmp r8d, 9
jb short loc_3259C
lea eax, [r8+r8]
cmp ecx, eax
cmovnb ecx, eax
loc_3259C:
test r8d, r8d
cmovz r8d, ecx
mov dword ptr [rbx+8], 0
mov [rbx+0Ch], r8d
mov [rbx+10h], ecx
mov [rbx+14h], esi
imul r8d, esi
mov rdi, r8
call _malloc
mov [rbx], rax
test rax, rax
jz short loc_325CC
xor eax, eax
jmp short loc_325D5
loc_325CC:
mov dword ptr [rbx+0Ch], 0
mov al, 1
loc_325D5:
add rsp, 8
pop rbx
pop rbp
retn
|
long long ma_init_dynamic_array(long long a1, unsigned int a2, unsigned int a3, unsigned int a4)
{
unsigned int v4; // r8d
long long v5; // rax
v4 = a3;
if ( !a4 )
{
a4 = 16;
if ( a2 <= 0x1E1 )
a4 = 0x1FF8u / (unsigned __int16)a2;
if ( a3 >= 9 && a4 >= 2 * a3 )
a4 = 2 * a3;
}
if ( !a3 )
v4 = a4;
*(_DWORD *)(a1 + 8) = 0;
*(_DWORD *)(a1 + 12) = v4;
*(_DWORD *)(a1 + 16) = a4;
*(_DWORD *)(a1 + 20) = a2;
v5 = malloc(a2 * v4);
*(_QWORD *)a1 = v5;
if ( v5 )
return 0LL;
*(_DWORD *)(a1 + 12) = 0;
return 1LL;
}
|
ma_init_dynamic_array:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV R8D,EDX
MOV RBX,RDI
TEST ECX,ECX
JNZ 0x0013259c
MOV ECX,0x10
CMP ESI,0x1e1
JA 0x0013258d
MOV AX,0x1ff8
XOR EDX,EDX
DIV SI
MOVZX ECX,AX
LAB_0013258d:
CMP R8D,0x9
JC 0x0013259c
LEA EAX,[R8 + R8*0x1]
CMP ECX,EAX
CMOVNC ECX,EAX
LAB_0013259c:
TEST R8D,R8D
CMOVZ R8D,ECX
MOV dword ptr [RBX + 0x8],0x0
MOV dword ptr [RBX + 0xc],R8D
MOV dword ptr [RBX + 0x10],ECX
MOV dword ptr [RBX + 0x14],ESI
IMUL R8D,ESI
MOV RDI,R8
CALL 0x00113610
MOV qword ptr [RBX],RAX
TEST RAX,RAX
JZ 0x001325cc
XOR EAX,EAX
JMP 0x001325d5
LAB_001325cc:
MOV dword ptr [RBX + 0xc],0x0
MOV AL,0x1
LAB_001325d5:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
bool ma_init_dynamic_array(int8 *param_1,uint param_2,uint param_3,uint param_4)
{
void *pvVar1;
if (param_4 == 0) {
param_4 = 0x10;
if (param_2 < 0x1e2) {
param_4 = 0x1ff8 / (param_2 & 0xffff);
}
if ((8 < param_3) && (param_3 * 2 <= param_4)) {
param_4 = param_3 * 2;
}
}
if (param_3 == 0) {
param_3 = param_4;
}
*(int4 *)(param_1 + 1) = 0;
*(uint *)((long)param_1 + 0xc) = param_3;
*(uint *)(param_1 + 2) = param_4;
*(uint *)((long)param_1 + 0x14) = param_2;
pvVar1 = malloc((ulong)(param_3 * param_2));
*param_1 = pvVar1;
if (pvVar1 == (void *)0x0) {
*(int4 *)((long)param_1 + 0xc) = 0;
}
return pvVar1 == (void *)0x0;
}
|
|
11,737 |
cxxopts::exceptions::exception::~exception()
|
zkingston[P]unknot/build_O1/_deps/cxxopts-src/include/cxxopts.hpp
|
explicit exception(std::string message)
: m_message(std::move(message))
{
}
|
O1
|
cpp
|
cxxopts::exceptions::exception::~exception():
pushq %rbx
movq %rdi, %rbx
leaq 0x302591(%rip), %rax # 0x333118
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x30ba2
movq (%rax), %rsi
incq %rsi
callq 0xfa70
movq %rbx, %rdi
popq %rbx
jmp 0x10260
nop
|
_ZN7cxxopts10exceptions9exceptionD2Ev:
push rbx
mov rbx, rdi
lea rax, off_333118
mov [rdi], rax
mov rdi, [rdi+8]; void *
lea rax, [rbx+18h]
cmp rdi, rax
jz short loc_30BA2
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_30BA2:
mov rdi, rbx; this
pop rbx
jmp __ZNSt9exceptionD2Ev; std::exception::~exception()
|
void cxxopts::exceptions::exception::~exception(std::exception *a1)
{
_QWORD *v2; // rdi
*(_QWORD *)a1 = off_333118;
v2 = (_QWORD *)*((_QWORD *)a1 + 1);
if ( v2 != (_QWORD *)((char *)a1 + 24) )
operator delete(v2, *((_QWORD *)a1 + 3) + 1LL);
std::exception::~exception(a1);
}
|
~exception:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x433118]
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x8]
LEA RAX,[RBX + 0x18]
CMP RDI,RAX
JZ 0x00130ba2
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x0010fa70
LAB_00130ba2:
MOV RDI,RBX
POP RBX
JMP 0x00110260
|
/* cxxopts::exceptions::exception::~exception() */
void __thiscall cxxopts::exceptions::exception::~exception(exception *this)
{
*(int ***)this = &PTR__exception_00433118;
if (*(exception **)(this + 8) != this + 0x18) {
operator_delete(*(exception **)(this + 8),*(long *)(this + 0x18) + 1);
}
std::exception::~exception((exception *)this);
return;
}
|
|
11,738 |
minja::Value::dump_string(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, char)
|
monkey531[P]llama/common/minja.hpp
|
static void dump_string(const json & primitive, std::ostringstream & out, char string_quote = '\'') {
if (!primitive.is_string()) throw std::runtime_error("Value is not a string: " + primitive.dump());
auto s = primitive.dump();
if (string_quote == '"' || s.find('\'') != std::string::npos) {
out << s;
return;
}
// Reuse json dump, just changing string quotes
out << string_quote;
for (size_t i = 1, n = s.size() - 1; i < n; ++i) {
if (s[i] == '\\' && s[i + 1] == '"') {
out << '"';
i++;
} else if (s[i] == string_quote) {
out << '\\' << string_quote;
} else {
out << s[i];
}
}
out << string_quote;
}
|
O3
|
cpp
|
minja::Value::dump_string(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, char):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
cmpb $0x3, (%rdi)
jne 0x872b3
movl %edx, %ebp
movq %rsi, %rbx
movq %rsp, %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
movl $0x20, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x7fbc8
cmpb $0x22, %bpl
je 0x871b3
movq %rsp, %rdi
movl $0x27, %esi
xorl %edx, %edx
callq 0x1ab60
cmpq $-0x1, %rax
je 0x871ec
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x1aa20
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x871df
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a900
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x20(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x1aa20
movq 0x8(%rsp), %r15
decq %r15
cmpq $0x2, %r15
jb 0x87299
movl $0x1, %r12d
leaq 0x20(%rsp), %r14
movq (%rsp), %rcx
movb (%rcx,%r12), %al
cmpb $0x5c, %al
jne 0x8724c
cmpb $0x22, 0x1(%rcx,%r12)
jne 0x8724c
movb $0x22, 0x20(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1aa20
incq %r12
jmp 0x87291
cmpb %bpl, %al
jne 0x8727d
movb $0x5c, 0x20(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1aa20
movb %bpl, 0x20(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x1aa20
jmp 0x87291
movb %al, 0x20(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1aa20
incq %r12
cmpq %r15, %r12
jb 0x8721e
leaq 0x20(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x1aa20
jmp 0x871c4
movl $0x10, %edi
callq 0x1a460
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
movl $0x20, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x7fbc8
leaq 0x68b63(%rip), %rsi # 0xefe47
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x78e69
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1ae50
xorl %ebp, %ebp
movq 0xa4ce8(%rip), %rsi # 0x12bff0
movq 0xa4c51(%rip), %rdx # 0x12bf60
movq %rbx, %rdi
callq 0x1af40
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x87335
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a900
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x87350
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a900
testb %bpl, %bpl
jne 0x8737a
jmp 0x873a4
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8737a
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a900
jmp 0x8737a
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a690
jmp 0x873a4
jmp 0x87386
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x873a4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a900
movq %r14, %rdi
callq 0x1afd0
|
_ZN5minja5Value11dump_stringERKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES5_IhSaIhEEvEERNS6_19basic_ostringstreamIcS9_SA_EEc:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 40h
mov r14, rdi
cmp byte ptr [rdi], 3
jnz loc_872B3
mov ebp, edx
mov rbx, rsi
mov rdi, rsp
mov rsi, r14
mov edx, 0FFFFFFFFh
mov ecx, 20h ; ' '
xor r8d, r8d
xor r9d, r9d
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dumpEicbNS0_6detail15error_handler_tE; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::dump(int,char,bool,nlohmann::json_abi_v3_11_3::detail::error_handler_t)
cmp bpl, 22h ; '"'
jz short loc_871B3
mov rdi, rsp
mov esi, 27h ; '''
xor edx, edx
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEcm; std::string::find(char,ulong)
cmp rax, 0FFFFFFFFFFFFFFFFh
jz short loc_871EC
loc_871B3:
mov rsi, [rsp+68h+var_68]
mov rdx, [rsp+68h+var_60]
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
loc_871C4:
lea rax, [rsp+68h+var_58]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_871DF
mov rsi, [rsp+68h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_871DF:
add rsp, 40h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_871EC:
lea rsi, [rsp+68h+var_48]
mov [rsi], bpl
mov edx, 1
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov r15, [rsp+68h+var_60]
dec r15
cmp r15, 2
jb loc_87299
mov r12d, 1
lea r14, [rsp+68h+var_48]
loc_8721E:
mov rcx, [rsp+68h+var_68]
mov al, [rcx+r12]
cmp al, 5Ch ; '\'
jnz short loc_8724C
cmp byte ptr [rcx+r12+1], 22h ; '"'
jnz short loc_8724C
mov [rsp+68h+var_48], 22h ; '"'
mov edx, 1
mov rdi, rbx
mov rsi, r14
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
inc r12
jmp short loc_87291
loc_8724C:
cmp al, bpl
jnz short loc_8727D
mov [rsp+68h+var_48], 5Ch ; '\'
mov edx, 1
mov rdi, rbx
mov rsi, r14
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov [rsp+68h+var_48], bpl
mov edx, 1
mov rdi, rax
mov rsi, r14
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
jmp short loc_87291
loc_8727D:
mov [rsp+68h+var_48], al
mov edx, 1
mov rdi, rbx
mov rsi, r14
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
loc_87291:
inc r12
cmp r12, r15
jb short loc_8721E
loc_87299:
lea rsi, [rsp+68h+var_48]
mov [rsi], bpl
mov edx, 1
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
jmp loc_871C4
loc_872B3:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+68h+var_48]
mov rsi, r14
mov edx, 0FFFFFFFFh
mov ecx, 20h ; ' '
xor r8d, r8d
xor r9d, r9d
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dumpEicbNS0_6detail15error_handler_tE; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::dump(int,char,bool,nlohmann::json_abi_v3_11_3::detail::error_handler_t)
lea rsi, aValueIsNotAStr; "Value is not a string: "
mov rdi, rsp
lea rdx, [rsp+68h+var_48]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
mov rsi, rsp
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+68h+var_58]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_87335
mov rsi, [rsp+68h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_87335:
lea rax, [rsp+68h+var_38]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_87350
mov rsi, [rsp+68h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_87350:
test bpl, bpl
jnz short loc_8737A
jmp short loc_873A4
mov r14, rax
lea rax, [rsp+68h+var_38]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_8737A
mov rsi, [rsp+68h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_8737A
mov r14, rax
loc_8737A:
mov rdi, rbx; void *
call ___cxa_free_exception
jmp short loc_873A4
jmp short $+2
loc_87386:
mov r14, rax
lea rax, [rsp+68h+var_58]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_873A4
mov rsi, [rsp+68h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_873A4:
mov rdi, r14
call __Unwind_Resume
|
void minja::Value::dump_string(_BYTE *a1, long long a2, char a3)
{
unsigned long long v4; // r15
unsigned long long v5; // r12
char v6; // al
long long v7; // rax
void *exception; // rbx
long long *v9; // [rsp+0h] [rbp-68h] BYREF
long long v10; // [rsp+8h] [rbp-60h]
long long v11; // [rsp+10h] [rbp-58h] BYREF
_BYTE v12[16]; // [rsp+20h] [rbp-48h] BYREF
if ( *a1 != 3 )
{
exception = __cxa_allocate_exception(0x10uLL);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::dump(
(long long)v12,
(long long)a1,
-1,
32,
0,
0);
std::operator+<char>((long long)&v9, (long long)"Value is not a string: ", (long long)v12);
std::runtime_error::runtime_error(exception, &v9);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::dump(
(long long)&v9,
(long long)a1,
-1,
32,
0,
0);
if ( a3 != 34 && std::string::find(&v9, 39LL, 0LL) == -1 )
{
v12[0] = a3;
std::__ostream_insert<char,std::char_traits<char>>(a2, v12, 1LL);
v4 = v10 - 1;
if ( (unsigned long long)(v10 - 1) >= 2 )
{
v5 = 1LL;
do
{
v6 = *((_BYTE *)v9 + v5);
if ( v6 == 92 && *((_BYTE *)v9 + v5 + 1) == 34 )
{
v12[0] = 34;
std::__ostream_insert<char,std::char_traits<char>>(a2, v12, 1LL);
++v5;
}
else if ( v6 == a3 )
{
v12[0] = 92;
v7 = std::__ostream_insert<char,std::char_traits<char>>(a2, v12, 1LL);
v12[0] = a3;
std::__ostream_insert<char,std::char_traits<char>>(v7, v12, 1LL);
}
else
{
v12[0] = *((_BYTE *)v9 + v5);
std::__ostream_insert<char,std::char_traits<char>>(a2, v12, 1LL);
}
++v5;
}
while ( v5 < v4 );
}
v12[0] = a3;
std::__ostream_insert<char,std::char_traits<char>>(a2, v12, 1LL);
}
else
{
std::__ostream_insert<char,std::char_traits<char>>(a2, v9, v10);
}
if ( v9 != &v11 )
operator delete(v9, v11 + 1);
}
|
dump_string:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x40
MOV R14,RDI
CMP byte ptr [RDI],0x3
JNZ 0x001872b3
MOV EBP,EDX
MOV RBX,RSI
MOV RDI,RSP
MOV RSI,R14
MOV EDX,0xffffffff
MOV ECX,0x20
XOR R8D,R8D
XOR R9D,R9D
CALL 0x0017fbc8
CMP BPL,0x22
JZ 0x001871b3
MOV RDI,RSP
MOV ESI,0x27
XOR EDX,EDX
CALL 0x0011ab60
CMP RAX,-0x1
JZ 0x001871ec
LAB_001871b3:
MOV RSI,qword ptr [RSP]
MOV RDX,qword ptr [RSP + 0x8]
LAB_001871bc:
MOV RDI,RBX
CALL 0x0011aa20
LAB_001871c4:
LEA RAX,[RSP + 0x10]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001871df
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x0011a900
LAB_001871df:
ADD RSP,0x40
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001871ec:
LEA RSI,[RSP + 0x20]
MOV byte ptr [RSI],BPL
MOV EDX,0x1
MOV RDI,RBX
CALL 0x0011aa20
MOV R15,qword ptr [RSP + 0x8]
DEC R15
CMP R15,0x2
JC 0x00187299
MOV R12D,0x1
LEA R14,[RSP + 0x20]
LAB_0018721e:
MOV RCX,qword ptr [RSP]
MOV AL,byte ptr [RCX + R12*0x1]
CMP AL,0x5c
JNZ 0x0018724c
CMP byte ptr [RCX + R12*0x1 + 0x1],0x22
JNZ 0x0018724c
MOV byte ptr [RSP + 0x20],0x22
LAB_00187237:
MOV EDX,0x1
MOV RDI,RBX
MOV RSI,R14
CALL 0x0011aa20
INC R12
JMP 0x00187291
LAB_0018724c:
CMP AL,BPL
JNZ 0x0018727d
MOV byte ptr [RSP + 0x20],0x5c
MOV EDX,0x1
MOV RDI,RBX
MOV RSI,R14
CALL 0x0011aa20
MOV byte ptr [RSP + 0x20],BPL
MOV EDX,0x1
MOV RDI,RAX
MOV RSI,R14
CALL 0x0011aa20
JMP 0x00187291
LAB_0018727d:
MOV byte ptr [RSP + 0x20],AL
MOV EDX,0x1
MOV RDI,RBX
MOV RSI,R14
CALL 0x0011aa20
LAB_00187291:
INC R12
CMP R12,R15
JC 0x0018721e
LAB_00187299:
LEA RSI,[RSP + 0x20]
MOV byte ptr [RSI],BPL
LAB_001872a1:
MOV EDX,0x1
MOV RDI,RBX
CALL 0x0011aa20
LAB_001872ae:
JMP 0x001871c4
LAB_001872b3:
MOV EDI,0x10
CALL 0x0011a460
MOV RBX,RAX
LAB_001872c0:
LEA RDI,[RSP + 0x20]
MOV RSI,R14
MOV EDX,0xffffffff
MOV ECX,0x20
XOR R8D,R8D
XOR R9D,R9D
CALL 0x0017fbc8
LAB_001872dd:
LEA RSI,[0x1efe47]
MOV RDI,RSP
LEA RDX,[RSP + 0x20]
CALL 0x00178e69
MOV BPL,0x1
LAB_001872f4:
MOV RSI,RSP
MOV RDI,RBX
CALL 0x0011ae50
XOR EBP,EBP
MOV RSI,qword ptr [0x0022bff0]
MOV RDX,qword ptr [0x0022bf60]
MOV RDI,RBX
CALL 0x0011af40
|
/* minja::Value::dump_string(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const&, std::__cxx11::ostringstream&, char) */
void minja::Value::dump_string(basic_json *param_1,ostringstream *param_2,char param_3)
{
long lVar1;
ostream *poVar2;
runtime_error *this;
ulong uVar3;
long *local_68;
long local_60;
long local_58 [2];
char local_48 [32];
if (*param_1 != (basic_json)0x3) {
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001872c0 to 001872dc has its CatchHandler @ 00187377 */
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::dump(local_48,param_1,0xffffffff,0x20,0,0);
/* try { // try from 001872dd to 001872f0 has its CatchHandler @ 00187357 */
std::operator+((char *)&local_68,(string *)"Value is not a string: ");
/* try { // try from 001872f4 to 00187316 has its CatchHandler @ 00187317 */
std::runtime_error::runtime_error(this,(string *)&local_68);
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_0022bff0,PTR__runtime_error_0022bf60);
}
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::dump(&local_68,param_1,0xffffffff,0x20,0,0);
if (param_3 != '\"') {
lVar1 = std::__cxx11::string::find((char)&local_68,0x27);
if (lVar1 == -1) {
local_48[0] = param_3;
std::__ostream_insert<char,std::char_traits<char>>((ostream *)param_2,local_48,1);
if (1 < local_60 - 1U) {
uVar3 = 1;
do {
local_48[0] = *(char *)((long)local_68 + uVar3);
if ((local_48[0] == '\\') && (*(char *)((long)local_68 + uVar3 + 1) == '\"')) {
local_48[0] = '\"';
/* try { // try from 00187237 to 00187290 has its CatchHandler @ 00187386 */
std::__ostream_insert<char,std::char_traits<char>>((ostream *)param_2,local_48,1);
uVar3 = uVar3 + 1;
}
else if (local_48[0] == param_3) {
local_48[0] = '\\';
poVar2 = std::__ostream_insert<char,std::char_traits<char>>
((ostream *)param_2,local_48,1);
local_48[0] = param_3;
std::__ostream_insert<char,std::char_traits<char>>(poVar2,local_48,1);
}
else {
std::__ostream_insert<char,std::char_traits<char>>((ostream *)param_2,local_48,1);
}
uVar3 = uVar3 + 1;
} while (uVar3 < local_60 - 1U);
}
local_48[0] = param_3;
/* try { // try from 001872a1 to 001872ad has its CatchHandler @ 00187384 */
std::__ostream_insert<char,std::char_traits<char>>((ostream *)param_2,local_48,1);
goto LAB_001871c4;
}
}
/* try { // try from 001871bc to 00187200 has its CatchHandler @ 00187384 */
std::__ostream_insert<char,std::char_traits<char>>((ostream *)param_2,(char *)local_68,local_60);
LAB_001871c4:
if (local_68 != local_58) {
operator_delete(local_68,local_58[0] + 1);
}
return;
}
|
|
11,739 |
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 0xe9503
movq 0x688(%rbx), %rax
jmp 0xe9547
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 0xe958a
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 0x5fea0
movq %r13, %rdi
callq 0x5f480
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 0xe9578
|
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_E9503
mov rax, [rbx+688h]
jmp short loc_E9547
loc_E9503:
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_E958A
mov r13, [rbx+690h]
mov r9, r14
loc_E9547:
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_E9578:
mov eax, r14d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_E958A:
mov r14d, 1
jmp short loc_E9578
|
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 0x001e9503
MOV RAX,qword ptr [RBX + 0x688]
JMP 0x001e9547
LAB_001e9503:
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 0x001e958a
MOV R13,qword ptr [RBX + 0x690]
MOV R9,R14
LAB_001e9547:
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 0x0015fea0
MOV RDI,R13
CALL 0x0015f480
ADD qword ptr [RBX + 0x690],RAX
LAB_001e9578:
MOV EAX,R14D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001e958a:
MOV R14D,0x1
JMP 0x001e9578
|
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;
}
|
|
11,740 |
ggml_get_first_tensor
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c
|
struct ggml_tensor * ggml_get_first_tensor(const struct ggml_context * ctx) {
struct ggml_object * obj = ctx->objects_begin;
char * const mem_buffer = ctx->mem_buffer;
while (obj != NULL) {
if (obj->type == GGML_OBJECT_TYPE_TENSOR) {
return (struct ggml_tensor *)(mem_buffer + obj->offs);
}
obj = obj->next;
}
return NULL;
}
|
O0
|
c
|
ggml_get_first_tensor:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4bf30
movq -0x18(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x4bf22
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
addq (%rcx), %rax
movq %rax, -0x8(%rbp)
jmp 0x4bf38
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x4bf00
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
|
ggml_get_first_tensor:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov rax, [rax+18h]
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rbp+var_20], rax
loc_4BF00:
cmp [rbp+var_18], 0
jz short loc_4BF30
mov rax, [rbp+var_18]
cmp dword ptr [rax+18h], 0
jnz short loc_4BF22
mov rax, [rbp+var_20]
mov rcx, [rbp+var_18]
add rax, [rcx]
mov [rbp+var_8], rax
jmp short loc_4BF38
loc_4BF22:
mov rax, [rbp+var_18]
mov rax, [rax+10h]
mov [rbp+var_18], rax
jmp short loc_4BF00
loc_4BF30:
mov [rbp+var_8], 0
loc_4BF38:
mov rax, [rbp+var_8]
pop rbp
retn
|
long long ggml_get_first_tensor(long long a1)
{
long long i; // [rsp+8h] [rbp-18h]
for ( i = *(_QWORD *)(a1 + 24); i; i = *(_QWORD *)(i + 16) )
{
if ( !*(_DWORD *)(i + 24) )
return *(_QWORD *)i + *(_QWORD *)(a1 + 8);
}
return 0LL;
}
|
ggml_get_first_tensor:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x20],RAX
LAB_0014bf00:
CMP qword ptr [RBP + -0x18],0x0
JZ 0x0014bf30
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX + 0x18],0x0
JNZ 0x0014bf22
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x18]
ADD RAX,qword ptr [RCX]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0014bf38
LAB_0014bf22:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0014bf00
LAB_0014bf30:
MOV qword ptr [RBP + -0x8],0x0
LAB_0014bf38:
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
long ggml_get_first_tensor(long param_1)
{
long *local_20;
local_20 = *(long **)(param_1 + 0x18);
while( true ) {
if (local_20 == (long *)0x0) {
return 0;
}
if ((int)local_20[3] == 0) break;
local_20 = (long *)local_20[2];
}
return *(long *)(param_1 + 8) + *local_20;
}
|
|
11,741 |
ggml_get_first_tensor
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c
|
struct ggml_tensor * ggml_get_first_tensor(const struct ggml_context * ctx) {
struct ggml_object * obj = ctx->objects_begin;
char * const mem_buffer = ctx->mem_buffer;
while (obj != NULL) {
if (obj->type == GGML_OBJECT_TYPE_TENSOR) {
return (struct ggml_tensor *)(mem_buffer + obj->offs);
}
obj = obj->next;
}
return NULL;
}
|
O1
|
c
|
ggml_get_first_tensor:
movq 0x18(%rdi), %rcx
testq %rcx, %rcx
je 0x1b83f
movq 0x8(%rdi), %rax
cmpl $0x0, 0x18(%rcx)
je 0x1b842
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
jne 0x1b830
xorl %eax, %eax
retq
addq (%rcx), %rax
retq
|
ggml_get_first_tensor:
mov rcx, [rdi+18h]
test rcx, rcx
jz short loc_1B83F
mov rax, [rdi+8]
loc_1B830:
cmp dword ptr [rcx+18h], 0
jz short loc_1B842
mov rcx, [rcx+10h]
test rcx, rcx
jnz short loc_1B830
loc_1B83F:
xor eax, eax
retn
loc_1B842:
add rax, [rcx]
retn
|
long long ggml_get_first_tensor(long long a1)
{
long long v1; // rcx
v1 = *(_QWORD *)(a1 + 24);
if ( !v1 )
return 0LL;
while ( *(_DWORD *)(v1 + 24) )
{
v1 = *(_QWORD *)(v1 + 16);
if ( !v1 )
return 0LL;
}
return *(_QWORD *)v1 + *(_QWORD *)(a1 + 8);
}
|
ggml_get_first_tensor:
MOV RCX,qword ptr [RDI + 0x18]
TEST RCX,RCX
JZ 0x0011b83f
MOV RAX,qword ptr [RDI + 0x8]
LAB_0011b830:
CMP dword ptr [RCX + 0x18],0x0
JZ 0x0011b842
MOV RCX,qword ptr [RCX + 0x10]
TEST RCX,RCX
JNZ 0x0011b830
LAB_0011b83f:
XOR EAX,EAX
RET
LAB_0011b842:
ADD RAX,qword ptr [RCX]
RET
|
long ggml_get_first_tensor(long param_1)
{
long *plVar1;
plVar1 = *(long **)(param_1 + 0x18);
if (plVar1 != (long *)0x0) {
do {
if ((int)plVar1[3] == 0) {
return *(long *)(param_1 + 8) + *plVar1;
}
plVar1 = (long *)plVar1[2];
} while (plVar1 != (long *)0x0);
}
return 0;
}
|
|
11,742 |
ggml_get_first_tensor
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c
|
struct ggml_tensor * ggml_get_first_tensor(const struct ggml_context * ctx) {
struct ggml_object * obj = ctx->objects_begin;
char * const mem_buffer = ctx->mem_buffer;
while (obj != NULL) {
if (obj->type == GGML_OBJECT_TYPE_TENSOR) {
return (struct ggml_tensor *)(mem_buffer + obj->offs);
}
obj = obj->next;
}
return NULL;
}
|
O3
|
c
|
ggml_get_first_tensor:
movq 0x18(%rdi), %rcx
testq %rcx, %rcx
je 0x1a54d
movq 0x8(%rdi), %rax
cmpl $0x0, 0x18(%rcx)
je 0x1a550
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
jne 0x1a53e
xorl %eax, %eax
retq
addq (%rcx), %rax
retq
|
ggml_get_first_tensor:
mov rcx, [rdi+18h]
test rcx, rcx
jz short loc_1A54D
mov rax, [rdi+8]
loc_1A53E:
cmp dword ptr [rcx+18h], 0
jz short loc_1A550
mov rcx, [rcx+10h]
test rcx, rcx
jnz short loc_1A53E
loc_1A54D:
xor eax, eax
retn
loc_1A550:
add rax, [rcx]
retn
|
long long ggml_get_first_tensor(long long a1)
{
long long v1; // rcx
v1 = *(_QWORD *)(a1 + 24);
if ( !v1 )
return 0LL;
while ( *(_DWORD *)(v1 + 24) )
{
v1 = *(_QWORD *)(v1 + 16);
if ( !v1 )
return 0LL;
}
return *(_QWORD *)v1 + *(_QWORD *)(a1 + 8);
}
|
ggml_get_first_tensor:
MOV RCX,qword ptr [RDI + 0x18]
TEST RCX,RCX
JZ 0x0011a54d
MOV RAX,qword ptr [RDI + 0x8]
LAB_0011a53e:
CMP dword ptr [RCX + 0x18],0x0
JZ 0x0011a550
MOV RCX,qword ptr [RCX + 0x10]
TEST RCX,RCX
JNZ 0x0011a53e
LAB_0011a54d:
XOR EAX,EAX
RET
LAB_0011a550:
ADD RAX,qword ptr [RCX]
RET
|
long ggml_get_first_tensor(long param_1)
{
long *plVar1;
plVar1 = *(long **)(param_1 + 0x18);
if (plVar1 != (long *)0x0) {
do {
if ((int)plVar1[3] == 0) {
return *(long *)(param_1 + 8) + *plVar1;
}
plVar1 = (long *)plVar1[2];
} while (plVar1 != (long *)0x0);
}
return 0;
}
|
|
11,743 |
my_b_cache_read_r
|
eloqsql/mysys/mf_iocache.c
|
static int _my_b_cache_read_r(IO_CACHE *cache, uchar *Buffer, size_t Count)
{
my_off_t pos_in_file;
size_t length, diff_length, left_length= 0;
IO_CACHE_SHARE *cshare= cache->share;
DBUG_ENTER("_my_b_cache_read_r");
DBUG_ASSERT(!(cache->myflags & MY_ENCRYPT));
while (Count)
{
size_t cnt, len;
pos_in_file= cache->pos_in_file + (cache->read_end - cache->buffer);
diff_length= (size_t) (pos_in_file & (IO_SIZE-1));
length=IO_ROUND_UP(Count+diff_length)-diff_length;
length= ((length <= cache->read_length) ?
length + IO_ROUND_DN(cache->read_length - length) :
length - IO_ROUND_UP(length - cache->read_length));
if (cache->type != READ_FIFO &&
(length > (cache->end_of_file - pos_in_file)))
length= (size_t) (cache->end_of_file - pos_in_file);
if (length == 0)
{
cache->error= (int) left_length;
DBUG_RETURN(1);
}
if (lock_io_cache(cache, pos_in_file))
{
/* With a synchronized write/read cache we won't come here... */
DBUG_ASSERT(!cshare->source_cache);
/*
... unless the writer has gone before this thread entered the
lock. Simulate EOF in this case. It can be distinguished by
cache->file.
*/
if (cache->file < 0)
len= 0;
else
{
/*
Whenever a function which operates on IO_CACHE flushes/writes
some part of the IO_CACHE to disk it will set the property
"seek_not_done" to indicate this to other functions operating
on the IO_CACHE.
*/
if (cache->seek_not_done)
{
if (mysql_file_seek(cache->file, pos_in_file, MY_SEEK_SET, MYF(0))
== MY_FILEPOS_ERROR)
{
cache->error= -1;
unlock_io_cache(cache);
DBUG_RETURN(1);
}
}
len= mysql_file_read(cache->file, cache->buffer, length, cache->myflags);
}
DBUG_PRINT("io_cache_share", ("read %lu bytes", (ulong) len));
cache->read_end= cache->buffer + (len == (size_t) -1 ? 0 : len);
cache->error= (len == length ? 0 : (int) len);
cache->pos_in_file= pos_in_file;
/* Copy important values to the share. */
cshare->error= cache->error;
cshare->read_end= cache->read_end;
cshare->pos_in_file= pos_in_file;
/* Mark all threads as running and wake them. */
unlock_io_cache(cache);
}
else
{
/*
With a synchronized write/read cache readers always come here.
Copy important values from the share.
*/
cache->error= cshare->error;
cache->read_end= cshare->read_end;
cache->pos_in_file= cshare->pos_in_file;
len= ((cache->error == -1) ? (size_t) -1 :
(size_t) (cache->read_end - cache->buffer));
}
cache->read_pos= cache->buffer;
cache->seek_not_done= 0;
if (len == 0 || len == (size_t) -1)
{
DBUG_PRINT("io_cache_share", ("reader error. len %lu left %lu",
(ulong) len, (ulong) left_length));
cache->error= (int) left_length;
DBUG_RETURN(1);
}
cnt= (len > Count) ? Count : len;
if (cnt)
memcpy(Buffer, cache->read_pos, cnt);
Count -= cnt;
Buffer+= cnt;
left_length+= cnt;
cache->read_pos+= cnt;
}
DBUG_RETURN(0);
}
|
O0
|
c
|
my_b_cache_read_r:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0xe0f50
jmp 0xe0f52
cmpq $0x0, -0x20(%rbp)
je 0xe1333
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq -0x10(%rbp), %rdx
movq 0x20(%rdx), %rdx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
andq $0xfff, %rax # imm = 0xFFF
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
addq -0x38(%rbp), %rax
addq $0x1000, %rax # imm = 0x1000
subq $0x1, %rax
movabsq $0xfffff000, %rcx # imm = 0xFFFFF000
andq %rcx, %rax
subq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0xf0(%rcx), %rax
ja 0xe0fed
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0xf0(%rcx), %rcx
subq -0x30(%rbp), %rcx
movabsq $0xfffff000, %rdx # imm = 0xFFFFF000
andq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x60(%rbp)
jmp 0xe101f
movq -0x30(%rbp), %rax
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rdx
subq 0xf0(%rdx), %rcx
addq $0x1000, %rcx # imm = 0x1000
subq $0x1, %rcx
movabsq $0xfffff000, %rdx # imm = 0xFFFFF000
andq %rdx, %rcx
subq %rcx, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x4, 0xb0(%rax)
je 0xe1059
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq -0x28(%rbp), %rcx
cmpq %rcx, %rax
jbe 0xe1059
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
subq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xe107c
movq -0x40(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xe4(%rax)
movl $0x1, -0x4(%rbp)
jmp 0xe133c
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xe2b00
cmpl $0x0, %eax
je 0xe11f0
jmp 0xe1094
jmp 0xe1096
movq -0x10(%rbp), %rax
cmpl $0x0, 0xd4(%rax)
jge 0xe10b0
movq $0x0, -0x58(%rbp)
jmp 0xe1145
movq -0x10(%rbp), %rax
cmpl $0x0, 0xe0(%rax)
je 0xe110f
movq -0x10(%rbp), %rax
movl 0xd4(%rax), %edx
movq -0x28(%rbp), %rcx
leaq 0x72ef9(%rip), %rdi # 0x153fcb
movl $0x4cb, %esi # imm = 0x4CB
xorl %r8d, %r8d
xorl %eax, %eax
movl %eax, %r9d
callq 0xdff80
cmpq $-0x1, %rax
jne 0xe110d
movq -0x10(%rbp), %rax
movl $0xffffffff, 0xe4(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
callq 0xe2d60
movl $0x1, -0x4(%rbp)
jmp 0xe133c
jmp 0xe110f
movq -0x10(%rbp), %rax
movl 0xd4(%rax), %edx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x30(%rbp), %r8
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %r9
leaq 0x72e94(%rip), %rdi # 0x153fcb
movl $0x4d3, %esi # imm = 0x4D3
callq 0xe2990
movq %rax, -0x58(%rbp)
jmp 0xe1147
jmp 0xe1149
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x68(%rbp)
cmpq $-0x1, -0x58(%rbp)
jne 0xe1164
xorl %eax, %eax
movq %rax, -0x70(%rbp)
jmp 0xe116c
movq -0x58(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rcx
movq -0x70(%rbp), %rax
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x58(%rbp), %rax
cmpq -0x30(%rbp), %rax
jne 0xe1190
xorl %eax, %eax
movl %eax, -0x74(%rbp)
jmp 0xe1197
movq -0x58(%rbp), %rax
movl %eax, -0x74(%rbp)
movl -0x74(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xe4(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl 0xe4(%rax), %ecx
movq -0x48(%rbp), %rax
movl %ecx, 0xe0(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0xd0(%rax)
movq -0x28(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0xb8(%rax)
movq -0x10(%rbp), %rdi
callq 0xe2d60
jmp 0xe1262
movq -0x48(%rbp), %rax
movl 0xe0(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xe4(%rax)
movq -0x48(%rbp), %rax
movq 0xd0(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x48(%rbp), %rax
movq 0xb8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0xe4(%rax)
jne 0xe1243
movq $-0x1, %rax
movq %rax, -0x80(%rbp)
jmp 0xe125a
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0xe0(%rax)
cmpq $0x0, -0x58(%rbp)
je 0xe128e
cmpq $-0x1, -0x58(%rbp)
jne 0xe12ae
jmp 0xe1290
jmp 0xe1292
movq -0x40(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xe4(%rax)
movl $0x1, -0x4(%rbp)
jmp 0xe133c
movq -0x58(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0xe12c5
movq -0x20(%rbp), %rax
movq %rax, -0x88(%rbp)
jmp 0xe12d0
movq -0x58(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0xe12f7
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x50(%rbp), %rdx
callq 0x2a090
movq -0x50(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x50(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x50(%rbp), %rax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x50(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
jmp 0xe0f52
jmp 0xe1335
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
_my_b_cache_read_r:
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_40], 0
mov rax, [rbp+var_10]
mov rax, [rax+98h]
mov [rbp+var_48], rax
jmp short $+2
loc_E0F50:
jmp short $+2
loc_E0F52:
cmp [rbp+var_20], 0
jz loc_E1333
mov rax, [rbp+var_10]
mov rax, [rax]
mov rcx, [rbp+var_10]
mov rcx, [rcx+18h]
mov rdx, [rbp+var_10]
mov rdx, [rdx+20h]
sub rcx, rdx
add rax, rcx
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
and rax, 0FFFh
mov [rbp+var_38], rax
mov rax, [rbp+var_20]
add rax, [rbp+var_38]
add rax, 1000h
sub rax, 1
mov rcx, 0FFFFF000h
and rax, rcx
sub rax, [rbp+var_38]
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
mov rcx, [rbp+var_10]
cmp rax, [rcx+0F0h]
ja short loc_E0FED
mov rax, [rbp+var_30]
mov rcx, [rbp+var_10]
mov rcx, [rcx+0F0h]
sub rcx, [rbp+var_30]
mov rdx, 0FFFFF000h
and rcx, rdx
add rax, rcx
mov [rbp+var_60], rax
jmp short loc_E101F
loc_E0FED:
mov rax, [rbp+var_30]
mov rcx, [rbp+var_30]
mov rdx, [rbp+var_10]
sub rcx, [rdx+0F0h]
add rcx, 1000h
sub rcx, 1
mov rdx, 0FFFFF000h
and rcx, rdx
sub rax, rcx
mov [rbp+var_60], rax
loc_E101F:
mov rax, [rbp+var_60]
mov [rbp+var_30], rax
mov rax, [rbp+var_10]
cmp dword ptr [rax+0B0h], 4
jz short loc_E1059
mov rax, [rbp+var_30]
mov rcx, [rbp+var_10]
mov rcx, [rcx+8]
sub rcx, [rbp+var_28]
cmp rax, rcx
jbe short loc_E1059
mov rax, [rbp+var_10]
mov rax, [rax+8]
sub rax, [rbp+var_28]
mov [rbp+var_30], rax
loc_E1059:
cmp [rbp+var_30], 0
jnz short loc_E107C
mov rax, [rbp+var_40]
mov ecx, eax
mov rax, [rbp+var_10]
mov [rax+0E4h], ecx
mov [rbp+var_4], 1
jmp loc_E133C
loc_E107C:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
call lock_io_cache
cmp eax, 0
jz loc_E11F0
jmp short $+2
loc_E1094:
jmp short $+2
loc_E1096:
mov rax, [rbp+var_10]
cmp dword ptr [rax+0D4h], 0
jge short loc_E10B0
mov [rbp+var_58], 0
jmp loc_E1145
loc_E10B0:
mov rax, [rbp+var_10]
cmp dword ptr [rax+0E0h], 0
jz short loc_E110F
mov rax, [rbp+var_10]
mov edx, [rax+0D4h]
mov rcx, [rbp+var_28]
lea rdi, aWorkspaceLlm4b_35; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 4CBh
xor r8d, r8d
xor eax, eax
mov r9d, eax
call inline_mysql_file_seek_6
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_E110D
mov rax, [rbp+var_10]
mov dword ptr [rax+0E4h], 0FFFFFFFFh
mov rdi, [rbp+var_10]
call unlock_io_cache
mov [rbp+var_4], 1
jmp loc_E133C
loc_E110D:
jmp short $+2
loc_E110F:
mov rax, [rbp+var_10]
mov edx, [rax+0D4h]
mov rax, [rbp+var_10]
mov rcx, [rax+20h]
mov r8, [rbp+var_30]
mov rax, [rbp+var_10]
mov r9, [rax+0F8h]
lea rdi, aWorkspaceLlm4b_35; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 4D3h
call inline_mysql_file_read_5
mov [rbp+var_58], rax
loc_E1145:
jmp short $+2
loc_E1147:
jmp short $+2
loc_E1149:
mov rax, [rbp+var_10]
mov rax, [rax+20h]
mov [rbp+var_68], rax
cmp [rbp+var_58], 0FFFFFFFFFFFFFFFFh
jnz short loc_E1164
xor eax, eax
mov [rbp+var_70], rax
jmp short loc_E116C
loc_E1164:
mov rax, [rbp+var_58]
mov [rbp+var_70], rax
loc_E116C:
mov rcx, [rbp+var_68]
mov rax, [rbp+var_70]
add rcx, rax
mov rax, [rbp+var_10]
mov [rax+18h], rcx
mov rax, [rbp+var_58]
cmp rax, [rbp+var_30]
jnz short loc_E1190
xor eax, eax
mov [rbp+var_74], eax
jmp short loc_E1197
loc_E1190:
mov rax, [rbp+var_58]
mov [rbp+var_74], eax
loc_E1197:
mov ecx, [rbp+var_74]
mov rax, [rbp+var_10]
mov [rax+0E4h], ecx
mov rcx, [rbp+var_28]
mov rax, [rbp+var_10]
mov [rax], rcx
mov rax, [rbp+var_10]
mov ecx, [rax+0E4h]
mov rax, [rbp+var_48]
mov [rax+0E0h], ecx
mov rax, [rbp+var_10]
mov rcx, [rax+18h]
mov rax, [rbp+var_48]
mov [rax+0D0h], rcx
mov rcx, [rbp+var_28]
mov rax, [rbp+var_48]
mov [rax+0B8h], rcx
mov rdi, [rbp+var_10]
call unlock_io_cache
jmp short loc_E1262
loc_E11F0:
mov rax, [rbp+var_48]
mov ecx, [rax+0E0h]
mov rax, [rbp+var_10]
mov [rax+0E4h], ecx
mov rax, [rbp+var_48]
mov rcx, [rax+0D0h]
mov rax, [rbp+var_10]
mov [rax+18h], rcx
mov rax, [rbp+var_48]
mov rcx, [rax+0B8h]
mov rax, [rbp+var_10]
mov [rax], rcx
mov rax, [rbp+var_10]
cmp dword ptr [rax+0E4h], 0FFFFFFFFh
jnz short loc_E1243
mov rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_80], rax
jmp short loc_E125A
loc_E1243:
mov rax, [rbp+var_10]
mov rax, [rax+18h]
mov rcx, [rbp+var_10]
mov rcx, [rcx+20h]
sub rax, rcx
mov [rbp+var_80], rax
loc_E125A:
mov rax, [rbp+var_80]
mov [rbp+var_58], rax
loc_E1262:
mov rax, [rbp+var_10]
mov rcx, [rax+20h]
mov rax, [rbp+var_10]
mov [rax+10h], rcx
mov rax, [rbp+var_10]
mov dword ptr [rax+0E0h], 0
cmp [rbp+var_58], 0
jz short loc_E128E
cmp [rbp+var_58], 0FFFFFFFFFFFFFFFFh
jnz short loc_E12AE
loc_E128E:
jmp short $+2
loc_E1290:
jmp short $+2
loc_E1292:
mov rax, [rbp+var_40]
mov ecx, eax
mov rax, [rbp+var_10]
mov [rax+0E4h], ecx
mov [rbp+var_4], 1
jmp loc_E133C
loc_E12AE:
mov rax, [rbp+var_58]
cmp rax, [rbp+var_20]
jbe short loc_E12C5
mov rax, [rbp+var_20]
mov [rbp+var_88], rax
jmp short loc_E12D0
loc_E12C5:
mov rax, [rbp+var_58]
mov [rbp+var_88], rax
loc_E12D0:
mov rax, [rbp+var_88]
mov [rbp+var_50], rax
cmp [rbp+var_50], 0
jz short loc_E12F7
mov rdi, [rbp+var_18]
mov rax, [rbp+var_10]
mov rsi, [rax+10h]
mov rdx, [rbp+var_50]
call _memcpy
loc_E12F7:
mov rcx, [rbp+var_50]
mov rax, [rbp+var_20]
sub rax, rcx
mov [rbp+var_20], rax
mov rax, [rbp+var_50]
add rax, [rbp+var_18]
mov [rbp+var_18], rax
mov rax, [rbp+var_50]
add rax, [rbp+var_40]
mov [rbp+var_40], rax
mov rcx, [rbp+var_50]
mov rax, [rbp+var_10]
add rcx, [rax+10h]
mov [rax+10h], rcx
jmp loc_E0F52
loc_E1333:
jmp short $+2
loc_E1335:
mov [rbp+var_4], 0
loc_E133C:
mov eax, [rbp+var_4]
add rsp, 90h
pop rbp
retn
|
long long my_b_cache_read_r(long long a1, long long a2, unsigned long long a3)
{
unsigned long long v4; // [rsp+8h] [rbp-88h]
long long v5; // [rsp+10h] [rbp-80h]
int v6; // [rsp+1Ch] [rbp-74h]
unsigned long long v7; // [rsp+20h] [rbp-70h]
unsigned long long v8; // [rsp+30h] [rbp-60h]
unsigned long long v9; // [rsp+38h] [rbp-58h]
long long v10; // [rsp+48h] [rbp-48h]
int v11; // [rsp+50h] [rbp-40h]
unsigned long long v12; // [rsp+60h] [rbp-30h]
long long v13; // [rsp+60h] [rbp-30h]
long long v14; // [rsp+68h] [rbp-28h]
v11 = 0;
v10 = *(_QWORD *)(a1 + 152);
while ( a3 )
{
v14 = *(_QWORD *)(a1 + 24) - *(_QWORD *)(a1 + 32) + *(_QWORD *)a1;
v12 = (((v14 & 0xFFF) + a3 + 4095) & 0xFFFFF000) - (v14 & 0xFFF);
if ( v12 > *(_QWORD *)(a1 + 240) )
v8 = v12 - ((v12 - *(_QWORD *)(a1 + 240) + 4095) & 0xFFFFF000);
else
v8 = ((*(_QWORD *)(a1 + 240) - v12) & 0xFFFFF000) + v12;
v13 = v8;
if ( *(_DWORD *)(a1 + 176) != 4 && v8 > *(_QWORD *)(a1 + 8) - v14 )
v13 = *(_QWORD *)(a1 + 8) - v14;
if ( !v13 )
{
*(_DWORD *)(a1 + 228) = v11;
return 1;
}
if ( (unsigned int)lock_io_cache(a1, v14) )
{
if ( *(int *)(a1 + 212) >= 0 )
{
if ( *(_DWORD *)(a1 + 224)
&& inline_mysql_file_seek_6(
(long long)"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",
0x4CBu,
*(_DWORD *)(a1 + 212),
v14,
0,
0LL) == -1 )
{
*(_DWORD *)(a1 + 228) = -1;
unlock_io_cache(a1);
return 1;
}
v9 = inline_mysql_file_read_5(
"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",
1235LL,
*(unsigned int *)(a1 + 212),
*(_QWORD *)(a1 + 32),
v13,
*(_QWORD *)(a1 + 248));
}
else
{
v9 = 0LL;
}
if ( v9 == -1LL )
v7 = 0LL;
else
v7 = v9;
*(_QWORD *)(a1 + 24) = v7 + *(_QWORD *)(a1 + 32);
if ( v9 == v13 )
v6 = 0;
else
v6 = v9;
*(_DWORD *)(a1 + 228) = v6;
*(_QWORD *)a1 = v14;
*(_DWORD *)(v10 + 224) = *(_DWORD *)(a1 + 228);
*(_QWORD *)(v10 + 208) = *(_QWORD *)(a1 + 24);
*(_QWORD *)(v10 + 184) = v14;
unlock_io_cache(a1);
}
else
{
*(_DWORD *)(a1 + 228) = *(_DWORD *)(v10 + 224);
*(_QWORD *)(a1 + 24) = *(_QWORD *)(v10 + 208);
*(_QWORD *)a1 = *(_QWORD *)(v10 + 184);
if ( *(_DWORD *)(a1 + 228) == -1 )
v5 = -1LL;
else
v5 = *(_QWORD *)(a1 + 24) - *(_QWORD *)(a1 + 32);
v9 = v5;
}
*(_QWORD *)(a1 + 16) = *(_QWORD *)(a1 + 32);
*(_DWORD *)(a1 + 224) = 0;
if ( !v9 || v9 == -1LL )
{
*(_DWORD *)(a1 + 228) = v11;
return 1;
}
if ( v9 <= a3 )
v4 = v9;
else
v4 = a3;
memcpy(a2, *(_QWORD *)(a1 + 16), v4);
a3 -= v4;
a2 += v4;
v11 += v4;
*(_QWORD *)(a1 + 16) += v4;
}
return 0;
}
|
_my_b_cache_read_r:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x40],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x98]
MOV qword ptr [RBP + -0x48],RAX
JMP 0x001e0f50
LAB_001e0f50:
JMP 0x001e0f52
LAB_001e0f52:
CMP qword ptr [RBP + -0x20],0x0
JZ 0x001e1333
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x18]
MOV RDX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RDX + 0x20]
SUB RCX,RDX
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
AND RAX,0xfff
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,qword ptr [RBP + -0x38]
ADD RAX,0x1000
SUB RAX,0x1
MOV RCX,0xfffff000
AND RAX,RCX
SUB RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0xf0]
JA 0x001e0fed
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0xf0]
SUB RCX,qword ptr [RBP + -0x30]
MOV RDX,0xfffff000
AND RCX,RDX
ADD RAX,RCX
MOV qword ptr [RBP + -0x60],RAX
JMP 0x001e101f
LAB_001e0fed:
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x10]
SUB RCX,qword ptr [RDX + 0xf0]
ADD RCX,0x1000
SUB RCX,0x1
MOV RDX,0xfffff000
AND RCX,RDX
SUB RAX,RCX
MOV qword ptr [RBP + -0x60],RAX
LAB_001e101f:
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0xb0],0x4
JZ 0x001e1059
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x8]
SUB RCX,qword ptr [RBP + -0x28]
CMP RAX,RCX
JBE 0x001e1059
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
SUB RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x30],RAX
LAB_001e1059:
CMP qword ptr [RBP + -0x30],0x0
JNZ 0x001e107c
MOV RAX,qword ptr [RBP + -0x40]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe4],ECX
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001e133c
LAB_001e107c:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x001e2b00
CMP EAX,0x0
JZ 0x001e11f0
JMP 0x001e1094
LAB_001e1094:
JMP 0x001e1096
LAB_001e1096:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0xd4],0x0
JGE 0x001e10b0
MOV qword ptr [RBP + -0x58],0x0
JMP 0x001e1145
LAB_001e10b0:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0xe0],0x0
JZ 0x001e110f
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RAX + 0xd4]
MOV RCX,qword ptr [RBP + -0x28]
LEA RDI,[0x253fcb]
MOV ESI,0x4cb
XOR R8D,R8D
XOR EAX,EAX
MOV R9D,EAX
CALL 0x001dff80
CMP RAX,-0x1
JNZ 0x001e110d
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe4],0xffffffff
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001e2d60
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001e133c
LAB_001e110d:
JMP 0x001e110f
LAB_001e110f:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RAX + 0xd4]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x20]
MOV R8,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV R9,qword ptr [RAX + 0xf8]
LEA RDI,[0x253fcb]
MOV ESI,0x4d3
CALL 0x001e2990
MOV qword ptr [RBP + -0x58],RAX
LAB_001e1145:
JMP 0x001e1147
LAB_001e1147:
JMP 0x001e1149
LAB_001e1149:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x20]
MOV qword ptr [RBP + -0x68],RAX
CMP qword ptr [RBP + -0x58],-0x1
JNZ 0x001e1164
XOR EAX,EAX
MOV qword ptr [RBP + -0x70],RAX
JMP 0x001e116c
LAB_001e1164:
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x70],RAX
LAB_001e116c:
MOV RCX,qword ptr [RBP + -0x68]
MOV RAX,qword ptr [RBP + -0x70]
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x18],RCX
MOV RAX,qword ptr [RBP + -0x58]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001e1190
XOR EAX,EAX
MOV dword ptr [RBP + -0x74],EAX
JMP 0x001e1197
LAB_001e1190:
MOV RAX,qword ptr [RBP + -0x58]
MOV dword ptr [RBP + -0x74],EAX
LAB_001e1197:
MOV ECX,dword ptr [RBP + -0x74]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe4],ECX
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0xe4]
MOV RAX,qword ptr [RBP + -0x48]
MOV dword ptr [RAX + 0xe0],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX + 0xd0],RCX
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX + 0xb8],RCX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001e2d60
JMP 0x001e1262
LAB_001e11f0:
MOV RAX,qword ptr [RBP + -0x48]
MOV ECX,dword ptr [RAX + 0xe0]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe4],ECX
MOV RAX,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RAX + 0xd0]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x18],RCX
MOV RAX,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0xe4],-0x1
JNZ 0x001e1243
MOV RAX,-0x1
MOV qword ptr [RBP + -0x80],RAX
JMP 0x001e125a
LAB_001e1243:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x18]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x20]
SUB RAX,RCX
MOV qword ptr [RBP + -0x80],RAX
LAB_001e125a:
MOV RAX,qword ptr [RBP + -0x80]
MOV qword ptr [RBP + -0x58],RAX
LAB_001e1262:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe0],0x0
CMP qword ptr [RBP + -0x58],0x0
JZ 0x001e128e
CMP qword ptr [RBP + -0x58],-0x1
JNZ 0x001e12ae
LAB_001e128e:
JMP 0x001e1290
LAB_001e1290:
JMP 0x001e1292
LAB_001e1292:
MOV RAX,qword ptr [RBP + -0x40]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe4],ECX
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001e133c
LAB_001e12ae:
MOV RAX,qword ptr [RBP + -0x58]
CMP RAX,qword ptr [RBP + -0x20]
JBE 0x001e12c5
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x88],RAX
JMP 0x001e12d0
LAB_001e12c5:
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x88],RAX
LAB_001e12d0:
MOV RAX,qword ptr [RBP + -0x88]
MOV qword ptr [RBP + -0x50],RAX
CMP qword ptr [RBP + -0x50],0x0
JZ 0x001e12f7
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x10]
MOV RDX,qword ptr [RBP + -0x50]
CALL 0x0012a090
LAB_001e12f7:
MOV RCX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x20]
SUB RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x40],RAX
MOV RCX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x10]
ADD RCX,qword ptr [RAX + 0x10]
MOV qword ptr [RAX + 0x10],RCX
JMP 0x001e0f52
LAB_001e1333:
JMP 0x001e1335
LAB_001e1335:
MOV dword ptr [RBP + -0x4],0x0
LAB_001e133c:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x90
POP RBP
RET
|
int4 _my_b_cache_read_r(ulong *param_1,void *param_2,ulong param_3)
{
ulong uVar1;
int iVar2;
ulong uVar3;
long lVar4;
ulong uVar5;
size_t local_90;
ulong local_88;
int4 local_7c;
ulong local_78;
ulong local_68;
ulong local_60;
long local_48;
ulong local_38;
ulong local_28;
void *local_20;
local_48 = 0;
uVar1 = param_1[0x13];
local_28 = param_3;
local_20 = param_2;
while( true ) {
if (local_28 == 0) {
return 0;
}
uVar3 = *param_1 + (param_1[3] - param_1[4]);
local_68 = (local_28 + (uVar3 & 0xfff) + 0xfff & 0xfffff000) - (uVar3 & 0xfff);
if (param_1[0x1e] < local_68) {
uVar5 = -((local_68 - param_1[0x1e]) + 0xfff & 0xfffff000);
}
else {
uVar5 = param_1[0x1e] - local_68 & 0xfffff000;
}
local_68 = local_68 + uVar5;
local_38 = local_68;
if (((int)param_1[0x16] != 4) && (param_1[1] - uVar3 < local_68)) {
local_38 = param_1[1] - uVar3;
}
if (local_38 == 0) {
*(int *)((long)param_1 + 0xe4) = (int)local_48;
return 1;
}
iVar2 = lock_io_cache(param_1,uVar3);
if (iVar2 == 0) {
*(int4 *)((long)param_1 + 0xe4) = *(int4 *)(uVar1 + 0xe0);
param_1[3] = *(ulong *)(uVar1 + 0xd0);
*param_1 = *(ulong *)(uVar1 + 0xb8);
if (*(int *)((long)param_1 + 0xe4) == -1) {
local_88 = 0xffffffffffffffff;
}
else {
local_88 = param_1[3] - param_1[4];
}
local_60 = local_88;
}
else {
if (*(int *)((long)param_1 + 0xd4) < 0) {
local_60 = 0;
}
else {
if (((int)param_1[0x1c] != 0) &&
(lVar4 = inline_mysql_file_seek
("/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",0x4cb,
*(int4 *)((long)param_1 + 0xd4),uVar3,0,0), lVar4 == -1)) {
*(int4 *)((long)param_1 + 0xe4) = 0xffffffff;
unlock_io_cache(param_1);
return 1;
}
local_60 = inline_mysql_file_read
("/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",0x4d3,
*(int4 *)((long)param_1 + 0xd4),param_1[4],local_38,
param_1[0x1f]);
}
if (local_60 == 0xffffffffffffffff) {
local_78 = 0;
}
else {
local_78 = local_60;
}
param_1[3] = param_1[4] + local_78;
if (local_60 == local_38) {
local_7c = 0;
}
else {
local_7c = (int4)local_60;
}
*(int4 *)((long)param_1 + 0xe4) = local_7c;
*param_1 = uVar3;
*(int4 *)(uVar1 + 0xe0) = *(int4 *)((long)param_1 + 0xe4);
*(ulong *)(uVar1 + 0xd0) = param_1[3];
*(ulong *)(uVar1 + 0xb8) = uVar3;
unlock_io_cache(param_1);
}
param_1[2] = param_1[4];
*(int4 *)(param_1 + 0x1c) = 0;
if ((local_60 == 0) || (local_60 == 0xffffffffffffffff)) break;
if (local_28 < local_60) {
local_90 = local_28;
}
else {
local_90 = local_60;
}
if (local_90 != 0) {
memcpy(local_20,(void *)param_1[2],local_90);
}
local_28 = local_28 - local_90;
local_20 = (void *)(local_90 + (long)local_20);
local_48 = local_90 + local_48;
param_1[2] = local_90 + param_1[2];
}
*(int *)((long)param_1 + 0xe4) = (int)local_48;
return 1;
}
|
|
11,744 |
my_b_cache_read_r
|
eloqsql/mysys/mf_iocache.c
|
static int _my_b_cache_read_r(IO_CACHE *cache, uchar *Buffer, size_t Count)
{
my_off_t pos_in_file;
size_t length, diff_length, left_length= 0;
IO_CACHE_SHARE *cshare= cache->share;
DBUG_ENTER("_my_b_cache_read_r");
DBUG_ASSERT(!(cache->myflags & MY_ENCRYPT));
while (Count)
{
size_t cnt, len;
pos_in_file= cache->pos_in_file + (cache->read_end - cache->buffer);
diff_length= (size_t) (pos_in_file & (IO_SIZE-1));
length=IO_ROUND_UP(Count+diff_length)-diff_length;
length= ((length <= cache->read_length) ?
length + IO_ROUND_DN(cache->read_length - length) :
length - IO_ROUND_UP(length - cache->read_length));
if (cache->type != READ_FIFO &&
(length > (cache->end_of_file - pos_in_file)))
length= (size_t) (cache->end_of_file - pos_in_file);
if (length == 0)
{
cache->error= (int) left_length;
DBUG_RETURN(1);
}
if (lock_io_cache(cache, pos_in_file))
{
/* With a synchronized write/read cache we won't come here... */
DBUG_ASSERT(!cshare->source_cache);
/*
... unless the writer has gone before this thread entered the
lock. Simulate EOF in this case. It can be distinguished by
cache->file.
*/
if (cache->file < 0)
len= 0;
else
{
/*
Whenever a function which operates on IO_CACHE flushes/writes
some part of the IO_CACHE to disk it will set the property
"seek_not_done" to indicate this to other functions operating
on the IO_CACHE.
*/
if (cache->seek_not_done)
{
if (mysql_file_seek(cache->file, pos_in_file, MY_SEEK_SET, MYF(0))
== MY_FILEPOS_ERROR)
{
cache->error= -1;
unlock_io_cache(cache);
DBUG_RETURN(1);
}
}
len= mysql_file_read(cache->file, cache->buffer, length, cache->myflags);
}
DBUG_PRINT("io_cache_share", ("read %lu bytes", (ulong) len));
cache->read_end= cache->buffer + (len == (size_t) -1 ? 0 : len);
cache->error= (len == length ? 0 : (int) len);
cache->pos_in_file= pos_in_file;
/* Copy important values to the share. */
cshare->error= cache->error;
cshare->read_end= cache->read_end;
cshare->pos_in_file= pos_in_file;
/* Mark all threads as running and wake them. */
unlock_io_cache(cache);
}
else
{
/*
With a synchronized write/read cache readers always come here.
Copy important values from the share.
*/
cache->error= cshare->error;
cache->read_end= cshare->read_end;
cache->pos_in_file= cshare->pos_in_file;
len= ((cache->error == -1) ? (size_t) -1 :
(size_t) (cache->read_end - cache->buffer));
}
cache->read_pos= cache->buffer;
cache->seek_not_done= 0;
if (len == 0 || len == (size_t) -1)
{
DBUG_PRINT("io_cache_share", ("reader error. len %lu left %lu",
(ulong) len, (ulong) left_length));
cache->error= (int) left_length;
DBUG_RETURN(1);
}
cnt= (len > Count) ? Count : len;
if (cnt)
memcpy(Buffer, cache->read_pos, cnt);
Count -= cnt;
Buffer+= cnt;
left_length+= cnt;
cache->read_pos+= cnt;
}
DBUG_RETURN(0);
}
|
O3
|
c
|
my_b_cache_read_r:
testq %rdx, %rdx
je 0x95b1a
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq %rsi, -0x50(%rbp)
movq 0x98(%rdi), %rax
movq %rax, -0x40(%rbp)
xorl %edx, %edx
movq 0x18(%rbx), %r13
movq 0xf0(%rbx), %r12
subq 0x20(%rbx), %r13
addq (%rbx), %r13
movl %r13d, %ecx
andl $0xfff, %ecx # imm = 0xFFF
leal (%r14,%rcx), %eax
addl $0xfff, %eax # imm = 0xFFF
andl $0xfffff000, %eax # imm = 0xFFFFF000
subq %rcx, %rax
cmpq %r12, %rax
jbe 0x958a8
movl %eax, %ecx
subl %r12d, %ecx
addl $0xfff, %ecx # imm = 0xFFF
andl $0xfffff000, %ecx # imm = 0xFFFFF000
subq %rcx, %rax
movq %rax, %r12
jmp 0x958b5
subl %eax, %r12d
andl $0xfffff000, %r12d # imm = 0xFFFFF000
addq %rax, %r12
cmpl $0x4, 0xb0(%rbx)
je 0x958cc
movq 0x8(%rbx), %rax
subq %r13, %rax
cmpq %rax, %r12
cmovaeq %rax, %r12
testq %r12, %r12
je 0x95b1d
movq %rdx, -0x48(%rbp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x96e46
testl %eax, %eax
je 0x959ad
movl 0xd4(%rbx), %r15d
testl %r15d, %r15d
js 0x959e4
cmpl $0x0, 0xe0(%rbx)
je 0x9594d
leaq 0x2f0704(%rip), %rax # 0x386010
movq (%rax), %rax
leaq -0xa8(%rbp), %rdi
movl %r15d, %esi
movl $0x8, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x95aff
movl %r15d, %edi
movq %r13, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xa0b40
cmpq $-0x1, %rax
je 0x95b58
movl 0xd4(%rbx), %r15d
movq 0x20(%rbx), %rax
movq %rax, -0x38(%rbp)
movq 0xf8(%rbx), %rax
movq %rax, -0x30(%rbp)
leaq 0x2f06a9(%rip), %rax # 0x386010
movq (%rax), %rax
leaq -0xa8(%rbp), %rdi
movl %r15d, %esi
movl $0x6, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x95a86
movl %r15d, %edi
movq -0x38(%rbp), %rsi
movq %r12, %rdx
movq -0x30(%rbp), %rcx
callq 0xa0940
movq %rax, %r15
cmpq $-0x1, %r15
movl $0x0, %eax
cmovneq %r15, %rax
jmp 0x959e9
movq -0x40(%rbp), %rcx
movl 0xe0(%rcx), %eax
movl %eax, 0xe4(%rbx)
movq 0xd0(%rcx), %r15
movq %r15, 0x18(%rbx)
movq 0xb8(%rcx), %rcx
movq %rcx, (%rbx)
movq 0x20(%rbx), %rsi
cmpl $-0x1, %eax
je 0x95b29
subq %rsi, %r15
jmp 0x95a34
xorl %r15d, %r15d
xorl %eax, %eax
addq 0x20(%rbx), %rax
cmpq %r12, %r15
movl %r15d, %ecx
movl $0x0, %edx
cmovel %edx, %ecx
movq %rax, 0x18(%rbx)
movl %ecx, 0xe4(%rbx)
movq %r13, (%rbx)
movq -0x40(%rbp), %rdx
movl %ecx, 0xe0(%rdx)
movq 0x18(%rbx), %rax
movq %rax, 0xd0(%rdx)
movq %r13, 0xb8(%rdx)
movq 0x98(%rbx), %rdi
callq 0x97047
movq 0x20(%rbx), %rsi
movq %rsi, 0x10(%rbx)
movl $0x0, 0xe0(%rbx)
leaq 0x1(%r15), %rax
cmpq $0x1, %rax
jbe 0x95b37
cmpq %r14, %r15
cmovaeq %r14, %r15
movq -0x50(%rbp), %r12
movq %r12, %rdi
movq %r15, %rdx
callq 0x29080
addq %r15, %r12
movq %r12, -0x50(%rbp)
movq -0x48(%rbp), %rdx
addq %r15, %rdx
addq %r15, 0x10(%rbx)
subq %r15, %r14
jne 0x9585e
jmp 0x95b25
movq %rax, %rcx
leaq 0x2f0580(%rip), %rax # 0x386010
movq (%rax), %rax
movq %rcx, -0x58(%rbp)
movq %rcx, %rdi
movq %r12, %rsi
leaq 0x466b8(%rip), %rdx # 0xdc15c
movl $0x4d3, %ecx # imm = 0x4D3
callq *0x210(%rax)
movl %r15d, %edi
movq -0x38(%rbp), %rsi
movq %r12, %rdx
movq -0x30(%rbp), %rcx
callq 0xa0940
movq %rax, %r15
testq %rax, %rax
movl $0x0, %eax
cmoveq %r12, %rax
cmpq $-0x1, %r15
movl $0x0, %esi
cmovneq %r15, %rsi
testb $0x6, -0x30(%rbp)
cmovneq %rax, %rsi
leaq 0x2f0523(%rip), %rax # 0x386010
movq (%rax), %rax
movq -0x58(%rbp), %rdi
callq *0x218(%rax)
jmp 0x9599e
movq %rax, %rdi
movl %r15d, %esi
movq %r13, %rdx
leaq -0x60(%rbp), %rcx
callq 0x2ea0a
movq -0x60(%rbp), %rax
jmp 0x9593c
xorl %eax, %eax
retq
movl %edx, 0xe4(%rbx)
jmp 0x95b41
xorl %eax, %eax
jmp 0x95b46
movq %rsi, 0x10(%rbx)
movl $0x0, 0xe0(%rbx)
movq -0x48(%rbp), %rax
movl %eax, 0xe4(%rbx)
movl $0x1, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, 0xe4(%rbx) # imm = 0xFFFFFFFF
movq 0x98(%rbx), %rdi
callq 0x97047
jmp 0x95b41
|
_my_b_cache_read_r:
test rdx, rdx
jz loc_95B1A
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 88h
mov r14, rdx
mov rbx, rdi
mov [rbp-50h], rsi
mov rax, [rdi+98h]
mov [rbp-40h], rax
xor edx, edx
loc_9585E:
mov r13, [rbx+18h]
mov r12, [rbx+0F0h]
sub r13, [rbx+20h]
add r13, [rbx]
mov ecx, r13d
and ecx, 0FFFh
lea eax, [r14+rcx]
add eax, 0FFFh
and eax, 0FFFFF000h
sub rax, rcx
cmp rax, r12
jbe short loc_958A8
mov ecx, eax
sub ecx, r12d
add ecx, 0FFFh
and ecx, 0FFFFF000h
sub rax, rcx
mov r12, rax
jmp short loc_958B5
loc_958A8:
sub r12d, eax
and r12d, 0FFFFF000h
add r12, rax
loc_958B5:
cmp dword ptr [rbx+0B0h], 4
jz short loc_958CC
mov rax, [rbx+8]
sub rax, r13
cmp r12, rax
cmovnb r12, rax
loc_958CC:
test r12, r12
jz loc_95B1D
mov [rbp-48h], rdx
mov rdi, rbx
mov rsi, r13
call lock_io_cache
test eax, eax
jz loc_959AD
mov r15d, [rbx+0D4h]
test r15d, r15d
js loc_959E4
cmp dword ptr [rbx+0E0h], 0
jz short loc_9594D
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp-0A8h]
mov esi, r15d
mov edx, 8
call qword ptr [rax+158h]
test rax, rax
jnz loc_95AFF
mov edi, r15d
mov rsi, r13
xor edx, edx
xor ecx, ecx
call my_seek
loc_9593C:
cmp rax, 0FFFFFFFFFFFFFFFFh
jz loc_95B58
mov r15d, [rbx+0D4h]
loc_9594D:
mov rax, [rbx+20h]
mov [rbp-38h], rax
mov rax, [rbx+0F8h]
mov [rbp-30h], rax
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp-0A8h]
mov esi, r15d
mov edx, 6
call qword ptr [rax+158h]
test rax, rax
jnz loc_95A86
mov edi, r15d
mov rsi, [rbp-38h]
mov rdx, r12
mov rcx, [rbp-30h]
call my_read
mov r15, rax
loc_9599E:
cmp r15, 0FFFFFFFFFFFFFFFFh
mov eax, 0
cmovnz rax, r15
jmp short loc_959E9
loc_959AD:
mov rcx, [rbp-40h]
mov eax, [rcx+0E0h]
mov [rbx+0E4h], eax
mov r15, [rcx+0D0h]
mov [rbx+18h], r15
mov rcx, [rcx+0B8h]
mov [rbx], rcx
mov rsi, [rbx+20h]
cmp eax, 0FFFFFFFFh
jz loc_95B29
sub r15, rsi
jmp short loc_95A34
loc_959E4:
xor r15d, r15d
xor eax, eax
loc_959E9:
add rax, [rbx+20h]
cmp r15, r12
mov ecx, r15d
mov edx, 0
cmovz ecx, edx
mov [rbx+18h], rax
mov [rbx+0E4h], ecx
mov [rbx], r13
mov rdx, [rbp-40h]
mov [rdx+0E0h], ecx
mov rax, [rbx+18h]
mov [rdx+0D0h], rax
mov [rdx+0B8h], r13
mov rdi, [rbx+98h]
call unlock_io_cache
mov rsi, [rbx+20h]
loc_95A34:
mov [rbx+10h], rsi
mov dword ptr [rbx+0E0h], 0
lea rax, [r15+1]
cmp rax, 1
jbe loc_95B37
cmp r15, r14
cmovnb r15, r14
mov r12, [rbp-50h]
mov rdi, r12
mov rdx, r15
call _memcpy
add r12, r15
mov [rbp-50h], r12
mov rdx, [rbp-48h]
add rdx, r15
add [rbx+10h], r15
sub r14, r15
jnz loc_9585E
jmp loc_95B25
loc_95A86:
mov rcx, rax
lea rax, PSI_server
mov rax, [rax]
mov [rbp-58h], rcx
mov rdi, rcx
mov rsi, r12
lea rdx, aWorkspaceLlm4b_21; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 4D3h
call qword ptr [rax+210h]
mov edi, r15d
mov rsi, [rbp-38h]
mov rdx, r12
mov rcx, [rbp-30h]
call my_read
mov r15, rax
test rax, rax
mov eax, 0
cmovz rax, r12
cmp r15, 0FFFFFFFFFFFFFFFFh
mov esi, 0
cmovnz rsi, r15
test byte ptr [rbp-30h], 6
cmovnz rsi, rax
lea rax, PSI_server
mov rax, [rax]
mov rdi, [rbp-58h]
call qword ptr [rax+218h]
jmp loc_9599E
loc_95AFF:
mov rdi, rax
mov esi, r15d
mov rdx, r13
lea rcx, [rbp-60h]
call _my_b_cache_read_r_cold_1
mov rax, [rbp-60h]
jmp loc_9593C
loc_95B1A:
xor eax, eax
retn
loc_95B1D:
mov [rbx+0E4h], edx
jmp short loc_95B41
loc_95B25:
xor eax, eax
jmp short loc_95B46
loc_95B29:
mov [rbx+10h], rsi
mov dword ptr [rbx+0E0h], 0
loc_95B37:
mov rax, [rbp-48h]
mov [rbx+0E4h], eax
loc_95B41:
mov eax, 1
loc_95B46:
add rsp, 88h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_95B58:
mov dword ptr [rbx+0E4h], 0FFFFFFFFh
mov rdi, [rbx+98h]
call unlock_io_cache
jmp short loc_95B41
|
long long my_b_cache_read_r(long long a1, long long a2, unsigned long long a3)
{
unsigned long long v3; // r14
long long v4; // rdx
unsigned long long v5; // r12
long long v6; // r13
long long v7; // rcx
unsigned long long v8; // rax
unsigned long long v9; // r12
unsigned int v10; // r15d
long long v11; // rax
long long v12; // rax
long long v13; // rax
unsigned long long v14; // r15
unsigned long long v15; // rax
long long v16; // rcx
int v17; // eax
long long v18; // r15
long long v19; // rsi
unsigned long long v20; // rax
int v21; // ecx
long long v22; // rdx
long long v23; // r12
unsigned long long v24; // rax
unsigned long long v25; // rsi
_BYTE v27[72]; // [rsp-B0h] [rbp-B0h] BYREF
long long v28; // [rsp-68h] [rbp-68h] BYREF
long long v29; // [rsp-60h] [rbp-60h]
long long v30; // [rsp-58h] [rbp-58h]
long long v31; // [rsp-50h] [rbp-50h]
long long v32; // [rsp-48h] [rbp-48h]
long long v33; // [rsp-40h] [rbp-40h]
long long v34; // [rsp-38h] [rbp-38h]
if ( !a3 )
return 0LL;
v3 = a3;
v30 = a2;
v32 = *(_QWORD *)(a1 + 152);
v4 = 0LL;
while ( 1 )
{
v5 = *(_QWORD *)(a1 + 240);
v6 = *(_QWORD *)a1 + *(_QWORD *)(a1 + 24) - *(_QWORD *)(a1 + 32);
v7 = (*(_WORD *)a1 + *(_WORD *)(a1 + 24) - *(_WORD *)(a1 + 32)) & 0xFFF;
v8 = (((_DWORD)v3 + (_DWORD)v7 + 4095) & 0xFFFFF000) - v7;
if ( v8 <= v5 )
v9 = v8 + (((_DWORD)v5 - (_DWORD)v8) & 0xFFFFF000);
else
v9 = v8 - (((_DWORD)v8 - (_DWORD)v5 + 4095) & 0xFFFFF000);
if ( *(_DWORD *)(a1 + 176) != 4 && v9 >= *(_QWORD *)(a1 + 8) - v6 )
v9 = *(_QWORD *)(a1 + 8) - v6;
if ( !v9 )
{
*(_DWORD *)(a1 + 228) = v4;
return 1LL;
}
v31 = v4;
if ( (unsigned int)lock_io_cache(a1, v6) )
break;
v16 = v32;
v17 = *(_DWORD *)(v32 + 224);
*(_DWORD *)(a1 + 228) = v17;
v18 = *(_QWORD *)(v16 + 208);
*(_QWORD *)(a1 + 24) = v18;
*(_QWORD *)a1 = *(_QWORD *)(v16 + 184);
v19 = *(_QWORD *)(a1 + 32);
if ( v17 == -1 )
{
*(_QWORD *)(a1 + 16) = v19;
*(_DWORD *)(a1 + 224) = 0;
LABEL_44:
*(_DWORD *)(a1 + 228) = v31;
return 1LL;
}
v14 = v18 - v19;
LABEL_28:
*(_QWORD *)(a1 + 16) = v19;
*(_DWORD *)(a1 + 224) = 0;
if ( v14 + 1 <= 1 )
goto LABEL_44;
if ( v14 >= v3 )
v14 = v3;
v23 = v30;
memcpy(v30, v19, v14);
v30 = v14 + v23;
v4 = v14 + v31;
*(_QWORD *)(a1 + 16) += v14;
v3 -= v14;
if ( !v3 )
return 0LL;
}
v10 = *(_DWORD *)(a1 + 212);
if ( (v10 & 0x80000000) != 0 )
{
v14 = 0LL;
v15 = 0LL;
LABEL_25:
v20 = *(_QWORD *)(a1 + 32) + v15;
v21 = v14;
if ( v14 == v9 )
v21 = 0;
*(_QWORD *)(a1 + 24) = v20;
*(_DWORD *)(a1 + 228) = v21;
*(_QWORD *)a1 = v6;
v22 = v32;
*(_DWORD *)(v32 + 224) = v21;
*(_QWORD *)(v22 + 208) = *(_QWORD *)(a1 + 24);
*(_QWORD *)(v22 + 184) = v6;
unlock_io_cache(*(_QWORD *)(a1 + 152));
v19 = *(_QWORD *)(a1 + 32);
goto LABEL_28;
}
if ( !*(_DWORD *)(a1 + 224) )
{
LABEL_17:
v33 = *(_QWORD *)(a1 + 32);
v34 = *(_QWORD *)(a1 + 248);
v13 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v27, v10, 6LL);
if ( v13 )
{
v29 = v13;
((void ( *)(long long, unsigned long long, const char *, long long))PSI_server[66])(
v13,
v9,
"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",
1235LL);
v14 = my_read(v10, v33, v9, v34);
v24 = 0LL;
if ( !v14 )
v24 = v9;
v25 = 0LL;
if ( v14 != -1LL )
v25 = v14;
if ( (v34 & 6) != 0 )
v25 = v24;
((void ( *)(long long, unsigned long long))PSI_server[67])(v29, v25);
}
else
{
v14 = my_read(v10, v33, v9, v34);
}
v15 = 0LL;
if ( v14 != -1LL )
v15 = v14;
goto LABEL_25;
}
v11 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v27, v10, 8LL);
if ( v11 )
{
my_b_cache_read_r_cold_1(v11, v10, v6, &v28);
v12 = v28;
}
else
{
v12 = my_seek(v10, v6, 0LL, 0LL);
}
if ( v12 != -1 )
{
v10 = *(_DWORD *)(a1 + 212);
goto LABEL_17;
}
*(_DWORD *)(a1 + 228) = -1;
unlock_io_cache(*(_QWORD *)(a1 + 152));
return 1LL;
}
|
_my_b_cache_read_r:
TEST RDX,RDX
JZ 0x00195b1a
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x88
MOV R14,RDX
MOV RBX,RDI
MOV qword ptr [RBP + -0x50],RSI
MOV RAX,qword ptr [RDI + 0x98]
MOV qword ptr [RBP + -0x40],RAX
XOR EDX,EDX
LAB_0019585e:
MOV R13,qword ptr [RBX + 0x18]
MOV R12,qword ptr [RBX + 0xf0]
SUB R13,qword ptr [RBX + 0x20]
ADD R13,qword ptr [RBX]
MOV ECX,R13D
AND ECX,0xfff
LEA EAX,[R14 + RCX*0x1]
ADD EAX,0xfff
AND EAX,0xfffff000
SUB RAX,RCX
CMP RAX,R12
JBE 0x001958a8
MOV ECX,EAX
SUB ECX,R12D
ADD ECX,0xfff
AND ECX,0xfffff000
SUB RAX,RCX
MOV R12,RAX
JMP 0x001958b5
LAB_001958a8:
SUB R12D,EAX
AND R12D,0xfffff000
ADD R12,RAX
LAB_001958b5:
CMP dword ptr [RBX + 0xb0],0x4
JZ 0x001958cc
MOV RAX,qword ptr [RBX + 0x8]
SUB RAX,R13
CMP R12,RAX
CMOVNC R12,RAX
LAB_001958cc:
TEST R12,R12
JZ 0x00195b1d
MOV qword ptr [RBP + -0x48],RDX
MOV RDI,RBX
MOV RSI,R13
CALL 0x00196e46
TEST EAX,EAX
JZ 0x001959ad
MOV R15D,dword ptr [RBX + 0xd4]
TEST R15D,R15D
JS 0x001959e4
CMP dword ptr [RBX + 0xe0],0x0
JZ 0x0019594d
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0xa8]
MOV ESI,R15D
MOV EDX,0x8
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x00195aff
MOV EDI,R15D
MOV RSI,R13
XOR EDX,EDX
XOR ECX,ECX
CALL 0x001a0b40
LAB_0019593c:
CMP RAX,-0x1
JZ 0x00195b58
MOV R15D,dword ptr [RBX + 0xd4]
LAB_0019594d:
MOV RAX,qword ptr [RBX + 0x20]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBX + 0xf8]
MOV qword ptr [RBP + -0x30],RAX
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0xa8]
MOV ESI,R15D
MOV EDX,0x6
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x00195a86
MOV EDI,R15D
MOV RSI,qword ptr [RBP + -0x38]
MOV RDX,R12
MOV RCX,qword ptr [RBP + -0x30]
CALL 0x001a0940
MOV R15,RAX
LAB_0019599e:
CMP R15,-0x1
MOV EAX,0x0
CMOVNZ RAX,R15
JMP 0x001959e9
LAB_001959ad:
MOV RCX,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RCX + 0xe0]
MOV dword ptr [RBX + 0xe4],EAX
MOV R15,qword ptr [RCX + 0xd0]
MOV qword ptr [RBX + 0x18],R15
MOV RCX,qword ptr [RCX + 0xb8]
MOV qword ptr [RBX],RCX
MOV RSI,qword ptr [RBX + 0x20]
CMP EAX,-0x1
JZ 0x00195b29
SUB R15,RSI
JMP 0x00195a34
LAB_001959e4:
XOR R15D,R15D
XOR EAX,EAX
LAB_001959e9:
ADD RAX,qword ptr [RBX + 0x20]
CMP R15,R12
MOV ECX,R15D
MOV EDX,0x0
CMOVZ ECX,EDX
MOV qword ptr [RBX + 0x18],RAX
MOV dword ptr [RBX + 0xe4],ECX
MOV qword ptr [RBX],R13
MOV RDX,qword ptr [RBP + -0x40]
MOV dword ptr [RDX + 0xe0],ECX
MOV RAX,qword ptr [RBX + 0x18]
MOV qword ptr [RDX + 0xd0],RAX
MOV qword ptr [RDX + 0xb8],R13
MOV RDI,qword ptr [RBX + 0x98]
CALL 0x00197047
MOV RSI,qword ptr [RBX + 0x20]
LAB_00195a34:
MOV qword ptr [RBX + 0x10],RSI
MOV dword ptr [RBX + 0xe0],0x0
LEA RAX,[R15 + 0x1]
CMP RAX,0x1
JBE 0x00195b37
CMP R15,R14
CMOVNC R15,R14
MOV R12,qword ptr [RBP + -0x50]
MOV RDI,R12
MOV RDX,R15
CALL 0x00129080
ADD R12,R15
MOV qword ptr [RBP + -0x50],R12
MOV RDX,qword ptr [RBP + -0x48]
ADD RDX,R15
ADD qword ptr [RBX + 0x10],R15
SUB R14,R15
JNZ 0x0019585e
JMP 0x00195b25
LAB_00195a86:
MOV RCX,RAX
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x58],RCX
MOV RDI,RCX
MOV RSI,R12
LEA RDX,[0x1dc15c]
MOV ECX,0x4d3
CALL qword ptr [RAX + 0x210]
MOV EDI,R15D
MOV RSI,qword ptr [RBP + -0x38]
MOV RDX,R12
MOV RCX,qword ptr [RBP + -0x30]
CALL 0x001a0940
MOV R15,RAX
TEST RAX,RAX
MOV EAX,0x0
CMOVZ RAX,R12
CMP R15,-0x1
MOV ESI,0x0
CMOVNZ RSI,R15
TEST byte ptr [RBP + -0x30],0x6
CMOVNZ RSI,RAX
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RBP + -0x58]
CALL qword ptr [RAX + 0x218]
JMP 0x0019599e
LAB_00195aff:
MOV RDI,RAX
MOV ESI,R15D
MOV RDX,R13
LEA RCX,[RBP + -0x60]
CALL 0x0012ea0a
MOV RAX,qword ptr [RBP + -0x60]
JMP 0x0019593c
LAB_00195b1a:
XOR EAX,EAX
RET
LAB_00195b1d:
MOV dword ptr [RBX + 0xe4],EDX
JMP 0x00195b41
LAB_00195b25:
XOR EAX,EAX
JMP 0x00195b46
LAB_00195b29:
MOV qword ptr [RBX + 0x10],RSI
MOV dword ptr [RBX + 0xe0],0x0
LAB_00195b37:
MOV RAX,qword ptr [RBP + -0x48]
MOV dword ptr [RBX + 0xe4],EAX
LAB_00195b41:
MOV EAX,0x1
LAB_00195b46:
ADD RSP,0x88
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00195b58:
MOV dword ptr [RBX + 0xe4],0xffffffff
MOV RDI,qword ptr [RBX + 0x98]
CALL 0x00197047
JMP 0x00195b41
|
int8 _my_b_cache_read_r(long *param_1,void *param_2,ulong param_3)
{
void *pvVar1;
int iVar2;
ulong uVar3;
long lVar4;
ulong uVar5;
ulong uVar6;
uint uVar7;
int4 uVar8;
void *__src;
ulong uVar9;
long lVar10;
int1 local_b0 [72];
long local_68;
long local_60;
void *local_58;
long local_50;
long local_48;
long local_40;
ulong local_38;
if (param_3 == 0) {
return 0;
}
local_48 = param_1[0x13];
local_50 = 0;
local_58 = param_2;
while( true ) {
lVar10 = (param_1[3] - param_1[4]) + *param_1;
uVar7 = (uint)lVar10 & 0xfff;
uVar3 = (ulong)((int)param_3 + uVar7 + 0xfff & 0xfffff000) - (ulong)uVar7;
iVar2 = (int)param_1[0x1e];
if ((ulong)param_1[0x1e] < uVar3) {
uVar5 = -(ulong)(((int)uVar3 - iVar2) + 0xfffU & 0xfffff000);
}
else {
uVar5 = (ulong)(iVar2 - (int)uVar3 & 0xfffff000);
}
uVar3 = uVar3 + uVar5;
if (((int)param_1[0x16] != 4) && ((ulong)(param_1[1] - lVar10) <= uVar3)) {
uVar3 = param_1[1] - lVar10;
}
if (uVar3 == 0) {
*(int *)((long)param_1 + 0xe4) = (int)local_50;
return 1;
}
iVar2 = lock_io_cache(param_1,lVar10);
if (iVar2 == 0) {
iVar2 = *(int *)(local_48 + 0xe0);
*(int *)((long)param_1 + 0xe4) = iVar2;
lVar10 = *(long *)(local_48 + 0xd0);
param_1[3] = lVar10;
*param_1 = *(long *)(local_48 + 0xb8);
__src = (void *)param_1[4];
if (iVar2 == -1) {
param_1[2] = (long)__src;
*(int4 *)(param_1 + 0x1c) = 0;
break;
}
uVar5 = lVar10 - (long)__src;
}
else {
iVar2 = *(int *)((long)param_1 + 0xd4);
if (iVar2 < 0) {
uVar5 = 0;
uVar6 = 0;
}
else {
if ((int)param_1[0x1c] != 0) {
lVar4 = (**(code **)(PSI_server + 0x158))(local_b0,iVar2,8);
if (lVar4 == 0) {
lVar4 = my_seek(iVar2,lVar10,0,0);
}
else {
_my_b_cache_read_r_cold_1(lVar4,iVar2,lVar10,&local_68);
lVar4 = local_68;
}
if (lVar4 == -1) {
*(int4 *)((long)param_1 + 0xe4) = 0xffffffff;
unlock_io_cache(param_1[0x13]);
return 1;
}
iVar2 = *(int *)((long)param_1 + 0xd4);
}
local_40 = param_1[4];
local_38 = param_1[0x1f];
lVar4 = (**(code **)(PSI_server + 0x158))(local_b0,iVar2,6);
if (lVar4 == 0) {
uVar5 = my_read(iVar2,local_40,uVar3,local_38);
}
else {
local_60 = lVar4;
(**(code **)(PSI_server + 0x210))
(lVar4,uVar3,"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",0x4d3
);
uVar5 = my_read(iVar2,local_40,uVar3,local_38);
uVar6 = 0;
if (uVar5 == 0) {
uVar6 = uVar3;
}
uVar9 = 0;
if (uVar5 != 0xffffffffffffffff) {
uVar9 = uVar5;
}
if ((local_38 & 6) != 0) {
uVar9 = uVar6;
}
(**(code **)(PSI_server + 0x218))(local_60,uVar9);
}
uVar6 = 0;
if (uVar5 != 0xffffffffffffffff) {
uVar6 = uVar5;
}
}
uVar8 = (int4)uVar5;
if (uVar5 == uVar3) {
uVar8 = 0;
}
param_1[3] = uVar6 + param_1[4];
*(int4 *)((long)param_1 + 0xe4) = uVar8;
*param_1 = lVar10;
*(int4 *)(local_48 + 0xe0) = uVar8;
*(long *)(local_48 + 0xd0) = param_1[3];
*(long *)(local_48 + 0xb8) = lVar10;
unlock_io_cache(param_1[0x13]);
__src = (void *)param_1[4];
}
pvVar1 = local_58;
param_1[2] = (long)__src;
*(int4 *)(param_1 + 0x1c) = 0;
if (uVar5 + 1 < 2) break;
if (param_3 <= uVar5) {
uVar5 = param_3;
}
memcpy(local_58,__src,uVar5);
local_58 = (void *)((long)pvVar1 + uVar5);
local_50 = local_50 + uVar5;
param_1[2] = param_1[2] + uVar5;
param_3 = param_3 - uVar5;
if (param_3 == 0) {
return 0;
}
}
*(int *)((long)param_1 + 0xe4) = (int)local_50;
return 1;
}
|
|
11,745 |
google::protobuf::compiler::objectivec::MapFieldGenerator::DetermineObjectiveCClassDefinitions(std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>*) const
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/compiler/objectivec/objectivec_map_field.cc
|
void MapFieldGenerator::DetermineObjectiveCClassDefinitions(
std::set<std::string>* fwd_decls) const {
// Class name is already in "storage_type".
const FieldDescriptor* value_descriptor =
descriptor_->message_type()->map_value();
if (GetObjectiveCType(value_descriptor) == OBJECTIVECTYPE_MESSAGE) {
fwd_decls->insert(ObjCClassDeclaration(
value_field_generator_->variable("storage_type")));
}
}
|
O3
|
cpp
|
google::protobuf::compiler::objectivec::MapFieldGenerator::DetermineObjectiveCClassDefinitions(std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>*) const:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
callq 0x11d7ce
movq %rax, %rdi
callq 0x11df52
movq %rax, %r15
movq 0x18(%rax), %rdi
testq %rdi, %rdi
je 0xf0d62
leaq 0x48ee5(%rip), %rax # 0x139c34
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0x20(%rsp), %rdx
movq %r15, (%rdx)
callq 0x2f19d
movzbl 0x2(%r15), %edi
callq 0x4ce97
cmpl $0xa, %eax
jne 0xf0dc5
movq 0x40(%r14), %rsi
leaq 0xf58df(%rip), %rdx # 0x1e665b
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0xbee0a
movq %rsp, %rdi
movq %r14, %rsi
callq 0x4c764
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x329e0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf0db2
callq 0x1f4a0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf0dc5
callq 0x1f4a0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf0dea
callq 0x1f4a0
jmp 0xf0dea
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf0dfd
callq 0x1f4a0
movq %rbx, %rdi
callq 0x1f860
nopl (%rax)
|
_ZNK6google8protobuf8compiler10objectivec17MapFieldGenerator35DetermineObjectiveCClassDefinitionsEPSt3setINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4lessISA_ESaISA_EE:
push r15
push r14
push rbx
sub rsp, 40h
mov rbx, rsi
mov r14, rdi
mov rdi, [rdi+8]; this
call _ZNK6google8protobuf15FieldDescriptor12message_typeEv; google::protobuf::FieldDescriptor::message_type(void)
mov rdi, rax; this
call _ZNK6google8protobuf10Descriptor9map_valueEv; google::protobuf::Descriptor::map_value(void)
mov r15, rax
mov rdi, [rax+18h]
test rdi, rdi
jz short loc_F0D62
lea rax, _ZN6google8protobuf15FieldDescriptor12TypeOnceInitEPKS1_; google::protobuf::FieldDescriptor::TypeOnceInit(google::protobuf::FieldDescriptor const*)
mov rsi, rsp
mov [rsi], rax
lea rdx, [rsp+58h+var_38]
mov [rdx], r15
call _ZSt9call_onceIPFvPKN6google8protobuf15FieldDescriptorEEJS4_EEvRSt9once_flagOT_DpOT0_; std::call_once<void (*)(google::protobuf::FieldDescriptor const*),google::protobuf::FieldDescriptor const*>(std::once_flag &,void (*)(google::protobuf::FieldDescriptor const*) &&,google::protobuf::FieldDescriptor const* &&)
loc_F0D62:
movzx edi, byte ptr [r15+2]
call _ZN6google8protobuf8compiler10objectivec17GetObjectiveCTypeENS0_15FieldDescriptor4TypeE; google::protobuf::compiler::objectivec::GetObjectiveCType(google::protobuf::FieldDescriptor::Type)
cmp eax, 0Ah
jnz short loc_F0DC5
mov rsi, [r14+40h]
lea rdx, aArrayStorageTy+6; "storage_type"
lea r14, [rsp+58h+var_38]
mov rdi, r14
call _ZNK6google8protobuf8compiler10objectivec14FieldGenerator8variableB5cxx11EPKc; google::protobuf::compiler::objectivec::FieldGenerator::variable(char const*)
mov rdi, rsp; int
mov rsi, r14; int
call _ZN6google8protobuf8compiler10objectivec20ObjCClassDeclarationERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; google::protobuf::compiler::objectivec::ObjCClassDeclaration(std::string const&)
mov rsi, rsp
mov rdi, rbx
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_St9_IdentityIS5_ESt4lessIS5_ESaIS5_EE16_M_insert_uniqueIS5_EESt4pairISt17_Rb_tree_iteratorIS5_EbEOT_; std::_Rb_tree<std::string,std::string,std::_Identity<std::string>,std::less<std::string>,std::allocator<std::string>>::_M_insert_unique<std::string>(std::string &&)
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_F0DB2
call __ZdlPv; operator delete(void *)
loc_F0DB2:
lea rax, [rsp+58h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_F0DC5
call __ZdlPv; operator delete(void *)
loc_F0DC5:
add rsp, 40h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
lea rax, [rsp+arg_8]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_F0DEA
call __ZdlPv; operator delete(void *)
jmp short loc_F0DEA
mov rbx, rax
loc_F0DEA:
lea rax, [rsp+arg_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_F0DFD
call __ZdlPv; operator delete(void *)
loc_F0DFD:
mov rdi, rbx
call __Unwind_Resume
|
void google::protobuf::compiler::objectivec::MapFieldGenerator::DetermineObjectiveCClassDefinitions(
long long a1,
long long a2)
{
google::protobuf::Descriptor *v3; // rax
long long v4; // r15
long long v5; // rdi
long long v6; // rdx
void *v7[2]; // [rsp+0h] [rbp-58h] BYREF
char v8; // [rsp+10h] [rbp-48h] BYREF
int v9[4]; // [rsp+20h] [rbp-38h] BYREF
char v10; // [rsp+30h] [rbp-28h] BYREF
v3 = (google::protobuf::Descriptor *)google::protobuf::FieldDescriptor::message_type(*(google::protobuf::FieldDescriptor **)(a1 + 8));
v4 = google::protobuf::Descriptor::map_value(v3);
v5 = *(_QWORD *)(v4 + 24);
if ( v5 )
{
v7[0] = google::protobuf::FieldDescriptor::TypeOnceInit;
*(_QWORD *)v9 = v4;
std::call_once<void (*)(google::protobuf::FieldDescriptor const*),google::protobuf::FieldDescriptor const*>(
v5,
(long long)v7,
(long long)v9);
}
if ( (unsigned int)google::protobuf::compiler::objectivec::GetObjectiveCType(*(unsigned __int8 *)(v4 + 2)) == 10 )
{
google::protobuf::compiler::objectivec::FieldGenerator::variable[abi:cxx11](
v9,
*(_QWORD *)(a1 + 64),
(long long)"storage_type");
google::protobuf::compiler::objectivec::ObjCClassDeclaration((long long)v7, v9);
std::_Rb_tree<std::string,std::string,std::_Identity<std::string>,std::less<std::string>,std::allocator<std::string>>::_M_insert_unique<std::string>(
a2,
(long long)v7,
v6);
if ( v7[0] != &v8 )
operator delete(v7[0]);
if ( *(char **)v9 != &v10 )
operator delete(*(void **)v9);
}
}
|
DetermineObjectiveCClassDefinitions:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV RBX,RSI
MOV R14,RDI
MOV RDI,qword ptr [RDI + 0x8]
CALL 0x0021d7ce
MOV RDI,RAX
CALL 0x0021df52
MOV R15,RAX
MOV RDI,qword ptr [RAX + 0x18]
TEST RDI,RDI
JZ 0x001f0d62
LEA RAX,[0x239c34]
MOV RSI,RSP
MOV qword ptr [RSI],RAX
LEA RDX,[RSP + 0x20]
MOV qword ptr [RDX],R15
CALL 0x0012f19d
LAB_001f0d62:
MOVZX EDI,byte ptr [R15 + 0x2]
CALL 0x0014ce97
CMP EAX,0xa
JNZ 0x001f0dc5
MOV RSI,qword ptr [R14 + 0x40]
LEA RDX,[0x2e665b]
LEA R14,[RSP + 0x20]
MOV RDI,R14
CALL 0x001bee0a
LAB_001f0d89:
MOV RDI,RSP
MOV RSI,R14
CALL 0x0014c764
LAB_001f0d94:
MOV RSI,RSP
MOV RDI,RBX
CALL 0x001329e0
LAB_001f0d9f:
LEA RAX,[RSP + 0x10]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001f0db2
CALL 0x0011f4a0
LAB_001f0db2:
LEA RAX,[RSP + 0x30]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001f0dc5
CALL 0x0011f4a0
LAB_001f0dc5:
ADD RSP,0x40
POP RBX
POP R14
POP R15
RET
|
/* google::protobuf::compiler::objectivec::MapFieldGenerator::DetermineObjectiveCClassDefinitions(std::set<std::__cxx11::string,
std::less<std::__cxx11::string >, std::allocator<std::__cxx11::string > >*) const */
void __thiscall
google::protobuf::compiler::objectivec::MapFieldGenerator::DetermineObjectiveCClassDefinitions
(MapFieldGenerator *this,set *param_1)
{
int iVar1;
Descriptor *this_00;
FieldDescriptor *pFVar2;
code *local_58 [2];
int1 local_48 [16];
FieldDescriptor *local_38 [2];
FieldDescriptor local_28 [16];
this_00 = (Descriptor *)FieldDescriptor::message_type(*(FieldDescriptor **)(this + 8));
pFVar2 = (FieldDescriptor *)Descriptor::map_value(this_00);
if (*(once_flag **)(pFVar2 + 0x18) != (once_flag *)0x0) {
local_58[0] = FieldDescriptor::TypeOnceInit;
local_38[0] = pFVar2;
std::
call_once<void(*)(google::protobuf::FieldDescriptor_const*),google::protobuf::FieldDescriptor_const*>
(*(once_flag **)(pFVar2 + 0x18),(_func_void_FieldDescriptor_ptr *)local_58,local_38);
}
iVar1 = GetObjectiveCType(pFVar2[2]);
if (iVar1 == 10) {
FieldGenerator::variable_abi_cxx11_((char *)local_38);
/* try { // try from 001f0d89 to 001f0d93 has its CatchHandler @ 001f0de7 */
ObjCClassDeclaration((objectivec *)local_58,(string *)local_38);
/* try { // try from 001f0d94 to 001f0d9e has its CatchHandler @ 001f0dcf */
std::
_Rb_tree<std::__cxx11::string,std::__cxx11::string,std::_Identity<std::__cxx11::string>,std::less<std::__cxx11::string>,std::allocator<std::__cxx11::string>>
::_M_insert_unique<std::__cxx11::string>
((_Rb_tree<std::__cxx11::string,std::__cxx11::string,std::_Identity<std::__cxx11::string>,std::less<std::__cxx11::string>,std::allocator<std::__cxx11::string>>
*)param_1,(string *)local_58);
if (local_58[0] != (code *)local_48) {
operator_delete(local_58[0]);
}
if (local_38[0] != local_28) {
operator_delete(local_38[0]);
}
}
return;
}
|
|
11,746 |
my_b_flush_io_cache
|
eloqsql/mysys/mf_iocache.c
|
int my_b_flush_io_cache(IO_CACHE *info, int need_append_buffer_lock)
{
size_t length;
my_bool append_cache= (info->type == SEQ_READ_APPEND);
DBUG_ENTER("my_b_flush_io_cache");
DBUG_PRINT("enter", ("cache: %p", info));
if (!append_cache)
need_append_buffer_lock= 0;
if (info->type == WRITE_CACHE || append_cache)
{
if (info->file == -1)
{
if (real_open_cached_file(info))
DBUG_RETURN((info->error= -1));
}
LOCK_APPEND_BUFFER;
if ((length=(size_t) (info->write_pos - info->write_buffer)))
{
if (append_cache)
{
if (mysql_file_write(info->file, info->write_buffer, length,
info->myflags | MY_NABP))
{
info->error= -1;
DBUG_RETURN(-1);
}
info->end_of_file+= info->write_pos - info->append_read_pos;
info->append_read_pos= info->write_buffer;
DBUG_ASSERT(info->end_of_file == mysql_file_tell(info->file, MYF(0)));
}
else
{
int res= info->write_function(info, info->write_buffer, length);
if (res)
DBUG_RETURN(res);
set_if_bigger(info->end_of_file, info->pos_in_file);
}
info->write_end= (info->write_buffer + info->buffer_length -
((info->pos_in_file + length) & (IO_SIZE - 1)));
info->write_pos= info->write_buffer;
++info->disk_writes;
UNLOCK_APPEND_BUFFER;
DBUG_RETURN(info->error);
}
}
UNLOCK_APPEND_BUFFER;
DBUG_RETURN(0);
}
|
O0
|
c
|
my_b_flush_io_cache:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x3, 0xb0(%rax)
sete %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x21(%rbp)
jmp 0x74da7
cmpb $0x0, -0x21(%rbp)
jne 0x74db4
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, 0xb0(%rax)
je 0x74dce
movsbl -0x21(%rbp), %eax
cmpl $0x0, %eax
je 0x74fb3
movq -0x10(%rbp), %rax
cmpl $-0x1, 0xd4(%rax)
jne 0x74e06
movq -0x10(%rbp), %rdi
callq 0x96650
cmpb $0x0, %al
je 0x74e04
jmp 0x74dea
movq -0x10(%rbp), %rax
movl $0xffffffff, 0xe4(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x74fcf
jmp 0x74e06
cmpl $0x0, -0x14(%rbp)
je 0x74e25
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
leaq 0x70b4a(%rip), %rsi # 0xe5965
movl $0x6ad, %edx # imm = 0x6AD
callq 0x75960
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x74fb1
cmpb $0x0, -0x21(%rbp)
je 0x74ed9
movq -0x10(%rbp), %rax
movl 0xd4(%rax), %edx
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x20(%rbp), %r8
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %r9
orq $0x4, %r9
leaq 0x70ae9(%rip), %rdi # 0xe5965
movl $0x6b4, %esi # imm = 0x6B4
callq 0x75db0
cmpq $0x0, %rax
je 0x74ea6
movq -0x10(%rbp), %rax
movl $0xffffffff, 0xe4(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x74fcf
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
subq %rax, %rcx
movq -0x10(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
jmp 0x74ed7
jmp 0x74f32
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rsi
movq -0x20(%rbp), %rdx
callq *%rax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x74f0c
jmp 0x74f01
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x74fcf
jmp 0x74f0e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x74f2e
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x74f30
jmp 0x74f32
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x10(%rbp), %rax
addq 0xe8(%rax), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rdx
addq -0x20(%rbp), %rdx
andq $0xfff, %rdx # imm = 0xFFF
xorl %eax, %eax
subq %rdx, %rax
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
movq 0xb8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xb8(%rax)
cmpl $0x0, -0x14(%rbp)
je 0x74fa0
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0x75a90
jmp 0x74fa2
movq -0x10(%rbp), %rax
movl 0xe4(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x74fcf
jmp 0x74fb3
cmpl $0x0, -0x14(%rbp)
je 0x74fc6
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0x75a90
jmp 0x74fc8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
my_b_flush_io_cache:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov rax, [rbp+var_10]
cmp dword ptr [rax+0B0h], 3
setz al
and al, 1
movzx eax, al
mov [rbp+var_21], al
jmp short $+2
loc_74DA7:
cmp [rbp+var_21], 0
jnz short loc_74DB4
mov [rbp+var_14], 0
loc_74DB4:
mov rax, [rbp+var_10]
cmp dword ptr [rax+0B0h], 2
jz short loc_74DCE
movsx eax, [rbp+var_21]
cmp eax, 0
jz loc_74FB3
loc_74DCE:
mov rax, [rbp+var_10]
cmp dword ptr [rax+0D4h], 0FFFFFFFFh
jnz short loc_74E06
mov rdi, [rbp+var_10]
call real_open_cached_file
cmp al, 0
jz short loc_74E04
jmp short $+2
loc_74DEA:
mov rax, [rbp+var_10]
mov dword ptr [rax+0E4h], 0FFFFFFFFh
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_74FCF
loc_74E04:
jmp short $+2
loc_74E06:
cmp [rbp+var_14], 0
jz short loc_74E25
mov rdi, [rbp+var_10]
add rdi, 50h ; 'P'
lea rsi, aWorkspaceLlm4b_15; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 6ADh
call inline_mysql_mutex_lock_8
loc_74E25:
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov rcx, [rbp+var_10]
mov rcx, [rcx+30h]
sub rax, rcx
mov [rbp+var_20], rax
cmp rax, 0
jz loc_74FB1
cmp [rbp+var_21], 0
jz loc_74ED9
mov rax, [rbp+var_10]
mov edx, [rax+0D4h]
mov rax, [rbp+var_10]
mov rcx, [rax+30h]
mov r8, [rbp+var_20]
mov rax, [rbp+var_10]
mov r9, [rax+0F8h]
or r9, 4
lea rdi, aWorkspaceLlm4b_15; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 6B4h
call inline_mysql_file_write_1
cmp rax, 0
jz short loc_74EA6
mov rax, [rbp+var_10]
mov dword ptr [rax+0E4h], 0FFFFFFFFh
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_74FCF
loc_74EA6:
mov rax, [rbp+var_10]
mov rcx, [rax+40h]
mov rax, [rbp+var_10]
mov rax, [rax+38h]
sub rcx, rax
mov rax, [rbp+var_10]
add rcx, [rax+8]
mov [rax+8], rcx
mov rax, [rbp+var_10]
mov rcx, [rax+30h]
mov rax, [rbp+var_10]
mov [rax+38h], rcx
jmp short $+2
loc_74ED7:
jmp short loc_74F32
loc_74ED9:
mov rax, [rbp+var_10]
mov rax, [rax+0A8h]
mov rdi, [rbp+var_10]
mov rcx, [rbp+var_10]
mov rsi, [rcx+30h]
mov rdx, [rbp+var_20]
call rax
mov [rbp+var_28], eax
cmp [rbp+var_28], 0
jz short loc_74F0C
jmp short $+2
loc_74F01:
mov eax, [rbp+var_28]
mov [rbp+var_4], eax
jmp loc_74FCF
loc_74F0C:
jmp short $+2
loc_74F0E:
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov rcx, [rbp+var_10]
cmp rax, [rcx]
jnb short loc_74F2E
mov rax, [rbp+var_10]
mov rcx, [rax]
mov rax, [rbp+var_10]
mov [rax+8], rcx
loc_74F2E:
jmp short $+2
loc_74F30:
jmp short $+2
loc_74F32:
mov rax, [rbp+var_10]
mov rcx, [rax+30h]
mov rax, [rbp+var_10]
add rcx, [rax+0E8h]
mov rax, [rbp+var_10]
mov rdx, [rax]
add rdx, [rbp+var_20]
and rdx, 0FFFh
xor eax, eax
sub rax, rdx
add rcx, rax
mov rax, [rbp+var_10]
mov [rax+48h], rcx
mov rax, [rbp+var_10]
mov rcx, [rax+30h]
mov rax, [rbp+var_10]
mov [rax+40h], rcx
mov rax, [rbp+var_10]
mov rcx, [rax+0B8h]
add rcx, 1
mov [rax+0B8h], rcx
cmp [rbp+var_14], 0
jz short loc_74FA0
mov rdi, [rbp+var_10]
add rdi, 50h ; 'P'
call inline_mysql_mutex_unlock_8
loc_74FA0:
jmp short $+2
loc_74FA2:
mov rax, [rbp+var_10]
mov eax, [rax+0E4h]
mov [rbp+var_4], eax
jmp short loc_74FCF
loc_74FB1:
jmp short $+2
loc_74FB3:
cmp [rbp+var_14], 0
jz short loc_74FC6
mov rdi, [rbp+var_10]
add rdi, 50h ; 'P'
call inline_mysql_mutex_unlock_8
loc_74FC6:
jmp short $+2
loc_74FC8:
mov [rbp+var_4], 0
loc_74FCF:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
|
long long my_b_flush_io_cache(long long a1, int a2)
{
unsigned int v3; // [rsp+8h] [rbp-28h]
bool v4; // [rsp+Fh] [rbp-21h]
long long v5; // [rsp+10h] [rbp-20h]
v4 = *(_DWORD *)(a1 + 176) == 3;
if ( *(_DWORD *)(a1 + 176) != 3 )
a2 = 0;
if ( *(_DWORD *)(a1 + 176) != 2 && *(_DWORD *)(a1 + 176) != 3 )
goto LABEL_22;
if ( *(_DWORD *)(a1 + 212) == -1 && (unsigned __int8)real_open_cached_file(a1) )
{
*(_DWORD *)(a1 + 228) = -1;
return (unsigned int)-1;
}
if ( a2 )
inline_mysql_mutex_lock_8(a1 + 80, "/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c", 1709LL);
v5 = *(_QWORD *)(a1 + 64) - *(_QWORD *)(a1 + 48);
if ( v5 )
{
if ( v4 )
{
if ( inline_mysql_file_write_1(
"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",
1716LL,
*(unsigned int *)(a1 + 212),
*(_QWORD *)(a1 + 48),
v5,
*(_QWORD *)(a1 + 248) | 4LL) )
{
*(_DWORD *)(a1 + 228) = -1;
return (unsigned int)-1;
}
*(_QWORD *)(a1 + 8) += *(_QWORD *)(a1 + 64) - *(_QWORD *)(a1 + 56);
*(_QWORD *)(a1 + 56) = *(_QWORD *)(a1 + 48);
}
else
{
v3 = (*(long long ( **)(long long, _QWORD, long long))(a1 + 168))(a1, *(_QWORD *)(a1 + 48), v5);
if ( v3 )
return v3;
if ( *(_QWORD *)(a1 + 8) < *(_QWORD *)a1 )
*(_QWORD *)(a1 + 8) = *(_QWORD *)a1;
}
*(_QWORD *)(a1 + 72) = *(_QWORD *)(a1 + 232)
+ *(_QWORD *)(a1 + 48)
- (((_WORD)v5 + (unsigned __int16)*(_QWORD *)a1) & 0xFFF);
*(_QWORD *)(a1 + 64) = *(_QWORD *)(a1 + 48);
++*(_QWORD *)(a1 + 184);
if ( a2 )
inline_mysql_mutex_unlock_8(a1 + 80);
return *(unsigned int *)(a1 + 228);
}
else
{
LABEL_22:
if ( a2 )
inline_mysql_mutex_unlock_8(a1 + 80);
return 0;
}
}
|
my_b_flush_io_cache:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0xb0],0x3
SETZ AL
AND AL,0x1
MOVZX EAX,AL
MOV byte ptr [RBP + -0x21],AL
JMP 0x00174da7
LAB_00174da7:
CMP byte ptr [RBP + -0x21],0x0
JNZ 0x00174db4
MOV dword ptr [RBP + -0x14],0x0
LAB_00174db4:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0xb0],0x2
JZ 0x00174dce
MOVSX EAX,byte ptr [RBP + -0x21]
CMP EAX,0x0
JZ 0x00174fb3
LAB_00174dce:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0xd4],-0x1
JNZ 0x00174e06
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00196650
CMP AL,0x0
JZ 0x00174e04
JMP 0x00174dea
LAB_00174dea:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe4],0xffffffff
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x00174fcf
LAB_00174e04:
JMP 0x00174e06
LAB_00174e06:
CMP dword ptr [RBP + -0x14],0x0
JZ 0x00174e25
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x50
LEA RSI,[0x1e5965]
MOV EDX,0x6ad
CALL 0x00175960
LAB_00174e25:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x30]
SUB RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JZ 0x00174fb1
CMP byte ptr [RBP + -0x21],0x0
JZ 0x00174ed9
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RAX + 0xd4]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x30]
MOV R8,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV R9,qword ptr [RAX + 0xf8]
OR R9,0x4
LEA RDI,[0x1e5965]
MOV ESI,0x6b4
CALL 0x00175db0
CMP RAX,0x0
JZ 0x00174ea6
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe4],0xffffffff
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x00174fcf
LAB_00174ea6:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x40]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x38]
SUB RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x38],RCX
JMP 0x00174ed7
LAB_00174ed7:
JMP 0x00174f32
LAB_00174ed9:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0xa8]
MOV RDI,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RCX + 0x30]
MOV RDX,qword ptr [RBP + -0x20]
CALL RAX
MOV dword ptr [RBP + -0x28],EAX
CMP dword ptr [RBP + -0x28],0x0
JZ 0x00174f0c
JMP 0x00174f01
LAB_00174f01:
MOV EAX,dword ptr [RBP + -0x28]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00174fcf
LAB_00174f0c:
JMP 0x00174f0e
LAB_00174f0e:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX]
JNC 0x00174f2e
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x8],RCX
LAB_00174f2e:
JMP 0x00174f30
LAB_00174f30:
JMP 0x00174f32
LAB_00174f32:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x30]
MOV RAX,qword ptr [RBP + -0x10]
ADD RCX,qword ptr [RAX + 0xe8]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX]
ADD RDX,qword ptr [RBP + -0x20]
AND RDX,0xfff
XOR EAX,EAX
SUB RAX,RDX
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x48],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x40],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0xb8]
ADD RCX,0x1
MOV qword ptr [RAX + 0xb8],RCX
CMP dword ptr [RBP + -0x14],0x0
JZ 0x00174fa0
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x50
CALL 0x00175a90
LAB_00174fa0:
JMP 0x00174fa2
LAB_00174fa2:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0xe4]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00174fcf
LAB_00174fb1:
JMP 0x00174fb3
LAB_00174fb3:
CMP dword ptr [RBP + -0x14],0x0
JZ 0x00174fc6
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x50
CALL 0x00175a90
LAB_00174fc6:
JMP 0x00174fc8
LAB_00174fc8:
MOV dword ptr [RBP + -0x4],0x0
LAB_00174fcf:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int my_b_flush_io_cache(ulong *param_1,int param_2)
{
char cVar1;
int iVar2;
long lVar3;
long lVar4;
bool bVar5;
int local_1c;
bVar5 = (int)param_1[0x16] == 3;
local_1c = param_2;
if (!bVar5) {
local_1c = 0;
}
if (((int)param_1[0x16] == 2) || (bVar5)) {
if ((*(int *)((long)param_1 + 0xd4) == -1) &&
(cVar1 = real_open_cached_file(param_1), cVar1 != '\0')) {
*(int4 *)((long)param_1 + 0xe4) = 0xffffffff;
return -1;
}
if (local_1c != 0) {
inline_mysql_mutex_lock
(param_1 + 10,"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",0x6ad);
}
lVar3 = param_1[8] - param_1[6];
if (lVar3 != 0) {
if (bVar5) {
lVar4 = inline_mysql_file_write
("/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",0x6b4,
*(int4 *)((long)param_1 + 0xd4),param_1[6],lVar3,param_1[0x1f] | 4)
;
if (lVar4 != 0) {
*(int4 *)((long)param_1 + 0xe4) = 0xffffffff;
return -1;
}
param_1[1] = (param_1[8] - param_1[7]) + param_1[1];
param_1[7] = param_1[6];
}
else {
iVar2 = (*(code *)param_1[0x15])(param_1,param_1[6],lVar3);
if (iVar2 != 0) {
return iVar2;
}
if (param_1[1] < *param_1) {
param_1[1] = *param_1;
}
}
param_1[9] = (param_1[6] + param_1[0x1d]) - (*param_1 + lVar3 & 0xfff);
param_1[8] = param_1[6];
param_1[0x17] = param_1[0x17] + 1;
if (local_1c != 0) {
inline_mysql_mutex_unlock(param_1 + 10);
}
return *(int *)((long)param_1 + 0xe4);
}
}
if (local_1c != 0) {
inline_mysql_mutex_unlock(param_1 + 10);
}
return 0;
}
|
|
11,747 |
testing::internal::ShouldUseColor(bool)
|
AlayaLite/build_O0/_deps/googletest-src/googletest/src/gtest.cc
|
bool ShouldUseColor(bool stdout_is_tty) {
std::string c = GTEST_FLAG_GET(color);
const char* const gtest_color = c.c_str();
if (String::CaseInsensitiveCStringEquals(gtest_color, "auto")) {
#if defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_WINDOWS_MINGW)
// On Windows the TERM variable is usually not set, but the
// console there does support colors.
return stdout_is_tty;
#else
// On non-Windows platforms, we rely on the TERM variable.
const char* const term = posix::GetEnv("TERM");
const bool term_supports_color =
term != nullptr && (String::CStringEquals(term, "xterm") ||
String::CStringEquals(term, "xterm-color") ||
String::CStringEquals(term, "xterm-kitty") ||
String::CStringEquals(term, "alacritty") ||
String::CStringEquals(term, "screen") ||
String::CStringEquals(term, "tmux") ||
String::CStringEquals(term, "rxvt-unicode") ||
String::CStringEquals(term, "linux") ||
String::CStringEquals(term, "cygwin") ||
String::EndsWithCaseInsensitive(term, "-256color"));
return stdout_is_tty && term_supports_color;
#endif // GTEST_OS_WINDOWS
}
return String::CaseInsensitiveCStringEquals(gtest_color, "yes") ||
String::CaseInsensitiveCStringEquals(gtest_color, "true") ||
String::CaseInsensitiveCStringEquals(gtest_color, "t") ||
String::CStringEquals(gtest_color, "1");
// We take "yes", "true", "t", and "1" as meaning "yes". If the
// value is neither one of these nor "auto", we treat it as "no" to
// be conservative.
}
|
O0
|
cpp
|
testing::internal::ShouldUseColor(bool):
subq $0xe8, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, 0xe6(%rsp)
leaq 0xb0ece(%rip), %rsi # 0x178b58
leaq 0xc0(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x39160
movq 0x38(%rsp), %rdi
callq 0x1acc0
movq %rax, 0xb8(%rsp)
movq 0xb8(%rsp), %rdi
leaq 0x4b11e(%rip), %rsi # 0x112ddb
callq 0xc3160
movb %al, 0x47(%rsp)
jmp 0xc7cc8
movb 0x47(%rsp), %al
testb $0x1, %al
jne 0xc7cd5
jmp 0xc8046
leaq 0x45a1e(%rip), %rdi # 0x10d6fa
callq 0xe4170
movq %rax, 0x30(%rsp)
jmp 0xc7ce8
movq 0x30(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq 0xa0(%rsp), %rcx
movb $0x0, 0x76(%rsp)
movb $0x0, 0x75(%rsp)
movb $0x0, 0x4e(%rsp)
movb $0x0, 0x4d(%rsp)
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, 0x2f(%rsp)
je 0xc7f02
movq 0xa0(%rsp), %rdi
leaq 0x45a1a(%rip), %rsi # 0x10d74a
callq 0xc0580
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x2e(%rsp)
jne 0xc7efa
movq 0xa0(%rsp), %rdi
leaq 0x4bb68(%rip), %rsi # 0x1138bd
callq 0xc0580
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x2e(%rsp)
jne 0xc7efa
movq 0xa0(%rsp), %rdi
leaq 0x4bb4f(%rip), %rsi # 0x1138c9
callq 0xc0580
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x2e(%rsp)
jne 0xc7efa
movq 0xa0(%rsp), %rdi
leaq 0x459b1(%rip), %rsi # 0x10d750
callq 0xc0580
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x2e(%rsp)
jne 0xc7efa
movq 0xa0(%rsp), %rdi
leaq 0x45979(%rip), %rsi # 0x10d73d
callq 0xc0580
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x2e(%rsp)
jne 0xc7efa
movq 0xa0(%rsp), %rdi
leaq 0x4baec(%rip), %rsi # 0x1138d5
callq 0xc0580
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x2e(%rsp)
jne 0xc7efa
movq 0xa0(%rsp), %rdi
leaq 0x4bacc(%rip), %rsi # 0x1138da
callq 0xc0580
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x2e(%rsp)
jne 0xc7efa
movq 0xa0(%rsp), %rdi
leaq 0x458f4(%rip), %rsi # 0x10d727
callq 0xc0580
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x2e(%rsp)
jne 0xc7efa
movq 0xa0(%rsp), %rdi
leaq 0x458b4(%rip), %rsi # 0x10d70c
callq 0xc0580
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x2e(%rsp)
jne 0xc7efa
movq 0xa0(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x77(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x14c90
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movb $0x1, 0x76(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x1a6a0
jmp 0xc7ea5
movb $0x1, 0x75(%rsp)
leaq 0x4f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x14c90
movq 0x10(%rsp), %rdx
movb $0x1, 0x4e(%rsp)
leaq 0x4ba1d(%rip), %rsi # 0x1138e7
leaq 0x50(%rsp), %rdi
callq 0x1a6a0
jmp 0xc7ed6
movb $0x1, 0x4d(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xb67e0
movb %al, 0xf(%rsp)
jmp 0xc7ef0
movb 0xf(%rsp), %al
movb %al, 0x2e(%rsp)
jmp 0xc7efa
movb 0x2e(%rsp), %al
movb %al, 0x2f(%rsp)
movb 0x2f(%rsp), %al
movb %al, 0xe(%rsp)
testb $0x1, 0x4d(%rsp)
jne 0xc7f13
jmp 0xc7f1d
leaq 0x50(%rsp), %rdi
callq 0x1aac0
testb $0x1, 0x4e(%rsp)
jne 0xc7f26
jmp 0xc7f30
leaq 0x4f(%rsp), %rdi
callq 0x14750
testb $0x1, 0x75(%rsp)
jne 0xc7f39
jmp 0xc7f43
leaq 0x78(%rsp), %rdi
callq 0x1aac0
testb $0x1, 0x76(%rsp)
jne 0xc7f4c
jmp 0xc7f56
leaq 0x77(%rsp), %rdi
callq 0x14750
movb 0xe(%rsp), %al
andb $0x1, %al
movb %al, 0x9f(%rsp)
xorl %eax, %eax
testb $0x1, 0xe6(%rsp)
movb %al, 0xd(%rsp)
je 0xc7f7e
movb 0x9f(%rsp), %al
movb %al, 0xd(%rsp)
movb 0xd(%rsp), %al
andb $0x1, %al
movb %al, 0xe7(%rsp)
movl $0x1, 0x48(%rsp)
jmp 0xc80f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0xc8112
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0xc802e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0xc8006
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
testb $0x1, 0x4d(%rsp)
jne 0xc7ffa
jmp 0xc8004
leaq 0x50(%rsp), %rdi
callq 0x1aac0
jmp 0xc8006
testb $0x1, 0x4e(%rsp)
jne 0xc800f
jmp 0xc8019
leaq 0x4f(%rsp), %rdi
callq 0x14750
testb $0x1, 0x75(%rsp)
jne 0xc8022
jmp 0xc802c
leaq 0x78(%rsp), %rdi
callq 0x1aac0
jmp 0xc802e
testb $0x1, 0x76(%rsp)
jne 0xc8037
jmp 0xc8041
leaq 0x77(%rsp), %rdi
callq 0x14750
jmp 0xc8112
movq 0xb8(%rsp), %rdi
leaq 0x4b89c(%rip), %rsi # 0x1138f1
callq 0xc3160
movb %al, 0xc(%rsp)
jmp 0xc8060
movb 0xc(%rsp), %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0xb(%rsp)
jne 0xc80df
jmp 0xc8071
movq 0xb8(%rsp), %rdi
leaq 0x4402c(%rip), %rsi # 0x10c0ac
callq 0xc3160
movb %al, 0xa(%rsp)
jmp 0xc808b
movb 0xa(%rsp), %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0xb(%rsp)
jne 0xc80df
jmp 0xc809c
movq 0xb8(%rsp), %rdi
leaq 0x4bd55(%rip), %rsi # 0x113e00
callq 0xc3160
movb %al, 0x9(%rsp)
jmp 0xc80b6
movb 0x9(%rsp), %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0xb(%rsp)
jne 0xc80df
jmp 0xc80c7
movq 0xb8(%rsp), %rdi
leaq 0x4a979(%rip), %rsi # 0x112a4f
callq 0xc0580
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
andb $0x1, %al
movb %al, 0xe7(%rsp)
movl $0x1, 0x48(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0x1aac0
movb 0xe7(%rsp), %al
andb $0x1, %al
addq $0xe8, %rsp
retq
leaq 0xc0(%rsp), %rdi
callq 0x1aac0
movq 0xb0(%rsp), %rdi
callq 0x14c80
nopl (%rax)
|
_ZN7testing8internal14ShouldUseColorEb:
sub rsp, 0E8h
mov al, dil
and al, 1
mov [rsp+0E8h+var_2], al
lea rsi, _ZN7testing17FLAGS_gtest_colorB5cxx11E; testing::FLAGS_gtest_color
lea rdi, [rsp+0E8h+var_28]
mov [rsp+0E8h+var_B0], rdi
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2ERKS4_; std::string::basic_string(std::string const&)
mov rdi, [rsp+0E8h+var_B0]
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov [rsp+0E8h+var_30], rax
mov rdi, [rsp+0E8h+var_30]; this
lea rsi, aAuto; "auto"
call _ZN7testing8internal6String28CaseInsensitiveCStringEqualsEPKcS3_; testing::internal::String::CaseInsensitiveCStringEquals(char const*,char const*)
mov [rsp+0E8h+var_A1], al
jmp short $+2
loc_C7CC8:
mov al, [rsp+0E8h+var_A1]
test al, 1
jnz short loc_C7CD5
jmp loc_C8046
loc_C7CD5:
lea rdi, aColorterm+5; this
call _ZN7testing8internal5posix6GetEnvEPKc; testing::internal::posix::GetEnv(char const*)
mov [rsp+0E8h+var_B8], rax
jmp short $+2
loc_C7CE8:
mov rax, [rsp+0E8h+var_B8]
mov [rsp+0E8h+var_48], rax
mov rcx, [rsp+0E8h+var_48]
mov [rsp+0E8h+var_72], 0
mov [rsp+0E8h+var_73], 0
mov [rsp+0E8h+var_9A], 0
mov [rsp+0E8h+var_9B], 0
xor eax, eax
cmp rcx, 0
mov [rsp+0E8h+var_B9], al
jz loc_C7F02
mov rdi, [rsp+0E8h+var_48]; this
lea rsi, aXterm; "xterm"
call _ZN7testing8internal6String13CStringEqualsEPKcS3_; testing::internal::String::CStringEquals(char const*,char const*)
mov cl, al
mov al, 1
test cl, 1
mov [rsp+0E8h+var_BA], al
jnz loc_C7EFA
mov rdi, [rsp+0E8h+var_48]; this
lea rsi, aXtermColor; "xterm-color"
call _ZN7testing8internal6String13CStringEqualsEPKcS3_; testing::internal::String::CStringEquals(char const*,char const*)
mov cl, al
mov al, 1
test cl, 1
mov [rsp+0E8h+var_BA], al
jnz loc_C7EFA
mov rdi, [rsp+0E8h+var_48]; this
lea rsi, aXtermKitty; "xterm-kitty"
call _ZN7testing8internal6String13CStringEqualsEPKcS3_; testing::internal::String::CStringEquals(char const*,char const*)
mov cl, al
mov al, 1
test cl, 1
mov [rsp+0E8h+var_BA], al
jnz loc_C7EFA
mov rdi, [rsp+0E8h+var_48]; this
lea rsi, aAlacritty; "alacritty"
call _ZN7testing8internal6String13CStringEqualsEPKcS3_; testing::internal::String::CStringEquals(char const*,char const*)
mov cl, al
mov al, 1
test cl, 1
mov [rsp+0E8h+var_BA], al
jnz loc_C7EFA
mov rdi, [rsp+0E8h+var_48]; this
lea rsi, aScreen; "screen"
call _ZN7testing8internal6String13CStringEqualsEPKcS3_; testing::internal::String::CStringEquals(char const*,char const*)
mov cl, al
mov al, 1
test cl, 1
mov [rsp+0E8h+var_BA], al
jnz loc_C7EFA
mov rdi, [rsp+0E8h+var_48]; this
lea rsi, aTmux; "tmux"
call _ZN7testing8internal6String13CStringEqualsEPKcS3_; testing::internal::String::CStringEquals(char const*,char const*)
mov cl, al
mov al, 1
test cl, 1
mov [rsp+0E8h+var_BA], al
jnz loc_C7EFA
mov rdi, [rsp+0E8h+var_48]; this
lea rsi, aRxvtUnicode; "rxvt-unicode"
call _ZN7testing8internal6String13CStringEqualsEPKcS3_; testing::internal::String::CStringEquals(char const*,char const*)
mov cl, al
mov al, 1
test cl, 1
mov [rsp+0E8h+var_BA], al
jnz loc_C7EFA
mov rdi, [rsp+0E8h+var_48]; this
lea rsi, aLinux; "linux"
call _ZN7testing8internal6String13CStringEqualsEPKcS3_; testing::internal::String::CStringEquals(char const*,char const*)
mov cl, al
mov al, 1
test cl, 1
mov [rsp+0E8h+var_BA], al
jnz loc_C7EFA
mov rdi, [rsp+0E8h+var_48]; this
lea rsi, aCygwin; "cygwin"
call _ZN7testing8internal6String13CStringEqualsEPKcS3_; testing::internal::String::CStringEquals(char const*,char const*)
mov cl, al
mov al, 1
test cl, 1
mov [rsp+0E8h+var_BA], al
jnz loc_C7EFA
mov rax, [rsp+0E8h+var_48]
mov [rsp+0E8h+var_D0], rax
lea rdi, [rsp+0E8h+var_71]
mov [rsp+0E8h+var_C8], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rsi, [rsp+0E8h+var_D0]
mov rdx, [rsp+0E8h+var_C8]
mov [rsp+0E8h+var_72], 1
lea rdi, [rsp+0E8h+var_70]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_C7EA5:
mov [rsp+0E8h+var_73], 1
lea rdi, [rsp+0E8h+var_99]
mov [rsp+0E8h+var_D8], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdx, [rsp+0E8h+var_D8]
mov [rsp+0E8h+var_9A], 1
lea rsi, a256color; "-256color"
lea rdi, [rsp+0E8h+var_98]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_C7ED6:
mov [rsp+0E8h+var_9B], 1
lea rdi, [rsp+0E8h+var_70]
lea rsi, [rsp+0E8h+var_98]
call _ZN7testing8internal6String23EndsWithCaseInsensitiveERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES9_; testing::internal::String::EndsWithCaseInsensitive(std::string const&,std::string const&)
mov [rsp+0E8h+var_D9], al
jmp short $+2
loc_C7EF0:
mov al, [rsp+0E8h+var_D9]
mov [rsp+0E8h+var_BA], al
jmp short $+2
loc_C7EFA:
mov al, [rsp+0E8h+var_BA]
mov [rsp+0E8h+var_B9], al
loc_C7F02:
mov al, [rsp+0E8h+var_B9]
mov [rsp+0E8h+var_DA], al
test [rsp+0E8h+var_9B], 1
jnz short loc_C7F13
jmp short loc_C7F1D
loc_C7F13:
lea rdi, [rsp+0E8h+var_98]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_C7F1D:
test [rsp+0E8h+var_9A], 1
jnz short loc_C7F26
jmp short loc_C7F30
loc_C7F26:
lea rdi, [rsp+0E8h+var_99]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
loc_C7F30:
test [rsp+0E8h+var_73], 1
jnz short loc_C7F39
jmp short loc_C7F43
loc_C7F39:
lea rdi, [rsp+0E8h+var_70]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_C7F43:
test [rsp+0E8h+var_72], 1
jnz short loc_C7F4C
jmp short loc_C7F56
loc_C7F4C:
lea rdi, [rsp+0E8h+var_71]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
loc_C7F56:
mov al, [rsp+0E8h+var_DA]
and al, 1
mov [rsp+0E8h+var_49], al
xor eax, eax
test [rsp+0E8h+var_2], 1
mov [rsp+0E8h+var_DB], al
jz short loc_C7F7E
mov al, [rsp+0E8h+var_49]
mov [rsp+0E8h+var_DB], al
loc_C7F7E:
mov al, [rsp+0E8h+var_DB]
and al, 1
mov [rsp+0E8h+var_1], al
mov [rsp+0E8h+var_A0], 1
jmp loc_C80F4
mov rcx, rax
mov eax, edx
mov [rsp+arg_A8], rcx
mov [rsp+arg_A4], eax
jmp loc_C8112
mov rcx, rax
mov eax, edx
mov [rsp+arg_A8], rcx
mov [rsp+arg_A4], eax
jmp short loc_C802E
mov rcx, rax
mov eax, edx
mov [rsp+arg_A8], rcx
mov [rsp+arg_A4], eax
jmp short loc_C8006
mov rcx, rax
mov eax, edx
mov [rsp+arg_A8], rcx
mov [rsp+arg_A4], eax
test [rsp+arg_45], 1
jnz short loc_C7FFA
jmp short loc_C8004
loc_C7FFA:
lea rdi, [rsp+arg_48]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_C8004:
jmp short $+2
loc_C8006:
test [rsp+arg_46], 1
jnz short loc_C800F
jmp short loc_C8019
loc_C800F:
lea rdi, [rsp+arg_47]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
loc_C8019:
test [rsp+arg_6D], 1
jnz short loc_C8022
jmp short loc_C802C
loc_C8022:
lea rdi, [rsp+arg_70]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_C802C:
jmp short $+2
loc_C802E:
test [rsp+arg_6E], 1
jnz short loc_C8037
jmp short loc_C8041
loc_C8037:
lea rdi, [rsp+arg_6F]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
loc_C8041:
jmp loc_C8112
loc_C8046:
mov rdi, [rsp+0E8h+var_30]; this
lea rsi, aYes; "yes"
call _ZN7testing8internal6String28CaseInsensitiveCStringEqualsEPKcS3_; testing::internal::String::CaseInsensitiveCStringEquals(char const*,char const*)
mov [rsp+0E8h+var_DC], al
jmp short $+2
loc_C8060:
mov cl, [rsp+0E8h+var_DC]
mov al, 1
test cl, 1
mov [rsp+0E8h+var_DD], al
jnz short loc_C80DF
jmp short $+2
loc_C8071:
mov rdi, [rsp+0E8h+var_30]; this
lea rsi, aTrue; "true"
call _ZN7testing8internal6String28CaseInsensitiveCStringEqualsEPKcS3_; testing::internal::String::CaseInsensitiveCStringEquals(char const*,char const*)
mov [rsp+0E8h+var_DE], al
jmp short $+2
loc_C808B:
mov cl, [rsp+0E8h+var_DE]
mov al, 1
test cl, 1
mov [rsp+0E8h+var_DD], al
jnz short loc_C80DF
jmp short $+2
loc_C809C:
mov rdi, [rsp+0E8h+var_30]; this
lea rsi, aT+1; char *
call _ZN7testing8internal6String28CaseInsensitiveCStringEqualsEPKcS3_; testing::internal::String::CaseInsensitiveCStringEquals(char const*,char const*)
mov [rsp+0E8h+var_DF], al
jmp short $+2
loc_C80B6:
mov cl, [rsp+0E8h+var_DF]
mov al, 1
test cl, 1
mov [rsp+0E8h+var_DD], al
jnz short loc_C80DF
jmp short $+2
loc_C80C7:
mov rdi, [rsp+0E8h+var_30]; this
lea rsi, aFcntlPipeFd1FS+22h; char *
call _ZN7testing8internal6String13CStringEqualsEPKcS3_; testing::internal::String::CStringEquals(char const*,char const*)
mov [rsp+0E8h+var_DD], al
loc_C80DF:
mov al, [rsp+0E8h+var_DD]
and al, 1
mov [rsp+0E8h+var_1], al
mov [rsp+0E8h+var_A0], 1
loc_C80F4:
lea rdi, [rsp+0E8h+var_28]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov al, [rsp+0E8h+var_1]
and al, 1
add rsp, 0E8h
retn
loc_C8112:
lea rdi, [rsp+arg_B8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, [rsp+arg_A8]
call __Unwind_Resume
|
bool testing::internal::ShouldUseColor(testing::internal *this)
{
const char *v1; // rsi
const char *v2; // rdx
const char *v3; // rdx
const char *v4; // rdx
const char *v5; // rdx
const char *v6; // rdx
const char *v7; // rdx
const char *v8; // rdx
const char *v9; // rdx
const char *v10; // rdx
const char *v11; // rdx
const char *v12; // rdx
const char *v13; // rdx
const char *v14; // rdx
const char *v15; // rdx
bool v17; // [rsp+Bh] [rbp-DDh]
bool v18; // [rsp+Dh] [rbp-DBh]
testing::internal::String *v19; // [rsp+18h] [rbp-D0h]
char v20; // [rsp+2Eh] [rbp-BAh]
char v21; // [rsp+2Fh] [rbp-B9h]
char v22; // [rsp+4Dh] [rbp-9Bh]
char v23; // [rsp+4Eh] [rbp-9Ah]
char v24; // [rsp+4Fh] [rbp-99h] BYREF
_BYTE v25[37]; // [rsp+50h] [rbp-98h] BYREF
char v26; // [rsp+75h] [rbp-73h]
char v27; // [rsp+76h] [rbp-72h]
char v28; // [rsp+77h] [rbp-71h] BYREF
_BYTE v29[39]; // [rsp+78h] [rbp-70h] BYREF
bool v30; // [rsp+9Fh] [rbp-49h]
testing::internal::String *Env; // [rsp+A0h] [rbp-48h]
testing::internal::String *v32; // [rsp+B8h] [rbp-30h]
_QWORD v33[4]; // [rsp+C0h] [rbp-28h] BYREF
char v34; // [rsp+E6h] [rbp-2h]
bool v35; // [rsp+E7h] [rbp-1h]
v34 = (unsigned __int8)this & 1;
std::string::basic_string(v33, (long long)&testing::FLAGS_gtest_color[abi:cxx11]);
v32 = (testing::internal::String *)std::string::c_str((long long)v33);
v1 = "auto";
if ( testing::internal::String::CaseInsensitiveCStringEquals(v32, "auto", v2) )
{
Env = (testing::internal::String *)testing::internal::posix::GetEnv((testing::internal::posix *)"TERM", "auto");
v27 = 0;
v26 = 0;
v23 = 0;
v22 = 0;
v21 = 0;
if ( Env )
{
v1 = "xterm";
v20 = 1;
if ( !testing::internal::String::CStringEquals(Env, "xterm", v4) )
{
v1 = "xterm-color";
v20 = 1;
if ( !testing::internal::String::CStringEquals(Env, "xterm-color", v5) )
{
v1 = "xterm-kitty";
v20 = 1;
if ( !testing::internal::String::CStringEquals(Env, "xterm-kitty", v6) )
{
v1 = "alacritty";
v20 = 1;
if ( !testing::internal::String::CStringEquals(Env, "alacritty", v7) )
{
v1 = "screen";
v20 = 1;
if ( !testing::internal::String::CStringEquals(Env, "screen", v8) )
{
v1 = "tmux";
v20 = 1;
if ( !testing::internal::String::CStringEquals(Env, "tmux", v9) )
{
v1 = "rxvt-unicode";
v20 = 1;
if ( !testing::internal::String::CStringEquals(Env, "rxvt-unicode", v10) )
{
v1 = "linux";
v20 = 1;
if ( !testing::internal::String::CStringEquals(Env, "linux", v11) )
{
v1 = "cygwin";
v20 = 1;
if ( !testing::internal::String::CStringEquals(Env, "cygwin", v12) )
{
v19 = Env;
std::allocator<char>::allocator();
v27 = 1;
std::string::basic_string<std::allocator<char>>((long long)v29, (long long)v19, (long long)&v28);
v26 = 1;
std::allocator<char>::allocator();
v23 = 1;
std::string::basic_string<std::allocator<char>>(
(long long)v25,
(long long)"-256color",
(long long)&v24);
v22 = 1;
v1 = v25;
v20 = testing::internal::String::EndsWithCaseInsensitive((long long)v29, (long long)v25);
}
}
}
}
}
}
}
}
}
v21 = v20;
}
if ( (v22 & 1) != 0 )
std::string::~string(v25);
if ( (v23 & 1) != 0 )
std::allocator<char>::~allocator(&v24, v1);
if ( (v26 & 1) != 0 )
std::string::~string(v29);
if ( (v27 & 1) != 0 )
std::allocator<char>::~allocator(&v28, v1);
v30 = v21 & 1;
v18 = 0;
if ( (v34 & 1) != 0 )
v18 = v30;
v35 = v18;
}
else
{
v17 = 1;
if ( !testing::internal::String::CaseInsensitiveCStringEquals(v32, "yes", v3) )
{
v17 = 1;
if ( !testing::internal::String::CaseInsensitiveCStringEquals(v32, "true", v13) )
{
v17 = 1;
if ( !testing::internal::String::CaseInsensitiveCStringEquals(v32, "t", v14) )
v17 = testing::internal::String::CStringEquals(v32, "1", v15);
}
}
v35 = v17;
}
std::string::~string(v33);
return v35;
}
|
ShouldUseColor:
SUB RSP,0xe8
MOV AL,DIL
AND AL,0x1
MOV byte ptr [RSP + 0xe6],AL
LEA RSI,[0x278b58]
LEA RDI,[RSP + 0xc0]
MOV qword ptr [RSP + 0x38],RDI
CALL 0x00139160
MOV RDI,qword ptr [RSP + 0x38]
CALL 0x0011acc0
MOV qword ptr [RSP + 0xb8],RAX
MOV RDI,qword ptr [RSP + 0xb8]
LAB_001c7cb6:
LEA RSI,[0x212ddb]
CALL 0x001c3160
MOV byte ptr [RSP + 0x47],AL
JMP 0x001c7cc8
LAB_001c7cc8:
MOV AL,byte ptr [RSP + 0x47]
TEST AL,0x1
JNZ 0x001c7cd5
JMP 0x001c8046
LAB_001c7cd5:
LEA RDI,[0x20d6fa]
CALL 0x001e4170
MOV qword ptr [RSP + 0x30],RAX
JMP 0x001c7ce8
LAB_001c7ce8:
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0xa0],RAX
MOV RCX,qword ptr [RSP + 0xa0]
MOV byte ptr [RSP + 0x76],0x0
MOV byte ptr [RSP + 0x75],0x0
MOV byte ptr [RSP + 0x4e],0x0
MOV byte ptr [RSP + 0x4d],0x0
XOR EAX,EAX
CMP RCX,0x0
MOV byte ptr [RSP + 0x2f],AL
JZ 0x001c7f02
MOV RDI,qword ptr [RSP + 0xa0]
LEA RSI,[0x20d74a]
CALL 0x001c0580
MOV CL,AL
MOV AL,0x1
TEST CL,0x1
MOV byte ptr [RSP + 0x2e],AL
JNZ 0x001c7efa
MOV RDI,qword ptr [RSP + 0xa0]
LEA RSI,[0x2138bd]
CALL 0x001c0580
MOV CL,AL
MOV AL,0x1
TEST CL,0x1
MOV byte ptr [RSP + 0x2e],AL
JNZ 0x001c7efa
MOV RDI,qword ptr [RSP + 0xa0]
LEA RSI,[0x2138c9]
CALL 0x001c0580
MOV CL,AL
MOV AL,0x1
TEST CL,0x1
MOV byte ptr [RSP + 0x2e],AL
JNZ 0x001c7efa
MOV RDI,qword ptr [RSP + 0xa0]
LEA RSI,[0x20d750]
CALL 0x001c0580
MOV CL,AL
MOV AL,0x1
TEST CL,0x1
MOV byte ptr [RSP + 0x2e],AL
JNZ 0x001c7efa
MOV RDI,qword ptr [RSP + 0xa0]
LEA RSI,[0x20d73d]
CALL 0x001c0580
MOV CL,AL
MOV AL,0x1
TEST CL,0x1
MOV byte ptr [RSP + 0x2e],AL
JNZ 0x001c7efa
MOV RDI,qword ptr [RSP + 0xa0]
LEA RSI,[0x2138d5]
CALL 0x001c0580
MOV CL,AL
MOV AL,0x1
TEST CL,0x1
MOV byte ptr [RSP + 0x2e],AL
JNZ 0x001c7efa
MOV RDI,qword ptr [RSP + 0xa0]
LEA RSI,[0x2138da]
CALL 0x001c0580
MOV CL,AL
MOV AL,0x1
TEST CL,0x1
MOV byte ptr [RSP + 0x2e],AL
JNZ 0x001c7efa
MOV RDI,qword ptr [RSP + 0xa0]
LEA RSI,[0x20d727]
CALL 0x001c0580
MOV CL,AL
MOV AL,0x1
TEST CL,0x1
MOV byte ptr [RSP + 0x2e],AL
JNZ 0x001c7efa
MOV RDI,qword ptr [RSP + 0xa0]
LEA RSI,[0x20d70c]
CALL 0x001c0580
MOV CL,AL
MOV AL,0x1
TEST CL,0x1
MOV byte ptr [RSP + 0x2e],AL
JNZ 0x001c7efa
MOV RAX,qword ptr [RSP + 0xa0]
MOV qword ptr [RSP + 0x18],RAX
LEA RDI,[RSP + 0x77]
MOV qword ptr [RSP + 0x20],RDI
CALL 0x00114c90
MOV RSI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x20]
MOV byte ptr [RSP + 0x76],0x1
LAB_001c7e99:
LEA RDI,[RSP + 0x78]
CALL 0x0011a6a0
JMP 0x001c7ea5
LAB_001c7ea5:
MOV byte ptr [RSP + 0x75],0x1
LEA RDI,[RSP + 0x4f]
MOV qword ptr [RSP + 0x10],RDI
CALL 0x00114c90
MOV RDX,qword ptr [RSP + 0x10]
MOV byte ptr [RSP + 0x4e],0x1
LAB_001c7ec3:
LEA RSI,[0x2138e7]
LEA RDI,[RSP + 0x50]
CALL 0x0011a6a0
JMP 0x001c7ed6
LAB_001c7ed6:
MOV byte ptr [RSP + 0x4d],0x1
LAB_001c7edb:
LEA RDI,[RSP + 0x78]
LEA RSI,[RSP + 0x50]
CALL 0x001b67e0
MOV byte ptr [RSP + 0xf],AL
JMP 0x001c7ef0
LAB_001c7ef0:
MOV AL,byte ptr [RSP + 0xf]
MOV byte ptr [RSP + 0x2e],AL
JMP 0x001c7efa
LAB_001c7efa:
MOV AL,byte ptr [RSP + 0x2e]
MOV byte ptr [RSP + 0x2f],AL
LAB_001c7f02:
MOV AL,byte ptr [RSP + 0x2f]
MOV byte ptr [RSP + 0xe],AL
TEST byte ptr [RSP + 0x4d],0x1
JNZ 0x001c7f13
JMP 0x001c7f1d
LAB_001c7f13:
LEA RDI,[RSP + 0x50]
CALL 0x0011aac0
LAB_001c7f1d:
TEST byte ptr [RSP + 0x4e],0x1
JNZ 0x001c7f26
JMP 0x001c7f30
LAB_001c7f26:
LEA RDI,[RSP + 0x4f]
CALL 0x00114750
LAB_001c7f30:
TEST byte ptr [RSP + 0x75],0x1
JNZ 0x001c7f39
JMP 0x001c7f43
LAB_001c7f39:
LEA RDI,[RSP + 0x78]
CALL 0x0011aac0
LAB_001c7f43:
TEST byte ptr [RSP + 0x76],0x1
JNZ 0x001c7f4c
JMP 0x001c7f56
LAB_001c7f4c:
LEA RDI,[RSP + 0x77]
CALL 0x00114750
LAB_001c7f56:
MOV AL,byte ptr [RSP + 0xe]
AND AL,0x1
MOV byte ptr [RSP + 0x9f],AL
XOR EAX,EAX
TEST byte ptr [RSP + 0xe6],0x1
MOV byte ptr [RSP + 0xd],AL
JZ 0x001c7f7e
MOV AL,byte ptr [RSP + 0x9f]
MOV byte ptr [RSP + 0xd],AL
LAB_001c7f7e:
MOV AL,byte ptr [RSP + 0xd]
AND AL,0x1
MOV byte ptr [RSP + 0xe7],AL
MOV dword ptr [RSP + 0x48],0x1
JMP 0x001c80f4
LAB_001c8046:
MOV RDI,qword ptr [RSP + 0xb8]
LAB_001c804e:
LEA RSI,[0x2138f1]
CALL 0x001c3160
MOV byte ptr [RSP + 0xc],AL
JMP 0x001c8060
LAB_001c8060:
MOV CL,byte ptr [RSP + 0xc]
MOV AL,0x1
TEST CL,0x1
MOV byte ptr [RSP + 0xb],AL
JNZ 0x001c80df
JMP 0x001c8071
LAB_001c8071:
MOV RDI,qword ptr [RSP + 0xb8]
LEA RSI,[0x20c0ac]
CALL 0x001c3160
MOV byte ptr [RSP + 0xa],AL
JMP 0x001c808b
LAB_001c808b:
MOV CL,byte ptr [RSP + 0xa]
MOV AL,0x1
TEST CL,0x1
MOV byte ptr [RSP + 0xb],AL
JNZ 0x001c80df
JMP 0x001c809c
LAB_001c809c:
MOV RDI,qword ptr [RSP + 0xb8]
LEA RSI,[0x213e00]
CALL 0x001c3160
LAB_001c80b0:
MOV byte ptr [RSP + 0x9],AL
JMP 0x001c80b6
LAB_001c80b6:
MOV CL,byte ptr [RSP + 0x9]
MOV AL,0x1
TEST CL,0x1
MOV byte ptr [RSP + 0xb],AL
JNZ 0x001c80df
JMP 0x001c80c7
LAB_001c80c7:
MOV RDI,qword ptr [RSP + 0xb8]
LEA RSI,[0x212a4f]
CALL 0x001c0580
MOV byte ptr [RSP + 0xb],AL
LAB_001c80df:
MOV AL,byte ptr [RSP + 0xb]
AND AL,0x1
MOV byte ptr [RSP + 0xe7],AL
MOV dword ptr [RSP + 0x48],0x1
LAB_001c80f4:
LEA RDI,[RSP + 0xc0]
CALL 0x0011aac0
MOV AL,byte ptr [RSP + 0xe7]
AND AL,0x1
ADD RSP,0xe8
RET
|
/* testing::internal::ShouldUseColor(bool) */
ulong testing::internal::ShouldUseColor(bool param_1)
{
bool bVar1;
bool bVar2;
char *pcVar3;
byte bVar4;
int8 uVar5;
byte local_dd;
byte local_db;
byte local_ba;
byte local_b9;
allocator local_99;
string local_98 [37];
byte local_73;
byte local_72;
allocator local_71;
string local_70 [39];
byte local_49;
char *local_48;
char *local_30;
string local_28 [38];
byte local_2;
byte local_1;
local_2 = param_1;
std::__cxx11::string::string(local_28,(string *)FLAGS_gtest_color_abi_cxx11_);
local_30 = (char *)std::__cxx11::string::c_str(local_28);
/* try { // try from 001c7cb6 to 001c7ce0 has its CatchHandler @ 001c7f98 */
bVar4 = String::CaseInsensitiveCStringEquals(local_30,"auto");
if ((bVar4 & 1) == 0) {
/* try { // try from 001c804e to 001c80af has its CatchHandler @ 001c7f98 */
bVar4 = String::CaseInsensitiveCStringEquals(local_30,"yes");
local_dd = 1;
if ((bVar4 & 1) == 0) {
bVar4 = String::CaseInsensitiveCStringEquals(local_30,"true");
local_dd = 1;
if ((bVar4 & 1) == 0) {
bVar4 = String::CaseInsensitiveCStringEquals(local_30,"t");
local_dd = 1;
if ((bVar4 & 1) == 0) {
local_dd = String::CStringEquals(local_30,"1");
}
}
}
local_1 = local_dd & 1;
}
else {
local_48 = (char *)posix::GetEnv("TERM");
local_72 = 0;
local_73 = 0;
bVar2 = false;
bVar1 = false;
local_b9 = 0;
if (local_48 != (char *)0x0) {
bVar4 = String::CStringEquals(local_48,"xterm");
local_ba = 1;
if ((bVar4 & 1) == 0) {
bVar4 = String::CStringEquals(local_48,"xterm-color");
local_ba = 1;
if ((bVar4 & 1) == 0) {
bVar4 = String::CStringEquals(local_48,"xterm-kitty");
local_ba = 1;
if ((bVar4 & 1) == 0) {
bVar4 = String::CStringEquals(local_48,"alacritty");
local_ba = 1;
if ((bVar4 & 1) == 0) {
bVar4 = String::CStringEquals(local_48,"screen");
local_ba = 1;
if ((bVar4 & 1) == 0) {
bVar4 = String::CStringEquals(local_48,"tmux");
local_ba = 1;
if ((bVar4 & 1) == 0) {
bVar4 = String::CStringEquals(local_48,"rxvt-unicode");
local_ba = 1;
if ((bVar4 & 1) == 0) {
bVar4 = String::CStringEquals(local_48,"linux");
local_ba = 1;
if ((bVar4 & 1) == 0) {
bVar4 = String::CStringEquals(local_48,"cygwin");
pcVar3 = local_48;
local_ba = 1;
if ((bVar4 & 1) == 0) {
std::allocator<char>::allocator();
local_72 = 1;
/* try { // try from 001c7e99 to 001c7ea2 has its CatchHandler @ 001c7fb1 */
std::__cxx11::string::string<std::allocator<char>>
(local_70,pcVar3,&local_71);
local_73 = 1;
std::allocator<char>::allocator();
bVar2 = true;
/* try { // try from 001c7ec3 to 001c7ed3 has its CatchHandler @ 001c7fc7 */
std::__cxx11::string::string<std::allocator<char>>
(local_98,"-256color",&local_99);
bVar1 = true;
/* try { // try from 001c7edb to 001c7ee9 has its CatchHandler @ 001c7fdd */
local_ba = String::EndsWithCaseInsensitive(local_70,local_98);
}
}
}
}
}
}
}
}
}
local_b9 = local_ba;
}
if (bVar1) {
std::__cxx11::string::~string(local_98);
}
if (bVar2) {
std::allocator<char>::~allocator((allocator<char> *)&local_99);
}
if ((local_73 & 1) != 0) {
std::__cxx11::string::~string(local_70);
}
if ((local_72 & 1) != 0) {
std::allocator<char>::~allocator((allocator<char> *)&local_71);
}
local_49 = local_b9 & 1;
local_db = 0;
if ((local_2 & 1) != 0) {
local_db = local_49;
}
local_1 = local_db;
}
uVar5 = std::__cxx11::string::~string(local_28);
return CONCAT71((int7)((ulong)uVar5 >> 8),local_1) & 0xffffffffffffff01;
}
|
|
11,748 |
JS_WriteTypedArray
|
bluesky950520[P]quickjs/quickjs.c
|
static int JS_WriteTypedArray(BCWriterState *s, JSValue obj)
{
JSObject *p = JS_VALUE_GET_OBJ(obj);
JSTypedArray *ta = p->u.typed_array;
bc_put_u8(s, BC_TAG_TYPED_ARRAY);
bc_put_u8(s, p->class_id - JS_CLASS_UINT8C_ARRAY);
bc_put_leb128(s, p->u.array.count);
bc_put_leb128(s, ta->offset);
if (JS_WriteObjectRec(s, JS_MKPTR(JS_TAG_OBJECT, ta->buffer)))
return -1;
return 0;
}
|
O0
|
c
|
JS_WriteTypedArray:
subq $0x48, %rsp
movq %rsi, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq %rdi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movl $0xe, %esi
callq 0x768e0
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movzwl 0x6(%rax), %eax
subl $0x15, %eax
movzbl %al, %esi
callq 0x768e0
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movl 0x40(%rax), %esi
callq 0x77470
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rax
movl 0x20(%rax), %esi
callq 0x77470
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movq $-0x1, 0x10(%rsp)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x49fc0
cmpl $0x0, %eax
je 0x77d11
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x77d19
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
|
JS_WriteTypedArray:
sub rsp, 48h
mov [rsp+48h+var_18], rsi
mov [rsp+48h+var_10], rdx
mov [rsp+48h+var_20], rdi
mov rax, [rsp+48h+var_18]
mov [rsp+48h+var_28], rax
mov rax, [rsp+48h+var_28]
mov rax, [rax+30h]
mov [rsp+48h+var_30], rax
mov rdi, [rsp+48h+var_20]
mov esi, 0Eh
call bc_put_u8
mov rdi, [rsp+48h+var_20]
mov rax, [rsp+48h+var_28]
movzx eax, word ptr [rax+6]
sub eax, 15h
movzx esi, al
call bc_put_u8
mov rdi, [rsp+48h+var_20]
mov rax, [rsp+48h+var_28]
mov esi, [rax+40h]
call bc_put_leb128
mov rdi, [rsp+48h+var_20]
mov rax, [rsp+48h+var_30]
mov esi, [rax+20h]
call bc_put_leb128
mov rdi, [rsp+48h+var_20]
mov rax, [rsp+48h+var_30]
mov rax, [rax+18h]
mov [rsp+48h+var_40], rax
mov [rsp+48h+var_38], 0FFFFFFFFFFFFFFFFh
mov rsi, [rsp+48h+var_40]
mov rdx, [rsp+48h+var_38]
call JS_WriteObjectRec
cmp eax, 0
jz short loc_77D11
mov [rsp+48h+var_4], 0FFFFFFFFh
jmp short loc_77D19
loc_77D11:
mov [rsp+48h+var_4], 0
loc_77D19:
mov eax, [rsp+48h+var_4]
add rsp, 48h
retn
|
long long JS_WriteTypedArray(
long long *a1,
long long a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
double a7,
double a8,
__m128 a9,
__m128 a10)
{
double v10; // xmm4_8
double v11; // xmm5_8
long long v13; // [rsp+18h] [rbp-30h]
v13 = *(_QWORD *)(a2 + 48);
bc_put_u8((long long)a1, 14);
bc_put_u8((long long)a1, *(_WORD *)(a2 + 6) - 21);
bc_put_leb128((long long)a1, *(_DWORD *)(a2 + 64));
bc_put_leb128((long long)a1, *(_DWORD *)(v13 + 32));
if ( (unsigned int)JS_WriteObjectRec(a1, *(_QWORD *)(v13 + 24), -1LL, a3, a4, a5, a6, v10, v11, a9, a10) )
return (unsigned int)-1;
else
return 0;
}
|
JS_WriteTypedArray:
SUB RSP,0x48
MOV qword ptr [RSP + 0x30],RSI
MOV qword ptr [RSP + 0x38],RDX
MOV qword ptr [RSP + 0x28],RDI
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RAX + 0x30]
MOV qword ptr [RSP + 0x18],RAX
MOV RDI,qword ptr [RSP + 0x28]
MOV ESI,0xe
CALL 0x001768e0
MOV RDI,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x20]
MOVZX EAX,word ptr [RAX + 0x6]
SUB EAX,0x15
MOVZX ESI,AL
CALL 0x001768e0
MOV RDI,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x20]
MOV ESI,dword ptr [RAX + 0x40]
CALL 0x00177470
MOV RDI,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x18]
MOV ESI,dword ptr [RAX + 0x20]
CALL 0x00177470
MOV RDI,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],-0x1
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
CALL 0x00149fc0
CMP EAX,0x0
JZ 0x00177d11
MOV dword ptr [RSP + 0x44],0xffffffff
JMP 0x00177d19
LAB_00177d11:
MOV dword ptr [RSP + 0x44],0x0
LAB_00177d19:
MOV EAX,dword ptr [RSP + 0x44]
ADD RSP,0x48
RET
|
int4 JS_WriteTypedArray(int8 param_1,long param_2)
{
long lVar1;
int iVar2;
int4 local_4;
lVar1 = *(long *)(param_2 + 0x30);
bc_put_u8(param_1,0xe);
bc_put_u8(param_1,*(short *)(param_2 + 6) - 0x15U & 0xff);
bc_put_leb128(param_1,*(int4 *)(param_2 + 0x40));
bc_put_leb128(param_1,*(int4 *)(lVar1 + 0x20));
iVar2 = JS_WriteObjectRec(param_1,*(int8 *)(lVar1 + 0x18),0xffffffffffffffff);
if (iVar2 == 0) {
local_4 = 0;
}
else {
local_4 = 0xffffffff;
}
return local_4;
}
|
|
11,749 |
JS_WriteTypedArray
|
bluesky950520[P]quickjs/quickjs.c
|
static int JS_WriteTypedArray(BCWriterState *s, JSValue obj)
{
JSObject *p = JS_VALUE_GET_OBJ(obj);
JSTypedArray *ta = p->u.typed_array;
bc_put_u8(s, BC_TAG_TYPED_ARRAY);
bc_put_u8(s, p->class_id - JS_CLASS_UINT8C_ARRAY);
bc_put_leb128(s, p->u.array.count);
bc_put_leb128(s, ta->offset);
if (JS_WriteObjectRec(s, JS_MKPTR(JS_TAG_OBJECT, ta->buffer)))
return -1;
return 0;
}
|
O1
|
c
|
JS_WriteTypedArray:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x30(%rsi), %r12
leaq 0x8(%rdi), %r15
movq %r15, %rdi
movl $0xe, %esi
callq 0x1a8bc
movb 0x6(%r14), %al
addb $-0x15, %al
movzbl %al, %esi
movq %r15, %rdi
callq 0x1a8bc
movl 0x40(%r14), %esi
movq %r15, %rdi
callq 0x44c40
movl 0x20(%r12), %esi
movq %r15, %rdi
callq 0x44c40
movq 0x18(%r12), %rsi
movq %rbx, %rdi
movq $-0x1, %rdx
callq 0x30e56
xorl %ecx, %ecx
negl %eax
sbbl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
JS_WriteTypedArray:
push r15
push r14
push r12
push rbx
push rax
mov r14, rsi
mov rbx, rdi
mov r12, [rsi+30h]
lea r15, [rdi+8]
mov rdi, r15
mov esi, 0Eh
call dbuf_putc
mov al, [r14+6]
add al, 0EBh
movzx esi, al
mov rdi, r15
call dbuf_putc
mov esi, [r14+40h]
mov rdi, r15
call dbuf_put_leb128
mov esi, [r12+20h]
mov rdi, r15
call dbuf_put_leb128
mov rsi, [r12+18h]
mov rdi, rbx
mov rdx, 0FFFFFFFFFFFFFFFFh
call JS_WriteObjectRec
xor ecx, ecx
neg eax
sbb ecx, ecx
mov eax, ecx
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
|
long long JS_WriteTypedArray(
long long *a1,
long long a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
double a7,
double a8,
__m128 a9,
__m128 a10)
{
long long v10; // r12
long long v11; // rcx
long long v12; // r8
long long v13; // r9
__m128 v14; // xmm4
__m128 v15; // xmm5
v10 = *(_QWORD *)(a2 + 48);
dbuf_putc(a1 + 1, 14);
dbuf_putc(a1 + 1, *(_BYTE *)(a2 + 6) - 21);
dbuf_put_leb128(a1 + 1, *(unsigned int *)(a2 + 64));
dbuf_put_leb128(a1 + 1, *(unsigned int *)(v10 + 32));
return (unsigned int)-((unsigned int)JS_WriteObjectRec(
a1,
*(_QWORD *)(v10 + 24),
-1LL,
v11,
v12,
v13,
a3,
a4,
a5,
a6,
v14,
v15,
a9,
a10) != 0);
}
|
JS_WriteTypedArray:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
MOV R12,qword ptr [RSI + 0x30]
LEA R15,[RDI + 0x8]
MOV RDI,R15
MOV ESI,0xe
CALL 0x0011a8bc
MOV AL,byte ptr [R14 + 0x6]
ADD AL,0xeb
MOVZX ESI,AL
MOV RDI,R15
CALL 0x0011a8bc
MOV ESI,dword ptr [R14 + 0x40]
MOV RDI,R15
CALL 0x00144c40
MOV ESI,dword ptr [R12 + 0x20]
MOV RDI,R15
CALL 0x00144c40
MOV RSI,qword ptr [R12 + 0x18]
MOV RDI,RBX
MOV RDX,-0x1
CALL 0x00130e56
XOR ECX,ECX
NEG EAX
SBB ECX,ECX
MOV EAX,ECX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
int JS_WriteTypedArray(long param_1,long param_2)
{
long lVar1;
long lVar2;
int iVar3;
lVar2 = *(long *)(param_2 + 0x30);
lVar1 = param_1 + 8;
dbuf_putc(lVar1,0xe);
dbuf_putc(lVar1,*(char *)(param_2 + 6) + -0x15);
dbuf_put_leb128(lVar1,*(int4 *)(param_2 + 0x40));
dbuf_put_leb128(lVar1,*(int4 *)(lVar2 + 0x20));
iVar3 = JS_WriteObjectRec(param_1,*(int8 *)(lVar2 + 0x18),0xffffffffffffffff);
return -(uint)(iVar3 != 0);
}
|
|
11,750 |
my_copy_fix_mb2_or_mb4
|
eloqsql/strings/ctype-ucs2.c
|
static size_t
my_copy_fix_mb2_or_mb4(CHARSET_INFO *cs,
char *dst, size_t dst_length,
const char *src, size_t src_length,
size_t nchars, MY_STRCOPY_STATUS *status)
{
size_t length2, src_offset= src_length % cs->mbminlen;
my_char_copy_status_t padstatus;
if (!src_offset)
return my_copy_fix_mb(cs, dst, dst_length,
src, src_length, nchars, status);
if ((padstatus= my_copy_incomplete_char(cs, dst, dst_length,
src, src_length, nchars, TRUE)) ==
MY_CHAR_COPY_ERROR)
{
status->m_source_end_pos= status->m_well_formed_error_pos= src;
return 0;
}
length2= my_copy_fix_mb(cs, dst + cs->mbminlen, dst_length - cs->mbminlen,
src + src_offset, src_length - src_offset,
nchars - 1, status);
if (padstatus == MY_CHAR_COPY_FIXED)
status->m_well_formed_error_pos= src;
return cs->mbminlen /* The left-padded character */ + length2;
}
|
O3
|
c
|
my_copy_fix_mb2_or_mb4:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r12
movq %rdx, %r10
movq %rsi, %rbx
movq %rdi, %r14
movl 0x98(%rdi), %r13d
movq %r8, %rax
xorl %edx, %edx
divq %r13
testq %rdx, %rdx
je 0x483ad
cmpq %r10, %r13
seta %al
movq 0x10(%rbp), %rsi
testq %r9, %r9
sete %cl
orb %al, %cl
jne 0x4843c
movq %rdx, %r15
movq %rsi, -0x38(%rbp)
movq %r10, -0x40(%rbp)
movq %r8, -0x48(%rbp)
movq %r9, -0x50(%rbp)
subq %rdx, %r13
movq %rbx, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x241b0
addq %rbx, %r13
movq %r13, %rdi
movq %r12, -0x58(%rbp)
movq %r12, %rsi
movq %r15, %rdx
callq 0x24570
movl 0x98(%r14), %edx
addq %rbx, %rdx
movq 0xb8(%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0xc0(%rax)
movl 0x98(%r14), %r13d
cmpl %r13d, %eax
movl %eax, -0x2c(%rbp)
jne 0x483cc
movq -0x58(%rbp), %r12
movq -0x50(%rbp), %r9
movq -0x48(%rbp), %r8
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rsi
jmp 0x48402
movq %r14, %rdi
movq %rbx, %rsi
movq %r10, %rdx
movq %r12, %rcx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x37386
movq 0xb8(%r14), %rax
leaq (%rbx,%r13), %rcx
movl $0x3f, %esi
movq %r14, %rdi
movq %rbx, %rdx
callq *0x30(%rax)
cmpl 0x98(%r14), %eax
movq -0x58(%rbp), %r12
movq -0x50(%rbp), %r9
movq -0x48(%rbp), %r8
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rsi
jne 0x4843c
movl %eax, %eax
addq %rax, %rbx
subq %rax, %rdx
leaq (%r12,%r15), %rcx
subq %r15, %r8
decq %r9
movq %rsi, (%rsp)
movq %r14, %rdi
movq %rsi, %r15
movq %rbx, %rsi
callq 0x37386
cmpl %r13d, -0x2c(%rbp)
je 0x48430
movq %r12, 0x8(%r15)
movl 0x98(%r14), %ecx
addq %rcx, %rax
jmp 0x48445
movq %r12, 0x8(%rsi)
movq %r12, (%rsi)
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
my_copy_fix_mb2_or_mb4:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r12, rcx
mov r10, rdx
mov rbx, rsi
mov r14, rdi
mov r13d, [rdi+98h]
mov rax, r8
xor edx, edx
div r13
test rdx, rdx
jz loc_483AD
cmp r13, r10
setnbe al
mov rsi, [rbp+arg_0]
test r9, r9
setz cl
or cl, al
jnz loc_4843C
mov r15, rdx
mov [rbp+var_38], rsi
mov [rbp+var_40], r10
mov [rbp+var_48], r8
mov [rbp+var_50], r9
sub r13, rdx
mov rdi, rbx
xor esi, esi
mov rdx, r13
call _memset
add r13, rbx
mov rdi, r13
mov [rbp+var_58], r12
mov rsi, r12
mov rdx, r15
call _memmove
mov edx, [r14+98h]
add rdx, rbx
mov rax, [r14+0B8h]
mov rdi, r14
mov rsi, rbx
call qword ptr [rax+0C0h]
mov r13d, [r14+98h]
cmp eax, r13d
mov [rbp+var_2C], eax
jnz short loc_483CC
mov r12, [rbp+var_58]
mov r9, [rbp+var_50]
mov r8, [rbp+var_48]
mov rdx, [rbp+var_40]
mov rsi, [rbp+var_38]
jmp short loc_48402
loc_483AD:
mov rdi, r14
mov rsi, rbx
mov rdx, r10
mov rcx, r12
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp my_copy_fix_mb
loc_483CC:
mov rax, [r14+0B8h]
lea rcx, [rbx+r13]
mov esi, 3Fh ; '?'
mov rdi, r14
mov rdx, rbx
call qword ptr [rax+30h]
cmp eax, [r14+98h]
mov r12, [rbp+var_58]
mov r9, [rbp+var_50]
mov r8, [rbp+var_48]
mov rdx, [rbp+var_40]
mov rsi, [rbp+var_38]
jnz short loc_4843C
loc_48402:
mov eax, eax
add rbx, rax
sub rdx, rax
lea rcx, [r12+r15]
sub r8, r15
dec r9
mov [rsp+60h+var_60], rsi
mov rdi, r14
mov r15, rsi
mov rsi, rbx
call my_copy_fix_mb
cmp [rbp+var_2C], r13d
jz short loc_48430
mov [r15+8], r12
loc_48430:
mov ecx, [r14+98h]
add rax, rcx
jmp short loc_48445
loc_4843C:
mov [rsi+8], r12
mov [rsi], r12
xor eax, eax
loc_48445:
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
unsigned long long my_copy_fix_mb2_or_mb4(
long long a1,
long long a2,
unsigned long long a3,
long long a4,
unsigned long long a5,
long long a6,
unsigned long long *a7)
{
unsigned long long v9; // r13
unsigned long long *v10; // rsi
unsigned long long v11; // r15
unsigned long long v12; // r13
unsigned int v13; // eax
long long v14; // r13
long long v15; // r9
unsigned long long v16; // r8
unsigned long long v17; // rdx
unsigned long long fixed; // rax
unsigned int v23; // [rsp+34h] [rbp-2Ch]
v9 = *(unsigned int *)(a1 + 152);
if ( !(a5 % v9) )
return my_copy_fix_mb(a1, a2, a3, a4, a5, a6, a7);
v10 = a7;
if ( v9 > a3 || a6 == 0 )
goto LABEL_10;
v11 = a5 % *(unsigned int *)(a1 + 152);
v12 = v9 - a5 % v9;
memset(a2, 0LL, v12);
memmove(a2 + v12, a4, v11);
v13 = (*(long long ( **)(long long, long long, long long))(*(_QWORD *)(a1 + 184) + 192LL))(
a1,
a2,
a2 + *(unsigned int *)(a1 + 152));
v14 = *(unsigned int *)(a1 + 152);
v23 = v13;
if ( v13 != (_DWORD)v14 )
{
v13 = (*(long long ( **)(long long, long long, long long, long long))(*(_QWORD *)(a1 + 184) + 48LL))(
a1,
63LL,
a2,
a2 + v14);
v15 = a6;
v16 = a5;
v17 = a3;
v10 = a7;
if ( v13 == *(_DWORD *)(a1 + 152) )
goto LABEL_7;
LABEL_10:
v10[1] = a4;
*v10 = a4;
return 0LL;
}
v15 = a6;
v16 = a5;
v17 = a3;
v10 = a7;
LABEL_7:
fixed = my_copy_fix_mb(a1, v13 + a2, v17 - v13, a4 + v11, v16 - v11, v15 - 1, v10);
if ( v23 != (_DWORD)v14 )
v10[1] = a4;
return *(unsigned int *)(a1 + 152) + fixed;
}
|
my_copy_fix_mb2_or_mb4:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R12,RCX
MOV R10,RDX
MOV RBX,RSI
MOV R14,RDI
MOV R13D,dword ptr [RDI + 0x98]
MOV RAX,R8
XOR EDX,EDX
DIV R13
TEST RDX,RDX
JZ 0x001483ad
CMP R13,R10
SETA AL
MOV RSI,qword ptr [RBP + 0x10]
TEST R9,R9
SETZ CL
OR CL,AL
JNZ 0x0014843c
MOV R15,RDX
MOV qword ptr [RBP + -0x38],RSI
MOV qword ptr [RBP + -0x40],R10
MOV qword ptr [RBP + -0x48],R8
MOV qword ptr [RBP + -0x50],R9
SUB R13,RDX
MOV RDI,RBX
XOR ESI,ESI
MOV RDX,R13
CALL 0x001241b0
ADD R13,RBX
MOV RDI,R13
MOV qword ptr [RBP + -0x58],R12
MOV RSI,R12
MOV RDX,R15
CALL 0x00124570
MOV EDX,dword ptr [R14 + 0x98]
ADD RDX,RBX
MOV RAX,qword ptr [R14 + 0xb8]
MOV RDI,R14
MOV RSI,RBX
CALL qword ptr [RAX + 0xc0]
MOV R13D,dword ptr [R14 + 0x98]
CMP EAX,R13D
MOV dword ptr [RBP + -0x2c],EAX
JNZ 0x001483cc
MOV R12,qword ptr [RBP + -0x58]
MOV R9,qword ptr [RBP + -0x50]
MOV R8,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x38]
JMP 0x00148402
LAB_001483ad:
MOV RDI,R14
MOV RSI,RBX
MOV RDX,R10
MOV RCX,R12
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00137386
LAB_001483cc:
MOV RAX,qword ptr [R14 + 0xb8]
LEA RCX,[RBX + R13*0x1]
MOV ESI,0x3f
MOV RDI,R14
MOV RDX,RBX
CALL qword ptr [RAX + 0x30]
CMP EAX,dword ptr [R14 + 0x98]
MOV R12,qword ptr [RBP + -0x58]
MOV R9,qword ptr [RBP + -0x50]
MOV R8,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x38]
JNZ 0x0014843c
LAB_00148402:
MOV EAX,EAX
ADD RBX,RAX
SUB RDX,RAX
LEA RCX,[R12 + R15*0x1]
SUB R8,R15
DEC R9
MOV qword ptr [RSP],RSI
MOV RDI,R14
MOV R15,RSI
MOV RSI,RBX
CALL 0x00137386
CMP dword ptr [RBP + -0x2c],R13D
JZ 0x00148430
MOV qword ptr [R15 + 0x8],R12
LAB_00148430:
MOV ECX,dword ptr [R14 + 0x98]
ADD RAX,RCX
JMP 0x00148445
LAB_0014843c:
MOV qword ptr [RSI + 0x8],R12
MOV qword ptr [RSI],R12
XOR EAX,EAX
LAB_00148445:
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long my_copy_fix_mb2_or_mb4
(long param_1,void *param_2,ulong param_3,void *param_4,ulong param_5,long param_6,
int8 *param_7)
{
uint uVar1;
uint uVar2;
uint uVar3;
long lVar4;
ulong __n;
ulong uVar5;
uVar5 = (ulong)*(uint *)(param_1 + 0x98);
__n = param_5 % uVar5;
if (__n == 0) {
lVar4 = my_copy_fix_mb(param_1,param_2,param_3,param_4);
return lVar4;
}
if (param_6 != 0 && uVar5 <= param_3) {
memset(param_2,0,uVar5 - __n);
memmove((void *)((uVar5 - __n) + (long)param_2),param_4,__n);
uVar2 = (**(code **)(*(long *)(param_1 + 0xb8) + 0xc0))
(param_1,param_2,(ulong)*(uint *)(param_1 + 0x98) + (long)param_2);
uVar1 = *(uint *)(param_1 + 0x98);
uVar3 = uVar2;
if ((uVar2 == uVar1) ||
(uVar3 = (**(code **)(*(long *)(param_1 + 0xb8) + 0x30))
(param_1,0x3f,param_2,(long)param_2 + (ulong)uVar1),
uVar3 == *(uint *)(param_1 + 0x98))) {
lVar4 = my_copy_fix_mb(param_1,(long)param_2 + (ulong)uVar3,param_3 - uVar3,
(long)param_4 + __n,param_5 - __n,param_6 + -1,param_7);
if (uVar2 != uVar1) {
param_7[1] = param_4;
}
return lVar4 + (ulong)*(uint *)(param_1 + 0x98);
}
}
param_7[1] = param_4;
*param_7 = param_4;
return 0;
}
|
|
11,751 |
google::protobuf::MapValueConstRef::GetInt32Value() const
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/map_field.h
|
int32_t GetInt32Value() const {
TYPE_CHECK(FieldDescriptor::CPPTYPE_INT32,
"MapValueConstRef::GetInt32Value");
return *reinterpret_cast<int32_t*>(data_);
}
|
O3
|
c
|
google::protobuf::MapValueConstRef::GetInt32Value() const:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
callq 0x98410
cmpl $0x1, %eax
je 0x9bb25
leaq 0xcd454(%rip), %rdx # 0x168ec5
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x3, %esi
movl $0x2d0, %ecx # imm = 0x2D0
callq 0x857c2
leaq 0xcd49b(%rip), %rsi # 0x168f2a
movq %r14, %rdi
callq 0x852c0
leaq 0xcd8cb(%rip), %rsi # 0x169369
movq %rax, %rdi
callq 0x852c0
leaq 0xcd4c0(%rip), %rsi # 0x168f6d
movq %rax, %rdi
callq 0x852c0
leaq 0xcd4c7(%rip), %rsi # 0x168f83
movq %rax, %rdi
callq 0x852c0
leaq 0x170ac5(%rip), %r15 # 0x20c590
movq 0x8(%r15), %rsi
movq %rax, %rdi
callq 0x852c0
leaq 0xd0581(%rip), %rsi # 0x16c05f
movq %rax, %rdi
callq 0x852c0
leaq 0xcd4a4(%rip), %rsi # 0x168f91
movq %rax, %rdi
callq 0x852c0
movq %rax, %r14
movq %rbx, %rdi
callq 0x98410
movl %eax, %eax
movq (%r15,%rax,8), %rsi
movq %r14, %rdi
callq 0x852c0
leaq 0x7(%rsp), %rdi
movq %rax, %rsi
callq 0x8539a
leaq 0x8(%rsp), %rdi
callq 0x857e0
movq (%rbx), %rax
movl (%rax), %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x9bb36
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x857e0
movq %rbx, %rdi
callq 0x2e220
nop
|
_ZNK6google8protobuf16MapValueConstRef13GetInt32ValueEv:
push r15
push r14
push rbx
sub rsp, 40h
mov rbx, rdi
call _ZNK6google8protobuf16MapValueConstRef4typeEv; google::protobuf::MapValueConstRef::type(void)
cmp eax, 1
jz loc_9BB25
lea rdx, aWorkspaceLlm4b_22; "/workspace/llm4binary/github2025/aimrt_"...
lea r14, [rsp+58h+var_50]
mov rdi, r14
mov esi, 3
mov ecx, 2D0h
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
lea rsi, aProtocolBuffer_0; "Protocol Buffer map usage error:\n"
mov rdi, r14
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
lea rsi, aMapvalueconstr_0; "MapValueConstRef::GetInt32Value"
mov rdi, rax
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
lea rsi, aTypeDoesNotMat; " type does not match\n"
mov rdi, rax
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
lea rsi, aExpected; " Expected : "
mov rdi, rax
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
lea r15, _ZN6google8protobuf15FieldDescriptor14kCppTypeToNameE; google::protobuf::FieldDescriptor::kCppTypeToName
mov rsi, [r15+8]
mov rdi, rax
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
lea rsi, aSyntax0+0Fh; "\n"
mov rdi, rax
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
lea rsi, aActual_0; " Actual : "
mov rdi, rax
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov r14, rax
mov rdi, rbx; this
call _ZNK6google8protobuf16MapValueConstRef4typeEv; google::protobuf::MapValueConstRef::type(void)
mov eax, eax
mov rsi, [r15+rax*8]
mov rdi, r14
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
lea rdi, [rsp+58h+var_51]
mov rsi, rax
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
lea rdi, [rsp+58h+var_50]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_9BB25:
mov rax, [rbx]
mov eax, [rax]
add rsp, 40h
pop rbx
pop r14
pop r15
retn
jmp short $+2
loc_9BB36:
mov rbx, rax
lea rdi, [rsp+arg_0]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
mov rdi, rbx
call __Unwind_Resume
|
long long google::protobuf::MapValueConstRef::GetInt32Value(google::protobuf::MapValueConstRef *this)
{
long long v1; // rax
long long v2; // rax
long long v3; // rax
long long v4; // rax
long long v5; // rax
long long v6; // rax
long long v7; // r14
unsigned int v8; // eax
google::protobuf::internal::LogMessage *v9; // rax
char v11; // [rsp+7h] [rbp-51h] BYREF
_BYTE v12[80]; // [rsp+8h] [rbp-50h] BYREF
if ( (unsigned int)google::protobuf::MapValueConstRef::type(this) != 1 )
{
google::protobuf::internal::LogMessage::LogMessage(
(long long)v12,
3,
(long long)"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/map_field.h",
720);
v1 = google::protobuf::internal::LogMessage::operator<<((long long)v12, (long long)"Protocol Buffer map usage error:\n");
v2 = google::protobuf::internal::LogMessage::operator<<(v1, (long long)"MapValueConstRef::GetInt32Value");
v3 = google::protobuf::internal::LogMessage::operator<<(v2, (long long)" type does not match\n");
v4 = google::protobuf::internal::LogMessage::operator<<(v3, (long long)" Expected : ");
v5 = google::protobuf::internal::LogMessage::operator<<(
v4,
(long long)*(&google::protobuf::FieldDescriptor::kCppTypeToName + 1));
v6 = google::protobuf::internal::LogMessage::operator<<(v5, (long long)"\n");
v7 = google::protobuf::internal::LogMessage::operator<<(v6, (long long)" Actual : ");
v8 = google::protobuf::MapValueConstRef::type(this);
v9 = (google::protobuf::internal::LogMessage *)google::protobuf::internal::LogMessage::operator<<(
v7,
(long long)*(&google::protobuf::FieldDescriptor::kCppTypeToName + v8));
google::protobuf::internal::LogFinisher::operator=((long long)&v11, v9);
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)v12);
}
return **(unsigned int **)this;
}
|
GetInt32Value:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV RBX,RDI
CALL 0x00198410
CMP EAX,0x1
JZ 0x0019bb25
LEA RDX,[0x268ec5]
LEA R14,[RSP + 0x8]
MOV RDI,R14
MOV ESI,0x3
MOV ECX,0x2d0
CALL 0x001857c2
LAB_0019ba88:
LEA RSI,[0x268f2a]
MOV RDI,R14
CALL 0x001852c0
LEA RSI,[0x269369]
MOV RDI,RAX
CALL 0x001852c0
LEA RSI,[0x268f6d]
MOV RDI,RAX
CALL 0x001852c0
LEA RSI,[0x268f83]
MOV RDI,RAX
CALL 0x001852c0
LEA R15,[0x30c590]
MOV RSI,qword ptr [R15 + 0x8]
MOV RDI,RAX
CALL 0x001852c0
LEA RSI,[0x26c05f]
MOV RDI,RAX
CALL 0x001852c0
LEA RSI,[0x268f91]
MOV RDI,RAX
CALL 0x001852c0
MOV R14,RAX
MOV RDI,RBX
CALL 0x00198410
MOV EAX,EAX
MOV RSI,qword ptr [R15 + RAX*0x8]
MOV RDI,R14
CALL 0x001852c0
LAB_0019bb0e:
LEA RDI,[RSP + 0x7]
MOV RSI,RAX
CALL 0x0018539a
LAB_0019bb1b:
LEA RDI,[RSP + 0x8]
CALL 0x001857e0
LAB_0019bb25:
MOV RAX,qword ptr [RBX]
MOV EAX,dword ptr [RAX]
ADD RSP,0x40
POP RBX
POP R14
POP R15
RET
|
/* google::protobuf::MapValueConstRef::GetInt32Value() const */
int4 __thiscall google::protobuf::MapValueConstRef::GetInt32Value(MapValueConstRef *this)
{
int iVar1;
uint uVar2;
LogMessage *pLVar3;
LogFinisher local_51;
LogMessage local_50 [56];
iVar1 = type(this);
if (iVar1 != 1) {
internal::LogMessage::LogMessage
(local_50,3,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/map_field.h"
,0x2d0);
/* try { // try from 0019ba88 to 0019bb0d has its CatchHandler @ 0019bb36 */
pLVar3 = (LogMessage *)
internal::LogMessage::operator<<(local_50,"Protocol Buffer map usage error:\n");
pLVar3 = (LogMessage *)
internal::LogMessage::operator<<(pLVar3,"MapValueConstRef::GetInt32Value");
pLVar3 = (LogMessage *)internal::LogMessage::operator<<(pLVar3," type does not match\n");
pLVar3 = (LogMessage *)internal::LogMessage::operator<<(pLVar3," Expected : ");
pLVar3 = (LogMessage *)
internal::LogMessage::operator<<(pLVar3,(char *)FieldDescriptor::kCppTypeToName._8_8_);
pLVar3 = (LogMessage *)internal::LogMessage::operator<<(pLVar3,"\n");
pLVar3 = (LogMessage *)internal::LogMessage::operator<<(pLVar3," Actual : ");
uVar2 = type(this);
pLVar3 = (LogMessage *)
internal::LogMessage::operator<<
(pLVar3,*(char **)(FieldDescriptor::kCppTypeToName + (ulong)uVar2 * 8));
/* try { // try from 0019bb0e to 0019bb1a has its CatchHandler @ 0019bb34 */
internal::LogFinisher::operator=(&local_51,pLVar3);
internal::LogMessage::~LogMessage(local_50);
}
return **(int4 **)this;
}
|
|
11,752 |
void nlohmann::json_abi_v3_11_3::detail::get_arithmetic_value<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>, long, 0>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, long&)
|
llama.cpp/common/json.hpp
|
void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
{
switch (static_cast<value_t>(j))
{
case value_t::number_unsigned:
{
val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
break;
}
case value_t::number_integer:
{
val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
break;
}
case value_t::number_float:
{
val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
break;
}
case value_t::null:
case value_t::object:
case value_t::array:
case value_t::string:
case value_t::boolean:
case value_t::binary:
case value_t::discarded:
default:
JSON_THROW(type_error::create(302, concat("type must be number, but is ", j.type_name()), &j));
}
}
|
O3
|
cpp
|
void nlohmann::json_abi_v3_11_3::detail::get_arithmetic_value<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>, long, 0>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, long&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
movzbl (%rdi), %eax
cmpl $0x5, %eax
je 0xcb76c
cmpl $0x7, %eax
je 0xcb772
cmpl $0x6, %eax
jne 0xcb784
movq 0x8(%r14), %rax
jmp 0xcb778
cvttsd2si 0x8(%r14), %rax
movq %rax, (%rsi)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x21660
movq %rax, %rbx
movq %r14, %rdi
callq 0x2e874
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x51f6d(%rip), %rsi # 0x11d715
leaq 0x10(%rsp), %rdi
callq 0x2f388
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x12e, %esi # imm = 0x12E
movq %r14, %rcx
callq 0x2f1b4
xorl %ebp, %ebp
leaq 0xa01b5(%rip), %rsi # 0x16b988
leaq -0x99fd0(%rip), %rdx # 0x3180a
movq %rbx, %rdi
callq 0x21a80
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xcb800
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21180
testb %bpl, %bpl
jne 0xcb80a
jmp 0xcb812
movq %rax, %r14
movq %rbx, %rdi
callq 0x21f50
movq %r14, %rdi
callq 0x21b20
|
_ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEElTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_:
push rbp; void *
push r14; int
push rbx; __int64
sub rsp, 30h
mov r14, rdi
movzx eax, byte ptr [rdi]
cmp eax, 5
jz short loc_CB76C
cmp eax, 7
jz short loc_CB772
cmp eax, 6
jnz short loc_CB784
loc_CB76C:
mov rax, [r14+8]
jmp short loc_CB778
loc_CB772:
cvttsd2si rax, qword ptr [r14+8]
loc_CB778:
mov [rsi], rax
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_CB784:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; 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>::type_name(void)
lea rdx, [rsp+48h+var_40]
mov [rdx], rax
lea rsi, aTypeMustBeNumb; "type must be number, but is "
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA29_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[29],char const*>(char const(&)[29],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 12Eh; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+48h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_CB800
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_CB800:
test bpl, bpl
jnz short loc_CB80A
jmp short loc_CB812
mov r14, rax
loc_CB80A:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_CB812:
mov rdi, r14
call __Unwind_Resume
|
long long ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEElTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_(
double *a1,
_QWORD *a2)
{
int v2; // eax
long long result; // rax
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
const char *v5; // [rsp+8h] [rbp-40h] BYREF
_QWORD v6[2]; // [rsp+10h] [rbp-38h] BYREF
v2 = *(unsigned __int8 *)a1;
if ( v2 != 5 )
{
if ( v2 == 7 )
{
result = (unsigned int)(int)a1[1];
goto LABEL_6;
}
if ( v2 != 6 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v5 = 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>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[29],char const*>(
(long long)v6,
(long long)"type must be number, but is ",
&v5);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
exception,
302,
v6);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
}
result = *((_QWORD *)a1 + 1);
LABEL_6:
*a2 = result;
return result;
}
|
_ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEElTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RDI
MOVZX EAX,byte ptr [RDI]
CMP EAX,0x5
JZ 0x001cb76c
CMP EAX,0x7
JZ 0x001cb772
CMP EAX,0x6
JNZ 0x001cb784
LAB_001cb76c:
MOV RAX,qword ptr [R14 + 0x8]
JMP 0x001cb778
LAB_001cb772:
CVTTSD2SI RAX,qword ptr [R14 + 0x8]
LAB_001cb778:
MOV qword ptr [RSI],RAX
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_001cb784:
MOV EDI,0x20
CALL 0x00121660
MOV RBX,RAX
MOV RDI,R14
CALL 0x0012e874
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_001cb7a1:
LEA RSI,[0x21d715]
LEA RDI,[RSP + 0x10]
CALL 0x0012f388
MOV BPL,0x1
LAB_001cb7b5:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x12e
MOV RCX,R14
CALL 0x0012f1b4
XOR EBP,EBP
LEA RSI,[0x26b988]
LEA RDX,[0x13180a]
MOV RDI,RBX
CALL 0x00121a80
|
void _ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEElTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*param_1,long *param_2)
{
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>
bVar1;
long lVar2;
int8 uVar3;
char *local_40;
detail local_38 [32];
bVar1 = *param_1;
if (bVar1 != (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>
)0x5) {
if (bVar1 == (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>
)0x7) {
lVar2 = (long)*(double *)(param_1 + 8);
goto LAB_001cb778;
}
if (bVar1 != (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>
)0x6) {
uVar3 = __cxa_allocate_exception(0x20);
local_40 = (char *)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>
::type_name(param_1);
/* try { // try from 001cb7a1 to 001cb7b1 has its CatchHandler @ 001cb807 */
nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string,char_const(&)[29],char_const*>
(local_38,"type must be number, but is ",&local_40);
/* try { // try from 001cb7b5 to 001cb7e1 has its CatchHandler @ 001cb7e2 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar3,0x12e,local_38,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar3,&nlohmann::json_abi_v3_11_3::detail::type_error::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
}
lVar2 = *(long *)(param_1 + 8);
LAB_001cb778:
*param_2 = lVar2;
return;
}
|
|
11,753 |
ft_nlq_read_next
|
eloqsql/storage/myisam/ft_nlq_search.c
|
int ft_nlq_read_next(FT_INFO *handler, char *record)
{
MI_INFO *info= (MI_INFO *) handler->info;
if (++handler->curdoc >= handler->ndocs)
{
--handler->curdoc;
return HA_ERR_END_OF_FILE;
}
info->update&= (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED);
info->lastpos=handler->doc[handler->curdoc].dpos;
if (!(*info->read_record)(info,info->lastpos,(uchar*) record))
{
info->update|= HA_STATE_AKTIV; /* Record is read */
return 0;
}
return my_errno;
}
|
O3
|
c
|
ft_nlq_read_next:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
movl 0x14(%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x14(%rdi)
cmpl 0x10(%rdi), %ecx
jge 0x7320d
movq %rsi, %rdx
andl $0x401, 0x1d0(%rbx) # imm = 0x401
movslq 0x14(%rdi), %rax
shlq $0x4, %rax
movq 0x18(%rdi,%rax), %rsi
movq %rsi, 0x170(%rbx)
movq %rbx, %rdi
callq *0x140(%rbx)
testl %eax, %eax
je 0x73217
callq 0xa16ee
movl (%rax), %eax
jmp 0x73220
movl %eax, 0x14(%rdi)
movl $0x89, %eax
jmp 0x73220
orb $0x2, 0x1d0(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
ft_nlq_read_next:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, [rdi+8]
mov eax, [rdi+14h]
lea ecx, [rax+1]
mov [rdi+14h], ecx
cmp ecx, [rdi+10h]
jge short loc_7320D
mov rdx, rsi
and dword ptr [rbx+1D0h], 401h
movsxd rax, dword ptr [rdi+14h]
shl rax, 4
mov rsi, [rdi+rax+18h]
mov [rbx+170h], rsi
mov rdi, rbx
call qword ptr [rbx+140h]
test eax, eax
jz short loc_73217
call _my_thread_var
mov eax, [rax]
jmp short loc_73220
loc_7320D:
mov [rdi+14h], eax
mov eax, 89h
jmp short loc_73220
loc_73217:
or byte ptr [rbx+1D0h], 2
xor eax, eax
loc_73220:
add rsp, 8
pop rbx
pop rbp
retn
|
long long ft_nlq_read_next(long long a1, long long a2)
{
long long v2; // rbx
int v3; // eax
const char *v5; // rsi
v2 = *(_QWORD *)(a1 + 8);
v3 = *(_DWORD *)(a1 + 20);
*(_DWORD *)(a1 + 20) = v3 + 1;
if ( v3 + 1 >= *(_DWORD *)(a1 + 16) )
{
*(_DWORD *)(a1 + 20) = v3;
return 137LL;
}
else
{
*(_DWORD *)(v2 + 464) &= 0x401u;
v5 = *(const char **)(a1 + 16LL * *(int *)(a1 + 20) + 24);
*(_QWORD *)(v2 + 368) = v5;
if ( (*(unsigned int ( **)(long long, const char *, long long))(v2 + 320))(v2, v5, a2) )
{
return *(unsigned int *)my_thread_var(v2, v5);
}
else
{
*(_BYTE *)(v2 + 464) |= 2u;
return 0LL;
}
}
}
|
ft_nlq_read_next:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,qword ptr [RDI + 0x8]
MOV EAX,dword ptr [RDI + 0x14]
LEA ECX,[RAX + 0x1]
MOV dword ptr [RDI + 0x14],ECX
CMP ECX,dword ptr [RDI + 0x10]
JGE 0x0017320d
MOV RDX,RSI
AND dword ptr [RBX + 0x1d0],0x401
MOVSXD RAX,dword ptr [RDI + 0x14]
SHL RAX,0x4
MOV RSI,qword ptr [RDI + RAX*0x1 + 0x18]
MOV qword ptr [RBX + 0x170],RSI
MOV RDI,RBX
CALL qword ptr [RBX + 0x140]
TEST EAX,EAX
JZ 0x00173217
CALL 0x001a16ee
MOV EAX,dword ptr [RAX]
JMP 0x00173220
LAB_0017320d:
MOV dword ptr [RDI + 0x14],EAX
MOV EAX,0x89
JMP 0x00173220
LAB_00173217:
OR byte ptr [RBX + 0x1d0],0x2
XOR EAX,EAX
LAB_00173220:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
int4 ft_nlq_read_next(long param_1,int8 param_2)
{
int iVar1;
long lVar2;
int8 uVar3;
int iVar4;
int4 uVar5;
int4 *puVar6;
lVar2 = *(long *)(param_1 + 8);
iVar1 = *(int *)(param_1 + 0x14);
iVar4 = iVar1 + 1;
*(int *)(param_1 + 0x14) = iVar4;
if (iVar4 < *(int *)(param_1 + 0x10)) {
*(uint *)(lVar2 + 0x1d0) = *(uint *)(lVar2 + 0x1d0) & 0x401;
uVar3 = *(int8 *)(param_1 + 0x18 + (long)*(int *)(param_1 + 0x14) * 0x10);
*(int8 *)(lVar2 + 0x170) = uVar3;
iVar4 = (**(code **)(lVar2 + 0x140))(lVar2,uVar3,param_2);
if (iVar4 == 0) {
*(byte *)(lVar2 + 0x1d0) = *(byte *)(lVar2 + 0x1d0) | 2;
uVar5 = 0;
}
else {
puVar6 = (int4 *)_my_thread_var();
uVar5 = *puVar6;
}
}
else {
*(int *)(param_1 + 0x14) = iVar1;
uVar5 = 0x89;
}
return uVar5;
}
|
|
11,754 |
my_convert
|
eloqsql/strings/ctype.c
|
uint32
my_convert(char *to, uint32 to_length, CHARSET_INFO *to_cs,
const char *from, uint32 from_length,
CHARSET_INFO *from_cs, uint *errors)
{
uint32 length, length2;
/*
If any of the character sets is not ASCII compatible,
immediately switch to slow mb_wc->wc_mb method.
*/
if ((to_cs->state | from_cs->state) & MY_CS_NONASCII)
return my_convert_using_func(to, to_length,
to_cs, to_cs->cset->wc_mb,
from, from_length,
from_cs, from_cs->cset->mb_wc,
errors);
length= length2= MY_MIN(to_length, from_length);
#if defined(__i386__) || defined(__x86_64__)
/*
Special loop for i386, it allows to refer to a
non-aligned memory block as UINT32, which makes
it possible to copy four bytes at once. This
gives about 10% performance improvement comparing
to byte-by-byte loop.
*/
for ( ; length >= 4; length-= 4, from+= 4, to+= 4)
{
if ((*(uint32*)from) & 0x80808080)
break;
*((uint32*) to)= *((const uint32*) from);
}
#endif /* __i386__ */
for (; ; *to++= *from++, length--)
{
if (!length)
{
*errors= 0;
return length2;
}
if (*((unsigned char*) from) > 0x7F) /* A non-ASCII character */
{
uint32 copied_length= length2 - length;
to_length-= copied_length;
from_length-= copied_length;
return copied_length + my_convert_using_func(to, to_length, to_cs,
to_cs->cset->wc_mb,
from, from_length, from_cs,
from_cs->cset->mb_wc,
errors);
}
}
DBUG_ASSERT(FALSE); // Should never get to here
return 0; // Make compiler happy
}
|
O3
|
c
|
my_convert:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r9, %rax
movl %r8d, %r9d
movq %rcx, %r8
movq 0x10(%rbp), %r10
movl 0xc(%rax), %ecx
orl 0xc(%rdx), %ecx
btl $0xd, %ecx
jb 0xf68fc
cmpl %r9d, %esi
movl %r9d, %ebx
cmovbl %esi, %ebx
movl %ebx, %ecx
cmpl $0x4, %ebx
jb 0xf68d5
movl (%r8), %r11d
testl $0x80808080, %r11d # imm = 0x80808080
jne 0xf68d9
movl %r11d, (%rdi)
addl $-0x4, %ecx
addq $0x4, %r8
addq $0x4, %rdi
cmpl $0x3, %ecx
ja 0xf68b6
testl %ecx, %ecx
je 0xf68f3
movl %ecx, %r14d
xorl %r15d, %r15d
movb (%r8,%r15), %cl
testb %cl, %cl
js 0xf6929
movb %cl, (%rdi,%r15)
incq %r15
cmpl %r15d, %r14d
jne 0xf68df
movl $0x0, (%r10)
jmp 0xf696e
movl %esi, %esi
movq 0xb8(%rdx), %rcx
movq 0x30(%rcx), %rcx
movl %r9d, %r9d
movq 0xb8(%rax), %r11
subq $0x8, %rsp
pushq %r10
pushq 0x28(%r11)
pushq %rax
callq 0xf678b
addq $0x28, %rsp
jmp 0xf6974
addl %r14d, %esi
subl %ebx, %esi
subl %r15d, %esi
addl %r14d, %r9d
subl %ebx, %r9d
subl %r15d, %r9d
movq 0xb8(%rdx), %rcx
movq 0x30(%rcx), %rcx
movq 0xb8(%rax), %r11
addq %r15, %rdi
addq %r15, %r8
subq $0x8, %rsp
pushq %r10
pushq 0x28(%r11)
pushq %rax
callq 0xf678b
addq $0x20, %rsp
subl %r14d, %ebx
addl %r15d, %ebx
addl %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
my_convert:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rax, r9
mov r9d, r8d
mov r8, rcx
mov r10, [rbp+arg_0]
mov ecx, [rax+0Ch]
or ecx, [rdx+0Ch]
bt ecx, 0Dh
jb short loc_F68FC
cmp esi, r9d
mov ebx, r9d
cmovb ebx, esi
mov ecx, ebx
cmp ebx, 4
jb short loc_F68D5
loc_F68B6:
mov r11d, [r8]
test r11d, 80808080h
jnz short loc_F68D9
mov [rdi], r11d
add ecx, 0FFFFFFFCh
add r8, 4
add rdi, 4
cmp ecx, 3
ja short loc_F68B6
loc_F68D5:
test ecx, ecx
jz short loc_F68F3
loc_F68D9:
mov r14d, ecx
xor r15d, r15d
loc_F68DF:
mov cl, [r8+r15]
test cl, cl
js short loc_F6929
mov [rdi+r15], cl
inc r15
cmp r14d, r15d
jnz short loc_F68DF
loc_F68F3:
mov dword ptr [r10], 0
jmp short loc_F696E
loc_F68FC:
mov esi, esi
mov rcx, [rdx+0B8h]
mov rcx, [rcx+30h]
mov r9d, r9d
mov r11, [rax+0B8h]
sub rsp, 8
push r10
push qword ptr [r11+28h]
push rax
call my_convert_using_func
add rsp, 28h
jmp short loc_F6974
loc_F6929:
add esi, r14d
sub esi, ebx
sub esi, r15d
add r9d, r14d
sub r9d, ebx
sub r9d, r15d
mov rcx, [rdx+0B8h]
mov rcx, [rcx+30h]
mov r11, [rax+0B8h]
add rdi, r15
add r8, r15
sub rsp, 8
push r10
push qword ptr [r11+28h]
push rax
call my_convert_using_func
add rsp, 20h
sub ebx, r14d
add ebx, r15d
add ebx, eax
loc_F696E:
mov eax, ebx
add rsp, 8
loc_F6974:
pop rbx
pop r14
pop r15
pop rbp
retn
|
long long my_convert(
_DWORD *a1,
unsigned int a2,
long long a3,
long long a4,
unsigned int a5,
long long a6,
_DWORD *a7)
{
_DWORD *v9; // r8
unsigned int v10; // ebx
unsigned int v11; // ecx
unsigned int v12; // r14d
long long v13; // r15
char v14; // cl
v9 = (_DWORD *)a4;
if ( ((*(_DWORD *)(a3 + 12) | *(_DWORD *)(a6 + 12)) & 0x2000) != 0 )
return my_convert_using_func(
(long long)a1,
a2,
a3,
*(long long ( **)(long long, long long, long long, long long))(*(_QWORD *)(a3 + 184) + 48LL),
a4,
a5,
a6,
*(long long ( **)(long long, long long *, long long, unsigned long long))(*(_QWORD *)(a6 + 184) + 40LL),
a7);
v10 = a5;
if ( a2 < a5 )
v10 = a2;
v11 = v10;
if ( v10 >= 4 )
{
while ( (*v9 & 0x80808080) == 0 )
{
*a1 = *v9;
v11 -= 4;
++v9;
++a1;
if ( v11 <= 3 )
goto LABEL_7;
}
goto LABEL_8;
}
LABEL_7:
if ( v11 )
{
LABEL_8:
v12 = v11;
v13 = 0LL;
do
{
v14 = *((_BYTE *)v9 + v13);
if ( v14 < 0 )
return (unsigned int)my_convert_using_func(
(long long)a1 + v13,
v12 + a2 - v10 - (unsigned int)v13,
a3,
*(long long ( **)(long long, long long, long long, long long))(*(_QWORD *)(a3 + 184)
+ 48LL),
(long long)v9 + v13,
v12 + a5 - v10 - (unsigned int)v13,
a6,
*(long long ( **)(long long, long long *, long long, unsigned long long))(*(_QWORD *)(a6 + 184) + 40LL),
a7)
+ (_DWORD)v13
+ v10
- v12;
*((_BYTE *)a1 + v13++) = v14;
}
while ( v12 != (_DWORD)v13 );
}
*a7 = 0;
return v10;
}
|
my_convert:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RAX,R9
MOV R9D,R8D
MOV R8,RCX
MOV R10,qword ptr [RBP + 0x10]
MOV ECX,dword ptr [RAX + 0xc]
OR ECX,dword ptr [RDX + 0xc]
BT ECX,0xd
JC 0x001f68fc
CMP ESI,R9D
MOV EBX,R9D
CMOVC EBX,ESI
MOV ECX,EBX
CMP EBX,0x4
JC 0x001f68d5
LAB_001f68b6:
MOV R11D,dword ptr [R8]
TEST R11D,0x80808080
JNZ 0x001f68d9
MOV dword ptr [RDI],R11D
ADD ECX,-0x4
ADD R8,0x4
ADD RDI,0x4
CMP ECX,0x3
JA 0x001f68b6
LAB_001f68d5:
TEST ECX,ECX
JZ 0x001f68f3
LAB_001f68d9:
MOV R14D,ECX
XOR R15D,R15D
LAB_001f68df:
MOV CL,byte ptr [R8 + R15*0x1]
TEST CL,CL
JS 0x001f6929
MOV byte ptr [RDI + R15*0x1],CL
INC R15
CMP R14D,R15D
JNZ 0x001f68df
LAB_001f68f3:
MOV dword ptr [R10],0x0
JMP 0x001f696e
LAB_001f68fc:
MOV ESI,ESI
MOV RCX,qword ptr [RDX + 0xb8]
MOV RCX,qword ptr [RCX + 0x30]
MOV R9D,R9D
MOV R11,qword ptr [RAX + 0xb8]
SUB RSP,0x8
PUSH R10
PUSH qword ptr [R11 + 0x28]
PUSH RAX
CALL 0x001f678b
ADD RSP,0x28
JMP 0x001f6974
LAB_001f6929:
ADD ESI,R14D
SUB ESI,EBX
SUB ESI,R15D
ADD R9D,R14D
SUB R9D,EBX
SUB R9D,R15D
MOV RCX,qword ptr [RDX + 0xb8]
MOV RCX,qword ptr [RCX + 0x30]
MOV R11,qword ptr [RAX + 0xb8]
ADD RDI,R15
ADD R8,R15
SUB RSP,0x8
PUSH R10
PUSH qword ptr [R11 + 0x28]
PUSH RAX
CALL 0x001f678b
ADD RSP,0x20
SUB EBX,R14D
ADD EBX,R15D
ADD EBX,EAX
LAB_001f696e:
MOV EAX,EBX
ADD RSP,0x8
LAB_001f6974:
POP RBX
POP R14
POP R15
POP RBP
RET
|
ulong my_convert(uint *param_1,uint param_2,long param_3,uint *param_4,uint param_5,long param_6,
int4 *param_7)
{
int iVar1;
ulong uVar2;
uint uVar3;
uint uVar5;
int iVar6;
long lVar7;
ulong uVar4;
uVar2 = (ulong)param_5;
if (((*(uint *)(param_6 + 0xc) | *(uint *)(param_3 + 0xc)) >> 0xd & 1) == 0) {
if (param_2 < param_5) {
uVar2 = (ulong)param_2;
}
uVar5 = (uint)uVar2;
uVar3 = uVar5;
uVar4 = uVar2;
while (3 < uVar3) {
uVar3 = (uint)uVar4;
if ((*param_4 & 0x80808080) != 0) goto LAB_001f68d9;
*param_1 = *param_4;
uVar3 = uVar3 - 4;
uVar4 = (ulong)uVar3;
param_4 = param_4 + 1;
param_1 = param_1 + 1;
}
if (uVar3 != 0) {
LAB_001f68d9:
lVar7 = 0;
do {
if (*(char *)((long)param_4 + lVar7) < '\0') {
iVar6 = (int)lVar7;
iVar1 = my_convert_using_func
((long)param_1 + lVar7,((param_2 + uVar3) - uVar5) - iVar6,param_3,
*(int8 *)(*(long *)(param_3 + 0xb8) + 0x30),(long)param_4 + lVar7
,((param_5 + uVar3) - uVar5) - iVar6,param_6,
*(int8 *)(*(long *)(param_6 + 0xb8) + 0x28),param_7);
return (ulong)((uVar5 - uVar3) + iVar6 + iVar1);
}
*(char *)((long)param_1 + lVar7) = *(char *)((long)param_4 + lVar7);
lVar7 = lVar7 + 1;
} while (uVar3 != (uint)lVar7);
}
*param_7 = 0;
}
else {
uVar2 = my_convert_using_func
(param_1,param_2,param_3,*(int8 *)(*(long *)(param_3 + 0xb8) + 0x30),
param_4,uVar2,param_6,*(int8 *)(*(long *)(param_6 + 0xb8) + 0x28),
param_7);
}
return uVar2;
}
|
|
11,755 |
my_interval_timer
|
eloqsql/mysys/my_getsystime.c
|
ulonglong my_interval_timer()
{
#ifdef HAVE_CLOCK_GETTIME
struct timespec tp;
clock_gettime(CLOCK_MONOTONIC, &tp);
return tp.tv_sec*1000000000ULL+tp.tv_nsec;
#elif defined(HAVE_GETHRTIME)
return gethrtime();
#elif defined(_WIN32)
DBUG_ASSERT(query_performance_frequency);
LARGE_INTEGER t_cnt;
QueryPerformanceCounter(&t_cnt);
return (t_cnt.QuadPart / query_performance_frequency * 1000000000ULL) +
((t_cnt.QuadPart % query_performance_frequency) * 1000000000ULL /
query_performance_frequency);
#else
/* TODO: check for other possibilities for hi-res timestamping */
struct timeval tv;
gettimeofday(&tv,NULL);
return tv.tv_sec*1000000000ULL+tv.tv_usec*1000ULL;
#endif
}
|
O0
|
c
|
my_interval_timer:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
leaq -0x10(%rbp), %rsi
callq 0x27340
imulq $0x3b9aca00, -0x10(%rbp), %rax # imm = 0x3B9ACA00
addq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
my_interval_timer:
push rbp
mov rbp, rsp
sub rsp, 10h
mov edi, 1
lea rsi, [rbp+var_10]
call _clock_gettime
imul rax, [rbp+var_10], 3B9ACA00h
add rax, [rbp+var_8]
add rsp, 10h
pop rbp
retn
|
long long my_interval_timer()
{
_QWORD v1[2]; // [rsp+0h] [rbp-10h] BYREF
clock_gettime(1LL, v1);
return v1[1] + 1000000000LL * v1[0];
}
|
my_interval_timer:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV EDI,0x1
LEA RSI,[RBP + -0x10]
CALL 0x00127340
IMUL RAX,qword ptr [RBP + -0x10],0x3b9aca00
ADD RAX,qword ptr [RBP + -0x8]
ADD RSP,0x10
POP RBP
RET
|
long my_interval_timer(void)
{
timespec local_18;
clock_gettime(1,&local_18);
return local_18.tv_sec * 1000000000 + local_18.tv_nsec;
}
|
|
11,756 |
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 0x36cd2
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 0x36cd2
cmpq %rbx, %rax
jb 0x36c9c
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_36CD2
mov r12, rdi
dec r15
mov r14d, 1
mov rax, [rbp+var_30]
loc_36C9C:
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_36CD2
cmp rax, rbx
jb short loc_36C9C
loc_36CD2:
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 0x00136cd2
MOV R12,RDI
DEC R15
MOV R14D,0x1
MOV RAX,qword ptr [RBP + -0x30]
LAB_00136c9c:
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 0x00136cd2
CMP RAX,RBX
JC 0x00136c9c
LAB_00136cd2:
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;
}
|
|
11,757 |
rak_array_inplace_clear
|
fabiosvm[P]rak/src/array.c
|
void rak_array_inplace_clear(RakArray *arr)
{
release_elements(arr);
rak_slice_clear(&arr->slice);
}
|
O1
|
c
|
rak_array_inplace_clear:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq 0xc(%rdi), %r14
testq %r14, %r14
jle 0x2870
shlq $0x4, %r14
xorl %r15d, %r15d
movq 0x10(%rbx), %rax
movq (%rax,%r15), %rdi
movq 0x8(%rax,%r15), %rsi
callq 0x84ec
addq $0x10, %r15
cmpq %r15, %r14
jne 0x2855
movl $0x0, 0xc(%rbx)
popq %rbx
popq %r14
popq %r15
retq
|
rak_array_inplace_clear:
push r15
push r14
push rbx
mov rbx, rdi
movsxd r14, dword ptr [rdi+0Ch]
test r14, r14
jle short loc_2870
shl r14, 4
xor r15d, r15d
loc_2855:
mov rax, [rbx+10h]
mov rdi, [rax+r15]
mov rsi, [rax+r15+8]
call rak_value_release
add r15, 10h
cmp r14, r15
jnz short loc_2855
loc_2870:
mov dword ptr [rbx+0Ch], 0
pop rbx
pop r14
pop r15
retn
|
long long rak_array_inplace_clear(long long a1)
{
long long v1; // r14
long long v2; // r14
long long v3; // r15
long long result; // rax
v1 = *(int *)(a1 + 12);
if ( v1 > 0 )
{
v2 = 16 * v1;
v3 = 0LL;
do
{
result = rak_value_release(*(_QWORD *)(*(_QWORD *)(a1 + 16) + v3), *(_QWORD *)(*(_QWORD *)(a1 + 16) + v3 + 8));
v3 += 16LL;
}
while ( v2 != v3 );
}
*(_DWORD *)(a1 + 12) = 0;
return result;
}
|
rak_array_inplace_clear:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDI
MOVSXD R14,dword ptr [RDI + 0xc]
TEST R14,R14
JLE 0x00102870
SHL R14,0x4
XOR R15D,R15D
LAB_00102855:
MOV RAX,qword ptr [RBX + 0x10]
MOV RDI,qword ptr [RAX + R15*0x1]
MOV RSI,qword ptr [RAX + R15*0x1 + 0x8]
CALL 0x001084ec
ADD R15,0x10
CMP R14,R15
JNZ 0x00102855
LAB_00102870:
MOV dword ptr [RBX + 0xc],0x0
POP RBX
POP R14
POP R15
RET
|
void rak_array_inplace_clear(long param_1)
{
int iVar1;
long lVar2;
iVar1 = *(int *)(param_1 + 0xc);
if (0 < (long)iVar1) {
lVar2 = 0;
do {
rak_value_release(*(int8 *)(*(long *)(param_1 + 0x10) + lVar2),
*(int8 *)(*(long *)(param_1 + 0x10) + 8 + lVar2));
lVar2 = lVar2 + 0x10;
} while ((long)iVar1 * 0x10 != lVar2);
}
*(int4 *)(param_1 + 0xc) = 0;
return;
}
|
|
11,758 |
ggml_abort
|
ngxson[P]ggml-easy/ggml/src/ggml.c
|
void ggml_abort(const char * file, int line, const char * fmt, ...) {
fflush(stdout);
fprintf(stderr, "%s:%d: ", file, line);
va_list args;
va_start(args, fmt);
vfprintf(stderr, fmt, args);
va_end(args);
fprintf(stderr, "\n");
ggml_print_backtrace();
abort();
}
|
O0
|
c
|
ggml_abort:
subq $0xe8, %rsp
testb %al, %al
je 0x47f2c
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdi, 0xe0(%rsp)
movl %esi, 0xdc(%rsp)
movq %rdx, 0xd0(%rsp)
movq 0x93037(%rip), %rax # 0xdaf90
movq (%rax), %rdi
callq 0x447c0
movq 0x93068(%rip), %rax # 0xdafd0
movq (%rax), %rdi
movq 0xe0(%rsp), %rdx
movl 0xdc(%rsp), %ecx
leaq 0x6c4b7(%rip), %rsi # 0xb4438
movb $0x0, %al
callq 0x457e0
leaq 0xb0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0xf0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
movq 0x93019(%rip), %rax # 0xdafd0
movq (%rax), %rdi
movq 0xd0(%rsp), %rsi
leaq 0xb0(%rsp), %rdx
callq 0x450a0
leaq 0xb0(%rsp), %rax
movq 0x92ff2(%rip), %rax # 0xdafd0
movq (%rax), %rdi
leaq 0x7bb2c(%rip), %rsi # 0xc3b14
movb $0x0, %al
callq 0x457e0
callq 0x48000
callq 0x41fc0
nopl (%rax)
|
ggml_abort:
sub rsp, 0E8h
test al, al
jz short loc_47F2C
movaps [rsp+0E8h+var_B8], xmm0
movaps [rsp+0E8h+var_A8], xmm1
movaps [rsp+0E8h+var_98], xmm2
movaps [rsp+0E8h+var_88], xmm3
movaps [rsp+0E8h+var_78], xmm4
movaps [rsp+0E8h+var_68], xmm5
movaps [rsp+0E8h+var_58], xmm6
movaps [rsp+0E8h+var_48], xmm7
loc_47F2C:
mov [rsp+0E8h+var_C0], r9
mov [rsp+0E8h+var_C8], r8
mov [rsp+0E8h+var_D0], rcx
mov [rsp+0E8h+var_8], rdi
mov [rsp+0E8h+var_C], esi
mov [rsp+0E8h+var_18], rdx
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov rdi, [rax]
mov rdx, [rsp+0E8h+var_8]
mov ecx, [rsp+0E8h+var_C]
lea rsi, aSD; "%s:%d: "
mov al, 0
call _fprintf
lea rax, [rsp+0E8h+var_38]
mov rcx, rsp
mov [rax+10h], rcx
lea rcx, [rsp+0E8h+arg_0]
mov [rax+8], rcx
mov dword ptr [rax+4], 30h ; '0'
mov dword ptr [rax], 18h
mov rax, cs:stderr_ptr
mov rdi, [rax]
mov rsi, [rsp+0E8h+var_18]
lea rdx, [rsp+0E8h+var_38]
call _vfprintf
lea rax, [rsp+0E8h+var_38]
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aSDuplicateKeyS+2Fh; "\n"
mov al, 0
call _fprintf
call ggml_print_backtrace
call _abort
|
void __noreturn ggml_abort(const char *a1, int a2, long long a3, ...)
{
va_list va; // [rsp+B0h] [rbp-38h] BYREF
long long v4; // [rsp+D0h] [rbp-18h]
int v5; // [rsp+DCh] [rbp-Ch]
const char *v6; // [rsp+E0h] [rbp-8h]
va_start(va, a3);
v6 = a1;
v5 = a2;
v4 = a3;
fflush(stdout);
fprintf(stderr, "%s:%d: ", a1, a2);
vfprintf(stderr, v4, va);
fprintf(stderr, "\n");
ggml_print_backtrace();
abort();
}
|
ggml_abort:
SUB RSP,0xe8
TEST AL,AL
JZ 0x00147f2c
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOVAPS xmmword ptr [RSP + 0x40],XMM1
MOVAPS xmmword ptr [RSP + 0x50],XMM2
MOVAPS xmmword ptr [RSP + 0x60],XMM3
MOVAPS xmmword ptr [RSP + 0x70],XMM4
MOVAPS xmmword ptr [RSP + 0x80],XMM5
MOVAPS xmmword ptr [RSP + 0x90],XMM6
MOVAPS xmmword ptr [RSP + 0xa0],XMM7
LAB_00147f2c:
MOV qword ptr [RSP + 0x28],R9
MOV qword ptr [RSP + 0x20],R8
MOV qword ptr [RSP + 0x18],RCX
MOV qword ptr [RSP + 0xe0],RDI
MOV dword ptr [RSP + 0xdc],ESI
MOV qword ptr [RSP + 0xd0],RDX
MOV RAX,qword ptr [0x001daf90]
MOV RDI,qword ptr [RAX]
CALL 0x001447c0
MOV RAX,qword ptr [0x001dafd0]
MOV RDI,qword ptr [RAX]
MOV RDX,qword ptr [RSP + 0xe0]
MOV ECX,dword ptr [RSP + 0xdc]
LEA RSI,[0x1b4438]
MOV AL,0x0
CALL 0x001457e0
LEA RAX,[RSP + 0xb0]
MOV RCX,RSP
MOV qword ptr [RAX + 0x10],RCX
LEA RCX,[RSP + 0xf0]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RAX + 0x4],0x30
MOV dword ptr [RAX],0x18
MOV RAX,qword ptr [0x001dafd0]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RSP + 0xd0]
LEA RDX,[RSP + 0xb0]
CALL 0x001450a0
LEA RAX,[RSP + 0xb0]
MOV RAX,qword ptr [0x001dafd0]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x1c3b14]
MOV AL,0x0
CALL 0x001457e0
CALL 0x00148000
CALL 0x00141fc0
|
void ggml_abort(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,uint param_10,char *param_11,int8 param_12,
int8 param_13,int8 param_14)
{
char in_AL;
int1 auStack_e8 [24];
int8 local_d0;
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;
int4 local_38;
int4 local_34;
int1 *local_30;
int1 *local_28;
char *local_18;
uint local_c;
int8 local_8;
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_d0 = param_12;
local_c8 = param_13;
local_c0 = param_14;
local_18 = param_11;
local_c = param_10;
local_8 = param_9;
fflush(*(FILE **)PTR_stdout_001daf90);
fprintf(*(FILE **)PTR_stderr_001dafd0,"%s:%d: ",local_8,(ulong)local_c);
local_30 = &stack0x00000008;
local_34 = 0x30;
local_38 = 0x18;
local_28 = auStack_e8;
vfprintf(*(FILE **)PTR_stderr_001dafd0,local_18,&local_38);
fprintf(*(FILE **)PTR_stderr_001dafd0,"\n");
ggml_print_backtrace();
/* WARNING: Subroutine does not return */
abort();
}
|
|
11,759 |
ggml_abort
|
ngxson[P]ggml-easy/ggml/src/ggml.c
|
void ggml_abort(const char * file, int line, const char * fmt, ...) {
fflush(stdout);
fprintf(stderr, "%s:%d: ", file, line);
va_list args;
va_start(args, fmt);
vfprintf(stderr, fmt, args);
va_end(args);
fprintf(stderr, "\n");
ggml_print_backtrace();
abort();
}
|
O3
|
c
|
ggml_abort:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
testb %al, %al
je 0x18c9e
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
leaq 0x20(%rsp), %r15
movq %rcx, 0x18(%r15)
movq %r8, 0x20(%r15)
movq %r9, 0x28(%r15)
movq 0x512d2(%rip), %rax # 0x69f88
movq (%rax), %rdi
callq 0x17350
movq 0x51303(%rip), %r12 # 0x69fc8
movq (%r12), %rdi
leaq 0x317c4(%rip), %rsi # 0x4a494
movq %r14, %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x17820
movq %rsp, %rdx
movq %r15, 0x10(%rdx)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000018, %rax # imm = 0x3000000018
movq %rax, (%rdx)
movq (%r12), %rdi
movq %rbx, %rsi
callq 0x175f0
movq (%r12), %rsi
movl $0xa, %edi
callq 0x174d0
callq 0x18d20
callq 0x168f0
|
ggml_abort:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 0D0h
mov rbx, rdx
mov ebp, esi
mov r14, rdi
test al, al
jz short loc_18C9E
movaps [rsp+0F8h+var_A8], xmm0
movaps [rsp+0F8h+var_98], xmm1
movaps [rsp+0F8h+var_88], xmm2
movaps [rsp+0F8h+var_78], xmm3
movaps [rsp+0F8h+var_68], xmm4
movaps [rsp+0F8h+var_58], xmm5
movaps [rsp+0F8h+var_48], xmm6
movaps [rsp+0F8h+var_38], xmm7
loc_18C9E:
lea r15, [rsp+0F8h+var_D8]
mov [r15+18h], rcx
mov [r15+20h], r8
mov [r15+28h], r9
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov r12, cs:stderr_ptr
mov rdi, [r12]
lea rsi, aSD; "%s:%d: "
mov rdx, r14
mov ecx, ebp
xor eax, eax
call _fprintf
mov rdx, rsp
mov [rdx+10h], r15
lea rax, [rsp+0F8h+arg_0]
mov [rdx+8], rax
mov rax, 3000000018h
mov [rdx], rax
mov rdi, [r12]
mov rsi, rbx
call _vfprintf
mov rsi, [r12]
mov edi, 0Ah
call _fputc
call ggml_print_backtrace
call _abort
|
void __noreturn ggml_abort(
const char *a1,
int a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
long long v16; // rdx
_QWORD v17[4]; // [rsp+0h] [rbp-F8h] BYREF
char v18; // [rsp+20h] [rbp-D8h] BYREF
long long v19; // [rsp+38h] [rbp-C0h]
long long v20; // [rsp+40h] [rbp-B8h]
long long v21; // [rsp+48h] [rbp-B0h]
__m128 v22; // [rsp+50h] [rbp-A8h]
__m128 v23; // [rsp+60h] [rbp-98h]
__m128 v24; // [rsp+70h] [rbp-88h]
__m128 v25; // [rsp+80h] [rbp-78h]
__m128 v26; // [rsp+90h] [rbp-68h]
__m128 v27; // [rsp+A0h] [rbp-58h]
__m128 v28; // [rsp+B0h] [rbp-48h]
__m128 v29; // [rsp+C0h] [rbp-38h]
v22 = a7;
v23 = a8;
v24 = a9;
v25 = a10;
v26 = a11;
v27 = a12;
v28 = a13;
v29 = a14;
v19 = a4;
v20 = a5;
v21 = a6;
fflush(stdout);
fprintf(stderr, "%s:%d: ", a1, a2);
v17[2] = &v18;
v17[1] = &a15;
v17[0] = 0x3000000018LL;
((void ( *)(_QWORD, long long, _QWORD *))vfprintf)(stderr, a3, v17);
fputc(10LL, stderr, v16);
ggml_print_backtrace();
abort();
}
|
ggml_abort:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0xd0
MOV RBX,RDX
MOV EBP,ESI
MOV R14,RDI
TEST AL,AL
JZ 0x00118c9e
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOVAPS xmmword ptr [RSP + 0x60],XMM1
MOVAPS xmmword ptr [RSP + 0x70],XMM2
MOVAPS xmmword ptr [RSP + 0x80],XMM3
MOVAPS xmmword ptr [RSP + 0x90],XMM4
MOVAPS xmmword ptr [RSP + 0xa0],XMM5
MOVAPS xmmword ptr [RSP + 0xb0],XMM6
MOVAPS xmmword ptr [RSP + 0xc0],XMM7
LAB_00118c9e:
LEA R15,[RSP + 0x20]
MOV qword ptr [R15 + 0x18],RCX
MOV qword ptr [R15 + 0x20],R8
MOV qword ptr [R15 + 0x28],R9
MOV RAX,qword ptr [0x00169f88]
MOV RDI,qword ptr [RAX]
CALL 0x00117350
MOV R12,qword ptr [0x00169fc8]
MOV RDI,qword ptr [R12]
LEA RSI,[0x14a494]
MOV RDX,R14
MOV ECX,EBP
XOR EAX,EAX
CALL 0x00117820
MOV RDX,RSP
MOV qword ptr [RDX + 0x10],R15
LEA RAX,[RSP + 0x100]
MOV qword ptr [RDX + 0x8],RAX
MOV RAX,0x3000000018
MOV qword ptr [RDX],RAX
MOV RDI,qword ptr [R12]
MOV RSI,RBX
CALL 0x001175f0
MOV RSI,qword ptr [R12]
MOV EDI,0xa
CALL 0x001174d0
CALL 0x00118d20
CALL 0x001168f0
|
void ggml_abort(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,uint param_10,char *param_11,int8 param_12,
int8 param_13,int8 param_14)
{
int *puVar1;
char in_AL;
int8 local_f8;
int1 *local_f0;
int1 *local_e8;
int1 local_d8 [24];
int8 local_c0;
int8 local_b8;
int8 local_b0;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
int8 local_58;
int8 local_48;
int8 local_38;
if (in_AL != '\0') {
local_a8 = param_1;
local_98 = param_2;
local_88 = param_3;
local_78 = param_4;
local_68 = param_5;
local_58 = param_6;
local_48 = param_7;
local_38 = param_8;
}
local_c0 = param_12;
local_b8 = param_13;
local_b0 = param_14;
fflush(*(FILE **)PTR_stdout_00169f88);
puVar1 = PTR_stderr_00169fc8;
fprintf(*(FILE **)PTR_stderr_00169fc8,"%s:%d: ",param_9,(ulong)param_10);
local_f0 = &stack0x00000008;
local_f8 = 0x3000000018;
local_e8 = local_d8;
vfprintf(*(FILE **)puVar1,param_11,&local_f8);
fputc(10,*(FILE **)puVar1);
ggml_print_backtrace();
/* WARNING: Subroutine does not return */
abort();
}
|
|
11,760 |
mi_restore_status
|
eloqsql/storage/myisam/mi_locking.c
|
void mi_restore_status(void *param)
{
MI_INFO *info= (MI_INFO*) param;
DBUG_ENTER("mi_restore_status");
DBUG_PRINT("info",("key_file: %ld data_file: %ld",
(long) info->s->state.state.key_file_length,
(long) info->s->state.state.data_file_length));
info->state= &info->s->state.state;
info->append_insert_at_end= 0;
DBUG_VOID_RETURN;
}
|
O0
|
c
|
mi_restore_status:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0xb82e2
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x18, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x33a(%rax)
jmp 0xb8302
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
mi_restore_status:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
jmp short $+2
loc_B82E2:
mov rax, [rbp+var_10]
mov rcx, [rax]
add rcx, 18h
mov rax, [rbp+var_10]
mov [rax+8], rcx
mov rax, [rbp+var_10]
mov byte ptr [rax+33Ah], 0
jmp short $+2
loc_B8302:
pop rbp
retn
|
long long mi_restore_status(long long a1)
{
long long result; // rax
*(_QWORD *)(a1 + 8) = *(_QWORD *)a1 + 24LL;
result = a1;
*(_BYTE *)(a1 + 826) = 0;
return result;
}
|
mi_restore_status:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001b82e2
LAB_001b82e2:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
ADD RCX,0x18
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x33a],0x0
JMP 0x001b8302
LAB_001b8302:
POP RBP
RET
|
void mi_restore_status(long *param_1)
{
param_1[1] = *param_1 + 0x18;
*(int1 *)((long)param_1 + 0x33a) = 0;
return;
}
|
|
11,761 |
Workspaces::getWorkspaces[abi:cxx11]()
|
mihussein[P]Hlemon/src/workspaces.cpp
|
std::string Workspaces::getWorkspaces() {
std::string result = "";
for (const std::string name : shownWorkspaces) {
if (name == "LM" || name == "LT") {
result += "%{F#777777}|%{F-} ";
continue;
}
result += name + " ";
}
return result;
}
|
O2
|
cpp
|
Workspaces::getWorkspaces[abi:cxx11]():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x1d2e(%rip), %rsi # 0x940a
leaq 0x28(%rsp), %r14
movq %r14, %rdx
callq 0x593c
movq 0x5d28(%rip), %r15 # 0xd418
movq 0x5d29(%rip), %r13 # 0xd420
leaq 0x1e57(%rip), %r12 # 0x9555
leaq 0x8(%rsp), %rbp
cmpq %r13, %r15
je 0x7779
movq %r14, %rdi
movq %r15, %rsi
callq 0x44e0
movq %r14, %rdi
movq %r12, %rsi
callq 0x59b9
testb %al, %al
jne 0x7735
movq %r14, %rdi
leaq 0x1e2c(%rip), %rsi # 0x9558
callq 0x59b9
testb %al, %al
je 0x7746
movq %rbx, %rdi
leaq 0x1f01(%rip), %rsi # 0x9640
callq 0x46b0
jmp 0x776b
movq %rbp, %rdi
movq %r14, %rsi
leaq 0x1aff(%rip), %rdx # 0x9252
callq 0x7831
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x46d0
movq %rbp, %rdi
callq 0x46e8
movq %r14, %rdi
callq 0x46e8
addq $0x20, %r15
jmp 0x7703
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x779c
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x46e8
jmp 0x779f
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x46e8
jmp 0x77ae
movq %rax, %r14
movq %rbx, %rdi
callq 0x46e8
movq %r14, %rdi
callq 0x4630
|
_ZN10Workspaces13getWorkspacesB5cxx11Ev:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov rbx, rdi
lea rsi, aErrorInitializ+1Ch; ""
lea r14, [rsp+78h+var_50]
mov rdx, r14
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
mov r15, qword ptr cs:_ZN10Workspaces15shownWorkspacesB5cxx11E; Workspaces::shownWorkspaces
mov r13, qword ptr cs:_ZN10Workspaces15shownWorkspacesB5cxx11E+8; Workspaces::shownWorkspaces
lea r12, aLm; "LM"
lea rbp, [rsp+78h+var_70]
loc_7703:
cmp r15, r13
jz short loc_7779
mov rdi, r14
mov rsi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2ERKS4_; std::string::basic_string(std::string const&)
mov rdi, r14
mov rsi, r12
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
test al, al
jnz short loc_7735
mov rdi, r14
lea rsi, aLt; "LT"
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
test al, al
jz short loc_7746
loc_7735:
mov rdi, rbx
lea rsi, aF777777F_0; "%{F#777777}|%{F-} "
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
jmp short loc_776B
loc_7746:
mov rdi, rbp
mov rsi, r14
lea rdx, asc_9251+1; " "
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EERKS8_PKS5_; std::operator+<char>(std::string const&,char const*)
mov rdi, rbx
mov rsi, rbp
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendERKS4_; std::string::append(std::string const&)
mov rdi, rbp; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_776B:
mov rdi, r14; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
add r15, 20h ; ' '
jmp short loc_7703
loc_7779:
mov rax, rbx
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_779C
mov r14, rax
lea rdi, [rsp+arg_0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_779F
loc_779C:
mov r14, rax
loc_779F:
lea rdi, [rsp+arg_20]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_77AE
mov r14, rax
loc_77AE:
mov rdi, rbx; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r14
call __Unwind_Resume
|
_QWORD * Workspaces::getWorkspaces[abi:cxx11](_QWORD *a1)
{
long long v1; // r13
long long i; // r15
_BYTE v4[32]; // [rsp+8h] [rbp-70h] BYREF
_BYTE v5[80]; // [rsp+28h] [rbp-50h] BYREF
std::string::basic_string<std::allocator<char>>(a1, (long long)"");
v1 = *((_QWORD *)&Workspaces::shownWorkspaces[abi:cxx11] + 1);
for ( i = Workspaces::shownWorkspaces[abi:cxx11]; i != v1; i += 32LL )
{
std::string::basic_string(v5);
if ( std::operator==<char>((long long)v5) || std::operator==<char>((long long)v5) )
{
std::string::append(a1, "%{F#777777}|%{F-} ");
}
else
{
std::operator+<char>(v4, v5, " ");
std::string::append(a1, v4);
std::string::~string(v4);
}
std::string::~string(v5);
}
return a1;
}
|
getWorkspaces[abi:cxx11]:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV RBX,RDI
LEA RSI,[0x10940a]
LEA R14,[RSP + 0x28]
MOV RDX,R14
CALL 0x0010593c
MOV R15,qword ptr [0x0010d418]
MOV R13,qword ptr [0x0010d420]
LEA R12,[0x109555]
LEA RBP,[RSP + 0x8]
LAB_00107703:
CMP R15,R13
JZ 0x00107779
LAB_00107708:
MOV RDI,R14
MOV RSI,R15
CALL 0x001044e0
MOV RDI,R14
MOV RSI,R12
CALL 0x001059b9
TEST AL,AL
JNZ 0x00107735
MOV RDI,R14
LEA RSI,[0x109558]
CALL 0x001059b9
TEST AL,AL
JZ 0x00107746
LAB_00107735:
MOV RDI,RBX
LEA RSI,[0x109640]
CALL 0x001046b0
JMP 0x0010776b
LAB_00107746:
MOV RDI,RBP
MOV RSI,R14
LEA RDX,[0x109252]
CALL 0x00107831
LAB_00107758:
MOV RDI,RBX
MOV RSI,RBP
CALL 0x001046d0
LAB_00107763:
MOV RDI,RBP
CALL 0x001046e8
LAB_0010776b:
MOV RDI,R14
CALL 0x001046e8
ADD R15,0x20
JMP 0x00107703
LAB_00107779:
MOV RAX,RBX
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* Workspaces::getWorkspaces[abi:cxx11]() */
Workspaces * __thiscall Workspaces::getWorkspaces_abi_cxx11_(Workspaces *this)
{
string *psVar1;
bool bVar2;
string *psVar3;
string local_70 [32];
string local_50 [32];
std::__cxx11::string::string<std::allocator<char>>((string *)this,"",(allocator *)local_50);
psVar1 = DAT_0010d420;
psVar3 = shownWorkspaces_abi_cxx11_;
do {
if (psVar3 == psVar1) {
return this;
}
/* try { // try from 00107708 to 00107712 has its CatchHandler @ 001077ab */
std::__cxx11::string::string(local_50,psVar3);
bVar2 = std::operator==(local_50,"LM");
if (bVar2) {
LAB_00107735:
/* try { // try from 00107735 to 00107743 has its CatchHandler @ 0010779c */
std::__cxx11::string::append((char *)this);
}
else {
bVar2 = std::operator==(local_50,"LT");
if (bVar2) goto LAB_00107735;
/* try { // try from 00107746 to 00107757 has its CatchHandler @ 0010778b */
std::operator+(local_70,(char *)local_50);
/* try { // try from 00107758 to 00107762 has its CatchHandler @ 0010778d */
std::__cxx11::string::append((string *)this);
std::__cxx11::string::~string(local_70);
}
std::__cxx11::string::~string(local_50);
psVar3 = psVar3 + 0x20;
} while( true );
}
|
|
11,762 |
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::end_object()
|
monkey531[P]llama/common/json.hpp
|
bool end_object()
{
JSON_ASSERT(!ref_stack.empty());
JSON_ASSERT(ref_stack.back()->is_object());
ref_stack.back()->set_parents();
ref_stack.pop_back();
return true;
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::end_object():
pushq %rax
movq 0x10(%rdi), %rax
cmpq %rax, 0x8(%rdi)
je 0x4c1be
movq -0x8(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x4c1da
addq $-0x8, %rax
movq %rax, 0x10(%rdi)
movb $0x1, %al
popq %rcx
retq
leaq 0x5dc42(%rip), %rdi # 0xa9e07
leaq 0x5b0c0(%rip), %rdx # 0xa728c
leaq 0x5f146(%rip), %rcx # 0xab319
movl $0x1aeb, %esi # imm = 0x1AEB
jmp 0x4c1f4
leaq 0x5dc26(%rip), %rdi # 0xa9e07
leaq 0x5b0a4(%rip), %rdx # 0xa728c
leaq 0x5f0d8(%rip), %rcx # 0xab2c7
movl $0x1aec, %esi # imm = 0x1AEC
xorl %eax, %eax
callq 0x18ad0
nop
|
_ZN8nlohmann16json_abi_v3_11_36detail19json_sax_dom_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE10end_objectEv:
push rax
mov rax, [rdi+10h]
cmp [rdi+8], rax
jz short loc_4C1BE
mov rcx, [rax-8]
cmp byte ptr [rcx], 1
jnz short loc_4C1DA
add rax, 0FFFFFFFFFFFFFFF8h
mov [rdi+10h], rax
mov al, 1
pop rcx
retn
loc_4C1BE:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aRefStackEmpty; "!ref_stack.empty()"
mov esi, 1AEBh
jmp short loc_4C1F4
loc_4C1DA:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aRefStackBackIs+20h; "ref_stack.back()->is_object()"
mov esi, 1AECh
loc_4C1F4:
xor eax, eax
call _ggml_abort
nop
|
char nlohmann::json_abi_v3_11_3::detail::json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::end_object(
long long a1)
{
long long v1; // rax
long long v3; // rsi
v1 = *(_QWORD *)(a1 + 16);
if ( *(_QWORD *)(a1 + 8) == v1 )
{
v3 = 6891LL;
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
6891LL,
"GGML_ASSERT(%s) failed",
"!ref_stack.empty()");
}
else
{
if ( **(_BYTE **)(v1 - 8) == 1 )
{
*(_QWORD *)(a1 + 16) = v1 - 8;
return 1;
}
v3 = 6892LL;
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
6892LL,
"GGML_ASSERT(%s) failed",
"ref_stack.back()->is_object()");
}
return nlohmann::json_abi_v3_11_3::detail::json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::key(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
v3);
}
|
end_object:
PUSH RAX
MOV RAX,qword ptr [RDI + 0x10]
CMP qword ptr [RDI + 0x8],RAX
JZ 0x0014c1be
MOV RCX,qword ptr [RAX + -0x8]
CMP byte ptr [RCX],0x1
JNZ 0x0014c1da
ADD RAX,-0x8
MOV qword ptr [RDI + 0x10],RAX
MOV AL,0x1
POP RCX
RET
LAB_0014c1be:
LEA RDI,[0x1a9e07]
LEA RDX,[0x1a728c]
LEA RCX,[0x1ab319]
MOV ESI,0x1aeb
JMP 0x0014c1f4
LAB_0014c1da:
LEA RDI,[0x1a9e07]
LEA RDX,[0x1a728c]
LEA RCX,[0x1ab2c7]
MOV ESI,0x1aec
LAB_0014c1f4:
XOR EAX,EAX
CALL 0x00118ad0
|
/* nlohmann::json_abi_v3_11_3::detail::json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::end_object() */
int8 __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::end_object(json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this)
{
long lVar1;
char *pcVar2;
int8 uVar3;
lVar1 = *(long *)(this + 0x10);
if (*(long *)(this + 8) == lVar1) {
pcVar2 = "!ref_stack.empty()";
uVar3 = 0x1aeb;
}
else {
if (**(char **)(lVar1 + -8) == '\x01') {
*(long *)(this + 0x10) = lVar1 + -8;
return CONCAT71((int7)((ulong)(lVar1 + -8) >> 8),1);
}
pcVar2 = "ref_stack.back()->is_object()";
uVar3 = 0x1aec;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",uVar3,
"GGML_ASSERT(%s) failed",pcVar2);
}
|
|
11,763 |
glfwDestroyCursor
|
untodesu[P]riteg/build_O3/_deps/glfw-src/src/input.c
|
GLFWAPI void glfwDestroyCursor(GLFWcursor* handle)
{
_GLFWcursor* cursor = (_GLFWcursor*) handle;
_GLFW_REQUIRE_INIT();
if (cursor == NULL)
return;
// Make sure the cursor is not being used by any window
{
_GLFWwindow* window;
for (window = _glfw.windowListHead; window; window = window->next)
{
if (window->cursor == cursor)
glfwSetCursor((GLFWwindow*) window, NULL);
}
}
_glfwPlatformDestroyCursor(cursor);
// Unlink cursor from global linked list
{
_GLFWcursor** prev = &_glfw.cursorListHead;
while (*prev != cursor)
prev = &((*prev)->next);
*prev = cursor->next;
}
free(cursor);
}
|
O3
|
c
|
glfwDestroyCursor:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x8e60a(%rip), %rax # 0xa8638
cmpl $0x0, (%rax)
je 0x1a090
movq %rdi, %rbx
testq %rdi, %rdi
je 0x1a0a5
movq 0x3f0(%rax), %r14
testq %r14, %r14
je 0x1a05c
cmpq %rbx, 0x48(%r14)
jne 0x1a057
movq %r14, %rdi
xorl %esi, %esi
callq 0x1a13f
movq (%r14), %r14
jmp 0x1a042
movq %rbx, %rdi
callq 0x2551c
movl $0x3e8, %eax # imm = 0x3E8
addq 0x8cf50(%rip), %rax # 0xa6fc0
movq %rax, %rcx
movq (%rax), %rax
cmpq %rbx, %rax
jne 0x1a070
movq (%rbx), %rax
movq %rax, (%rcx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xca50
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x18e91
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
glfwDestroyCursor:
push r14
push rbx
push rax
lea rax, _glfw
cmp dword ptr [rax], 0
jz short loc_1A090
mov rbx, rdi
test rdi, rdi
jz short loc_1A0A5
mov r14, [rax+3F0h]
loc_1A042:
test r14, r14
jz short loc_1A05C
cmp [r14+48h], rbx
jnz short loc_1A057
mov rdi, r14
xor esi, esi
call glfwSetCursor
loc_1A057:
mov r14, [r14]
jmp short loc_1A042
loc_1A05C:
mov rdi, rbx
call _glfwPlatformDestroyCursor
mov eax, 3E8h
add rax, cs:_glfw_ptr
loc_1A070:
mov rcx, rax
mov rax, [rax]
cmp rax, rbx
jnz short loc_1A070
mov rax, [rbx]
mov [rcx], rax
mov rdi, rbx
add rsp, 8
pop rbx
pop r14
jmp _free
loc_1A090:
mov edi, offset loc_10001
xor esi, esi
xor eax, eax
add rsp, 8
pop rbx
pop r14
jmp _glfwInputError
loc_1A0A5:
add rsp, 8
pop rbx
pop r14
retn
|
_DWORD * glfwDestroyCursor(_QWORD *a1)
{
_DWORD *result; // rax
_QWORD *i; // r14
_QWORD *v3; // rax
_QWORD *v4; // rcx
result = glfw;
if ( !glfw[0] )
return glfwInputError((unsigned int)&loc_10001, 0LL);
if ( a1 )
{
for ( i = *(_QWORD **)&glfw[252]; i; i = (_QWORD *)*i )
{
if ( (_QWORD *)i[9] == a1 )
glfwSetCursor(i, 0LL);
}
glfwPlatformDestroyCursor(a1);
v3 = &glfw[250];
do
{
v4 = v3;
v3 = (_QWORD *)*v3;
}
while ( v3 != a1 );
*v4 = *a1;
return (_DWORD *)free(a1);
}
return result;
}
|
glfwDestroyCursor:
PUSH R14
PUSH RBX
PUSH RAX
LEA RAX,[0x1a8638]
CMP dword ptr [RAX],0x0
JZ 0x0011a090
MOV RBX,RDI
TEST RDI,RDI
JZ 0x0011a0a5
MOV R14,qword ptr [RAX + 0x3f0]
LAB_0011a042:
TEST R14,R14
JZ 0x0011a05c
CMP qword ptr [R14 + 0x48],RBX
JNZ 0x0011a057
MOV RDI,R14
XOR ESI,ESI
CALL 0x0011a13f
LAB_0011a057:
MOV R14,qword ptr [R14]
JMP 0x0011a042
LAB_0011a05c:
MOV RDI,RBX
CALL 0x0012551c
MOV EAX,0x3e8
ADD RAX,qword ptr [0x001a6fc0]
LAB_0011a070:
MOV RCX,RAX
MOV RAX,qword ptr [RAX]
CMP RAX,RBX
JNZ 0x0011a070
MOV RAX,qword ptr [RBX]
MOV qword ptr [RCX],RAX
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R14
JMP 0x0010ca50
LAB_0011a090:
MOV EDI,0x10001
XOR ESI,ESI
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP R14
JMP 0x00118e91
LAB_0011a0a5:
ADD RSP,0x8
POP RBX
POP R14
RET
|
void glfwDestroyCursor(long *param_1)
{
long *plVar1;
long *plVar2;
int8 *puVar3;
if (_glfw == 0) {
_glfwInputError(0x10001,0);
return;
}
puVar3 = DAT_001a8a28;
if (param_1 == (long *)0x0) {
return;
}
for (; puVar3 != (int8 *)0x0; puVar3 = (int8 *)*puVar3) {
if ((long *)puVar3[9] == param_1) {
glfwSetCursor(puVar3,0);
}
}
_glfwPlatformDestroyCursor(param_1);
plVar1 = (long *)(PTR__glfw_001a6fc0 + 1000);
do {
plVar2 = plVar1;
plVar1 = (long *)*plVar2;
} while (plVar1 != param_1);
*plVar2 = *param_1;
free(param_1);
return;
}
|
|
11,764 |
common_context_params_to_llama(common_params const&)
|
monkey531[P]llama/common/common.cpp
|
struct llama_context_params common_context_params_to_llama(const common_params & params) {
auto cparams = llama_context_default_params();
cparams.n_ctx = params.n_ctx;
cparams.n_seq_max = params.n_parallel;
cparams.n_batch = params.n_batch;
cparams.n_ubatch = params.n_ubatch;
cparams.n_threads = params.cpuparams.n_threads;
cparams.n_threads_batch = params.cpuparams_batch.n_threads == -1 ?
params.cpuparams.n_threads : params.cpuparams_batch.n_threads;
cparams.logits_all = params.logits_all;
cparams.embeddings = params.embedding;
cparams.rope_scaling_type = params.rope_scaling_type;
cparams.rope_freq_base = params.rope_freq_base;
cparams.rope_freq_scale = params.rope_freq_scale;
cparams.yarn_ext_factor = params.yarn_ext_factor;
cparams.yarn_attn_factor = params.yarn_attn_factor;
cparams.yarn_beta_fast = params.yarn_beta_fast;
cparams.yarn_beta_slow = params.yarn_beta_slow;
cparams.yarn_orig_ctx = params.yarn_orig_ctx;
cparams.pooling_type = params.pooling_type;
cparams.attention_type = params.attention_type;
cparams.defrag_thold = params.defrag_thold;
cparams.cb_eval = params.cb_eval;
cparams.cb_eval_user_data = params.cb_eval_user_data;
cparams.offload_kqv = !params.no_kv_offload;
cparams.flash_attn = params.flash_attn;
cparams.no_perf = params.no_perf;
if (params.reranking) {
cparams.embeddings = true;
cparams.pooling_type = LLAMA_POOLING_TYPE_RANK;
}
cparams.type_k = params.cache_type_k;
cparams.type_v = params.cache_type_v;
return cparams;
}
|
O2
|
cpp
|
common_context_params_to_llama(common_params const&):
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x240a0
movl 0x18(%r14), %eax
movl %eax, 0xc(%rbx)
movq 0x4(%r14), %rax
movq %rax, (%rbx)
movl 0xc(%r14), %eax
movl %eax, 0x8(%rbx)
movl 0x274(%r14), %eax
movl %eax, 0x10(%rbx)
movl 0x488(%r14), %ecx
cmpl $-0x1, %ecx
cmovel %eax, %ecx
movl %ecx, 0x14(%rbx)
movb 0xfe8(%r14), %al
movb %al, 0x60(%rbx)
movb 0x1038(%r14), %al
movb %al, 0x61(%rbx)
movups 0x2c(%r14), %xmm0
movups %xmm0, 0x24(%rbx)
movsd 0x3c(%r14), %xmm0
movsd %xmm0, 0x34(%rbx)
movl 0x44(%r14), %eax
movl %eax, 0x3c(%rbx)
movq 0x6b4(%r14), %rax
movq %rax, 0x18(%rbx)
movl 0x6bc(%r14), %eax
movl %eax, 0x20(%rbx)
movss 0x48(%r14), %xmm0
movss %xmm0, 0x40(%rbx)
movups 0x6a0(%r14), %xmm0
movups %xmm0, 0x48(%rbx)
movb 0xfee(%r14), %al
xorb $0x1, %al
movb %al, 0x62(%rbx)
movb 0xfe4(%r14), %al
movb %al, 0x63(%rbx)
movb 0xfe5(%r14), %al
movb %al, 0x64(%rbx)
cmpb $0x1, 0x1080(%r14)
jne 0x5a792
movb $0x1, 0x61(%rbx)
movl $0x4, 0x1c(%rbx)
movq 0xff4(%r14), %rax
movq %rax, 0x58(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
_Z30common_context_params_to_llamaRK13common_params:
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
call _llama_context_default_params
mov eax, [r14+18h]
mov [rbx+0Ch], eax
mov rax, [r14+4]
mov [rbx], rax
mov eax, [r14+0Ch]
mov [rbx+8], eax
mov eax, [r14+274h]
mov [rbx+10h], eax
mov ecx, [r14+488h]
cmp ecx, 0FFFFFFFFh
cmovz ecx, eax
mov [rbx+14h], ecx
mov al, [r14+0FE8h]
mov [rbx+60h], al
mov al, [r14+1038h]
mov [rbx+61h], al
movups xmm0, xmmword ptr [r14+2Ch]
movups xmmword ptr [rbx+24h], xmm0
movsd xmm0, qword ptr [r14+3Ch]
movsd qword ptr [rbx+34h], xmm0
mov eax, [r14+44h]
mov [rbx+3Ch], eax
mov rax, [r14+6B4h]
mov [rbx+18h], rax
mov eax, [r14+6BCh]
mov [rbx+20h], eax
movss xmm0, dword ptr [r14+48h]
movss dword ptr [rbx+40h], xmm0
movups xmm0, xmmword ptr [r14+6A0h]
movups xmmword ptr [rbx+48h], xmm0
mov al, [r14+0FEEh]
xor al, 1
mov [rbx+62h], al
mov al, [r14+0FE4h]
mov [rbx+63h], al
mov al, [r14+0FE5h]
mov [rbx+64h], al
cmp byte ptr [r14+1080h], 1
jnz short loc_5A792
mov byte ptr [rbx+61h], 1
mov dword ptr [rbx+1Ch], 4
loc_5A792:
mov rax, [r14+0FF4h]
mov [rbx+58h], rax
mov rax, rbx
add rsp, 8
pop rbx
pop r14
retn
|
const common_params * common_context_params_to_llama(const common_params *a1, long long a2)
{
int v2; // eax
int v3; // ecx
llama_context_default_params(a1);
*((_DWORD *)a1 + 3) = *(_DWORD *)(a2 + 24);
*(_QWORD *)a1 = *(_QWORD *)(a2 + 4);
*((_DWORD *)a1 + 2) = *(_DWORD *)(a2 + 12);
v2 = *(_DWORD *)(a2 + 628);
*((_DWORD *)a1 + 4) = v2;
v3 = *(_DWORD *)(a2 + 1160);
if ( v3 == -1 )
v3 = v2;
*((_DWORD *)a1 + 5) = v3;
*((_BYTE *)a1 + 96) = *(_BYTE *)(a2 + 4072);
*((_BYTE *)a1 + 97) = *(_BYTE *)(a2 + 4152);
*(_OWORD *)((char *)a1 + 36) = *(_OWORD *)(a2 + 44);
*(_QWORD *)((char *)a1 + 52) = *(_QWORD *)(a2 + 60);
*((_DWORD *)a1 + 15) = *(_DWORD *)(a2 + 68);
*((_QWORD *)a1 + 3) = *(_QWORD *)(a2 + 1716);
*((_DWORD *)a1 + 8) = *(_DWORD *)(a2 + 1724);
*((_DWORD *)a1 + 16) = *(_DWORD *)(a2 + 72);
*(_OWORD *)((char *)a1 + 72) = *(_OWORD *)(a2 + 1696);
*((_BYTE *)a1 + 98) = *(_BYTE *)(a2 + 4078) ^ 1;
*((_BYTE *)a1 + 99) = *(_BYTE *)(a2 + 4068);
*((_BYTE *)a1 + 100) = *(_BYTE *)(a2 + 4069);
if ( *(_BYTE *)(a2 + 4224) == 1 )
{
*((_BYTE *)a1 + 97) = 1;
*((_DWORD *)a1 + 7) = 4;
}
*((_QWORD *)a1 + 11) = *(_QWORD *)(a2 + 4084);
return a1;
}
|
common_context_params_to_llama:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
CALL 0x001240a0
MOV EAX,dword ptr [R14 + 0x18]
MOV dword ptr [RBX + 0xc],EAX
MOV RAX,qword ptr [R14 + 0x4]
MOV qword ptr [RBX],RAX
MOV EAX,dword ptr [R14 + 0xc]
MOV dword ptr [RBX + 0x8],EAX
MOV EAX,dword ptr [R14 + 0x274]
MOV dword ptr [RBX + 0x10],EAX
MOV ECX,dword ptr [R14 + 0x488]
CMP ECX,-0x1
CMOVZ ECX,EAX
MOV dword ptr [RBX + 0x14],ECX
MOV AL,byte ptr [R14 + 0xfe8]
MOV byte ptr [RBX + 0x60],AL
MOV AL,byte ptr [R14 + 0x1038]
MOV byte ptr [RBX + 0x61],AL
MOVUPS XMM0,xmmword ptr [R14 + 0x2c]
MOVUPS xmmword ptr [RBX + 0x24],XMM0
MOVSD XMM0,qword ptr [R14 + 0x3c]
MOVSD qword ptr [RBX + 0x34],XMM0
MOV EAX,dword ptr [R14 + 0x44]
MOV dword ptr [RBX + 0x3c],EAX
MOV RAX,qword ptr [R14 + 0x6b4]
MOV qword ptr [RBX + 0x18],RAX
MOV EAX,dword ptr [R14 + 0x6bc]
MOV dword ptr [RBX + 0x20],EAX
MOVSS XMM0,dword ptr [R14 + 0x48]
MOVSS dword ptr [RBX + 0x40],XMM0
MOVUPS XMM0,xmmword ptr [R14 + 0x6a0]
MOVUPS xmmword ptr [RBX + 0x48],XMM0
MOV AL,byte ptr [R14 + 0xfee]
XOR AL,0x1
MOV byte ptr [RBX + 0x62],AL
MOV AL,byte ptr [R14 + 0xfe4]
MOV byte ptr [RBX + 0x63],AL
MOV AL,byte ptr [R14 + 0xfe5]
MOV byte ptr [RBX + 0x64],AL
CMP byte ptr [R14 + 0x1080],0x1
JNZ 0x0015a792
MOV byte ptr [RBX + 0x61],0x1
MOV dword ptr [RBX + 0x1c],0x4
LAB_0015a792:
MOV RAX,qword ptr [R14 + 0xff4]
MOV qword ptr [RBX + 0x58],RAX
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* common_context_params_to_llama(common_params const&) */
common_params * common_context_params_to_llama(common_params *param_1)
{
int iVar1;
int8 uVar2;
int iVar3;
long in_RSI;
llama_context_default_params();
*(int4 *)(param_1 + 0xc) = *(int4 *)(in_RSI + 0x18);
*(int8 *)param_1 = *(int8 *)(in_RSI + 4);
*(int4 *)(param_1 + 8) = *(int4 *)(in_RSI + 0xc);
iVar1 = *(int *)(in_RSI + 0x274);
*(int *)(param_1 + 0x10) = iVar1;
iVar3 = *(int *)(in_RSI + 0x488);
if (*(int *)(in_RSI + 0x488) == -1) {
iVar3 = iVar1;
}
*(int *)(param_1 + 0x14) = iVar3;
param_1[0x60] = *(common_params *)(in_RSI + 0xfe8);
param_1[0x61] = *(common_params *)(in_RSI + 0x1038);
uVar2 = *(int8 *)(in_RSI + 0x34);
*(int8 *)(param_1 + 0x24) = *(int8 *)(in_RSI + 0x2c);
*(int8 *)(param_1 + 0x2c) = uVar2;
*(int8 *)(param_1 + 0x34) = *(int8 *)(in_RSI + 0x3c);
*(int4 *)(param_1 + 0x3c) = *(int4 *)(in_RSI + 0x44);
*(int8 *)(param_1 + 0x18) = *(int8 *)(in_RSI + 0x6b4);
*(int4 *)(param_1 + 0x20) = *(int4 *)(in_RSI + 0x6bc);
*(int4 *)(param_1 + 0x40) = *(int4 *)(in_RSI + 0x48);
uVar2 = *(int8 *)(in_RSI + 0x6a8);
*(int8 *)(param_1 + 0x48) = *(int8 *)(in_RSI + 0x6a0);
*(int8 *)(param_1 + 0x50) = uVar2;
param_1[0x62] = (common_params)(*(byte *)(in_RSI + 0xfee) ^ 1);
param_1[99] = *(common_params *)(in_RSI + 0xfe4);
param_1[100] = *(common_params *)(in_RSI + 0xfe5);
if (*(char *)(in_RSI + 0x1080) == '\x01') {
param_1[0x61] = (common_params)0x1;
*(int4 *)(param_1 + 0x1c) = 4;
}
*(int8 *)(param_1 + 0x58) = *(int8 *)(in_RSI + 0xff4);
return param_1;
}
|
|
11,765 |
google::protobuf::FileDescriptorProto::_internal_has_source_code_info() const
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.pb.h
|
inline bool FileDescriptorProto::_internal_has_source_code_info() const {
bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
PROTOBUF_ASSUME(!value || _impl_.source_code_info_ != nullptr);
return value;
}
|
O0
|
c
|
google::protobuf::FileDescriptorProto::_internal_has_source_code_info() const:
subq $0x98, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x20(%rsp)
addq $0x10, %rax
movq %rax, 0x90(%rsp)
movl $0x0, 0x8c(%rsp)
movq 0x90(%rsp), %rax
movslq 0x8c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
andl $0x10, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x7f(%rsp)
xorl %eax, %eax
testb $0x1, %al
jne 0x4e64c0
jmp 0x4e6569
movb 0x7f(%rsp), %al
movb $0x0, 0x3f(%rsp)
testb $0x1, %al
je 0x4e64dc
movq 0x20(%rsp), %rax
cmpq $0x0, 0xd0(%rax)
je 0x4e64de
jmp 0x4e652e
leaq 0x1149d8(%rip), %rdx # 0x5faebd
leaq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0x3, %esi
movl $0x23b4, %ecx # imm = 0x23B4
callq 0x3ef0b0
movq 0x10(%rsp), %rdi
movb $0x1, 0x3f(%rsp)
leaq 0x114a17(%rip), %rsi # 0x5faf26
callq 0x3ee970
movq %rax, 0x18(%rsp)
jmp 0x4e651b
movq 0x18(%rsp), %rsi
leaq 0x2b(%rsp), %rdi
callq 0x3eeb20
jmp 0x4e652c
jmp 0x4e652e
testb $0x1, 0x3f(%rsp)
jne 0x4e6537
jmp 0x4e6541
leaq 0x40(%rsp), %rdi
callq 0x3ef0f0
jmp 0x4e64b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
testb $0x1, 0x3f(%rsp)
jne 0x4e655d
jmp 0x4e6567
leaq 0x40(%rsp), %rdi
callq 0x3ef0f0
jmp 0x4e659c
movb $0x1, %al
testb $0x1, 0x7f(%rsp)
movb %al, 0xf(%rsp)
je 0x4e658a
movq 0x20(%rsp), %rax
cmpq $0x0, 0xd0(%rax)
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
movb 0x7f(%rsp), %al
andb $0x1, %al
addq $0x98, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x198ce0
nopw %cs:(%rax,%rax)
|
_ZNK6google8protobuf19FileDescriptorProto30_internal_has_source_code_infoEv:
sub rsp, 98h
mov [rsp+98h+var_18], rdi
mov rax, [rsp+98h+var_18]
mov [rsp+98h+var_78], rax
add rax, 10h
mov [rsp+98h+var_8], rax
mov [rsp+98h+var_C], 0
mov rax, [rsp+98h+var_8]
movsxd rcx, [rsp+98h+var_C]
mov eax, [rax+rcx*4]
and eax, 10h
cmp eax, 0
setnz al
and al, 1
mov [rsp+98h+var_19], al
loc_4E64B5:
xor eax, eax
test al, 1
jnz short loc_4E64C0
jmp loc_4E6569
loc_4E64C0:
mov al, [rsp+98h+var_19]
mov [rsp+98h+var_59], 0
test al, 1
jz short loc_4E64DC
mov rax, [rsp+98h+var_78]
cmp qword ptr [rax+0D0h], 0
jz short loc_4E64DE
loc_4E64DC:
jmp short loc_4E652E
loc_4E64DE:
lea rdx, aWorkspaceLlm4b_48; "/workspace/llm4binary/github2025/aimrt_"...
lea rdi, [rsp+98h+var_58]
mov [rsp+98h+var_88], rdi
mov esi, 3
mov ecx, 23B4h
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
mov rdi, [rsp+98h+var_88]
mov [rsp+98h+var_59], 1
lea rsi, aCheckFailedVal_2; "CHECK failed: !value || _impl_.source_c"...
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+98h+var_80], rax
jmp short $+2
loc_4E651B:
mov rsi, [rsp+98h+var_80]
lea rdi, [rsp+98h+var_6D]
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
jmp short $+2
loc_4E652C:
jmp short $+2
loc_4E652E:
test [rsp+98h+var_59], 1
jnz short loc_4E6537
jmp short loc_4E6541
loc_4E6537:
lea rdi, [rsp+98h+var_58]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_4E6541:
jmp loc_4E64B5
mov rcx, rax
mov eax, edx
mov [rsp+arg_28], rcx
mov [rsp+arg_24], eax
test [rsp+arg_37], 1
jnz short loc_4E655D
jmp short loc_4E6567
loc_4E655D:
lea rdi, [rsp+arg_38]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_4E6567:
jmp short loc_4E659C
loc_4E6569:
mov al, 1
test [rsp+98h+var_19], 1
mov [rsp+98h+var_89], al
jz short loc_4E658A
mov rax, [rsp+98h+var_78]
cmp qword ptr [rax+0D0h], 0
setnz al
mov [rsp+98h+var_89], al
loc_4E658A:
mov al, [rsp+98h+var_89]
mov al, [rsp+98h+var_19]
and al, 1
add rsp, 98h
retn
loc_4E659C:
mov rdi, [rsp+arg_28]
call __Unwind_Resume
|
bool google::protobuf::FileDescriptorProto::_internal_has_source_code_info(
google::protobuf::FileDescriptorProto *this)
{
return (*((_DWORD *)this + 4) & 0x10) != 0;
}
|
MergeFrom:
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 0x004e7b20
ADD RSP,0x18
RET
|
/* google::protobuf::RepeatedPtrField<std::__cxx11::string
>::MergeFrom(google::protobuf::RepeatedPtrField<std::__cxx11::string > const&) */
void __thiscall
google::protobuf::RepeatedPtrField<std::__cxx11::string>::MergeFrom
(RepeatedPtrField<std::__cxx11::string> *this,RepeatedPtrField *param_1)
{
internal::RepeatedPtrFieldBase::
MergeFrom<google::protobuf::RepeatedPtrField<std::__cxx11::string>::TypeHandler>
((RepeatedPtrFieldBase *)this,(RepeatedPtrFieldBase *)param_1);
return;
}
|
|
11,766 |
testing::Matcher<std::basic_string_view<char, std::char_traits<char>> const&>::Matcher(char const*)
|
AlayaLite/build_O3/_deps/googletest-src/googletest/src/gtest-matchers.cc
|
Matcher<const internal::StringView&>::Matcher(const char* s) {
*this = Eq(std::string(s));
}
|
O3
|
cpp
|
testing::Matcher<std::basic_string_view<char, std::char_traits<char>> const&>::Matcher(char const*):
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
leaq 0x5c5c2(%rip), %r14 # 0xb36b8
addq $0x10, %r14
movq %r14, (%rdi)
leaq 0x40(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x16c9c
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x18f38
leaq 0x5c935(%rip), %rax # 0xb3a68
addq $0x10, %rax
movq %rax, 0x28(%rsp)
movq $0x0, 0x38(%rsp)
leaq 0x5ca04(%rip), %rax # 0xb3b50
movq %rax, 0x30(%rsp)
movl $0x28, %edi
callq 0x11190
movl $0x1, (%rax)
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rdx
cmpq %r15, %rdx
je 0x57185
movq %rdx, 0x8(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x5718c
movups (%r15), %xmm0
movups %xmm0, (%rcx)
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq %r15, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
leaq 0x28(%rsp), %rsi
movq %rax, 0x10(%rsi)
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0x77c2c
leaq 0x28(%rsp), %rdi
callq 0x7b3ee
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x571dd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11120
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x571f8
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x11120
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x7b3ee
jmp 0x57214
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x57230
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11120
jmp 0x57230
movq %rax, %r14
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x57250
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x11120
jmp 0x57250
movq %rax, %r14
movq %rbx, %rdi
callq 0x7b3ee
movq %r14, %rdi
callq 0x11760
|
_ZN7testing7MatcherIRKSt17basic_string_viewIcSt11char_traitsIcEEEC2EPKc:
push r15
push r14
push rbx
sub rsp, 60h
mov rbx, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi+8], xmm0
lea r14, _ZTVN7testing7MatcherIRKSt17basic_string_viewIcSt11char_traitsIcEEEE; `vtable for'testing::Matcher<std::string_view const&>
add r14, 10h
mov [rdi], r14
lea rdi, [rsp+78h+var_38]
lea rdx, [rsp+78h+var_71]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea r15, [rsp+78h+var_60]
mov [r15-10h], r15
mov rsi, [rsp+78h+var_38]
mov rdx, [rsp+78h+var_30]
add rdx, rsi
lea rdi, [rsp+78h+var_70]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
lea rax, _ZTVN7testing8internal11MatcherBaseIRKSt17basic_string_viewIcSt11char_traitsIcEEEE; `vtable for'testing::internal::MatcherBase<std::string_view const&>
add rax, 10h
mov [rsp+78h+var_50], rax
mov [rsp+78h+var_40], 0
lea rax, _ZZN7testing8internal11MatcherBaseIRKSt17basic_string_viewIcSt11char_traitsIcEEE9GetVTableINS8_11ValuePolicyINS0_9EqMatcherINSt7__cxx1112basic_stringIcS4_SaIcEEEEELb0EEEEEPKNS8_6VTableEvE7kVTable; testing::internal::MatcherBase<std::string_view const&>::GetVTable<testing::internal::MatcherBase<std::string_view const&>::ValuePolicy<testing::internal::EqMatcher<std::string>,false>>(void)::kVTable
mov [rsp+78h+var_48], rax
mov edi, 28h ; '('; unsigned __int64
call __Znwm; operator new(ulong)
mov dword ptr [rax], 1
mov rcx, rax
add rcx, 18h
mov [rax+8], rcx
mov rdx, [rsp+78h+var_70]
cmp rdx, r15
jz short loc_57185
mov [rax+8], rdx
mov rcx, [rsp+78h+var_60]
mov [rax+18h], rcx
jmp short loc_5718C
loc_57185:
movups xmm0, xmmword ptr [r15]
movups xmmword ptr [rcx], xmm0
loc_5718C:
mov rcx, [rsp+78h+var_68]
mov [rax+10h], rcx
mov [rsp+78h+var_70], r15
mov [rsp+78h+var_68], 0
mov byte ptr [rsp+78h+var_60], 0
lea rsi, [rsp+78h+var_50]
mov [rsi+10h], rax
mov [rsi], r14
mov rdi, rbx
call _ZN7testing8internal11MatcherBaseIRKSt17basic_string_viewIcSt11char_traitsIcEEEaSEOS8_; testing::internal::MatcherBase<std::string_view const&>::operator=(testing::internal::MatcherBase<std::string_view const&>&&)
lea rdi, [rsp+78h+var_50]
call _ZN7testing8internal11MatcherBaseIRKSt17basic_string_viewIcSt11char_traitsIcEEED2Ev; testing::internal::MatcherBase<std::string_view const&>::~MatcherBase()
mov rdi, [rsp+78h+var_70]; void *
cmp rdi, r15
jz short loc_571DD
mov rsi, [rsp+78h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_571DD:
lea rax, [rsp+78h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_571F8
mov rsi, [rsp+78h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_571F8:
add rsp, 60h
pop rbx
pop r14
pop r15
retn
mov r14, rax
lea rdi, [rsp+arg_20]
call _ZN7testing8internal11MatcherBaseIRKSt17basic_string_viewIcSt11char_traitsIcEEED2Ev; testing::internal::MatcherBase<std::string_view const&>::~MatcherBase()
jmp short loc_57214
mov r14, rax
loc_57214:
mov rdi, [rsp+arg_0]; void *
cmp rdi, r15
jz short loc_57230
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_57230
mov r14, rax
loc_57230:
lea rax, [rsp+arg_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_57250
mov rsi, [rsp+arg_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_57250
mov r14, rax
loc_57250:
mov rdi, rbx
call _ZN7testing8internal11MatcherBaseIRKSt17basic_string_viewIcSt11char_traitsIcEEED2Ev; testing::internal::MatcherBase<std::string_view const&>::~MatcherBase()
mov rdi, r14
call __Unwind_Resume
|
void testing::Matcher<std::string_view const&>::Matcher(long long a1, long long a2)
{
long long v2; // rax
void *v3; // [rsp+8h] [rbp-70h] BYREF
long long v4; // [rsp+10h] [rbp-68h]
__int128 v5; // [rsp+18h] [rbp-60h] BYREF
_QWORD v6[2]; // [rsp+28h] [rbp-50h] BYREF
long long v7; // [rsp+38h] [rbp-40h]
void *v8[2]; // [rsp+40h] [rbp-38h] BYREF
long long v9; // [rsp+50h] [rbp-28h] BYREF
*(_OWORD *)(a1 + 8) = 0LL;
*(_QWORD *)a1 = &`vtable for'testing::Matcher<std::string_view const&> + 2;
std::string::basic_string<std::allocator<char>>(v8, a2);
v3 = &v5;
std::string::_M_construct<char *>((long long)&v3, (_BYTE *)v8[0], (long long)v8[0] + (unsigned long long)v8[1]);
v6[0] = &`vtable for'testing::internal::MatcherBase<std::string_view const&> + 2;
v7 = 0LL;
v6[1] = testing::internal::MatcherBase<std::string_view const&>::GetVTable<testing::internal::MatcherBase<std::string_view const&>::ValuePolicy<testing::internal::EqMatcher<std::string>,false>>(void)::kVTable;
v2 = operator new(0x28uLL);
*(_DWORD *)v2 = 1;
*(_QWORD *)(v2 + 8) = v2 + 24;
if ( v3 == &v5 )
{
*(_OWORD *)(v2 + 24) = v5;
}
else
{
*(_QWORD *)(v2 + 8) = v3;
*(_QWORD *)(v2 + 24) = v5;
}
*(_QWORD *)(v2 + 16) = v4;
v3 = &v5;
v4 = 0LL;
LOBYTE(v5) = 0;
v7 = v2;
v6[0] = &`vtable for'testing::Matcher<std::string_view const&> + 2;
testing::internal::MatcherBase<std::string_view const&>::operator=(a1);
testing::internal::MatcherBase<std::string_view const&>::~MatcherBase(v6);
if ( v3 != &v5 )
operator delete(v3, v5 + 1);
if ( v8[0] != &v9 )
operator delete(v8[0], v9 + 1);
}
|
Matcher:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x60
MOV RBX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x8],XMM0
LEA R14,[0x1b36b8]
ADD R14,0x10
MOV qword ptr [RDI],R14
LAB_001570fd:
LEA RDI,[RSP + 0x40]
LEA RDX,[RSP + 0x7]
CALL 0x00116c9c
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x10],R15
MOV RSI,qword ptr [RSP + 0x40]
MOV RDX,qword ptr [RSP + 0x48]
ADD RDX,RSI
LAB_00157122:
LEA RDI,[RSP + 0x8]
CALL 0x00118f38
LEA RAX,[0x1b3a68]
ADD RAX,0x10
MOV qword ptr [RSP + 0x28],RAX
MOV qword ptr [RSP + 0x38],0x0
LEA RAX,[0x1b3b50]
MOV qword ptr [RSP + 0x30],RAX
LAB_00157151:
MOV EDI,0x28
CALL 0x00111190
MOV dword ptr [RAX],0x1
MOV RCX,RAX
ADD RCX,0x18
MOV qword ptr [RAX + 0x8],RCX
MOV RDX,qword ptr [RSP + 0x8]
CMP RDX,R15
JZ 0x00157185
MOV qword ptr [RAX + 0x8],RDX
MOV RCX,qword ptr [RSP + 0x18]
MOV qword ptr [RAX + 0x18],RCX
JMP 0x0015718c
LAB_00157185:
MOVUPS XMM0,xmmword ptr [R15]
MOVUPS xmmword ptr [RCX],XMM0
LAB_0015718c:
MOV RCX,qword ptr [RSP + 0x10]
MOV qword ptr [RAX + 0x10],RCX
MOV qword ptr [RSP + 0x8],R15
MOV qword ptr [RSP + 0x10],0x0
MOV byte ptr [RSP + 0x18],0x0
LEA RSI,[RSP + 0x28]
MOV qword ptr [RSI + 0x10],RAX
MOV qword ptr [RSI],R14
LAB_001571b4:
MOV RDI,RBX
CALL 0x00177c2c
LAB_001571bc:
LEA RDI,[RSP + 0x28]
CALL 0x0017b3ee
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R15
JZ 0x001571dd
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x00111120
LAB_001571dd:
LEA RAX,[RSP + 0x50]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001571f8
MOV RSI,qword ptr [RSP + 0x50]
INC RSI
CALL 0x00111120
LAB_001571f8:
ADD RSP,0x60
POP RBX
POP R14
POP R15
RET
|
/* testing::Matcher<std::basic_string_view<char, std::char_traits<char> > const&>::Matcher(char
const*) */
void __thiscall
testing::Matcher<std::basic_string_view<char,std::char_traits<char>>const&>::Matcher
(Matcher<std::basic_string_view<char,std::char_traits<char>>const&> *this,char *param_1)
{
allocator local_71;
int1 *local_70;
int8 local_68;
int1 local_60;
int7 uStack_5f;
int8 uStack_58;
int **local_50;
int1 *local_48;
int4 *local_40;
long *local_38;
long local_30;
long local_28 [2];
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
*(int ***)this = &PTR__MatcherBase_001b36c8;
/* try { // try from 001570fd to 0015710b has its CatchHandler @ 0015724d */
std::__cxx11::string::string<std::allocator<char>>((string *)&local_38,param_1,&local_71);
/* try { // try from 00157122 to 0015712b has its CatchHandler @ 0015722d */
local_70 = &local_60;
std::__cxx11::string::_M_construct<char*>(&local_70,local_38,local_30 + (long)local_38);
local_50 = &PTR__MatcherBase_001b3a78;
local_40 = (int4 *)0x0;
local_48 = internal::MatcherBase<std::basic_string_view<char,std::char_traits<char>>const&>::
GetVTable<testing::internal::MatcherBase<std::basic_string_view<char,std::char_traits<char>>const&>::ValuePolicy<testing::internal::EqMatcher<std::__cxx11::string>,false>>()
::kVTable;
/* try { // try from 00157151 to 0015715a has its CatchHandler @ 00157211 */
local_40 = (int4 *)operator_new(0x28);
*local_40 = 1;
*(int4 **)(local_40 + 2) = local_40 + 6;
if (local_70 == &local_60) {
*(ulong *)(local_40 + 6) = CONCAT71(uStack_5f,local_60);
*(int8 *)(local_40 + 8) = uStack_58;
}
else {
*(int1 **)(local_40 + 2) = local_70;
*(ulong *)(local_40 + 6) = CONCAT71(uStack_5f,local_60);
}
*(int8 *)(local_40 + 4) = local_68;
local_68 = 0;
local_60 = 0;
local_50 = &PTR__MatcherBase_001b36c8;
local_70 = &local_60;
/* try { // try from 001571b4 to 001571bb has its CatchHandler @ 00157202 */
internal::MatcherBase<std::basic_string_view<char,std::char_traits<char>>const&>::operator=
((MatcherBase<std::basic_string_view<char,std::char_traits<char>>const&> *)this,
(MatcherBase *)&local_50);
internal::MatcherBase<std::basic_string_view<char,std::char_traits<char>>const&>::~MatcherBase
((MatcherBase<std::basic_string_view<char,std::char_traits<char>>const&> *)&local_50);
if (local_70 != &local_60) {
operator_delete(local_70,CONCAT71(uStack_5f,local_60) + 1);
}
if (local_38 != local_28) {
operator_delete(local_38,local_28[0] + 1);
}
return;
}
|
|
11,767 |
make_tempfile
|
eloqsql/client/mysql_plugin.c
|
static int make_tempfile(char *filename, const char *ext)
{
int fd= 0;
if ((fd= create_temp_file(filename, NullS, ext, 0, MYF(MY_WME))) < 0)
{
fprintf(stderr, "ERROR: Cannot generate temporary file. Error code: %d.\n",
fd);
return 1;
}
my_close(fd, MYF(0));
return 0;
}
|
O0
|
c
|
make_tempfile:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
xorl %ecx, %ecx
movl $0x10, %r8d
callq 0x28af0
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jge 0x26eec
movq 0x1b2109(%rip), %rax # 0x1d8fd8
movq (%rax), %rdi
movl -0x1c(%rbp), %edx
leaq 0x5b78f(%rip), %rsi # 0x8266b
movb $0x0, %al
callq 0x254d0
movl $0x1, -0x4(%rbp)
jmp 0x26eff
movl -0x1c(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x2ec20
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
make_tempfile:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], 0
mov rdi, [rbp+var_10]
mov rdx, [rbp+var_18]
xor eax, eax
mov esi, eax
xor ecx, ecx
mov r8d, 10h
call create_temp_file
mov [rbp+var_1C], eax
cmp eax, 0
jge short loc_26EEC
mov rax, cs:stderr_ptr
mov rdi, [rax]
mov edx, [rbp+var_1C]
lea rsi, aErrorCannotGen; "ERROR: Cannot generate temporary file. "...
mov al, 0
call _fprintf
mov [rbp+var_4], 1
jmp short loc_26EFF
loc_26EEC:
mov edi, [rbp+var_1C]
xor eax, eax
mov esi, eax
call my_close
mov [rbp+var_4], 0
loc_26EFF:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
|
long long make_tempfile(long long a1, long long a2)
{
int temp_file; // [rsp+4h] [rbp-1Ch]
temp_file = create_temp_file(a1, 0LL, a2, 0LL, 16LL);
if ( temp_file >= 0 )
{
my_close((unsigned int)temp_file, 0LL);
return 0;
}
else
{
fprintf(stderr, "ERROR: Cannot generate temporary file. Error code: %d.\n", temp_file);
return 1;
}
}
|
make_tempfile:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],0x0
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
XOR EAX,EAX
MOV ESI,EAX
XOR ECX,ECX
MOV R8D,0x10
CALL 0x00128af0
MOV dword ptr [RBP + -0x1c],EAX
CMP EAX,0x0
JGE 0x00126eec
MOV RAX,qword ptr [0x002d8fd8]
MOV RDI,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x1c]
LEA RSI,[0x18266b]
MOV AL,0x0
CALL 0x001254d0
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00126eff
LAB_00126eec:
MOV EDI,dword ptr [RBP + -0x1c]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x0012ec20
MOV dword ptr [RBP + -0x4],0x0
LAB_00126eff:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
bool make_tempfile(int8 param_1,int8 param_2)
{
uint uVar1;
uVar1 = create_temp_file(param_1,0,param_2,0,0x10);
if (-1 < (int)uVar1) {
my_close(uVar1,0);
}
else {
fprintf(*(FILE **)PTR_stderr_002d8fd8,"ERROR: Cannot generate temporary file. Error code: %d.\n"
,(ulong)uVar1);
}
return -1 >= (int)uVar1;
}
|
|
11,768 |
my_time_init
|
eloqsql/mysys/my_getsystime.c
|
void my_time_init()
{
#ifdef _WIN32
compile_time_assert(sizeof(LARGE_INTEGER) ==
sizeof(query_performance_frequency));
QueryPerformanceFrequency((LARGE_INTEGER *)&query_performance_frequency);
DBUG_ASSERT(query_performance_frequency);
#endif
}
|
O3
|
c
|
my_time_init:
pushq %rbp
movq %rsp, %rbp
popq %rbp
retq
|
my_time_init:
push rbp
mov rbp, rsp
pop rbp
retn
|
void my_time_init()
{
;
}
|
my_time_init:
PUSH RBP
MOV RBP,RSP
POP RBP
RET
|
void my_time_init(void)
{
return;
}
|
|
11,769 |
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::reset()
|
monkey531[P]llama/common/json.hpp
|
void reset() noexcept
{
token_buffer.clear();
token_string.clear();
token_string.push_back(char_traits<char_type>::to_char_type(current));
}
|
O2
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::reset():
pushq %rax
movq %rdi, %rax
andq $0x0, 0x58(%rdi)
movq 0x50(%rdi), %rcx
movb $0x0, (%rcx)
addq $0x38, %rdi
movq 0x38(%rax), %rcx
cmpq %rcx, 0x40(%rax)
je 0x4071a
movq %rcx, 0x40(%rax)
movb 0x14(%rax), %al
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
callq 0x40590
popq %rax
retq
movq %rax, %rdi
callq 0x28ddb
nop
|
_ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE5resetEv:
push rax
mov rax, rdi
and qword ptr [rdi+58h], 0
mov rcx, [rdi+50h]
mov byte ptr [rcx], 0
add rdi, 38h ; '8'
mov rcx, [rax+38h]
cmp [rax+40h], rcx
jz short loc_4071A
mov [rax+40h], rcx
loc_4071A:
mov al, [rax+14h]
lea rsi, [rsp+8+var_1]
mov [rsi], al
call _ZNSt6vectorIcSaIcEE12emplace_backIJcEEERcDpOT_; std::vector<char>::emplace_back<char>(char &&)
pop rax
retn
mov rdi, rax
call __clang_call_terminate
|
void __spoils<rdx,rcx,r8,r9,r10,r11,xmm4,xmm5> nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::reset(
long long a1)
{
long long v2; // rdi
long long v3; // rcx
char v4; // [rsp+1h] [rbp-1h] BYREF
*(_QWORD *)(a1 + 88) = 0LL;
**(_BYTE **)(a1 + 80) = 0;
v2 = a1 + 56;
v3 = *(_QWORD *)(a1 + 56);
if ( *(_QWORD *)(a1 + 64) != v3 )
*(_QWORD *)(a1 + 64) = v3;
v4 = *(_BYTE *)(a1 + 20);
std::vector<char>::emplace_back<char>(v2, &v4);
}
|
reset:
PUSH RAX
MOV RAX,RDI
AND qword ptr [RDI + 0x58],0x0
MOV RCX,qword ptr [RDI + 0x50]
MOV byte ptr [RCX],0x0
ADD RDI,0x38
MOV RCX,qword ptr [RAX + 0x38]
CMP qword ptr [RAX + 0x40],RCX
JZ 0x0014071a
MOV qword ptr [RAX + 0x40],RCX
LAB_0014071a:
MOV AL,byte ptr [RAX + 0x14]
LEA RSI,[RSP + 0x7]
MOV byte ptr [RSI],AL
LAB_00140724:
CALL 0x00140590
POP RAX
RET
|
/* nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>,
nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > > >::reset() */
int8 __thiscall
nlohmann::json_abi_v3_11_3::detail::
lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
::reset(lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*this)
{
int8 in_RAX;
int8 uStack_8;
*(int8 *)(this + 0x58) = 0;
**(int1 **)(this + 0x50) = 0;
if (*(long *)(this + 0x40) != *(long *)(this + 0x38)) {
*(long *)(this + 0x40) = *(long *)(this + 0x38);
}
uStack_8 = CONCAT17(this[0x14],(int7)in_RAX);
/* try { // try from 00140724 to 00140728 has its CatchHandler @ 0014072b */
std::vector<char,std::allocator<char>>::emplace_back<char>
((vector<char,std::allocator<char>> *)(this + 0x38),(char *)((long)&uStack_8 + 7));
return uStack_8;
}
|
|
11,770 |
mysql_set_server_option_start_internal
|
eloqsql/libmariadb/libmariadb/mariadb_async.c
|
static void
mysql_set_server_option_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_set_server_option,
(parms->mysql, parms->option),
parms->mysql,
int,
r_int)
}
|
O0
|
c
|
mysql_set_server_option_start_internal:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x29e30
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
mysql_set_server_option_start_internal:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rdi, [rax]
mov rax, [rbp+var_10]
mov esi, [rax+8]
call mysql_set_server_option
mov [rbp+var_14], eax
mov ecx, [rbp+var_14]
mov rax, [rbp+var_20]
mov [rax+8], ecx
mov rax, [rbp+var_20]
mov dword ptr [rax], 0
add rsp, 20h
pop rbp
retn
|
_DWORD * mysql_set_server_option_start_internal(long long a1)
{
_DWORD *result; // rax
_DWORD *v2; // [rsp+0h] [rbp-20h]
v2 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)a1 + 1152LL) + 40LL);
v2[2] = mysql_set_server_option(*(_QWORD *)a1, *(_DWORD *)(a1 + 8));
result = v2;
*v2 = 0;
return result;
}
|
mysql_set_server_option_start_internal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RAX + 0x8]
CALL 0x00129e30
MOV dword ptr [RBP + -0x14],EAX
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x8],ECX
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],0x0
ADD RSP,0x20
POP RBP
RET
|
void mysql_set_server_option_start_internal(long *param_1)
{
int4 *puVar1;
int4 uVar2;
puVar1 = *(int4 **)(*(long *)(*param_1 + 0x480) + 0x28);
uVar2 = mysql_set_server_option(*param_1,(int)param_1[1]);
puVar1[2] = uVar2;
*puVar1 = 0;
return;
}
|
|
11,771 |
mj_defaultSolRefImp
|
aimrt_mujoco_sim/_deps/mujoco-src/src/engine/engine_io.c
|
void mj_defaultSolRefImp(mjtNum* solref, mjtNum* solimp) {
if (solref) {
solref[0] = 0.02; // timeconst
solref[1] = 1; // dampratio
}
if (solimp) {
solimp[0] = 0.9; // dmin
solimp[1] = 0.95; // dmax
solimp[2] = 0.001; // width
solimp[3] = 0.5; // midpoint
solimp[4] = 2; // power
}
}
|
O0
|
c
|
mj_defaultSolRefImp:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
cmpq $0x0, -0x8(%rsp)
je 0x94495
movq -0x8(%rsp), %rax
vmovsd 0x483839(%rip), %xmm0 # 0x517cb8
vmovsd %xmm0, (%rax)
movq -0x8(%rsp), %rax
vmovsd 0x4836c8(%rip), %xmm0 # 0x517b58
vmovsd %xmm0, 0x8(%rax)
cmpq $0x0, -0x10(%rsp)
je 0x944f6
movq -0x10(%rsp), %rax
vmovsd 0x483816(%rip), %xmm0 # 0x517cc0
vmovsd %xmm0, (%rax)
movq -0x10(%rsp), %rax
vmovsd 0x4836fd(%rip), %xmm0 # 0x517bb8
vmovsd %xmm0, 0x8(%rax)
movq -0x10(%rsp), %rax
vmovsd 0x4836b3(%rip), %xmm0 # 0x517b80
vmovsd %xmm0, 0x10(%rax)
movq -0x10(%rsp), %rax
vmovsd 0x483659(%rip), %xmm0 # 0x517b38
vmovsd %xmm0, 0x18(%rax)
movq -0x10(%rsp), %rax
vmovsd 0x48364f(%rip), %xmm0 # 0x517b40
vmovsd %xmm0, 0x20(%rax)
retq
nopw (%rax,%rax)
|
mj_defaultSolRefImp:
mov [rsp+var_8], rdi
mov [rsp+var_10], rsi
cmp [rsp+var_8], 0
jz short loc_94495
mov rax, [rsp+var_8]
vmovsd xmm0, cs:qword_517CB8
vmovsd qword ptr [rax], xmm0
mov rax, [rsp+var_8]
vmovsd xmm0, cs:qword_517B58
vmovsd qword ptr [rax+8], xmm0
loc_94495:
cmp [rsp+var_10], 0
jz short locret_944F6
mov rax, [rsp+var_10]
vmovsd xmm0, cs:qword_517CC0
vmovsd qword ptr [rax], xmm0
mov rax, [rsp+var_10]
vmovsd xmm0, cs:qword_517BB8
vmovsd qword ptr [rax+8], xmm0
mov rax, [rsp+var_10]
vmovsd xmm0, cs:qword_517B80
vmovsd qword ptr [rax+10h], xmm0
mov rax, [rsp+var_10]
vmovsd xmm0, cs:qword_517B38
vmovsd qword ptr [rax+18h], xmm0
mov rax, [rsp+var_10]
vmovsd xmm0, cs:qword_517B40
vmovsd qword ptr [rax+20h], xmm0
locret_944F6:
retn
|
long long mj_defaultSolRefImp(long long a1, long long a2)
{
long long result; // rax
if ( a1 )
{
_RAX = a1;
__asm
{
vmovsd xmm0, cs:qword_517CB8
vmovsd qword ptr [rax], xmm0
}
result = a1;
__asm
{
vmovsd xmm0, cs:qword_517B58
vmovsd qword ptr [rax+8], xmm0
}
}
if ( a2 )
{
_RAX = a2;
__asm
{
vmovsd xmm0, cs:qword_517CC0
vmovsd qword ptr [rax], xmm0
}
_RAX = a2;
__asm
{
vmovsd xmm0, cs:qword_517BB8
vmovsd qword ptr [rax+8], xmm0
}
_RAX = a2;
__asm
{
vmovsd xmm0, cs:qword_517B80
vmovsd qword ptr [rax+10h], xmm0
}
_RAX = a2;
__asm
{
vmovsd xmm0, cs:qword_517B38
vmovsd qword ptr [rax+18h], xmm0
}
result = a2;
__asm
{
vmovsd xmm0, cs:qword_517B40
vmovsd qword ptr [rax+20h], xmm0
}
}
return result;
}
|
mj_defaultSolRefImp:
MOV qword ptr [RSP + -0x8],RDI
MOV qword ptr [RSP + -0x10],RSI
CMP qword ptr [RSP + -0x8],0x0
JZ 0x00194495
MOV RAX,qword ptr [RSP + -0x8]
VMOVSD XMM0,qword ptr [0x00617cb8]
VMOVSD qword ptr [RAX],XMM0
MOV RAX,qword ptr [RSP + -0x8]
VMOVSD XMM0,qword ptr [0x00617b58]
VMOVSD qword ptr [RAX + 0x8],XMM0
LAB_00194495:
CMP qword ptr [RSP + -0x10],0x0
JZ 0x001944f6
MOV RAX,qword ptr [RSP + -0x10]
VMOVSD XMM0,qword ptr [0x00617cc0]
VMOVSD qword ptr [RAX],XMM0
MOV RAX,qword ptr [RSP + -0x10]
VMOVSD XMM0,qword ptr [0x00617bb8]
VMOVSD qword ptr [RAX + 0x8],XMM0
MOV RAX,qword ptr [RSP + -0x10]
VMOVSD XMM0,qword ptr [0x00617b80]
VMOVSD qword ptr [RAX + 0x10],XMM0
MOV RAX,qword ptr [RSP + -0x10]
VMOVSD XMM0,qword ptr [0x00617b38]
VMOVSD qword ptr [RAX + 0x18],XMM0
MOV RAX,qword ptr [RSP + -0x10]
VMOVSD XMM0,qword ptr [0x00617b40]
VMOVSD qword ptr [RAX + 0x20],XMM0
LAB_001944f6:
RET
|
void mj_defaultSolRefImp(int8 *param_1,int8 *param_2)
{
if (param_1 != (int8 *)0x0) {
*param_1 = DAT_00617cb8;
param_1[1] = DAT_00617b58;
}
if (param_2 != (int8 *)0x0) {
*param_2 = DAT_00617cc0;
param_2[1] = DAT_00617bb8;
param_2[2] = DAT_00617b80;
param_2[3] = DAT_00617b38;
param_2[4] = DAT_00617b40;
}
return;
}
|
|
11,772 |
diff
|
eloqsql/strings/dtoa.c
|
static Bigint *diff(Bigint *a, Bigint *b, Stack_alloc *alloc)
{
Bigint *c;
int i, wa, wb;
ULong *xa, *xae, *xb, *xbe, *xc;
ULLong borrow, y;
i= cmp(a,b);
if (!i)
{
c= Balloc(0, alloc);
c->wds= 1;
c->p.x[0]= 0;
return c;
}
if (i < 0)
{
c= a;
a= b;
b= c;
i= 1;
}
else
i= 0;
c= Balloc(a->k, alloc);
c->sign= i;
wa= a->wds;
xa= a->p.x;
xae= xa + wa;
wb= b->wds;
xb= b->p.x;
xbe= xb + wb;
xc= c->p.x;
borrow= 0;
do
{
y= (ULLong)*xa++ - *xb++ - borrow;
borrow= y >> 32 & (ULong)1;
*xc++= (ULong) (y & FFFFFFFF);
}
while (xb < xbe);
while (xa < xae)
{
y= *xa++ - borrow;
borrow= y >> 32 & (ULong)1;
*xc++= (ULong) (y & FFFFFFFF);
}
while (!*--xc)
wa--;
c->wds= wa;
return c;
}
|
O0
|
c
|
diff:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x73080
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x72ebe
movq -0x20(%rbp), %rsi
xorl %edi, %edi
callq 0x72590
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x1, 0x14(%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movl $0x0, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7306a
cmpl $0x0, -0x2c(%rbp)
jge 0x72ee5
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x1, -0x2c(%rbp)
jmp 0x72eec
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x20(%rbp), %rsi
callq 0x72590
movq %rax, -0x28(%rbp)
movl -0x2c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movslq -0x30(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movslq -0x34(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movq $0x0, -0x68(%rbp)
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x40(%rbp)
movl (%rax), %eax
movq -0x50(%rbp), %rcx
movq %rcx, %rdx
addq $0x4, %rdx
movq %rdx, -0x50(%rbp)
movl (%rcx), %ecx
subq %rcx, %rax
subq -0x68(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
shrq $0x20, %rax
andq $0x1, %rax
movq %rax, -0x68(%rbp)
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq -0x70(%rbp), %rax
movl %eax, %ecx
movq -0x60(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x60(%rbp)
movl %ecx, (%rax)
movq -0x50(%rbp), %rax
cmpq -0x58(%rbp), %rax
jb 0x72f6d
jmp 0x72fd7
movq -0x40(%rbp), %rax
cmpq -0x48(%rbp), %rax
jae 0x7302d
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x40(%rbp)
movl (%rax), %eax
subq -0x68(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
shrq $0x20, %rax
andq $0x1, %rax
movq %rax, -0x68(%rbp)
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq -0x70(%rbp), %rax
movl %eax, %ecx
movq -0x60(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x60(%rbp)
movl %ecx, (%rax)
jmp 0x72fd7
jmp 0x7302f
movq -0x60(%rbp), %rax
movq %rax, %rcx
addq $-0x4, %rcx
movq %rcx, -0x60(%rbp)
cmpl $0x0, -0x4(%rax)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x7304d
jmp 0x73058
movl -0x30(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x7302f
movl -0x30(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
diff:
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call cmp
mov [rbp+var_2C], eax
cmp [rbp+var_2C], 0
jnz short loc_72EBE
mov rsi, [rbp+var_20]
xor edi, edi
call Balloc
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
mov dword ptr [rax+14h], 1
mov rax, [rbp+var_28]
mov rax, [rax]
mov dword ptr [rax], 0
mov rax, [rbp+var_28]
mov [rbp+var_8], rax
jmp loc_7306A
loc_72EBE:
cmp [rbp+var_2C], 0
jge short loc_72EE5
mov rax, [rbp+var_10]
mov [rbp+var_28], rax
mov rax, [rbp+var_18]
mov [rbp+var_10], rax
mov rax, [rbp+var_28]
mov [rbp+var_18], rax
mov [rbp+var_2C], 1
jmp short loc_72EEC
loc_72EE5:
mov [rbp+var_2C], 0
loc_72EEC:
mov rax, [rbp+var_10]
mov edi, [rax+8]
mov rsi, [rbp+var_20]
call Balloc
mov [rbp+var_28], rax
mov ecx, [rbp+var_2C]
mov rax, [rbp+var_28]
mov [rax+10h], ecx
mov rax, [rbp+var_10]
mov eax, [rax+14h]
mov [rbp+var_30], eax
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
movsxd rcx, [rbp+var_30]
shl rcx, 2
add rax, rcx
mov [rbp+var_48], rax
mov rax, [rbp+var_18]
mov eax, [rax+14h]
mov [rbp+var_34], eax
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rbp+var_50], rax
mov rax, [rbp+var_50]
movsxd rcx, [rbp+var_34]
shl rcx, 2
add rax, rcx
mov [rbp+var_58], rax
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rbp+var_60], rax
mov [rbp+var_68], 0
loc_72F6D:
mov rax, [rbp+var_40]
mov rcx, rax
add rcx, 4
mov [rbp+var_40], rcx
mov eax, [rax]
mov rcx, [rbp+var_50]
mov rdx, rcx
add rdx, 4
mov [rbp+var_50], rdx
mov ecx, [rcx]
sub rax, rcx
sub rax, [rbp+var_68]
mov [rbp+var_70], rax
mov rax, [rbp+var_70]
shr rax, 20h
and rax, 1
mov [rbp+var_68], rax
mov rax, 0FFFFFFFFh
and rax, [rbp+var_70]
mov ecx, eax
mov rax, [rbp+var_60]
mov rdx, rax
add rdx, 4
mov [rbp+var_60], rdx
mov [rax], ecx
mov rax, [rbp+var_50]
cmp rax, [rbp+var_58]
jb short loc_72F6D
jmp short $+2
loc_72FD7:
mov rax, [rbp+var_40]
cmp rax, [rbp+var_48]
jnb short loc_7302D
mov rax, [rbp+var_40]
mov rcx, rax
add rcx, 4
mov [rbp+var_40], rcx
mov eax, [rax]
sub rax, [rbp+var_68]
mov [rbp+var_70], rax
mov rax, [rbp+var_70]
shr rax, 20h
and rax, 1
mov [rbp+var_68], rax
mov rax, 0FFFFFFFFh
and rax, [rbp+var_70]
mov ecx, eax
mov rax, [rbp+var_60]
mov rdx, rax
add rdx, 4
mov [rbp+var_60], rdx
mov [rax], ecx
jmp short loc_72FD7
loc_7302D:
jmp short $+2
loc_7302F:
mov rax, [rbp+var_60]
mov rcx, rax
add rcx, 0FFFFFFFFFFFFFFFCh
mov [rbp+var_60], rcx
cmp dword ptr [rax-4], 0
setnz al
xor al, 0FFh
test al, 1
jnz short loc_7304D
jmp short loc_73058
loc_7304D:
mov eax, [rbp+var_30]
add eax, 0FFFFFFFFh
mov [rbp+var_30], eax
jmp short loc_7302F
loc_73058:
mov ecx, [rbp+var_30]
mov rax, [rbp+var_28]
mov [rax+14h], ecx
mov rax, [rbp+var_28]
mov [rbp+var_8], rax
loc_7306A:
mov rax, [rbp+var_8]
add rsp, 70h
pop rbp
retn
|
long long diff(unsigned int **a1, unsigned int **a2, long long a3)
{
unsigned int *v3; // rax
unsigned int *v4; // rcx
_DWORD *v5; // rax
unsigned int *v6; // rax
_DWORD *v7; // rax
_DWORD *v8; // rax
unsigned long long v10; // [rsp+0h] [rbp-70h]
unsigned long long v11; // [rsp+0h] [rbp-70h]
long long v12; // [rsp+8h] [rbp-68h]
_DWORD *v13; // [rsp+10h] [rbp-60h]
unsigned long long v14; // [rsp+18h] [rbp-58h]
unsigned int *v15; // [rsp+20h] [rbp-50h]
unsigned long long v16; // [rsp+28h] [rbp-48h]
unsigned int *v17; // [rsp+30h] [rbp-40h]
int v18; // [rsp+40h] [rbp-30h]
int v19; // [rsp+44h] [rbp-2Ch]
int v20; // [rsp+44h] [rbp-2Ch]
long long v21; // [rsp+48h] [rbp-28h]
long long v22; // [rsp+48h] [rbp-28h]
unsigned int **v24; // [rsp+58h] [rbp-18h]
unsigned int **v25; // [rsp+60h] [rbp-10h]
v25 = a1;
v24 = a2;
v19 = cmp(a1, a2);
if ( v19 )
{
if ( v19 >= 0 )
{
v20 = 0;
}
else
{
v25 = a2;
v24 = a1;
v20 = 1;
}
v22 = Balloc(*((_DWORD *)v25 + 2), a3);
*(_DWORD *)(v22 + 16) = v20;
v18 = *((_DWORD *)v25 + 5);
v17 = *v25;
v16 = (unsigned long long)&(*v25)[v18];
v15 = *v24;
v14 = (unsigned long long)&(*v24)[*((int *)v24 + 5)];
v13 = *(_DWORD **)v22;
v12 = 0LL;
do
{
v3 = v17++;
v4 = v15++;
v10 = *v3 - (unsigned long long)*v4 - v12;
v12 = HIDWORD(v10) & 1;
v5 = v13++;
*v5 = v10;
}
while ( (unsigned long long)v15 < v14 );
while ( (unsigned long long)v17 < v16 )
{
v6 = v17++;
v11 = *v6 - v12;
v12 = HIDWORD(v11) & 1;
v7 = v13++;
*v7 = v11;
}
while ( 1 )
{
v8 = v13--;
if ( *(v8 - 1) )
break;
--v18;
}
*(_DWORD *)(v22 + 20) = v18;
return v22;
}
else
{
v21 = Balloc(0, a3);
*(_DWORD *)(v21 + 20) = 1;
**(_DWORD **)v21 = 0;
return v21;
}
}
|
diff:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00173080
MOV dword ptr [RBP + -0x2c],EAX
CMP dword ptr [RBP + -0x2c],0x0
JNZ 0x00172ebe
MOV RSI,qword ptr [RBP + -0x20]
XOR EDI,EDI
CALL 0x00172590
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX + 0x14],0x1
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV dword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0017306a
LAB_00172ebe:
CMP dword ptr [RBP + -0x2c],0x0
JGE 0x00172ee5
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x2c],0x1
JMP 0x00172eec
LAB_00172ee5:
MOV dword ptr [RBP + -0x2c],0x0
LAB_00172eec:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDI,dword ptr [RAX + 0x8]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x00172590
MOV qword ptr [RBP + -0x28],RAX
MOV ECX,dword ptr [RBP + -0x2c]
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x14]
MOV dword ptr [RBP + -0x30],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOVSXD RCX,dword ptr [RBP + -0x30]
SHL RCX,0x2
ADD RAX,RCX
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x14]
MOV dword ptr [RBP + -0x34],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOVSXD RCX,dword ptr [RBP + -0x34]
SHL RCX,0x2
ADD RAX,RCX
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x60],RAX
MOV qword ptr [RBP + -0x68],0x0
LAB_00172f6d:
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,RAX
ADD RCX,0x4
MOV qword ptr [RBP + -0x40],RCX
MOV EAX,dword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x50]
MOV RDX,RCX
ADD RDX,0x4
MOV qword ptr [RBP + -0x50],RDX
MOV ECX,dword ptr [RCX]
SUB RAX,RCX
SUB RAX,qword ptr [RBP + -0x68]
MOV qword ptr [RBP + -0x70],RAX
MOV RAX,qword ptr [RBP + -0x70]
SHR RAX,0x20
AND RAX,0x1
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,0xffffffff
AND RAX,qword ptr [RBP + -0x70]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x60]
MOV RDX,RAX
ADD RDX,0x4
MOV qword ptr [RBP + -0x60],RDX
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x50]
CMP RAX,qword ptr [RBP + -0x58]
JC 0x00172f6d
JMP 0x00172fd7
LAB_00172fd7:
MOV RAX,qword ptr [RBP + -0x40]
CMP RAX,qword ptr [RBP + -0x48]
JNC 0x0017302d
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,RAX
ADD RCX,0x4
MOV qword ptr [RBP + -0x40],RCX
MOV EAX,dword ptr [RAX]
SUB RAX,qword ptr [RBP + -0x68]
MOV qword ptr [RBP + -0x70],RAX
MOV RAX,qword ptr [RBP + -0x70]
SHR RAX,0x20
AND RAX,0x1
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,0xffffffff
AND RAX,qword ptr [RBP + -0x70]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x60]
MOV RDX,RAX
ADD RDX,0x4
MOV qword ptr [RBP + -0x60],RDX
MOV dword ptr [RAX],ECX
JMP 0x00172fd7
LAB_0017302d:
JMP 0x0017302f
LAB_0017302f:
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,RAX
ADD RCX,-0x4
MOV qword ptr [RBP + -0x60],RCX
CMP dword ptr [RAX + -0x4],0x0
SETNZ AL
XOR AL,0xff
TEST AL,0x1
JNZ 0x0017304d
JMP 0x00173058
LAB_0017304d:
MOV EAX,dword ptr [RBP + -0x30]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x30],EAX
JMP 0x0017302f
LAB_00173058:
MOV ECX,dword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX + 0x14],ECX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x8],RAX
LAB_0017306a:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x70
POP RBP
RET
|
int8 * diff(int8 *param_1,int8 *param_2,int8 param_3)
{
uint *puVar1;
uint *puVar2;
int iVar3;
ulong uVar4;
uint *puVar5;
uint *puVar6;
int4 *puVar7;
ulong local_70;
int4 *local_68;
uint *local_58;
uint *local_48;
int local_38;
uint local_34;
int8 *local_20;
int8 *local_18;
int8 *local_10;
iVar3 = cmp(param_1,param_2);
if (iVar3 == 0) {
local_10 = (int8 *)Balloc(0,param_3);
*(int4 *)((long)local_10 + 0x14) = 1;
*(int4 *)*local_10 = 0;
}
else {
local_20 = param_2;
local_18 = param_1;
if (iVar3 < 0) {
local_20 = param_1;
local_18 = param_2;
}
local_34 = (uint)(iVar3 < 0);
local_10 = (int8 *)Balloc(*(int4 *)(local_18 + 1),param_3);
*(uint *)(local_10 + 2) = local_34;
local_38 = *(int *)((long)local_18 + 0x14);
puVar1 = (uint *)*local_18;
iVar3 = *(int *)((long)local_20 + 0x14);
puVar2 = (uint *)*local_20;
local_70 = 0;
local_68 = (int4 *)*local_10;
local_58 = puVar2;
local_48 = puVar1;
do {
puVar5 = local_48 + 1;
puVar6 = local_58 + 1;
uVar4 = ((ulong)*local_48 - (ulong)*local_58) - local_70;
local_70 = uVar4 >> 0x20 & 1;
puVar7 = local_68 + 1;
*local_68 = (int)uVar4;
local_68 = puVar7;
local_58 = puVar6;
local_48 = puVar5;
} while (puVar6 < puVar2 + iVar3);
while (local_48 < puVar1 + local_38) {
uVar4 = *local_48 - local_70;
local_70 = uVar4 >> 0x20 & 1;
*local_68 = (int)uVar4;
local_68 = local_68 + 1;
local_48 = local_48 + 1;
}
while (local_68[-1] == 0) {
local_38 = local_38 + -1;
local_68 = local_68 + -1;
}
*(int *)((long)local_10 + 0x14) = local_38;
}
return local_10;
}
|
|
11,773 |
alaya::SearchTest_SearchHNSWTestSQSpace_Test::TestBody()
|
AlayaLite/tests/executor/search_test.cpp
|
TEST_F(SearchTest, SearchHNSWTestSQSpace) {
const size_t kM = 64;
size_t topk = 10;
size_t ef = 100;
std::string index_type = "HNSW";
std::filesystem::path index_file =
fmt::format("{}_M{}_SQ.{}", dir_name_.string(), kM, index_type);
auto load_graph = std::make_shared<alaya::Graph<>>(points_num_, kM);
if (!std::filesystem::exists(index_file)) {
std::shared_ptr<alaya::RawSpace<>> build_graph_space =
std::make_shared<alaya::RawSpace<>>(points_num_, dim_, MetricType::L2);
build_graph_space->fit(data_.data(), points_num_);
auto build_start = std::chrono::steady_clock::now();
alaya::HNSWBuilder<alaya::RawSpace<>> hnsw =
alaya::HNSWBuilder<alaya::RawSpace<>>(build_graph_space);
auto hnsw_graph = hnsw.build_graph();
auto build_end = std::chrono::steady_clock::now();
auto build_time = static_cast<std::chrono::duration<double>>(build_end - build_start).count();
LOG_INFO("The time of building hnsw is {}s.", build_time);
std::string_view path = index_file.native();
hnsw_graph->save(path);
}
}
|
O0
|
cpp
|
alaya::SearchTest_SearchHNSWTestSQSpace_Test::TestBody():
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x1f580
movq 0x8(%rsp), %rax
leaq 0x1a9a3c(%rip), %rcx # 0x1cbbd0
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x18, %rsp
retq
|
_ZN5alaya37SearchTest_SearchHNSWTestSQSpace_TestC2Ev:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov rdi, [rsp+18h+var_8]; this
mov [rsp+18h+var_10], rdi
call _ZN5alaya10SearchTestC2Ev; alaya::SearchTest::SearchTest(void)
mov rax, [rsp+18h+var_10]
lea rcx, _ZTVN5alaya37SearchTest_SearchHNSWTestSQSpace_TestE; `vtable for'alaya::SearchTest_SearchHNSWTestSQSpace_Test
add rcx, 10h
mov [rax], rcx
add rsp, 18h
retn
|
alaya::SearchTest_SearchHNSWTestSQSpace_Test * alaya::SearchTest_SearchHNSWTestSQSpace_Test::SearchTest_SearchHNSWTestSQSpace_Test(
alaya::SearchTest_SearchHNSWTestSQSpace_Test *this)
{
alaya::SearchTest_SearchHNSWTestSQSpace_Test *result; // rax
alaya::SearchTest::SearchTest(this);
result = this;
*(_QWORD *)this = &`vtable for'alaya::SearchTest_SearchHNSWTestSQSpace_Test + 2;
return result;
}
|
SearchTest_SearchHNSWTestSQSpace_Test:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV RDI,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x8],RDI
CALL 0x0011f580
MOV RAX,qword ptr [RSP + 0x8]
LEA RCX,[0x2cbbd0]
ADD RCX,0x10
MOV qword ptr [RAX],RCX
ADD RSP,0x18
RET
|
/* alaya::SearchTest_SearchHNSWTestSQSpace_Test::SearchTest_SearchHNSWTestSQSpace_Test() */
void __thiscall
alaya::SearchTest_SearchHNSWTestSQSpace_Test::SearchTest_SearchHNSWTestSQSpace_Test
(SearchTest_SearchHNSWTestSQSpace_Test *this)
{
SearchTest::SearchTest((SearchTest *)this);
*(int ***)this = &PTR__SearchTest_SearchHNSWTestSQSpace_Test_002cbbe0;
return;
}
|
|
11,774 |
js_init_module_bjson
|
bluesky950520[P]quickjs/quickjs-libc.c
|
JSModuleDef *js_init_module_bjson(JSContext *ctx, const char *module_name)
{
JSModuleDef *m;
m = JS_NewCModule(ctx, module_name, js_bjson_init);
if (!m)
return NULL;
JS_AddModuleExportList(ctx, m, js_bjson_funcs, countof(js_bjson_funcs));
return m;
}
|
O0
|
c
|
js_init_module_bjson:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0x51(%rip), %rdx # 0x12690
callq 0x49520
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x1265c
movq $0x0, 0x20(%rsp)
jmp 0x12681
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0x11dfd3(%rip), %rdx # 0x130640
movl $0xa, %ecx
callq 0x4d300
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
|
js_init_module_bjson:
sub rsp, 28h
mov [rsp+28h+var_10], rdi
mov [rsp+28h+var_18], rsi
mov rdi, [rsp+28h+var_10]
mov rsi, [rsp+28h+var_18]
lea rdx, js_bjson_init
call JS_NewCModule
mov [rsp+28h+var_20], rax
cmp [rsp+28h+var_20], 0
jnz short loc_1265C
mov [rsp+28h+var_8], 0
jmp short loc_12681
loc_1265C:
mov rdi, [rsp+28h+var_10]
mov rsi, [rsp+28h+var_20]
lea rdx, js_bjson_funcs
mov ecx, 0Ah
call JS_AddModuleExportList
mov rax, [rsp+28h+var_20]
mov [rsp+28h+var_8], rax
loc_12681:
mov rax, [rsp+28h+var_8]
add rsp, 28h
retn
|
long long js_init_module_bjson(long long a1, long long a2)
{
long long v3; // [rsp+8h] [rbp-20h]
v3 = JS_NewCModule(a1, a2, js_bjson_init);
if ( !v3 )
return 0LL;
JS_AddModuleExportList(a1, v3, &js_bjson_funcs, 10LL);
return v3;
}
|
js_init_module_bjson:
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RDI
MOV qword ptr [RSP + 0x10],RSI
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x10]
LEA RDX,[0x112690]
CALL 0x00149520
MOV qword ptr [RSP + 0x8],RAX
CMP qword ptr [RSP + 0x8],0x0
JNZ 0x0011265c
MOV qword ptr [RSP + 0x20],0x0
JMP 0x00112681
LAB_0011265c:
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x8]
LEA RDX,[0x230640]
MOV ECX,0xa
CALL 0x0014d300
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x20],RAX
LAB_00112681:
MOV RAX,qword ptr [RSP + 0x20]
ADD RSP,0x28
RET
|
long js_init_module_bjson(int8 param_1,int8 param_2)
{
long local_8;
local_8 = JS_NewCModule(param_1,param_2,js_bjson_init);
if (local_8 == 0) {
local_8 = 0;
}
else {
JS_AddModuleExportList(param_1,local_8,js_bjson_funcs,10);
}
return local_8;
}
|
|
11,775 |
js_init_module_bjson
|
bluesky950520[P]quickjs/quickjs-libc.c
|
JSModuleDef *js_init_module_bjson(JSContext *ctx, const char *module_name)
{
JSModuleDef *m;
m = JS_NewCModule(ctx, module_name, js_bjson_init);
if (!m)
return NULL;
JS_AddModuleExportList(ctx, m, js_bjson_funcs, countof(js_bjson_funcs));
return m;
}
|
O1
|
c
|
js_init_module_bjson:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x33(%rip), %rdx # 0x15d66
callq 0x30853
testq %rax, %rax
je 0x15d59
movq %rax, %rbx
leaq 0xb17a9(%rip), %rdx # 0xc74f0
movq %r14, %rdi
movq %rax, %rsi
movl $0xa, %ecx
callq 0x33050
jmp 0x15d5b
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
js_init_module_bjson:
push r14
push rbx
push rax
mov r14, rdi
lea rdx, js_bjson_init
call JS_NewCModule
test rax, rax
jz short loc_15D59
mov rbx, rax
lea rdx, js_bjson_funcs
mov rdi, r14
mov rsi, rax
mov ecx, 0Ah
call JS_AddModuleExportList
jmp short loc_15D5B
loc_15D59:
xor ebx, ebx
loc_15D5B:
mov rax, rbx
add rsp, 8
pop rbx
pop r14
retn
|
long long js_init_module_bjson(long long a1, long long a2)
{
long long v2; // rax
long long v3; // rbx
v2 = JS_NewCModule(a1, a2, js_bjson_init);
if ( !v2 )
return 0LL;
v3 = v2;
JS_AddModuleExportList(a1, v2, &js_bjson_funcs, 10LL);
return v3;
}
|
js_init_module_bjson:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RDI
LEA RDX,[0x115d66]
CALL 0x00130853
TEST RAX,RAX
JZ 0x00115d59
MOV RBX,RAX
LEA RDX,[0x1c74f0]
MOV RDI,R14
MOV RSI,RAX
MOV ECX,0xa
CALL 0x00133050
JMP 0x00115d5b
LAB_00115d59:
XOR EBX,EBX
LAB_00115d5b:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R14
RET
|
long js_init_module_bjson(int8 param_1,int8 param_2)
{
long lVar1;
lVar1 = JS_NewCModule(param_1,param_2,js_bjson_init);
if (lVar1 == 0) {
lVar1 = 0;
}
else {
JS_AddModuleExportList(param_1,lVar1,js_bjson_funcs,10);
}
return lVar1;
}
|
|
11,776 |
js_init_module_bjson
|
bluesky950520[P]quickjs/quickjs-libc.c
|
JSModuleDef *js_init_module_bjson(JSContext *ctx, const char *module_name)
{
JSModuleDef *m;
m = JS_NewCModule(ctx, module_name, js_bjson_init);
if (!m)
return NULL;
JS_AddModuleExportList(ctx, m, js_bjson_funcs, countof(js_bjson_funcs));
return m;
}
|
O2
|
c
|
js_init_module_bjson:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2d(%rip), %rdx # 0x10c1b
callq 0x28e4b
movq %rax, %r14
testq %rax, %rax
je 0x10c10
leaq 0xa496e(%rip), %rdx # 0xb5570
pushq $0xa
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2c74a
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
js_init_module_bjson:
push r14
push rbx
push rax
mov rbx, rdi
lea rdx, js_bjson_init
call JS_NewCModule
mov r14, rax
test rax, rax
jz short loc_10C10
lea rdx, js_bjson_funcs
push 0Ah
pop rcx
mov rdi, rbx
mov rsi, r14
call JS_AddModuleExportList
loc_10C10:
mov rax, r14
add rsp, 8
pop rbx
pop r14
retn
|
long long js_init_module_bjson(long long a1, long long a2)
{
long long v2; // rax
long long v3; // r14
v2 = JS_NewCModule(a1, a2, js_bjson_init);
v3 = v2;
if ( v2 )
JS_AddModuleExportList(a1, v2, &js_bjson_funcs, 10LL);
return v3;
}
|
js_init_module_bjson:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
LEA RDX,[0x110c1b]
CALL 0x00128e4b
MOV R14,RAX
TEST RAX,RAX
JZ 0x00110c10
LEA RDX,[0x1b5570]
PUSH 0xa
POP RCX
MOV RDI,RBX
MOV RSI,R14
CALL 0x0012c74a
LAB_00110c10:
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R14
RET
|
long js_init_module_bjson(int8 param_1,int8 param_2)
{
long lVar1;
lVar1 = JS_NewCModule(param_1,param_2,js_bjson_init);
if (lVar1 != 0) {
JS_AddModuleExportList(param_1,lVar1,js_bjson_funcs,10);
}
return lVar1;
}
|
|
11,777 |
fmt::v10::basic_memory_buffer<unsigned int, 32ul, std::allocator<unsigned int>>::move(fmt::v10::basic_memory_buffer<unsigned int, 32ul, std::allocator<unsigned int>>&)
|
aimrt_mujoco_sim/_deps/fmt-src/include/fmt/format.h
|
FMT_CONSTEXPR20 void move(basic_memory_buffer& other) {
alloc_ = std::move(other.alloc_);
T* data = other.data();
size_t size = other.size(), capacity = other.capacity();
if (data == other.store_) {
this->set(store_, capacity);
detail::copy_str<T>(other.store_, other.store_ + size, store_);
} else {
this->set(data, capacity);
// Set pointer to the inline array so that delete is not called
// when deallocating.
other.set(other.store_, 0);
other.clear();
}
this->resize(size);
}
|
O0
|
c
|
fmt::v10::basic_memory_buffer<unsigned int, 32ul, std::allocator<unsigned int>>::move(fmt::v10::basic_memory_buffer<unsigned int, 32ul, std::allocator<unsigned int>>&):
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0xb5d80
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0xb5dd0
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0xb5d70
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
addq $0x20, %rcx
cmpq %rcx, %rax
jne 0xb699c
movq 0x8(%rsp), %rdi
movq %rdi, %rsi
addq $0x20, %rsi
movq 0x10(%rsp), %rdx
callq 0xb5ba0
movq 0x8(%rsp), %rdx
movq 0x28(%rsp), %rdi
addq $0x20, %rdi
movq 0x28(%rsp), %rsi
addq $0x20, %rsi
movq 0x18(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rsi
addq $0x20, %rdx
callq 0xb69f0
jmp 0xb69d1
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0xb5ba0
movq 0x28(%rsp), %rdi
movq 0x28(%rsp), %rsi
addq $0x20, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xb5ba0
movq 0x28(%rsp), %rdi
callq 0xb6a40
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xb6230
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
|
_ZN3fmt3v1019basic_memory_bufferIjLm32ESaIjEE4moveERS3_:
sub rsp, 38h
mov [rsp+38h+var_8], rdi
mov [rsp+38h+var_10], rsi
mov rax, [rsp+38h+var_8]
mov [rsp+38h+var_30], rax
mov rdi, [rsp+38h+var_10]
call _ZN3fmt3v106detail6bufferIjE4dataEv; fmt::v10::detail::buffer<uint>::data(void)
mov [rsp+38h+var_18], rax
mov rdi, [rsp+38h+var_10]
call _ZNK3fmt3v106detail6bufferIjE4sizeEv; fmt::v10::detail::buffer<uint>::size(void)
mov [rsp+38h+var_20], rax
mov rdi, [rsp+38h+var_10]
call _ZNK3fmt3v106detail6bufferIjE8capacityEv; fmt::v10::detail::buffer<uint>::capacity(void)
mov [rsp+38h+var_28], rax
mov rax, [rsp+38h+var_18]
mov rcx, [rsp+38h+var_10]
add rcx, 20h ; ' '
cmp rax, rcx
jnz short loc_B699C
mov rdi, [rsp+38h+var_30]
mov rsi, rdi
add rsi, 20h ; ' '
mov rdx, [rsp+38h+var_28]
call _ZN3fmt3v106detail6bufferIjE3setEPjm; fmt::v10::detail::buffer<uint>::set(uint *,ulong)
mov rdx, [rsp+38h+var_30]
mov rdi, [rsp+38h+var_10]
add rdi, 20h ; ' '
mov rsi, [rsp+38h+var_10]
add rsi, 20h ; ' '
mov rax, [rsp+38h+var_20]
shl rax, 2
add rsi, rax
add rdx, 20h ; ' '
call _ZN3fmt3v106detail8copy_strIjPjS3_EET1_T0_S5_S4_; fmt::v10::detail::copy_str<uint,uint *,uint *>(uint *,uint *,uint *)
jmp short loc_B69D1
loc_B699C:
mov rdi, [rsp+38h+var_30]
mov rsi, [rsp+38h+var_18]
mov rdx, [rsp+38h+var_28]
call _ZN3fmt3v106detail6bufferIjE3setEPjm; fmt::v10::detail::buffer<uint>::set(uint *,ulong)
mov rdi, [rsp+38h+var_10]
mov rsi, [rsp+38h+var_10]
add rsi, 20h ; ' '
xor eax, eax
mov edx, eax
call _ZN3fmt3v106detail6bufferIjE3setEPjm; fmt::v10::detail::buffer<uint>::set(uint *,ulong)
mov rdi, [rsp+38h+var_10]
call _ZN3fmt3v106detail6bufferIjE5clearEv; fmt::v10::detail::buffer<uint>::clear(void)
loc_B69D1:
mov rdi, [rsp+38h+var_30]
mov rsi, [rsp+38h+var_20]
call _ZN3fmt3v1019basic_memory_bufferIjLm32ESaIjEE6resizeEm; fmt::v10::basic_memory_buffer<uint,32ul,std::allocator<uint>>::resize(ulong)
add rsp, 38h
retn
|
long long fmt::v10::basic_memory_buffer<unsigned int,32ul,std::allocator<unsigned int>>::move(
long long a1,
long long a2)
{
long long v3; // [rsp+10h] [rbp-28h]
long long v4; // [rsp+18h] [rbp-20h]
long long v5; // [rsp+20h] [rbp-18h]
v5 = fmt::v10::detail::buffer<unsigned int>::data(a2);
v4 = fmt::v10::detail::buffer<unsigned int>::size(a2);
v3 = fmt::v10::detail::buffer<unsigned int>::capacity(a2);
if ( v5 == a2 + 32 )
{
fmt::v10::detail::buffer<unsigned int>::set(a1, a1 + 32, v3);
fmt::v10::detail::copy_str<unsigned int,unsigned int *,unsigned int *>(a2 + 32, 4 * v4 + a2 + 32, a1 + 32);
}
else
{
fmt::v10::detail::buffer<unsigned int>::set(a1, v5, v3);
fmt::v10::detail::buffer<unsigned int>::set(a2, a2 + 32, 0LL);
fmt::v10::detail::buffer<unsigned int>::clear(a2);
}
return fmt::v10::basic_memory_buffer<unsigned int,32ul,std::allocator<unsigned int>>::resize(a1, v4);
}
|
move:
SUB RSP,0x38
MOV qword ptr [RSP + 0x30],RDI
MOV qword ptr [RSP + 0x28],RSI
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x001b5d80
MOV qword ptr [RSP + 0x20],RAX
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x001b5dd0
MOV qword ptr [RSP + 0x18],RAX
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x001b5d70
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [RSP + 0x28]
ADD RCX,0x20
CMP RAX,RCX
JNZ 0x001b699c
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,RDI
ADD RSI,0x20
MOV RDX,qword ptr [RSP + 0x10]
CALL 0x001b5ba0
MOV RDX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RSP + 0x28]
ADD RDI,0x20
MOV RSI,qword ptr [RSP + 0x28]
ADD RSI,0x20
MOV RAX,qword ptr [RSP + 0x18]
SHL RAX,0x2
ADD RSI,RAX
ADD RDX,0x20
CALL 0x001b69f0
JMP 0x001b69d1
LAB_001b699c:
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x10]
CALL 0x001b5ba0
MOV RDI,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RSP + 0x28]
ADD RSI,0x20
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001b5ba0
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x001b6a40
LAB_001b69d1:
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x18]
CALL 0x001b6230
ADD RSP,0x38
RET
|
/* fmt::v10::basic_memory_buffer<unsigned int, 32ul, std::allocator<unsigned int>
>::move(fmt::v10::basic_memory_buffer<unsigned int, 32ul, std::allocator<unsigned int> >&) */
void __thiscall
fmt::v10::basic_memory_buffer<unsigned_int,32ul,std::allocator<unsigned_int>>::move
(basic_memory_buffer<unsigned_int,32ul,std::allocator<unsigned_int>> *this,
basic_memory_buffer *param_1)
{
basic_memory_buffer *pbVar1;
ulong uVar2;
ulong uVar3;
pbVar1 = (basic_memory_buffer *)
v10::detail::buffer<unsigned_int>::data((buffer<unsigned_int> *)param_1);
uVar2 = v10::detail::buffer<unsigned_int>::size((buffer<unsigned_int> *)param_1);
uVar3 = v10::detail::buffer<unsigned_int>::capacity((buffer<unsigned_int> *)param_1);
if (pbVar1 == param_1 + 0x20) {
v10::detail::buffer<unsigned_int>::set((buffer<unsigned_int> *)this,(uint *)(this + 0x20),uVar3)
;
v10::detail::copy_str<unsigned_int,unsigned_int*,unsigned_int*>
((uint *)(param_1 + 0x20),(uint *)(param_1 + uVar2 * 4 + 0x20),(uint *)(this + 0x20));
}
else {
v10::detail::buffer<unsigned_int>::set((buffer<unsigned_int> *)this,(uint *)pbVar1,uVar3);
v10::detail::buffer<unsigned_int>::set
((buffer<unsigned_int> *)param_1,(uint *)(param_1 + 0x20),0);
v10::detail::buffer<unsigned_int>::clear((buffer<unsigned_int> *)param_1);
}
resize(this,uVar2);
return;
}
|
|
11,778 |
httplib::detail::mmap::open(char const*)
|
monkey531[P]llama/examples/server/httplib.h
|
inline bool mmap::open(const char *path) {
close();
#if defined(_WIN32)
auto wpath = u8string_to_wstring(path);
if (wpath.empty()) { return false; }
#if _WIN32_WINNT >= _WIN32_WINNT_WIN8
hFile_ = ::CreateFile2(wpath.c_str(), GENERIC_READ, FILE_SHARE_READ,
OPEN_EXISTING, NULL);
#else
hFile_ = ::CreateFileW(wpath.c_str(), GENERIC_READ, FILE_SHARE_READ, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
#endif
if (hFile_ == INVALID_HANDLE_VALUE) { return false; }
LARGE_INTEGER size{};
if (!::GetFileSizeEx(hFile_, &size)) { return false; }
// If the following line doesn't compile due to QuadPart, update Windows SDK.
// See:
// https://github.com/yhirose/cpp-httplib/issues/1903#issuecomment-2316520721
if (static_cast<ULONGLONG>(size.QuadPart) >
(std::numeric_limits<decltype(size_)>::max)()) {
// `size_t` might be 32-bits, on 32-bits Windows.
return false;
}
size_ = static_cast<size_t>(size.QuadPart);
#if _WIN32_WINNT >= _WIN32_WINNT_WIN8
hMapping_ =
::CreateFileMappingFromApp(hFile_, NULL, PAGE_READONLY, size_, NULL);
#else
hMapping_ = ::CreateFileMappingW(hFile_, NULL, PAGE_READONLY, 0, 0, NULL);
#endif
// Special treatment for an empty file...
if (hMapping_ == NULL && size_ == 0) {
close();
is_open_empty_file = true;
return true;
}
if (hMapping_ == NULL) {
close();
return false;
}
#if _WIN32_WINNT >= _WIN32_WINNT_WIN8
addr_ = ::MapViewOfFileFromApp(hMapping_, FILE_MAP_READ, 0, 0);
#else
addr_ = ::MapViewOfFile(hMapping_, FILE_MAP_READ, 0, 0, 0);
#endif
if (addr_ == nullptr) {
close();
return false;
}
#else
fd_ = ::open(path, O_RDONLY);
if (fd_ == -1) { return false; }
struct stat sb;
if (fstat(fd_, &sb) == -1) {
close();
return false;
}
size_ = static_cast<size_t>(sb.st_size);
addr_ = ::mmap(NULL, size_, PROT_READ, MAP_PRIVATE, fd_, 0);
// Special treatment for an empty file...
if (addr_ == MAP_FAILED && size_ == 0) {
close();
is_open_empty_file = true;
return false;
}
#endif
return true;
}
|
O3
|
c
|
httplib::detail::mmap::open(char const*):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x6fca9
movq 0x8(%rbx), %rsi
callq 0x1f630
movq $0x0, 0x10(%rbx)
movl (%rbx), %edi
cmpl $-0x1, %edi
je 0x6fcbb
callq 0x20550
movl $0xffffffff, (%rbx) # imm = 0xFFFFFFFF
movq $0x0, 0x8(%rbx)
xorl %ebp, %ebp
movq %r14, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x1f800
movl %eax, (%rbx)
cmpl $-0x1, %eax
je 0x6fd87
movq %rsp, %rsi
movl %eax, %edi
callq 0x20230
cmpl $-0x1, %eax
je 0x6fd51
movq 0x30(%rsp), %rsi
movq %rsi, 0x8(%rbx)
movl (%rbx), %r8d
xorl %edi, %edi
movl $0x1, %edx
movl $0x2, %ecx
xorl %r9d, %r9d
callq 0x203a0
movq %rax, 0x10(%rbx)
movb $0x1, %bpl
cmpq $-0x1, %rax
jne 0x6fd87
cmpq $0x0, 0x8(%rbx)
jne 0x6fd87
movq %rax, %rdi
xorl %esi, %esi
callq 0x1f630
movq $0x0, 0x10(%rbx)
movl (%rbx), %edi
cmpl $-0x1, %edi
je 0x6fd43
callq 0x20550
movl $0xffffffff, (%rbx) # imm = 0xFFFFFFFF
movq $0x0, 0x8(%rbx)
movb $0x1, 0x18(%rbx)
jmp 0x6fd85
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x6fd6b
movq 0x8(%rbx), %rsi
callq 0x1f630
movq $0x0, 0x10(%rbx)
movl (%rbx), %edi
cmpl $-0x1, %edi
je 0x6fd7d
callq 0x20550
movl $0xffffffff, (%rbx) # imm = 0xFFFFFFFF
movq $0x0, 0x8(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
|
_ZN7httplib6detail4mmap4openEPKc:
push rbp
push r14
push rbx
sub rsp, 90h
mov r14, rsi
mov rbx, rdi
mov rdi, [rdi+10h]
test rdi, rdi
jz short loc_6FCA9
mov rsi, [rbx+8]
call _munmap
mov qword ptr [rbx+10h], 0
loc_6FCA9:
mov edi, [rbx]
cmp edi, 0FFFFFFFFh
jz short loc_6FCBB
call _close
mov dword ptr [rbx], 0FFFFFFFFh
loc_6FCBB:
mov qword ptr [rbx+8], 0
xor ebp, ebp
mov rdi, r14
xor esi, esi
xor eax, eax
call _open
mov [rbx], eax
cmp eax, 0FFFFFFFFh
jz loc_6FD87
mov rsi, rsp
mov edi, eax
call _fstat
cmp eax, 0FFFFFFFFh
jz short loc_6FD51
mov rsi, [rsp+0A8h+var_78]
mov [rbx+8], rsi
mov r8d, [rbx]
xor edi, edi
mov edx, 1
mov ecx, 2
xor r9d, r9d
call _mmap
mov [rbx+10h], rax
mov bpl, 1
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_6FD87
cmp qword ptr [rbx+8], 0
jnz short loc_6FD87
mov rdi, rax
xor esi, esi
call _munmap
mov qword ptr [rbx+10h], 0
mov edi, [rbx]
cmp edi, 0FFFFFFFFh
jz short loc_6FD43
call _close
mov dword ptr [rbx], 0FFFFFFFFh
loc_6FD43:
mov qword ptr [rbx+8], 0
mov byte ptr [rbx+18h], 1
jmp short loc_6FD85
loc_6FD51:
mov rdi, [rbx+10h]
test rdi, rdi
jz short loc_6FD6B
mov rsi, [rbx+8]
call _munmap
mov qword ptr [rbx+10h], 0
loc_6FD6B:
mov edi, [rbx]
cmp edi, 0FFFFFFFFh
jz short loc_6FD7D
call _close
mov dword ptr [rbx], 0FFFFFFFFh
loc_6FD7D:
mov qword ptr [rbx+8], 0
loc_6FD85:
xor ebp, ebp
loc_6FD87:
mov eax, ebp
add rsp, 90h
pop rbx
pop r14
pop rbp
retn
|
long long httplib::detail::mmap::open(httplib::detail::mmap *this, const char *a2)
{
long long v3; // rdi
long long v4; // rdi
unsigned int v5; // ebp
unsigned int v6; // eax
long long v7; // rsi
long long v8; // rax
long long v9; // rdi
long long v10; // rdi
long long v11; // rdi
long long v13; // [rsp+0h] [rbp-A8h] BYREF
long long v14; // [rsp+30h] [rbp-78h]
v3 = *((_QWORD *)this + 2);
if ( v3 )
{
munmap(v3, *((_QWORD *)this + 1));
*((_QWORD *)this + 2) = 0LL;
}
v4 = *(unsigned int *)this;
if ( (_DWORD)v4 != -1 )
{
close(v4);
*(_DWORD *)this = -1;
}
*((_QWORD *)this + 1) = 0LL;
v5 = 0;
v6 = open(a2, 0LL);
*(_DWORD *)this = v6;
if ( v6 != -1 )
{
if ( (unsigned int)fstat(v6, &v13) == -1 )
{
v10 = *((_QWORD *)this + 2);
if ( v10 )
{
munmap(v10, *((_QWORD *)this + 1));
*((_QWORD *)this + 2) = 0LL;
}
v11 = *(unsigned int *)this;
if ( (_DWORD)v11 != -1 )
{
close(v11);
*(_DWORD *)this = -1;
}
*((_QWORD *)this + 1) = 0LL;
return 0;
}
v7 = v14;
*((_QWORD *)this + 1) = v14;
v8 = mmap(0LL, v7, 1LL, 2LL, *(unsigned int *)this, 0LL);
*((_QWORD *)this + 2) = v8;
LOBYTE(v5) = 1;
if ( v8 == -1 && !*((_QWORD *)this + 1) )
{
munmap(-1LL, 0LL);
*((_QWORD *)this + 2) = 0LL;
v9 = *(unsigned int *)this;
if ( (_DWORD)v9 != -1 )
{
close(v9);
*(_DWORD *)this = -1;
}
*((_QWORD *)this + 1) = 0LL;
*((_BYTE *)this + 24) = 1;
return 0;
}
}
return v5;
}
|
open:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x90
MOV R14,RSI
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x10]
TEST RDI,RDI
JZ 0x0016fca9
MOV RSI,qword ptr [RBX + 0x8]
CALL 0x0011f630
MOV qword ptr [RBX + 0x10],0x0
LAB_0016fca9:
MOV EDI,dword ptr [RBX]
CMP EDI,-0x1
JZ 0x0016fcbb
CALL 0x00120550
MOV dword ptr [RBX],0xffffffff
LAB_0016fcbb:
MOV qword ptr [RBX + 0x8],0x0
XOR EBP,EBP
MOV RDI,R14
XOR ESI,ESI
XOR EAX,EAX
CALL 0x0011f800
MOV dword ptr [RBX],EAX
CMP EAX,-0x1
JZ 0x0016fd87
MOV RSI,RSP
MOV EDI,EAX
CALL 0x00120230
CMP EAX,-0x1
JZ 0x0016fd51
MOV RSI,qword ptr [RSP + 0x30]
MOV qword ptr [RBX + 0x8],RSI
MOV R8D,dword ptr [RBX]
XOR EDI,EDI
MOV EDX,0x1
MOV ECX,0x2
XOR R9D,R9D
CALL 0x001203a0
MOV qword ptr [RBX + 0x10],RAX
MOV BPL,0x1
CMP RAX,-0x1
JNZ 0x0016fd87
CMP qword ptr [RBX + 0x8],0x0
JNZ 0x0016fd87
MOV RDI,RAX
XOR ESI,ESI
CALL 0x0011f630
MOV qword ptr [RBX + 0x10],0x0
MOV EDI,dword ptr [RBX]
CMP EDI,-0x1
JZ 0x0016fd43
CALL 0x00120550
MOV dword ptr [RBX],0xffffffff
LAB_0016fd43:
MOV qword ptr [RBX + 0x8],0x0
MOV byte ptr [RBX + 0x18],0x1
JMP 0x0016fd85
LAB_0016fd51:
MOV RDI,qword ptr [RBX + 0x10]
TEST RDI,RDI
JZ 0x0016fd6b
MOV RSI,qword ptr [RBX + 0x8]
CALL 0x0011f630
MOV qword ptr [RBX + 0x10],0x0
LAB_0016fd6b:
MOV EDI,dword ptr [RBX]
CMP EDI,-0x1
JZ 0x0016fd7d
CALL 0x00120550
MOV dword ptr [RBX],0xffffffff
LAB_0016fd7d:
MOV qword ptr [RBX + 0x8],0x0
LAB_0016fd85:
XOR EBP,EBP
LAB_0016fd87:
MOV EAX,EBP
ADD RSP,0x90
POP RBX
POP R14
POP RBP
RET
|
/* httplib::detail::mmap::open(char const*) */
int8 __thiscall httplib::detail::mmap::open(mmap *this,char *param_1)
{
int iVar1;
void *pvVar2;
stat sStack_a8;
if (*(void **)(this + 0x10) != (void *)0x0) {
munmap(*(void **)(this + 0x10),*(size_t *)(this + 8));
*(int8 *)(this + 0x10) = 0;
}
if (*(int *)this != -1) {
close(*(int *)this);
*(int4 *)this = 0xffffffff;
}
*(int8 *)(this + 8) = 0;
iVar1 = ::open(param_1,0);
*(int *)this = iVar1;
if (iVar1 != -1) {
iVar1 = fstat(iVar1,&sStack_a8);
if (iVar1 == -1) {
if (*(void **)(this + 0x10) != (void *)0x0) {
munmap(*(void **)(this + 0x10),*(size_t *)(this + 8));
*(int8 *)(this + 0x10) = 0;
}
if (*(int *)this != -1) {
close(*(int *)this);
*(int4 *)this = 0xffffffff;
}
*(int8 *)(this + 8) = 0;
}
else {
*(__off_t *)(this + 8) = sStack_a8.st_size;
pvVar2 = ::mmap((void *)0x0,sStack_a8.st_size,1,2,*(int *)this,0);
*(void **)(this + 0x10) = pvVar2;
if (pvVar2 != (void *)0xffffffffffffffff) {
return 1;
}
if (*(long *)(this + 8) != 0) {
return 1;
}
munmap((void *)0xffffffffffffffff,0);
*(int8 *)(this + 0x10) = 0;
if (*(int *)this != -1) {
close(*(int *)this);
*(int4 *)this = 0xffffffff;
}
*(int8 *)(this + 8) = 0;
this[0x18] = (mmap)0x1;
}
}
return 0;
}
|
|
11,779 |
my_suspend_hook
|
eloqsql/libmariadb/libmariadb/mariadb_lib.c
|
static void
my_suspend_hook(my_bool suspend, void *data)
{
struct my_hook_data *hook_data= (struct my_hook_data *)data;
if (suspend)
{
hook_data->orig_pvio= hook_data->orig_mysql->net.pvio;
hook_data->orig_mysql->net.pvio= hook_data->new_mysql->net.pvio;
}
else
hook_data->orig_mysql->net.pvio= hook_data->orig_pvio;
}
|
O3
|
c
|
my_suspend_hook:
pushq %rbp
movq %rsp, %rbp
testb %dil, %dil
je 0x212bb
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
movq (%rax), %rdx
movq %rdx, 0x10(%rsi)
movq (%rcx), %rcx
jmp 0x212c2
movq (%rsi), %rax
movq 0x10(%rsi), %rcx
movq %rcx, (%rax)
popq %rbp
retq
|
my_suspend_hook:
push rbp
mov rbp, rsp
test dil, dil
jz short loc_212BB
mov rax, [rsi]
mov rcx, [rsi+8]
mov rdx, [rax]
mov [rsi+10h], rdx
mov rcx, [rcx]
jmp short loc_212C2
loc_212BB:
mov rax, [rsi]
mov rcx, [rsi+10h]
loc_212C2:
mov [rax], rcx
pop rbp
retn
|
_QWORD * my_suspend_hook(char a1, long long a2)
{
_QWORD *result; // rax
long long *v3; // rcx
long long v4; // rcx
result = *(_QWORD **)a2;
if ( a1 )
{
v3 = *(long long **)(a2 + 8);
*(_QWORD *)(a2 + 16) = **(_QWORD **)a2;
v4 = *v3;
}
else
{
v4 = *(_QWORD *)(a2 + 16);
}
*result = v4;
return result;
}
|
my_suspend_hook:
PUSH RBP
MOV RBP,RSP
TEST DIL,DIL
JZ 0x001212bb
MOV RAX,qword ptr [RSI]
MOV RCX,qword ptr [RSI + 0x8]
MOV RDX,qword ptr [RAX]
MOV qword ptr [RSI + 0x10],RDX
MOV RCX,qword ptr [RCX]
JMP 0x001212c2
LAB_001212bb:
MOV RAX,qword ptr [RSI]
MOV RCX,qword ptr [RSI + 0x10]
LAB_001212c2:
MOV qword ptr [RAX],RCX
POP RBP
RET
|
void my_suspend_hook(char param_1,int8 *param_2)
{
int8 *puVar1;
int8 uVar2;
if (param_1 == '\0') {
puVar1 = (int8 *)*param_2;
uVar2 = param_2[2];
}
else {
puVar1 = (int8 *)*param_2;
param_2[2] = *puVar1;
uVar2 = *(int8 *)param_2[1];
}
*puVar1 = uVar2;
return;
}
|
|
11,780 |
lf_dynarray_iterate
|
eloqsql/mysys/lf_dynarray.c
|
int lf_dynarray_iterate(LF_DYNARRAY *array, lf_dynarray_func func, void *arg)
{
int i, res;
for (i= 0; i < LF_DYNARRAY_LEVELS; i++)
if ((res= recursive_iterate(array, array->level[i], i, func, arg)))
return res;
return 0;
}
|
O0
|
c
|
lf_dynarray_iterate:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x4, -0x24(%rbp)
jge 0x5c73e
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movl -0x24(%rbp), %edx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
callq 0x5c750
movl %eax, -0x28(%rbp)
cmpl $0x0, %eax
je 0x5c731
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5c745
jmp 0x5c733
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5c6fb
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
|
lf_dynarray_iterate:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_24], 0
loc_5C6FB:
cmp [rbp+var_24], 4
jge short loc_5C73E
mov rdi, [rbp+var_10]
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_24]
mov rsi, [rax+rcx*8]
mov edx, [rbp+var_24]
mov rcx, [rbp+var_18]
mov r8, [rbp+var_20]
call recursive_iterate
mov [rbp+var_28], eax
cmp eax, 0
jz short loc_5C731
mov eax, [rbp+var_28]
mov [rbp+var_4], eax
jmp short loc_5C745
loc_5C731:
jmp short $+2
loc_5C733:
mov eax, [rbp+var_24]
add eax, 1
mov [rbp+var_24], eax
jmp short loc_5C6FB
loc_5C73E:
mov [rbp+var_4], 0
loc_5C745:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
|
long long lf_dynarray_iterate(long long a1, long long a2, long long a3)
{
unsigned int v4; // [rsp+8h] [rbp-28h]
int i; // [rsp+Ch] [rbp-24h]
for ( i = 0; i < 4; ++i )
{
v4 = recursive_iterate(a1, *(_QWORD *)(a1 + 8LL * i), (unsigned int)i, a2, a3);
if ( v4 )
return v4;
}
return 0;
}
|
lf_dynarray_iterate:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV dword ptr [RBP + -0x24],0x0
LAB_0015c6fb:
CMP dword ptr [RBP + -0x24],0x4
JGE 0x0015c73e
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x24]
MOV RSI,qword ptr [RAX + RCX*0x8]
MOV EDX,dword ptr [RBP + -0x24]
MOV RCX,qword ptr [RBP + -0x18]
MOV R8,qword ptr [RBP + -0x20]
CALL 0x0015c750
MOV dword ptr [RBP + -0x28],EAX
CMP EAX,0x0
JZ 0x0015c731
MOV EAX,dword ptr [RBP + -0x28]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0015c745
LAB_0015c731:
JMP 0x0015c733
LAB_0015c733:
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,0x1
MOV dword ptr [RBP + -0x24],EAX
JMP 0x0015c6fb
LAB_0015c73e:
MOV dword ptr [RBP + -0x4],0x0
LAB_0015c745:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int lf_dynarray_iterate(long param_1,int8 param_2,int8 param_3)
{
int iVar1;
int local_2c;
local_2c = 0;
while( true ) {
if (3 < local_2c) {
return 0;
}
iVar1 = recursive_iterate(param_1,*(int8 *)(param_1 + (long)local_2c * 8),local_2c,param_2
,param_3);
if (iVar1 != 0) break;
local_2c = local_2c + 1;
}
return iVar1;
}
|
|
11,781 |
my_convert
|
eloqsql/strings/ctype.c
|
uint32
my_convert(char *to, uint32 to_length, CHARSET_INFO *to_cs,
const char *from, uint32 from_length,
CHARSET_INFO *from_cs, uint *errors)
{
uint32 length, length2;
/*
If any of the character sets is not ASCII compatible,
immediately switch to slow mb_wc->wc_mb method.
*/
if ((to_cs->state | from_cs->state) & MY_CS_NONASCII)
return my_convert_using_func(to, to_length,
to_cs, to_cs->cset->wc_mb,
from, from_length,
from_cs, from_cs->cset->mb_wc,
errors);
length= length2= MY_MIN(to_length, from_length);
#if defined(__i386__) || defined(__x86_64__)
/*
Special loop for i386, it allows to refer to a
non-aligned memory block as UINT32, which makes
it possible to copy four bytes at once. This
gives about 10% performance improvement comparing
to byte-by-byte loop.
*/
for ( ; length >= 4; length-= 4, from+= 4, to+= 4)
{
if ((*(uint32*)from) & 0x80808080)
break;
*((uint32*) to)= *((const uint32*) from);
}
#endif /* __i386__ */
for (; ; *to++= *from++, length--)
{
if (!length)
{
*errors= 0;
return length2;
}
if (*((unsigned char*) from) > 0x7F) /* A non-ASCII character */
{
uint32 copied_length= length2 - length;
to_length-= copied_length;
from_length-= copied_length;
return copied_length + my_convert_using_func(to, to_length, to_cs,
to_cs->cset->wc_mb,
from, from_length, from_cs,
from_cs->cset->mb_wc,
errors);
}
}
DBUG_ASSERT(FALSE); // Should never get to here
return 0; // Make compiler happy
}
|
O0
|
c
|
my_convert:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq %r9, -0x38(%rbp)
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x38(%rbp), %rcx
orl 0xc(%rcx), %eax
andl $0x2000, %eax # imm = 0x2000
cmpl $0x0, %eax
je 0xcd533
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
movq -0x20(%rbp), %rdx
movq -0x20(%rbp), %rax
movq 0xb8(%rax), %rax
movq 0x30(%rax), %rcx
movq -0x28(%rbp), %r8
movl -0x2c(%rbp), %eax
movl %eax, %r9d
movq -0x38(%rbp), %r11
movq -0x38(%rbp), %rax
movq 0xb8(%rax), %rax
movq 0x28(%rax), %r10
movq 0x10(%rbp), %rax
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0xcd320
movl %eax, -0x4(%rbp)
jmp 0xcd679
movl -0x14(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jae 0xcd543
movl -0x14(%rbp), %eax
movl %eax, -0x48(%rbp)
jmp 0xcd549
movl -0x2c(%rbp), %eax
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %eax
movl %eax, -0x40(%rbp)
movl %eax, -0x3c(%rbp)
cmpl $0x4, -0x3c(%rbp)
jb 0xcd599
movq -0x28(%rbp), %rax
movl (%rax), %eax
andl $0x80808080, %eax # imm = 0x80808080
cmpl $0x0, %eax
je 0xcd56a
jmp 0xcd599
movq -0x28(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x3c(%rbp), %eax
subl $0x4, %eax
movl %eax, -0x3c(%rbp)
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
jmp 0xcd552
jmp 0xcd59b
cmpl $0x0, -0x3c(%rbp)
jne 0xcd5b6
movq 0x10(%rbp), %rax
movl $0x0, (%rax)
movl -0x40(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xcd679
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x7f, %eax
jle 0xcd647
movl -0x40(%rbp), %eax
subl -0x3c(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %ecx
movl -0x14(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x44(%rbp), %ecx
movl -0x2c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x2c(%rbp)
movl -0x44(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
movq -0x20(%rbp), %rdx
movq -0x20(%rbp), %rax
movq 0xb8(%rax), %rax
movq 0x30(%rax), %rcx
movq -0x28(%rbp), %r8
movl -0x2c(%rbp), %eax
movl %eax, %r9d
movq -0x38(%rbp), %r11
movq -0x38(%rbp), %rax
movq 0xb8(%rax), %rax
movq 0x28(%rax), %r10
movq 0x10(%rbp), %rax
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0xcd320
movl %eax, %ecx
movl -0x4c(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0xcd679
jmp 0xcd649
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb (%rax), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movl -0x3c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0xcd59b
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_convert:
push rbp
mov rbp, rsp
sub rsp, 70h
mov rax, [rbp+arg_0]
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_2C], r8d
mov [rbp+var_38], r9
mov rax, [rbp+var_20]
mov eax, [rax+0Ch]
mov rcx, [rbp+var_38]
or eax, [rcx+0Ch]
and eax, 2000h
cmp eax, 0
jz short loc_CD533
mov rdi, [rbp+var_10]
mov eax, [rbp+var_14]
mov esi, eax
mov rdx, [rbp+var_20]
mov rax, [rbp+var_20]
mov rax, [rax+0B8h]
mov rcx, [rax+30h]
mov r8, [rbp+var_28]
mov eax, [rbp+var_2C]
mov r9d, eax
mov r11, [rbp+var_38]
mov rax, [rbp+var_38]
mov rax, [rax+0B8h]
mov r10, [rax+28h]
mov rax, [rbp+arg_0]
mov [rsp+70h+var_70], r11
mov [rsp+70h+var_68], r10
mov [rsp+70h+var_60], rax
call my_convert_using_func
mov [rbp+var_4], eax
jmp loc_CD679
loc_CD533:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_2C]
jnb short loc_CD543
mov eax, [rbp+var_14]
mov [rbp+var_48], eax
jmp short loc_CD549
loc_CD543:
mov eax, [rbp+var_2C]
mov [rbp+var_48], eax
loc_CD549:
mov eax, [rbp+var_48]
mov [rbp+var_40], eax
mov [rbp+var_3C], eax
loc_CD552:
cmp [rbp+var_3C], 4
jb short loc_CD599
mov rax, [rbp+var_28]
mov eax, [rax]
and eax, 80808080h
cmp eax, 0
jz short loc_CD56A
jmp short loc_CD599
loc_CD56A:
mov rax, [rbp+var_28]
mov ecx, [rax]
mov rax, [rbp+var_10]
mov [rax], ecx
mov eax, [rbp+var_3C]
sub eax, 4
mov [rbp+var_3C], eax
mov rax, [rbp+var_28]
add rax, 4
mov [rbp+var_28], rax
mov rax, [rbp+var_10]
add rax, 4
mov [rbp+var_10], rax
jmp short loc_CD552
loc_CD599:
jmp short $+2
loc_CD59B:
cmp [rbp+var_3C], 0
jnz short loc_CD5B6
mov rax, [rbp+arg_0]
mov dword ptr [rax], 0
mov eax, [rbp+var_40]
mov [rbp+var_4], eax
jmp loc_CD679
loc_CD5B6:
mov rax, [rbp+var_28]
movzx eax, byte ptr [rax]
cmp eax, 7Fh
jle loc_CD647
mov eax, [rbp+var_40]
sub eax, [rbp+var_3C]
mov [rbp+var_44], eax
mov ecx, [rbp+var_44]
mov eax, [rbp+var_14]
sub eax, ecx
mov [rbp+var_14], eax
mov ecx, [rbp+var_44]
mov eax, [rbp+var_2C]
sub eax, ecx
mov [rbp+var_2C], eax
mov eax, [rbp+var_44]
mov [rbp+var_4C], eax
mov rdi, [rbp+var_10]
mov eax, [rbp+var_14]
mov esi, eax
mov rdx, [rbp+var_20]
mov rax, [rbp+var_20]
mov rax, [rax+0B8h]
mov rcx, [rax+30h]
mov r8, [rbp+var_28]
mov eax, [rbp+var_2C]
mov r9d, eax
mov r11, [rbp+var_38]
mov rax, [rbp+var_38]
mov rax, [rax+0B8h]
mov r10, [rax+28h]
mov rax, [rbp+arg_0]
mov [rsp+70h+var_70], r11
mov [rsp+70h+var_68], r10
mov [rsp+70h+var_60], rax
call my_convert_using_func
mov ecx, eax
mov eax, [rbp+var_4C]
add eax, ecx
mov [rbp+var_4], eax
jmp short loc_CD679
loc_CD647:
jmp short $+2
loc_CD649:
mov rax, [rbp+var_28]
mov rcx, rax
add rcx, 1
mov [rbp+var_28], rcx
mov cl, [rax]
mov rax, [rbp+var_10]
mov rdx, rax
add rdx, 1
mov [rbp+var_10], rdx
mov [rax], cl
mov eax, [rbp+var_3C]
add eax, 0FFFFFFFFh
mov [rbp+var_3C], eax
jmp loc_CD59B
loc_CD679:
mov eax, [rbp+var_4]
add rsp, 70h
pop rbp
retn
|
long long my_convert(
long long a1,
unsigned int a2,
long long a3,
unsigned long long a4,
unsigned int a5,
long long a6,
_DWORD *a7)
{
char *v7; // rax
char v8; // cl
_BYTE *v9; // rax
unsigned int v11; // [rsp+28h] [rbp-48h]
unsigned int i; // [rsp+34h] [rbp-3Ch]
_DWORD *v13; // [rsp+48h] [rbp-28h]
_DWORD *v14; // [rsp+60h] [rbp-10h]
v14 = (_DWORD *)a1;
v13 = (_DWORD *)a4;
if ( ((*(_DWORD *)(a6 + 12) | *(_DWORD *)(a3 + 12)) & 0x2000) != 0 )
{
return (unsigned int)my_convert_using_func(
a1,
a2,
a3,
*(long long ( **)(long long, long long, long long, long long))(*(_QWORD *)(a3 + 184) + 48LL),
a4,
a5,
a6,
*(long long ( **)(long long, long long *, unsigned long long, unsigned long long))(*(_QWORD *)(a6 + 184) + 40LL),
a7);
}
else
{
if ( a2 >= a5 )
v11 = a5;
else
v11 = a2;
for ( i = v11; i >= 4 && (*v13 & 0x80808080) == 0; i -= 4 )
*v14++ = *v13++;
while ( 1 )
{
if ( !i )
{
*a7 = 0;
return v11;
}
if ( *(unsigned __int8 *)v13 > 0x7Fu )
break;
v7 = (char *)v13;
v13 = (_DWORD *)((char *)v13 + 1);
v8 = *v7;
v9 = v14;
v14 = (_DWORD *)((char *)v14 + 1);
*v9 = v8;
--i;
}
return (unsigned int)(my_convert_using_func(
(long long)v14,
a2 - (v11 - i),
a3,
*(long long ( **)(long long, long long, long long, long long))(*(_QWORD *)(a3 + 184) + 48LL),
(unsigned long long)v13,
a5 - (v11 - i),
a6,
*(long long ( **)(long long, long long *, unsigned long long, unsigned long long))(*(_QWORD *)(a6 + 184) + 40LL),
a7)
+ v11
- i);
}
}
|
my_convert:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV dword ptr [RBP + -0x2c],R8D
MOV qword ptr [RBP + -0x38],R9
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0xc]
MOV RCX,qword ptr [RBP + -0x38]
OR EAX,dword ptr [RCX + 0xc]
AND EAX,0x2000
CMP EAX,0x0
JZ 0x001cd533
MOV RDI,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x14]
MOV ESI,EAX
MOV RDX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0xb8]
MOV RCX,qword ptr [RAX + 0x30]
MOV R8,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RBP + -0x2c]
MOV R9D,EAX
MOV R11,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0xb8]
MOV R10,qword ptr [RAX + 0x28]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RSP],R11
MOV qword ptr [RSP + 0x8],R10
MOV qword ptr [RSP + 0x10],RAX
CALL 0x001cd320
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001cd679
LAB_001cd533:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x2c]
JNC 0x001cd543
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x48],EAX
JMP 0x001cd549
LAB_001cd543:
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x48],EAX
LAB_001cd549:
MOV EAX,dword ptr [RBP + -0x48]
MOV dword ptr [RBP + -0x40],EAX
MOV dword ptr [RBP + -0x3c],EAX
LAB_001cd552:
CMP dword ptr [RBP + -0x3c],0x4
JC 0x001cd599
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
AND EAX,0x80808080
CMP EAX,0x0
JZ 0x001cd56a
JMP 0x001cd599
LAB_001cd56a:
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],ECX
MOV EAX,dword ptr [RBP + -0x3c]
SUB EAX,0x4
MOV dword ptr [RBP + -0x3c],EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x4
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x4
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001cd552
LAB_001cd599:
JMP 0x001cd59b
LAB_001cd59b:
CMP dword ptr [RBP + -0x3c],0x0
JNZ 0x001cd5b6
MOV RAX,qword ptr [RBP + 0x10]
MOV dword ptr [RAX],0x0
MOV EAX,dword ptr [RBP + -0x40]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001cd679
LAB_001cd5b6:
MOV RAX,qword ptr [RBP + -0x28]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x7f
JLE 0x001cd647
MOV EAX,dword ptr [RBP + -0x40]
SUB EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x44],EAX
MOV ECX,dword ptr [RBP + -0x44]
MOV EAX,dword ptr [RBP + -0x14]
SUB EAX,ECX
MOV dword ptr [RBP + -0x14],EAX
MOV ECX,dword ptr [RBP + -0x44]
MOV EAX,dword ptr [RBP + -0x2c]
SUB EAX,ECX
MOV dword ptr [RBP + -0x2c],EAX
MOV EAX,dword ptr [RBP + -0x44]
MOV dword ptr [RBP + -0x4c],EAX
MOV RDI,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x14]
MOV ESI,EAX
MOV RDX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0xb8]
MOV RCX,qword ptr [RAX + 0x30]
MOV R8,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RBP + -0x2c]
MOV R9D,EAX
MOV R11,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0xb8]
MOV R10,qword ptr [RAX + 0x28]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RSP],R11
MOV qword ptr [RSP + 0x8],R10
MOV qword ptr [RSP + 0x10],RAX
CALL 0x001cd320
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x4c]
ADD EAX,ECX
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001cd679
LAB_001cd647:
JMP 0x001cd649
LAB_001cd649:
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x28],RCX
MOV CL,byte ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x10],RDX
MOV byte ptr [RAX],CL
MOV EAX,dword ptr [RBP + -0x3c]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x3c],EAX
JMP 0x001cd59b
LAB_001cd679:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x70
POP RBP
RET
|
uint my_convert(uint *param_1,uint param_2,long param_3,uint *param_4,uint param_5,long param_6,
int4 *param_7)
{
int iVar1;
int iVar2;
uint local_50;
uint local_44;
uint *local_30;
uint *local_18;
uint local_c;
if (((*(uint *)(param_3 + 0xc) | *(uint *)(param_6 + 0xc)) & 0x2000) == 0) {
local_50 = param_5;
if (param_2 < param_5) {
local_50 = param_2;
}
local_44 = local_50;
local_18 = param_1;
for (local_30 = param_4; (3 < local_44 && ((*local_30 & 0x80808080) == 0));
local_30 = local_30 + 1) {
*local_18 = *local_30;
local_44 = local_44 - 4;
local_18 = local_18 + 1;
}
for (; local_44 != 0; local_44 = local_44 - 1) {
if (0x7f < (byte)*local_30) {
iVar1 = local_50 - local_44;
iVar2 = my_convert_using_func
(local_18,param_2 - iVar1,param_3,
*(int8 *)(*(long *)(param_3 + 0xb8) + 0x30),local_30,
param_5 - iVar1,param_6,*(int8 *)(*(long *)(param_6 + 0xb8) + 0x28)
,param_7);
return iVar1 + iVar2;
}
*(byte *)local_18 = (byte)*local_30;
local_30 = (uint *)((long)local_30 + 1);
local_18 = (uint *)((long)local_18 + 1);
}
*param_7 = 0;
local_c = local_50;
}
else {
local_c = my_convert_using_func
(param_1,param_2,param_3,*(int8 *)(*(long *)(param_3 + 0xb8) + 0x30),
param_4,param_5,param_6,*(int8 *)(*(long *)(param_6 + 0xb8) + 0x28),
param_7);
}
return local_c;
}
|
|
11,782 |
template_packet_init
|
xtate/src/templ/templ-init.c
|
void template_packet_init(TmplSet *templset, macaddress_t source_mac,
macaddress_t router_mac_ipv4,
macaddress_t router_mac_ipv6, int data_link,
uint64_t entropy, const TmplOpt *templ_opts) {
unsigned char *buf;
size_t length;
templset->count = 0;
templset->entropy = entropy;
/* [SCTP] */
_template_init(&templset->pkts[TmplType_SCTP], source_mac, router_mac_ipv4,
router_mac_ipv6, default_sctp_template,
sizeof(default_sctp_template) - 1, data_link);
templset->count++;
/* [TCP] */
_template_init(&templset->pkts[TmplType_TCP], source_mac, router_mac_ipv4,
router_mac_ipv6, default_tcp_template,
sizeof(default_tcp_template) - 1, data_link);
templset->count++;
/* [TCP SYN] */
length = sizeof(default_tcp_syn_template) - 1;
buf = MALLOC(length);
memcpy(buf, default_tcp_syn_template, length);
templ_tcp_apply_options(&buf, &length, templ_opts); /*set options for syn*/
_template_init(&templset->pkts[TmplType_TCP_SYN], source_mac,
router_mac_ipv4, router_mac_ipv6, buf, length, data_link);
templset->count++;
free(buf);
/* [TCP] */
_template_init(&templset->pkts[TmplType_TCP_RST], source_mac,
router_mac_ipv4, router_mac_ipv6, default_tcp_rst_template,
sizeof(default_tcp_rst_template) - 1, data_link);
templset->count++;
/* [UDP] */
_template_init(&templset->pkts[TmplType_UDP], source_mac, router_mac_ipv4,
router_mac_ipv6, default_udp_template,
sizeof(default_udp_template) - 1, data_link);
templset->count++;
/* [ICMP ping] */
_template_init(&templset->pkts[TmplType_ICMP_ECHO], source_mac,
router_mac_ipv4, router_mac_ipv6, default_icmp_ping_template,
sizeof(default_icmp_ping_template) - 1, data_link);
templset->count++;
/* [ICMP timestamp] */
_template_init(&templset->pkts[TmplType_ICMP_TS], source_mac,
router_mac_ipv4, router_mac_ipv6,
default_icmp_timestamp_template,
sizeof(default_icmp_timestamp_template) - 1, data_link);
templset->count++;
/* [ARP] */
_template_init(&templset->pkts[TmplType_ARP], source_mac, router_mac_ipv4,
router_mac_ipv6, default_arp_template,
sizeof(default_arp_template) - 1, data_link);
templset->count++;
/* [NDP NS] */
_template_init(&templset->pkts[TmplType_NDP_NS], source_mac,
router_mac_ipv4, router_mac_ipv6, default_ndp_ns_template,
sizeof(default_ndp_ns_template) - 1, data_link);
templset->count++;
}
|
O3
|
c
|
template_packet_init:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movl $0x0, (%rdi)
movq %r9, 0x8(%rdi)
leaq 0x10(%rdi), %r13
addq $0x130, %rdi # imm = 0x130
movl %r8d, (%rsp)
leaq 0x549cf(%rip), %r8 # 0x9e750
movl $0x42, %r9d
callq 0x49f32
incl (%rbx)
movl %ebp, (%rsp)
leaq 0x548f8(%rip), %r8 # 0x9e690
movl $0x36, %r9d
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x49f32
incl (%rbx)
leaq 0x8(%rsp), %rax
movq $0x3a, (%rax)
movl $0x3a, %edi
callq 0x50885
leaq 0x10(%rsp), %r13
movq %rax, (%r13)
movaps 0x548f9(%rip), %xmm0 # 0x9e6d0
movups %xmm0, (%rax)
movaps 0x548ff(%rip), %xmm0 # 0x9e6e0
movups %xmm0, 0x10(%rax)
movaps 0x54904(%rip), %xmm0 # 0x9e6f0
movups %xmm0, 0x20(%rax)
movups 0x54903(%rip), %xmm0 # 0x9e6fa
movups %xmm0, 0x2a(%rax)
movq %r13, %rdi
leaq 0x8(%rsp), %rsi
movq 0x50(%rsp), %rdx
callq 0x4b2b5
leaq 0x58(%rbx), %rdi
movq (%r13), %r8
leaq 0x8(%rsp), %rax
movq (%rax), %r9
movl %ebp, (%rsp)
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x49f32
incl (%rbx)
movq (%r13), %rdi
callq 0x151e0
leaq 0xa0(%rbx), %rdi
movl %ebp, (%rsp)
leaq 0x548c6(%rip), %r8 # 0x9e710
movl $0x36, %r9d
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x49f32
incl (%rbx)
leaq 0xe8(%rbx), %rdi
movl %ebp, (%rsp)
leaq 0x5492f(%rip), %r8 # 0x9e7a0
movl $0x2a, %r9d
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x49f32
incl (%rbx)
leaq 0x178(%rbx), %rdi
movl %ebp, (%rsp)
leaq 0x54938(%rip), %r8 # 0x9e7d0
movl $0x2a, %r9d
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x49f32
incl (%rbx)
leaq 0x1c0(%rbx), %rdi
movl %ebp, (%rsp)
leaq 0x54941(%rip), %r8 # 0x9e800
movl $0x36, %r9d
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x49f32
incl (%rbx)
leaq 0x208(%rbx), %rdi
movl %ebp, (%rsp)
leaq 0x5495a(%rip), %r8 # 0x9e840
movl $0x2a, %r9d
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x49f32
incl (%rbx)
leaq 0x250(%rbx), %rdi
movl %ebp, (%rsp)
leaq 0x54963(%rip), %r8 # 0x9e870
movl $0x42, %r9d
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x49f32
incl (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
template_packet_init:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov ebp, r8d
mov r14, rcx
mov r15, rdx
mov r12, rsi
mov rbx, rdi
mov dword ptr [rdi], 0
mov [rdi+8], r9
lea r13, [rdi+10h]
add rdi, 130h
mov [rsp+48h+var_48], r8d
lea r8, default_sctp_template
mov r9d, 42h ; 'B'
call _template_init
inc dword ptr [rbx]
mov [rsp+48h+var_48], ebp
lea r8, default_tcp_template
mov r9d, 36h ; '6'
mov rdi, r13
mov rsi, r12
mov rdx, r15
mov rcx, r14
call _template_init
inc dword ptr [rbx]
lea rax, [rsp+48h+var_40]
mov qword ptr [rax], 3Ah ; ':'
mov edi, 3Ah ; ':'
call MALLOC
lea r13, [rsp+48h+var_38]
mov [r13+0], rax
movaps xmm0, cs:default_tcp_syn_template
movups xmmword ptr [rax], xmm0
movaps xmm0, cs:xmmword_9E6E0
movups xmmword ptr [rax+10h], xmm0
movaps xmm0, cs:xmmword_9E6F0
movups xmmword ptr [rax+20h], xmm0
movups xmm0, cs:xmmword_9E6F0+0Ah
movups xmmword ptr [rax+2Ah], xmm0
mov rdi, r13
lea rsi, [rsp+48h+var_40]
mov rdx, [rsp+48h+arg_0]
call templ_tcp_apply_options
lea rdi, [rbx+58h]
mov r8, [r13+0]
lea rax, [rsp+48h+var_40]
mov r9, [rax]
mov [rsp+48h+var_48], ebp
mov rsi, r12
mov rdx, r15
mov rcx, r14
call _template_init
inc dword ptr [rbx]
mov rdi, [r13+0]
call _free
lea rdi, [rbx+0A0h]
mov [rsp+48h+var_48], ebp
lea r8, default_tcp_rst_template
mov r9d, 36h ; '6'
mov rsi, r12
mov rdx, r15
mov rcx, r14
call _template_init
inc dword ptr [rbx]
lea rdi, [rbx+0E8h]
mov [rsp+48h+var_48], ebp
lea r8, default_udp_template
mov r9d, 2Ah ; '*'
mov rsi, r12
mov rdx, r15
mov rcx, r14
call _template_init
inc dword ptr [rbx]
lea rdi, [rbx+178h]
mov [rsp+48h+var_48], ebp
lea r8, default_icmp_ping_template
mov r9d, 2Ah ; '*'
mov rsi, r12
mov rdx, r15
mov rcx, r14
call _template_init
inc dword ptr [rbx]
lea rdi, [rbx+1C0h]
mov [rsp+48h+var_48], ebp
lea r8, default_icmp_timestamp_template
mov r9d, 36h ; '6'
mov rsi, r12
mov rdx, r15
mov rcx, r14
call _template_init
inc dword ptr [rbx]
lea rdi, [rbx+208h]
mov [rsp+48h+var_48], ebp
lea r8, default_arp_template
mov r9d, 2Ah ; '*'
mov rsi, r12
mov rdx, r15
mov rcx, r14
call _template_init
inc dword ptr [rbx]
lea rdi, [rbx+250h]
mov [rsp+48h+var_48], ebp
lea r8, default_ndp_ns_template
mov r9d, 42h ; 'B'
mov rsi, r12
mov rdx, r15
mov rcx, r14
call _template_init
inc dword ptr [rbx]
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long template_packet_init(long long a1, int a2, int a3, int a4, int a5, long long a6, long long a7)
{
_OWORD *v10; // rax
long long result; // rax
long long v12; // [rsp+8h] [rbp-40h] BYREF
_OWORD *v13; // [rsp+10h] [rbp-38h] BYREF
*(_DWORD *)a1 = 0;
*(_QWORD *)(a1 + 8) = a6;
template_init(a1 + 304, a2, a3, a4, (unsigned int)&default_sctp_template, 66, a5);
++*(_DWORD *)a1;
template_init(a1 + 16, a2, a3, a4, (unsigned int)&default_tcp_template, 54, a5);
++*(_DWORD *)a1;
v12 = 58LL;
v10 = (_OWORD *)MALLOC(58LL);
v13 = v10;
*v10 = default_tcp_syn_template;
v10[1] = xmmword_9E6E0;
v10[2] = xmmword_9E6F0;
*(_OWORD *)((char *)v10 + 42) = *(__int128 *)((char *)&xmmword_9E6F0 + 10);
templ_tcp_apply_options(&v13, &v12, a7);
template_init(a1 + 88, a2, a3, a4, (_DWORD)v13, v12, a5);
++*(_DWORD *)a1;
free(v13);
template_init(a1 + 160, a2, a3, a4, (unsigned int)&default_tcp_rst_template, 54, a5);
++*(_DWORD *)a1;
template_init(a1 + 232, a2, a3, a4, (unsigned int)&default_udp_template, 42, a5);
++*(_DWORD *)a1;
template_init(a1 + 376, a2, a3, a4, (unsigned int)&default_icmp_ping_template, 42, a5);
++*(_DWORD *)a1;
template_init(a1 + 448, a2, a3, a4, (unsigned int)&default_icmp_timestamp_template, 54, a5);
++*(_DWORD *)a1;
template_init(a1 + 520, a2, a3, a4, (unsigned int)&default_arp_template, 42, a5);
++*(_DWORD *)a1;
result = template_init((int)a1 + 592, a2, a3, a4, (unsigned int)&default_ndp_ns_template, 66, a5);
++*(_DWORD *)a1;
return result;
}
|
template_packet_init:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV EBP,R8D
MOV R14,RCX
MOV R15,RDX
MOV R12,RSI
MOV RBX,RDI
MOV dword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],R9
LEA R13,[RDI + 0x10]
ADD RDI,0x130
MOV dword ptr [RSP],R8D
LEA R8,[0x19e750]
MOV R9D,0x42
CALL 0x00149f32
INC dword ptr [RBX]
MOV dword ptr [RSP],EBP
LEA R8,[0x19e690]
MOV R9D,0x36
MOV RDI,R13
MOV RSI,R12
MOV RDX,R15
MOV RCX,R14
CALL 0x00149f32
INC dword ptr [RBX]
LEA RAX,[RSP + 0x8]
MOV qword ptr [RAX],0x3a
MOV EDI,0x3a
CALL 0x00150885
LEA R13,[RSP + 0x10]
MOV qword ptr [R13],RAX
MOVAPS XMM0,xmmword ptr [0x0019e6d0]
MOVUPS xmmword ptr [RAX],XMM0
MOVAPS XMM0,xmmword ptr [0x0019e6e0]
MOVUPS xmmword ptr [RAX + 0x10],XMM0
MOVAPS XMM0,xmmword ptr [0x0019e6f0]
MOVUPS xmmword ptr [RAX + 0x20],XMM0
MOVUPS XMM0,xmmword ptr [0x0019e6fa]
MOVUPS xmmword ptr [RAX + 0x2a],XMM0
MOV RDI,R13
LEA RSI,[RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x50]
CALL 0x0014b2b5
LEA RDI,[RBX + 0x58]
MOV R8,qword ptr [R13]
LEA RAX,[RSP + 0x8]
MOV R9,qword ptr [RAX]
MOV dword ptr [RSP],EBP
MOV RSI,R12
MOV RDX,R15
MOV RCX,R14
CALL 0x00149f32
INC dword ptr [RBX]
MOV RDI,qword ptr [R13]
CALL 0x001151e0
LEA RDI,[RBX + 0xa0]
MOV dword ptr [RSP],EBP
LEA R8,[0x19e710]
MOV R9D,0x36
MOV RSI,R12
MOV RDX,R15
MOV RCX,R14
CALL 0x00149f32
INC dword ptr [RBX]
LEA RDI,[RBX + 0xe8]
MOV dword ptr [RSP],EBP
LEA R8,[0x19e7a0]
MOV R9D,0x2a
MOV RSI,R12
MOV RDX,R15
MOV RCX,R14
CALL 0x00149f32
INC dword ptr [RBX]
LEA RDI,[RBX + 0x178]
MOV dword ptr [RSP],EBP
LEA R8,[0x19e7d0]
MOV R9D,0x2a
MOV RSI,R12
MOV RDX,R15
MOV RCX,R14
CALL 0x00149f32
INC dword ptr [RBX]
LEA RDI,[RBX + 0x1c0]
MOV dword ptr [RSP],EBP
LEA R8,[0x19e800]
MOV R9D,0x36
MOV RSI,R12
MOV RDX,R15
MOV RCX,R14
CALL 0x00149f32
INC dword ptr [RBX]
LEA RDI,[RBX + 0x208]
MOV dword ptr [RSP],EBP
LEA R8,[0x19e840]
MOV R9D,0x2a
MOV RSI,R12
MOV RDX,R15
MOV RCX,R14
CALL 0x00149f32
INC dword ptr [RBX]
LEA RDI,[RBX + 0x250]
MOV dword ptr [RSP],EBP
LEA R8,[0x19e870]
MOV R9D,0x42
MOV RSI,R12
MOV RDX,R15
MOV RCX,R14
CALL 0x00149f32
INC dword ptr [RBX]
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void template_packet_init
(int *param_1,int8 param_2,int8 param_3,int8 param_4,
int4 param_5,int8 param_6,int8 param_7)
{
int8 uVar1;
int4 uVar2;
int4 uVar3;
int4 uVar4;
int8 local_40;
int8 *local_38;
*param_1 = 0;
*(int8 *)(param_1 + 2) = param_6;
_template_init(param_1 + 0x4c);
*param_1 = *param_1 + 1;
_template_init(param_1 + 4,param_2,param_3,param_4,default_tcp_template,0x36,param_5);
*param_1 = *param_1 + 1;
local_40 = 0x3a;
local_38 = (int8 *)MALLOC(0x3a);
uVar1 = default_tcp_syn_template._8_8_;
*local_38 = default_tcp_syn_template._0_8_;
local_38[1] = uVar1;
uVar1 = default_tcp_syn_template._24_8_;
local_38[2] = default_tcp_syn_template._16_8_;
local_38[3] = uVar1;
uVar1 = CONCAT26(default_tcp_syn_template._46_2_,
CONCAT42(default_tcp_syn_template._42_4_,default_tcp_syn_template._40_2_));
local_38[4] = default_tcp_syn_template._32_8_;
local_38[5] = uVar1;
uVar4 = default_tcp_syn_template._54_4_;
uVar3 = default_tcp_syn_template._50_4_;
uVar2 = CONCAT22(default_tcp_syn_template._48_2_,default_tcp_syn_template._46_2_);
*(int4 *)((long)local_38 + 0x2a) = default_tcp_syn_template._42_4_;
*(int4 *)((long)local_38 + 0x2e) = uVar2;
*(int4 *)((long)local_38 + 0x32) = uVar3;
*(int4 *)((long)local_38 + 0x36) = uVar4;
templ_tcp_apply_options(&local_38,&local_40,param_7);
_template_init(param_1 + 0x16,param_2,param_3,param_4,local_38,local_40,param_5);
*param_1 = *param_1 + 1;
free(local_38);
_template_init(param_1 + 0x28,param_2,param_3,param_4,default_tcp_rst_template,0x36,param_5);
*param_1 = *param_1 + 1;
_template_init(param_1 + 0x3a,param_2,param_3,param_4,default_udp_template,0x2a,param_5);
*param_1 = *param_1 + 1;
_template_init(param_1 + 0x5e,param_2,param_3,param_4,default_icmp_ping_template,0x2a,param_5);
*param_1 = *param_1 + 1;
_template_init(param_1 + 0x70,param_2,param_3,param_4,default_icmp_timestamp_template,0x36,param_5
);
*param_1 = *param_1 + 1;
_template_init(param_1 + 0x82,param_2,param_3,param_4,default_arp_template,0x2a,param_5);
*param_1 = *param_1 + 1;
_template_init(param_1 + 0x94,param_2,param_3,param_4,default_ndp_ns_template,0x42,param_5);
*param_1 = *param_1 + 1;
return;
}
|
|
11,783 |
mi_mmap_pread
|
eloqsql/storage/myisam/mi_dynrec.c
|
size_t mi_mmap_pread(MI_INFO *info, uchar *Buffer,
size_t Count, my_off_t offset, myf MyFlags)
{
DBUG_PRINT("info", ("mi_read with mmap %d\n", info->dfile));
if (info->s->concurrent_insert)
mysql_rwlock_rdlock(&info->s->mmap_lock);
/*
The following test may fail in the following cases:
- We failed to remap a memory area (fragmented memory?)
- This thread has done some writes, but not yet extended the
memory mapped area.
*/
if (info->s->mmaped_length >= offset + Count)
{
memcpy(Buffer, info->s->file_map + offset, Count);
if (info->s->concurrent_insert)
mysql_rwlock_unlock(&info->s->mmap_lock);
return 0;
}
else
{
if (info->s->concurrent_insert)
mysql_rwlock_unlock(&info->s->mmap_lock);
return mysql_file_pread(info->dfile, Buffer, Count, offset, MyFlags);
}
}
|
O0
|
c
|
mi_mmap_pread:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
jmp 0xa6a5e
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, 0x384(%rax)
je 0xa6a8d
movq -0x10(%rbp), %rax
movq (%rax), %rdi
addq $0x4e0, %rdi # imm = 0x4E0
leaq 0xb2f24(%rip), %rsi # 0x1599a7
movl $0xac, %edx
callq 0xa6e30
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x4d0(%rax), %rax
movq -0x28(%rbp), %rcx
addq -0x20(%rbp), %rcx
cmpq %rcx, %rax
jb 0xa6af4
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x270(%rax), %rsi
addq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2a0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, 0x384(%rax)
je 0xa6aea
movq -0x10(%rbp), %rax
movq (%rax), %rdi
addq $0x4e0, %rdi # imm = 0x4E0
callq 0xa6ea0
movq $0x0, -0x8(%rbp)
jmp 0xa6b4a
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, 0x384(%rax)
je 0xa6b17
movq -0x10(%rbp), %rax
movq (%rax), %rdi
addq $0x4e0, %rdi # imm = 0x4E0
callq 0xa6ea0
movq -0x10(%rbp), %rax
movl 0x1c0(%rax), %edx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
movq -0x30(%rbp), %rax
leaq 0xb2e6f(%rip), %rdi # 0x1599a7
movl $0xc0, %esi
movq %rax, (%rsp)
callq 0xa6f10
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
mi_mmap_pread:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
jmp short $+2
loc_A6A5E:
mov rax, [rbp+var_10]
mov rax, [rax]
cmp byte ptr [rax+384h], 0
jz short loc_A6A8D
mov rax, [rbp+var_10]
mov rdi, [rax]
add rdi, 4E0h
lea rsi, aWorkspaceLlm4b_24; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 0ACh
call inline_mysql_rwlock_rdlock_3
loc_A6A8D:
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+4D0h]
mov rcx, [rbp+var_28]
add rcx, [rbp+var_20]
cmp rax, rcx
jb short loc_A6AF4
mov rdi, [rbp+var_18]
mov rax, [rbp+var_10]
mov rax, [rax]
mov rsi, [rax+270h]
add rsi, [rbp+var_28]
mov rdx, [rbp+var_20]
call _memcpy
mov rax, [rbp+var_10]
mov rax, [rax]
cmp byte ptr [rax+384h], 0
jz short loc_A6AEA
mov rax, [rbp+var_10]
mov rdi, [rax]
add rdi, 4E0h
call inline_mysql_rwlock_unlock_5
loc_A6AEA:
mov [rbp+var_8], 0
jmp short loc_A6B4A
loc_A6AF4:
mov rax, [rbp+var_10]
mov rax, [rax]
cmp byte ptr [rax+384h], 0
jz short loc_A6B17
mov rax, [rbp+var_10]
mov rdi, [rax]
add rdi, 4E0h
call inline_mysql_rwlock_unlock_5
loc_A6B17:
mov rax, [rbp+var_10]
mov edx, [rax+1C0h]
mov rcx, [rbp+var_18]
mov r8, [rbp+var_20]
mov r9, [rbp+var_28]
mov rax, [rbp+var_30]
lea rdi, aWorkspaceLlm4b_24; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 0C0h
mov [rsp+40h+var_40], rax
call inline_mysql_file_pread_6
mov [rbp+var_8], rax
loc_A6B4A:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
|
long long mi_mmap_pread(_DWORD *a1, long long a2, long long a3, long long a4, long long a5)
{
if ( *(_BYTE *)(*(_QWORD *)a1 + 900LL) )
inline_mysql_rwlock_rdlock_3(
*(_QWORD *)a1 + 1248LL,
"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_dynrec.c",
172LL);
if ( *(_QWORD *)(*(_QWORD *)a1 + 1232LL) < (unsigned long long)(a3 + a4) )
{
if ( *(_BYTE *)(*(_QWORD *)a1 + 900LL) )
inline_mysql_rwlock_unlock_5(*(_QWORD *)a1 + 1248LL);
return inline_mysql_file_pread_6(
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_dynrec.c",
192,
a1[112],
a2,
a3,
a4,
a5);
}
else
{
memcpy(a2, a4 + *(_QWORD *)(*(_QWORD *)a1 + 624LL), a3);
if ( *(_BYTE *)(*(_QWORD *)a1 + 900LL) )
inline_mysql_rwlock_unlock_5(*(_QWORD *)a1 + 1248LL);
return 0LL;
}
}
|
mi_mmap_pread:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
JMP 0x001a6a5e
LAB_001a6a5e:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
CMP byte ptr [RAX + 0x384],0x0
JZ 0x001a6a8d
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
ADD RDI,0x4e0
LEA RSI,[0x2599a7]
MOV EDX,0xac
CALL 0x001a6e30
LAB_001a6a8d:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x4d0]
MOV RCX,qword ptr [RBP + -0x28]
ADD RCX,qword ptr [RBP + -0x20]
CMP RAX,RCX
JC 0x001a6af4
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RSI,qword ptr [RAX + 0x270]
ADD RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x0012a0b0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
CMP byte ptr [RAX + 0x384],0x0
JZ 0x001a6aea
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
ADD RDI,0x4e0
CALL 0x001a6ea0
LAB_001a6aea:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001a6b4a
LAB_001a6af4:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
CMP byte ptr [RAX + 0x384],0x0
JZ 0x001a6b17
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
ADD RDI,0x4e0
CALL 0x001a6ea0
LAB_001a6b17:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RAX + 0x1c0]
MOV RCX,qword ptr [RBP + -0x18]
MOV R8,qword ptr [RBP + -0x20]
MOV R9,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x30]
LEA RDI,[0x2599a7]
MOV ESI,0xc0
MOV qword ptr [RSP],RAX
CALL 0x001a6f10
MOV qword ptr [RBP + -0x8],RAX
LAB_001a6b4a:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
int8 mi_mmap_pread(long *param_1,void *param_2,size_t param_3,long param_4,int8 param_5)
{
int8 local_10;
if (*(char *)(*param_1 + 900) != '\0') {
inline_mysql_rwlock_rdlock
(*param_1 + 0x4e0,
"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_dynrec.c",0xac);
}
if (*(ulong *)(*param_1 + 0x4d0) < param_4 + param_3) {
if (*(char *)(*param_1 + 900) != '\0') {
inline_mysql_rwlock_unlock(*param_1 + 0x4e0);
}
local_10 = inline_mysql_file_pread
("/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_dynrec.c",0xc0
,(int)param_1[0x38],param_2,param_3,param_4,param_5);
}
else {
memcpy(param_2,(void *)(*(long *)(*param_1 + 0x270) + param_4),param_3);
if (*(char *)(*param_1 + 900) != '\0') {
inline_mysql_rwlock_unlock(*param_1 + 0x4e0);
}
local_10 = 0;
}
return local_10;
}
|
|
11,784 |
my_numcells_cp932
|
eloqsql/strings/ctype-cp932.c
|
static
size_t my_numcells_cp932(CHARSET_INFO *cs __attribute__((unused)),
const char *str, const char *str_end)
{
size_t clen= 0;
const uchar *b= (const uchar *) str;
const uchar *e= (const uchar *) str_end;
for (clen= 0; b < e; )
{
if (*b >= 0xA1 && *b <= 0xDF)
{
clen++;
b++;
}
else if (*b > 0x7F)
{
clen+= 2;
b+= 2;
}
else
{
clen++;
b++;
}
}
return clen;
}
|
O0
|
c
|
my_numcells_cp932:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x39e15
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xa1, %eax
jl 0x39dd0
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xdf, %eax
jg 0x39dd0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x39e10
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x7f, %eax
jle 0x39df6
movq -0x20(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x28(%rbp)
jmp 0x39e0e
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x39e10
jmp 0x39d90
movq -0x20(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
|
my_numcells_cp932:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], 0
mov rax, [rbp+var_10]
mov [rbp+var_28], rax
mov rax, [rbp+var_18]
mov [rbp+var_30], rax
mov [rbp+var_20], 0
loc_39D90:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_30]
jnb short loc_39E15
mov rax, [rbp+var_28]
movzx eax, byte ptr [rax]
cmp eax, 0A1h
jl short loc_39DD0
mov rax, [rbp+var_28]
movzx eax, byte ptr [rax]
cmp eax, 0DFh
jg short loc_39DD0
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_20], rax
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
jmp short loc_39E10
loc_39DD0:
mov rax, [rbp+var_28]
movzx eax, byte ptr [rax]
cmp eax, 7Fh
jle short loc_39DF6
mov rax, [rbp+var_20]
add rax, 2
mov [rbp+var_20], rax
mov rax, [rbp+var_28]
add rax, 2
mov [rbp+var_28], rax
jmp short loc_39E0E
loc_39DF6:
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_20], rax
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
loc_39E0E:
jmp short $+2
loc_39E10:
jmp loc_39D90
loc_39E15:
mov rax, [rbp+var_20]
pop rbp
retn
|
long long my_numcells_cp932(long long a1, unsigned __int8 *a2, unsigned long long a3)
{
long long v5; // [rsp+10h] [rbp-20h]
v5 = 0LL;
while ( (unsigned long long)a2 < a3 )
{
if ( *a2 < 0xA1u || *a2 > 0xDFu )
{
if ( *a2 <= 0x7Fu )
{
++v5;
++a2;
}
else
{
v5 += 2LL;
a2 += 2;
}
}
else
{
++v5;
++a2;
}
}
return v5;
}
|
my_numcells_cp932:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV qword ptr [RBP + -0x20],0x0
LAB_00139d90:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNC 0x00139e15
MOV RAX,qword ptr [RBP + -0x28]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0xa1
JL 0x00139dd0
MOV RAX,qword ptr [RBP + -0x28]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0xdf
JG 0x00139dd0
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00139e10
LAB_00139dd0:
MOV RAX,qword ptr [RBP + -0x28]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x7f
JLE 0x00139df6
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x2
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00139e0e
LAB_00139df6:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
LAB_00139e0e:
JMP 0x00139e10
LAB_00139e10:
JMP 0x00139d90
LAB_00139e15:
MOV RAX,qword ptr [RBP + -0x20]
POP RBP
RET
|
long my_numcells_cp932(int8 param_1,byte *param_2,byte *param_3)
{
byte *local_30;
long local_28;
local_28 = 0;
local_30 = param_2;
while (local_30 < param_3) {
if ((*local_30 < 0xa1) || (0xdf < *local_30)) {
if (*local_30 < 0x80) {
local_28 = local_28 + 1;
local_30 = local_30 + 1;
}
else {
local_28 = local_28 + 2;
local_30 = local_30 + 2;
}
}
else {
local_28 = local_28 + 1;
local_30 = local_30 + 1;
}
}
return local_28;
}
|
|
11,785 |
sqr_fp4
|
corpus-core[P]colibri-stateless/build_O3/_deps/blst-src/src/fp12_tower.c
|
static void sqr_fp4(vec384fp4 ret, const vec384x a0, const vec384x a1)
{
vec768x t0, t1, t2;
sqr_fp2x2(t0, a0);
sqr_fp2x2(t1, a1);
add_fp2(ret[1], a0, a1);
mul_by_u_plus_1_fp2x2(t2, t1);
add_fp2x2(t2, t2, t0);
redc_fp2x2(ret[0], t2);
sqr_fp2x2(t2, ret[1]);
sub_fp2x2(t2, t2, t0);
sub_fp2x2(t2, t2, t1);
redc_fp2x2(ret[1], t2);
}
|
O3
|
c
|
sqr_fp4:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp # imm = 0x248
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
leaq 0x248e5(%rip), %rbx # 0x8a910
leaq -0x1b0(%rbp), %rdi
movq %rbx, %rdx
callq 0x71f60
leaq -0xf0(%rbp), %r15
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x71f60
leaq 0x60(%r14), %rdi
movq %rdi, -0x30(%rbp)
movq %r13, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x6d6e0
leaq -0x90(%rbp), %rdx
leaq -0x270(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %rdx, %r15
movq %rbx, %rcx
callq 0x6eac0
leaq -0x210(%rbp), %r13
movq %r13, %rdi
leaq -0xf0(%rbp), %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x6e9a0
movq %r12, %rdi
movq %r12, %rsi
leaq -0x1b0(%rbp), %rdx
movq %rbx, %rcx
callq 0x6e9a0
leaq -0x150(%rbp), %rdx
movq %r13, %rdi
movq %r13, %rsi
movq %rbx, %rcx
callq 0x6e9a0
movabsq $-0x760c000300030003, %r15 # imm = 0x89F3FFFCFFFCFFFD
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x72760
leaq 0x30(%r14), %rdi
movq %r13, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x72760
movq %r12, %rdi
movq -0x30(%rbp), %r15
movq %r15, %rsi
movq %rbx, %rdx
callq 0x71f60
movq %r12, %rdi
movq %r12, %rsi
leaq -0x1b0(%rbp), %rdx
movq %rbx, %rcx
callq 0x6eac0
movq %r13, %rdi
movq %r13, %rsi
leaq -0x150(%rbp), %rdx
movq %rbx, %rcx
callq 0x6eac0
movq %r12, %rdi
movq %r12, %rsi
leaq -0xf0(%rbp), %rdx
movq %rbx, %rcx
callq 0x6eac0
movq %r13, %rdi
movq %r13, %rsi
leaq -0x90(%rbp), %rdx
movq %rbx, %rcx
callq 0x6eac0
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movabsq $-0x760c000300030003, %r15 # imm = 0x89F3FFFCFFFCFFFD
movq %r15, %rcx
callq 0x72760
addq $0x90, %r14
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x72760
addq $0x248, %rsp # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
sqr_fp4:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 248h
mov r12, rdx
mov r13, rsi
mov r14, rdi
lea rbx, BLS12_381_P
lea rdi, [rbp+var_1B0]
mov rdx, rbx
call sqr_382x
lea r15, [rbp+var_F0]
mov rdi, r15
mov rsi, r12
mov rdx, rbx
call sqr_382x
lea rdi, [r14+60h]
mov [rbp+var_30], rdi
mov rsi, r13
mov rdx, r12
mov rcx, rbx
call add_mod_384x
lea rdx, [rbp+var_90]
lea r12, [rbp+var_270]
mov rdi, r12
mov rsi, r15
mov r15, rdx
mov rcx, rbx
call _sub_mod_384x384
lea r13, [rbp+var_210]
mov rdi, r13
lea rsi, [rbp+var_F0]
mov rdx, r15
mov rcx, rbx
call add_mod_384x384
mov rdi, r12
mov rsi, r12
lea rdx, [rbp+var_1B0]
mov rcx, rbx
call add_mod_384x384
lea rdx, [rbp+var_150]
mov rdi, r13
mov rsi, r13
mov rcx, rbx
call add_mod_384x384
mov r15, 89F3FFFCFFFCFFFDh
mov rdi, r14
mov rsi, r12
mov rdx, rbx
mov rcx, r15
call redc_mont_384
lea rdi, [r14+30h]
mov rsi, r13
mov rdx, rbx
mov rcx, r15
call redc_mont_384
mov rdi, r12
mov r15, [rbp+var_30]
mov rsi, r15
mov rdx, rbx
call sqr_382x
mov rdi, r12
mov rsi, r12
lea rdx, [rbp+var_1B0]
mov rcx, rbx
call _sub_mod_384x384
mov rdi, r13
mov rsi, r13
lea rdx, [rbp+var_150]
mov rcx, rbx
call _sub_mod_384x384
mov rdi, r12
mov rsi, r12
lea rdx, [rbp+var_F0]
mov rcx, rbx
call _sub_mod_384x384
mov rdi, r13
mov rsi, r13
lea rdx, [rbp+var_90]
mov rcx, rbx
call _sub_mod_384x384
mov rdi, r15
mov rsi, r12
mov rdx, rbx
mov r15, 89F3FFFCFFFCFFFDh
mov rcx, r15
call redc_mont_384
add r14, 90h
mov rdi, r14
mov rsi, r13
mov rdx, rbx
mov rcx, r15
call redc_mont_384
add rsp, 248h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long sqr_fp4(long long a1, long long a2, long long a3)
{
long long v4; // r15
_BYTE v6[96]; // [rsp+0h] [rbp-270h] BYREF
_BYTE v7[96]; // [rsp+60h] [rbp-210h] BYREF
_BYTE v8[96]; // [rsp+C0h] [rbp-1B0h] BYREF
_BYTE v9[96]; // [rsp+120h] [rbp-150h] BYREF
_BYTE v10[96]; // [rsp+180h] [rbp-F0h] BYREF
_BYTE v11[96]; // [rsp+1E0h] [rbp-90h] BYREF
long long v12; // [rsp+240h] [rbp-30h]
sqr_382x(v8, a2, &BLS12_381_P);
sqr_382x(v10, a3, &BLS12_381_P);
v12 = a1 + 96;
add_mod_384x(a1 + 96, a2, a3, &BLS12_381_P);
sub_mod_384x384(v6, v10, v11, &BLS12_381_P);
add_mod_384x384(v7, v10, v11, &BLS12_381_P);
add_mod_384x384(v6, v6, v8, &BLS12_381_P);
add_mod_384x384(v7, v7, v9, &BLS12_381_P);
redc_mont_384(a1, v6, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
redc_mont_384(a1 + 48, v7, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
v4 = v12;
sqr_382x(v6, v12, &BLS12_381_P);
sub_mod_384x384(v6, v6, v8, &BLS12_381_P);
sub_mod_384x384(v7, v7, v9, &BLS12_381_P);
sub_mod_384x384(v6, v6, v10, &BLS12_381_P);
sub_mod_384x384(v7, v7, v11, &BLS12_381_P);
redc_mont_384(v4, v6, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
return redc_mont_384(a1 + 144, v7, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
}
|
sqr_fp4:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x248
MOV R12,RDX
MOV R13,RSI
MOV R14,RDI
LEA RBX,[0x18a910]
LEA RDI,[RBP + -0x1b0]
MOV RDX,RBX
CALL 0x00171f60
LEA R15,[RBP + -0xf0]
MOV RDI,R15
MOV RSI,R12
MOV RDX,RBX
CALL 0x00171f60
LEA RDI,[R14 + 0x60]
MOV qword ptr [RBP + -0x30],RDI
MOV RSI,R13
MOV RDX,R12
MOV RCX,RBX
CALL 0x0016d6e0
LEA RDX,[RBP + -0x90]
LEA R12,[RBP + -0x270]
MOV RDI,R12
MOV RSI,R15
MOV R15,RDX
MOV RCX,RBX
CALL 0x0016eac0
LEA R13,[RBP + -0x210]
MOV RDI,R13
LEA RSI,[RBP + -0xf0]
MOV RDX,R15
MOV RCX,RBX
CALL 0x0016e9a0
MOV RDI,R12
MOV RSI,R12
LEA RDX,[RBP + -0x1b0]
MOV RCX,RBX
CALL 0x0016e9a0
LEA RDX,[RBP + -0x150]
MOV RDI,R13
MOV RSI,R13
MOV RCX,RBX
CALL 0x0016e9a0
MOV R15,-0x760c000300030003
MOV RDI,R14
MOV RSI,R12
MOV RDX,RBX
MOV RCX,R15
CALL 0x00172760
LEA RDI,[R14 + 0x30]
MOV RSI,R13
MOV RDX,RBX
MOV RCX,R15
CALL 0x00172760
MOV RDI,R12
MOV R15,qword ptr [RBP + -0x30]
MOV RSI,R15
MOV RDX,RBX
CALL 0x00171f60
MOV RDI,R12
MOV RSI,R12
LEA RDX,[RBP + -0x1b0]
MOV RCX,RBX
CALL 0x0016eac0
MOV RDI,R13
MOV RSI,R13
LEA RDX,[RBP + -0x150]
MOV RCX,RBX
CALL 0x0016eac0
MOV RDI,R12
MOV RSI,R12
LEA RDX,[RBP + -0xf0]
MOV RCX,RBX
CALL 0x0016eac0
MOV RDI,R13
MOV RSI,R13
LEA RDX,[RBP + -0x90]
MOV RCX,RBX
CALL 0x0016eac0
MOV RDI,R15
MOV RSI,R12
MOV RDX,RBX
MOV R15,-0x760c000300030003
MOV RCX,R15
CALL 0x00172760
ADD R14,0x90
MOV RDI,R14
MOV RSI,R13
MOV RDX,RBX
MOV RCX,R15
CALL 0x00172760
ADD RSP,0x248
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void sqr_fp4(long param_1,int8 param_2,int8 param_3)
{
long lVar1;
int1 local_278 [96];
int1 local_218 [96];
int1 local_1b8 [96];
int1 local_158 [96];
int1 local_f8 [96];
int1 local_98 [96];
long local_38;
sqr_382x(local_1b8,param_2,BLS12_381_P);
sqr_382x(local_f8,param_3,BLS12_381_P);
local_38 = param_1 + 0x60;
add_mod_384x(local_38,param_2,param_3,BLS12_381_P);
sub_mod_384x384(local_278,local_f8,local_98,BLS12_381_P);
add_mod_384x384(local_218,local_f8,local_98,BLS12_381_P);
add_mod_384x384(local_278,local_278,local_1b8,BLS12_381_P);
add_mod_384x384(local_218,local_218,local_158,BLS12_381_P);
redc_mont_384(param_1,local_278,BLS12_381_P,0x89f3fffcfffcfffd);
redc_mont_384(param_1 + 0x30,local_218,BLS12_381_P,0x89f3fffcfffcfffd);
lVar1 = local_38;
sqr_382x(local_278,local_38,BLS12_381_P);
sub_mod_384x384(local_278,local_278,local_1b8,BLS12_381_P);
sub_mod_384x384(local_218,local_218,local_158,BLS12_381_P);
sub_mod_384x384(local_278,local_278,local_f8,BLS12_381_P);
sub_mod_384x384(local_218,local_218,local_98,BLS12_381_P);
redc_mont_384(lVar1,local_278,BLS12_381_P,0x89f3fffcfffcfffd);
redc_mont_384(param_1 + 0x90,local_218,BLS12_381_P,0x89f3fffcfffcfffd);
return;
}
|
|
11,786 |
wsrep_must_process_fk(upd_node_t const*, trx_t const*)
|
eloqsql/storage/innobase/row/row0upd.cc
|
inline bool wsrep_must_process_fk(const upd_node_t* node, const trx_t* trx)
{
if (!trx->is_wsrep()) {
return false;
}
return que_node_get_type(node->common.parent) != QUE_NODE_UPDATE
|| static_cast<upd_node_t*>(node->common.parent)->cascade_node
!= node;
}
|
O0
|
cpp
|
wsrep_must_process_fk(upd_node_t const*, trx_t const*):
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xfc4210
testb $0x1, %al
jne 0x10f8b63
movb $0x0, -0x1(%rbp)
jmp 0x10f8b9c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10f7020
movq %rax, %rcx
movb $0x1, %al
cmpq $0x4, %rcx
movb %al, -0x19(%rbp)
jne 0x10f8b94
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x58(%rax), %rax
cmpq -0x10(%rbp), %rax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
_Z21wsrep_must_process_fkPK10upd_node_tPK5trx_t:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rdi, [rbp+var_18]; this
call _ZNK5trx_t8is_wsrepEv; trx_t::is_wsrep(void)
test al, 1
jnz short loc_10F8B63
mov [rbp+var_1], 0
jmp short loc_10F8B9C
loc_10F8B63:
mov rax, [rbp+var_10]
mov rdi, [rax+8]; void *
call _ZL17que_node_get_typePKv_3; que_node_get_type(void const*)
mov rcx, rax
mov al, 1
cmp rcx, 4
mov [rbp+var_19], al
jnz short loc_10F8B94
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov rax, [rax+58h]
cmp rax, [rbp+var_10]
setnz al
mov [rbp+var_19], al
loc_10F8B94:
mov al, [rbp+var_19]
and al, 1
mov [rbp+var_1], al
loc_10F8B9C:
mov al, [rbp+var_1]
and al, 1
add rsp, 20h
pop rbp
retn
|
bool wsrep_must_process_fk(const upd_node_t *a1, const trx_t *a2)
{
bool v3; // [rsp+7h] [rbp-19h]
if ( !trx_t::is_wsrep(a2) )
return 0;
v3 = 1;
if ( que_node_get_type(*((const void **)a1 + 1)) == 4 )
return *(_QWORD *)(*((_QWORD *)a1 + 1) + 88LL) != (_QWORD)a1;
return v3;
}
|
_M_end:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x8
POP RBP
RET
|
/* std::_Rb_tree<unsigned long, unsigned long, std::_Identity<unsigned long>, std::less<unsigned
long>, ut_allocator<unsigned long, true> >::_M_end() */
_Rb_tree<unsigned_long,unsigned_long,std::_Identity<unsigned_long>,std::less<unsigned_long>,ut_allocator<unsigned_long,true>>
* __thiscall
std::
_Rb_tree<unsigned_long,unsigned_long,std::_Identity<unsigned_long>,std::less<unsigned_long>,ut_allocator<unsigned_long,true>>
::_M_end(_Rb_tree<unsigned_long,unsigned_long,std::_Identity<unsigned_long>,std::less<unsigned_long>,ut_allocator<unsigned_long,true>>
*this)
{
return this + 8;
}
|
|
11,787 |
ftxui::focusCursorBar(std::shared_ptr<ftxui::Node>)
|
Andrewchistyakov[P]flashcards_lyc/build_O2/_deps/ftxui-src/src/ftxui/dom/frame.cpp
|
Element focusCursorBar(Element child) {
return std::make_shared<FocusCursor>(unpack(std::move(child)),
Screen::Cursor::Bar);
}
|
O2
|
cpp
|
ftxui::focusCursorBar(std::shared_ptr<ftxui::Node>):
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
leaq 0x28(%rsp), %rbx
movups (%rsi), %xmm0
andq $0x0, 0x8(%rsi)
movaps %xmm0, -0x8(%rbx)
andq $0x0, (%rsi)
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x1d99c
leaq 0x4(%rsp), %rdx
movl $0x6, (%rdx)
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2eed6
leaq 0x38(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movups %xmm0, (%r14)
andq $0x0, -0x8(%rdi)
callq 0x13452
leaq 0x8(%rsp), %rdi
callq 0x13b2c
movq %rbx, %rdi
callq 0x13452
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x13b2c
jmp 0x2f108
movq %rax, %r14
movq %rbx, %rdi
callq 0x13452
movq %r14, %rdi
callq 0xc7f0
|
_ZN5ftxui14focusCursorBarESt10shared_ptrINS_4NodeEE:
push r14
push rbx
sub rsp, 48h
mov r14, rdi
lea rbx, [rsp+58h+var_30]
movups xmm0, xmmword ptr [rsi]
and qword ptr [rsi+8], 0
movaps xmmword ptr [rbx-8], xmm0
and qword ptr [rsi], 0
lea rdi, [rsp+58h+var_50]
lea rsi, [rsp+58h+var_38]
call _ZN5ftxui6unpackIJSt10shared_ptrINS_4NodeEEEEESt6vectorIS3_SaIS3_EEDpT_; ftxui::unpack<std::shared_ptr<ftxui::Node>>(std::shared_ptr<ftxui::Node>)
lea rdx, [rsp+58h+var_54]
mov dword ptr [rdx], 6
lea rdi, [rsp+58h+var_28]
lea rsi, [rsp+58h+var_50]
call _ZSt11make_sharedIN5ftxui12_GLOBAL__N_111FocusCursorEJSt6vectorISt10shared_ptrINS0_4NodeEESaIS6_EENS0_6Screen6Cursor5ShapeEEES4_IT_EDpOT0_; std::make_shared<ftxui::`anonymous namespace'::FocusCursor,std::vector<std::shared_ptr<ftxui::Node>>,ftxui::Screen::Cursor::Shape>(std::vector<std::shared_ptr<ftxui::Node>>,ftxui::Screen::Cursor::Shape &&)
lea rdi, [rsp+58h+var_20]
movaps xmm0, xmmword ptr [rdi-8]
and qword ptr [rdi], 0
movups xmmword ptr [r14], 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+58h+var_50]
call _ZNSt6vectorISt10shared_ptrIN5ftxui4NodeEESaIS3_EED2Ev; std::vector<std::shared_ptr<ftxui::Node>>::~vector()
mov rdi, rbx
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rax, r14
add rsp, 48h
pop rbx
pop r14
retn
mov r14, rax
lea rdi, [rsp+arg_0]
call _ZNSt6vectorISt10shared_ptrIN5ftxui4NodeEESaIS3_EED2Ev; std::vector<std::shared_ptr<ftxui::Node>>::~vector()
jmp short loc_2F108
mov r14, rax
loc_2F108:
mov rdi, rbx
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rdi, r14
call __Unwind_Resume
|
_OWORD * ftxui::focusCursorBar(_OWORD *a1, __int128 *a2)
{
__int128 v2; // xmm0
__int128 v3; // xmm0
int v5; // [rsp+4h] [rbp-54h] BYREF
__int128 v6; // [rsp+8h] [rbp-50h] BYREF
__int128 v7; // [rsp+20h] [rbp-38h] BYREF
_OWORD v8[2]; // [rsp+30h] [rbp-28h] BYREF
v2 = *a2;
*((_QWORD *)a2 + 1) = 0LL;
v7 = v2;
*(_QWORD *)a2 = 0LL;
ftxui::unpack<std::shared_ptr<ftxui::Node>>((long long)&v6, (long long)&v7);
v5 = 6;
std::make_shared<ftxui::`anonymous namespace'::FocusCursor,std::vector<std::shared_ptr<ftxui::Node>>,ftxui::Screen::Cursor::Shape>(
v8,
&v6,
&v5);
v3 = v8[0];
*((_QWORD *)&v8[0] + 1) = 0LL;
*a1 = v3;
*(_QWORD *)&v8[0] = 0LL;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count((_QWORD *)v8 + 1);
std::vector<std::shared_ptr<ftxui::Node>>::~vector(&v6);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count((_QWORD *)&v7 + 1);
return a1;
}
|
focusCursorBar:
PUSH R14
PUSH RBX
SUB RSP,0x48
MOV R14,RDI
LEA RBX,[RSP + 0x28]
MOVUPS XMM0,xmmword ptr [RSI]
AND qword ptr [RSI + 0x8],0x0
MOVAPS xmmword ptr [RBX + -0x8],XMM0
AND qword ptr [RSI],0x0
LAB_0012f095:
LEA RDI,[RSP + 0x8]
LEA RSI,[RSP + 0x20]
CALL 0x0011d99c
LEA RDX,[RSP + 0x4]
MOV dword ptr [RDX],0x6
LAB_0012f0af:
LEA RDI,[RSP + 0x30]
LEA RSI,[RSP + 0x8]
CALL 0x0012eed6
LAB_0012f0be:
LEA RDI,[RSP + 0x38]
MOVAPS XMM0,xmmword ptr [RDI + -0x8]
AND qword ptr [RDI],0x0
MOVUPS xmmword ptr [R14],XMM0
AND qword ptr [RDI + -0x8],0x0
CALL 0x00113452
LEA RDI,[RSP + 0x8]
CALL 0x00113b2c
MOV RDI,RBX
CALL 0x00113452
MOV RAX,R14
ADD RSP,0x48
POP RBX
POP R14
RET
|
/* ftxui::focusCursorBar(std::shared_ptr<ftxui::Node>) */
ftxui * __thiscall ftxui::focusCursorBar(ftxui *this,int8 *param_2)
{
int8 uVar1;
ftxui local_50 [24];
int4 local_38;
int4 uStack_34;
int4 uStack_30;
int4 uStack_2c;
int8 local_28;
int8 auStack_20 [2];
local_38 = *(int4 *)param_2;
uStack_34 = *(int4 *)((long)param_2 + 4);
uStack_30 = *(int4 *)(param_2 + 1);
uStack_2c = *(int4 *)((long)param_2 + 0xc);
param_2[1] = 0;
*param_2 = 0;
/* try { // try from 0012f095 to 0012f0a3 has its CatchHandler @ 0012f105 */
unpack<std::shared_ptr<ftxui::Node>>(local_50,&local_38);
/* try { // try from 0012f0af to 0012f0bd has its CatchHandler @ 0012f0f6 */
std::
make_shared<ftxui::(anonymous_namespace)::FocusCursor,std::vector<std::shared_ptr<ftxui::Node>,std::allocator<std::shared_ptr<ftxui::Node>>>,ftxui::Screen::Cursor::Shape>
((vector *)&local_28,(Shape *)local_50);
uVar1 = auStack_20[0];
auStack_20[0] = 0;
*(int8 *)this = local_28;
*(int8 *)(this + 8) = uVar1;
local_28 = 0;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)auStack_20);
std::vector<std::shared_ptr<ftxui::Node>,std::allocator<std::shared_ptr<ftxui::Node>>>::~vector
((vector<std::shared_ptr<ftxui::Node>,std::allocator<std::shared_ptr<ftxui::Node>>> *)
local_50);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)&uStack_30);
return this;
}
|
|
11,788 |
yoyo::BufferQueen<yoyo::Message>::enqueen(yoyo::Message&&)
|
isyoCode[P]yoyologger/test/../src/logger.hpp
|
void enqueen(T&& item) {
{
std::unique_lock<std::mutex> lock(_Mtx);
_isPushCv.wait(lock, [this]() { return !_dataQueen.isFull(); });
_dataQueen.push(std::move(item));
}
_isPopCv.notify_one();
}
|
O1
|
cpp
|
yoyo::BufferQueen<yoyo::Message>::enqueen(yoyo::Message&&):
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %rdi, (%r15)
movb $0x0, 0x8(%r15)
movq %r15, %rdi
callq 0x4d5a
movb $0x1, 0x8(%r15)
leaq 0x28(%rbx), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x6690
leaq 0x88(%rbx), %rdi
movq %r14, %rsi
callq 0x66e8
movq %rsp, %rdi
callq 0x4d44
addq $0x58, %rbx
movq %rbx, %rdi
callq 0x3120
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4d44
movq %rbx, %rdi
callq 0x33a0
|
_ZN4yoyo11BufferQueenINS_7MessageEE7enqueenEOS1_:
push r15
push r14
push rbx
sub rsp, 10h
mov r14, rsi
mov rbx, rdi
mov r15, rsp
mov [r15], rdi
mov byte ptr [r15+8], 0
mov rdi, r15
call _ZNSt11unique_lockISt5mutexE4lockEv; std::unique_lock<std::mutex>::lock(void)
mov byte ptr [r15+8], 1
lea rdi, [rbx+28h]
mov rsi, r15
mov rdx, rbx
call _ZNSt18condition_variable4waitIZN4yoyo11BufferQueenINS1_7MessageEE7enqueenEOS3_EUlvE_EEvRSt11unique_lockISt5mutexET_; std::condition_variable::wait<yoyo::BufferQueen<yoyo::Message>::enqueen(yoyo::Message&&)::{lambda(void)#1}>(std::unique_lock<std::mutex> &,yoyo::BufferQueen<yoyo::Message>::enqueen(yoyo::Message&&)::{lambda(void)#1})
lea rdi, [rbx+88h]
mov rsi, r14
call _ZN4yoyo11CirculQueenINS_7MessageEE4pushEOS1_; yoyo::CirculQueen<yoyo::Message>::push(yoyo::Message&&)
mov rdi, rsp
call _ZNSt11unique_lockISt5mutexED2Ev; std::unique_lock<std::mutex>::~unique_lock()
add rbx, 58h ; 'X'
mov rdi, rbx; this
call __ZNSt18condition_variable10notify_oneEv; std::condition_variable::notify_one(void)
add rsp, 10h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
mov rdi, rsp
call _ZNSt11unique_lockISt5mutexED2Ev; std::unique_lock<std::mutex>::~unique_lock()
mov rdi, rbx
call __Unwind_Resume
|
long long yoyo::BufferQueen<yoyo::Message>::enqueen(long long a1, long long a2)
{
long long v3; // [rsp+0h] [rbp-28h] BYREF
char v4; // [rsp+8h] [rbp-20h]
v3 = a1;
v4 = 0;
std::unique_lock<std::mutex>::lock(&v3);
v4 = 1;
std::condition_variable::wait<yoyo::BufferQueen<yoyo::Message>::enqueen(yoyo::Message&&)::{lambda(void)#1}>(
a1 + 40,
&v3,
a1);
yoyo::CirculQueen<yoyo::Message>::push(a1 + 136, a2);
std::unique_lock<std::mutex>::~unique_lock((long long)&v3);
return std::condition_variable::notify_one((std::condition_variable *)(a1 + 88));
}
|
enqueen:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV R14,RSI
MOV RBX,RDI
MOV R15,RSP
MOV qword ptr [R15],RDI
MOV byte ptr [R15 + 0x8],0x0
MOV RDI,R15
CALL 0x00104d5a
MOV byte ptr [R15 + 0x8],0x1
LEA RDI,[RBX + 0x28]
LAB_001065e9:
MOV RSI,R15
MOV RDX,RBX
CALL 0x00106690
LAB_001065f4:
LEA RDI,[RBX + 0x88]
MOV RSI,R14
CALL 0x001066e8
MOV RDI,RSP
CALL 0x00104d44
ADD RBX,0x58
MOV RDI,RBX
CALL 0x00103120
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
|
/* yoyo::BufferQueen<yoyo::Message>::enqueen(yoyo::Message&&) */
void __thiscall
yoyo::BufferQueen<yoyo::Message>::enqueen(BufferQueen<yoyo::Message> *this,Message *param_1)
{
BufferQueen<yoyo::Message> *local_28;
int1 local_20;
local_20 = 0;
local_28 = this;
std::unique_lock<std::mutex>::lock();
local_20 = 1;
/* try { // try from 001065e9 to 001065f3 has its CatchHandler @ 00106621 */
std::condition_variable::
wait<yoyo::BufferQueen<yoyo::Message>::enqueen(yoyo::Message&&)::_lambda()_1_>
((condition_variable *)(this + 0x28),&local_28,this);
CirculQueen<yoyo::Message>::push((CirculQueen<yoyo::Message> *)(this + 0x88),param_1);
std::unique_lock<std::mutex>::~unique_lock((unique_lock<std::mutex> *)&local_28);
std::condition_variable::notify_one();
return;
}
|
|
11,789 |
my_caseup_utf16
|
eloqsql/strings/ctype-ucs2.c
|
static size_t
my_caseup_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_toupper_utf16(uni_plane, &wc);
if (res != wc_mb(cs, wc, (uchar *) dst, (uchar *) dstend))
break;
src+= res;
dst+= res;
}
return srclen;
}
|
O0
|
c
|
my_caseup_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 0x6d7b8
jmp 0x6d7ba
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x50(%rbp), %rcx
movb %al, -0x61(%rbp)
jae 0x6d7eb
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 0x6d7f4
jmp 0x6d84f
movq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x70d40
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 0x6d828
jmp 0x6d84f
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 0x6d7ba
movq -0x18(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
|
my_caseup_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_6D7B8:
jmp short $+2
loc_6D7BA:
mov rcx, [rbp+var_10]
xor eax, eax
cmp rcx, [rbp+var_50]
mov [rbp+var_61], al
jnb short loc_6D7EB
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_6D7EB:
mov al, [rbp+var_61]
test al, 1
jnz short loc_6D7F4
jmp short loc_6D84F
loc_6D7F4:
mov rdi, [rbp+var_60]
lea rsi, [rbp+var_30]
call my_toupper_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_6D828
jmp short loc_6D84F
loc_6D828:
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_6D7BA
loc_6D84F:
mov rax, [rbp+var_18]
add rsp, 70h
pop rbp
retn
|
long long my_caseup_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_toupper_utf16(v7, v13);
if ( v10 != v11(v17, v13[0], v14, v8) )
break;
v16 += v10;
v14 += v10;
}
return v15;
}
|
my_caseup_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 0x0016d7b8
LAB_0016d7b8:
JMP 0x0016d7ba
LAB_0016d7ba:
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x50]
MOV byte ptr [RBP + -0x61],AL
JNC 0x0016d7eb
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_0016d7eb:
MOV AL,byte ptr [RBP + -0x61]
TEST AL,0x1
JNZ 0x0016d7f4
JMP 0x0016d84f
LAB_0016d7f4:
MOV RDI,qword ptr [RBP + -0x60]
LEA RSI,[RBP + -0x30]
CALL 0x00170d40
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 0x0016d828
JMP 0x0016d84f
LAB_0016d828:
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 0x0016d7ba
LAB_0016d84f:
MOV RAX,qword ptr [RBP + -0x18]
ADD RSP,0x70
POP RBP
RET
|
long my_caseup_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_toupper_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;
}
|
|
11,790 |
read_to_buffer
|
eloqsql/storage/myisam/sort.c
|
static my_off_t read_to_buffer(IO_CACHE *fromfile, BUFFPEK *buffpek,
uint sort_length)
{
register ha_keys count;
size_t length;
if ((count= (ha_keys) MY_MIN((ha_rows) buffpek->max_keys,
(ha_rows) buffpek->count)))
{
if (my_b_pread(fromfile, (uchar*) buffpek->base,
(length= (size_t) (sort_length * count)),
buffpek->file_pos))
return(HA_OFFSET_ERROR);
buffpek->key=buffpek->base;
buffpek->file_pos+= length; /* New filepos */
buffpek->count-= count;
buffpek->mem_count= count;
}
return (((my_off_t) count) * sort_length);
}
|
O0
|
c
|
read_to_buffer:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x12fab63
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x12fab6f
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x12fabef
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movl -0x1c(%rbp), %eax
movl %eax, %edx
imulq -0x28(%rbp), %rdx
movq %rdx, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
callq 0x130cb00
cmpl $0x0, %eax
je 0x12fabb2
movq $-0x1, -0x8(%rbp)
jmp 0x12fabfe
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
imulq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
read_to_buffer_0:
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_18]
mov rax, [rax+28h]
mov rcx, [rbp+var_18]
cmp rax, [rcx+18h]
jnb short loc_12FAB63
mov rax, [rbp+var_18]
mov rax, [rax+28h]
mov [rbp+var_38], rax
jmp short loc_12FAB6F
loc_12FAB63:
mov rax, [rbp+var_18]
mov rax, [rax+18h]
mov [rbp+var_38], rax
loc_12FAB6F:
mov rax, [rbp+var_38]
mov [rbp+var_28], rax
cmp rax, 0
jz short loc_12FABEF
mov rdi, [rbp+var_10]
mov rax, [rbp+var_18]
mov rsi, [rax+8]
mov eax, [rbp+var_1C]
mov edx, eax
imul rdx, [rbp+var_28]
mov [rbp+var_30], rdx
mov rax, [rbp+var_18]
mov rcx, [rax]
call my_b_pread
cmp eax, 0
jz short loc_12FABB2
mov [rbp+var_8], 0FFFFFFFFFFFFFFFFh
jmp short loc_12FABFE
loc_12FABB2:
mov rax, [rbp+var_18]
mov rcx, [rax+8]
mov rax, [rbp+var_18]
mov [rax+10h], rcx
mov rcx, [rbp+var_30]
mov rax, [rbp+var_18]
add rcx, [rax]
mov [rax], rcx
mov rdx, [rbp+var_28]
mov rax, [rbp+var_18]
mov rcx, [rax+18h]
sub rcx, rdx
mov [rax+18h], rcx
mov rcx, [rbp+var_28]
mov rax, [rbp+var_18]
mov [rax+20h], rcx
loc_12FABEF:
mov rax, [rbp+var_28]
mov ecx, [rbp+var_1C]
imul rax, rcx
mov [rbp+var_8], rax
loc_12FABFE:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
|
long long read_to_buffer_0(long long a1, _QWORD *a2, unsigned int a3)
{
long long v4; // [rsp+8h] [rbp-38h]
if ( a2[5] >= a2[3] )
v4 = a2[3];
else
v4 = a2[5];
if ( !v4 )
return a3 * v4;
if ( !(unsigned int)my_b_pread(a1, a2[1], v4 * a3, *a2) )
{
a2[2] = a2[1];
*a2 += v4 * a3;
a2[3] -= v4;
a2[4] = v4;
return a3 * v4;
}
return -1LL;
}
|
trx_i_s_cache_get_rows_used:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0xc]
CALL 0x012fab60
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
ADD RSP,0x20
POP RBP
RET
|
/* trx_i_s_cache_get_rows_used(trx_i_s_cache_t*, i_s_table) */
int8 trx_i_s_cache_get_rows_used(int8 param_1,int4 param_2)
{
int8 *puVar1;
puVar1 = (int8 *)cache_select_table(param_1,param_2);
return *puVar1;
}
|
|
11,791 |
SDL_GetRenderViewport
|
SDL3Lite/source/SDL3/SDL_Renderer.cpp
|
bool SDL_GetRenderViewport(SDL_Renderer* renderer, SDL_Rect* rect)
{
assert(renderer);
assert(rect);
rect->x = 0;
rect->y = 0;
rect->w = renderer->GetSize().x;
rect->h = renderer->GetSize().y;
return true;
}
|
O0
|
cpp
|
SDL_GetRenderViewport:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x26239
jmp 0x26258
leaq 0xd8f7(%rip), %rdi # 0x33b37
leaq 0xd84f(%rip), %rsi # 0x33a96
movl $0xd1, %edx
leaq 0xdad0(%rip), %rcx # 0x33d23
callq 0x1a190
cmpq $0x0, -0x10(%rbp)
je 0x26261
jmp 0x26280
leaq 0xc54b(%rip), %rdi # 0x327b3
leaq 0xd827(%rip), %rsi # 0x33a96
movl $0xd2, %edx
leaq 0xdaa8(%rip), %rcx # 0x33d23
callq 0x1a190
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl 0x4(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
SDL_GetRenderViewport:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
cmp [rbp+var_8], 0
jz short loc_26239
jmp short loc_26258
loc_26239:
lea rdi, aRenderer; "renderer"
lea rsi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github2025/SDL3Li"...
mov edx, 0D1h
lea rcx, aBoolSdlGetrend; "bool SDL_GetRenderViewport(SDL_Renderer"...
call ___assert_fail
loc_26258:
cmp [rbp+var_10], 0
jz short loc_26261
jmp short loc_26280
loc_26261:
lea rdi, aGldispatchcomp_2+15h; "rect"
lea rsi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github2025/SDL3Li"...
mov edx, 0D2h
lea rcx, aBoolSdlGetrend; "bool SDL_GetRenderViewport(SDL_Renderer"...
call ___assert_fail
loc_26280:
mov rax, [rbp+var_10]
mov dword ptr [rax], 0
mov rax, [rbp+var_10]
mov dword ptr [rax+4], 0
mov rdi, [rbp+var_8]
mov rax, [rdi]
call qword ptr [rax+18h]
mov ecx, [rax]
mov rax, [rbp+var_10]
mov [rax+8], ecx
mov rdi, [rbp+var_8]
mov rax, [rdi]
call qword ptr [rax+18h]
mov ecx, [rax+4]
mov rax, [rbp+var_10]
mov [rax+0Ch], ecx
mov al, 1
and al, 1
add rsp, 10h
pop rbp
retn
|
char SDL_GetRenderViewport(long long a1, _DWORD *a2)
{
if ( !a1 )
__assert_fail(
"renderer",
"/workspace/llm4binary/github2025/SDL3Lite/source/SDL3/SDL_Renderer.cpp",
209LL,
"bool SDL_GetRenderViewport(SDL_Renderer *, SDL_Rect *)");
if ( !a2 )
__assert_fail(
"rect",
"/workspace/llm4binary/github2025/SDL3Lite/source/SDL3/SDL_Renderer.cpp",
210LL,
"bool SDL_GetRenderViewport(SDL_Renderer *, SDL_Rect *)");
*a2 = 0;
a2[1] = 0;
a2[2] = *(_DWORD *)(*(long long ( **)(long long))(*(_QWORD *)a1 + 24LL))(a1);
a2[3] = *(_DWORD *)((*(long long ( **)(long long))(*(_QWORD *)a1 + 24LL))(a1) + 4);
return 1;
}
|
SDL_GetRenderViewport:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
CMP qword ptr [RBP + -0x8],0x0
JZ 0x00126239
JMP 0x00126258
LAB_00126239:
LEA RDI,[0x133b37]
LEA RSI,[0x133a96]
MOV EDX,0xd1
LEA RCX,[0x133d23]
CALL 0x0011a190
LAB_00126258:
CMP qword ptr [RBP + -0x10],0x0
JZ 0x00126261
JMP 0x00126280
LAB_00126261:
LEA RDI,[0x1327b3]
LEA RSI,[0x133a96]
MOV EDX,0xd2
LEA RCX,[0x133d23]
CALL 0x0011a190
LAB_00126280:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x4],0x0
MOV RDI,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
MOV ECX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x8],ECX
MOV RDI,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
MOV ECX,dword ptr [RAX + 0x4]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xc],ECX
MOV AL,0x1
AND AL,0x1
ADD RSP,0x10
POP RBP
RET
|
int8 SDL_GetRenderViewport(long *param_1,int4 *param_2)
{
int4 *puVar1;
long lVar2;
if (param_1 == (long *)0x0) {
/* WARNING: Subroutine does not return */
__assert_fail("renderer",
"/workspace/llm4binary/github2025/SDL3Lite/source/SDL3/SDL_Renderer.cpp",0xd1,
"bool SDL_GetRenderViewport(SDL_Renderer *, SDL_Rect *)");
}
if (param_2 != (int4 *)0x0) {
*param_2 = 0;
param_2[1] = 0;
puVar1 = (int4 *)(**(code **)(*param_1 + 0x18))();
param_2[2] = *puVar1;
lVar2 = (**(code **)(*param_1 + 0x18))();
param_2[3] = *(int4 *)(lVar2 + 4);
return 1;
}
/* WARNING: Subroutine does not return */
__assert_fail("rect","/workspace/llm4binary/github2025/SDL3Lite/source/SDL3/SDL_Renderer.cpp",0xd2
,"bool SDL_GetRenderViewport(SDL_Renderer *, SDL_Rect *)");
}
|
|
11,792 |
FileWriterJson::FileWriterJson(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
|
shubhamoy[P]dir2txt/src/FileWriterJson.cpp
|
FileWriterJson::FileWriterJson(const std::string& outputFile, bool stripComments)
: outputFileName(outputFile), stripComments(stripComments) {
out.open(outputFile);
if (!out) {
std::cerr << "❌ Failed to open output file: " << outputFile << std::endl;
std::exit(1);
}
}
|
O1
|
cpp
|
FileWriterJson::FileWriterJson(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x26123(%rip), %rax # 0x4db38
movq %rax, (%rdi)
leaq 0x8(%rdi), %r14
movb $0x0, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movq %r14, %rdi
movl $0x1, %esi
callq 0x29abe
movq %r14, 0x10(%rsp)
movq %r14, %rdi
movl $0x1, %esi
callq 0x29abe
leaq 0x18(%rbx), %r14
movq %r14, %rdi
callq 0x85b0
leaq 0x218(%rbx), %r15
leaq 0x228(%rbx), %rax
movq %rax, 0x8(%rsp)
movq %rax, 0x218(%rbx)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x9eca
leaq 0x238(%rbx), %r13
movq %r13, %rdi
callq 0xba58
movb %bpl, 0x260(%rbx)
movq %r14, %rdi
movq %r12, %rsi
movl $0x10, %edx
callq 0x81b0
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r14,%rax)
jne 0x27ac5
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2651c(%rip), %rdi # 0x4dfe8
leaq 0xf412(%rip), %rsi # 0x36ee5
movl $0x20, %edx
callq 0x8400
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq 0x264fb(%rip), %rdi # 0x4dfe8
callq 0x8400
movq %rax, %rdi
callq 0x81c0
movl $0x1, %edi
callq 0x8430
movq %rax, %r12
jmp 0x27b33
movq %rax, %r12
jmp 0x27b3b
movq %rax, %r12
movq %r13, %rdi
callq 0x9990
movq (%r15), %rdi
cmpq 0x8(%rsp), %rdi
je 0x27b33
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x8380
movq %r14, %rdi
callq 0x8510
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x29abe
movq %rbx, %rdi
callq 0x29b94
movq %r12, %rdi
callq 0x85d0
|
_ZN14FileWriterJsonC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEb:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov ebp, edx
mov r12, rsi
mov rbx, rdi
lea rax, off_4DB38
mov [rdi], rax
lea r14, [rdi+8]
mov byte ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov [rsp+48h+var_38], r14
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
lea r14, [rbx+18h]
mov rdi, r14
call __ZNSt14basic_ofstreamIcSt11char_traitsIcEEC1Ev; std::ofstream::basic_ofstream(void)
lea r15, [rbx+218h]
lea rax, [rbx+228h]
mov [rsp+48h+var_40], rax
mov [rbx+218h], rax
mov rsi, [r12]
mov rdx, [r12+8]
add rdx, rsi
mov rdi, r15
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
lea r13, [rbx+238h]
mov rdi, r13; this
call _ZNSt10filesystem7__cxx114pathC2Ev; std::filesystem::__cxx11::path::path(void)
mov [rbx+260h], bpl
mov rdi, r14
mov rsi, r12
mov edx, 10h
call __ZNSt14basic_ofstreamIcSt11char_traitsIcEE4openERKNSt7__cxx1112basic_stringIcS1_SaIcEEESt13_Ios_Openmode; std::ofstream::open(std::string const&,std::_Ios_Openmode)
mov rax, [r14]
mov rax, [rax-18h]
test byte ptr [r14+rax+20h], 5
jnz short loc_27AC5
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_27AC5:
mov rdi, cs:_ZSt4cerr_ptr
lea rsi, unk_36EE5
mov edx, 20h ; ' '
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rsi, [r12]
mov rdx, [r12+8]
mov rdi, cs:_ZSt4cerr_ptr
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rdi, rax
call __ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_; std::endl<char,std::char_traits<char>>(std::ostream &)
mov edi, 1
call _exit
mov r12, rax
jmp short loc_27B33
mov r12, rax
jmp short loc_27B3B
mov r12, rax
mov rdi, r13; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
mov rdi, [r15]; void *
cmp rdi, [rsp+48h+var_40]
jz short loc_27B33
mov rax, [rsp+48h+var_40]
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_27B33:
mov rdi, r14
call __ZNSt14basic_ofstreamIcSt11char_traitsIcEED1Ev; std::ofstream::~ofstream()
loc_27B3B:
mov rbx, [rsp+48h+var_38]
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, r12
call __Unwind_Resume
|
long long FileWriterJson::FileWriterJson(long long a1, _QWORD *a2, char a3)
{
long long result; // rax
long long v5; // rax
*(_QWORD *)a1 = off_4DB38;
*(_BYTE *)(a1 + 8) = 0;
*(_QWORD *)(a1 + 16) = 0LL;
nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(
a1 + 8,
1LL);
nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(
a1 + 8,
1LL);
std::ofstream::basic_ofstream(a1 + 24);
*(_QWORD *)(a1 + 536) = a1 + 552;
std::string::_M_construct<char *>((long long *)(a1 + 536), (_BYTE *)*a2, *a2 + a2[1]);
std::filesystem::__cxx11::path::path((std::filesystem::__cxx11::path *)(a1 + 568));
*(_BYTE *)(a1 + 608) = a3;
std::ofstream::open(a1 + 24, a2, 16LL);
result = *(_QWORD *)(*(_QWORD *)(a1 + 24) - 24LL);
if ( (*(_BYTE *)(a1 + 24 + result + 32) & 5) != 0 )
{
std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, &unk_36EE5, 32LL);
v5 = std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, *a2, a2[1]);
std::endl<char,std::char_traits<char>>(v5);
exit(1LL);
}
return result;
}
|
FileWriterJson:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV EBP,EDX
MOV R12,RSI
MOV RBX,RDI
LEA RAX,[0x14db38]
MOV qword ptr [RDI],RAX
LEA R14,[RDI + 0x8]
MOV byte ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV RDI,R14
MOV ESI,0x1
CALL 0x00129abe
MOV qword ptr [RSP + 0x10],R14
MOV RDI,R14
MOV ESI,0x1
CALL 0x00129abe
LEA R14,[RBX + 0x18]
LAB_00127a4b:
MOV RDI,R14
CALL 0x001085b0
LEA R15,[RBX + 0x218]
LEA RAX,[RBX + 0x228]
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RBX + 0x218],RAX
MOV RSI,qword ptr [R12]
MOV RDX,qword ptr [R12 + 0x8]
ADD RDX,RSI
LAB_00127a79:
MOV RDI,R15
CALL 0x00109eca
LEA R13,[RBX + 0x238]
MOV RDI,R13
CALL 0x0010ba58
MOV byte ptr [RBX + 0x260],BPL
LAB_00127a97:
MOV RDI,R14
MOV RSI,R12
MOV EDX,0x10
CALL 0x001081b0
MOV RAX,qword ptr [R14]
MOV RAX,qword ptr [RAX + -0x18]
TEST byte ptr [R14 + RAX*0x1 + 0x20],0x5
JNZ 0x00127ac5
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00127ac5:
MOV RDI,qword ptr [0x0014dfe8]
LEA RSI,[0x136ee5]
MOV EDX,0x20
CALL 0x00108400
MOV RSI,qword ptr [R12]
MOV RDX,qword ptr [R12 + 0x8]
MOV RDI,qword ptr [0x0014dfe8]
CALL 0x00108400
MOV RDI,RAX
CALL 0x001081c0
LAB_00127afa:
MOV EDI,0x1
CALL 0x00108430
|
/* FileWriterJson::FileWriterJson(std::__cxx11::string const&, bool) */
void __thiscall FileWriterJson::FileWriterJson(FileWriterJson *this,string *param_1,bool param_2)
{
ofstream *this_00;
ostream *poVar1;
bool bVar2;
*(int ***)this = &PTR__FileWriterJson_0014db38;
bVar2 = (bool)((char)this + '\b');
this[8] = (FileWriterJson)0x0;
*(int8 *)(this + 0x10) = 0;
nlohmann::json_abi_v3_12_0::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar2);
nlohmann::json_abi_v3_12_0::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar2);
this_00 = (ofstream *)(this + 0x18);
/* try { // try from 00127a4b to 00127a52 has its CatchHandler @ 00127b09 */
std::ofstream::ofstream(this_00);
*(FileWriterJson **)(this + 0x218) = this + 0x228;
/* try { // try from 00127a79 to 00127a80 has its CatchHandler @ 00127b04 */
std::__cxx11::string::_M_construct<char*>
(this + 0x218,*(long *)param_1,*(long *)(param_1 + 8) + *(long *)param_1);
std::filesystem::__cxx11::path::path((path *)(this + 0x238));
this[0x260] = (FileWriterJson)param_2;
/* try { // try from 00127a97 to 00127af9 has its CatchHandler @ 00127b0e */
std::ofstream::open(this_00,param_1,0x10);
if (((byte)this[*(long *)(*(long *)this_00 + -0x18) + 0x38] & 5) == 0) {
return;
}
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cerr_0014dfe8,&DAT_00136ee5,0x20);
poVar1 = std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cerr_0014dfe8,*(char **)param_1,*(long *)(param_1 + 8));
std::endl<char,std::char_traits<char>>(poVar1);
/* WARNING: Subroutine does not return */
exit(1);
}
|
|
11,793 |
js_regexp_get_source
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_regexp_get_source(JSContext *ctx, JSValue this_val)
{
JSRegExp *re;
JSString *p;
StringBuffer b_s, *b = &b_s;
int i, n, c, c2, bra;
if (JS_VALUE_GET_TAG(this_val) != JS_TAG_OBJECT)
return JS_ThrowTypeErrorNotAnObject(ctx);
if (js_same_value(ctx, this_val, ctx->class_proto[JS_CLASS_REGEXP]))
goto empty_regex;
re = js_get_regexp(ctx, this_val, TRUE);
if (!re)
return JS_EXCEPTION;
p = re->pattern;
if (p->len == 0) {
empty_regex:
return js_new_string8(ctx, "(?:)");
}
string_buffer_init2(ctx, b, p->len, p->is_wide_char);
/* Escape '/' and newline sequences as needed */
bra = 0;
for (i = 0, n = p->len; i < n;) {
c2 = -1;
switch (c = string_get(p, i++)) {
case '\\':
if (i < n)
c2 = string_get(p, i++);
break;
case ']':
bra = 0;
break;
case '[':
if (!bra) {
if (i < n && string_get(p, i) == ']')
c2 = string_get(p, i++);
bra = 1;
}
break;
case '\n':
c = '\\';
c2 = 'n';
break;
case '\r':
c = '\\';
c2 = 'r';
break;
case '/':
if (!bra) {
c = '\\';
c2 = '/';
}
break;
}
string_buffer_putc16(b, c);
if (c2 >= 0)
string_buffer_putc16(b, c2);
}
return string_buffer_end(b);
}
|
O0
|
c
|
js_regexp_get_source:
subq $0x78, %rsp
movq %rsi, 0x58(%rsp)
movq %rdx, 0x60(%rsp)
movq %rdi, 0x50(%rsp)
leaq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x60(%rsp), %rax
cmpl $-0x1, %eax
je 0x7dbd0
movq 0x50(%rsp), %rdi
callq 0x2e2e0
movq %rax, 0x68(%rsp)
movq %rdx, 0x70(%rsp)
jmp 0x7de4e
movq 0x50(%rsp), %rdi
movq 0x50(%rsp), %rax
movq 0x40(%rax), %rax
movq 0x58(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq 0x120(%rax), %rcx
movq 0x128(%rax), %r8
callq 0x34850
cmpl $0x0, %eax
je 0x7dc02
jmp 0x7dc61
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x60(%rsp), %rdx
movl $0x1, %ecx
callq 0x83010
movq %rax, 0x48(%rsp)
cmpq $0x0, 0x48(%rsp)
jne 0x7dc3e
movl $0x0, 0x68(%rsp)
movq $0x6, 0x70(%rsp)
jmp 0x7de4e
movq 0x48(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq 0x4(%rax), %rax
andq $0x7fffffff, %rax # imm = 0x7FFFFFFF
cmpl $0x0, %eax
jne 0x7dc81
jmp 0x7dc61
movq 0x50(%rsp), %rdi
leaq 0x8f813(%rip), %rsi # 0x10d480
callq 0x38330
movq %rax, 0x68(%rsp)
movq %rdx, 0x70(%rsp)
jmp 0x7de4e
movq 0x50(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x40(%rsp), %rax
movq 0x4(%rax), %rax
andq $0x7fffffff, %rax # imm = 0x7FFFFFFF
movl %eax, %edx
movq 0x40(%rsp), %rax
movq 0x4(%rax), %rax
shrq $0x1f, %rax
andq $0x1, %rax
movzbl %al, %ecx
callq 0x4c6f0
movl $0x0, 0x4(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x40(%rsp), %rax
movq 0x4(%rax), %rax
andq $0x7fffffff, %rax # imm = 0x7FFFFFFF
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jge 0x7de3a
movl $0xffffffff, 0x8(%rsp) # imm = 0xFFFFFFFF
movq 0x40(%rsp), %rdi
movl 0x14(%rsp), %esi
movl %esi, %eax
incl %eax
movl %eax, 0x14(%rsp)
callq 0x5b910
movl %eax, 0xc(%rsp)
movl %eax, %ecx
movl %ecx, (%rsp)
subl $0xa, %eax
je 0x7ddd5
jmp 0x7dd18
movl (%rsp), %eax
subl $0xd, %eax
je 0x7dde7
jmp 0x7dd26
movl (%rsp), %eax
subl $0x2f, %eax
je 0x7ddf9
jmp 0x7dd34
movl (%rsp), %eax
subl $0x5b, %eax
je 0x7dd8c
jmp 0x7dd3e
movl (%rsp), %eax
subl $0x5c, %eax
je 0x7dd55
jmp 0x7dd48
movl (%rsp), %eax
subl $0x5d, %eax
je 0x7dd7f
jmp 0x7de12
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jge 0x7dd7a
movq 0x40(%rsp), %rdi
movl 0x14(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
callq 0x5b910
movl %eax, 0x8(%rsp)
jmp 0x7de12
movl $0x0, 0x4(%rsp)
jmp 0x7de12
cmpl $0x0, 0x4(%rsp)
jne 0x7ddd3
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jge 0x7ddcb
movq 0x40(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x5b910
cmpl $0x5d, %eax
jne 0x7ddcb
movq 0x40(%rsp), %rdi
movl 0x14(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
callq 0x5b910
movl %eax, 0x8(%rsp)
movl $0x1, 0x4(%rsp)
jmp 0x7de12
movl $0x5c, 0xc(%rsp)
movl $0x6e, 0x8(%rsp)
jmp 0x7de12
movl $0x5c, 0xc(%rsp)
movl $0x72, 0x8(%rsp)
jmp 0x7de12
cmpl $0x0, 0x4(%rsp)
jne 0x7de10
movl $0x5c, 0xc(%rsp)
movl $0x2f, 0x8(%rsp)
jmp 0x7de12
movq 0x18(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x7d3d0
cmpl $0x0, 0x8(%rsp)
jl 0x7de35
movq 0x18(%rsp), %rdi
movl 0x8(%rsp), %esi
callq 0x7d3d0
jmp 0x7dcd8
movq 0x18(%rsp), %rdi
callq 0x4c840
movq %rax, 0x68(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x68(%rsp), %rax
movq 0x70(%rsp), %rdx
addq $0x78, %rsp
retq
nopl (%rax)
|
js_regexp_get_source:
sub rsp, 78h
mov [rsp+78h+var_20], rsi
mov [rsp+78h+var_18], rdx
mov [rsp+78h+var_28], rdi
lea rax, [rsp+78h+var_58]
mov [rsp+78h+var_60], rax
mov rax, [rsp+78h+var_18]
cmp eax, 0FFFFFFFFh
jz short loc_7DBD0
mov rdi, [rsp+78h+var_28]
call JS_ThrowTypeErrorNotAnObject
mov [rsp+78h+var_10], rax
mov [rsp+78h+var_8], rdx
jmp loc_7DE4E
loc_7DBD0:
mov rdi, [rsp+78h+var_28]
mov rax, [rsp+78h+var_28]
mov rax, [rax+40h]
mov rsi, [rsp+78h+var_20]
mov rdx, [rsp+78h+var_18]
mov rcx, [rax+120h]
mov r8, [rax+128h]
call js_same_value
cmp eax, 0
jz short loc_7DC02
jmp short loc_7DC61
loc_7DC02:
mov rdi, [rsp+78h+var_28]
mov rsi, [rsp+78h+var_20]
mov rdx, [rsp+78h+var_18]
mov ecx, 1
call js_get_regexp
mov [rsp+78h+var_30], rax
cmp [rsp+78h+var_30], 0
jnz short loc_7DC3E
mov dword ptr [rsp+78h+var_10], 0
mov [rsp+78h+var_8], 6
jmp loc_7DE4E
loc_7DC3E:
mov rax, [rsp+78h+var_30]
mov rax, [rax]
mov [rsp+78h+var_38], rax
mov rax, [rsp+78h+var_38]
mov rax, [rax+4]
and rax, 7FFFFFFFh
cmp eax, 0
jnz short loc_7DC81
jmp short $+2
loc_7DC61:
mov rdi, [rsp+78h+var_28]
lea rsi, asc_10D480; "(?:)"
call js_new_string8
mov [rsp+78h+var_10], rax
mov [rsp+78h+var_8], rdx
jmp loc_7DE4E
loc_7DC81:
mov rdi, [rsp+78h+var_28]
mov rsi, [rsp+78h+var_60]
mov rax, [rsp+78h+var_38]
mov rax, [rax+4]
and rax, 7FFFFFFFh
mov edx, eax
mov rax, [rsp+78h+var_38]
mov rax, [rax+4]
shr rax, 1Fh
and rax, 1
movzx ecx, al
call string_buffer_init2
mov [rsp+78h+var_74], 0
mov [rsp+78h+var_64], 0
mov rax, [rsp+78h+var_38]
mov rax, [rax+4]
and rax, 7FFFFFFFh
mov [rsp+78h+var_68], eax
loc_7DCD8:
mov eax, [rsp+78h+var_64]
cmp eax, [rsp+78h+var_68]
jge loc_7DE3A
mov [rsp+78h+var_70], 0FFFFFFFFh
mov rdi, [rsp+78h+var_38]
mov esi, [rsp+78h+var_64]
mov eax, esi
inc eax
mov [rsp+78h+var_64], eax
call string_get
mov [rsp+78h+var_6C], eax
mov ecx, eax
mov [rsp+78h+var_78], ecx
sub eax, 0Ah
jz loc_7DDD5
jmp short $+2
loc_7DD18:
mov eax, [rsp+78h+var_78]
sub eax, 0Dh
jz loc_7DDE7
jmp short $+2
loc_7DD26:
mov eax, [rsp+78h+var_78]
sub eax, 2Fh ; '/'
jz loc_7DDF9
jmp short $+2
loc_7DD34:
mov eax, [rsp+78h+var_78]
sub eax, 5Bh ; '['
jz short loc_7DD8C
jmp short $+2
loc_7DD3E:
mov eax, [rsp+78h+var_78]
sub eax, 5Ch ; '\'
jz short loc_7DD55
jmp short $+2
loc_7DD48:
mov eax, [rsp+78h+var_78]
sub eax, 5Dh ; ']'
jz short loc_7DD7F
jmp loc_7DE12
loc_7DD55:
mov eax, [rsp+78h+var_64]
cmp eax, [rsp+78h+var_68]
jge short loc_7DD7A
mov rdi, [rsp+78h+var_38]
mov esi, [rsp+78h+var_64]
mov eax, esi
add eax, 1
mov [rsp+78h+var_64], eax
call string_get
mov [rsp+78h+var_70], eax
loc_7DD7A:
jmp loc_7DE12
loc_7DD7F:
mov [rsp+78h+var_74], 0
jmp loc_7DE12
loc_7DD8C:
cmp [rsp+78h+var_74], 0
jnz short loc_7DDD3
mov eax, [rsp+78h+var_64]
cmp eax, [rsp+78h+var_68]
jge short loc_7DDCB
mov rdi, [rsp+78h+var_38]
mov esi, [rsp+78h+var_64]
call string_get
cmp eax, 5Dh ; ']'
jnz short loc_7DDCB
mov rdi, [rsp+78h+var_38]
mov esi, [rsp+78h+var_64]
mov eax, esi
add eax, 1
mov [rsp+78h+var_64], eax
call string_get
mov [rsp+78h+var_70], eax
loc_7DDCB:
mov [rsp+78h+var_74], 1
loc_7DDD3:
jmp short loc_7DE12
loc_7DDD5:
mov [rsp+78h+var_6C], 5Ch ; '\'
mov [rsp+78h+var_70], 6Eh ; 'n'
jmp short loc_7DE12
loc_7DDE7:
mov [rsp+78h+var_6C], 5Ch ; '\'
mov [rsp+78h+var_70], 72h ; 'r'
jmp short loc_7DE12
loc_7DDF9:
cmp [rsp+78h+var_74], 0
jnz short loc_7DE10
mov [rsp+78h+var_6C], 5Ch ; '\'
mov [rsp+78h+var_70], 2Fh ; '/'
loc_7DE10:
jmp short $+2
loc_7DE12:
mov rdi, [rsp+78h+var_60]
mov esi, [rsp+78h+var_6C]
call string_buffer_putc16
cmp [rsp+78h+var_70], 0
jl short loc_7DE35
mov rdi, [rsp+78h+var_60]
mov esi, [rsp+78h+var_70]
call string_buffer_putc16
loc_7DE35:
jmp loc_7DCD8
loc_7DE3A:
mov rdi, [rsp+78h+var_60]
call string_buffer_end
mov [rsp+78h+var_10], rax
mov [rsp+78h+var_8], rdx
loc_7DE4E:
mov rax, [rsp+78h+var_10]
mov rdx, [rsp+78h+var_8]
add rsp, 78h
retn
|
long long js_regexp_get_source(
long long a1,
_DWORD *a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
long long v14; // rdx
long long v15; // rdx
int v16; // esi
int v17; // esi
int v18; // esi
long long v19; // rdx
int v21; // [rsp+4h] [rbp-74h]
signed int v22; // [rsp+8h] [rbp-70h]
unsigned int v23; // [rsp+Ch] [rbp-6Ch]
int v24; // [rsp+10h] [rbp-68h]
int v25; // [rsp+14h] [rbp-64h]
_BYTE v26[32]; // [rsp+20h] [rbp-58h] BYREF
long long v27; // [rsp+40h] [rbp-38h]
long long *regexp; // [rsp+48h] [rbp-30h]
long long v29; // [rsp+50h] [rbp-28h]
_DWORD *v30; // [rsp+58h] [rbp-20h]
long long v31; // [rsp+60h] [rbp-18h]
long long v32; // [rsp+68h] [rbp-10h]
long long v33; // [rsp+70h] [rbp-8h]
v30 = a2;
v31 = a3;
v29 = a1;
if ( (_DWORD)a3 == -1 )
{
if ( (unsigned int)js_same_value(
v29,
v30,
v31,
*(_DWORD **)(*(_QWORD *)(v29 + 64) + 288LL),
*(_QWORD *)(*(_QWORD *)(v29 + 64) + 296LL)) )
goto LABEL_7;
regexp = (long long *)js_get_regexp(v29, v30, v31, 1LL);
if ( !regexp )
{
LODWORD(v32) = 0;
v33 = 6LL;
return v32;
}
v27 = *regexp;
if ( (*(_DWORD *)(v27 + 4) & 0x7FFFFFFF) == 0 )
{
LABEL_7:
v32 = js_new_string8(v29, (long long)"(?:)");
v33 = v15;
return v32;
}
string_buffer_init2(
v29,
(long long)v26,
*(_DWORD *)(v27 + 4) & 0x7FFFFFFF,
(*(_QWORD *)(v27 + 4) & 0x80000000LL) != 0);
v21 = 0;
v25 = 0;
v24 = *(_DWORD *)(v27 + 4) & 0x7FFFFFFF;
while ( v25 < v24 )
{
v22 = -1;
v16 = v25++;
v23 = string_get(v27, v16);
if ( v23 == 10 )
{
v22 = 110;
string_buffer_putc16((long long)v26, 0x5Cu);
}
else if ( v23 == 13 )
{
v22 = 114;
string_buffer_putc16((long long)v26, 0x5Cu);
}
else
{
switch ( v23 )
{
case '/':
if ( !v21 )
{
v23 = 92;
v22 = 47;
}
break;
case '[':
if ( !v21 )
{
if ( v25 < v24 && (unsigned int)string_get(v27, v25) == 93 )
{
v18 = v25++;
v22 = string_get(v27, v18);
}
v21 = 1;
}
break;
case '\\':
if ( v25 < v24 )
{
v17 = v25++;
v22 = string_get(v27, v17);
}
break;
case ']':
v21 = 0;
break;
}
string_buffer_putc16((long long)v26, v23);
}
if ( v22 >= 0 )
string_buffer_putc16((long long)v26, v22);
}
v32 = string_buffer_end((long long)v26);
v33 = v19;
}
else
{
v32 = JS_ThrowTypeErrorNotAnObject(v29, a7, a8, a9, a10, a11, a12, a13, a14, (long long)a2, a3, a4, a5, a6);
v33 = v14;
}
return v32;
}
|
js_regexp_get_source:
SUB RSP,0x78
MOV qword ptr [RSP + 0x58],RSI
MOV qword ptr [RSP + 0x60],RDX
MOV qword ptr [RSP + 0x50],RDI
LEA RAX,[RSP + 0x20]
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [RSP + 0x60]
CMP EAX,-0x1
JZ 0x0017dbd0
MOV RDI,qword ptr [RSP + 0x50]
CALL 0x0012e2e0
MOV qword ptr [RSP + 0x68],RAX
MOV qword ptr [RSP + 0x70],RDX
JMP 0x0017de4e
LAB_0017dbd0:
MOV RDI,qword ptr [RSP + 0x50]
MOV RAX,qword ptr [RSP + 0x50]
MOV RAX,qword ptr [RAX + 0x40]
MOV RSI,qword ptr [RSP + 0x58]
MOV RDX,qword ptr [RSP + 0x60]
MOV RCX,qword ptr [RAX + 0x120]
MOV R8,qword ptr [RAX + 0x128]
CALL 0x00134850
CMP EAX,0x0
JZ 0x0017dc02
JMP 0x0017dc61
LAB_0017dc02:
MOV RDI,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RSP + 0x58]
MOV RDX,qword ptr [RSP + 0x60]
MOV ECX,0x1
CALL 0x00183010
MOV qword ptr [RSP + 0x48],RAX
CMP qword ptr [RSP + 0x48],0x0
JNZ 0x0017dc3e
MOV dword ptr [RSP + 0x68],0x0
MOV qword ptr [RSP + 0x70],0x6
JMP 0x0017de4e
LAB_0017dc3e:
MOV RAX,qword ptr [RSP + 0x48]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP + 0x40],RAX
MOV RAX,qword ptr [RSP + 0x40]
MOV RAX,qword ptr [RAX + 0x4]
AND RAX,0x7fffffff
CMP EAX,0x0
JNZ 0x0017dc81
JMP 0x0017dc61
LAB_0017dc61:
MOV RDI,qword ptr [RSP + 0x50]
LEA RSI,[0x20d480]
CALL 0x00138330
MOV qword ptr [RSP + 0x68],RAX
MOV qword ptr [RSP + 0x70],RDX
JMP 0x0017de4e
LAB_0017dc81:
MOV RDI,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RSP + 0x40]
MOV RAX,qword ptr [RAX + 0x4]
AND RAX,0x7fffffff
MOV EDX,EAX
MOV RAX,qword ptr [RSP + 0x40]
MOV RAX,qword ptr [RAX + 0x4]
SHR RAX,0x1f
AND RAX,0x1
MOVZX ECX,AL
CALL 0x0014c6f0
MOV dword ptr [RSP + 0x4],0x0
MOV dword ptr [RSP + 0x14],0x0
MOV RAX,qword ptr [RSP + 0x40]
MOV RAX,qword ptr [RAX + 0x4]
AND RAX,0x7fffffff
MOV dword ptr [RSP + 0x10],EAX
LAB_0017dcd8:
MOV EAX,dword ptr [RSP + 0x14]
CMP EAX,dword ptr [RSP + 0x10]
JGE 0x0017de3a
MOV dword ptr [RSP + 0x8],0xffffffff
MOV RDI,qword ptr [RSP + 0x40]
MOV ESI,dword ptr [RSP + 0x14]
MOV EAX,ESI
INC EAX
MOV dword ptr [RSP + 0x14],EAX
CALL 0x0015b910
MOV dword ptr [RSP + 0xc],EAX
MOV ECX,EAX
MOV dword ptr [RSP],ECX
SUB EAX,0xa
JZ 0x0017ddd5
JMP 0x0017dd18
LAB_0017dd18:
MOV EAX,dword ptr [RSP]
SUB EAX,0xd
JZ 0x0017dde7
JMP 0x0017dd26
LAB_0017dd26:
MOV EAX,dword ptr [RSP]
SUB EAX,0x2f
JZ 0x0017ddf9
JMP 0x0017dd34
LAB_0017dd34:
MOV EAX,dword ptr [RSP]
SUB EAX,0x5b
JZ 0x0017dd8c
JMP 0x0017dd3e
LAB_0017dd3e:
MOV EAX,dword ptr [RSP]
SUB EAX,0x5c
JZ 0x0017dd55
JMP 0x0017dd48
LAB_0017dd48:
MOV EAX,dword ptr [RSP]
SUB EAX,0x5d
JZ 0x0017dd7f
JMP 0x0017de12
LAB_0017dd55:
MOV EAX,dword ptr [RSP + 0x14]
CMP EAX,dword ptr [RSP + 0x10]
JGE 0x0017dd7a
MOV RDI,qword ptr [RSP + 0x40]
MOV ESI,dword ptr [RSP + 0x14]
MOV EAX,ESI
ADD EAX,0x1
MOV dword ptr [RSP + 0x14],EAX
CALL 0x0015b910
MOV dword ptr [RSP + 0x8],EAX
LAB_0017dd7a:
JMP 0x0017de12
LAB_0017dd7f:
MOV dword ptr [RSP + 0x4],0x0
JMP 0x0017de12
LAB_0017dd8c:
CMP dword ptr [RSP + 0x4],0x0
JNZ 0x0017ddd3
MOV EAX,dword ptr [RSP + 0x14]
CMP EAX,dword ptr [RSP + 0x10]
JGE 0x0017ddcb
MOV RDI,qword ptr [RSP + 0x40]
MOV ESI,dword ptr [RSP + 0x14]
CALL 0x0015b910
CMP EAX,0x5d
JNZ 0x0017ddcb
MOV RDI,qword ptr [RSP + 0x40]
MOV ESI,dword ptr [RSP + 0x14]
MOV EAX,ESI
ADD EAX,0x1
MOV dword ptr [RSP + 0x14],EAX
CALL 0x0015b910
MOV dword ptr [RSP + 0x8],EAX
LAB_0017ddcb:
MOV dword ptr [RSP + 0x4],0x1
LAB_0017ddd3:
JMP 0x0017de12
LAB_0017ddd5:
MOV dword ptr [RSP + 0xc],0x5c
MOV dword ptr [RSP + 0x8],0x6e
JMP 0x0017de12
LAB_0017dde7:
MOV dword ptr [RSP + 0xc],0x5c
MOV dword ptr [RSP + 0x8],0x72
JMP 0x0017de12
LAB_0017ddf9:
CMP dword ptr [RSP + 0x4],0x0
JNZ 0x0017de10
MOV dword ptr [RSP + 0xc],0x5c
MOV dword ptr [RSP + 0x8],0x2f
LAB_0017de10:
JMP 0x0017de12
LAB_0017de12:
MOV RDI,qword ptr [RSP + 0x18]
MOV ESI,dword ptr [RSP + 0xc]
CALL 0x0017d3d0
CMP dword ptr [RSP + 0x8],0x0
JL 0x0017de35
MOV RDI,qword ptr [RSP + 0x18]
MOV ESI,dword ptr [RSP + 0x8]
CALL 0x0017d3d0
LAB_0017de35:
JMP 0x0017dcd8
LAB_0017de3a:
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x0014c840
MOV qword ptr [RSP + 0x68],RAX
MOV qword ptr [RSP + 0x70],RDX
LAB_0017de4e:
MOV RAX,qword ptr [RSP + 0x68]
MOV RDX,qword ptr [RSP + 0x70]
ADD RSP,0x78
RET
|
int1 [16] js_regexp_get_source(long param_1,int8 param_2,int8 param_3)
{
bool bVar1;
int iVar2;
uint uVar3;
int iVar4;
int1 auVar5 [16];
int local_70;
int local_6c;
int local_64;
int1 local_58 [32];
long local_38;
long *local_30;
long local_28;
int8 local_20;
int8 local_18;
int4 local_10;
int4 uStack_c;
int8 local_8;
local_28 = param_1;
local_20 = param_2;
local_18 = param_3;
if ((int)param_3 != -1) {
auVar5 = JS_ThrowTypeErrorNotAnObject(param_1);
local_8 = auVar5._8_8_;
local_10 = auVar5._0_4_;
uStack_c = auVar5._4_4_;
goto LAB_0017de4e;
}
iVar2 = js_same_value(param_1,param_2,param_3,*(int8 *)(*(long *)(param_1 + 0x40) + 0x120),
*(int8 *)(*(long *)(param_1 + 0x40) + 0x128));
if (iVar2 == 0) {
local_30 = (long *)js_get_regexp(local_28,local_20,local_18,1);
if (local_30 == (long *)0x0) {
local_10 = 0;
local_8 = 6;
goto LAB_0017de4e;
}
local_38 = *local_30;
if ((*(ulong *)(local_38 + 4) & 0x7fffffff) != 0) {
string_buffer_init2(local_28,local_58,(uint)*(int8 *)(local_38 + 4) & 0x7fffffff,
(byte)(*(ulong *)(local_38 + 4) >> 0x1f) & 1);
bVar1 = false;
local_64 = 0;
uVar3 = (uint)*(int8 *)(local_38 + 4) & 0x7fffffff;
while (local_64 < (int)uVar3) {
local_70 = -1;
iVar2 = local_64 + 1;
local_6c = string_get(local_38);
if (local_6c == 10) {
local_6c = 0x5c;
local_70 = 0x6e;
}
else if (local_6c == 0xd) {
local_6c = 0x5c;
local_70 = 0x72;
}
else if (local_6c == 0x2f) {
if (!bVar1) {
local_6c = 0x5c;
local_70 = 0x2f;
}
}
else if (local_6c == 0x5b) {
if (!bVar1) {
if ((iVar2 < (int)uVar3) && (iVar4 = string_get(local_38,iVar2), iVar4 == 0x5d)) {
local_70 = string_get(local_38);
iVar2 = local_64 + 2;
}
local_64 = iVar2;
bVar1 = true;
iVar2 = local_64;
}
}
else if (local_6c == 0x5c) {
if (iVar2 < (int)uVar3) {
local_70 = string_get(local_38);
iVar2 = local_64 + 2;
}
}
else if (local_6c == 0x5d) {
bVar1 = false;
}
local_64 = iVar2;
string_buffer_putc16(local_58,local_6c);
if (-1 < local_70) {
string_buffer_putc16(local_58,local_70);
}
}
auVar5 = string_buffer_end(local_58);
local_8 = auVar5._8_8_;
local_10 = auVar5._0_4_;
uStack_c = auVar5._4_4_;
goto LAB_0017de4e;
}
}
auVar5 = js_new_string8(local_28,&DAT_0020d480);
local_8 = auVar5._8_8_;
local_10 = auVar5._0_4_;
uStack_c = auVar5._4_4_;
LAB_0017de4e:
auVar5._4_4_ = uStack_c;
auVar5._0_4_ = local_10;
auVar5._8_8_ = local_8;
return auVar5;
}
|
|
11,794 |
js_regexp_get_source
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_regexp_get_source(JSContext *ctx, JSValue this_val)
{
JSRegExp *re;
JSString *p;
StringBuffer b_s, *b = &b_s;
int i, n, c, c2, bra;
if (JS_VALUE_GET_TAG(this_val) != JS_TAG_OBJECT)
return JS_ThrowTypeErrorNotAnObject(ctx);
if (js_same_value(ctx, this_val, ctx->class_proto[JS_CLASS_REGEXP]))
goto empty_regex;
re = js_get_regexp(ctx, this_val, TRUE);
if (!re)
return JS_EXCEPTION;
p = re->pattern;
if (p->len == 0) {
empty_regex:
return js_new_string8(ctx, "(?:)");
}
string_buffer_init2(ctx, b, p->len, p->is_wide_char);
/* Escape '/' and newline sequences as needed */
bra = 0;
for (i = 0, n = p->len; i < n;) {
c2 = -1;
switch (c = string_get(p, i++)) {
case '\\':
if (i < n)
c2 = string_get(p, i++);
break;
case ']':
bra = 0;
break;
case '[':
if (!bra) {
if (i < n && string_get(p, i) == ']')
c2 = string_get(p, i++);
bra = 1;
}
break;
case '\n':
c = '\\';
c2 = 'n';
break;
case '\r':
c = '\\';
c2 = 'r';
break;
case '/':
if (!bra) {
c = '\\';
c2 = '/';
}
break;
}
string_buffer_putc16(b, c);
if (c2 >= 0)
string_buffer_putc16(b, c2);
}
return string_buffer_end(b);
}
|
O1
|
c
|
js_regexp_get_source:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpl $-0x1, %edx
jne 0x46f32
movq %rsi, %r14
movq 0x40(%rbx), %rax
movq 0x120(%rax), %rcx
movq 0x128(%rax), %r8
movq %rbx, %rdi
callq 0x2584d
testl %eax, %eax
je 0x46f62
leaq 0x57571(%rip), %rsi # 0x9e484
movq %rbx, %rdi
movl $0x4, %edx
callq 0x1f5c9
movq %rax, %r14
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rax, %rcx
jmp 0x46f4d
leaq 0x569e4(%rip), %rsi # 0x9d91d
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21953
movl $0x6, %edx
xorl %ecx, %ecx
movl %r14d, %eax
orq %rcx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpw $0x12, 0x6(%r14)
jne 0x46f70
addq $0x30, %r14
jmp 0x46f80
movq %rbx, %rdi
movl $0x12, %esi
callq 0x269dc
xorl %r14d, %r14d
testq %r14, %r14
je 0x470e8
movq (%r14), %r14
movl 0x4(%r14), %edx
movl %edx, %esi
andl $0x7fffffff, %esi # imm = 0x7FFFFFFF
je 0x46f0c
shrl $0x1f, %edx
movq %rbx, 0x8(%rsp)
movl %esi, 0x1c(%rsp)
xorl %eax, %eax
movl %eax, 0x18(%rsp)
movl %edx, 0x20(%rsp)
movl %eax, 0x24(%rsp)
movq %rbx, %rdi
callq 0x1ff5f
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x470f5
movl $0x7fffffff, %r15d # imm = 0x7FFFFFFF
andl 0x4(%r14), %r15d
je 0x470d9
xorl %r12d, %r12d
leaq 0x8(%rsp), %rbx
xorl %r13d, %r13d
movslq %r13d, %rcx
movq 0x4(%r14), %rdx
testl %edx, %edx
js 0x46ffc
movzbl 0x18(%r14,%rcx), %esi
jmp 0x47002
movzwl 0x18(%r14,%rcx,2), %esi
leaq 0x1(%rcx), %rax
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
cmpl $0x5a, %esi
jg 0x47031
cmpl $0xa, %esi
je 0x4704c
cmpl $0xd, %esi
je 0x47074
cmpl $0x2f, %esi
jne 0x47092
testl %r12d, %r12d
je 0x47085
movl $0x1, %r12d
movl $0x2f, %esi
jmp 0x47092
cmpl $0x5b, %esi
je 0x47053
cmpl $0x5d, %esi
je 0x4707b
cmpl $0x5c, %esi
jne 0x47092
movl $0x5c, %esi
cmpl %r15d, %eax
jge 0x47092
jmp 0x470c1
movl $0x6e, %ebp
jmp 0x4708d
movl $0x5b, %esi
testl %r12d, %r12d
movl $0x1, %r12d
jne 0x47092
cmpl %r15d, %eax
jge 0x47092
testl %edx, %edx
js 0x470b6
movzbl 0x18(%r14,%rax), %edi
jmp 0x470bc
movl $0x72, %ebp
jmp 0x4708d
xorl %r12d, %r12d
movl $0x5d, %esi
jmp 0x47092
xorl %r12d, %r12d
movl $0x2f, %ebp
movl $0x5c, %esi
movl %eax, %r13d
movq %rbx, %rdi
callq 0x46bcb
testl %ebp, %ebp
js 0x470ab
movq %rbx, %rdi
movl %ebp, %esi
callq 0x46bcb
cmpl %r15d, %r13d
jl 0x46fe9
jmp 0x470d9
movzwl 0x1a(%r14,%rcx,2), %edi
cmpl $0x5d, %edi
jne 0x47092
addl $0x2, %r13d
testl %edx, %edx
js 0x470d1
movzbl 0x18(%r14,%rax), %ebp
jmp 0x47095
movzwl 0x1a(%r14,%rcx,2), %ebp
jmp 0x47095
leaq 0x8(%rsp), %rdi
callq 0x32830
jmp 0x46f20
movl $0x6, %edx
xorl %r14d, %r14d
jmp 0x46f4b
movl $0x0, 0x1c(%rsp)
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x46fce
|
js_regexp_get_source:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rbx, rdi
cmp edx, 0FFFFFFFFh
jnz short loc_46F32
mov r14, rsi
mov rax, [rbx+40h]
mov rcx, [rax+120h]
mov r8, [rax+128h]
mov rdi, rbx
call js_same_value
test eax, eax
jz short loc_46F62
loc_46F0C:
lea rsi, asc_9E484; "(?:)"
mov rdi, rbx
mov edx, 4
call js_new_string8_len
loc_46F20:
mov r14, rax
mov rcx, 0FFFFFFFF00000000h
and rcx, rax
jmp short loc_46F4D
loc_46F32:
lea rsi, aOperandPrototy+20h; "not an object"
xor r14d, r14d
mov rdi, rbx
xor eax, eax
call JS_ThrowTypeError
mov edx, 6
loc_46F4B:
xor ecx, ecx
loc_46F4D:
mov eax, r14d
or rax, rcx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_46F62:
cmp word ptr [r14+6], 12h
jnz short loc_46F70
add r14, 30h ; '0'
jmp short loc_46F80
loc_46F70:
mov rdi, rbx
mov esi, 12h
call JS_ThrowTypeErrorInvalidClass
xor r14d, r14d
loc_46F80:
test r14, r14
jz loc_470E8
mov r14, [r14]
mov edx, [r14+4]
mov esi, edx
and esi, 7FFFFFFFh
jz loc_46F0C
shr edx, 1Fh
mov [rsp+58h+var_50], rbx
mov [rsp+58h+var_3C], esi
xor eax, eax
mov [rsp+58h+var_40], eax
mov [rsp+58h+var_38], edx
mov [rsp+58h+var_34], eax
mov rdi, rbx
call js_alloc_string
mov [rsp+58h+var_48], rax
test rax, rax
jz loc_470F5
loc_46FCE:
mov r15d, 7FFFFFFFh
and r15d, [r14+4]
jz loc_470D9
xor r12d, r12d
lea rbx, [rsp+58h+var_50]
xor r13d, r13d
loc_46FE9:
movsxd rcx, r13d
mov rdx, [r14+4]
test edx, edx
js short loc_46FFC
movzx esi, byte ptr [r14+rcx+18h]
jmp short loc_47002
loc_46FFC:
movzx esi, word ptr [r14+rcx*2+18h]
loc_47002:
lea rax, [rcx+1]
mov ebp, 0FFFFFFFFh
cmp esi, 5Ah ; 'Z'
jg short loc_47031
cmp esi, 0Ah
jz short loc_4704C
cmp esi, 0Dh
jz short loc_47074
cmp esi, 2Fh ; '/'
jnz short loc_47092
test r12d, r12d
jz short loc_47085
mov r12d, 1
mov esi, 2Fh ; '/'
jmp short loc_47092
loc_47031:
cmp esi, 5Bh ; '['
jz short loc_47053
cmp esi, 5Dh ; ']'
jz short loc_4707B
cmp esi, 5Ch ; '\'
jnz short loc_47092
mov esi, 5Ch ; '\'
cmp eax, r15d
jge short loc_47092
jmp short loc_470C1
loc_4704C:
mov ebp, 6Eh ; 'n'
jmp short loc_4708D
loc_47053:
mov esi, 5Bh ; '['
test r12d, r12d
mov r12d, 1
jnz short loc_47092
cmp eax, r15d
jge short loc_47092
test edx, edx
js short loc_470B6
movzx edi, byte ptr [r14+rax+18h]
jmp short loc_470BC
loc_47074:
mov ebp, 72h ; 'r'
jmp short loc_4708D
loc_4707B:
xor r12d, r12d
mov esi, 5Dh ; ']'
jmp short loc_47092
loc_47085:
xor r12d, r12d
mov ebp, 2Fh ; '/'
loc_4708D:
mov esi, 5Ch ; '\'
loc_47092:
mov r13d, eax
loc_47095:
mov rdi, rbx
call string_buffer_putc16
test ebp, ebp
js short loc_470AB
mov rdi, rbx
mov esi, ebp
call string_buffer_putc16
loc_470AB:
cmp r13d, r15d
jl loc_46FE9
jmp short loc_470D9
loc_470B6:
movzx edi, word ptr [r14+rcx*2+1Ah]
loc_470BC:
cmp edi, 5Dh ; ']'
jnz short loc_47092
loc_470C1:
add r13d, 2
test edx, edx
js short loc_470D1
movzx ebp, byte ptr [r14+rax+18h]
jmp short loc_47095
loc_470D1:
movzx ebp, word ptr [r14+rcx*2+1Ah]
jmp short loc_47095
loc_470D9:
lea rdi, [rsp+58h+var_50]
call string_buffer_end
jmp loc_46F20
loc_470E8:
mov edx, 6
xor r14d, r14d
jmp loc_46F4B
loc_470F5:
mov [rsp+58h+var_3C], 0
mov [rsp+58h+var_34], 0FFFFFFFFh
jmp loc_46FCE
|
unsigned long long js_regexp_get_source(
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)
{
double v14; // xmm4_8
double v15; // xmm5_8
long long v16; // rax
unsigned int v17; // r14d
unsigned long long v18; // rcx
long long *v20; // r14
long long v21; // r14
unsigned int v22; // edx
int v23; // r15d
int v24; // r12d
int v25; // r13d
long long v26; // rcx
long long v27; // rdx
signed int v28; // esi
long long v29; // rax
signed int v30; // ebp
bool v31; // zf
int v32; // edi
char v33; // [rsp+0h] [rbp-58h]
long long v34; // [rsp+8h] [rbp-50h] BYREF
int v36; // [rsp+18h] [rbp-40h]
int v37; // [rsp+1Ch] [rbp-3Ch]
unsigned int v38; // [rsp+20h] [rbp-38h]
int v39; // [rsp+24h] [rbp-34h]
if ( (_DWORD)a3 != -1 )
{
v17 = 0;
JS_ThrowTypeError(a1, (long long)"not an object", a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v33);
goto LABEL_6;
}
if ( !(unsigned int)js_same_value(
a1,
(_DWORD *)a2,
a3,
*(_DWORD **)(*(_QWORD *)(a1 + 64) + 288LL),
*(_QWORD *)(*(_QWORD *)(a1 + 64) + 296LL)) )
{
if ( *(_WORD *)(a2 + 6) == 18 )
{
v20 = (long long *)(a2 + 48);
}
else
{
JS_ThrowTypeErrorInvalidClass(a1, 18, a7, a8, a9, a10, v14, v15, a13, a14);
v20 = 0LL;
}
if ( v20 )
{
v21 = *v20;
v22 = *(_DWORD *)(v21 + 4);
if ( (v22 & 0x7FFFFFFF) == 0 )
goto LABEL_3;
v34 = a1;
v37 = v22 & 0x7FFFFFFF;
v36 = 0;
v38 = v22 >> 31;
v39 = 0;
if ( !js_alloc_string(a1, v22 & 0x7FFFFFFF, v22 >> 31) )
{
v37 = 0;
v39 = -1;
}
v23 = *(_DWORD *)(v21 + 4) & 0x7FFFFFFF;
if ( !v23 )
{
LABEL_50:
v16 = (long long)string_buffer_end((long long)&v34);
goto LABEL_4;
}
v24 = 0;
v25 = 0;
while ( 1 )
{
v26 = v25;
v27 = *(_QWORD *)(v21 + 4);
if ( (int)v27 < 0 )
v28 = *(unsigned __int16 *)(v21 + 2LL * v25 + 24);
else
v28 = *(unsigned __int8 *)(v21 + v25 + 24);
v29 = v25 + 1LL;
v30 = -1;
if ( v28 > 90 )
{
switch ( v28 )
{
case '[':
v28 = 91;
v31 = v24 == 0;
v24 = 1;
if ( v31 && (int)v29 < v23 )
{
v32 = (int)v27 < 0 ? *(unsigned __int16 *)(v21 + 2LL * v25 + 26) : *(unsigned __int8 *)(v21 + v29 + 24);
if ( v32 == 93 )
{
LABEL_47:
v25 += 2;
if ( (int)v27 < 0 )
v30 = *(unsigned __int16 *)(v21 + 2 * v26 + 26);
else
v30 = *(unsigned __int8 *)(v21 + v29 + 24);
goto LABEL_41;
}
}
break;
case ']':
v24 = 0;
v28 = 93;
break;
case '\\':
v28 = 92;
if ( (int)v29 < v23 )
goto LABEL_47;
break;
}
}
else
{
switch ( v28 )
{
case 10:
v30 = 110;
LABEL_39:
v28 = 92;
break;
case 13:
v30 = 114;
goto LABEL_39;
case 47:
if ( !v24 )
{
v24 = 0;
v30 = 47;
goto LABEL_39;
}
v24 = 1;
v28 = 47;
break;
}
}
++v25;
LABEL_41:
string_buffer_putc16((long long)&v34, v28);
if ( v30 >= 0 )
string_buffer_putc16((long long)&v34, v30);
if ( v25 >= v23 )
goto LABEL_50;
}
}
v17 = 0;
LABEL_6:
v18 = 0LL;
return v18 | v17;
}
LABEL_3:
v16 = js_new_string8_len(a1, (long long)"(?:)", 4u);
LABEL_4:
v17 = v16;
v18 = v16 & 0xFFFFFFFF00000000LL;
return v18 | v17;
}
|
js_regexp_get_source:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
CMP EDX,-0x1
JNZ 0x00146f32
MOV R14,RSI
MOV RAX,qword ptr [RBX + 0x40]
MOV RCX,qword ptr [RAX + 0x120]
MOV R8,qword ptr [RAX + 0x128]
MOV RDI,RBX
CALL 0x0012584d
TEST EAX,EAX
JZ 0x00146f62
LAB_00146f0c:
LEA RSI,[0x19e484]
MOV RDI,RBX
MOV EDX,0x4
CALL 0x0011f5c9
LAB_00146f20:
MOV R14,RAX
MOV RCX,-0x100000000
AND RCX,RAX
JMP 0x00146f4d
LAB_00146f32:
LEA RSI,[0x19d91d]
XOR R14D,R14D
MOV RDI,RBX
XOR EAX,EAX
CALL 0x00121953
MOV EDX,0x6
LAB_00146f4b:
XOR ECX,ECX
LAB_00146f4d:
MOV EAX,R14D
OR RAX,RCX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00146f62:
CMP word ptr [R14 + 0x6],0x12
JNZ 0x00146f70
ADD R14,0x30
JMP 0x00146f80
LAB_00146f70:
MOV RDI,RBX
MOV ESI,0x12
CALL 0x001269dc
XOR R14D,R14D
LAB_00146f80:
TEST R14,R14
JZ 0x001470e8
MOV R14,qword ptr [R14]
MOV EDX,dword ptr [R14 + 0x4]
MOV ESI,EDX
AND ESI,0x7fffffff
JZ 0x00146f0c
SHR EDX,0x1f
MOV qword ptr [RSP + 0x8],RBX
MOV dword ptr [RSP + 0x1c],ESI
XOR EAX,EAX
MOV dword ptr [RSP + 0x18],EAX
MOV dword ptr [RSP + 0x20],EDX
MOV dword ptr [RSP + 0x24],EAX
MOV RDI,RBX
CALL 0x0011ff5f
MOV qword ptr [RSP + 0x10],RAX
TEST RAX,RAX
JZ 0x001470f5
LAB_00146fce:
MOV R15D,0x7fffffff
AND R15D,dword ptr [R14 + 0x4]
JZ 0x001470d9
XOR R12D,R12D
LEA RBX,[RSP + 0x8]
XOR R13D,R13D
LAB_00146fe9:
MOVSXD RCX,R13D
MOV RDX,qword ptr [R14 + 0x4]
TEST EDX,EDX
JS 0x00146ffc
MOVZX ESI,byte ptr [R14 + RCX*0x1 + 0x18]
JMP 0x00147002
LAB_00146ffc:
MOVZX ESI,word ptr [R14 + RCX*0x2 + 0x18]
LAB_00147002:
LEA RAX,[RCX + 0x1]
MOV EBP,0xffffffff
CMP ESI,0x5a
JG 0x00147031
CMP ESI,0xa
JZ 0x0014704c
CMP ESI,0xd
JZ 0x00147074
CMP ESI,0x2f
JNZ 0x00147092
TEST R12D,R12D
JZ 0x00147085
MOV R12D,0x1
MOV ESI,0x2f
JMP 0x00147092
LAB_00147031:
CMP ESI,0x5b
JZ 0x00147053
CMP ESI,0x5d
JZ 0x0014707b
CMP ESI,0x5c
JNZ 0x00147092
MOV ESI,0x5c
CMP EAX,R15D
JGE 0x00147092
JMP 0x001470c1
LAB_0014704c:
MOV EBP,0x6e
JMP 0x0014708d
LAB_00147053:
MOV ESI,0x5b
TEST R12D,R12D
MOV R12D,0x1
JNZ 0x00147092
CMP EAX,R15D
JGE 0x00147092
TEST EDX,EDX
JS 0x001470b6
MOVZX EDI,byte ptr [R14 + RAX*0x1 + 0x18]
JMP 0x001470bc
LAB_00147074:
MOV EBP,0x72
JMP 0x0014708d
LAB_0014707b:
XOR R12D,R12D
MOV ESI,0x5d
JMP 0x00147092
LAB_00147085:
XOR R12D,R12D
MOV EBP,0x2f
LAB_0014708d:
MOV ESI,0x5c
LAB_00147092:
MOV R13D,EAX
LAB_00147095:
MOV RDI,RBX
CALL 0x00146bcb
TEST EBP,EBP
JS 0x001470ab
MOV RDI,RBX
MOV ESI,EBP
CALL 0x00146bcb
LAB_001470ab:
CMP R13D,R15D
JL 0x00146fe9
JMP 0x001470d9
LAB_001470b6:
MOVZX EDI,word ptr [R14 + RCX*0x2 + 0x1a]
LAB_001470bc:
CMP EDI,0x5d
JNZ 0x00147092
LAB_001470c1:
ADD R13D,0x2
TEST EDX,EDX
JS 0x001470d1
MOVZX EBP,byte ptr [R14 + RAX*0x1 + 0x18]
JMP 0x00147095
LAB_001470d1:
MOVZX EBP,word ptr [R14 + RCX*0x2 + 0x1a]
JMP 0x00147095
LAB_001470d9:
LEA RDI,[RSP + 0x8]
CALL 0x00132830
JMP 0x00146f20
LAB_001470e8:
MOV EDX,0x6
XOR R14D,R14D
JMP 0x00146f4b
LAB_001470f5:
MOV dword ptr [RSP + 0x1c],0x0
MOV dword ptr [RSP + 0x24],0xffffffff
JMP 0x00146fce
|
ulong js_regexp_get_source(long param_1,long param_2,int8 param_3)
{
long lVar1;
long lVar2;
bool bVar3;
bool bVar4;
bool bVar5;
int iVar6;
int iVar7;
ulong uVar8;
ulong uVar9;
long lVar10;
int iVar11;
uint uVar12;
ushort uVar13;
ushort uVar14;
long *plVar15;
uint uVar16;
long local_50;
long local_48;
int4 local_40;
uint local_3c;
uint local_38;
int4 local_34;
if ((int)param_3 == -1) {
iVar6 = js_same_value(param_1,param_2,param_3,*(int8 *)(*(long *)(param_1 + 0x40) + 0x120)
,*(int8 *)(*(long *)(param_1 + 0x40) + 0x128));
if (iVar6 == 0) {
if (*(short *)(param_2 + 6) == 0x12) {
plVar15 = (long *)(param_2 + 0x30);
}
else {
JS_ThrowTypeErrorInvalidClass(param_1,0x12);
plVar15 = (long *)0x0;
}
if (plVar15 == (long *)0x0) goto LAB_00146f4b;
lVar2 = *plVar15;
local_3c = *(uint *)(lVar2 + 4) & 0x7fffffff;
if (local_3c == 0) goto LAB_00146f0c;
local_38 = *(uint *)(lVar2 + 4) >> 0x1f;
local_40 = 0;
local_34 = 0;
local_50 = param_1;
local_48 = js_alloc_string(param_1);
if (local_48 == 0) {
local_3c = 0;
local_34 = 0xffffffff;
}
uVar16 = *(uint *)(lVar2 + 4) & 0x7fffffff;
if (uVar16 != 0) {
bVar3 = false;
iVar6 = 0;
do {
lVar10 = (long)iVar6;
iVar11 = (int)*(int8 *)(lVar2 + 4);
if (iVar11 < 0) {
uVar13 = *(ushort *)(lVar2 + 0x18 + lVar10 * 2);
}
else {
uVar13 = (ushort)*(byte *)(lVar2 + 0x18 + lVar10);
}
lVar1 = lVar10 + 1;
uVar12 = 0xffffffff;
iVar7 = (int)lVar1;
if (0x5a < uVar13) {
if (uVar13 == 0x5b) {
uVar13 = 0x5b;
bVar4 = true;
bVar5 = !bVar3;
bVar3 = bVar4;
if ((bVar5) && (iVar7 < (int)uVar16)) {
if (iVar11 < 0) {
uVar14 = *(ushort *)(lVar2 + 0x1a + lVar10 * 2);
}
else {
uVar14 = (ushort)*(byte *)(lVar2 + 0x18 + lVar1);
}
if (uVar14 == 0x5d) goto LAB_001470c1;
}
}
else if (uVar13 == 0x5d) {
uVar13 = 0x5d;
bVar3 = false;
}
else if ((uVar13 == 0x5c) && (uVar13 = 0x5c, iVar7 < (int)uVar16)) {
LAB_001470c1:
iVar7 = iVar6 + 2;
if (iVar11 < 0) {
uVar12 = (uint)*(ushort *)(lVar2 + 0x1a + lVar10 * 2);
}
else {
uVar12 = (uint)*(byte *)(lVar2 + 0x18 + lVar1);
}
}
goto LAB_00147095;
}
if (uVar13 == 10) {
uVar12 = 0x6e;
LAB_0014708d:
uVar13 = 0x5c;
}
else {
if (uVar13 == 0xd) {
uVar12 = 0x72;
goto LAB_0014708d;
}
if (uVar13 == 0x2f) {
if (!bVar3) {
bVar3 = false;
uVar12 = 0x2f;
goto LAB_0014708d;
}
uVar13 = 0x2f;
bVar3 = true;
}
}
LAB_00147095:
iVar6 = iVar7;
string_buffer_putc16(&local_50,uVar13);
if (-1 < (int)uVar12) {
string_buffer_putc16(&local_50,uVar12);
}
} while (iVar6 < (int)uVar16);
}
uVar8 = string_buffer_end(&local_50);
}
else {
LAB_00146f0c:
uVar8 = js_new_string8_len(param_1,&DAT_0019e484,4);
}
uVar9 = uVar8 & 0xffffffff00000000;
}
else {
JS_ThrowTypeError(param_1,"not an object");
LAB_00146f4b:
uVar8 = 0;
uVar9 = 0;
}
return uVar8 & 0xffffffff | uVar9;
}
|
|
11,795 |
read_user_name
|
eloqsql/libmariadb/libmariadb/mariadb_lib.c
|
void read_user_name(char *name)
{
if (geteuid() == 0)
strcpy(name,"root"); /* allow use of surun */
else
{
#ifdef HAVE_GETPWUID
struct passwd *skr;
const char *str;
if ((skr=getpwuid(geteuid())) != NULL)
{
str=skr->pw_name;
} else if ((str=getlogin()) == NULL)
{
if (!(str=getenv("USER")) && !(str=getenv("LOGNAME")) &&
!(str=getenv("LOGIN")))
str="UNKNOWN_USER";
}
ma_strmake(name,str,USERNAME_LENGTH);
#elif defined(HAVE_CUSERID)
(void) cuserid(name);
#else
ma_strmake(name,"UNKNOWN_USER", USERNAME_LENGTH);
#endif
}
return;
}
|
O0
|
c
|
read_user_name:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x14290
cmpl $0x0, %eax
jne 0x317fb
movq -0x8(%rbp), %rdi
leaq 0x34117(%rip), %rsi # 0x65908
callq 0x143d0
jmp 0x31890
callq 0x14290
movl %eax, %edi
callq 0x144f0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x3181e
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x3187e
callq 0x14440
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x3187c
leaq 0x3939c(%rip), %rdi # 0x6abd0
callq 0x14550
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x3187a
leaq 0x39370(%rip), %rdi # 0x6abba
callq 0x14550
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x3187a
leaq 0x39362(%rip), %rdi # 0x6abc2
callq 0x14550
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x3187a
leaq 0x39352(%rip), %rax # 0x6abc8
movq %rax, -0x18(%rbp)
jmp 0x3187c
jmp 0x3187e
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x4c650
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
read_user_name:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
call _geteuid
cmp eax, 0
jnz short loc_317FB
mov rdi, [rbp+var_8]
lea rsi, aRoot; "root"
call _strcpy
jmp loc_31890
loc_317FB:
call _geteuid
mov edi, eax
call _getpwuid
mov [rbp+var_10], rax
cmp rax, 0
jz short loc_3181E
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_18], rax
jmp short loc_3187E
loc_3181E:
call _getlogin
mov [rbp+var_18], rax
cmp rax, 0
jnz short loc_3187C
lea rdi, aUnknownUser+8; "USER"
call _getenv
mov [rbp+var_18], rax
cmp rax, 0
jnz short loc_3187A
lea rdi, aLogname; "LOGNAME"
call _getenv
mov [rbp+var_18], rax
cmp rax, 0
jnz short loc_3187A
lea rdi, aLogin; "LOGIN"
call _getenv
mov [rbp+var_18], rax
cmp rax, 0
jnz short loc_3187A
lea rax, aUnknownUser; "UNKNOWN_USER"
mov [rbp+var_18], rax
loc_3187A:
jmp short $+2
loc_3187C:
jmp short $+2
loc_3187E:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_18]
mov edx, 200h
call ma_strmake
loc_31890:
add rsp, 20h
pop rbp
retn
|
long long read_user_name(long long a1)
{
unsigned int v2; // eax
const char *v3; // [rsp+8h] [rbp-18h]
_QWORD *v4; // [rsp+10h] [rbp-10h]
if ( !(unsigned int)geteuid() )
return strcpy(a1, "root");
v2 = geteuid();
v4 = (_QWORD *)getpwuid(v2);
if ( v4 )
return ma_strmake(a1, *v4, 512LL);
v3 = (const char *)getlogin();
if ( !v3 )
{
v3 = (const char *)getenv("USER");
if ( !v3 )
{
v3 = (const char *)getenv("LOGNAME");
if ( !v3 )
{
v3 = (const char *)getenv("LOGIN");
if ( !v3 )
v3 = "UNKNOWN_USER";
}
}
}
return ma_strmake(a1, v3, 512LL);
}
|
read_user_name:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
CALL 0x00114290
CMP EAX,0x0
JNZ 0x001317fb
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x165908]
CALL 0x001143d0
JMP 0x00131890
LAB_001317fb:
CALL 0x00114290
MOV EDI,EAX
CALL 0x001144f0
MOV qword ptr [RBP + -0x10],RAX
CMP RAX,0x0
JZ 0x0013181e
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0013187e
LAB_0013181e:
CALL 0x00114440
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JNZ 0x0013187c
LEA RDI,[0x16abd0]
CALL 0x00114550
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JNZ 0x0013187a
LEA RDI,[0x16abba]
CALL 0x00114550
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JNZ 0x0013187a
LEA RDI,[0x16abc2]
CALL 0x00114550
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JNZ 0x0013187a
LEA RAX,[0x16abc8]
MOV qword ptr [RBP + -0x18],RAX
LAB_0013187a:
JMP 0x0013187c
LAB_0013187c:
JMP 0x0013187e
LAB_0013187e:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,0x200
CALL 0x0014c650
LAB_00131890:
ADD RSP,0x20
POP RBP
RET
|
void read_user_name(char *param_1)
{
__uid_t _Var1;
passwd *ppVar2;
char *local_20;
_Var1 = geteuid();
if (_Var1 == 0) {
strcpy(param_1,"root");
}
else {
_Var1 = geteuid();
ppVar2 = getpwuid(_Var1);
if (ppVar2 == (passwd *)0x0) {
local_20 = getlogin();
if ((((local_20 == (char *)0x0) && (local_20 = getenv("USER"), local_20 == (char *)0x0)) &&
(local_20 = getenv("LOGNAME"), local_20 == (char *)0x0)) &&
(local_20 = getenv("LOGIN"), local_20 == (char *)0x0)) {
local_20 = "UNKNOWN_USER";
}
}
else {
local_20 = ppVar2->pw_name;
}
ma_strmake(param_1,local_20,0x200);
}
return;
}
|
|
11,796 |
read_user_name
|
eloqsql/libmariadb/libmariadb/mariadb_lib.c
|
void read_user_name(char *name)
{
if (geteuid() == 0)
strcpy(name,"root"); /* allow use of surun */
else
{
#ifdef HAVE_GETPWUID
struct passwd *skr;
const char *str;
if ((skr=getpwuid(geteuid())) != NULL)
{
str=skr->pw_name;
} else if ((str=getlogin()) == NULL)
{
if (!(str=getenv("USER")) && !(str=getenv("LOGNAME")) &&
!(str=getenv("LOGIN")))
str="UNKNOWN_USER";
}
ma_strmake(name,str,USERNAME_LENGTH);
#elif defined(HAVE_CUSERID)
(void) cuserid(name);
#else
ma_strmake(name,"UNKNOWN_USER", USERNAME_LENGTH);
#endif
}
return;
}
|
O3
|
c
|
read_user_name:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x142a0
testl %eax, %eax
je 0x277ff
callq 0x142a0
movl %eax, %edi
callq 0x14550
testq %rax, %rax
je 0x27810
movq (%rax), %rsi
jmp 0x2783f
movb $0x0, 0x4(%rbx)
movl $0x746f6f72, (%rbx) # imm = 0x746F6F72
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x14490
testq %rax, %rax
jne 0x2783c
leaq 0x23fbd(%rip), %rdi # 0x4b7de
callq 0x145b0
testq %rax, %rax
jne 0x2783c
leaq 0x23f96(%rip), %rdi # 0x4b7c8
callq 0x145b0
testq %rax, %rax
je 0x27852
movq %rax, %rsi
movl $0x200, %edx # imm = 0x200
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x367b7
leaq 0x23f77(%rip), %rdi # 0x4b7d0
callq 0x145b0
testq %rax, %rax
leaq 0x23f6e(%rip), %rsi # 0x4b7d6
cmovneq %rax, %rsi
jmp 0x2783f
|
read_user_name:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
call _geteuid
test eax, eax
jz short loc_277FF
call _geteuid
mov edi, eax
call _getpwuid
test rax, rax
jz short loc_27810
mov rsi, [rax]
jmp short loc_2783F
loc_277FF:
mov byte ptr [rbx+4], 0
mov dword ptr [rbx], 746F6F72h
add rsp, 8
pop rbx
pop rbp
retn
loc_27810:
call _getlogin
test rax, rax
jnz short loc_2783C
lea rdi, aUnknownUser+8; "USER"
call _getenv
test rax, rax
jnz short loc_2783C
lea rdi, aLogname; "LOGNAME"
call _getenv
test rax, rax
jz short loc_27852
loc_2783C:
mov rsi, rax
loc_2783F:
mov edx, 200h
mov rdi, rbx
add rsp, 8
pop rbx
pop rbp
jmp ma_strmake
loc_27852:
lea rdi, aLogin; "LOGIN"
call _getenv
test rax, rax
lea rsi, aUnknownUser; "UNKNOWN_USER"
cmovnz rsi, rax
jmp short loc_2783F
|
long long read_user_name(char *a1)
{
long long result; // rax
unsigned int v2; // eax
const char **v3; // rax
const char *v4; // rsi
long long v5; // rax
long long v6; // rax
result = geteuid(a1);
if ( (_DWORD)result )
{
v2 = geteuid(a1);
v3 = (const char **)getpwuid(v2);
if ( v3 )
{
v4 = *v3;
}
else
{
v5 = getlogin();
if ( v5 || (v5 = getenv("USER")) != 0 || (v5 = getenv("LOGNAME")) != 0 )
{
v4 = (const char *)v5;
}
else
{
v6 = getenv("LOGIN");
v4 = "UNKNOWN_USER";
if ( v6 )
v4 = (const char *)v6;
}
}
return ma_strmake(a1, v4, 512LL);
}
else
{
strcpy(a1, "root");
}
return result;
}
|
read_user_name:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
CALL 0x001142a0
TEST EAX,EAX
JZ 0x001277ff
CALL 0x001142a0
MOV EDI,EAX
CALL 0x00114550
TEST RAX,RAX
JZ 0x00127810
MOV RSI,qword ptr [RAX]
JMP 0x0012783f
LAB_001277ff:
MOV byte ptr [RBX + 0x4],0x0
MOV dword ptr [RBX],0x746f6f72
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_00127810:
CALL 0x00114490
TEST RAX,RAX
JNZ 0x0012783c
LEA RDI,[0x14b7de]
CALL 0x001145b0
TEST RAX,RAX
JNZ 0x0012783c
LEA RDI,[0x14b7c8]
CALL 0x001145b0
TEST RAX,RAX
JZ 0x00127852
LAB_0012783c:
MOV RSI,RAX
LAB_0012783f:
MOV EDX,0x200
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x001367b7
LAB_00127852:
LEA RDI,[0x14b7d0]
CALL 0x001145b0
TEST RAX,RAX
LEA RSI,[0x14b7d6]
CMOVNZ RSI,RAX
JMP 0x0012783f
|
void read_user_name(int4 *param_1)
{
__uid_t _Var1;
passwd *ppVar2;
char *pcVar3;
char *pcVar4;
_Var1 = geteuid();
if (_Var1 != 0) {
_Var1 = geteuid();
ppVar2 = getpwuid(_Var1);
if (ppVar2 == (passwd *)0x0) {
pcVar3 = getlogin();
if (((pcVar3 == (char *)0x0) && (pcVar3 = getenv("USER"), pcVar3 == (char *)0x0)) &&
(pcVar3 = getenv("LOGNAME"), pcVar3 == (char *)0x0)) {
pcVar4 = getenv("LOGIN");
pcVar3 = "UNKNOWN_USER";
if (pcVar4 != (char *)0x0) {
pcVar3 = pcVar4;
}
}
}
else {
pcVar3 = ppVar2->pw_name;
}
ma_strmake(param_1,pcVar3,0x200);
return;
}
*(int1 *)(param_1 + 1) = 0;
*param_1 = 0x746f6f72;
return;
}
|
|
11,797 |
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::next_byte_in_range(std::initializer_list<int>)
|
monkey531[P]llama/common/json.hpp
|
bool next_byte_in_range(std::initializer_list<char_int_type> ranges)
{
JSON_ASSERT(ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6);
add(current);
for (auto range = ranges.begin(); range != ranges.end(); ++range)
{
get();
if (JSON_HEDLEY_LIKELY(*range <= current && current <= *(++range))) // NOLINT(bugprone-inc-dec-in-conditions)
{
add(current);
}
else
{
error_message = "invalid string: ill-formed UTF-8 byte";
return false;
}
}
return true;
}
|
O0
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::next_byte_in_range(std::initializer_list<int>):
subq $0x48, %rsp
movq %rsi, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x7d380
cmpq $0x2, %rax
je 0xc757e
leaq 0x30(%rsp), %rdi
callq 0x7d380
cmpq $0x4, %rax
je 0xc757e
leaq 0x30(%rsp), %rdi
callq 0x7d380
cmpq $0x6, %rax
je 0xc757e
leaq 0x165fa3(%rip), %rdi # 0x22d507
movl $0x1da8, %esi # imm = 0x1DA8
leaq 0x15f765(%rip), %rdx # 0x226cd5
leaq 0x166cfd(%rip), %rcx # 0x22e274
movb $0x0, %al
callq 0x5ef80
movq 0x18(%rsp), %rdi
movl 0x14(%rdi), %esi
callq 0xc7320
leaq 0x30(%rsp), %rdi
callq 0x7ce90
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x7cea0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
je 0xc764c
movq 0x18(%rsp), %rdi
callq 0xc6500
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rax
movl (%rax), %ecx
xorl %eax, %eax
cmpl 0x14(%rdx), %ecx
movb %al, 0xf(%rsp)
jg 0xc7603
movq 0x18(%rsp), %rax
movl 0x14(%rax), %eax
movq 0x20(%rsp), %rcx
movq %rcx, %rdx
addq $0x4, %rdx
movq %rdx, 0x20(%rsp)
cmpl 0x4(%rcx), %eax
setle %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xc7611
jmp 0xc7620
movq 0x18(%rsp), %rdi
movl 0x14(%rdi), %esi
callq 0xc7320
jmp 0xc7637
movq 0x18(%rsp), %rax
leaq 0x166be8(%rip), %rcx # 0x22e214
movq %rcx, 0x70(%rax)
movb $0x0, 0x47(%rsp)
jmp 0xc7651
jmp 0xc7639
movq 0x20(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x20(%rsp)
jmp 0xc759a
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopl (%rax)
|
_ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE18next_byte_in_rangeESt16initializer_listIiE:
sub rsp, 48h
mov [rsp+48h+var_18], rsi
mov [rsp+48h+var_10], rdx
mov [rsp+48h+var_20], rdi
mov rax, [rsp+48h+var_20]
mov [rsp+48h+var_30], rax
lea rdi, [rsp+48h+var_18]
call _ZNKSt16initializer_listIiE4sizeEv; std::initializer_list<int>::size(void)
cmp rax, 2
jz short loc_C757E
lea rdi, [rsp+48h+var_18]
call _ZNKSt16initializer_listIiE4sizeEv; std::initializer_list<int>::size(void)
cmp rax, 4
jz short loc_C757E
lea rdi, [rsp+48h+var_18]
call _ZNKSt16initializer_listIiE4sizeEv; std::initializer_list<int>::size(void)
cmp rax, 6
jz short loc_C757E
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
mov esi, 1DA8h
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aRangesSize2Ran; "ranges.size() == 2 || ranges.size() == "...
mov al, 0
call _ggml_abort
loc_C757E:
mov rdi, [rsp+48h+var_30]
mov esi, [rdi+14h]
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3addEi; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::add(int)
lea rdi, [rsp+48h+var_18]
call _ZNKSt16initializer_listIiE5beginEv; std::initializer_list<int>::begin(void)
mov [rsp+48h+var_28], rax
loc_C759A:
mov rax, [rsp+48h+var_28]
mov [rsp+48h+var_38], rax
lea rdi, [rsp+48h+var_18]
call _ZNKSt16initializer_listIiE3endEv; std::initializer_list<int>::end(void)
mov rcx, rax
mov rax, [rsp+48h+var_38]
cmp rax, rcx
jz loc_C764C
mov rdi, [rsp+48h+var_30]
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(void)
mov rdx, [rsp+48h+var_30]
mov rax, [rsp+48h+var_28]
mov ecx, [rax]
xor eax, eax
cmp ecx, [rdx+14h]
mov [rsp+48h+var_39], al
jg short loc_C7603
mov rax, [rsp+48h+var_30]
mov eax, [rax+14h]
mov rcx, [rsp+48h+var_28]
mov rdx, rcx
add rdx, 4
mov [rsp+48h+var_28], rdx
cmp eax, [rcx+4]
setle al
mov [rsp+48h+var_39], al
loc_C7603:
mov al, [rsp+48h+var_39]
xor al, 0FFh
xor al, 0FFh
test al, 1
jnz short loc_C7611
jmp short loc_C7620
loc_C7611:
mov rdi, [rsp+48h+var_30]
mov esi, [rdi+14h]
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3addEi; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::add(int)
jmp short loc_C7637
loc_C7620:
mov rax, [rsp+48h+var_30]
lea rcx, aInvalidStringI; "invalid string: ill-formed UTF-8 byte"
mov [rax+70h], rcx
mov [rsp+48h+var_1], 0
jmp short loc_C7651
loc_C7637:
jmp short $+2
loc_C7639:
mov rax, [rsp+48h+var_28]
add rax, 4
mov [rsp+48h+var_28], rax
jmp loc_C759A
loc_C764C:
mov [rsp+48h+var_1], 1
loc_C7651:
mov al, [rsp+48h+var_1]
and al, 1
add rsp, 48h
retn
|
char nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::next_byte_in_range(
long long a1,
long long a2,
long long a3)
{
_DWORD *v3; // rcx
bool v5; // [rsp+Fh] [rbp-39h]
_DWORD *i; // [rsp+20h] [rbp-28h]
_QWORD v7[2]; // [rsp+30h] [rbp-18h] BYREF
v7[0] = a2;
v7[1] = a3;
if ( std::initializer_list<int>::size((long long)v7) != 2
&& std::initializer_list<int>::size((long long)v7) != 4
&& std::initializer_list<int>::size((long long)v7) != 6 )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
7592LL,
"GGML_ASSERT(%s) failed",
"ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6");
}
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::add(
a1,
*(_DWORD *)(a1 + 20));
for ( i = (_DWORD *)std::initializer_list<int>::begin((long long)v7);
i != (_DWORD *)std::initializer_list<int>::end((long long)v7);
++i )
{
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(a1);
v5 = 0;
if ( *i <= *(_DWORD *)(a1 + 20) )
{
v3 = i++;
v5 = *(_DWORD *)(a1 + 20) <= v3[1];
}
if ( !v5 )
{
*(_QWORD *)(a1 + 112) = "invalid string: ill-formed UTF-8 byte";
return 0;
}
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::add(
a1,
*(_DWORD *)(a1 + 20));
}
return 1;
}
|
next_byte_in_range:
SUB RSP,0x48
MOV qword ptr [RSP + 0x30],RSI
MOV qword ptr [RSP + 0x38],RDX
MOV qword ptr [RSP + 0x28],RDI
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x18],RAX
LEA RDI,[RSP + 0x30]
CALL 0x0017d380
CMP RAX,0x2
JZ 0x001c757e
LEA RDI,[RSP + 0x30]
CALL 0x0017d380
CMP RAX,0x4
JZ 0x001c757e
LEA RDI,[RSP + 0x30]
CALL 0x0017d380
CMP RAX,0x6
JZ 0x001c757e
LEA RDI,[0x32d507]
MOV ESI,0x1da8
LEA RDX,[0x326cd5]
LEA RCX,[0x32e274]
MOV AL,0x0
CALL 0x0015ef80
LAB_001c757e:
MOV RDI,qword ptr [RSP + 0x18]
MOV ESI,dword ptr [RDI + 0x14]
CALL 0x001c7320
LEA RDI,[RSP + 0x30]
CALL 0x0017ce90
MOV qword ptr [RSP + 0x20],RAX
LAB_001c759a:
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x10],RAX
LEA RDI,[RSP + 0x30]
CALL 0x0017cea0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x10]
CMP RAX,RCX
JZ 0x001c764c
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x001c6500
MOV RDX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RSP + 0x20]
MOV ECX,dword ptr [RAX]
XOR EAX,EAX
CMP ECX,dword ptr [RDX + 0x14]
MOV byte ptr [RSP + 0xf],AL
JG 0x001c7603
MOV RAX,qword ptr [RSP + 0x18]
MOV EAX,dword ptr [RAX + 0x14]
MOV RCX,qword ptr [RSP + 0x20]
MOV RDX,RCX
ADD RDX,0x4
MOV qword ptr [RSP + 0x20],RDX
CMP EAX,dword ptr [RCX + 0x4]
SETLE AL
MOV byte ptr [RSP + 0xf],AL
LAB_001c7603:
MOV AL,byte ptr [RSP + 0xf]
XOR AL,0xff
XOR AL,0xff
TEST AL,0x1
JNZ 0x001c7611
JMP 0x001c7620
LAB_001c7611:
MOV RDI,qword ptr [RSP + 0x18]
MOV ESI,dword ptr [RDI + 0x14]
CALL 0x001c7320
JMP 0x001c7637
LAB_001c7620:
MOV RAX,qword ptr [RSP + 0x18]
LEA RCX,[0x32e214]
MOV qword ptr [RAX + 0x70],RCX
MOV byte ptr [RSP + 0x47],0x0
JMP 0x001c7651
LAB_001c7637:
JMP 0x001c7639
LAB_001c7639:
MOV RAX,qword ptr [RSP + 0x20]
ADD RAX,0x4
MOV qword ptr [RSP + 0x20],RAX
JMP 0x001c759a
LAB_001c764c:
MOV byte ptr [RSP + 0x47],0x1
LAB_001c7651:
MOV AL,byte ptr [RSP + 0x47]
AND AL,0x1
ADD RSP,0x48
RET
|
/* nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>,
nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > > >::next_byte_in_range(std::initializer_list<int>) */
int1
nlohmann::json_abi_v3_11_3::detail::
lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
::next_byte_in_range
(lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*param_1,int8 param_2,int8 param_3)
{
bool bVar1;
long lVar2;
int *piVar3;
int *local_28;
int8 local_18;
int8 local_10;
local_18 = param_2;
local_10 = param_3;
lVar2 = std::initializer_list<int>::size((initializer_list<int> *)&local_18);
if (((lVar2 != 2) &&
(lVar2 = std::initializer_list<int>::size((initializer_list<int> *)&local_18), lVar2 != 4)) &&
(lVar2 = std::initializer_list<int>::size((initializer_list<int> *)&local_18), lVar2 != 6)) {
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",0x1da8,
"GGML_ASSERT(%s) failed",
"ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6");
}
add((int)param_1);
local_28 = (int *)std::initializer_list<int>::begin((initializer_list<int> *)&local_18);
while( true ) {
piVar3 = (int *)std::initializer_list<int>::end((initializer_list<int> *)&local_18);
if (local_28 == piVar3) {
return 1;
}
get(param_1);
bVar1 = false;
if (*local_28 <= *(int *)(param_1 + 0x14)) {
bVar1 = *(int *)(param_1 + 0x14) <= local_28[1];
local_28 = local_28 + 1;
}
if (!bVar1) break;
add((int)param_1);
local_28 = local_28 + 1;
}
*(char **)(param_1 + 0x70) = "invalid string: ill-formed UTF-8 byte";
return 0;
}
|
|
11,798 |
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::next_byte_in_range(std::initializer_list<int>)
|
monkey531[P]llama/common/json.hpp
|
bool next_byte_in_range(std::initializer_list<char_int_type> ranges)
{
JSON_ASSERT(ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6);
add(current);
for (auto range = ranges.begin(); range != ranges.end(); ++range)
{
get();
if (JSON_HEDLEY_LIKELY(*range <= current && current <= *(++range))) // NOLINT(bugprone-inc-dec-in-conditions)
{
add(current);
}
else
{
error_message = "invalid string: ill-formed UTF-8 byte";
return false;
}
}
return true;
}
|
O2
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::next_byte_in_range(std::initializer_list<int>):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x6, %rdx
ja 0x4abbe
movq %rdx, %rbx
pushq $0x54
popq %rax
btq %rdx, %rax
jae 0x4abbe
movq %rsi, %r15
movq %rdi, %r14
movsbl 0x14(%rdi), %esi
leaq 0x50(%rdi), %r12
movq %r12, %rdi
callq 0x24790
shlq $0x2, %rbx
testq %rbx, %rbx
je 0x4abac
movq %r14, %rdi
callq 0x4a7f8
movl 0x14(%r14), %eax
cmpl %eax, (%r15)
jg 0x4aba1
cmpl 0x4(%r15), %eax
jg 0x4aba1
movsbl %al, %esi
movq %r12, %rdi
callq 0x24790
addq $0x8, %r15
addq $-0x8, %rbx
jmp 0x4ab70
leaq 0x720b0(%rip), %rax # 0xbcc58
movq %rax, 0x70(%r14)
testq %rbx, %rbx
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x71392(%rip), %rdi # 0xbbf57
leaq 0x6af24(%rip), %rdx # 0xb5af0
leaq 0x720e5(%rip), %rcx # 0xbccb8
movl $0x1da8, %esi # imm = 0x1DA8
xorl %eax, %eax
callq 0x24f20
nop
|
_ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE18next_byte_in_rangeESt16initializer_listIiE:
push r15
push r14
push r12
push rbx
push rax
cmp rdx, 6
ja short loc_4ABBE
mov rbx, rdx
push 54h ; 'T'
pop rax
bt rax, rdx
jnb short loc_4ABBE
mov r15, rsi
mov r14, rdi
movsx esi, byte ptr [rdi+14h]
lea r12, [rdi+50h]
mov rdi, r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
shl rbx, 2
loc_4AB70:
test rbx, rbx
jz short loc_4ABAC
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(void)
mov eax, [r14+14h]
cmp [r15], eax
jg short loc_4ABA1
cmp eax, [r15+4]
jg short loc_4ABA1
movsx esi, al
mov rdi, r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
add r15, 8
add rbx, 0FFFFFFFFFFFFFFF8h
jmp short loc_4AB70
loc_4ABA1:
lea rax, aInvalidStringI; "invalid string: ill-formed UTF-8 byte"
mov [r14+70h], rax
loc_4ABAC:
test rbx, rbx
setz al
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
loc_4ABBE:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aRangesSize2Ran; "ranges.size() == 2 || ranges.size() == "...
mov esi, 1DA8h
xor eax, eax
call _ggml_abort
nop
|
char nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::next_byte_in_range(
__m128i *a1,
__int32 *a2,
unsigned long long a3)
{
long long v4; // rax
long long i; // rbx
__int32 v7; // eax
if ( a3 <= 6 && (v4 = 84LL, _bittest64(&v4, a3)) )
{
std::string::push_back(&a1[5], (unsigned int)a1[1].m128i_i8[4]);
for ( i = 4 * a3; i; i -= 8LL )
{
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(a1);
v7 = a1[1].m128i_i32[1];
if ( *a2 > v7 || v7 > a2[1] )
{
a1[7].m128i_i64[0] = (long long)"invalid string: ill-formed UTF-8 byte";
return i == 0;
}
std::string::push_back(&a1[5], (unsigned int)(char)v7);
a2 += 2;
}
return i == 0;
}
else
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
7592LL,
"GGML_ASSERT(%s) failed",
"ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6");
return std::_Vector_base<char>::~_Vector_base("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp");
}
}
|
next_byte_in_range:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
CMP RDX,0x6
JA 0x0014abbe
MOV RBX,RDX
PUSH 0x54
POP RAX
BT RAX,RDX
JNC 0x0014abbe
MOV R15,RSI
MOV R14,RDI
MOVSX ESI,byte ptr [RDI + 0x14]
LEA R12,[RDI + 0x50]
MOV RDI,R12
CALL 0x00124790
SHL RBX,0x2
LAB_0014ab70:
TEST RBX,RBX
JZ 0x0014abac
MOV RDI,R14
CALL 0x0014a7f8
MOV EAX,dword ptr [R14 + 0x14]
CMP dword ptr [R15],EAX
JG 0x0014aba1
CMP EAX,dword ptr [R15 + 0x4]
JG 0x0014aba1
MOVSX ESI,AL
MOV RDI,R12
CALL 0x00124790
ADD R15,0x8
ADD RBX,-0x8
JMP 0x0014ab70
LAB_0014aba1:
LEA RAX,[0x1bcc58]
MOV qword ptr [R14 + 0x70],RAX
LAB_0014abac:
TEST RBX,RBX
SETZ AL
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
LAB_0014abbe:
LEA RDI,[0x1bbf57]
LEA RDX,[0x1b5af0]
LEA RCX,[0x1bccb8]
MOV ESI,0x1da8
XOR EAX,EAX
CALL 0x00124f20
|
/* nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>,
nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > > >::next_byte_in_range(std::initializer_list<int>) */
bool nlohmann::json_abi_v3_11_3::detail::
lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
::next_byte_in_range
(lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*param_1,int *param_2,ulong param_3)
{
long lVar1;
char cVar2;
if ((6 < param_3) || ((0x54UL >> (param_3 & 0x3f) & 1) == 0)) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",0x1da8,
"GGML_ASSERT(%s) failed",
"ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6");
}
cVar2 = (char)param_1 + 'P';
std::__cxx11::string::push_back(cVar2);
lVar1 = param_3 << 2;
do {
if (lVar1 == 0) {
LAB_0014abac:
return lVar1 == 0;
}
get(param_1);
if ((*(int *)(param_1 + 0x14) < *param_2) || (param_2[1] < *(int *)(param_1 + 0x14))) {
*(char **)(param_1 + 0x70) = "invalid string: ill-formed UTF-8 byte";
goto LAB_0014abac;
}
std::__cxx11::string::push_back(cVar2);
param_2 = param_2 + 2;
lVar1 = lVar1 + -8;
} while( true );
}
|
|
11,799 |
google::protobuf::ServiceDescriptorProto* google::protobuf::Arena::CreateMaybeMessage<google::protobuf::ServiceDescriptorProto>(google::protobuf::Arena*)
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.pb.cc
|
PROTOBUF_NOINLINE ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto*
Arena::CreateMaybeMessage< ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto >(Arena* arena) {
return Arena::CreateMessageInternal< ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto >(arena);
}
|
O0
|
cpp
|
google::protobuf::ServiceDescriptorProto* google::protobuf::Arena::CreateMaybeMessage<google::protobuf::ServiceDescriptorProto>(google::protobuf::Arena*):
subq $0xb8, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0xd1c0f
movl $0x40, %edi
callq 0x13450
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
xorl %edx, %edx
movl %edx, %esi
callq 0xb96a0
jmp 0xd1c00
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x13400
movq 0x38(%rsp), %rdi
callq 0x13750
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
jmp 0xd1dc3
movq 0x20(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movq %rax, 0x98(%rsp)
movq $0x40, 0x90(%rsp)
movq $0x8, 0x88(%rsp)
movq $0x0, 0x80(%rsp)
leaq 0x1a752b(%rip), %rax # 0x279180
movq %rax, 0x78(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x80(%rsp)
jne 0xd1c9e
movq 0x8(%rsp), %rdi
movq 0x90(%rsp), %rsi
movq 0x88(%rsp), %rdx
movq 0x78(%rsp), %rcx
callq 0xdf5f0
movq %rax, 0xa0(%rsp)
jmp 0xd1da3
cmpq $0x8, 0x88(%rsp)
ja 0xd1d02
movq 0x90(%rsp), %rdi
callq 0xdf6a0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x78(%rsp), %rdx
callq 0x1816c0
movq %rax, 0x68(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x68(%rsp), %rcx
movq 0x70(%rsp), %rax
movq %rcx, (%rax)
movq 0x80(%rsp), %rcx
movq 0x70(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x68(%rsp), %rax
movq %rax, 0xa0(%rsp)
jmp 0xd1da3
movq 0x8(%rsp), %rdi
movq 0x90(%rsp), %rsi
addq 0x88(%rsp), %rsi
subq $0x8, %rsi
movq 0x78(%rsp), %rdx
callq 0x1816c0
movq %rax, 0x58(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x58(%rsp), %rcx
movq 0x88(%rsp), %rax
movq %rcx, 0xb0(%rsp)
movq %rax, 0xa8(%rsp)
movq 0xb0(%rsp), %rax
addq 0xa8(%rsp), %rax
subq $0x1, %rax
movq 0xa8(%rsp), %rcx
xorq $-0x1, %rcx
addq $0x1, %rcx
andq %rcx, %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rcx
movq 0x60(%rsp), %rax
movq %rcx, (%rax)
movq 0x80(%rsp), %rcx
movq 0x60(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x50(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq (%rsp), %rax
movq 0xa0(%rsp), %rdi
movq %rax, 0x40(%rsp)
leaq 0x40(%rsp), %rsi
callq 0xe3cf0
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
addq $0xb8, %rsp
retq
|
_ZN6google8protobuf5Arena18CreateMaybeMessageINS0_22ServiceDescriptorProtoEJEEEPT_PS1_DpOT0_:
sub rsp, 0B8h
mov [rsp+0B8h+var_A0], rdi
mov rax, [rsp+0B8h+var_A0]
mov [rsp+0B8h+var_98], rax
cmp [rsp+0B8h+var_98], 0
jnz short loc_D1C0F
mov edi, 40h ; '@'; unsigned __int64
call __Znwm; operator new(ulong)
mov rdi, rax; this
mov rax, rdi
mov [rsp+0B8h+var_A8], rax
xor edx, edx; bool
mov esi, edx; google::protobuf::Arena *
call _ZN6google8protobuf22ServiceDescriptorProtoC2EPNS0_5ArenaEb; google::protobuf::ServiceDescriptorProto::ServiceDescriptorProto(google::protobuf::Arena *,bool)
jmp short loc_D1C00
mov rdi, [rsp+arg_8]; void *
mov rcx, rax
mov eax, edx
mov [rsp+arg_30], rcx
mov [rsp+arg_2C], eax
call __ZdlPv; operator delete(void *)
mov rdi, [rsp+arg_30]
call __Unwind_Resume
loc_D1C00:
mov rax, [rsp+0B8h+var_A8]
mov [rsp+0B8h+var_90], rax
jmp loc_D1DC3
loc_D1C0F:
mov rax, [rsp+0B8h+var_98]
mov [rsp+0B8h+var_70], rax
mov rax, [rsp+0B8h+var_70]
mov [rsp+0B8h+var_B8], rax
mov [rsp+0B8h+var_20], rax
mov [rsp+0B8h+var_28], 40h ; '@'
mov [rsp+0B8h+var_30], 8
mov [rsp+0B8h+var_38], 0
lea rax, _ZTIN6google8protobuf22ServiceDescriptorProtoE; `typeinfo for'google::protobuf::ServiceDescriptorProto
mov [rsp+0B8h+var_40], rax
mov rax, [rsp+0B8h+var_20]
mov [rsp+0B8h+var_B0], rax
cmp [rsp+0B8h+var_38], 0
jnz short loc_D1C9E
mov rdi, [rsp+0B8h+var_B0]; this
mov rsi, [rsp+0B8h+var_28]; unsigned __int64
mov rdx, [rsp+0B8h+var_30]; unsigned __int64
mov rcx, [rsp+0B8h+var_40]; type_info *
call _ZN6google8protobuf5Arena23AllocateAlignedWithHookEmmPKSt9type_info; google::protobuf::Arena::AllocateAlignedWithHook(ulong,ulong,std::type_info const*)
mov [rsp+0B8h+var_18], rax
jmp loc_D1DA3
loc_D1C9E:
cmp [rsp+0B8h+var_30], 8
ja short loc_D1D02
mov rdi, [rsp+0B8h+var_28]; this
call _ZN6google8protobuf8internal10AlignUpTo8Em; google::protobuf::internal::AlignUpTo8(ulong)
mov rdi, [rsp+0B8h+var_B0]; this
mov rsi, rax; unsigned __int64
mov rdx, [rsp+0B8h+var_40]; type_info *
call _ZN6google8protobuf5Arena26AllocateAlignedWithCleanupEmPKSt9type_info; google::protobuf::Arena::AllocateAlignedWithCleanup(ulong,std::type_info const*)
mov [rsp+0B8h+var_50], rax
mov [rsp+0B8h+var_48], rdx
mov rcx, [rsp+0B8h+var_50]
mov rax, [rsp+0B8h+var_48]
mov [rax], rcx
mov rcx, [rsp+0B8h+var_38]
mov rax, [rsp+0B8h+var_48]
mov [rax+8], rcx
mov rax, [rsp+0B8h+var_50]
mov [rsp+0B8h+var_18], rax
jmp loc_D1DA3
loc_D1D02:
mov rdi, [rsp+0B8h+var_B0]; this
mov rsi, [rsp+0B8h+var_28]
add rsi, [rsp+0B8h+var_30]
sub rsi, 8; unsigned __int64
mov rdx, [rsp+0B8h+var_40]; type_info *
call _ZN6google8protobuf5Arena26AllocateAlignedWithCleanupEmPKSt9type_info; google::protobuf::Arena::AllocateAlignedWithCleanup(ulong,std::type_info const*)
mov [rsp+0B8h+var_60], rax
mov [rsp+0B8h+var_58], rdx
mov rcx, [rsp+0B8h+var_60]
mov rax, [rsp+0B8h+var_30]
mov [rsp+0B8h+var_8], rcx
mov [rsp+0B8h+var_10], rax
mov rax, [rsp+0B8h+var_8]
add rax, [rsp+0B8h+var_10]
sub rax, 1
mov rcx, [rsp+0B8h+var_10]
xor rcx, 0FFFFFFFFFFFFFFFFh
add rcx, 1
and rax, rcx
mov [rsp+0B8h+var_68], rax
mov rcx, [rsp+0B8h+var_68]
mov rax, [rsp+0B8h+var_58]
mov [rax], rcx
mov rcx, [rsp+0B8h+var_38]
mov rax, [rsp+0B8h+var_58]
mov [rax+8], rcx
mov rax, [rsp+0B8h+var_68]
mov [rsp+0B8h+var_18], rax
loc_D1DA3:
mov rax, [rsp+0B8h+var_B8]
mov rdi, [rsp+0B8h+var_18]
mov [rsp+0B8h+var_78], rax
lea rsi, [rsp+0B8h+var_78]
call _ZN6google8protobuf5Arena14InternalHelperINS0_22ServiceDescriptorProtoEE9ConstructIJPS1_EEEPS3_PvDpOT_; google::protobuf::Arena::InternalHelper<google::protobuf::ServiceDescriptorProto>::Construct<google::protobuf::Arena*>(void *,google::protobuf::Arena* &&)
mov [rsp+0B8h+var_90], rax
loc_D1DC3:
mov rax, [rsp+0B8h+var_90]
add rsp, 0B8h
retn
|
google::protobuf::ServiceDescriptorProto * google::protobuf::Arena::CreateMaybeMessage<google::protobuf::ServiceDescriptorProto>(
google::protobuf::Arena *a1)
{
google::protobuf::ServiceDescriptorProto *v2; // [rsp+10h] [rbp-A8h]
_QWORD v4[12]; // [rsp+40h] [rbp-78h] BYREF
long long AlignedWithHook; // [rsp+A0h] [rbp-18h]
if ( a1 )
{
v4[1] = a1;
v4[11] = a1;
v4[10] = 64LL;
v4[9] = 8LL;
v4[8] = 0LL;
v4[7] = &`typeinfo for'google::protobuf::ServiceDescriptorProto;
AlignedWithHook = google::protobuf::Arena::AllocateAlignedWithHook(
a1,
0x40uLL,
8uLL,
(const type_info *)&`typeinfo for'google::protobuf::ServiceDescriptorProto);
v4[0] = a1;
return (google::protobuf::ServiceDescriptorProto *)google::protobuf::Arena::InternalHelper<google::protobuf::ServiceDescriptorProto>::Construct<google::protobuf::Arena*>(
AlignedWithHook,
v4);
}
else
{
v2 = (google::protobuf::ServiceDescriptorProto *)operator new(0x40uLL);
google::protobuf::ServiceDescriptorProto::ServiceDescriptorProto(v2, 0LL, 0);
return v2;
}
}
|
CreateMaybeMessage<google::protobuf::ServiceDescriptorProto>:
SUB RSP,0xb8
MOV qword ptr [RSP + 0x18],RDI
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x20],RAX
CMP qword ptr [RSP + 0x20],0x0
JNZ 0x001d1c0f
MOV EDI,0x40
CALL 0x00113450
MOV RDI,RAX
MOV RAX,RDI
MOV qword ptr [RSP + 0x10],RAX
LAB_001d1bd3:
XOR EDX,EDX
MOV ESI,EDX
CALL 0x001b96a0
LAB_001d1bdc:
JMP 0x001d1c00
LAB_001d1c00:
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x28],RAX
JMP 0x001d1dc3
LAB_001d1c0f:
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x48],RAX
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x98],RAX
MOV qword ptr [RSP + 0x90],0x40
MOV qword ptr [RSP + 0x88],0x8
MOV qword ptr [RSP + 0x80],0x0
LEA RAX,[0x379180]
MOV qword ptr [RSP + 0x78],RAX
MOV RAX,qword ptr [RSP + 0x98]
MOV qword ptr [RSP + 0x8],RAX
CMP qword ptr [RSP + 0x80],0x0
JNZ 0x001d1c9e
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x90]
MOV RDX,qword ptr [RSP + 0x88]
MOV RCX,qword ptr [RSP + 0x78]
CALL 0x001df5f0
MOV qword ptr [RSP + 0xa0],RAX
JMP 0x001d1da3
LAB_001d1c9e:
CMP qword ptr [RSP + 0x88],0x8
JA 0x001d1d02
MOV RDI,qword ptr [RSP + 0x90]
CALL 0x001df6a0
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,RAX
MOV RDX,qword ptr [RSP + 0x78]
CALL 0x002816c0
MOV qword ptr [RSP + 0x68],RAX
MOV qword ptr [RSP + 0x70],RDX
MOV RCX,qword ptr [RSP + 0x68]
MOV RAX,qword ptr [RSP + 0x70]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RSP + 0x80]
MOV RAX,qword ptr [RSP + 0x70]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RSP + 0xa0],RAX
JMP 0x001d1da3
LAB_001d1d02:
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x90]
ADD RSI,qword ptr [RSP + 0x88]
SUB RSI,0x8
MOV RDX,qword ptr [RSP + 0x78]
CALL 0x002816c0
MOV qword ptr [RSP + 0x58],RAX
MOV qword ptr [RSP + 0x60],RDX
MOV RCX,qword ptr [RSP + 0x58]
MOV RAX,qword ptr [RSP + 0x88]
MOV qword ptr [RSP + 0xb0],RCX
MOV qword ptr [RSP + 0xa8],RAX
MOV RAX,qword ptr [RSP + 0xb0]
ADD RAX,qword ptr [RSP + 0xa8]
SUB RAX,0x1
MOV RCX,qword ptr [RSP + 0xa8]
XOR RCX,-0x1
ADD RCX,0x1
AND RAX,RCX
MOV qword ptr [RSP + 0x50],RAX
MOV RCX,qword ptr [RSP + 0x50]
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RSP + 0x80]
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0xa0],RAX
LAB_001d1da3:
MOV RAX,qword ptr [RSP]
MOV RDI,qword ptr [RSP + 0xa0]
MOV qword ptr [RSP + 0x40],RAX
LEA RSI,[RSP + 0x40]
CALL 0x001e3cf0
MOV qword ptr [RSP + 0x28],RAX
LAB_001d1dc3:
MOV RAX,qword ptr [RSP + 0x28]
ADD RSP,0xb8
RET
|
/* WARNING: Removing unreachable block (ram,0x001d1c9e) */
/* WARNING: Removing unreachable block (ram,0x001d1ca9) */
/* WARNING: Removing unreachable block (ram,0x001d1d02) */
/* google::protobuf::ServiceDescriptorProto*
google::protobuf::Arena::CreateMaybeMessage<google::protobuf::ServiceDescriptorProto>(google::protobuf::Arena*)
*/
ServiceDescriptorProto *
google::protobuf::Arena::CreateMaybeMessage<google::protobuf::ServiceDescriptorProto>
(Arena *param_1)
{
ServiceDescriptorProto *local_90;
Arena *local_78;
Arena *local_70;
pointer_____offset_0x10___ *local_40;
int8 local_38;
int8 local_30;
int8 local_28;
Arena *local_20;
void *local_18;
if (param_1 == (Arena *)0x0) {
local_90 = (ServiceDescriptorProto *)operator_new(0x40);
/* try { // try from 001d1bd3 to 001d1bdb has its CatchHandler @ 001d1bde */
ServiceDescriptorProto::ServiceDescriptorProto(local_90,(Arena *)0x0,false);
}
else {
local_28 = 0x40;
local_30 = 8;
local_38 = 0;
local_40 = &ServiceDescriptorProto::typeinfo;
local_70 = param_1;
local_20 = param_1;
local_18 = (void *)AllocateAlignedWithHook
(param_1,0x40,8,(type_info *)&ServiceDescriptorProto::typeinfo);
local_78 = param_1;
local_90 = InternalHelper<google::protobuf::ServiceDescriptorProto>::
Construct<google::protobuf::Arena*>(local_18,&local_78);
}
return local_90;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.